~bac/juju-gui/trunkcopy

* Manager object for synthetic event subscriptions to aggregate multiple synths on the same node without colliding with actual DOM subscription entries in the global map of DOM subscriptions. Also facilitates proper cleanup on page unload.

1418

1419

* @class SynthRegistry

1420

* @constructor

1421

* @param el {HTMLElement} the DOM element

1422

* @param yuid {String} the yuid stamp for the element

1423

* @param key {String} the generated id token used to identify an event type +

1424

* element in the global DOM subscription map.

1425

* @private

1426

1427

function SynthRegistry(el, yuid, key) {

1428

this.handles = [];

1429

this.el = el;

1430

this.key = key;

1431

this.domkey = yuid;

1432

}

1433

1434

SynthRegistry.prototype = {

1435

constructor: SynthRegistry,

1436

1437

// A few object properties to fake the CustomEvent interface for page

1438

// unload cleanup. DON'T TOUCH!

1439

type : '_synth',

1440

fn : noop,

1441

capture : false,

1442

1443

/**

1444

* Adds a subscription from the Notifier registry.

1445

1446

* @method register

1447

* @param handle {EventHandle} the subscription

1448

* @since 3.4.0

1449

1450

1451

handle.evt.registry = this;

1452

this.handles.push(handle);

1453

1454

1455

/**

1456

* Removes the subscription from the Notifier registry.

1457

1458

* @method _unregisterSub

1459

* @param sub {Subscription} the subscription

1460

* @since 3.4.0

1461

1462

unregister: function (sub) {

1463

var handles = this.handles,

1464

events = DOMMap[this.domkey],

1465

1466

1467

for (i = handles.length - 1; i >= 0; --i) {

1468

if (handles[i].sub === sub) {

1469

handles.splice(i, 1);

1470

break;

1471

}

1472

}

1473

1474

// Clean up left over objects when there are no more subscribers.

1475

if (!handles.length) {

1476

delete events[this.key];

1477

if (!Y.Object.size(events)) {

1478

delete DOMMap[this.domkey];

1479

}

1480

}

1481

1482

1483

/**

1484

* Used by the event system's unload cleanup process. When navigating

1485

* away from the page, the event system iterates the global map of element

1486

* subscriptions and detaches everything using detachAll(). Normally,

1487

* the map is populated with custom events, so this object needs to

1488

* at least support the detachAll method to duck type its way to

1489

* cleanliness.

1490

1491

* @method detachAll

1492

* @private

1493

* @since 3.4.0

1494

1495

detachAll : function () {

1496

var handles = this.handles,

1497

i = handles.length;

1498

1499

while (--i >= 0) {

1500

handles[i].detach();

1501

}

1502

}

1503

};

1504

1505

/**

1506

* <p>Wrapper class for the integration of new events into the YUI event

1507

* infrastructure. Don't instantiate this object directly, use

1508

* <code>Y.Event.define(type, config)</code>. See that method for details.</p>

1509

1510

* <p>Properties that MAY or SHOULD be specified in the configuration are noted

1511

* below and in the description of <code>Y.Event.define</code>.</p>

1512

1513

* @class SyntheticEvent

1514

* @constructor

1515

* @param cfg {Object} Implementation pieces and configuration

1516

* @since 3.1.0

1517

* @in event-synthetic

1518

1519

function SyntheticEvent() {

1520

this._init.apply(this, arguments);

1521

}

1522

1523

Y.mix(SyntheticEvent, {

1524

Notifier: Notifier,

1525

SynthRegistry: SynthRegistry,

1526

1527

/**

1528

* Returns the array of subscription handles for a node for the given event

1529

* type. Passing true as the third argument will create a registry entry

1530

* in the event system's DOM map to host the array if one doesn't yet exist.

1531

1532

* @method getRegistry

1533

* @param node {Node} the node

1534

* @param type {String} the event

1535

* @param create {Boolean} create a registration entry to host a new array

1536

* if one doesn't exist.

1537

* @return {Array}

1538

* @static

1539

* @protected

1540

* @since 3.2.0

1541

1542

getRegistry: function (node, type, create) {

1543

var el = node._node,

1544

yuid = Y.stamp(el),

1545

key = 'event:' + yuid + type + '_synth',

1546

events = DOMMap[yuid];

1547

1548

if (create) {

1549

if (!events) {

1550

events = DOMMap[yuid] = {};

1551

}

1552

if (!events[key]) {

1553

events[key] = new SynthRegistry(el, yuid, key);

1554

}

1555

}

1556

1557

return (events && events[key]) || null;

1558

1559

1560

/**

1561

* Alternate <code>_delete()</code> method for the CustomEvent object

1562

* created to manage SyntheticEvent subscriptions.

1563

1564

* @method _deleteSub

1565

* @param sub {Subscription} the subscription to clean up

1566

* @private

1567

* @since 3.2.0

1568

1569

_deleteSub: function (sub) {

1570

if (sub && sub.fn) {

1571

var synth = this.eventDef,

1572

method = (sub.filter) ? 'detachDelegate' : 'detach';

1573

1574

this.subscribers = {};

1575

this.subCount = 0;

1576

1577

synth[method](sub.node, sub, this.notifier, sub.filter);

1578

this.registry.unregister(sub);

1579

1580

delete sub.fn;

1581

delete sub.node;

1582

delete sub.context;

1583

}

1584

1585

1586

prototype: {

1587

constructor: SyntheticEvent,

1588

1589

/**

1590

* Construction logic for the event.

1591

1592

* @method _init

1593

* @protected

1594

1595

_init: function () {

1596

var config = this.publishConfig || (this.publishConfig = {});

1597

1598

// The notification mechanism handles facade creation

1599

this.emitFacade = ('emitFacade' in config) ?

1600

config.emitFacade :

1601

true;

1602

config.emitFacade = false;

1603

1604

1605

/**

1606

* <p>Implementers MAY provide this method definition.</p>

1607

1608

* <p>Implement this function if the event supports a different

1609

* subscription signature. This function is used by both

1610

* <code>on()</code> and <code>delegate()</code>. The second parameter

1611

* indicates that the event is being subscribed via

1612

* <code>delegate()</code>.</p>

1613

1614

* <p>Implementations must remove extra arguments from the args list

1615

* before returning. The required args for <code>on()</code>

1616

* subscriptions are</p>

1617

* <pre><code>[type, callback, target, context, argN...]</code></pre>

1618

1619

* <p>The required args for <code>delegate()</code>

1620

* subscriptions are</p>

1621

1622

* <pre><code>[type, callback, target, filter, context, argN...]</code></pre>

1623

1624

* <p>The return value from this function will be stored on the

1625

* subscription in the '_extra' property for reference elsewhere.</p>

1626

1627

* @method processArgs

1628

* @param args {Array} parmeters passed to Y.on(..) or Y.delegate(..)

1629

* @param delegate {Boolean} true if the subscription is from Y.delegate

1630

* @return {any}

1631

1632

processArgs: noop,

1633

1634

/**

1635

* <p>Implementers MAY override this property.</p>

1636

1637

* <p>Whether to prevent multiple subscriptions to this event that are

1638

* classified as being the same. By default, this means the subscribed

1639

* callback is the same function. See the <code>subMatch</code>

1640

* method. Setting this to true will impact performance for high volume

1641

* events.</p>

1642

1643

* @property preventDups

1644

* @type {Boolean}

1645

* @default false

1646

1647

//preventDups : false,

1648

1649

/**

1650

* <p>Implementers SHOULD provide this method definition.</p>

1651

1652

* Implementation logic for subscriptions done via <code>node.on(type,

1653

* fn)</code> or <code>Y.on(type, fn, target)</code>. This

1654

* function should set up the monitor(s) that will eventually fire the

1655

* event. Typically this involves subscribing to at least one DOM

1656

* event. It is recommended to store detach handles from any DOM

1657

* subscriptions to make for easy cleanup in the <code>detach</code>

1658

* method. Typically these handles are added to the <code>sub</code>

1659

* object. Also for SyntheticEvents that leverage a single DOM

1660

* subscription under the hood, it is recommended to pass the DOM event

1661

* object to <code>notifier.fire(e)</code>. (The event name on the

1662

* object will be updated).

1663

1664

* @method on

1665

* @param node {Node} the node the subscription is being applied to

1666

* @param sub {Subscription} the object to track this subscription

1667

* @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to

1668

* trigger the execution of the subscribers

1669

1670

on: noop,

1671

1672

/**

1673

* <p>Implementers SHOULD provide this method definition.</p>

1674

1675

* <p>Implementation logic for detaching subscriptions done via

1676

* <code>node.on(type, fn)</code>. This function should clean up any

1677

* subscriptions made in the <code>on()</code> phase.</p>

1678

1679

* @method detach

1680

* @param node {Node} the node the subscription was applied to

1681

* @param sub {Subscription} the object tracking this subscription

1682

* @param notifier {SyntheticEvent.Notifier} the Notifier used to

1683

* trigger the execution of the subscribers

1684

1685

detach: noop,

1686

1687

/**

1688

* <p>Implementers SHOULD provide this method definition.</p>

1689

1690

* <p>Implementation logic for subscriptions done via

1691

* <code>node.delegate(type, fn, filter)</code> or

1692

* <code>Y.delegate(type, fn, container, filter)</code>. Like with

1693

* <code>on()</code> above, this function should monitor the environment

1694

* for the event being fired, and trigger subscription execution by

1695

* calling <code>notifier.fire(e)</code>.</p>

1696

1697

* <p>This function receives a fourth argument, which is the filter

1698

* used to identify which Node's are of interest to the subscription.

1699

* The filter will be either a boolean function that accepts a target

1700

* Node for each hierarchy level as the event bubbles, or a selector

1701

* string. To translate selector strings into filter functions, use

1702

* <code>Y.delegate.compileFilter(filter)</code>.</p>

1703

1704

* @method delegate

1705

* @param node {Node} the node the subscription is being applied to

1706

* @param sub {Subscription} the object to track this subscription

1707

* @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to

1708

* trigger the execution of the subscribers

1709

* @param filter {String|Function} Selector string or function that

1710

* accepts an event object and returns null, a Node, or an

1711

* array of Nodes matching the criteria for processing.

1712

* @since 3.2.0

1713

1714

delegate : noop,

1715

1716

/**

1717

* <p>Implementers SHOULD provide this method definition.</p>

1718

1719

* <p>Implementation logic for detaching subscriptions done via

1720

* <code>node.delegate(type, fn, filter)</code> or

1721

* <code>Y.delegate(type, fn, container, filter)</code>. This function

1722

* should clean up any subscriptions made in the

1723

* <code>delegate()</code> phase.</p>

1724

1725

* @method detachDelegate

1726

* @param node {Node} the node the subscription was applied to

1727

* @param sub {Subscription} the object tracking this subscription

1728

* @param notifier {SyntheticEvent.Notifier} the Notifier used to

1729

* trigger the execution of the subscribers

1730

* @param filter {String|Function} Selector string or function that

1731

* accepts an event object and returns null, a Node, or an

1732

* array of Nodes matching the criteria for processing.

1733

* @since 3.2.0

1734

1735

detachDelegate : noop,

1736

1737

/**

1738

* Sets up the boilerplate for detaching the event and facilitating the

1739

* execution of subscriber callbacks.

1740

1741

* @method _on

1742

* @param args {Array} array of arguments passed to

1743

* <code>Y.on(...)</code> or <code>Y.delegate(...)</code>

1744

* @param delegate {Boolean} true if called from

1745

* <code>Y.delegate(...)</code>

1746

* @return {EventHandle} the detach handle for this subscription

1747

* @private

1748

* since 3.2.0

1749

1750

_on: function (args, delegate) {

1751

var handles = [],

1752

originalArgs = args.slice(),

1753

extra = this.processArgs(args, delegate),

1754

selector = args[2],

1755

method = delegate ? 'delegate' : 'on',

1756

nodes, handle;

1757

1758

// Can't just use Y.all because it doesn't support window (yet?)

1759

nodes = (isString(selector)) ?

1760

query(selector) :

1761

toArray(selector || Y.one(Y.config.win));

1762

1763

if (!nodes.length && isString(selector)) {

1764

handle = Y.on('available', function () {

1765

Y.mix(handle, Y[method].apply(Y, originalArgs), true);

1766

}, selector);

1767

1768

return handle;

1769

}

1770

1771

Y.Array.each(nodes, function (node) {

1772

var subArgs = args.slice(),

1773

filter;

1774

1775

node = Y.one(node);

1776

1777

if (node) {

1778

if (delegate) {

1779

filter = subArgs.splice(3, 1)[0];

1780

}

1781

1782

// (type, fn, el, thisObj, ...) => (fn, thisObj, ...)

1783

subArgs.splice(0, 4, subArgs[1], subArgs[3]);

1784

1785

if (!this.preventDups ||

1786

!this.getSubs(node, args, null, true))

1787

{

1788

handles.push(this._subscribe(node, method, subArgs, extra, filter));

1789

}

1790

}

1791

}, this);

1792

1793

return (handles.length === 1) ?

1794

handles[0] :

1795

new Y.EventHandle(handles);

1796

1797

1798

/**

1799

* Creates a new Notifier object for use by this event's

1800

* <code>on(...)</code> or <code>delegate(...)</code> implementation

1801

* and register the custom event proxy in the DOM system for cleanup.

1802

1803

* @method _subscribe

1804

* @param node {Node} the Node hosting the event

1805

* @param method {String} "on" or "delegate"

1806

* @param args {Array} the subscription arguments passed to either

1807

* <code>Y.on(...)</code> or <code>Y.delegate(...)</code>

1808

* after running through <code>processArgs(args)</code> to

1809

* normalize the argument signature

1810

* @param extra {any} Extra data parsed from

1811

* <code>processArgs(args)</code>

1812

* @param filter {String|Function} the selector string or function

1813

* filter passed to <code>Y.delegate(...)</code> (not

1814

* present when called from <code>Y.on(...)</code>)

1815

* @return {EventHandle}

1816

* @private

1817

* @since 3.2.0

1818

1819

_subscribe: function (node, method, args, extra, filter) {

1820

var dispatcher = new Y.CustomEvent(this.type, this.publishConfig),

1821

handle = dispatcher.on.apply(dispatcher, args),

1822

notifier = new Notifier(handle, this.emitFacade),

1823

registry = SyntheticEvent.getRegistry(node, this.type, true),

1824

sub = handle.sub;

1825

1826

sub.node = node;

1827

sub.filter = filter;

1828

if (extra) {

1829

this.applyArgExtras(extra, sub);

1830

}

1831

1832

Y.mix(dispatcher, {

1833

eventDef : this,

1834

notifier : notifier,

1835

host : node, // I forget what this is for

1836

currentTarget: node, // for generating facades

1837

target : node, // for generating facades

1838

el : node._node, // For category detach

1839

1840

_delete : SyntheticEvent._deleteSub

1841

}, true);

1842

1843

handle.notifier = notifier;

1844

1845

registry.register(handle);

1846

1847

// Call the implementation's "on" or "delegate" method

1848

this[method](node, sub, notifier, filter);

1849

1850

return handle;

1851

1852

1853

/**

1854

* <p>Implementers MAY provide this method definition.</p>

1855

1856

* <p>Implement this function if you want extra data extracted during

1857

* processArgs to be propagated to subscriptions on a per-node basis.

1858

* That is to say, if you call <code>Y.on('xyz', fn, xtra, 'div')</code>

1859

* the data returned from processArgs will be shared

1860

* across the subscription objects for all the divs. If you want each

1861

* subscription to receive unique information, do that processing

1862

* here.</p>

1863

1864

* <p>The default implementation adds the data extracted by processArgs

1865

* to the subscription object as <code>sub._extra</code>.</p>

1866

1867

* @method applyArgExtras

1868

* @param extra {any} Any extra data extracted from processArgs

1869

* @param sub {Subscription} the individual subscription

1870

1871

applyArgExtras: function (extra, sub) {

1872

sub._extra = extra;

1873

1874

1875

/**

1876

* Removes the subscription(s) from the internal subscription dispatch

1877

* mechanism. See <code>SyntheticEvent._deleteSub</code>.

1878

1879

* @method _detach

1880

* @param args {Array} The arguments passed to

1881

* <code>node.detach(...)</code>

1882

* @private

1883

* @since 3.2.0

1884

1885

_detach: function (args) {

1886

// Can't use Y.all because it doesn't support window (yet?)

1887

// TODO: Does Y.all support window now?

1888

var target = args[2],

1889

els = (isString(target)) ?

1890

query(target) : toArray(target),

1891

node, i, len, handles, j;

1892

1893

// (type, fn, el, context, filter?) => (type, fn, context, filter?)

1894

args.splice(2, 1);

1895

1896

for (i = 0, len = els.length; i < len; ++i) {

1897

node = Y.one(els[i]);

1898

1899

if (node) {

1900

handles = this.getSubs(node, args);

1901

1902

if (handles) {

1903

for (j = handles.length - 1; j >= 0; --j) {

1904

handles[j].detach();

1905

}

1906

}

1907

}

1908

}

1909

1910

1911

/**

1912

* Returns the detach handles of subscriptions on a node that satisfy a

1913

* search/filter function. By default, the filter used is the

1914

* <code>subMatch</code> method.

1915

1916

* @method getSubs

1917

* @param node {Node} the node hosting the event

1918

* @param args {Array} the array of original subscription args passed

1919

* to <code>Y.on(...)</code> (before

1920

* <code>processArgs</code>

1921

* @param filter {Function} function used to identify a subscription

1922

* for inclusion in the returned array

1923

* @param first {Boolean} stop after the first match (used to check for

1924

* duplicate subscriptions)

1925

* @return {EventHandle[]} detach handles for the matching subscriptions

1926

1927

getSubs: function (node, args, filter, first) {

1928

var registry = SyntheticEvent.getRegistry(node, this.type),

1929

handles = [],

1930

allHandles, i, len, handle;

1931

1932

if (registry) {

1933

allHandles = registry.handles;

1934

1935

if (!filter) {

1936

filter = this.subMatch;

1937

}

1938

1939

for (i = 0, len = allHandles.length; i < len; ++i) {

1940

handle = allHandles[i];

1941

if (filter.call(this, handle.sub, args)) {

1942

if (first) {

1943

return handle;

1944

} else {

1945

handles.push(allHandles[i]);

1946

}

1947

}

1948

}

1949

}

1950

1951

return handles.length && handles;

1952

1953

1954

/**

1955

* <p>Implementers MAY override this to define what constitutes a

1956

* &quot;same&quot; subscription. Override implementations should

1957

* consider the lack of a comparator as a match, so calling

1958

* <code>getSubs()</code> with no arguments will return all subs.</p>

1959

1960

* <p>Compares a set of subscription arguments against a Subscription

1961

* object to determine if they match. The default implementation

1962

* compares the callback function against the second argument passed to

1963

* <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>

1964

1965

* @method subMatch

1966

* @param sub {Subscription} the existing subscription

1967

* @param args {Array} the calling arguments passed to

1968

* <code>Y.on(...)</code> etc.

1969

* @return {Boolean} true if the sub can be described by the args

1970

* present

1971

* @since 3.2.0

1972

1973

subMatch: function (sub, args) {

1974

// Default detach cares only about the callback matching

1975

return !args[1] || sub.fn === args[1];

1976

}

1977

}

1978

}, true);

1979

1980

Y.SyntheticEvent = SyntheticEvent;

1981

1982

/**

1983

* <p>Defines a new event in the DOM event system. Implementers are

1984

* responsible for monitoring for a scenario whereby the event is fired. A

1985

* notifier object is provided to the functions identified below. When the

1986

* criteria defining the event are met, call notifier.fire( [args] ); to

1987

* execute event subscribers.</p>

1988

1989

* <p>The first parameter is the name of the event. The second parameter is a

1990

* configuration object which define the behavior of the event system when the

1991

* new event is subscribed to or detached from. The methods that should be

1992

* defined in this configuration object are <code>on</code>,

1993

* <code>detach</code>, <code>delegate</code>, and <code>detachDelegate</code>.

1994

* You are free to define any other methods or properties needed to define your

1995

* event. Be aware, however, that since the object is used to subclass

1996

* SyntheticEvent, you should avoid method names used by SyntheticEvent unless

1997

* your intention is to override the default behavior.</p>

1998

1999

* <p>This is a list of properties and methods that you can or should specify

2000

* in the configuration object:</p>

2001

2002

* <dl>

2003

* <dt><code>on</code></dt>

2004

* <dd><code>function (node, subscription, notifier)</code> The

2005

* implementation logic for subscription. Any special setup you need to

2006

* do to create the environment for the event being fired--E.g. native

2007

* DOM event subscriptions. Store subscription related objects and

2008

* state on the <code>subscription</code> object. When the

2009

* criteria have been met to fire the synthetic event, call

2010

* <code>notifier.fire(e)</code>. See Notifier's <code>fire()</code>

2011

* method for details about what to pass as parameters.</dd>

2012

2013

* <dt><code>detach</code></dt>

2014

* <dd><code>function (node, subscription, notifier)</code> The

2015

* implementation logic for cleaning up a detached subscription. E.g.

2016

* detach any DOM subscriptions added in <code>on</code>.</dd>

2017

2018

* <dt><code>delegate</code></dt>

2019

* <dd><code>function (node, subscription, notifier, filter)</code> The

2020

* implementation logic for subscription via <code>Y.delegate</code> or

2021

* <code>node.delegate</code>. The filter is typically either a selector

2022

* string or a function. You can use

2023

* <code>Y.delegate.compileFilter(selectorString)</code> to create a

2024

* filter function from a selector string if needed. The filter function

2025

* expects an event object as input and should output either null, a

2026

* matching Node, or an array of matching Nodes. Otherwise, this acts

2027

* like <code>on</code> DOM event subscriptions. Store subscription

2028

* related objects and information on the <code>subscription</code>

2029

* object. When the criteria have been met to fire the synthetic event,

2030

* call <code>notifier.fire(e)</code> as noted above.</dd>

2031

2032

* <dt><code>detachDelegate</code></dt>

2033

* <dd><code>function (node, subscription, notifier)</code> The

2034

* implementation logic for cleaning up a detached delegate subscription.

2035

* E.g. detach any DOM delegate subscriptions added in

2036

* <code>delegate</code>.</dd>

2037

2038

* <dt><code>publishConfig</code></dt>

2039

* <dd>(Object) The configuration object that will be used to instantiate

2040

* the underlying CustomEvent. See Notifier's <code>fire</code> method

2041

* for details.</dd>

2042

2043

* <dt><code>processArgs</code></dt

2044

* <dd>

2045

* <p><code>function (argArray, fromDelegate)</code> Optional method

2046

* to extract any additional arguments from the subscription

2047

* signature. Using this allows <code>on</code> or

2048

* <code>delegate</code> signatures like

2049

* <code>node.on(&quot;hover&quot;, overCallback,

2050

* outCallback)</code>.</p>

2051

* <p>When processing an atypical argument signature, make sure the

2052

* args array is returned to the normal signature before returning

2053

* from the function. For example, in the &quot;hover&quot; example

2054

* above, the <code>outCallback</code> needs to be <code>splice</code>d

2055

* out of the array. The expected signature of the args array for

2056

* <code>on()</code> subscriptions is:</p>

2057

* <pre>

2058

* <code>[type, callback, target, contextOverride, argN...]</code>

2059

* </pre>

2060

* <p>And for <code>delegate()</code>:</p>

2061

* <pre>

2062

* <code>[type, callback, target, filter, contextOverride, argN...]</code>

2063

* </pre>

2064

* <p>where <code>target</code> is the node the event is being

2065

* subscribed for. You can see these signatures documented for

2066

* <code>Y.on()</code> and <code>Y.delegate()</code> respectively.</p>

2067

* <p>Whatever gets returned from the function will be stored on the

2068

* <code>subscription</code> object under

2069

* <code>subscription._extra</code>.</p></dd>

2070

* <dt><code>subMatch</code></dt>

2071

* <dd>

2072

* <p><code>function (sub, args)</code> Compares a set of

2073

* subscription arguments against a Subscription object to determine

2074

* if they match. The default implementation compares the callback

2075

* function against the second argument passed to

2076

* <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>

2077

* </dd>

2078

* </dl>

2079

2080

* @method define

2081

* @param type {String} the name of the event

2082

* @param config {Object} the prototype definition for the new event (see above)

2083

* @param force {Boolean} override an existing event (use with caution)

2084

* @return {SyntheticEvent} the subclass implementation instance created to

2085

* handle event subscriptions of this type

2086

* @static

2087

* @for Event

2088

* @since 3.1.0

2089

* @in event-synthetic

2090

2091

Y.Event.define = function (type, config, force) {

2092

var eventDef, Impl, synth;

2093

2094

if (type && type.type) {

2095

eventDef = type;

2096

force = config;

2097

} else if (config) {

2098

eventDef = Y.merge({ type: type }, config);

2099

}

2100

2101

if (eventDef) {

2102

if (force || !Y.Node.DOM_EVENTS[eventDef.type]) {

2103

Impl = function () {

2104

SyntheticEvent.apply(this, arguments);

2105

};

2106

Y.extend(Impl, SyntheticEvent, eventDef);

2107

synth = new Impl();

2108

2109

type = synth.type;

2110

2111

Y.Node.DOM_EVENTS[type] = Y.Env.evt.plugins[type] = {

2112

eventDef: synth,

2113

2114

on: function () {

2115

return synth._on(toArray(arguments));

2116

2117

2118

delegate: function () {

2119

return synth._on(toArray(arguments), true);

2120

2121

2122

detach: function () {

2123

return synth._detach(toArray(arguments));

2124

}

2125

};

2126

2127

}

2128

} else if (isString(type) || isArray(type)) {

2129

Y.Array.each(toArray(type), function (t) {

2130

Y.Node.DOM_EVENTS[t] = 1;

2131

});

2132

}

2133

2134

return synth;

2135

};

2136

2137

</pre>

2138

</div>

2139

2140

</div>

2141

</div>

2142

</div>

2143

</div>

2144

</div>

2145

</div>

2146

2147

2148

2149

2150

2151

2152

2153

2154

</body>

2155

</html>

Older »