[Jifty-commit] r2484 - in jifty/branches/template-declare: .
lib/Jifty lib/Jifty/Manual lib/Jifty/Module lib/Jifty/Script
lib/Jifty/View/Static share/web/static/js
share/web/static/js/yui share/web/templates/__jifty/admin t
t/TestApp/lib/TestApp/Action t/TestApp/share/web/templates
jifty-commit at lists.jifty.org
jifty-commit at lists.jifty.org
Wed Jan 10 21:43:44 EST 2007
Author: trs
Date: Wed Jan 10 21:43:42 2007
New Revision: 2484
Added:
jifty/branches/template-declare/share/web/static/js/yui/container.js
jifty/branches/template-declare/t/TestApp/lib/TestApp/Action/DoSomethingElse.pm
jifty/branches/template-declare/t/TestApp/share/web/templates/dosomethingelse
Modified:
jifty/branches/template-declare/ (props changed)
jifty/branches/template-declare/Makefile.PL
jifty/branches/template-declare/lib/Jifty/Action.pm
jifty/branches/template-declare/lib/Jifty/Manual/Actions.pod
jifty/branches/template-declare/lib/Jifty/Manual/Cookbook.pod
jifty/branches/template-declare/lib/Jifty/Module/Pluggable.pm
jifty/branches/template-declare/lib/Jifty/Param/Schema.pm
jifty/branches/template-declare/lib/Jifty/Script/App.pm
jifty/branches/template-declare/lib/Jifty/View/Static/Handler.pm
jifty/branches/template-declare/lib/Jifty/Web.pm
jifty/branches/template-declare/share/web/static/js/jifty_utils.js
jifty/branches/template-declare/share/web/static/js/yui/dom.js
jifty/branches/template-declare/share/web/static/js/yui/event.js
jifty/branches/template-declare/share/web/static/js/yui/yahoo.js
jifty/branches/template-declare/share/web/templates/__jifty/admin/index.html
jifty/branches/template-declare/t/12-param-schema.t
Log:
Merge down from trunk
r18717 at zot (orig r2468): nelhage | 2007-01-05 16:10:43 -0500
Adding a note about canonicalizers being idempotent
r18718 at zot (orig r2469): alexmv | 2007-01-05 16:30:39 -0500
r15750 at zoq-fot-pik: chmrr | 2007-01-05 16:28:55 -0500
* Typo fix
r18719 at zot (orig r2470): alexmv | 2007-01-05 16:30:42 -0500
r15751 at zoq-fot-pik: chmrr | 2007-01-05 16:29:10 -0500
* Line wrapping POD
r18720 at zot (orig r2471): alexmv | 2007-01-05 16:30:46 -0500
r15752 at zoq-fot-pik: chmrr | 2007-01-05 16:29:51 -0500
* Close <li>s we open
r18721 at zot (orig r2472): alexmv | 2007-01-05 16:30:51 -0500
r15753 at zoq-fot-pik: chmrr | 2007-01-05 16:30:27 -0500
* Be explicit about the paths we're creating
r18759 at zot (orig r2477): yves | 2007-01-08 05:16:11 -0500
ldap autocomplete example
r18760 at zot (orig r2478): clkao | 2007-01-08 06:18:23 -0500
Actually implement if-modified-since for static view handler.
r18764 at zot (orig r2479): trs | 2007-01-08 21:34:24 -0500
r18762 at zot: tom | 2007-01-08 21:33:32 -0500
Missing template and action for r2463
r18786 at zot (orig r2480): alexmv | 2007-01-08 23:03:48 -0500
r15845 at zoq-fot-pik: chmrr | 2007-01-08 23:03:32 -0500
* 'length is 42' does not work with Object::Declare, due to how it
parses. Normally, 'foo is 42' is parsed as 'is->foo(42)', and the
method call is caught. With built-ins like 'length', however, perl
parses it as 'length(is(42))'.
Jifty::DBI::Schema has a working 'length is 42' because it does not
use Object::Declare. It exports 'length' and 'is', and expects it
to be parsed as 'length(is(42))'.
We instead use 'max_length is 42' instead of 'length is 42'.
r18787 at zot (orig r2481): alexmv | 2007-01-09 00:57:41 -0500
r15860 at zoq-fot-pik: chmrr | 2007-01-09 00:57:24 -0500
* Module::Pluggable does't include empty intermediate classes now
r18788 at zot (orig r2482): hlb | 2007-01-09 01:48:34 -0500
* upgrade yui library & add yui/container.js
r18791 at zot (orig r2483): trs | 2007-01-10 21:39:37 -0500
r18790 at zot: tom | 2007-01-10 21:39:18 -0500
Fix broken Jifty.Utils.isMSIE
Modified: jifty/branches/template-declare/Makefile.PL
==============================================================================
--- jifty/branches/template-declare/Makefile.PL (original)
+++ jifty/branches/template-declare/Makefile.PL Wed Jan 10 21:43:42 2007
@@ -48,7 +48,7 @@
requires('Log::Log4perl');
requires('LWP::UserAgent'); # Net::HTTP
requires('MIME::Types');
-requires('Module::Pluggable' => '2.95');
+requires('Module::Pluggable' => '3.1');
requires('Module::CoreList');
requires('Module::Refresh');
requires('Module::ScanDeps');
Modified: jifty/branches/template-declare/lib/Jifty/Action.pm
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/Action.pm (original)
+++ jifty/branches/template-declare/lib/Jifty/Action.pm Wed Jan 10 21:43:42 2007
@@ -762,6 +762,10 @@
If neither of those are true, by default canonicalize dates using
_canonicalize_date
+Note that it is possible that a canonicalizer will be called multiple
+times on the same field -- canonicalizers should be careful to do
+nothing to already-canonicalized data.
+
=cut
# XXX TODO: This is named with an underscore to prevent infinite
Modified: jifty/branches/template-declare/lib/Jifty/Manual/Actions.pod
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/Manual/Actions.pod (original)
+++ jifty/branches/template-declare/lib/Jifty/Manual/Actions.pod Wed Jan 10 21:43:42 2007
@@ -77,12 +77,12 @@
param title =>
label is 'Title',
- length is 50,
+ max_length is 50,
is mandatory;
param category =>
label is 'Category',
- length is 30;
+ max_length is 30;
param body =>
label is 'Entry',
Modified: jifty/branches/template-declare/lib/Jifty/Manual/Cookbook.pod
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/Manual/Cookbook.pod (original)
+++ jifty/branches/template-declare/lib/Jifty/Manual/Cookbook.pod Wed Jan 10 21:43:42 2007
@@ -11,6 +11,52 @@
=head1 HOW DO I ...
+=head2 Create an LDAP autocomplete field
+
+You need an action in your application. Then run
+
+ jifty action --name LdapSearch
+
+in C<lib/myApp/Action/LdapSearch.pm> add the C<search> field
+
+ use Jifty::Action schema {
+ param search =>
+ autocompleter is \&ldap_search;
+ }
+
+we need L<Net::LDAP> and an accessor to our LDAP value.
+
+ use Net::LDAP;
+
+ __PACKAGE__->mk_accessors(qw(LDAP));
+
+and we can write our C<ldap_search> fonction.
+Search need at least 3 characters and return an array of C<DisplayName (login)>
+
+ sub ldap_search {
+ my $self = shift;
+ my $search = shift;
+ my @res;
+ if (length $search > 2) {
+ if (! $self->LDAP() ) {
+ $self->LDAP( Net::LDAP->new('ldap.myorg.org');
+ $self->LDAP()->bind( );
+ }
+
+ $self->LDAP()->search(
+ base => 'ou=people,dc=myorg,dc=org',
+ filter => '(cn='.$filter.')',
+ attrs => ['uid','cn','givenname','displayname'],
+ sizelimit => 10
+ );
+
+ foreach my $entr ( $result->sorted('cn') ) {
+ push @res, $entr->get_value('displayname').' ('.$entr->get_value('uid').')';
+ }
+ }
+ return @res;
+ }
+
=head2 Add Atom/RSS Feeds ?
You could generate atom/rss feeds for virtually any model in your application.
@@ -25,12 +71,12 @@
use XML::Feed;
my $posts = MyApp::Model::PostCollection->new();
$posts->unlimit();
-
+
my $feed = XML::Feed->new( $type );
$feed->title( Jifty->config->framework('ApplicationName') . " Feed" );
$feed->link( Jifty->web->url );
$feed->description( $feed->title );
-
+
while( my $post = $posts->next ) {
my $feed_entry = XML::Feed::Entry->new($type);
$feed_entry->title($post->title);
@@ -49,7 +95,7 @@
set type => $1;
show('/feed');
};
-
+
And of course, you need to put these in your HTML header template
(conventionally that's C</_elements/header>):
Modified: jifty/branches/template-declare/lib/Jifty/Module/Pluggable.pm
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/Module/Pluggable.pm (original)
+++ jifty/branches/template-declare/lib/Jifty/Module/Pluggable.pm Wed Jan 10 21:43:42 2007
@@ -8,8 +8,8 @@
=head1 DESCRIPTION
-A custom subclass of Module::Pluggable to override the C<require> mechanism with one that better fits our
-own view of the world.
+A custom subclass of Module::Pluggable to override the C<require>
+mechanism with one that better fits our own view of the world.
=head2 require
Modified: jifty/branches/template-declare/lib/Jifty/Param/Schema.pm
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/Param/Schema.pm (original)
+++ jifty/branches/template-declare/lib/Jifty/Param/Schema.pm Wed Jan 10 21:43:42 2007
@@ -88,6 +88,7 @@
valid => 'valid_values',
render => 'render_as',
order => 'sort_order',
+ max_length => 'length',
},
copula => {
is => '',
Modified: jifty/branches/template-declare/lib/Jifty/Script/App.pm
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/Script/App.pm (original)
+++ jifty/branches/template-declare/lib/Jifty/Script/App.pm Wed Jan 10 21:43:42 2007
@@ -118,7 +118,7 @@
foreach my $dir (@dirs) {
$dir =~ s/__APP__/$lib_dir/;
- print("Creating directory $dir\n");
+ print("Creating directory @{[$self->prefix]}/$dir\n");
mkdir( $self->prefix."/$dir") or die "Can't create ". $self->prefix."/$dir: $!";
}
Modified: jifty/branches/template-declare/lib/Jifty/View/Static/Handler.pm
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/View/Static/Handler.pm (original)
+++ jifty/branches/template-declare/lib/Jifty/View/Static/Handler.pm Wed Jan 10 21:43:42 2007
@@ -28,7 +28,7 @@
* How do we merge together the two static roots?
* If static files go through Jifty::Handler
* We need a flag to allow them to go through the dispatcher, too
- * return "True" (304) for if-modified-since unless develmode.
+ * return "True" (304) for if-modified-since
* if the browser accepts gzipped data,
see if we have a cached gzipped copy
if so, send it
@@ -67,17 +67,19 @@
my $self = shift;
my $path = shift;
- #if ( Jifty->handler->cgi->http('If-Modified-Since') and not Jifty->config->framework('DevelMode') ) { $self->respond_not_modified(); }
- my $local_path = $self->file_path($path);
- unless ($local_path) {
- return undef;
+ my $local_path = $self->file_path($path) or return undef;
+
+ if ( my $since = Jifty->handler->cgi->http('If-Modified-Since') ) {
+ my @file_info = stat($local_path);
+ return $self->send_not_modified
+ unless $file_info[9] > HTTP::Date::str2time($since);
}
my $mime_type = $self->mime_type($local_path);
-
+
if ( $self->client_accepts_gzipped_content and $mime_type =~ m!^(text/|application/x-javascript)! ) {
return $self->send_file($local_path, $mime_type, 'gzip');
} else {
- return $self->send_file($local_path, $mime_type, 'uncompressed');
+ return $self->send_file($local_path, $mime_type, 'uncompressed');
}
}
@@ -228,7 +230,9 @@
sub send_not_modified {
my $self = shift;
- Jifty->handler->apache->header_out( Status => 304 );
+ my $apache = Jifty->handler->apache;
+ $apache->header_out( Status => 304 );
+ $apache->send_http_header();
return 1;
}
Modified: jifty/branches/template-declare/lib/Jifty/Web.pm
==============================================================================
--- jifty/branches/template-declare/lib/Jifty/Web.pm (original)
+++ jifty/branches/template-declare/lib/Jifty/Web.pm Wed Jan 10 21:43:42 2007
@@ -63,6 +63,7 @@
yui/event.js
yui/calendar.js
yui/tabview.js
+ yui/container.js
app.js
app_behaviour.js
css_browser_selector.js
Modified: jifty/branches/template-declare/share/web/static/js/jifty_utils.js
==============================================================================
--- jifty/branches/template-declare/share/web/static/js/jifty_utils.js (original)
+++ jifty/branches/template-declare/share/web/static/js/jifty_utils.js Wed Jan 10 21:43:42 2007
@@ -111,10 +111,8 @@
}
};
-/* This sets Jifty.Utils.isMSIE to true in IE
- @cc_on
- @if ( @_win32 )
- Jifty.Utils.isMSIE = true;
- @end
-*/
+/* This sets Jifty.Utils.isMSIE to true in IE */
+/*@cc_on
+ Jifty.Utils.isMSIE = true;
+@*/
Added: jifty/branches/template-declare/share/web/static/js/yui/container.js
==============================================================================
--- (empty file)
+++ jifty/branches/template-declare/share/web/static/js/yui/container.js Wed Jan 10 21:43:42 2007
@@ -0,0 +1,4614 @@
+/*
+Copyright (c) 2006, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version 0.12.1
+*/
+
+/**
+* Config is a utility used within an Object to allow the implementer to maintain a list of local configuration properties and listen for changes to those properties dynamically using CustomEvent. The initial values are also maintained so that the configuration can be reset at any given point to its initial state.
+* @namespace YAHOO.util
+* @class Config
+* @constructor
+* @param {Object} owner The owner Object to which this Config Object belongs
+*/
+YAHOO.util.Config = function(owner) {
+ if (owner) {
+ this.init(owner);
+ }
+};
+
+YAHOO.util.Config.prototype = {
+
+ /**
+ * Object reference to the owner of this Config Object
+ * @property owner
+ * @type Object
+ */
+ owner : null,
+
+ /**
+ * Boolean flag that specifies whether a queue is currently being executed
+ * @property queueInProgress
+ * @type Boolean
+ */
+ queueInProgress : false,
+
+
+ /**
+ * Validates that the value passed in is a Boolean.
+ * @method checkBoolean
+ * @param {Object} val The value to validate
+ * @return {Boolean} true, if the value is valid
+ */
+ checkBoolean: function(val) {
+ if (typeof val == 'boolean') {
+ return true;
+ } else {
+ return false;
+ }
+ },
+
+ /**
+ * Validates that the value passed in is a number.
+ * @method checkNumber
+ * @param {Object} val The value to validate
+ * @return {Boolean} true, if the value is valid
+ */
+ checkNumber: function(val) {
+ if (isNaN(val)) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+};
+
+
+/**
+* Initializes the configuration Object and all of its local members.
+* @method init
+* @param {Object} owner The owner Object to which this Config Object belongs
+*/
+YAHOO.util.Config.prototype.init = function(owner) {
+
+ this.owner = owner;
+
+ /**
+ * Object reference to the owner of this Config Object
+ * @event configChangedEvent
+ */
+ this.configChangedEvent = new YAHOO.util.CustomEvent("configChanged");
+
+ this.queueInProgress = false;
+
+ /* Private Members */
+
+ /**
+ * Maintains the local collection of configuration property objects and their specified values
+ * @property config
+ * @private
+ * @type Object
+ */
+ var config = {};
+
+ /**
+ * Maintains the local collection of configuration property objects as they were initially applied.
+ * This object is used when resetting a property.
+ * @property initialConfig
+ * @private
+ * @type Object
+ */
+ var initialConfig = {};
+
+ /**
+ * Maintains the local, normalized CustomEvent queue
+ * @property eventQueue
+ * @private
+ * @type Object
+ */
+ var eventQueue = [];
+
+ /**
+ * Fires a configuration property event using the specified value.
+ * @method fireEvent
+ * @private
+ * @param {String} key The configuration property's name
+ * @param {value} Object The value of the correct type for the property
+ */
+ var fireEvent = function( key, value ) {
+ key = key.toLowerCase();
+
+ var property = config[key];
+
+ if (typeof property != 'undefined' && property.event) {
+ property.event.fire(value);
+ }
+ };
+ /* End Private Members */
+
+ /**
+ * Adds a property to the Config Object's private config hash.
+ * @method addProperty
+ * @param {String} key The configuration property's name
+ * @param {Object} propertyObject The Object containing all of this property's arguments
+ */
+ this.addProperty = function( key, propertyObject ) {
+ key = key.toLowerCase();
+
+ config[key] = propertyObject;
+
+ propertyObject.event = new YAHOO.util.CustomEvent(key);
+ propertyObject.key = key;
+
+ if (propertyObject.handler) {
+ propertyObject.event.subscribe(propertyObject.handler, this.owner, true);
+ }
+
+ this.setProperty(key, propertyObject.value, true);
+
+ if (! propertyObject.suppressEvent) {
+ this.queueProperty(key, propertyObject.value);
+ }
+ };
+
+ /**
+ * Returns a key-value configuration map of the values currently set in the Config Object.
+ * @method getConfig
+ * @return {Object} The current config, represented in a key-value map
+ */
+ this.getConfig = function() {
+ var cfg = {};
+
+ for (var prop in config) {
+ var property = config[prop];
+ if (typeof property != 'undefined' && property.event) {
+ cfg[prop] = property.value;
+ }
+ }
+
+ return cfg;
+ };
+
+ /**
+ * Returns the value of specified property.
+ * @method getProperty
+ * @param {String} key The name of the property
+ * @return {Object} The value of the specified property
+ */
+ this.getProperty = function(key) {
+ key = key.toLowerCase();
+
+ var property = config[key];
+ if (typeof property != 'undefined' && property.event) {
+ return property.value;
+ } else {
+ return undefined;
+ }
+ };
+
+ /**
+ * Resets the specified property's value to its initial value.
+ * @method resetProperty
+ * @param {String} key The name of the property
+ * @return {Boolean} True is the property was reset, false if not
+ */
+ this.resetProperty = function(key) {
+ key = key.toLowerCase();
+
+ var property = config[key];
+ if (typeof property != 'undefined' && property.event) {
+ if (initialConfig[key] && initialConfig[key] != 'undefined') {
+ this.setProperty(key, initialConfig[key]);
+ }
+ return true;
+ } else {
+ return false;
+ }
+ };
+
+ /**
+ * Sets the value of a property. If the silent property is passed as true, the property's event will not be fired.
+ * @method setProperty
+ * @param {String} key The name of the property
+ * @param {String} value The value to set the property to
+ * @param {Boolean} silent Whether the value should be set silently, without firing the property event.
+ * @return {Boolean} True, if the set was successful, false if it failed.
+ */
+ this.setProperty = function(key, value, silent) {
+ key = key.toLowerCase();
+
+ if (this.queueInProgress && ! silent) {
+ this.queueProperty(key,value); // Currently running through a queue...
+ return true;
+ } else {
+ var property = config[key];
+ if (typeof property != 'undefined' && property.event) {
+ if (property.validator && ! property.validator(value)) { // validator
+ return false;
+ } else {
+ property.value = value;
+ if (! silent) {
+ fireEvent(key, value);
+ this.configChangedEvent.fire([key, value]);
+ }
+ return true;
+ }
+ } else {
+ return false;
+ }
+ }
+ };
+
+ /**
+ * Sets the value of a property and queues its event to execute. If the event is already scheduled to execute, it is
+ * moved from its current position to the end of the queue.
+ * @method queueProperty
+ * @param {String} key The name of the property
+ * @param {String} value The value to set the property to
+ * @return {Boolean} true, if the set was successful, false if it failed.
+ */
+ this.queueProperty = function(key, value) {
+ key = key.toLowerCase();
+
+ var property = config[key];
+
+ if (typeof property != 'undefined' && property.event) {
+ if (typeof value != 'undefined' && property.validator && ! property.validator(value)) { // validator
+ return false;
+ } else {
+
+ if (typeof value != 'undefined') {
+ property.value = value;
+ } else {
+ value = property.value;
+ }
+
+ var foundDuplicate = false;
+
+ for (var i=0;i<eventQueue.length;i++) {
+ var queueItem = eventQueue[i];
+
+ if (queueItem) {
+ var queueItemKey = queueItem[0];
+ var queueItemValue = queueItem[1];
+
+ if (queueItemKey.toLowerCase() == key) {
+ // found a dupe... push to end of queue, null current item, and break
+ eventQueue[i] = null;
+ eventQueue.push([key, (typeof value != 'undefined' ? value : queueItemValue)]);
+ foundDuplicate = true;
+ break;
+ }
+ }
+ }
+
+ if (! foundDuplicate && typeof value != 'undefined') { // this is a refire, or a new property in the queue
+ eventQueue.push([key, value]);
+ }
+ }
+
+ if (property.supercedes) {
+ for (var s=0;s<property.supercedes.length;s++) {
+ var supercedesCheck = property.supercedes[s];
+
+ for (var q=0;q<eventQueue.length;q++) {
+ var queueItemCheck = eventQueue[q];
+
+ if (queueItemCheck) {
+ var queueItemCheckKey = queueItemCheck[0];
+ var queueItemCheckValue = queueItemCheck[1];
+
+ if ( queueItemCheckKey.toLowerCase() == supercedesCheck.toLowerCase() ) {
+ eventQueue.push([queueItemCheckKey, queueItemCheckValue]);
+ eventQueue[q] = null;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return true;
+ } else {
+ return false;
+ }
+ };
+
+ /**
+ * Fires the event for a property using the property's current value.
+ * @method refireEvent
+ * @param {String} key The name of the property
+ */
+ this.refireEvent = function(key) {
+ key = key.toLowerCase();
+
+ var property = config[key];
+ if (typeof property != 'undefined' && property.event && typeof property.value != 'undefined') {
+ if (this.queueInProgress) {
+ this.queueProperty(key);
+ } else {
+ fireEvent(key, property.value);
+ }
+ }
+ };
+
+ /**
+ * Applies a key-value Object literal to the configuration, replacing any existing values, and queueing the property events.
+ * Although the values will be set, fireQueue() must be called for their associated events to execute.
+ * @method applyConfig
+ * @param {Object} userConfig The configuration Object literal
+ * @param {Boolean} init When set to true, the initialConfig will be set to the userConfig passed in, so that calling a reset will reset the properties to the passed values.
+ */
+ this.applyConfig = function(userConfig, init) {
+ if (init) {
+ initialConfig = userConfig;
+ }
+ for (var prop in userConfig) {
+ this.queueProperty(prop, userConfig[prop]);
+ }
+ };
+
+ /**
+ * Refires the events for all configuration properties using their current values.
+ * @method refresh
+ */
+ this.refresh = function() {
+ for (var prop in config) {
+ this.refireEvent(prop);
+ }
+ };
+
+ /**
+ * Fires the normalized list of queued property change events
+ * @method fireQueue
+ */
+ this.fireQueue = function() {
+ this.queueInProgress = true;
+ for (var i=0;i<eventQueue.length;i++) {
+ var queueItem = eventQueue[i];
+ if (queueItem) {
+ var key = queueItem[0];
+ var value = queueItem[1];
+
+ var property = config[key];
+ property.value = value;
+
+ fireEvent(key,value);
+ }
+ }
+
+ this.queueInProgress = false;
+ eventQueue = [];
+ };
+
+ /**
+ * Subscribes an external handler to the change event for any given property.
+ * @method subscribeToConfigEvent
+ * @param {String} key The property name
+ * @param {Function} handler The handler function to use subscribe to the property's event
+ * @param {Object} obj The Object to use for scoping the event handler (see CustomEvent documentation)
+ * @param {Boolean} override Optional. If true, will override "this" within the handler to map to the scope Object passed into the method.
+ * @return {Boolean} True, if the subscription was successful, otherwise false.
+ */
+ this.subscribeToConfigEvent = function(key, handler, obj, override) {
+ key = key.toLowerCase();
+
+ var property = config[key];
+ if (typeof property != 'undefined' && property.event) {
+ if (! YAHOO.util.Config.alreadySubscribed(property.event, handler, obj)) {
+ property.event.subscribe(handler, obj, override);
+ }
+ return true;
+ } else {
+ return false;
+ }
+ };
+
+ /**
+ * Unsubscribes an external handler from the change event for any given property.
+ * @method unsubscribeFromConfigEvent
+ * @param {String} key The property name
+ * @param {Function} handler The handler function to use subscribe to the property's event
+ * @param {Object} obj The Object to use for scoping the event handler (see CustomEvent documentation)
+ * @return {Boolean} True, if the unsubscription was successful, otherwise false.
+ */
+ this.unsubscribeFromConfigEvent = function(key, handler, obj) {
+ key = key.toLowerCase();
+
+ var property = config[key];
+ if (typeof property != 'undefined' && property.event) {
+ return property.event.unsubscribe(handler, obj);
+ } else {
+ return false;
+ }
+ };
+
+ /**
+ * Returns a string representation of the Config object
+ * @method toString
+ * @return {String} The Config object in string format.
+ */
+ this.toString = function() {
+ var output = "Config";
+ if (this.owner) {
+ output += " [" + this.owner.toString() + "]";
+ }
+ return output;
+ };
+
+ /**
+ * Returns a string representation of the Config object's current CustomEvent queue
+ * @method outputEventQueue
+ * @return {String} The string list of CustomEvents currently queued for execution
+ */
+ this.outputEventQueue = function() {
+ var output = "";
+ for (var q=0;q<eventQueue.length;q++) {
+ var queueItem = eventQueue[q];
+ if (queueItem) {
+ output += queueItem[0] + "=" + queueItem[1] + ", ";
+ }
+ }
+ return output;
+ };
+};
+
+/**
+* Checks to determine if a particular function/Object pair are already subscribed to the specified CustomEvent
+* @method YAHOO.util.Config.alreadySubscribed
+* @static
+* @param {YAHOO.util.CustomEvent} evt The CustomEvent for which to check the subscriptions
+* @param {Function} fn The function to look for in the subscribers list
+* @param {Object} obj The execution scope Object for the subscription
+* @return {Boolean} true, if the function/Object pair is already subscribed to the CustomEvent passed in
+*/
+YAHOO.util.Config.alreadySubscribed = function(evt, fn, obj) {
+ for (var e=0;e<evt.subscribers.length;e++) {
+ var subsc = evt.subscribers[e];
+ if (subsc && subsc.obj == obj && subsc.fn == fn) {
+ return true;
+ }
+ }
+ return false;
+};
+
+/**
+* The Container family of components is designed to enable developers to create different kinds of content-containing modules on the web. Module and Overlay are the most basic containers, and they can be used directly or extended to build custom containers. Also part of the Container family are four UI controls that extend Module and Overlay: Tooltip, Panel, Dialog, and SimpleDialog.
+* @module container
+* @title Container
+* @requires yahoo,dom,event,dragdrop,animation
+*/
+
+/**
+* Module is a JavaScript representation of the Standard Module Format. Standard Module Format is a simple standard for markup containers where child nodes representing the header, body, and footer of the content are denoted using the CSS classes "hd", "bd", and "ft" respectively. Module is the base class for all other classes in the YUI Container package.
+* @namespace YAHOO.widget
+* @class Module
+* @constructor
+* @param {String} el The element ID representing the Module <em>OR</em>
+* @param {HTMLElement} el The element representing the Module
+* @param {Object} userConfig The configuration Object literal containing the configuration that should be set for this module. See configuration documentation for more details.
+*/
+YAHOO.widget.Module = function(el, userConfig) {
+ if (el) {
+ this.init(el, userConfig);
+ }
+};
+
+/**
+* Constant representing the prefix path to use for non-secure images
+* @property YAHOO.widget.Module.IMG_ROOT
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Module.IMG_ROOT = "http://us.i1.yimg.com/us.yimg.com/i/";
+
+/**
+* Constant representing the prefix path to use for securely served images
+* @property YAHOO.widget.Module.IMG_ROOT_SSL
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Module.IMG_ROOT_SSL = "https://a248.e.akamai.net/sec.yimg.com/i/";
+
+/**
+* Constant for the default CSS class name that represents a Module
+* @property YAHOO.widget.Module.CSS_MODULE
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Module.CSS_MODULE = "module";
+
+/**
+* Constant representing the module header
+* @property YAHOO.widget.Module.CSS_HEADER
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Module.CSS_HEADER = "hd";
+
+/**
+* Constant representing the module body
+* @property YAHOO.widget.Module.CSS_BODY
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Module.CSS_BODY = "bd";
+
+/**
+* Constant representing the module footer
+* @property YAHOO.widget.Module.CSS_FOOTER
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Module.CSS_FOOTER = "ft";
+
+/**
+* Constant representing the url for the "src" attribute of the iframe used to monitor changes to the browser's base font size
+* @property YAHOO.widget.Module.RESIZE_MONITOR_SECURE_URL
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Module.RESIZE_MONITOR_SECURE_URL = "javascript:false;";
+
+/**
+* Singleton CustomEvent fired when the font size is changed in the browser.
+* Opera's "zoom" functionality currently does not support text size detection.
+* @event YAHOO.widget.Module.textResizeEvent
+*/
+YAHOO.widget.Module.textResizeEvent = new YAHOO.util.CustomEvent("textResize");
+
+YAHOO.widget.Module.prototype = {
+ /**
+ * The class's constructor function
+ * @property contructor
+ * @type Function
+ */
+ constructor : YAHOO.widget.Module,
+
+ /**
+ * The main module element that contains the header, body, and footer
+ * @property element
+ * @type HTMLElement
+ */
+ element : null,
+
+ /**
+ * The header element, denoted with CSS class "hd"
+ * @property header
+ * @type HTMLElement
+ */
+ header : null,
+
+ /**
+ * The body element, denoted with CSS class "bd"
+ * @property body
+ * @type HTMLElement
+ */
+ body : null,
+
+ /**
+ * The footer element, denoted with CSS class "ft"
+ * @property footer
+ * @type HTMLElement
+ */
+ footer : null,
+
+ /**
+ * The id of the element
+ * @property id
+ * @type String
+ */
+ id : null,
+
+ /**
+ * The String representing the image root
+ * @property imageRoot
+ * @type String
+ */
+ imageRoot : YAHOO.widget.Module.IMG_ROOT,
+
+ /**
+ * Initializes the custom events for Module which are fired automatically at appropriate times by the Module class.
+ * @method initEvents
+ */
+ initEvents : function() {
+
+ /**
+ * CustomEvent fired prior to class initalization.
+ * @event beforeInitEvent
+ * @param {class} classRef class reference of the initializing class, such as this.beforeInitEvent.fire(YAHOO.widget.Module)
+ */
+ this.beforeInitEvent = new YAHOO.util.CustomEvent("beforeInit");
+
+ /**
+ * CustomEvent fired after class initalization.
+ * @event initEvent
+ * @param {class} classRef class reference of the initializing class, such as this.beforeInitEvent.fire(YAHOO.widget.Module)
+ */
+ this.initEvent = new YAHOO.util.CustomEvent("init");
+
+ /**
+ * CustomEvent fired when the Module is appended to the DOM
+ * @event appendEvent
+ */
+ this.appendEvent = new YAHOO.util.CustomEvent("append");
+
+ /**
+ * CustomEvent fired before the Module is rendered
+ * @event beforeRenderEvent
+ */
+ this.beforeRenderEvent = new YAHOO.util.CustomEvent("beforeRender");
+
+ /**
+ * CustomEvent fired after the Module is rendered
+ * @event renderEvent
+ */
+ this.renderEvent = new YAHOO.util.CustomEvent("render");
+
+ /**
+ * CustomEvent fired when the header content of the Module is modified
+ * @event changeHeaderEvent
+ * @param {String/HTMLElement} content String/element representing the new header content
+ */
+ this.changeHeaderEvent = new YAHOO.util.CustomEvent("changeHeader");
+
+ /**
+ * CustomEvent fired when the body content of the Module is modified
+ * @event changeBodyEvent
+ * @param {String/HTMLElement} content String/element representing the new body content
+ */
+ this.changeBodyEvent = new YAHOO.util.CustomEvent("changeBody");
+
+ /**
+ * CustomEvent fired when the footer content of the Module is modified
+ * @event changeFooterEvent
+ * @param {String/HTMLElement} content String/element representing the new footer content
+ */
+ this.changeFooterEvent = new YAHOO.util.CustomEvent("changeFooter");
+
+ /**
+ * CustomEvent fired when the content of the Module is modified
+ * @event changeContentEvent
+ */
+ this.changeContentEvent = new YAHOO.util.CustomEvent("changeContent");
+
+ /**
+ * CustomEvent fired when the Module is destroyed
+ * @event destroyEvent
+ */
+ this.destroyEvent = new YAHOO.util.CustomEvent("destroy");
+
+ /**
+ * CustomEvent fired before the Module is shown
+ * @event beforeShowEvent
+ */
+ this.beforeShowEvent = new YAHOO.util.CustomEvent("beforeShow");
+
+ /**
+ * CustomEvent fired after the Module is shown
+ * @event showEvent
+ */
+ this.showEvent = new YAHOO.util.CustomEvent("show");
+
+ /**
+ * CustomEvent fired before the Module is hidden
+ * @event beforeHideEvent
+ */
+ this.beforeHideEvent = new YAHOO.util.CustomEvent("beforeHide");
+
+ /**
+ * CustomEvent fired after the Module is hidden
+ * @event hideEvent
+ */
+ this.hideEvent = new YAHOO.util.CustomEvent("hide");
+ },
+
+ /**
+ * String representing the current user-agent platform
+ * @property platform
+ * @type String
+ */
+ platform : function() {
+ var ua = navigator.userAgent.toLowerCase();
+ if (ua.indexOf("windows") != -1 || ua.indexOf("win32") != -1) {
+ return "windows";
+ } else if (ua.indexOf("macintosh") != -1) {
+ return "mac";
+ } else {
+ return false;
+ }
+ }(),
+
+ /**
+ * String representing the current user-agent browser
+ * @property browser
+ * @type String
+ */
+ browser : function() {
+ var ua = navigator.userAgent.toLowerCase();
+ if (ua.indexOf('opera')!=-1) { // Opera (check first in case of spoof)
+ return 'opera';
+ } else if (ua.indexOf('msie 7')!=-1) { // IE7
+ return 'ie7';
+ } else if (ua.indexOf('msie') !=-1) { // IE
+ return 'ie';
+ } else if (ua.indexOf('safari')!=-1) { // Safari (check before Gecko because it includes "like Gecko")
+ return 'safari';
+ } else if (ua.indexOf('gecko') != -1) { // Gecko
+ return 'gecko';
+ } else {
+ return false;
+ }
+ }(),
+
+ /**
+ * Boolean representing whether or not the current browsing context is secure (https)
+ * @property isSecure
+ * @type Boolean
+ */
+ isSecure : function() {
+ if (window.location.href.toLowerCase().indexOf("https") === 0) {
+ return true;
+ } else {
+ return false;
+ }
+ }(),
+
+ /**
+ * Initializes the custom events for Module which are fired automatically at appropriate times by the Module class.
+ */
+ initDefaultConfig : function() {
+ // Add properties //
+
+ /**
+ * Specifies whether the Module is visible on the page.
+ * @config visible
+ * @type Boolean
+ * @default true
+ */
+ this.cfg.addProperty("visible", { value:true, handler:this.configVisible, validator:this.cfg.checkBoolean } );
+
+ /**
+ * Object or array of objects representing the ContainerEffect classes that are active for animating the container.
+ * @config effect
+ * @type Object
+ * @default null
+ */
+ this.cfg.addProperty("effect", { suppressEvent:true, supercedes:["visible"] } );
+
+ /**
+ * Specifies whether to create a special proxy iframe to monitor for user font resizing in the document
+ * @config monitorresize
+ * @type Boolean
+ * @default true
+ */
+ this.cfg.addProperty("monitorresize", { value:true, handler:this.configMonitorResize } );
+ },
+
+ /**
+ * The Module class's initialization method, which is executed for Module and all of its subclasses. This method is automatically called by the constructor, and sets up all DOM references for pre-existing markup, and creates required markup if it is not already present.
+ * @method init
+ * @param {String} el The element ID representing the Module <em>OR</em>
+ * @param {HTMLElement} el The element representing the Module
+ * @param {Object} userConfig The configuration Object literal containing the configuration that should be set for this module. See configuration documentation for more details.
+ */
+ init : function(el, userConfig) {
+
+ this.initEvents();
+
+ this.beforeInitEvent.fire(YAHOO.widget.Module);
+
+ /**
+ * The Module's Config object used for monitoring configuration properties.
+ * @property cfg
+ * @type YAHOO.util.Config
+ */
+ this.cfg = new YAHOO.util.Config(this);
+
+ if (this.isSecure) {
+ this.imageRoot = YAHOO.widget.Module.IMG_ROOT_SSL;
+ }
+
+ if (typeof el == "string") {
+ var elId = el;
+
+ el = document.getElementById(el);
+ if (! el) {
+ el = document.createElement("DIV");
+ el.id = elId;
+ }
+ }
+
+ this.element = el;
+
+ if (el.id) {
+ this.id = el.id;
+ }
+
+ var childNodes = this.element.childNodes;
+
+ if (childNodes) {
+ for (var i=0;i<childNodes.length;i++) {
+ var child = childNodes[i];
+ switch (child.className) {
+ case YAHOO.widget.Module.CSS_HEADER:
+ this.header = child;
+ break;
+ case YAHOO.widget.Module.CSS_BODY:
+ this.body = child;
+ break;
+ case YAHOO.widget.Module.CSS_FOOTER:
+ this.footer = child;
+ break;
+ }
+ }
+ }
+
+ this.initDefaultConfig();
+
+ YAHOO.util.Dom.addClass(this.element, YAHOO.widget.Module.CSS_MODULE);
+
+ if (userConfig) {
+ this.cfg.applyConfig(userConfig, true);
+ }
+
+ // Subscribe to the fireQueue() method of Config so that any queued configuration changes are
+ // excecuted upon render of the Module
+ if (! YAHOO.util.Config.alreadySubscribed(this.renderEvent, this.cfg.fireQueue, this.cfg)) {
+ this.renderEvent.subscribe(this.cfg.fireQueue, this.cfg, true);
+ }
+
+ this.initEvent.fire(YAHOO.widget.Module);
+ },
+
+ /**
+ * Initialized an empty IFRAME that is placed out of the visible area that can be used to detect text resize.
+ * @method initResizeMonitor
+ */
+ initResizeMonitor : function() {
+
+ if(this.browser != "opera") {
+
+ var resizeMonitor = document.getElementById("_yuiResizeMonitor");
+
+ if (! resizeMonitor) {
+
+ resizeMonitor = document.createElement("iframe");
+
+ var bIE = (this.browser.indexOf("ie") === 0);
+
+ if(this.isSecure &&
+ YAHOO.widget.Module.RESIZE_MONITOR_SECURE_URL &&
+ bIE) {
+
+ resizeMonitor.src =
+ YAHOO.widget.Module.RESIZE_MONITOR_SECURE_URL;
+
+ }
+
+ resizeMonitor.id = "_yuiResizeMonitor";
+ resizeMonitor.style.visibility = "hidden";
+
+ document.body.appendChild(resizeMonitor);
+
+ resizeMonitor.style.width = "10em";
+ resizeMonitor.style.height = "10em";
+ resizeMonitor.style.position = "absolute";
+
+ var nLeft = -1 * resizeMonitor.offsetWidth,
+ nTop = -1 * resizeMonitor.offsetHeight;
+
+ resizeMonitor.style.top = nTop + "px";
+ resizeMonitor.style.left = nLeft + "px";
+ resizeMonitor.style.borderStyle = "none";
+ resizeMonitor.style.borderWidth = "0";
+ YAHOO.util.Dom.setStyle(resizeMonitor, "opacity", "0");
+
+ resizeMonitor.style.visibility = "visible";
+
+ if(!bIE) {
+
+ var doc = resizeMonitor.contentWindow.document;
+
+ doc.open();
+ doc.close();
+
+ }
+ }
+
+ var fireTextResize = function() {
+ YAHOO.widget.Module.textResizeEvent.fire();
+ };
+
+ if(resizeMonitor && resizeMonitor.contentWindow) {
+ this.resizeMonitor = resizeMonitor;
+
+ YAHOO.widget.Module.textResizeEvent.subscribe(this.onDomResize, this, true);
+
+ if (! YAHOO.widget.Module.textResizeInitialized) {
+ if (! YAHOO.util.Event.addListener(this.resizeMonitor.contentWindow, "resize", fireTextResize)) {
+ // This will fail in IE if document.domain has changed, so we must change the listener to
+ // use the resizeMonitor element instead
+ YAHOO.util.Event.addListener(this.resizeMonitor, "resize", fireTextResize);
+ }
+ YAHOO.widget.Module.textResizeInitialized = true;
+ }
+ }
+
+ }
+
+ },
+
+ /**
+ * Event handler fired when the resize monitor element is resized.
+ * @method onDomResize
+ * @param {DOMEvent} e The DOM resize event
+ * @param {Object} obj The scope object passed to the handler
+ */
+ onDomResize : function(e, obj) {
+
+ var nLeft = -1 * this.resizeMonitor.offsetWidth,
+ nTop = -1 * this.resizeMonitor.offsetHeight;
+
+ this.resizeMonitor.style.top = nTop + "px";
+ this.resizeMonitor.style.left = nLeft + "px";
+
+ },
+
+ /**
+ * Sets the Module's header content to the HTML specified, or appends the passed element to the header. If no header is present, one will be automatically created.
+ * @method setHeader
+ * @param {String} headerContent The HTML used to set the header <em>OR</em>
+ * @param {HTMLElement} headerContent The HTMLElement to append to the header
+ */
+ setHeader : function(headerContent) {
+ if (! this.header) {
+ this.header = document.createElement("DIV");
+ this.header.className = YAHOO.widget.Module.CSS_HEADER;
+ }
+
+ if (typeof headerContent == "string") {
+ this.header.innerHTML = headerContent;
+ } else {
+ this.header.innerHTML = "";
+ this.header.appendChild(headerContent);
+ }
+
+ this.changeHeaderEvent.fire(headerContent);
+ this.changeContentEvent.fire();
+ },
+
+ /**
+ * Appends the passed element to the header. If no header is present, one will be automatically created.
+ * @method appendToHeader
+ * @param {HTMLElement} element The element to append to the header
+ */
+ appendToHeader : function(element) {
+ if (! this.header) {
+ this.header = document.createElement("DIV");
+ this.header.className = YAHOO.widget.Module.CSS_HEADER;
+ }
+
+ this.header.appendChild(element);
+ this.changeHeaderEvent.fire(element);
+ this.changeContentEvent.fire();
+ },
+
+ /**
+ * Sets the Module's body content to the HTML specified, or appends the passed element to the body. If no body is present, one will be automatically created.
+ * @method setBody
+ * @param {String} bodyContent The HTML used to set the body <em>OR</em>
+ * @param {HTMLElement} bodyContent The HTMLElement to append to the body
+ */
+ setBody : function(bodyContent) {
+ if (! this.body) {
+ this.body = document.createElement("DIV");
+ this.body.className = YAHOO.widget.Module.CSS_BODY;
+ }
+
+ if (typeof bodyContent == "string")
+ {
+ this.body.innerHTML = bodyContent;
+ } else {
+ this.body.innerHTML = "";
+ this.body.appendChild(bodyContent);
+ }
+
+ this.changeBodyEvent.fire(bodyContent);
+ this.changeContentEvent.fire();
+ },
+
+ /**
+ * Appends the passed element to the body. If no body is present, one will be automatically created.
+ * @method appendToBody
+ * @param {HTMLElement} element The element to append to the body
+ */
+ appendToBody : function(element) {
+ if (! this.body) {
+ this.body = document.createElement("DIV");
+ this.body.className = YAHOO.widget.Module.CSS_BODY;
+ }
+
+ this.body.appendChild(element);
+ this.changeBodyEvent.fire(element);
+ this.changeContentEvent.fire();
+ },
+
+ /**
+ * Sets the Module's footer content to the HTML specified, or appends the passed element to the footer. If no footer is present, one will be automatically created.
+ * @method setFooter
+ * @param {String} footerContent The HTML used to set the footer <em>OR</em>
+ * @param {HTMLElement} footerContent The HTMLElement to append to the footer
+ */
+ setFooter : function(footerContent) {
+ if (! this.footer) {
+ this.footer = document.createElement("DIV");
+ this.footer.className = YAHOO.widget.Module.CSS_FOOTER;
+ }
+
+ if (typeof footerContent == "string") {
+ this.footer.innerHTML = footerContent;
+ } else {
+ this.footer.innerHTML = "";
+ this.footer.appendChild(footerContent);
+ }
+
+ this.changeFooterEvent.fire(footerContent);
+ this.changeContentEvent.fire();
+ },
+
+ /**
+ * Appends the passed element to the footer. If no footer is present, one will be automatically created.
+ * @method appendToFooter
+ * @param {HTMLElement} element The element to append to the footer
+ */
+ appendToFooter : function(element) {
+ if (! this.footer) {
+ this.footer = document.createElement("DIV");
+ this.footer.className = YAHOO.widget.Module.CSS_FOOTER;
+ }
+
+ this.footer.appendChild(element);
+ this.changeFooterEvent.fire(element);
+ this.changeContentEvent.fire();
+ },
+
+ /**
+ * Renders the Module by inserting the elements that are not already in the main Module into their correct places. Optionally appends the Module to the specified node prior to the render's execution. NOTE: For Modules without existing markup, the appendToNode argument is REQUIRED. If this argument is ommitted and the current element is not present in the document, the function will return false, indicating that the render was a failure.
+ * @method render
+ * @param {String} appendToNode The element id to which the Module should be appended to prior to rendering <em>OR</em>
+ * @param {HTMLElement} appendToNode The element to which the Module should be appended to prior to rendering
+ * @param {HTMLElement} moduleElement OPTIONAL. The element that represents the actual Standard Module container.
+ * @return {Boolean} Success or failure of the render
+ */
+ render : function(appendToNode, moduleElement) {
+ this.beforeRenderEvent.fire();
+
+ if (! moduleElement) {
+ moduleElement = this.element;
+ }
+
+ var me = this;
+ var appendTo = function(element) {
+ if (typeof element == "string") {
+ element = document.getElementById(element);
+ }
+
+ if (element) {
+ element.appendChild(me.element);
+ me.appendEvent.fire();
+ }
+ };
+
+ if (appendToNode) {
+ appendTo(appendToNode);
+ } else { // No node was passed in. If the element is not pre-marked up, this fails
+ if (! YAHOO.util.Dom.inDocument(this.element)) {
+ return false;
+ }
+ }
+
+ // Need to get everything into the DOM if it isn't already
+
+ if (this.header && ! YAHOO.util.Dom.inDocument(this.header)) {
+ // There is a header, but it's not in the DOM yet... need to add it
+ var firstChild = moduleElement.firstChild;
+ if (firstChild) { // Insert before first child if exists
+ moduleElement.insertBefore(this.header, firstChild);
+ } else { // Append to empty body because there are no children
+ moduleElement.appendChild(this.header);
+ }
+ }
+
+ if (this.body && ! YAHOO.util.Dom.inDocument(this.body)) {
+ // There is a body, but it's not in the DOM yet... need to add it
+ if (this.footer && YAHOO.util.Dom.isAncestor(this.moduleElement, this.footer)) { // Insert before footer if exists in DOM
+ moduleElement.insertBefore(this.body, this.footer);
+ } else { // Append to element because there is no footer
+ moduleElement.appendChild(this.body);
+ }
+ }
+
+ if (this.footer && ! YAHOO.util.Dom.inDocument(this.footer)) {
+ // There is a footer, but it's not in the DOM yet... need to add it
+ moduleElement.appendChild(this.footer);
+ }
+
+ this.renderEvent.fire();
+ return true;
+ },
+
+ /**
+ * Removes the Module element from the DOM and sets all child elements to null.
+ * @method destroy
+ */
+ destroy : function() {
+ var parent;
+
+ if (this.element) {
+ YAHOO.util.Event.purgeElement(this.element, true);
+ parent = this.element.parentNode;
+ }
+ if (parent) {
+ parent.removeChild(this.element);
+ }
+
+ this.element = null;
+ this.header = null;
+ this.body = null;
+ this.footer = null;
+
+ for (var e in this) {
+ if (e instanceof YAHOO.util.CustomEvent) {
+ e.unsubscribeAll();
+ }
+ }
+
+ YAHOO.widget.Module.textResizeEvent.unsubscribe(this.onDomResize, this);
+
+ this.destroyEvent.fire();
+ },
+
+ /**
+ * Shows the Module element by setting the visible configuration property to true. Also fires two events: beforeShowEvent prior to the visibility change, and showEvent after.
+ * @method show
+ */
+ show : function() {
+ this.cfg.setProperty("visible", true);
+ },
+
+ /**
+ * Hides the Module element by setting the visible configuration property to false. Also fires two events: beforeHideEvent prior to the visibility change, and hideEvent after.
+ * @method hide
+ */
+ hide : function() {
+ this.cfg.setProperty("visible", false);
+ },
+
+ // BUILT-IN EVENT HANDLERS FOR MODULE //
+
+ /**
+ * Default event handler for changing the visibility property of a Module. By default, this is achieved by switching the "display" style between "block" and "none".
+ * This method is responsible for firing showEvent and hideEvent.
+ * @param {String} type The CustomEvent type (usually the property name)
+ * @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+ * @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+ * @method configVisible
+ */
+ configVisible : function(type, args, obj) {
+ var visible = args[0];
+ if (visible) {
+ this.beforeShowEvent.fire();
+ YAHOO.util.Dom.setStyle(this.element, "display", "block");
+ this.showEvent.fire();
+ } else {
+ this.beforeHideEvent.fire();
+ YAHOO.util.Dom.setStyle(this.element, "display", "none");
+ this.hideEvent.fire();
+ }
+ },
+
+ /**
+ * Default event handler for the "monitorresize" configuration property
+ * @param {String} type The CustomEvent type (usually the property name)
+ * @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+ * @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+ * @method configMonitorResize
+ */
+ configMonitorResize : function(type, args, obj) {
+ var monitor = args[0];
+ if (monitor) {
+ this.initResizeMonitor();
+ } else {
+ YAHOO.util.Event.removeListener(this.resizeMonitor, "resize", this.onDomResize);
+ this.resizeMonitor = null;
+ }
+ }
+};
+
+/**
+* Returns a String representation of the Object.
+* @method toString
+* @return {String} The string representation of the Module
+*/
+YAHOO.widget.Module.prototype.toString = function() {
+ return "Module " + this.id;
+};
+
+/**
+* Overlay is a Module that is absolutely positioned above the page flow. It has convenience methods for positioning and sizing, as well as options for controlling zIndex and constraining the Overlay's position to the current visible viewport. Overlay also contains a dynamicly generated IFRAME which is placed beneath it for Internet Explorer 6 and 5.x so that it will be properly rendered above SELECT elements.
+* @namespace YAHOO.widget
+* @class Overlay
+* @extends YAHOO.widget.Module
+* @param {String} el The element ID representing the Overlay <em>OR</em>
+* @param {HTMLElement} el The element representing the Overlay
+* @param {Object} userConfig The configuration object literal containing 10/23/2006the configuration that should be set for this Overlay. See configuration documentation for more details.
+* @constructor
+*/
+YAHOO.widget.Overlay = function(el, userConfig) {
+ YAHOO.widget.Overlay.superclass.constructor.call(this, el, userConfig);
+};
+
+YAHOO.extend(YAHOO.widget.Overlay, YAHOO.widget.Module);
+
+/**
+* The URL that will be placed in the iframe
+* @property YAHOO.widget.Overlay.IFRAME_SRC
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Overlay.IFRAME_SRC = "javascript:false;";
+
+/**
+* Constant representing the top left corner of an element, used for configuring the context element alignment
+* @property YAHOO.widget.Overlay.TOP_LEFT
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Overlay.TOP_LEFT = "tl";
+
+/**
+* Constant representing the top right corner of an element, used for configuring the context element alignment
+* @property YAHOO.widget.Overlay.TOP_RIGHT
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Overlay.TOP_RIGHT = "tr";
+
+/**
+* Constant representing the top bottom left corner of an element, used for configuring the context element alignment
+* @property YAHOO.widget.Overlay.BOTTOM_LEFT
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Overlay.BOTTOM_LEFT = "bl";
+
+/**
+* Constant representing the bottom right corner of an element, used for configuring the context element alignment
+* @property YAHOO.widget.Overlay.BOTTOM_RIGHT
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Overlay.BOTTOM_RIGHT = "br";
+
+/**
+* Constant representing the default CSS class used for an Overlay
+* @property YAHOO.widget.Overlay.CSS_OVERLAY
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Overlay.CSS_OVERLAY = "overlay";
+
+/**
+* The Overlay initialization method, which is executed for Overlay and all of its subclasses. This method is automatically called by the constructor, and sets up all DOM references for pre-existing markup, and creates required markup if it is not already present.
+* @method init
+* @param {String} el The element ID representing the Overlay <em>OR</em>
+* @param {HTMLElement} el The element representing the Overlay
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this Overlay. See configuration documentation for more details.
+*/
+YAHOO.widget.Overlay.prototype.init = function(el, userConfig) {
+ YAHOO.widget.Overlay.superclass.init.call(this, el/*, userConfig*/); // Note that we don't pass the user config in here yet because we only want it executed once, at the lowest subclass level
+
+ this.beforeInitEvent.fire(YAHOO.widget.Overlay);
+
+ YAHOO.util.Dom.addClass(this.element, YAHOO.widget.Overlay.CSS_OVERLAY);
+
+ if (userConfig) {
+ this.cfg.applyConfig(userConfig, true);
+ }
+
+ if (this.platform == "mac" && this.browser == "gecko") {
+ if (! YAHOO.util.Config.alreadySubscribed(this.showEvent,this.showMacGeckoScrollbars,this)) {
+ this.showEvent.subscribe(this.showMacGeckoScrollbars,this,true);
+ }
+ if (! YAHOO.util.Config.alreadySubscribed(this.hideEvent,this.hideMacGeckoScrollbars,this)) {
+ this.hideEvent.subscribe(this.hideMacGeckoScrollbars,this,true);
+ }
+ }
+
+ this.initEvent.fire(YAHOO.widget.Overlay);
+};
+
+/**
+* Initializes the custom events for Overlay which are fired automatically at appropriate times by the Overlay class.
+* @method initEvents
+*/
+YAHOO.widget.Overlay.prototype.initEvents = function() {
+ YAHOO.widget.Overlay.superclass.initEvents.call(this);
+
+ /**
+ * CustomEvent fired before the Overlay is moved.
+ * @event beforeMoveEvent
+ * @param {Number} x x coordinate
+ * @param {Number} y y coordinate
+ */
+ this.beforeMoveEvent = new YAHOO.util.CustomEvent("beforeMove", this);
+
+ /**
+ * CustomEvent fired after the Overlay is moved.
+ * @event moveEvent
+ * @param {Number} x x coordinate
+ * @param {Number} y y coordinate
+ */
+ this.moveEvent = new YAHOO.util.CustomEvent("move", this);
+};
+
+/**
+* Initializes the class's configurable properties which can be changed using the Overlay's Config object (cfg).
+* @method initDefaultConfig
+*/
+YAHOO.widget.Overlay.prototype.initDefaultConfig = function() {
+ YAHOO.widget.Overlay.superclass.initDefaultConfig.call(this);
+
+ // Add overlay config properties //
+
+ /**
+ * The absolute x-coordinate position of the Overlay
+ * @config x
+ * @type Number
+ * @default null
+ */
+ this.cfg.addProperty("x", { handler:this.configX, validator:this.cfg.checkNumber, suppressEvent:true, supercedes:["iframe"] } );
+
+ /**
+ * The absolute y-coordinate position of the Overlay
+ * @config y
+ * @type Number
+ * @default null
+ */
+ this.cfg.addProperty("y", { handler:this.configY, validator:this.cfg.checkNumber, suppressEvent:true, supercedes:["iframe"] } );
+
+ /**
+ * An array with the absolute x and y positions of the Overlay
+ * @config xy
+ * @type Number[]
+ * @default null
+ */
+ this.cfg.addProperty("xy",{ handler:this.configXY, suppressEvent:true, supercedes:["iframe"] } );
+
+ /**
+ * The array of context arguments for context-sensitive positioning. The format is: [id or element, element corner, context corner]. For example, setting this property to ["img1", "tl", "bl"] would align the Overlay's top left corner to the context element's bottom left corner.
+ * @config context
+ * @type Array
+ * @default null
+ */
+ this.cfg.addProperty("context", { handler:this.configContext, suppressEvent:true, supercedes:["iframe"] } );
+
+ /**
+ * True if the Overlay should be anchored to the center of the viewport.
+ * @config fixedcenter
+ * @type Boolean
+ * @default false
+ */
+ this.cfg.addProperty("fixedcenter", { value:false, handler:this.configFixedCenter, validator:this.cfg.checkBoolean, supercedes:["iframe","visible"] } );
+
+ /**
+ * CSS width of the Overlay.
+ * @config width
+ * @type String
+ * @default null
+ */
+ this.cfg.addProperty("width", { handler:this.configWidth, suppressEvent:true, supercedes:["iframe"] } );
+
+ /**
+ * CSS height of the Overlay.
+ * @config height
+ * @type String
+ * @default null
+ */
+ this.cfg.addProperty("height", { handler:this.configHeight, suppressEvent:true, supercedes:["iframe"] } );
+
+ /**
+ * CSS z-index of the Overlay.
+ * @config zIndex
+ * @type Number
+ * @default null
+ */
+ this.cfg.addProperty("zIndex", { value:null, handler:this.configzIndex } );
+
+ /**
+ * True if the Overlay should be prevented from being positioned out of the viewport.
+ * @config constraintoviewport
+ * @type Boolean
+ * @default false
+ */
+ this.cfg.addProperty("constraintoviewport", { value:false, handler:this.configConstrainToViewport, validator:this.cfg.checkBoolean, supercedes:["iframe","x","y","xy"] } );
+
+ /**
+ * True if the Overlay should have an IFRAME shim (for correcting the select z-index bug in IE6 and below).
+ * @config iframe
+ * @type Boolean
+ * @default true for IE6 and below, false for all others
+ */
+ this.cfg.addProperty("iframe", { value:(this.browser == "ie" ? true : false), handler:this.configIframe, validator:this.cfg.checkBoolean, supercedes:["zIndex"] } );
+};
+
+/**
+* Moves the Overlay to the specified position. This function is identical to calling this.cfg.setProperty("xy", [x,y]);
+* @method moveTo
+* @param {Number} x The Overlay's new x position
+* @param {Number} y The Overlay's new y position
+*/
+YAHOO.widget.Overlay.prototype.moveTo = function(x, y) {
+ this.cfg.setProperty("xy",[x,y]);
+};
+
+/**
+* Adds a special CSS class to the Overlay when Mac/Gecko is in use, to work around a Gecko bug where
+* scrollbars cannot be hidden. See https://bugzilla.mozilla.org/show_bug.cgi?id=187435
+* @method hideMacGeckoScrollbars
+*/
+YAHOO.widget.Overlay.prototype.hideMacGeckoScrollbars = function() {
+ YAHOO.util.Dom.removeClass(this.element, "show-scrollbars");
+ YAHOO.util.Dom.addClass(this.element, "hide-scrollbars");
+};
+
+/**
+* Removes a special CSS class from the Overlay when Mac/Gecko is in use, to work around a Gecko bug where
+* scrollbars cannot be hidden. See https://bugzilla.mozilla.org/show_bug.cgi?id=187435
+* @method showMacGeckoScrollbars
+*/
+YAHOO.widget.Overlay.prototype.showMacGeckoScrollbars = function() {
+ YAHOO.util.Dom.removeClass(this.element, "hide-scrollbars");
+ YAHOO.util.Dom.addClass(this.element, "show-scrollbars");
+};
+
+// BEGIN BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* The default event handler fired when the "visible" property is changed. This method is responsible for firing showEvent and hideEvent.
+* @method configVisible
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configVisible = function(type, args, obj) {
+ var visible = args[0];
+
+ var currentVis = YAHOO.util.Dom.getStyle(this.element, "visibility");
+
+ if (currentVis == "inherit") {
+ var e = this.element.parentNode;
+ while (e.nodeType != 9 && e.nodeType != 11) {
+ currentVis = YAHOO.util.Dom.getStyle(e, "visibility");
+ if (currentVis != "inherit") { break; }
+ e = e.parentNode;
+ }
+ if (currentVis == "inherit") {
+ currentVis = "visible";
+ }
+ }
+
+ var effect = this.cfg.getProperty("effect");
+
+ var effectInstances = [];
+ if (effect) {
+ if (effect instanceof Array) {
+ for (var i=0;i<effect.length;i++) {
+ var eff = effect[i];
+ effectInstances[effectInstances.length] = eff.effect(this, eff.duration);
+ }
+ } else {
+ effectInstances[effectInstances.length] = effect.effect(this, effect.duration);
+ }
+ }
+
+ var isMacGecko = (this.platform == "mac" && this.browser == "gecko");
+
+ if (visible) { // Show
+ if (isMacGecko) {
+ this.showMacGeckoScrollbars();
+ }
+
+ if (effect) { // Animate in
+ if (visible) { // Animate in if not showing
+ if (currentVis != "visible" || currentVis === "") {
+ this.beforeShowEvent.fire();
+ for (var j=0;j<effectInstances.length;j++) {
+ var ei = effectInstances[j];
+ if (j === 0 && ! YAHOO.util.Config.alreadySubscribed(ei.animateInCompleteEvent,this.showEvent.fire,this.showEvent)) {
+ ei.animateInCompleteEvent.subscribe(this.showEvent.fire,this.showEvent,true); // Delegate showEvent until end of animateInComplete
+ }
+ ei.animateIn();
+ }
+ }
+ }
+ } else { // Show
+ if (currentVis != "visible" || currentVis === "") {
+ this.beforeShowEvent.fire();
+ YAHOO.util.Dom.setStyle(this.element, "visibility", "visible");
+ this.cfg.refireEvent("iframe");
+ this.showEvent.fire();
+ }
+ }
+
+ } else { // Hide
+ if (isMacGecko) {
+ this.hideMacGeckoScrollbars();
+ }
+
+ if (effect) { // Animate out if showing
+ if (currentVis == "visible") {
+ this.beforeHideEvent.fire();
+ for (var k=0;k<effectInstances.length;k++) {
+ var h = effectInstances[k];
+ if (k === 0 && ! YAHOO.util.Config.alreadySubscribed(h.animateOutCompleteEvent,this.hideEvent.fire,this.hideEvent)) {
+ h.animateOutCompleteEvent.subscribe(this.hideEvent.fire,this.hideEvent,true); // Delegate hideEvent until end of animateOutComplete
+ }
+ h.animateOut();
+ }
+ } else if (currentVis === "") {
+ YAHOO.util.Dom.setStyle(this.element, "visibility", "hidden");
+ }
+ } else { // Simple hide
+ if (currentVis == "visible" || currentVis === "") {
+ this.beforeHideEvent.fire();
+ YAHOO.util.Dom.setStyle(this.element, "visibility", "hidden");
+ this.cfg.refireEvent("iframe");
+ this.hideEvent.fire();
+ }
+ }
+ }
+};
+
+/**
+* Center event handler used for centering on scroll/resize, but only if the Overlay is visible
+* @method doCenterOnDOMEvent
+*/
+YAHOO.widget.Overlay.prototype.doCenterOnDOMEvent = function() {
+ if (this.cfg.getProperty("visible")) {
+ this.center();
+ }
+};
+
+/**
+* The default event handler fired when the "fixedcenter" property is changed.
+* @method configFixedCenter
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configFixedCenter = function(type, args, obj) {
+ var val = args[0];
+
+ if (val) {
+ this.center();
+
+ if (! YAHOO.util.Config.alreadySubscribed(this.beforeShowEvent, this.center, this)) {
+ this.beforeShowEvent.subscribe(this.center, this, true);
+ }
+
+ if (! YAHOO.util.Config.alreadySubscribed(YAHOO.widget.Overlay.windowResizeEvent, this.doCenterOnDOMEvent, this)) {
+ YAHOO.widget.Overlay.windowResizeEvent.subscribe(this.doCenterOnDOMEvent, this, true);
+ }
+
+ if (! YAHOO.util.Config.alreadySubscribed(YAHOO.widget.Overlay.windowScrollEvent, this.doCenterOnDOMEvent, this)) {
+ YAHOO.widget.Overlay.windowScrollEvent.subscribe( this.doCenterOnDOMEvent, this, true);
+ }
+ } else {
+ YAHOO.widget.Overlay.windowResizeEvent.unsubscribe(this.doCenterOnDOMEvent, this);
+ YAHOO.widget.Overlay.windowScrollEvent.unsubscribe(this.doCenterOnDOMEvent, this);
+ }
+};
+
+/**
+* The default event handler fired when the "height" property is changed.
+* @method configHeight
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configHeight = function(type, args, obj) {
+ var height = args[0];
+ var el = this.element;
+ YAHOO.util.Dom.setStyle(el, "height", height);
+ this.cfg.refireEvent("iframe");
+};
+
+/**
+* The default event handler fired when the "width" property is changed.
+* @method configWidth
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configWidth = function(type, args, obj) {
+ var width = args[0];
+ var el = this.element;
+ YAHOO.util.Dom.setStyle(el, "width", width);
+ this.cfg.refireEvent("iframe");
+};
+
+/**
+* The default event handler fired when the "zIndex" property is changed.
+* @method configzIndex
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configzIndex = function(type, args, obj) {
+ var zIndex = args[0];
+
+ var el = this.element;
+
+ if (! zIndex) {
+ zIndex = YAHOO.util.Dom.getStyle(el, "zIndex");
+ if (! zIndex || isNaN(zIndex)) {
+ zIndex = 0;
+ }
+ }
+
+ if (this.iframe) {
+ if (zIndex <= 0) {
+ zIndex = 1;
+ }
+ YAHOO.util.Dom.setStyle(this.iframe, "zIndex", (zIndex-1));
+ }
+
+ YAHOO.util.Dom.setStyle(el, "zIndex", zIndex);
+ this.cfg.setProperty("zIndex", zIndex, true);
+};
+
+/**
+* The default event handler fired when the "xy" property is changed.
+* @method configXY
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configXY = function(type, args, obj) {
+ var pos = args[0];
+ var x = pos[0];
+ var y = pos[1];
+
+ this.cfg.setProperty("x", x);
+ this.cfg.setProperty("y", y);
+
+ this.beforeMoveEvent.fire([x,y]);
+
+ x = this.cfg.getProperty("x");
+ y = this.cfg.getProperty("y");
+
+ this.cfg.refireEvent("iframe");
+ this.moveEvent.fire([x,y]);
+};
+
+/**
+* The default event handler fired when the "x" property is changed.
+* @method configX
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configX = function(type, args, obj) {
+ var x = args[0];
+ var y = this.cfg.getProperty("y");
+
+ this.cfg.setProperty("x", x, true);
+ this.cfg.setProperty("y", y, true);
+
+ this.beforeMoveEvent.fire([x,y]);
+
+ x = this.cfg.getProperty("x");
+ y = this.cfg.getProperty("y");
+
+ YAHOO.util.Dom.setX(this.element, x, true);
+
+ this.cfg.setProperty("xy", [x, y], true);
+
+ this.cfg.refireEvent("iframe");
+ this.moveEvent.fire([x, y]);
+};
+
+/**
+* The default event handler fired when the "y" property is changed.
+* @method configY
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configY = function(type, args, obj) {
+ var x = this.cfg.getProperty("x");
+ var y = args[0];
+
+ this.cfg.setProperty("x", x, true);
+ this.cfg.setProperty("y", y, true);
+
+ this.beforeMoveEvent.fire([x,y]);
+
+ x = this.cfg.getProperty("x");
+ y = this.cfg.getProperty("y");
+
+ YAHOO.util.Dom.setY(this.element, y, true);
+
+ this.cfg.setProperty("xy", [x, y], true);
+
+ this.cfg.refireEvent("iframe");
+ this.moveEvent.fire([x, y]);
+};
+
+/**
+* Shows the iframe shim, if it has been enabled
+* @method showIframe
+*/
+YAHOO.widget.Overlay.prototype.showIframe = function() {
+ if (this.iframe) {
+ this.iframe.style.display = "block";
+ }
+};
+
+/**
+* Hides the iframe shim, if it has been enabled
+* @method hideIframe
+*/
+YAHOO.widget.Overlay.prototype.hideIframe = function() {
+ if (this.iframe) {
+ this.iframe.style.display = "none";
+ }
+};
+
+/**
+* The default event handler fired when the "iframe" property is changed.
+* @method configIframe
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configIframe = function(type, args, obj) {
+
+ var val = args[0];
+
+ if (val) { // IFRAME shim is enabled
+
+ if (! YAHOO.util.Config.alreadySubscribed(this.showEvent, this.showIframe, this)) {
+ this.showEvent.subscribe(this.showIframe, this, true);
+ }
+ if (! YAHOO.util.Config.alreadySubscribed(this.hideEvent, this.hideIframe, this)) {
+ this.hideEvent.subscribe(this.hideIframe, this, true);
+ }
+
+ var x = this.cfg.getProperty("x");
+ var y = this.cfg.getProperty("y");
+
+ if (! x || ! y) {
+ this.syncPosition();
+ x = this.cfg.getProperty("x");
+ y = this.cfg.getProperty("y");
+ }
+
+ if (! isNaN(x) && ! isNaN(y)) {
+ if (! this.iframe) {
+ this.iframe = document.createElement("iframe");
+ if (this.isSecure) {
+ this.iframe.src = YAHOO.widget.Overlay.IFRAME_SRC;
+ }
+
+ var parent = this.element.parentNode;
+ if (parent) {
+ parent.appendChild(this.iframe);
+ } else {
+ document.body.appendChild(this.iframe);
+ }
+
+ YAHOO.util.Dom.setStyle(this.iframe, "position", "absolute");
+ YAHOO.util.Dom.setStyle(this.iframe, "border", "none");
+ YAHOO.util.Dom.setStyle(this.iframe, "margin", "0");
+ YAHOO.util.Dom.setStyle(this.iframe, "padding", "0");
+ YAHOO.util.Dom.setStyle(this.iframe, "opacity", "0");
+ if (this.cfg.getProperty("visible")) {
+ this.showIframe();
+ } else {
+ this.hideIframe();
+ }
+ }
+
+ var iframeDisplay = YAHOO.util.Dom.getStyle(this.iframe, "display");
+
+ if (iframeDisplay == "none") {
+ this.iframe.style.display = "block";
+ }
+
+ YAHOO.util.Dom.setXY(this.iframe, [x,y]);
+
+ var width = this.element.clientWidth;
+ var height = this.element.clientHeight;
+
+ YAHOO.util.Dom.setStyle(this.iframe, "width", (width+2) + "px");
+ YAHOO.util.Dom.setStyle(this.iframe, "height", (height+2) + "px");
+
+ if (iframeDisplay == "none") {
+ this.iframe.style.display = "none";
+ }
+ }
+ } else {
+ if (this.iframe) {
+ this.iframe.style.display = "none";
+ }
+ this.showEvent.unsubscribe(this.showIframe, this);
+ this.hideEvent.unsubscribe(this.hideIframe, this);
+ }
+};
+
+
+/**
+* The default event handler fired when the "constraintoviewport" property is changed.
+* @method configConstrainToViewport
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configConstrainToViewport = function(type, args, obj) {
+ var val = args[0];
+ if (val) {
+ if (! YAHOO.util.Config.alreadySubscribed(this.beforeMoveEvent, this.enforceConstraints, this)) {
+ this.beforeMoveEvent.subscribe(this.enforceConstraints, this, true);
+ }
+ } else {
+ this.beforeMoveEvent.unsubscribe(this.enforceConstraints, this);
+ }
+};
+
+/**
+* The default event handler fired when the "context" property is changed.
+* @method configContext
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.configContext = function(type, args, obj) {
+ var contextArgs = args[0];
+
+ if (contextArgs) {
+ var contextEl = contextArgs[0];
+ var elementMagnetCorner = contextArgs[1];
+ var contextMagnetCorner = contextArgs[2];
+
+ if (contextEl) {
+ if (typeof contextEl == "string") {
+ this.cfg.setProperty("context", [document.getElementById(contextEl),elementMagnetCorner,contextMagnetCorner], true);
+ }
+
+ if (elementMagnetCorner && contextMagnetCorner) {
+ this.align(elementMagnetCorner, contextMagnetCorner);
+ }
+ }
+ }
+};
+
+
+// END BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* Aligns the Overlay to its context element using the specified corner points (represented by the constants TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, and BOTTOM_RIGHT.
+* @method align
+* @param {String} elementAlign The String representing the corner of the Overlay that should be aligned to the context element
+* @param {String} contextAlign The corner of the context element that the elementAlign corner should stick to.
+*/
+YAHOO.widget.Overlay.prototype.align = function(elementAlign, contextAlign) {
+ var contextArgs = this.cfg.getProperty("context");
+ if (contextArgs) {
+ var context = contextArgs[0];
+
+ var element = this.element;
+ var me = this;
+
+ if (! elementAlign) {
+ elementAlign = contextArgs[1];
+ }
+
+ if (! contextAlign) {
+ contextAlign = contextArgs[2];
+ }
+
+ if (element && context) {
+ var elementRegion = YAHOO.util.Dom.getRegion(element);
+ var contextRegion = YAHOO.util.Dom.getRegion(context);
+
+ var doAlign = function(v,h) {
+ switch (elementAlign) {
+ case YAHOO.widget.Overlay.TOP_LEFT:
+ me.moveTo(h,v);
+ break;
+ case YAHOO.widget.Overlay.TOP_RIGHT:
+ me.moveTo(h-element.offsetWidth,v);
+ break;
+ case YAHOO.widget.Overlay.BOTTOM_LEFT:
+ me.moveTo(h,v-element.offsetHeight);
+ break;
+ case YAHOO.widget.Overlay.BOTTOM_RIGHT:
+ me.moveTo(h-element.offsetWidth,v-element.offsetHeight);
+ break;
+ }
+ };
+
+ switch (contextAlign) {
+ case YAHOO.widget.Overlay.TOP_LEFT:
+ doAlign(contextRegion.top, contextRegion.left);
+ break;
+ case YAHOO.widget.Overlay.TOP_RIGHT:
+ doAlign(contextRegion.top, contextRegion.right);
+ break;
+ case YAHOO.widget.Overlay.BOTTOM_LEFT:
+ doAlign(contextRegion.bottom, contextRegion.left);
+ break;
+ case YAHOO.widget.Overlay.BOTTOM_RIGHT:
+ doAlign(contextRegion.bottom, contextRegion.right);
+ break;
+ }
+ }
+ }
+};
+
+/**
+* The default event handler executed when the moveEvent is fired, if the "constraintoviewport" is set to true.
+* @method enforceConstraints
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Overlay.prototype.enforceConstraints = function(type, args, obj) {
+ var pos = args[0];
+
+ var x = pos[0];
+ var y = pos[1];
+
+ var offsetHeight = this.element.offsetHeight;
+ var offsetWidth = this.element.offsetWidth;
+
+ var viewPortWidth = YAHOO.util.Dom.getViewportWidth();
+ var viewPortHeight = YAHOO.util.Dom.getViewportHeight();
+
+ var scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
+ var scrollY = document.documentElement.scrollTop || document.body.scrollTop;
+
+ var topConstraint = scrollY + 10;
+ var leftConstraint = scrollX + 10;
+ var bottomConstraint = scrollY + viewPortHeight - offsetHeight - 10;
+ var rightConstraint = scrollX + viewPortWidth - offsetWidth - 10;
+
+ if (x < leftConstraint) {
+ x = leftConstraint;
+ } else if (x > rightConstraint) {
+ x = rightConstraint;
+ }
+
+ if (y < topConstraint) {
+ y = topConstraint;
+ } else if (y > bottomConstraint) {
+ y = bottomConstraint;
+ }
+
+ this.cfg.setProperty("x", x, true);
+ this.cfg.setProperty("y", y, true);
+ this.cfg.setProperty("xy", [x,y], true);
+};
+
+/**
+* Centers the container in the viewport.
+* @method center
+*/
+YAHOO.widget.Overlay.prototype.center = function() {
+ var scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
+ var scrollY = document.documentElement.scrollTop || document.body.scrollTop;
+
+ var viewPortWidth = YAHOO.util.Dom.getClientWidth();
+ var viewPortHeight = YAHOO.util.Dom.getClientHeight();
+
+ var elementWidth = this.element.offsetWidth;
+ var elementHeight = this.element.offsetHeight;
+
+ var x = (viewPortWidth / 2) - (elementWidth / 2) + scrollX;
+ var y = (viewPortHeight / 2) - (elementHeight / 2) + scrollY;
+
+ this.cfg.setProperty("xy", [parseInt(x, 10), parseInt(y, 10)]);
+
+ this.cfg.refireEvent("iframe");
+};
+
+/**
+* Synchronizes the Panel's "xy", "x", and "y" properties with the Panel's position in the DOM. This is primarily used to update position information during drag & drop.
+* @method syncPosition
+*/
+YAHOO.widget.Overlay.prototype.syncPosition = function() {
+ var pos = YAHOO.util.Dom.getXY(this.element);
+ this.cfg.setProperty("x", pos[0], true);
+ this.cfg.setProperty("y", pos[1], true);
+ this.cfg.setProperty("xy", pos, true);
+};
+
+/**
+* Event handler fired when the resize monitor element is resized.
+* @method onDomResize
+* @param {DOMEvent} e The resize DOM event
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.Overlay.prototype.onDomResize = function(e, obj) {
+ YAHOO.widget.Overlay.superclass.onDomResize.call(this, e, obj);
+ var me = this;
+ setTimeout(function() {
+ me.syncPosition();
+ me.cfg.refireEvent("iframe");
+ me.cfg.refireEvent("context");
+ }, 0);
+};
+
+/**
+* Removes the Overlay element from the DOM and sets all child elements to null.
+* @method destroy
+*/
+YAHOO.widget.Overlay.prototype.destroy = function() {
+ if (this.iframe) {
+ this.iframe.parentNode.removeChild(this.iframe);
+ }
+
+ this.iframe = null;
+
+ YAHOO.widget.Overlay.windowResizeEvent.unsubscribe(this.doCenterOnDOMEvent, this);
+ YAHOO.widget.Overlay.windowScrollEvent.unsubscribe(this.doCenterOnDOMEvent, this);
+
+ YAHOO.widget.Overlay.superclass.destroy.call(this);
+};
+
+/**
+* Returns a String representation of the object.
+* @method toString
+* @return {String} The string representation of the Overlay.
+*/
+YAHOO.widget.Overlay.prototype.toString = function() {
+ return "Overlay " + this.id;
+};
+
+/**
+* A singleton CustomEvent used for reacting to the DOM event for window scroll
+* @event YAHOO.widget.Overlay.windowScrollEvent
+*/
+YAHOO.widget.Overlay.windowScrollEvent = new YAHOO.util.CustomEvent("windowScroll");
+
+/**
+* A singleton CustomEvent used for reacting to the DOM event for window resize
+* @event YAHOO.widget.Overlay.windowResizeEvent
+*/
+YAHOO.widget.Overlay.windowResizeEvent = new YAHOO.util.CustomEvent("windowResize");
+
+/**
+* The DOM event handler used to fire the CustomEvent for window scroll
+* @method YAHOO.widget.Overlay.windowScrollHandler
+* @static
+* @param {DOMEvent} e The DOM scroll event
+*/
+YAHOO.widget.Overlay.windowScrollHandler = function(e) {
+ if (YAHOO.widget.Module.prototype.browser == "ie" || YAHOO.widget.Module.prototype.browser == "ie7") {
+ if (! window.scrollEnd) {
+ window.scrollEnd = -1;
+ }
+ clearTimeout(window.scrollEnd);
+ window.scrollEnd = setTimeout(function() { YAHOO.widget.Overlay.windowScrollEvent.fire(); }, 1);
+ } else {
+ YAHOO.widget.Overlay.windowScrollEvent.fire();
+ }
+};
+
+/**
+* The DOM event handler used to fire the CustomEvent for window resize
+* @method YAHOO.widget.Overlay.windowResizeHandler
+* @static
+* @param {DOMEvent} e The DOM resize event
+*/
+YAHOO.widget.Overlay.windowResizeHandler = function(e) {
+ if (YAHOO.widget.Module.prototype.browser == "ie" || YAHOO.widget.Module.prototype.browser == "ie7") {
+ if (! window.resizeEnd) {
+ window.resizeEnd = -1;
+ }
+ clearTimeout(window.resizeEnd);
+ window.resizeEnd = setTimeout(function() { YAHOO.widget.Overlay.windowResizeEvent.fire(); }, 100);
+ } else {
+ YAHOO.widget.Overlay.windowResizeEvent.fire();
+ }
+};
+
+/**
+* A boolean that indicated whether the window resize and scroll events have already been subscribed to.
+* @property YAHOO.widget.Overlay._initialized
+* @private
+* @type Boolean
+*/
+YAHOO.widget.Overlay._initialized = null;
+
+if (YAHOO.widget.Overlay._initialized === null) {
+ YAHOO.util.Event.addListener(window, "scroll", YAHOO.widget.Overlay.windowScrollHandler);
+ YAHOO.util.Event.addListener(window, "resize", YAHOO.widget.Overlay.windowResizeHandler);
+
+ YAHOO.widget.Overlay._initialized = true;
+}
+
+/**
+* OverlayManager is used for maintaining the focus status of multiple Overlays.* @namespace YAHOO.widget
+* @namespace YAHOO.widget
+* @class OverlayManager
+* @constructor
+* @param {Array} overlays Optional. A collection of Overlays to register with the manager.
+* @param {Object} userConfig The object literal representing the user configuration of the OverlayManager
+*/
+YAHOO.widget.OverlayManager = function(userConfig) {
+ this.init(userConfig);
+};
+
+/**
+* The CSS class representing a focused Overlay
+* @property YAHOO.widget.OverlayManager.CSS_FOCUSED
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.OverlayManager.CSS_FOCUSED = "focused";
+
+YAHOO.widget.OverlayManager.prototype = {
+ /**
+ * The class's constructor function
+ * @property contructor
+ * @type Function
+ */
+ constructor : YAHOO.widget.OverlayManager,
+
+ /**
+ * The array of Overlays that are currently registered
+ * @property overlays
+ * @type YAHOO.widget.Overlay[]
+ */
+ overlays : null,
+
+ /**
+ * Initializes the default configuration of the OverlayManager
+ * @method initDefaultConfig
+ */
+ initDefaultConfig : function() {
+ /**
+ * The collection of registered Overlays in use by the OverlayManager
+ * @config overlays
+ * @type YAHOO.widget.Overlay[]
+ * @default null
+ */
+ this.cfg.addProperty("overlays", { suppressEvent:true } );
+
+ /**
+ * The default DOM event that should be used to focus an Overlay
+ * @config focusevent
+ * @type String
+ * @default "mousedown"
+ */
+ this.cfg.addProperty("focusevent", { value:"mousedown" } );
+ },
+
+ /**
+ * Initializes the OverlayManager
+ * @method init
+ * @param {YAHOO.widget.Overlay[]} overlays Optional. A collection of Overlays to register with the manager.
+ * @param {Object} userConfig The object literal representing the user configuration of the OverlayManager
+ */
+ init : function(userConfig) {
+ /**
+ * The OverlayManager's Config object used for monitoring configuration properties.
+ * @property cfg
+ * @type YAHOO.util.Config
+ */
+ this.cfg = new YAHOO.util.Config(this);
+
+ this.initDefaultConfig();
+
+ if (userConfig) {
+ this.cfg.applyConfig(userConfig, true);
+ }
+ this.cfg.fireQueue();
+
+ /**
+ * The currently activated Overlay
+ * @property activeOverlay
+ * @private
+ * @type YAHOO.widget.Overlay
+ */
+ var activeOverlay = null;
+
+ /**
+ * Returns the currently focused Overlay
+ * @method getActive
+ * @return {YAHOO.widget.Overlay} The currently focused Overlay
+ */
+ this.getActive = function() {
+ return activeOverlay;
+ };
+
+ /**
+ * Focuses the specified Overlay
+ * @method focus
+ * @param {YAHOO.widget.Overlay} overlay The Overlay to focus
+ * @param {String} overlay The id of the Overlay to focus
+ */
+ this.focus = function(overlay) {
+ var o = this.find(overlay);
+ if (o) {
+ this.blurAll();
+ activeOverlay = o;
+ YAHOO.util.Dom.addClass(activeOverlay.element, YAHOO.widget.OverlayManager.CSS_FOCUSED);
+ this.overlays.sort(this.compareZIndexDesc);
+ var topZIndex = YAHOO.util.Dom.getStyle(this.overlays[0].element, "zIndex");
+ if (! isNaN(topZIndex) && this.overlays[0] != overlay) {
+ activeOverlay.cfg.setProperty("zIndex", (parseInt(topZIndex, 10) + 2));
+ }
+ this.overlays.sort(this.compareZIndexDesc);
+ }
+ };
+
+ /**
+ * Removes the specified Overlay from the manager
+ * @method remove
+ * @param {YAHOO.widget.Overlay} overlay The Overlay to remove
+ * @param {String} overlay The id of the Overlay to remove
+ */
+ this.remove = function(overlay) {
+ var o = this.find(overlay);
+ if (o) {
+ var originalZ = YAHOO.util.Dom.getStyle(o.element, "zIndex");
+ o.cfg.setProperty("zIndex", -1000, true);
+ this.overlays.sort(this.compareZIndexDesc);
+ this.overlays = this.overlays.slice(0, this.overlays.length-1);
+ o.cfg.setProperty("zIndex", originalZ, true);
+
+ o.cfg.setProperty("manager", null);
+ o.focusEvent = null;
+ o.blurEvent = null;
+ o.focus = null;
+ o.blur = null;
+ }
+ };
+
+ /**
+ * Removes focus from all registered Overlays in the manager
+ * @method blurAll
+ */
+ this.blurAll = function() {
+ activeOverlay = null;
+ for (var o=0;o<this.overlays.length;o++) {
+ YAHOO.util.Dom.removeClass(this.overlays[o].element, YAHOO.widget.OverlayManager.CSS_FOCUSED);
+ }
+ };
+
+ var overlays = this.cfg.getProperty("overlays");
+
+ if (! this.overlays) {
+ this.overlays = [];
+ }
+
+ if (overlays) {
+ this.register(overlays);
+ this.overlays.sort(this.compareZIndexDesc);
+ }
+ },
+
+ /**
+ * Registers an Overlay or an array of Overlays with the manager. Upon registration, the Overlay receives functions for focus and blur, along with CustomEvents for each.
+ * @method register
+ * @param {YAHOO.widget.Overlay} overlay An Overlay to register with the manager.
+ * @param {YAHOO.widget.Overlay[]} overlay An array of Overlays to register with the manager.
+ * @return {Boolean} True if any Overlays are registered.
+ */
+ register : function(overlay) {
+ if (overlay instanceof YAHOO.widget.Overlay) {
+ overlay.cfg.addProperty("manager", { value:this } );
+
+ overlay.focusEvent = new YAHOO.util.CustomEvent("focus");
+ overlay.blurEvent = new YAHOO.util.CustomEvent("blur");
+
+ var mgr=this;
+
+ overlay.focus = function() {
+ mgr.focus(this);
+ this.focusEvent.fire();
+ };
+
+ overlay.blur = function() {
+ mgr.blurAll();
+ this.blurEvent.fire();
+ };
+
+ var focusOnDomEvent = function(e,obj) {
+ overlay.focus();
+ };
+
+ var focusevent = this.cfg.getProperty("focusevent");
+ YAHOO.util.Event.addListener(overlay.element,focusevent,focusOnDomEvent,this,true);
+
+ var zIndex = YAHOO.util.Dom.getStyle(overlay.element, "zIndex");
+ if (! isNaN(zIndex)) {
+ overlay.cfg.setProperty("zIndex", parseInt(zIndex, 10));
+ } else {
+ overlay.cfg.setProperty("zIndex", 0);
+ }
+
+ this.overlays.push(overlay);
+ return true;
+ } else if (overlay instanceof Array) {
+ var regcount = 0;
+ for (var i=0;i<overlay.length;i++) {
+ if (this.register(overlay[i])) {
+ regcount++;
+ }
+ }
+ if (regcount > 0) {
+ return true;
+ }
+ } else {
+ return false;
+ }
+ },
+
+ /**
+ * Attempts to locate an Overlay by instance or ID.
+ * @method find
+ * @param {YAHOO.widget.Overlay} overlay An Overlay to locate within the manager
+ * @param {String} overlay An Overlay id to locate within the manager
+ * @return {YAHOO.widget.Overlay} The requested Overlay, if found, or null if it cannot be located.
+ */
+ find : function(overlay) {
+ if (overlay instanceof YAHOO.widget.Overlay) {
+ for (var o=0;o<this.overlays.length;o++) {
+ if (this.overlays[o] == overlay) {
+ return this.overlays[o];
+ }
+ }
+ } else if (typeof overlay == "string") {
+ for (var p=0;p<this.overlays.length;p++) {
+ if (this.overlays[p].id == overlay) {
+ return this.overlays[p];
+ }
+ }
+ }
+ return null;
+ },
+
+ /**
+ * Used for sorting the manager's Overlays by z-index.
+ * @method compareZIndexDesc
+ * @private
+ * @return {Number} 0, 1, or -1, depending on where the Overlay should fall in the stacking order.
+ */
+ compareZIndexDesc : function(o1, o2) {
+ var zIndex1 = o1.cfg.getProperty("zIndex");
+ var zIndex2 = o2.cfg.getProperty("zIndex");
+
+ if (zIndex1 > zIndex2) {
+ return -1;
+ } else if (zIndex1 < zIndex2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ },
+
+ /**
+ * Shows all Overlays in the manager.
+ * @method showAll
+ */
+ showAll : function() {
+ for (var o=0;o<this.overlays.length;o++) {
+ this.overlays[o].show();
+ }
+ },
+
+ /**
+ * Hides all Overlays in the manager.
+ * @method hideAll
+ */
+ hideAll : function() {
+ for (var o=0;o<this.overlays.length;o++) {
+ this.overlays[o].hide();
+ }
+ },
+
+
+ /**
+ * Returns a string representation of the object.
+ * @method toString
+ * @return {String} The string representation of the OverlayManager
+ */
+ toString : function() {
+ return "OverlayManager";
+ }
+
+};
+
+/**
+* KeyListener is a utility that provides an easy interface for listening for keydown/keyup events fired against DOM elements.
+* @namespace YAHOO.util
+* @class KeyListener
+* @constructor
+* @param {HTMLElement} attachTo The element or element ID to which the key event should be attached
+* @param {String} attachTo The element or element ID to which the key event should be attached
+* @param {Object} keyData The object literal representing the key(s) to detect. Possible attributes are shift(boolean), alt(boolean), ctrl(boolean) and keys(either an int or an array of ints representing keycodes).
+* @param {Function} handler The CustomEvent handler to fire when the key event is detected
+* @param {Object} handler An object literal representing the handler.
+* @param {String} event Optional. The event (keydown or keyup) to listen for. Defaults automatically to keydown.
+*/
+YAHOO.util.KeyListener = function(attachTo, keyData, handler, event) {
+ if (! event) {
+ event = YAHOO.util.KeyListener.KEYDOWN;
+ }
+
+ /**
+ * The CustomEvent fired internally when a key is pressed
+ * @event keyEvent
+ * @private
+ * @param {Object} keyData The object literal representing the key(s) to detect. Possible attributes are shift(boolean), alt(boolean), ctrl(boolean) and keys(either an int or an array of ints representing keycodes).
+ */
+ var keyEvent = new YAHOO.util.CustomEvent("keyPressed");
+
+ /**
+ * The CustomEvent fired when the KeyListener is enabled via the enable() function
+ * @event enabledEvent
+ * @param {Object} keyData The object literal representing the key(s) to detect. Possible attributes are shift(boolean), alt(boolean), ctrl(boolean) and keys(either an int or an array of ints representing keycodes).
+ */
+ this.enabledEvent = new YAHOO.util.CustomEvent("enabled");
+
+ /**
+ * The CustomEvent fired when the KeyListener is disabled via the disable() function
+ * @event disabledEvent
+ * @param {Object} keyData The object literal representing the key(s) to detect. Possible attributes are shift(boolean), alt(boolean), ctrl(boolean) and keys(either an int or an array of ints representing keycodes).
+ */
+ this.disabledEvent = new YAHOO.util.CustomEvent("disabled");
+
+ if (typeof attachTo == 'string') {
+ attachTo = document.getElementById(attachTo);
+ }
+
+ if (typeof handler == 'function') {
+ keyEvent.subscribe(handler);
+ } else {
+ keyEvent.subscribe(handler.fn, handler.scope, handler.correctScope);
+ }
+
+ /**
+ * Handles the key event when a key is pressed.
+ * @method handleKeyPress
+ * @param {DOMEvent} e The keypress DOM event
+ * @param {Object} obj The DOM event scope object
+ * @private
+ */
+ function handleKeyPress(e, obj) {
+ if (! keyData.shift) {
+ keyData.shift = false;
+ }
+ if (! keyData.alt) {
+ keyData.alt = false;
+ }
+ if (! keyData.ctrl) {
+ keyData.ctrl = false;
+ }
+
+ // check held down modifying keys first
+ if (e.shiftKey == keyData.shift &&
+ e.altKey == keyData.alt &&
+ e.ctrlKey == keyData.ctrl) { // if we pass this, all modifiers match
+
+ var dataItem;
+ var keyPressed;
+
+ if (keyData.keys instanceof Array) {
+ for (var i=0;i<keyData.keys.length;i++) {
+ dataItem = keyData.keys[i];
+
+ if (dataItem == e.charCode ) {
+ keyEvent.fire(e.charCode, e);
+ break;
+ } else if (dataItem == e.keyCode) {
+ keyEvent.fire(e.keyCode, e);
+ break;
+ }
+ }
+ } else {
+ dataItem = keyData.keys;
+
+ if (dataItem == e.charCode ) {
+ keyEvent.fire(e.charCode, e);
+ } else if (dataItem == e.keyCode) {
+ keyEvent.fire(e.keyCode, e);
+ }
+ }
+ }
+ }
+
+ /**
+ * Enables the KeyListener by attaching the DOM event listeners to the target DOM element
+ * @method enable
+ */
+ this.enable = function() {
+ if (! this.enabled) {
+ YAHOO.util.Event.addListener(attachTo, event, handleKeyPress);
+ this.enabledEvent.fire(keyData);
+ }
+ /**
+ * Boolean indicating the enabled/disabled state of the Tooltip
+ * @property enabled
+ * @type Boolean
+ */
+ this.enabled = true;
+ };
+
+ /**
+ * Disables the KeyListener by removing the DOM event listeners from the target DOM element
+ * @method disable
+ */
+ this.disable = function() {
+ if (this.enabled) {
+ YAHOO.util.Event.removeListener(attachTo, event, handleKeyPress);
+ this.disabledEvent.fire(keyData);
+ }
+ this.enabled = false;
+ };
+
+ /**
+ * Returns a String representation of the object.
+ * @method toString
+ * @return {String} The string representation of the KeyListener
+ */
+ this.toString = function() {
+ return "KeyListener [" + keyData.keys + "] " + attachTo.tagName + (attachTo.id ? "[" + attachTo.id + "]" : "");
+ };
+
+};
+
+/**
+* Constant representing the DOM "keydown" event.
+* @property YAHOO.util.KeyListener.KEYDOWN
+* @static
+* @final
+* @type String
+*/
+YAHOO.util.KeyListener.KEYDOWN = "keydown";
+
+/**
+* Constant representing the DOM "keyup" event.
+* @property YAHOO.util.KeyListener.KEYUP
+* @static
+* @final
+* @type String
+*/
+YAHOO.util.KeyListener.KEYUP = "keyup";
+
+/**
+* Tooltip is an implementation of Overlay that behaves like an OS tooltip, displaying when the user mouses over a particular element, and disappearing on mouse out.
+* @namespace YAHOO.widget
+* @class Tooltip
+* @extends YAHOO.widget.Overlay
+* @constructor
+* @param {String} el The element ID representing the Tooltip <em>OR</em>
+* @param {HTMLElement} el The element representing the Tooltip
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this Overlay. See configuration documentation for more details.
+*/
+YAHOO.widget.Tooltip = function(el, userConfig) {
+ YAHOO.widget.Tooltip.superclass.constructor.call(this, el, userConfig);
+};
+
+YAHOO.extend(YAHOO.widget.Tooltip, YAHOO.widget.Overlay);
+
+/**
+* Constant representing the Tooltip CSS class
+* @property YAHOO.widget.Tooltip.CSS_TOOLTIP
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Tooltip.CSS_TOOLTIP = "tt";
+
+/**
+* The Tooltip initialization method. This method is automatically called by the constructor. A Tooltip is automatically rendered by the init method, and it also is set to be invisible by default, and constrained to viewport by default as well.
+* @method init
+* @param {String} el The element ID representing the Tooltip <em>OR</em>
+* @param {HTMLElement} el The element representing the Tooltip
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this Tooltip. See configuration documentation for more details.
+*/
+YAHOO.widget.Tooltip.prototype.init = function(el, userConfig) {
+ if (document.readyState && document.readyState != "complete") {
+ var deferredInit = function() {
+ this.init(el, userConfig);
+ };
+ YAHOO.util.Event.addListener(window, "load", deferredInit, this, true);
+ } else {
+ YAHOO.widget.Tooltip.superclass.init.call(this, el);
+
+ this.beforeInitEvent.fire(YAHOO.widget.Tooltip);
+
+ YAHOO.util.Dom.addClass(this.element, YAHOO.widget.Tooltip.CSS_TOOLTIP);
+
+ if (userConfig) {
+ this.cfg.applyConfig(userConfig, true);
+ }
+
+ this.cfg.queueProperty("visible",false);
+ this.cfg.queueProperty("constraintoviewport",true);
+
+ this.setBody("");
+ this.render(this.cfg.getProperty("container"));
+
+ this.initEvent.fire(YAHOO.widget.Tooltip);
+ }
+};
+
+/**
+* Initializes the class's configurable properties which can be changed using the Overlay's Config object (cfg).
+* @method initDefaultConfig
+*/
+YAHOO.widget.Tooltip.prototype.initDefaultConfig = function() {
+ YAHOO.widget.Tooltip.superclass.initDefaultConfig.call(this);
+
+ /**
+ * Specifies whether the Tooltip should be kept from overlapping its context element.
+ * @config preventoverlap
+ * @type Boolean
+ * @default true
+ */
+ this.cfg.addProperty("preventoverlap", { value:true, validator:this.cfg.checkBoolean, supercedes:["x","y","xy"] } );
+
+ /**
+ * The number of milliseconds to wait before showing a Tooltip on mouseover.
+ * @config showdelay
+ * @type Number
+ * @default 200
+ */
+ this.cfg.addProperty("showdelay", { value:200, handler:this.configShowDelay, validator:this.cfg.checkNumber } );
+
+ /**
+ * The number of milliseconds to wait before automatically dismissing a Tooltip after the mouse has been resting on the context element.
+ * @config autodismissdelay
+ * @type Number
+ * @default 5000
+ */
+ this.cfg.addProperty("autodismissdelay", { value:5000, handler:this.configAutoDismissDelay, validator:this.cfg.checkNumber } );
+
+ /**
+ * The number of milliseconds to wait before hiding a Tooltip on mouseover.
+ * @config hidedelay
+ * @type Number
+ * @default 250
+ */
+ this.cfg.addProperty("hidedelay", { value:250, handler:this.configHideDelay, validator:this.cfg.checkNumber } );
+
+ /**
+ * Specifies the Tooltip's text.
+ * @config text
+ * @type String
+ * @default null
+ */
+ this.cfg.addProperty("text", { handler:this.configText, suppressEvent:true } );
+
+ /**
+ * Specifies the container element that the Tooltip's markup should be rendered into.
+ * @config container
+ * @type HTMLElement/String
+ * @default document.body
+ */
+ this.cfg.addProperty("container", { value:document.body, handler:this.configContainer } );
+
+ /**
+ * Specifies the element or elements that the Tooltip should be anchored to on mouseover.
+ * @config context
+ * @type HTMLElement[]/String[]
+ * @default null
+ */
+
+};
+
+// BEGIN BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* The default event handler fired when the "text" property is changed.
+* @method configText
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Tooltip.prototype.configText = function(type, args, obj) {
+ var text = args[0];
+ if (text) {
+ this.setBody(text);
+ }
+};
+
+/**
+* The default event handler fired when the "container" property is changed.
+* @method configContainer
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Tooltip.prototype.configContainer = function(type, args, obj) {
+ var container = args[0];
+ if (typeof container == 'string') {
+ this.cfg.setProperty("container", document.getElementById(container), true);
+ }
+};
+
+/**
+* The default event handler fired when the "context" property is changed.
+* @method configContext
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Tooltip.prototype.configContext = function(type, args, obj) {
+ var context = args[0];
+ if (context) {
+
+ // Normalize parameter into an array
+ if (! (context instanceof Array)) {
+ if (typeof context == "string") {
+ this.cfg.setProperty("context", [document.getElementById(context)], true);
+ } else { // Assuming this is an element
+ this.cfg.setProperty("context", [context], true);
+ }
+ context = this.cfg.getProperty("context");
+ }
+
+
+ // Remove any existing mouseover/mouseout listeners
+ if (this._context) {
+ for (var c=0;c<this._context.length;++c) {
+ var el = this._context[c];
+ YAHOO.util.Event.removeListener(el, "mouseover", this.onContextMouseOver);
+ YAHOO.util.Event.removeListener(el, "mousemove", this.onContextMouseMove);
+ YAHOO.util.Event.removeListener(el, "mouseout", this.onContextMouseOut);
+ }
+ }
+
+ // Add mouseover/mouseout listeners to context elements
+ this._context = context;
+ for (var d=0;d<this._context.length;++d) {
+ var el2 = this._context[d];
+ YAHOO.util.Event.addListener(el2, "mouseover", this.onContextMouseOver, this);
+ YAHOO.util.Event.addListener(el2, "mousemove", this.onContextMouseMove, this);
+ YAHOO.util.Event.addListener(el2, "mouseout", this.onContextMouseOut, this);
+ }
+ }
+};
+
+// END BUILT-IN PROPERTY EVENT HANDLERS //
+
+// BEGIN BUILT-IN DOM EVENT HANDLERS //
+
+/**
+* The default event handler fired when the user moves the mouse while over the context element.
+* @method onContextMouseMove
+* @param {DOMEvent} e The current DOM event
+* @param {Object} obj The object argument
+*/
+YAHOO.widget.Tooltip.prototype.onContextMouseMove = function(e, obj) {
+ obj.pageX = YAHOO.util.Event.getPageX(e);
+ obj.pageY = YAHOO.util.Event.getPageY(e);
+
+};
+
+/**
+* The default event handler fired when the user mouses over the context element.
+* @method onContextMouseOver
+* @param {DOMEvent} e The current DOM event
+* @param {Object} obj The object argument
+*/
+YAHOO.widget.Tooltip.prototype.onContextMouseOver = function(e, obj) {
+
+ if (obj.hideProcId) {
+ clearTimeout(obj.hideProcId);
+ obj.hideProcId = null;
+ }
+
+ var context = this;
+ YAHOO.util.Event.addListener(context, "mousemove", obj.onContextMouseMove, obj);
+
+ if (context.title) {
+ obj._tempTitle = context.title;
+ context.title = "";
+ }
+
+ /**
+ * The unique process ID associated with the thread responsible for showing the Tooltip.
+ * @type int
+ */
+ obj.showProcId = obj.doShow(e, context);
+};
+
+/**
+* The default event handler fired when the user mouses out of the context element.
+* @method onContextMouseOut
+* @param {DOMEvent} e The current DOM event
+* @param {Object} obj The object argument
+*/
+YAHOO.widget.Tooltip.prototype.onContextMouseOut = function(e, obj) {
+ var el = this;
+
+ if (obj._tempTitle) {
+ el.title = obj._tempTitle;
+ obj._tempTitle = null;
+ }
+
+ if (obj.showProcId) {
+ clearTimeout(obj.showProcId);
+ obj.showProcId = null;
+ }
+
+ if (obj.hideProcId) {
+ clearTimeout(obj.hideProcId);
+ obj.hideProcId = null;
+ }
+
+
+ obj.hideProcId = setTimeout(function() {
+ obj.hide();
+ }, obj.cfg.getProperty("hidedelay"));
+};
+
+// END BUILT-IN DOM EVENT HANDLERS //
+
+/**
+* Processes the showing of the Tooltip by setting the timeout delay and offset of the Tooltip.
+* @method doShow
+* @param {DOMEvent} e The current DOM event
+* @return {Number} The process ID of the timeout function associated with doShow
+*/
+YAHOO.widget.Tooltip.prototype.doShow = function(e, context) {
+
+ var yOffset = 25;
+ if (this.browser == "opera" && context.tagName == "A") {
+ yOffset += 12;
+ }
+
+ var me = this;
+ return setTimeout(
+ function() {
+ if (me._tempTitle) {
+ me.setBody(me._tempTitle);
+ } else {
+ me.cfg.refireEvent("text");
+ }
+
+ me.moveTo(me.pageX, me.pageY + yOffset);
+ if (me.cfg.getProperty("preventoverlap")) {
+ me.preventOverlap(me.pageX, me.pageY);
+ }
+
+ YAHOO.util.Event.removeListener(context, "mousemove", me.onContextMouseMove);
+
+ me.show();
+ me.hideProcId = me.doHide();
+ },
+ this.cfg.getProperty("showdelay"));
+};
+
+/**
+* Sets the timeout for the auto-dismiss delay, which by default is 5 seconds, meaning that a tooltip will automatically dismiss itself after 5 seconds of being displayed.
+* @method doHide
+*/
+YAHOO.widget.Tooltip.prototype.doHide = function() {
+ var me = this;
+ return setTimeout(
+ function() {
+ me.hide();
+ },
+ this.cfg.getProperty("autodismissdelay"));
+};
+
+/**
+* Fired when the Tooltip is moved, this event handler is used to prevent the Tooltip from overlapping with its context element.
+* @method preventOverlay
+* @param {Number} pageX The x coordinate position of the mouse pointer
+* @param {Number} pageY The y coordinate position of the mouse pointer
+*/
+YAHOO.widget.Tooltip.prototype.preventOverlap = function(pageX, pageY) {
+
+ var height = this.element.offsetHeight;
+
+ var elementRegion = YAHOO.util.Dom.getRegion(this.element);
+
+ elementRegion.top -= 5;
+ elementRegion.left -= 5;
+ elementRegion.right += 5;
+ elementRegion.bottom += 5;
+
+ var mousePoint = new YAHOO.util.Point(pageX, pageY);
+
+ if (elementRegion.contains(mousePoint)) {
+ this.cfg.setProperty("y", (pageY-height-5));
+ }
+};
+
+/**
+* Returns a string representation of the object.
+* @method toString
+* @return {String} The string representation of the Tooltip
+*/
+YAHOO.widget.Tooltip.prototype.toString = function() {
+ return "Tooltip " + this.id;
+};
+
+/**
+* Panel is an implementation of Overlay that behaves like an OS window, with a draggable header and an optional close icon at the top right.
+* @namespace YAHOO.widget
+* @class Panel
+* @extends YAHOO.widget.Overlay
+* @constructor
+* @param {String} el The element ID representing the Panel <em>OR</em>
+* @param {HTMLElement} el The element representing the Panel
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this Panel. See configuration documentation for more details.
+*/
+YAHOO.widget.Panel = function(el, userConfig) {
+ YAHOO.widget.Panel.superclass.constructor.call(this, el, userConfig);
+};
+
+YAHOO.extend(YAHOO.widget.Panel, YAHOO.widget.Overlay);
+
+/**
+* Constant representing the default CSS class used for a Panel
+* @property YAHOO.widget.Panel.CSS_PANEL
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Panel.CSS_PANEL = "panel";
+
+/**
+* Constant representing the default CSS class used for a Panel's wrapping container
+* @property YAHOO.widget.Panel.CSS_PANEL_CONTAINER
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Panel.CSS_PANEL_CONTAINER = "panel-container";
+
+/**
+* The Overlay initialization method, which is executed for Overlay and all of its subclasses. This method is automatically called by the constructor, and sets up all DOM references for pre-existing markup, and creates required markup if it is not already present.
+* @method init
+* @param {String} el The element ID representing the Overlay <em>OR</em>
+* @param {HTMLElement} el The element representing the Overlay
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this Overlay. See configuration documentation for more details.
+*/
+YAHOO.widget.Panel.prototype.init = function(el, userConfig) {
+ YAHOO.widget.Panel.superclass.init.call(this, el/*, userConfig*/); // Note that we don't pass the user config in here yet because we only want it executed once, at the lowest subclass level
+
+ this.beforeInitEvent.fire(YAHOO.widget.Panel);
+
+ YAHOO.util.Dom.addClass(this.element, YAHOO.widget.Panel.CSS_PANEL);
+
+ this.buildWrapper();
+
+ if (userConfig) {
+ this.cfg.applyConfig(userConfig, true);
+ }
+
+ this.beforeRenderEvent.subscribe(function() {
+ var draggable = this.cfg.getProperty("draggable");
+ if (draggable) {
+ if (! this.header) {
+ this.setHeader(" ");
+ }
+ }
+ }, this, true);
+
+ var me = this;
+
+ var doBlur = function() {
+ this.blur();
+ };
+
+ this.showMaskEvent.subscribe(function() {
+ var checkFocusable = function(el) {
+ if ((el.tagName == "A" || el.tagName == "BUTTON" || el.tagName == "SELECT" || el.tagName == "INPUT" || el.tagName == "TEXTAREA" || el.tagName == "FORM") && el.type != "hidden") {
+ if (! YAHOO.util.Dom.isAncestor(me.element, el)) {
+ YAHOO.util.Event.addListener(el, "focus", doBlur, el, true);
+ return true;
+ }
+ } else {
+ return false;
+ }
+ };
+
+ this.focusableElements = YAHOO.util.Dom.getElementsBy(checkFocusable);
+ }, this, true);
+
+ this.hideMaskEvent.subscribe(function() {
+ for (var i=0;i<this.focusableElements.length;i++) {
+ var el2 = this.focusableElements[i];
+ YAHOO.util.Event.removeListener(el2, "focus", doBlur);
+ }
+ }, this, true);
+
+ this.beforeShowEvent.subscribe(function() {
+ this.cfg.refireEvent("underlay");
+ }, this, true);
+
+ this.initEvent.fire(YAHOO.widget.Panel);
+};
+
+/**
+* Initializes the custom events for Module which are fired automatically at appropriate times by the Module class.
+*/
+YAHOO.widget.Panel.prototype.initEvents = function() {
+ YAHOO.widget.Panel.superclass.initEvents.call(this);
+
+ /**
+ * CustomEvent fired after the modality mask is shown
+ * @event showMaskEvent
+ */
+ this.showMaskEvent = new YAHOO.util.CustomEvent("showMask");
+
+ /**
+ * CustomEvent fired after the modality mask is hidden
+ * @event hideMaskEvent
+ */
+ this.hideMaskEvent = new YAHOO.util.CustomEvent("hideMask");
+
+ /**
+ * CustomEvent when the Panel is dragged
+ * @event dragEvent
+ */
+ this.dragEvent = new YAHOO.util.CustomEvent("drag");
+};
+
+/**
+* Initializes the class's configurable properties which can be changed using the Panel's Config object (cfg).
+* @method initDefaultConfig
+*/
+YAHOO.widget.Panel.prototype.initDefaultConfig = function() {
+ YAHOO.widget.Panel.superclass.initDefaultConfig.call(this);
+
+ // Add panel config properties //
+
+ /**
+ * True if the Panel should display a "close" button
+ * @config close
+ * @type Boolean
+ * @default true
+ */
+ this.cfg.addProperty("close", { value:true, handler:this.configClose, validator:this.cfg.checkBoolean, supercedes:["visible"] } );
+
+ /**
+ * True if the Panel should be draggable
+ * @config draggable
+ * @type Boolean
+ * @default true
+ */
+ this.cfg.addProperty("draggable", { value:true, handler:this.configDraggable, validator:this.cfg.checkBoolean, supercedes:["visible"] } );
+
+ /**
+ * Sets the type of underlay to display for the Panel. Valid values are "shadow", "matte", and "none".
+ * @config underlay
+ * @type String
+ * @default shadow
+ */
+ this.cfg.addProperty("underlay", { value:"shadow", handler:this.configUnderlay, supercedes:["visible"] } );
+
+ /**
+ * True if the Panel should be displayed in a modal fashion, automatically creating a transparent mask over the document that will not be removed until the Panel is dismissed.
+ * @config modal
+ * @type Boolean
+ * @default false
+ */
+ this.cfg.addProperty("modal", { value:false, handler:this.configModal, validator:this.cfg.checkBoolean, supercedes:["visible"] } );
+
+ /**
+ * A KeyListener (or array of KeyListeners) that will be enabled when the Panel is shown, and disabled when the Panel is hidden.
+ * @config keylisteners
+ * @type YAHOO.util.KeyListener[]
+ * @default null
+ */
+ this.cfg.addProperty("keylisteners", { handler:this.configKeyListeners, suppressEvent:true, supercedes:["visible"] } );
+};
+
+// BEGIN BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* The default event handler fired when the "close" property is changed. The method controls the appending or hiding of the close icon at the top right of the Panel.
+* @method configClose
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configClose = function(type, args, obj) {
+ var val = args[0];
+
+ var doHide = function(e, obj) {
+ obj.hide();
+ };
+
+ if (val) {
+ if (! this.close) {
+ this.close = document.createElement("DIV");
+ YAHOO.util.Dom.addClass(this.close, "close");
+
+ if (this.isSecure) {
+ YAHOO.util.Dom.addClass(this.close, "secure");
+ } else {
+ YAHOO.util.Dom.addClass(this.close, "nonsecure");
+ }
+
+ this.close.innerHTML = " ";
+ this.innerElement.appendChild(this.close);
+ YAHOO.util.Event.addListener(this.close, "click", doHide, this);
+ } else {
+ this.close.style.display = "block";
+ }
+ } else {
+ if (this.close) {
+ this.close.style.display = "none";
+ }
+ }
+};
+
+/**
+* The default event handler fired when the "draggable" property is changed.
+* @method configDraggable
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configDraggable = function(type, args, obj) {
+ var val = args[0];
+ if (val) {
+ if (this.header) {
+ YAHOO.util.Dom.setStyle(this.header,"cursor","move");
+ this.registerDragDrop();
+ }
+ } else {
+ if (this.dd) {
+ this.dd.unreg();
+ }
+ if (this.header) {
+ YAHOO.util.Dom.setStyle(this.header,"cursor","auto");
+ }
+ }
+};
+
+/**
+* The default event handler fired when the "underlay" property is changed.
+* @method configUnderlay
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configUnderlay = function(type, args, obj) {
+ var val = args[0];
+
+ switch (val.toLowerCase()) {
+ case "shadow":
+ YAHOO.util.Dom.removeClass(this.element, "matte");
+ YAHOO.util.Dom.addClass(this.element, "shadow");
+
+ if (! this.underlay) { // create if not already in DOM
+ this.underlay = document.createElement("DIV");
+ this.underlay.className = "underlay";
+ this.underlay.innerHTML = " ";
+ this.element.appendChild(this.underlay);
+ }
+
+ this.sizeUnderlay();
+ break;
+ case "matte":
+ YAHOO.util.Dom.removeClass(this.element, "shadow");
+ YAHOO.util.Dom.addClass(this.element, "matte");
+ break;
+ default:
+ YAHOO.util.Dom.removeClass(this.element, "shadow");
+ YAHOO.util.Dom.removeClass(this.element, "matte");
+ break;
+ }
+};
+
+/**
+* The default event handler fired when the "modal" property is changed. This handler subscribes or unsubscribes to the show and hide events to handle the display or hide of the modality mask.
+* @method configModal
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configModal = function(type, args, obj) {
+ var modal = args[0];
+
+ if (modal) {
+ this.buildMask();
+
+ if (! YAHOO.util.Config.alreadySubscribed( this.beforeShowEvent, this.showMask, this ) ) {
+ this.beforeShowEvent.subscribe(this.showMask, this, true);
+ }
+ if (! YAHOO.util.Config.alreadySubscribed( this.hideEvent, this.hideMask, this) ) {
+ this.hideEvent.subscribe(this.hideMask, this, true);
+ }
+ if (! YAHOO.util.Config.alreadySubscribed( YAHOO.widget.Overlay.windowResizeEvent, this.sizeMask, this ) ) {
+ YAHOO.widget.Overlay.windowResizeEvent.subscribe(this.sizeMask, this, true);
+ }
+ if (! YAHOO.util.Config.alreadySubscribed( this.destroyEvent, this.removeMask, this) ) {
+ this.destroyEvent.subscribe(this.removeMask, this, true);
+ }
+
+ this.cfg.refireEvent("zIndex");
+ } else {
+ this.beforeShowEvent.unsubscribe(this.showMask, this);
+ this.hideEvent.unsubscribe(this.hideMask, this);
+ YAHOO.widget.Overlay.windowResizeEvent.unsubscribe(this.sizeMask, this);
+ this.destroyEvent.unsubscribe(this.removeMask, this);
+ }
+};
+
+/**
+* Removes the modality mask.
+* @method removeMask
+*/
+YAHOO.widget.Panel.prototype.removeMask = function() {
+ if (this.mask) {
+ if (this.mask.parentNode) {
+ this.mask.parentNode.removeChild(this.mask);
+ }
+ this.mask = null;
+ }
+};
+
+/**
+* The default event handler fired when the "keylisteners" property is changed.
+* @method configKeyListeners
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configKeyListeners = function(type, args, obj) {
+ var listeners = args[0];
+
+ if (listeners) {
+ if (listeners instanceof Array) {
+ for (var i=0;i<listeners.length;i++) {
+ var listener = listeners[i];
+
+ if (! YAHOO.util.Config.alreadySubscribed(this.showEvent, listener.enable, listener)) {
+ this.showEvent.subscribe(listener.enable, listener, true);
+ }
+ if (! YAHOO.util.Config.alreadySubscribed(this.hideEvent, listener.disable, listener)) {
+ this.hideEvent.subscribe(listener.disable, listener, true);
+ this.destroyEvent.subscribe(listener.disable, listener, true);
+ }
+ }
+ } else {
+ if (! YAHOO.util.Config.alreadySubscribed(this.showEvent, listeners.enable, listeners)) {
+ this.showEvent.subscribe(listeners.enable, listeners, true);
+ }
+ if (! YAHOO.util.Config.alreadySubscribed(this.hideEvent, listeners.disable, listeners)) {
+ this.hideEvent.subscribe(listeners.disable, listeners, true);
+ this.destroyEvent.subscribe(listeners.disable, listeners, true);
+ }
+ }
+ }
+};
+
+/**
+* The default event handler fired when the "height" property is changed.
+* @method configHeight
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configHeight = function(type, args, obj) {
+ var height = args[0];
+ var el = this.innerElement;
+ YAHOO.util.Dom.setStyle(el, "height", height);
+ this.cfg.refireEvent("underlay");
+ this.cfg.refireEvent("iframe");
+};
+
+/**
+* The default event handler fired when the "width" property is changed.
+* @method configWidth
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configWidth = function(type, args, obj) {
+ var width = args[0];
+ var el = this.innerElement;
+ YAHOO.util.Dom.setStyle(el, "width", width);
+ this.cfg.refireEvent("underlay");
+ this.cfg.refireEvent("iframe");
+};
+
+/**
+* The default event handler fired when the "zIndex" property is changed.
+* @method configzIndex
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Panel.prototype.configzIndex = function(type, args, obj) {
+ YAHOO.widget.Panel.superclass.configzIndex.call(this, type, args, obj);
+
+ var maskZ = 0;
+ var currentZ = YAHOO.util.Dom.getStyle(this.element, "zIndex");
+
+ if (this.mask) {
+ if (! currentZ || isNaN(currentZ)) {
+ currentZ = 0;
+ }
+
+ if (currentZ === 0) {
+ this.cfg.setProperty("zIndex", 1);
+ } else {
+ maskZ = currentZ - 1;
+ YAHOO.util.Dom.setStyle(this.mask, "zIndex", maskZ);
+ }
+
+ }
+};
+
+// END BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* Builds the wrapping container around the Panel that is used for positioning the shadow and matte underlays. The container element is assigned to a local instance variable called container, and the element is reinserted inside of it.
+* @method buildWrapper
+*/
+YAHOO.widget.Panel.prototype.buildWrapper = function() {
+ var elementParent = this.element.parentNode;
+ var originalElement = this.element;
+
+ var wrapper = document.createElement("DIV");
+ wrapper.className = YAHOO.widget.Panel.CSS_PANEL_CONTAINER;
+ wrapper.id = originalElement.id + "_c";
+
+ if (elementParent) {
+ elementParent.insertBefore(wrapper, originalElement);
+ }
+
+ wrapper.appendChild(originalElement);
+
+ this.element = wrapper;
+ this.innerElement = originalElement;
+
+ YAHOO.util.Dom.setStyle(this.innerElement, "visibility", "inherit");
+};
+
+/**
+* Adjusts the size of the shadow based on the size of the element.
+* @method sizeUnderlay
+*/
+YAHOO.widget.Panel.prototype.sizeUnderlay = function() {
+ if (this.underlay && this.browser != "gecko" && this.browser != "safari") {
+ this.underlay.style.width = this.innerElement.offsetWidth + "px";
+ this.underlay.style.height = this.innerElement.offsetHeight + "px";
+ }
+};
+
+/**
+* Event handler fired when the resize monitor element is resized.
+* @method onDomResize
+* @param {DOMEvent} e The resize DOM event
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.Panel.prototype.onDomResize = function(e, obj) {
+ YAHOO.widget.Panel.superclass.onDomResize.call(this, e, obj);
+ var me = this;
+ setTimeout(function() {
+ me.sizeUnderlay();
+ }, 0);
+};
+
+/**
+* Registers the Panel's header for drag & drop capability.
+* @method registerDragDrop
+*/
+YAHOO.widget.Panel.prototype.registerDragDrop = function() {
+ if (this.header) {
+ this.dd = new YAHOO.util.DD(this.element.id, this.id);
+
+ if (! this.header.id) {
+ this.header.id = this.id + "_h";
+ }
+
+ var me = this;
+
+ this.dd.startDrag = function() {
+
+ if (me.browser == "ie") {
+ YAHOO.util.Dom.addClass(me.element,"drag");
+ }
+
+ if (me.cfg.getProperty("constraintoviewport")) {
+ var offsetHeight = me.element.offsetHeight;
+ var offsetWidth = me.element.offsetWidth;
+
+ var viewPortWidth = YAHOO.util.Dom.getViewportWidth();
+ var viewPortHeight = YAHOO.util.Dom.getViewportHeight();
+
+ var scrollX = window.scrollX || document.documentElement.scrollLeft;
+ var scrollY = window.scrollY || document.documentElement.scrollTop;
+
+ var topConstraint = scrollY + 10;
+ var leftConstraint = scrollX + 10;
+ var bottomConstraint = scrollY + viewPortHeight - offsetHeight - 10;
+ var rightConstraint = scrollX + viewPortWidth - offsetWidth - 10;
+
+ this.minX = leftConstraint;
+ this.maxX = rightConstraint;
+ this.constrainX = true;
+
+ this.minY = topConstraint;
+ this.maxY = bottomConstraint;
+ this.constrainY = true;
+ } else {
+ this.constrainX = false;
+ this.constrainY = false;
+ }
+
+ me.dragEvent.fire("startDrag", arguments);
+ };
+
+ this.dd.onDrag = function() {
+ me.syncPosition();
+ me.cfg.refireEvent("iframe");
+ if (this.platform == "mac" && this.browser == "gecko") {
+ this.showMacGeckoScrollbars();
+ }
+
+ me.dragEvent.fire("onDrag", arguments);
+ };
+
+ this.dd.endDrag = function() {
+ if (me.browser == "ie") {
+ YAHOO.util.Dom.removeClass(me.element,"drag");
+ }
+
+ me.dragEvent.fire("endDrag", arguments);
+ };
+
+ this.dd.setHandleElId(this.header.id);
+ this.dd.addInvalidHandleType("INPUT");
+ this.dd.addInvalidHandleType("SELECT");
+ this.dd.addInvalidHandleType("TEXTAREA");
+ }
+};
+
+/**
+* Builds the mask that is laid over the document when the Panel is configured to be modal.
+* @method buildMask
+*/
+YAHOO.widget.Panel.prototype.buildMask = function() {
+ if (! this.mask) {
+ this.mask = document.createElement("DIV");
+ this.mask.id = this.id + "_mask";
+ this.mask.className = "mask";
+ this.mask.innerHTML = " ";
+
+ var maskClick = function(e, obj) {
+ YAHOO.util.Event.stopEvent(e);
+ };
+
+ var firstChild = document.body.firstChild;
+ if (firstChild) {
+ document.body.insertBefore(this.mask, document.body.firstChild);
+ } else {
+ document.body.appendChild(this.mask);
+ }
+ }
+};
+
+/**
+* Hides the modality mask.
+* @method hideMask
+*/
+YAHOO.widget.Panel.prototype.hideMask = function() {
+ if (this.cfg.getProperty("modal") && this.mask) {
+ this.mask.style.display = "none";
+ this.hideMaskEvent.fire();
+ YAHOO.util.Dom.removeClass(document.body, "masked");
+ }
+};
+
+/**
+* Shows the modality mask.
+* @method showMask
+*/
+YAHOO.widget.Panel.prototype.showMask = function() {
+ if (this.cfg.getProperty("modal") && this.mask) {
+ YAHOO.util.Dom.addClass(document.body, "masked");
+ this.sizeMask();
+ this.mask.style.display = "block";
+ this.showMaskEvent.fire();
+ }
+};
+
+/**
+* Sets the size of the modality mask to cover the entire scrollable area of the document
+* @method sizeMask
+*/
+YAHOO.widget.Panel.prototype.sizeMask = function() {
+ if (this.mask) {
+ this.mask.style.height = YAHOO.util.Dom.getDocumentHeight()+"px";
+ this.mask.style.width = YAHOO.util.Dom.getDocumentWidth()+"px";
+ }
+};
+
+/**
+* Renders the Panel by inserting the elements that are not already in the main Panel into their correct places. Optionally appends the Panel to the specified node prior to the render's execution. NOTE: For Panels without existing markup, the appendToNode argument is REQUIRED. If this argument is ommitted and the current element is not present in the document, the function will return false, indicating that the render was a failure.
+* @method render
+* @param {String} appendToNode The element id to which the Module should be appended to prior to rendering <em>OR</em>
+* @param {HTMLElement} appendToNode The element to which the Module should be appended to prior to rendering
+* @return {boolean} Success or failure of the render
+*/
+YAHOO.widget.Panel.prototype.render = function(appendToNode) {
+ return YAHOO.widget.Panel.superclass.render.call(this, appendToNode, this.innerElement);
+};
+
+/**
+* Returns a String representation of the object.
+* @method toString
+* @return {String} The string representation of the Panel.
+*/
+YAHOO.widget.Panel.prototype.toString = function() {
+ return "Panel " + this.id;
+};
+
+/**
+* Dialog is an implementation of Panel that can be used to submit form data. Built-in functionality for buttons with event handlers is included, and button sets can be build dynamically, or the preincluded ones for Submit/Cancel and OK/Cancel can be utilized. Forms can be processed in 3 ways -- via an asynchronous Connection utility call, a simple form POST or GET, or manually.
+* @namespace YAHOO.widget
+* @class Dialog
+* @extends YAHOO.widget.Panel
+* @constructor
+* @param {String} el The element ID representing the Dialog <em>OR</em>
+* @param {HTMLElement} el The element representing the Dialog
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this Dialog. See configuration documentation for more details.
+*/
+YAHOO.widget.Dialog = function(el, userConfig) {
+ YAHOO.widget.Dialog.superclass.constructor.call(this, el, userConfig);
+};
+
+YAHOO.extend(YAHOO.widget.Dialog, YAHOO.widget.Panel);
+
+/**
+* Constant representing the default CSS class used for a Dialog
+* @property YAHOO.widget.Dialog.CSS_DIALOG
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.Dialog.CSS_DIALOG = "dialog";
+
+/**
+* Initializes the class's configurable properties which can be changed using the Dialog's Config object (cfg).
+* @method initDefaultConfig
+*/
+YAHOO.widget.Dialog.prototype.initDefaultConfig = function() {
+ YAHOO.widget.Dialog.superclass.initDefaultConfig.call(this);
+
+ /**
+ * The internally maintained callback object for use with the Connection utility
+ * @property callback
+ * @type Object
+ */
+ this.callback = {
+ /**
+ * The function to execute upon success of the Connection submission
+ * @property callback.success
+ * @type Function
+ */
+ success : null,
+ /**
+ * The function to execute upon failure of the Connection submission
+ * @property callback.failure
+ * @type Function
+ */
+ failure : null,
+ /**
+ * The arbitraty argument or arguments to pass to the Connection callback functions
+ * @property callback.argument
+ * @type Object
+ */
+ argument: null
+ };
+
+ // Add form dialog config properties //
+
+ /**
+ * The method to use for posting the Dialog's form. Possible values are "async", "form", and "manual".
+ * @config postmethod
+ * @type String
+ * @default async
+ */
+ this.cfg.addProperty("postmethod", { value:"async", handler:this.configPostMethod, validator:function(val) {
+ if (val != "form" && val != "async" && val != "none" && val != "manual") {
+ return false;
+ } else {
+ return true;
+ }
+ } });
+
+ /**
+ * Object literal(s) defining the buttons for the Dialog's footer.
+ * @config buttons
+ * @type Object[]
+ * @default "none"
+ */
+ this.cfg.addProperty("buttons", { value:"none", handler:this.configButtons } );
+};
+
+/**
+* Initializes the custom events for Dialog which are fired automatically at appropriate times by the Dialog class.
+* @method initEvents
+*/
+YAHOO.widget.Dialog.prototype.initEvents = function() {
+ YAHOO.widget.Dialog.superclass.initEvents.call(this);
+
+ /**
+ * CustomEvent fired prior to submission
+ * @event beforeSumitEvent
+ */
+ this.beforeSubmitEvent = new YAHOO.util.CustomEvent("beforeSubmit");
+
+ /**
+ * CustomEvent fired after submission
+ * @event submitEvent
+ */
+ this.submitEvent = new YAHOO.util.CustomEvent("submit");
+
+ /**
+ * CustomEvent fired prior to manual submission
+ * @event manualSubmitEvent
+ */
+ this.manualSubmitEvent = new YAHOO.util.CustomEvent("manualSubmit");
+
+ /**
+ * CustomEvent fired prior to asynchronous submission
+ * @event asyncSubmitEvent
+ */
+ this.asyncSubmitEvent = new YAHOO.util.CustomEvent("asyncSubmit");
+
+ /**
+ * CustomEvent fired prior to form-based submission
+ * @event formSubmitEvent
+ */
+ this.formSubmitEvent = new YAHOO.util.CustomEvent("formSubmit");
+
+ /**
+ * CustomEvent fired after cancel
+ * @event cancelEvent
+ */
+ this.cancelEvent = new YAHOO.util.CustomEvent("cancel");
+};
+
+/**
+* The Dialog initialization method, which is executed for Dialog and all of its subclasses. This method is automatically called by the constructor, and sets up all DOM references for pre-existing markup, and creates required markup if it is not already present.
+* @method init
+* @param {String} el The element ID representing the Dialog <em>OR</em>
+* @param {HTMLElement} el The element representing the Dialog
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this Dialog. See configuration documentation for more details.
+*/
+YAHOO.widget.Dialog.prototype.init = function(el, userConfig) {
+ YAHOO.widget.Dialog.superclass.init.call(this, el/*, userConfig*/); // Note that we don't pass the user config in here yet because we only want it executed once, at the lowest subclass level
+
+ this.beforeInitEvent.fire(YAHOO.widget.Dialog);
+
+ YAHOO.util.Dom.addClass(this.element, YAHOO.widget.Dialog.CSS_DIALOG);
+
+ this.cfg.setProperty("visible", false);
+
+ if (userConfig) {
+ this.cfg.applyConfig(userConfig, true);
+ }
+
+ this.showEvent.subscribe(this.focusFirst, this, true);
+ this.beforeHideEvent.subscribe(this.blurButtons, this, true);
+
+ this.beforeRenderEvent.subscribe(function() {
+ var buttonCfg = this.cfg.getProperty("buttons");
+ if (buttonCfg && buttonCfg != "none") {
+ if (! this.footer) {
+ this.setFooter("");
+ }
+ }
+ }, this, true);
+
+ this.initEvent.fire(YAHOO.widget.Dialog);
+};
+
+/**
+* Performs the submission of the Dialog form depending on the value of "postmethod" property.
+* @method doSubmit
+*/
+YAHOO.widget.Dialog.prototype.doSubmit = function() {
+ var pm = this.cfg.getProperty("postmethod");
+ switch (pm) {
+ case "async":
+ var method = this.form.getAttribute("method") || 'POST';
+ method = method.toUpperCase();
+ YAHOO.util.Connect.setForm(this.form);
+ var cObj = YAHOO.util.Connect.asyncRequest(method, this.form.getAttribute("action"), this.callback);
+ this.asyncSubmitEvent.fire();
+ break;
+ case "form":
+ this.form.submit();
+ this.formSubmitEvent.fire();
+ break;
+ case "none":
+ case "manual":
+ this.manualSubmitEvent.fire();
+ break;
+ }
+};
+
+/**
+* Prepares the Dialog's internal FORM object, creating one if one is not currently present.
+* @method registerForm
+*/
+YAHOO.widget.Dialog.prototype.registerForm = function() {
+ var form = this.element.getElementsByTagName("FORM")[0];
+
+ if (! form) {
+ var formHTML = "<form name=\"frm_" + this.id + "\" action=\"\"></form>";
+ this.body.innerHTML += formHTML;
+ form = this.element.getElementsByTagName("FORM")[0];
+ }
+
+ this.firstFormElement = function() {
+ for (var f=0;f<form.elements.length;f++ ) {
+ var el = form.elements[f];
+ if (el.focus) {
+ if (el.type && el.type != "hidden") {
+ return el;
+ }
+ }
+ }
+ return null;
+ }();
+
+ this.lastFormElement = function() {
+ for (var f=form.elements.length-1;f>=0;f-- ) {
+ var el = form.elements[f];
+ if (el.focus) {
+ if (el.type && el.type != "hidden") {
+ return el;
+ }
+ }
+ }
+ return null;
+ }();
+
+ this.form = form;
+
+ if (this.cfg.getProperty("modal") && this.form) {
+
+ var me = this;
+
+ var firstElement = this.firstFormElement || this.firstButton;
+ if (firstElement) {
+ this.preventBackTab = new YAHOO.util.KeyListener(firstElement, { shift:true, keys:9 }, {fn:me.focusLast, scope:me, correctScope:true} );
+ this.showEvent.subscribe(this.preventBackTab.enable, this.preventBackTab, true);
+ this.hideEvent.subscribe(this.preventBackTab.disable, this.preventBackTab, true);
+ }
+
+ var lastElement = this.lastButton || this.lastFormElement;
+ if (lastElement) {
+ this.preventTabOut = new YAHOO.util.KeyListener(lastElement, { shift:false, keys:9 }, {fn:me.focusFirst, scope:me, correctScope:true} );
+ this.showEvent.subscribe(this.preventTabOut.enable, this.preventTabOut, true);
+ this.hideEvent.subscribe(this.preventTabOut.disable, this.preventTabOut, true);
+ }
+ }
+};
+
+// BEGIN BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* The default event handler for the "buttons" configuration property
+* @method configButtons
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Dialog.prototype.configButtons = function(type, args, obj) {
+ var buttons = args[0];
+ if (buttons != "none") {
+ this.buttonSpan = null;
+ this.buttonSpan = document.createElement("SPAN");
+ this.buttonSpan.className = "button-group";
+
+ for (var b=0;b<buttons.length;b++) {
+ var button = buttons[b];
+
+ var htmlButton = document.createElement("BUTTON");
+ htmlButton.setAttribute("type", "button");
+
+ if (button.isDefault) {
+ htmlButton.className = "default";
+ this.defaultHtmlButton = htmlButton;
+ }
+
+ htmlButton.appendChild(document.createTextNode(button.text));
+ YAHOO.util.Event.addListener(htmlButton, "click", button.handler, this, true);
+
+ this.buttonSpan.appendChild(htmlButton);
+ button.htmlButton = htmlButton;
+
+ if (b === 0) {
+ this.firstButton = button.htmlButton;
+ }
+
+ if (b == (buttons.length-1)) {
+ this.lastButton = button.htmlButton;
+ }
+
+ }
+
+ this.setFooter(this.buttonSpan);
+
+ this.cfg.refireEvent("iframe");
+ this.cfg.refireEvent("underlay");
+ } else { // Do cleanup
+ if (this.buttonSpan) {
+ if (this.buttonSpan.parentNode) {
+ this.buttonSpan.parentNode.removeChild(this.buttonSpan);
+ }
+
+ this.buttonSpan = null;
+ this.firstButton = null;
+ this.lastButton = null;
+ this.defaultHtmlButton = null;
+ }
+ }
+};
+
+
+/**
+* The default event handler used to focus the first field of the form when the Dialog is shown.
+* @method focusFirst
+*/
+YAHOO.widget.Dialog.prototype.focusFirst = function(type,args,obj) {
+ if (args) {
+ var e = args[1];
+ if (e) {
+ YAHOO.util.Event.stopEvent(e);
+ }
+ }
+
+ if (this.firstFormElement) {
+ this.firstFormElement.focus();
+ } else {
+ this.focusDefaultButton();
+ }
+};
+
+/**
+* Sets the focus to the last button in the button or form element in the Dialog
+* @method focusLast
+*/
+YAHOO.widget.Dialog.prototype.focusLast = function(type,args,obj) {
+ if (args) {
+ var e = args[1];
+ if (e) {
+ YAHOO.util.Event.stopEvent(e);
+ }
+ }
+
+ var buttons = this.cfg.getProperty("buttons");
+ if (buttons && buttons instanceof Array) {
+ this.focusLastButton();
+ } else {
+ if (this.lastFormElement) {
+ this.lastFormElement.focus();
+ }
+ }
+};
+
+/**
+* Sets the focus to the button that is designated as the default. By default, his handler is executed when the show event is fired.
+* @method focusDefaultButton
+*/
+YAHOO.widget.Dialog.prototype.focusDefaultButton = function() {
+ if (this.defaultHtmlButton) {
+ this.defaultHtmlButton.focus();
+ }
+};
+
+/**
+* Blurs all the html buttons
+* @method blurButtons
+*/
+YAHOO.widget.Dialog.prototype.blurButtons = function() {
+ var buttons = this.cfg.getProperty("buttons");
+ if (buttons && buttons instanceof Array) {
+ var html = buttons[0].htmlButton;
+ if (html) {
+ html.blur();
+ }
+ }
+};
+
+/**
+* Sets the focus to the first button in the button list
+* @method focusFirstButton
+*/
+YAHOO.widget.Dialog.prototype.focusFirstButton = function() {
+ var buttons = this.cfg.getProperty("buttons");
+ if (buttons && buttons instanceof Array) {
+ var html = buttons[0].htmlButton;
+ if (html) {
+ html.focus();
+ }
+ }
+};
+
+/**
+* Sets the focus to the first button in the button list
+* @method focusLastButton
+*/
+YAHOO.widget.Dialog.prototype.focusLastButton = function() {
+ var buttons = this.cfg.getProperty("buttons");
+ if (buttons && buttons instanceof Array) {
+ var html = buttons[buttons.length-1].htmlButton;
+ if (html) {
+ html.focus();
+ }
+ }
+};
+
+/**
+* The default event handler for the "postmethod" configuration property
+* @method configPostMethod
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.Dialog.prototype.configPostMethod = function(type, args, obj) {
+ var postmethod = args[0];
+
+ this.registerForm();
+ YAHOO.util.Event.addListener(this.form, "submit", function(e) {
+ YAHOO.util.Event.stopEvent(e);
+ this.submit();
+ this.form.blur();
+ }, this, true);
+};
+
+// END BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* Built-in function hook for writing a validation function that will be checked for a "true" value prior to a submit. This function, as implemented by default, always returns true, so it should be overridden if validation is necessary.
+* @method validate
+*/
+YAHOO.widget.Dialog.prototype.validate = function() {
+ return true;
+};
+
+/**
+* Executes a submit of the Dialog followed by a hide, if validation is successful.
+* @method submit
+*/
+YAHOO.widget.Dialog.prototype.submit = function() {
+ if (this.validate()) {
+ this.beforeSubmitEvent.fire();
+ this.doSubmit();
+ this.submitEvent.fire();
+ this.hide();
+ return true;
+ } else {
+ return false;
+ }
+};
+
+/**
+* Executes the cancel of the Dialog followed by a hide.
+* @method cancel
+*/
+YAHOO.widget.Dialog.prototype.cancel = function() {
+ this.cancelEvent.fire();
+ this.hide();
+};
+
+/**
+* Returns a JSON-compatible data structure representing the data currently contained in the form.
+* @method getData
+* @return {Object} A JSON object reprsenting the data of the current form.
+*/
+YAHOO.widget.Dialog.prototype.getData = function() {
+ var form = this.form;
+ var data = {};
+
+ if (form) {
+ for (var i=0;i<form.elements.length;i++) {
+ var formItem = form.elements[i];
+ if (formItem) {
+ if (formItem.tagName) { // Got a single form item
+ switch (formItem.tagName) {
+ case "INPUT":
+ switch (formItem.type) {
+ case "checkbox":
+ data[formItem.name] = formItem.checked;
+ break;
+ case "textbox":
+ case "text":
+ case "hidden":
+ data[formItem.name] = formItem.value;
+ break;
+ }
+ break;
+ case "TEXTAREA":
+ data[formItem.name] = formItem.value;
+ break;
+ case "SELECT":
+ var val = [];
+ for (var x=0;x<formItem.options.length;x++) {
+ var option = formItem.options[x];
+ if (option.selected) {
+ var selval = option.value;
+ if (! selval || selval === "") {
+ selval = option.text;
+ }
+ val[val.length] = selval;
+ }
+ }
+ data[formItem.name] = val;
+ break;
+ }
+ } else if (formItem[0] && formItem[0].tagName) { // this is an array of form items
+ if (formItem[0].tagName == "INPUT") {
+ switch (formItem[0].type) {
+ case "radio":
+ for (var r=0; r<formItem.length; r++) {
+ var radio = formItem[r];
+ if (radio.checked) {
+ data[radio.name] = radio.value;
+ break;
+ }
+ }
+ break;
+ case "checkbox":
+ var cbArray = [];
+ for (var c=0; c<formItem.length; c++) {
+ var check = formItem[c];
+ if (check.checked) {
+ cbArray[cbArray.length] = check.value;
+ }
+ }
+ data[formItem[0].name] = cbArray;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ return data;
+};
+
+/**
+* Returns a string representation of the object.
+* @method toString
+* @return {String} The string representation of the Dialog
+*/
+YAHOO.widget.Dialog.prototype.toString = function() {
+ return "Dialog " + this.id;
+};
+
+/**
+* SimpleDialog is a simple implementation of Dialog that can be used to submit a single value. Forms can be processed in 3 ways -- via an asynchronous Connection utility call, a simple form POST or GET, or manually.
+* @namespace YAHOO.widget
+* @class SimpleDialog
+* @extends YAHOO.widget.Dialog
+* @constructor
+* @param {String} el The element ID representing the SimpleDialog <em>OR</em>
+* @param {HTMLElement} el The element representing the SimpleDialog
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this SimpleDialog. See configuration documentation for more details.
+*/
+YAHOO.widget.SimpleDialog = function(el, userConfig) {
+ YAHOO.widget.SimpleDialog.superclass.constructor.call(this, el, userConfig);
+};
+
+YAHOO.extend(YAHOO.widget.SimpleDialog, YAHOO.widget.Dialog);
+
+/**
+* Constant for the standard network icon for a blocking action
+* @property YAHOO.widget.SimpleDialog.ICON_BLOCK
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.SimpleDialog.ICON_BLOCK = "nt/ic/ut/bsc/blck16_1.gif";
+
+/**
+* Constant for the standard network icon for alarm
+* @property YAHOO.widget.SimpleDialog.ICON_ALARM
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.SimpleDialog.ICON_ALARM = "nt/ic/ut/bsc/alrt16_1.gif";
+
+/**
+* Constant for the standard network icon for help
+* @property YAHOO.widget.SimpleDialog.ICON_HELP
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.SimpleDialog.ICON_HELP = "nt/ic/ut/bsc/hlp16_1.gif";
+
+/**
+* Constant for the standard network icon for info
+* @property YAHOO.widget.SimpleDialog.ICON_INFO
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.SimpleDialog.ICON_INFO = "nt/ic/ut/bsc/info16_1.gif";
+
+/**
+* Constant for the standard network icon for warn
+* @property YAHOO.widget.SimpleDialog.ICON_WARN
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.SimpleDialog.ICON_WARN = "nt/ic/ut/bsc/warn16_1.gif";
+
+/**
+* Constant for the standard network icon for a tip
+* @property YAHOO.widget.SimpleDialog.ICON_TIP
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.SimpleDialog.ICON_TIP = "nt/ic/ut/bsc/tip16_1.gif";
+
+/**
+* Constant representing the default CSS class used for a SimpleDialog
+* @property YAHOO.widget.SimpleDialog.CSS_SIMPLEDIALOG
+* @static
+* @final
+* @type String
+*/
+YAHOO.widget.SimpleDialog.CSS_SIMPLEDIALOG = "simple-dialog";
+
+/**
+* Initializes the class's configurable properties which can be changed using the SimpleDialog's Config object (cfg).
+* @method initDefaultConfig
+*/
+YAHOO.widget.SimpleDialog.prototype.initDefaultConfig = function() {
+ YAHOO.widget.SimpleDialog.superclass.initDefaultConfig.call(this);
+
+ // Add dialog config properties //
+
+ /**
+ * Sets the informational icon for the SimpleDialog
+ * @config icon
+ * @type String
+ * @default "none"
+ */
+ this.cfg.addProperty("icon", { value:"none", handler:this.configIcon, suppressEvent:true } );
+
+ /**
+ * Sets the text for the SimpleDialog
+ * @config text
+ * @type String
+ * @default ""
+ */
+ this.cfg.addProperty("text", { value:"", handler:this.configText, suppressEvent:true, supercedes:["icon"] } );
+};
+
+
+/**
+* The SimpleDialog initialization method, which is executed for SimpleDialog and all of its subclasses. This method is automatically called by the constructor, and sets up all DOM references for pre-existing markup, and creates required markup if it is not already present.
+* @method init
+* @param {String} el The element ID representing the SimpleDialog <em>OR</em>
+* @param {HTMLElement} el The element representing the SimpleDialog
+* @param {Object} userConfig The configuration object literal containing the configuration that should be set for this SimpleDialog. See configuration documentation for more details.
+*/
+YAHOO.widget.SimpleDialog.prototype.init = function(el, userConfig) {
+ YAHOO.widget.SimpleDialog.superclass.init.call(this, el/*, userConfig*/); // Note that we don't pass the user config in here yet because we only want it executed once, at the lowest subclass level
+
+ this.beforeInitEvent.fire(YAHOO.widget.SimpleDialog);
+
+ YAHOO.util.Dom.addClass(this.element, YAHOO.widget.SimpleDialog.CSS_SIMPLEDIALOG);
+
+ this.cfg.queueProperty("postmethod", "manual");
+
+ if (userConfig) {
+ this.cfg.applyConfig(userConfig, true);
+ }
+
+ this.beforeRenderEvent.subscribe(function() {
+ if (! this.body) {
+ this.setBody("");
+ }
+ }, this, true);
+
+ this.initEvent.fire(YAHOO.widget.SimpleDialog);
+
+};
+/**
+* Prepares the SimpleDialog's internal FORM object, creating one if one is not currently present, and adding the value hidden field.
+* @method registerForm
+*/
+YAHOO.widget.SimpleDialog.prototype.registerForm = function() {
+ YAHOO.widget.SimpleDialog.superclass.registerForm.call(this);
+ this.form.innerHTML += "<input type=\"hidden\" name=\"" + this.id + "\" value=\"\"/>";
+};
+
+// BEGIN BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* Fired when the "icon" property is set.
+* @method configIcon
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.SimpleDialog.prototype.configIcon = function(type,args,obj) {
+ var icon = args[0];
+ if (icon && icon != "none") {
+ var iconHTML = "<img src=\"" + this.imageRoot + icon + "\" class=\"icon\" />";
+ this.body.innerHTML = iconHTML + this.body.innerHTML;
+ }
+};
+
+/**
+* Fired when the "text" property is set.
+* @method configText
+* @param {String} type The CustomEvent type (usually the property name)
+* @param {Object[]} args The CustomEvent arguments. For configuration handlers, args[0] will equal the newly applied value for the property.
+* @param {Object} obj The scope object. For configuration handlers, this will usually equal the owner.
+*/
+YAHOO.widget.SimpleDialog.prototype.configText = function(type,args,obj) {
+ var text = args[0];
+ if (text) {
+ this.setBody(text);
+ this.cfg.refireEvent("icon");
+ }
+};
+// END BUILT-IN PROPERTY EVENT HANDLERS //
+
+/**
+* Returns a string representation of the object.
+* @method toString
+* @return {String} The string representation of the SimpleDialog
+*/
+YAHOO.widget.SimpleDialog.prototype.toString = function() {
+ return "SimpleDialog " + this.id;
+};
+
+/**
+* ContainerEffect encapsulates animation transitions that are executed when an Overlay is shown or hidden.
+* @namespace YAHOO.widget
+* @class ContainerEffect
+* @constructor
+* @param {YAHOO.widget.Overlay} overlay The Overlay that the animation should be associated with
+* @param {Object} attrIn The object literal representing the animation arguments to be used for the animate-in transition. The arguments for this literal are: attributes(object, see YAHOO.util.Anim for description), duration(Number), and method(i.e. YAHOO.util.Easing.easeIn).
+* @param {Object} attrOut The object literal representing the animation arguments to be used for the animate-out transition. The arguments for this literal are: attributes(object, see YAHOO.util.Anim for description), duration(Number), and method(i.e. YAHOO.util.Easing.easeIn).
+* @param {HTMLElement} targetElement Optional. The target element that should be animated during the transition. Defaults to overlay.element.
+* @param {class} Optional. The animation class to instantiate. Defaults to YAHOO.util.Anim. Other options include YAHOO.util.Motion.
+*/
+YAHOO.widget.ContainerEffect = function(overlay, attrIn, attrOut, targetElement, animClass) {
+ if (! animClass) {
+ animClass = YAHOO.util.Anim;
+ }
+
+ /**
+ * The overlay to animate
+ * @property overlay
+ * @type YAHOO.widget.Overlay
+ */
+ this.overlay = overlay;
+ /**
+ * The animation attributes to use when transitioning into view
+ * @property attrIn
+ * @type Object
+ */
+ this.attrIn = attrIn;
+ /**
+ * The animation attributes to use when transitioning out of view
+ * @property attrOut
+ * @type Object
+ */
+ this.attrOut = attrOut;
+ /**
+ * The target element to be animated
+ * @property targetElement
+ * @type HTMLElement
+ */
+ this.targetElement = targetElement || overlay.element;
+ /**
+ * The animation class to use for animating the overlay
+ * @property animClass
+ * @type class
+ */
+ this.animClass = animClass;
+};
+
+/**
+* Initializes the animation classes and events.
+* @method init
+*/
+YAHOO.widget.ContainerEffect.prototype.init = function() {
+ this.beforeAnimateInEvent = new YAHOO.util.CustomEvent("beforeAnimateIn");
+ this.beforeAnimateOutEvent = new YAHOO.util.CustomEvent("beforeAnimateOut");
+
+ this.animateInCompleteEvent = new YAHOO.util.CustomEvent("animateInComplete");
+ this.animateOutCompleteEvent = new YAHOO.util.CustomEvent("animateOutComplete");
+
+ this.animIn = new this.animClass(this.targetElement, this.attrIn.attributes, this.attrIn.duration, this.attrIn.method);
+ this.animIn.onStart.subscribe(this.handleStartAnimateIn, this);
+ this.animIn.onTween.subscribe(this.handleTweenAnimateIn, this);
+ this.animIn.onComplete.subscribe(this.handleCompleteAnimateIn, this);
+
+ this.animOut = new this.animClass(this.targetElement, this.attrOut.attributes, this.attrOut.duration, this.attrOut.method);
+ this.animOut.onStart.subscribe(this.handleStartAnimateOut, this);
+ this.animOut.onTween.subscribe(this.handleTweenAnimateOut, this);
+ this.animOut.onComplete.subscribe(this.handleCompleteAnimateOut, this);
+};
+
+/**
+* Triggers the in-animation.
+* @method animateIn
+*/
+YAHOO.widget.ContainerEffect.prototype.animateIn = function() {
+ this.beforeAnimateInEvent.fire();
+ this.animIn.animate();
+};
+
+/**
+* Triggers the out-animation.
+* @method animateOut
+*/
+YAHOO.widget.ContainerEffect.prototype.animateOut = function() {
+ this.beforeAnimateOutEvent.fire();
+ this.animOut.animate();
+};
+
+/**
+* The default onStart handler for the in-animation.
+* @method handleStartAnimateIn
+* @param {String} type The CustomEvent type
+* @param {Object[]} args The CustomEvent arguments
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.ContainerEffect.prototype.handleStartAnimateIn = function(type, args, obj) { };
+/**
+* The default onTween handler for the in-animation.
+* @method handleTweenAnimateIn
+* @param {String} type The CustomEvent type
+* @param {Object[]} args The CustomEvent arguments
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.ContainerEffect.prototype.handleTweenAnimateIn = function(type, args, obj) { };
+/**
+* The default onComplete handler for the in-animation.
+* @method handleCompleteAnimateIn
+* @param {String} type The CustomEvent type
+* @param {Object[]} args The CustomEvent arguments
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.ContainerEffect.prototype.handleCompleteAnimateIn = function(type, args, obj) { };
+
+/**
+* The default onStart handler for the out-animation.
+* @method handleStartAnimateOut
+* @param {String} type The CustomEvent type
+* @param {Object[]} args The CustomEvent arguments
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.ContainerEffect.prototype.handleStartAnimateOut = function(type, args, obj) { };
+/**
+* The default onTween handler for the out-animation.
+* @method handleTweenAnimateOut
+* @param {String} type The CustomEvent type
+* @param {Object[]} args The CustomEvent arguments
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.ContainerEffect.prototype.handleTweenAnimateOut = function(type, args, obj) { };
+/**
+* The default onComplete handler for the out-animation.
+* @method handleCompleteAnimateOut
+* @param {String} type The CustomEvent type
+* @param {Object[]} args The CustomEvent arguments
+* @param {Object} obj The scope object
+*/
+YAHOO.widget.ContainerEffect.prototype.handleCompleteAnimateOut = function(type, args, obj) { };
+
+/**
+* Returns a string representation of the object.
+* @method toString
+* @return {String} The string representation of the ContainerEffect
+*/
+YAHOO.widget.ContainerEffect.prototype.toString = function() {
+ var output = "ContainerEffect";
+ if (this.overlay) {
+ output += " [" + this.overlay.toString() + "]";
+ }
+ return output;
+};
+
+/**
+* A pre-configured ContainerEffect instance that can be used for fading an overlay in and out.
+* @method FADE
+* @static
+* @param {Overlay} overlay The Overlay object to animate
+* @param {Number} dur The duration of the animation
+* @return {ContainerEffect} The configured ContainerEffect object
+*/
+YAHOO.widget.ContainerEffect.FADE = function(overlay, dur) {
+ var fade = new YAHOO.widget.ContainerEffect(overlay, { attributes:{opacity: {from:0, to:1}}, duration:dur, method:YAHOO.util.Easing.easeIn }, { attributes:{opacity: {to:0}}, duration:dur, method:YAHOO.util.Easing.easeOut}, overlay.element );
+
+ fade.handleStartAnimateIn = function(type,args,obj) {
+ YAHOO.util.Dom.addClass(obj.overlay.element, "hide-select");
+
+ if (! obj.overlay.underlay) {
+ obj.overlay.cfg.refireEvent("underlay");
+ }
+
+ if (obj.overlay.underlay) {
+ obj.initialUnderlayOpacity = YAHOO.util.Dom.getStyle(obj.overlay.underlay, "opacity");
+ obj.overlay.underlay.style.filter = null;
+ }
+
+ YAHOO.util.Dom.setStyle(obj.overlay.element, "visibility", "visible");
+ YAHOO.util.Dom.setStyle(obj.overlay.element, "opacity", 0);
+ };
+
+ fade.handleCompleteAnimateIn = function(type,args,obj) {
+ YAHOO.util.Dom.removeClass(obj.overlay.element, "hide-select");
+
+ if (obj.overlay.element.style.filter) {
+ obj.overlay.element.style.filter = null;
+ }
+
+ if (obj.overlay.underlay) {
+ YAHOO.util.Dom.setStyle(obj.overlay.underlay, "opacity", obj.initialUnderlayOpacity);
+ }
+
+ obj.overlay.cfg.refireEvent("iframe");
+ obj.animateInCompleteEvent.fire();
+ };
+
+ fade.handleStartAnimateOut = function(type, args, obj) {
+ YAHOO.util.Dom.addClass(obj.overlay.element, "hide-select");
+
+ if (obj.overlay.underlay) {
+ obj.overlay.underlay.style.filter = null;
+ }
+ };
+
+ fade.handleCompleteAnimateOut = function(type, args, obj) {
+ YAHOO.util.Dom.removeClass(obj.overlay.element, "hide-select");
+ if (obj.overlay.element.style.filter) {
+ obj.overlay.element.style.filter = null;
+ }
+ YAHOO.util.Dom.setStyle(obj.overlay.element, "visibility", "hidden");
+ YAHOO.util.Dom.setStyle(obj.overlay.element, "opacity", 1);
+
+ obj.overlay.cfg.refireEvent("iframe");
+
+ obj.animateOutCompleteEvent.fire();
+ };
+
+ fade.init();
+ return fade;
+};
+
+
+/**
+* A pre-configured ContainerEffect instance that can be used for sliding an overlay in and out.
+* @method SLIDE
+* @static
+* @param {Overlay} overlay The Overlay object to animate
+* @param {Number} dur The duration of the animation
+* @return {ContainerEffect} The configured ContainerEffect object
+*/
+YAHOO.widget.ContainerEffect.SLIDE = function(overlay, dur) {
+ var x = overlay.cfg.getProperty("x") || YAHOO.util.Dom.getX(overlay.element);
+ var y = overlay.cfg.getProperty("y") || YAHOO.util.Dom.getY(overlay.element);
+
+ var clientWidth = YAHOO.util.Dom.getClientWidth();
+ var offsetWidth = overlay.element.offsetWidth;
+
+ var slide = new YAHOO.widget.ContainerEffect(overlay, {
+ attributes:{ points: { to:[x, y] } },
+ duration:dur,
+ method:YAHOO.util.Easing.easeIn
+ },
+ {
+ attributes:{ points: { to:[(clientWidth+25), y] } },
+ duration:dur,
+ method:YAHOO.util.Easing.easeOut
+ },
+ overlay.element,
+ YAHOO.util.Motion);
+
+
+ slide.handleStartAnimateIn = function(type,args,obj) {
+ obj.overlay.element.style.left = (-25-offsetWidth) + "px";
+ obj.overlay.element.style.top = y + "px";
+ };
+
+ slide.handleTweenAnimateIn = function(type, args, obj) {
+
+
+ var pos = YAHOO.util.Dom.getXY(obj.overlay.element);
+
+ var currentX = pos[0];
+ var currentY = pos[1];
+
+ if (YAHOO.util.Dom.getStyle(obj.overlay.element, "visibility") == "hidden" && currentX < x) {
+ YAHOO.util.Dom.setStyle(obj.overlay.element, "visibility", "visible");
+ }
+
+ obj.overlay.cfg.setProperty("xy", [currentX,currentY], true);
+ obj.overlay.cfg.refireEvent("iframe");
+ };
+
+ slide.handleCompleteAnimateIn = function(type, args, obj) {
+ obj.overlay.cfg.setProperty("xy", [x,y], true);
+ obj.startX = x;
+ obj.startY = y;
+ obj.overlay.cfg.refireEvent("iframe");
+ obj.animateInCompleteEvent.fire();
+ };
+
+ slide.handleStartAnimateOut = function(type, args, obj) {
+ var vw = YAHOO.util.Dom.getViewportWidth();
+
+ var pos = YAHOO.util.Dom.getXY(obj.overlay.element);
+
+ var yso = pos[1];
+
+ var currentTo = obj.animOut.attributes.points.to;
+ obj.animOut.attributes.points.to = [(vw+25), yso];
+ };
+
+ slide.handleTweenAnimateOut = function(type, args, obj) {
+ var pos = YAHOO.util.Dom.getXY(obj.overlay.element);
+
+ var xto = pos[0];
+ var yto = pos[1];
+
+ obj.overlay.cfg.setProperty("xy", [xto,yto], true);
+ obj.overlay.cfg.refireEvent("iframe");
+ };
+
+ slide.handleCompleteAnimateOut = function(type, args, obj) {
+ YAHOO.util.Dom.setStyle(obj.overlay.element, "visibility", "hidden");
+
+ obj.overlay.cfg.setProperty("xy", [x,y]);
+ obj.animateOutCompleteEvent.fire();
+ };
+
+ slide.init();
+ return slide;
+};
\ No newline at end of file
Modified: jifty/branches/template-declare/share/web/static/js/yui/dom.js
==============================================================================
--- jifty/branches/template-declare/share/web/static/js/yui/dom.js (original)
+++ jifty/branches/template-declare/share/web/static/js/yui/dom.js Wed Jan 10 21:43:42 2007
@@ -2,7 +2,7 @@
Copyright (c) 2006, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.net/yui/license.txt
-version: 0.12.0
+version: 0.12.1
*/
/**
@@ -317,11 +317,14 @@
if (pos[0] !== null) { el.style.left = pos[0] - pageXY[0] + delta[0] + 'px'; }
if (pos[1] !== null) { el.style.top = pos[1] - pageXY[1] + delta[1] + 'px'; }
- var newXY = this.getXY(el);
+ if (!noRetry) {
+ var newXY = this.getXY(el);
- // if retry is true, try one more time if we miss
- if (!noRetry && (newXY[0] != pos[0] || newXY[1] != pos[1]) ) {
- this.setXY(el, pos, true);
+ // if retry is true, try one more time if we miss
+ if ( (pos[0] !== null && newXY[0] != pos[0]) ||
+ (pos[1] !== null && newXY[1] != pos[1]) ) {
+ this.setXY(el, pos, true);
+ }
}
};
@@ -583,9 +586,18 @@
*/
getElementsBy: function(method, tag, root) {
tag = tag || '*';
- root = Y.Dom.get(root) || document;
var nodes = [];
+
+ if (root) {
+ root = Y.Dom.get(root);
+ if (!root) { // if no root node, then no children
+ return nodes;
+ }
+ } else {
+ root = document;
+ }
+
var elements = root.getElementsByTagName(tag);
if ( !elements.length && (tag == '*' && root.all) ) {
Modified: jifty/branches/template-declare/share/web/static/js/yui/event.js
==============================================================================
--- jifty/branches/template-declare/share/web/static/js/yui/event.js (original)
+++ jifty/branches/template-declare/share/web/static/js/yui/event.js Wed Jan 10 21:43:42 2007
@@ -2,7 +2,7 @@
Copyright (c) 2006, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.net/yui/license.txt
-version: 0.12.0
+version: 0.12.1
*/
/**
@@ -15,7 +15,11 @@
* refer to this object in the callback. Default value:
* the window object. The listener can override this.
* @param {boolean} silent pass true to prevent the event from writing to
- * the log system
+ * the debugsystem
+ * @param {int} signature the signature that the custom event subscriber
+ * will receive. YAHOO.util.CustomEvent.LIST or
+ * YAHOO.util.CustomEvent.FLAT. The default is
+ * YAHOO.util.CustomEvent.LIST.
* @namespace YAHOO.util
* @class CustomEvent
* @constructor
@@ -39,7 +43,7 @@
/**
* By default all custom events are logged in the debug build, set silent
- * to true to disable logging for this event.
+ * to true to disable debug outpu for this event.
* @property silent
* @type boolean
*/
@@ -181,6 +185,8 @@
* @method fire
* @param {Object*} arguments an arbitrary set of parameters to pass to
* the handler.
+ * @return {boolean} false if one of the subscribers returned false,
+ * true otherwise
*/
fire: function() {
var len=this.subscribers.length;
@@ -647,7 +653,8 @@
* the execution scope of the listener
* @return {boolean} True if the action was successful or defered,
* false if one or more of the elements
- * could not have the event bound to it.
+ * could not have the listener attached,
+ * or if the operation throws an exception.
* @static
*/
addListener: function(el, sType, fn, obj, override) {
@@ -705,6 +712,7 @@
return true;
}
+
// if the user chooses to override the scope, we use the custom
// object passed in, otherwise the executing scope will be the
// HTML element that the event is registered on
@@ -759,7 +767,14 @@
legacyHandlers[legacyIndex].push(li);
} else {
- this._simpleAdd(el, sType, wrappedFn, false);
+ try {
+ this._simpleAdd(el, sType, wrappedFn, false);
+ } catch(e) {
+ // handle an error trying to attach an event. If it fails
+ // we need to clean up the cache
+ this.removeListener(el, sType, fn);
+ return false;
+ }
}
return true;
@@ -893,6 +908,7 @@
return false;
}
+
if (this.useLegacyEvent(el, sType)) {
var legacyIndex = this.getLegacyIndex(el, sType);
var llist = legacyHandlers[legacyIndex];
@@ -910,7 +926,11 @@
}
} else {
- this._simpleRemove(el, sType, cacheItem[this.WFN], false);
+ try {
+ this._simpleRemove(el, sType, cacheItem[this.WFN], false);
+ } catch(e) {
+ return false;
+ }
}
// removed the wrapped handler
@@ -1252,6 +1272,7 @@
this.locked = true;
+
// keep trying until after the page is loaded. We need to
// check the page load state prior to trying to bind the
// elements so that we can be certain all elements have been
@@ -1270,7 +1291,9 @@
if (el) {
// The element is available, but not necessarily ready
-
+ // @todo verify IE7 compatibility
+ // @todo should we test parentNode.nextSibling?
+ // @todo re-evaluate global content ready
if ( !item.checkReady ||
loadComplete ||
el.nextSibling ||
@@ -1285,7 +1308,9 @@
}
}
item.fn.call(scope, item.obj);
- delete onAvailStack[i];
+ //delete onAvailStack[i];
+ // null out instead of delete for Opera
+ onAvailStack[i] = null;
}
} else {
notAvail.push(item);
@@ -1296,6 +1321,7 @@
retryCount = (notAvail.length === 0) ? 0 : retryCount - 1;
if (tryAgain) {
+ onAvailStack = notAvail; // cleanse the array
this.startInterval();
} else {
clearInterval(this._interval);
@@ -1397,12 +1423,14 @@
}
}
l[EU.FN].call(scope, EU.getEvent(e), l[EU.OBJ] );
- delete unloadListeners[i];
+ unloadListeners[i] = null;
l=null;
scope=null;
}
}
+ unloadListeners = null;
+
if (listeners && listeners.length > 0) {
j = listeners.length;
while (j) {
@@ -1421,11 +1449,16 @@
for (i=0,len=legacyEvents.length; i<len; ++i) {
// dereference the element
- delete legacyEvents[i][0];
+ //delete legacyEvents[i][0];
+ legacyEvents[i][0] = null;
+
// delete the array item
- delete legacyEvents[i];
+ //delete legacyEvents[i];
+ legacyEvents[i] = null;
}
+ legacyEvents = null;
+
EU._simpleRemove(window, "unload", EU._unload);
},
Modified: jifty/branches/template-declare/share/web/static/js/yui/yahoo.js
==============================================================================
--- jifty/branches/template-declare/share/web/static/js/yui/yahoo.js (original)
+++ jifty/branches/template-declare/share/web/static/js/yui/yahoo.js Wed Jan 10 21:43:42 2007
@@ -2,9 +2,8 @@
Copyright (c) 2006, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.net/yui/license.txt
-version: 0.12.0
+version: 0.12.1
*/
-
/**
* The YAHOO object is the single global object used by YUI Library. It
* contains utility function for setting up namespaces, inheritance, and
@@ -14,12 +13,12 @@
* @title YAHOO Global
*/
-/**
- * The YAHOO global namespace object
- * @class YAHOO
- * @static
- */
if (typeof YAHOO == "undefined") {
+ /**
+ * The YAHOO global namespace object
+ * @class YAHOO
+ * @static
+ */
var YAHOO = {};
}
@@ -89,7 +88,7 @@
* @static
* @param {Function} subc the object to modify
* @param {Function} superc the object to inherit
- * @param {String[]} overrides additional properties/methods to add to the
+ * @param {Object} overrides additional properties/methods to add to the
* subclass prototype. These will override the
* matching items obtained from the superclass
* if present.
Modified: jifty/branches/template-declare/share/web/templates/__jifty/admin/index.html
==============================================================================
--- jifty/branches/template-declare/share/web/templates/__jifty/admin/index.html (original)
+++ jifty/branches/template-declare/share/web/templates/__jifty/admin/index.html Wed Jan 10 21:43:42 2007
@@ -21,7 +21,7 @@
% foreach my $action (Jifty->api->actions) {
% Jifty::Util->require($action);
% next if ( $action->can('autogenerated') and $action->autogenerated);
-<li><% Jifty->web->link( url => '/__jifty/admin/action/'.$action, label => $action) %>
+<li><% Jifty->web->link( url => '/__jifty/admin/action/'.$action, label => $action) %></li>
% }
</ul>
Modified: jifty/branches/template-declare/t/12-param-schema.t
==============================================================================
--- jifty/branches/template-declare/t/12-param-schema.t (original)
+++ jifty/branches/template-declare/t/12-param-schema.t Wed Jan 10 21:43:42 2007
@@ -14,7 +14,7 @@
use Jifty::Action schema {
param keys =>
- length is 30,
+ max_length is 30,
label is 'Search Keys',
hints are 'Enter your search keys here!',
default is 'blah blah blah';
@@ -37,7 +37,7 @@
my $keys = $args->{keys};
ok $keys, 'keys okay';
-is $keys->{length}, 30, 'length ok';
+is $keys->{length}, 30, 'max_length ok';
is $keys->{label}, 'Search Keys', 'label ok';
is $keys->{type}, 'text', 'type ok';
is $keys->{hints}, 'Enter your search keys here!', 'hints okay';
Added: jifty/branches/template-declare/t/TestApp/lib/TestApp/Action/DoSomethingElse.pm
==============================================================================
--- (empty file)
+++ jifty/branches/template-declare/t/TestApp/lib/TestApp/Action/DoSomethingElse.pm Wed Jan 10 21:43:42 2007
@@ -0,0 +1,22 @@
+package TestApp::Action::DoSomethingElse;
+
+use Jifty::Param::Schema;
+use Jifty::Action schema {
+
+param foo =>
+ label is 'Foo',
+ ajax validates,
+ is mandatory;
+
+param bar =>
+ label is 'Bar',
+ ajax validates,
+ is mandatory;
+};
+
+sub take_action {
+ my $self = shift;
+ $self->result->message("Something happened!");
+}
+
+1;
Added: jifty/branches/template-declare/t/TestApp/share/web/templates/dosomethingelse
==============================================================================
--- (empty file)
+++ jifty/branches/template-declare/t/TestApp/share/web/templates/dosomethingelse Wed Jan 10 21:43:42 2007
@@ -0,0 +1,14 @@
+<%init>
+my $action = Jifty->web->new_action(
+ class => 'DoSomethingElse',
+ moniker => 'dosomething',
+);
+</%init>
+<&| /_elements/wrapper, title => "Test of simple form for validation" &>
+ Basic test of a simple form for validation.
+<% Jifty->web->form->start() %>
+<% $action->form_field('foo') %>
+<% $action->form_field('bar') %>
+<% Jifty->web->form->submit %>
+<% Jifty->web->form->end %>
+</&>
More information about the Jifty-commit
mailing list