Ubuntu UI Toolkit

Merge lp:~ubuntu-sdk-team/ubuntu-ui-toolkit/generatedApDocs into lp:ubuntu-ui-toolkit/staging

  1. generatedApDocs
  2. Merge into staging
Proposed by Cris Dywan
Status: Merged
Merged at revision: 1493
Proposed branch: lp:~ubuntu-sdk-team/ubuntu-ui-toolkit/generatedApDocs
Merge into: lp:ubuntu-ui-toolkit/staging
Diff against target: 15774 lines (+15512/-3)
36 files modified
debian/rules (+3/-2)
documentation/autopilot-helpers/_build/html/_modules/index.html (+74/-0)
documentation/autopilot-helpers/_build/html/_modules/ubuntuuitoolkit.html (+161/-0)
documentation/autopilot-helpers/_build/html/_sources/index.txt (+17/-0)
documentation/autopilot-helpers/_build/html/_sources/ubuntuuitoolkit.txt (+10/-0)
documentation/autopilot-helpers/_build/html/_static/basic.css (+537/-0)
documentation/autopilot-helpers/_build/html/_static/default.css (+256/-0)
documentation/autopilot-helpers/_build/html/_static/doctools.js (+238/-0)
documentation/autopilot-helpers/_build/html/_static/jquery.js (+9404/-0)
documentation/autopilot-helpers/_build/html/_static/nature.css (+211/-0)
documentation/autopilot-helpers/_build/html/_static/pygments.css (+63/-0)
documentation/autopilot-helpers/_build/html/_static/searchtools.js (+622/-0)
documentation/autopilot-helpers/_build/html/_static/sidebar.js (+159/-0)
documentation/autopilot-helpers/_build/html/_static/underscore.js (+1415/-0)
documentation/autopilot-helpers/_build/html/_static/websupport.js (+808/-0)
documentation/autopilot-helpers/_build/html/genindex.html (+73/-0)
documentation/autopilot-helpers/_build/html/index.html (+875/-0)
documentation/autopilot-helpers/_build/html/py-modindex.html (+96/-0)
documentation/autopilot-helpers/_build/html/search.html (+96/-0)
documentation/autopilot-helpers/_build/html/searchindex.js (+1/-0)
documentation/autopilot-helpers/_build/html/ubuntuuitoolkit.html (+79/-0)
documentation/autopilot-helpers/_build/json/_modules/index.fjson (+1/-0)
documentation/autopilot-helpers/_build/json/_modules/ubuntuuitoolkit.fjson (+1/-0)
documentation/autopilot-helpers/_build/json/_sources/index.txt (+17/-0)
documentation/autopilot-helpers/_build/json/_sources/ubuntuuitoolkit.txt (+10/-0)
documentation/autopilot-helpers/_build/json/_static/nature.css (+211/-0)
documentation/autopilot-helpers/_build/json/_static/pygments.css (+63/-0)
documentation/autopilot-helpers/_build/json/genindex.fjson (+1/-0)
documentation/autopilot-helpers/_build/json/globalcontext.json (+1/-0)
documentation/autopilot-helpers/_build/json/index.fjson (+1/-0)
documentation/autopilot-helpers/_build/json/py-modindex.fjson (+1/-0)
documentation/autopilot-helpers/_build/json/search.fjson (+1/-0)
documentation/autopilot-helpers/_build/json/searchindex.json (+1/-0)
documentation/autopilot-helpers/_build/json/ubuntuuitoolkit.fjson (+1/-0)
documentation/autopilot-helpers/conf.py (+3/-0)
tests/license/checklicense.sh (+1/-1)
To merge this branch: bzr merge lp:~ubuntu-sdk-team/ubuntu-ui-toolkit/generatedApDocs
Reviewer Review Type Date Requested Status
PS Jenkins bot continuous-integration Needs Fixing
Martin Pitt (community) Approve
Review via email: mp+256913@code.launchpad.net

This proposal supersedes a proposal from 2015-04-21.

Commit message

Ship generated HTML and JSON docs for Autopilot helpers

Description of the change

Ship generated HTML and JSON docs for Autopilot helpers

To post a comment you must log in.
Revision history for this message
Martin Pitt (pitti) wrote : Posted in a previous version of this proposal

Thanks Christian! This is of course "ugh" and a technical debt, but we don't have that much choice now. For vivid+1 we should sort this out properly by dropping autopilot-legacy, promoting autopilot to main, and re-enable building the docs, but for vivid this will do fine.

review: Approve
Reply
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-autolanding/907/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-autolanding/215/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-autolanding/214/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-autolanding/214/console

review: Needs Fixing (continuous-integration)
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Continuous integration, rev:1491
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1690/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2364/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/417/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/420/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/417/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2362/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1690/rebuild

review: Needs Fixing (continuous-integration)
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-autolanding/910/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-autolanding/218/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-autolanding/217/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-autolanding/217/console

review: Needs Fixing (continuous-integration)
Revision history for this message
Martin Pitt (pitti) wrote :

Not sure why this is a new MP now, but my original review still applies. Thanks!

review: Approve
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Continuous integration, rev:1492
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1692/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2367/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/419/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/422/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/419/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2365/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1692/rebuild

review: Needs Fixing (continuous-integration)
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-autolanding/912/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-autolanding/220/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-autolanding/219/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-autolanding/219/console

review: Needs Fixing (continuous-integration)
Revision history for this message
PS Jenkins bot (ps-jenkins) wrote :

FAILED: Continuous integration, rev:1492
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1695/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2387
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/423
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/425
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/425/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/422
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/2083
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2385
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2385/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19845

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/1695/rebuild

review: Needs Fixing (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'debian/rules'
2--- debian/rules 2015-02-12 09:37:05 +0000
3+++ debian/rules 2015-04-21 12:16:30 +0000
4@@ -36,8 +36,9 @@
5
6 override_dh_install:
7 dh_auto_build -- docs
8- sphinx-build -b singlehtml documentation/autopilot-helpers documentation/autopilot-helpers/_build/html
9- sphinx-build -b json documentation/autopilot-helpers documentation/autopilot-helpers/_build/json
10+ # FIXME: Due to autopilot not being in the archive we ship docs for now
11+ # sphinx-build -b singlehtml documentation/autopilot-helpers documentation/autopilot-helpers/_build/html
12+ # sphinx-build -b json documentation/autopilot-helpers documentation/autopilot-helpers/_build/json
13 mkdir -p debian/tmp/`qmake -query QT_INSTALL_DOCS`/qch
14 mkdir -p debian/tmp/usr/share/ubuntu-ui-toolkit/doc
15 cp -r $(CURDIR)/documentation/*qch debian/tmp/`qmake -query QT_INSTALL_DOCS`/qch
16
17=== added directory 'documentation/autopilot-helpers/_build'
18=== added directory 'documentation/autopilot-helpers/_build/html'
19=== added directory 'documentation/autopilot-helpers/_build/html/_modules'
20=== added file 'documentation/autopilot-helpers/_build/html/_modules/index.html'
21--- documentation/autopilot-helpers/_build/html/_modules/index.html 1970-01-01 00:00:00 +0000
22+++ documentation/autopilot-helpers/_build/html/_modules/index.html 2015-04-21 12:16:30 +0000
23@@ -0,0 +1,74 @@
24+<!--
25+ Copyright 2015 Canonical Ltd.
26+-->
27+
28+
29+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
30+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
31+
32+
33+<html xmlns="http://www.w3.org/1999/xhtml">
34+ <head>
35+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
36+
37+ <title>Overview: module code &mdash; ubuntu-ui-toolkit-autopilot 15.04 documentation</title>
38+
39+ <link rel="stylesheet" href="../_static/default.css" type="text/css" />
40+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
41+
42+ <script type="text/javascript">
43+ var DOCUMENTATION_OPTIONS = {
44+ URL_ROOT: '../',
45+ VERSION: '15.04',
46+ COLLAPSE_INDEX: false,
47+ FILE_SUFFIX: '.html',
48+ HAS_SOURCE: true
49+ };
50+ </script>
51+ <script type="text/javascript" src="../_static/jquery.js"></script>
52+ <script type="text/javascript" src="../_static/underscore.js"></script>
53+ <script type="text/javascript" src="../_static/doctools.js"></script>
54+ <link rel="shortcut icon" href="../_static/favicon.ico"/>
55+ <link rel="top" title="ubuntu-ui-toolkit-autopilot 15.04 documentation" href="../index.html" />
56+ </head>
57+ <body>
58+ <div class="related">
59+ <h3>Navigation</h3>
60+ <ul>
61+ <li class="right" style="margin-right: 10px">
62+ <a href="../genindex.html" title="General Index"
63+ accesskey="I">index</a></li>
64+ <li class="right" >
65+ <a href="../py-modindex.html" title="Python Module Index"
66+ >modules</a> |</li>
67+ <li><a href="../index.html">ubuntu-ui-toolkit-autopilot 15.04 documentation</a> &raquo;</li>
68+ </ul>
69+ </div>
70+<div class="document">
71+ <div class="documentwrapper">
72+ <div class="bodywrapper">
73+ <div class="body">
74+
75+ <h1>All modules for which code is available</h1>
76+<ul><li><a href="ubuntuuitoolkit.html">ubuntuuitoolkit</a></li>
77+</ul>
78+
79+ </div>
80+ </div>
81+ <div class="related">
82+ <h3>Navigation</h3>
83+ <ul>
84+ <li class="right" style="margin-right: 10px">
85+ <a href="../genindex.html" title="General Index"
86+ >index</a></li>
87+ <li class="right" >
88+ <a href="../py-modindex.html" title="Python Module Index"
89+ >modules</a> |</li>
90+ <li><a href="../index.html">ubuntu-ui-toolkit-autopilot 15.04 documentation</a> &raquo;</li>
91+ </ul>
92+ </div>
93+ <div class="footer">
94+ &copy; Copyright 2015, Canonical.
95+ </div>
96+ </body>
97+</html>
98\ No newline at end of file
99
100=== added file 'documentation/autopilot-helpers/_build/html/_modules/ubuntuuitoolkit.html'
101--- documentation/autopilot-helpers/_build/html/_modules/ubuntuuitoolkit.html 1970-01-01 00:00:00 +0000
102+++ documentation/autopilot-helpers/_build/html/_modules/ubuntuuitoolkit.html 2015-04-21 12:16:30 +0000
103@@ -0,0 +1,161 @@
104+<!--
105+ Copyright 2015 Canonical Ltd.
106+-->
107+
108+
109+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
110+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
111+
112+
113+<html xmlns="http://www.w3.org/1999/xhtml">
114+ <head>
115+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
116+
117+ <title>ubuntuuitoolkit &mdash; ubuntu-ui-toolkit-autopilot 15.04 documentation</title>
118+
119+ <link rel="stylesheet" href="../_static/default.css" type="text/css" />
120+ <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
121+
122+ <script type="text/javascript">
123+ var DOCUMENTATION_OPTIONS = {
124+ URL_ROOT: '../',
125+ VERSION: '15.04',
126+ COLLAPSE_INDEX: false,
127+ FILE_SUFFIX: '.html',
128+ HAS_SOURCE: true
129+ };
130+ </script>
131+ <script type="text/javascript" src="../_static/jquery.js"></script>
132+ <script type="text/javascript" src="../_static/underscore.js"></script>
133+ <script type="text/javascript" src="../_static/doctools.js"></script>
134+ <link rel="shortcut icon" href="../_static/favicon.ico"/>
135+ <link rel="top" title="ubuntu-ui-toolkit-autopilot 15.04 documentation" href="../index.html" />
136+ <link rel="up" title="Module code" href="index.html" />
137+ </head>
138+ <body>
139+ <div class="related">
140+ <h3>Navigation</h3>
141+ <ul>
142+ <li class="right" style="margin-right: 10px">
143+ <a href="../genindex.html" title="General Index"
144+ accesskey="I">index</a></li>
145+ <li class="right" >
146+ <a href="../py-modindex.html" title="Python Module Index"
147+ >modules</a> |</li>
148+ <li><a href="../index.html">ubuntu-ui-toolkit-autopilot 15.04 documentation</a> &raquo;</li>
149+ <li><a href="index.html" accesskey="U">Module code</a> &raquo;</li>
150+ </ul>
151+ </div>
152+<div class="document">
153+ <div class="documentwrapper">
154+ <div class="bodywrapper">
155+ <div class="body">
156+
157+ <h1>Source code for ubuntuuitoolkit</h1><div class="highlight"><pre>
158+<span class="c"># -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-</span>
159+<span class="c">#</span>
160+<span class="c"># Copyright (C) 2012, 2013, 2014 Canonical Ltd.</span>
161+<span class="c">#</span>
162+<span class="c"># This program is free software; you can redistribute it and/or modify</span>
163+<span class="c"># it under the terms of the GNU Lesser General Public License as published by</span>
164+<span class="c"># the Free Software Foundation; version 3.</span>
165+<span class="c">#</span>
166+<span class="c"># This program is distributed in the hope that it will be useful,</span>
167+<span class="c"># but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
168+<span class="c"># MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the</span>
169+<span class="c"># GNU Lesser General Public License for more details.</span>
170+<span class="c">#</span>
171+<span class="c"># You should have received a copy of the GNU Lesser General Public License</span>
172+<span class="c"># along with this program. If not, see &lt;http://www.gnu.org/licenses/&gt;.</span>
173+
174+<span class="sd">&quot;&quot;&quot;Ubuntu UI Toolkit Autopilot tests and helpers.&quot;&quot;&quot;</span>
175+
176+
177+<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span>
178+ <span class="s">&#39;AppHeader&#39;</span><span class="p">,</span>
179+ <span class="s">&#39;base&#39;</span><span class="p">,</span>
180+ <span class="s">&#39;check_autopilot_version&#39;</span><span class="p">,</span>
181+ <span class="s">&#39;CheckBox&#39;</span><span class="p">,</span>
182+ <span class="s">&#39;environment&#39;</span><span class="p">,</span>
183+ <span class="s">&#39;fixture_setup&#39;</span><span class="p">,</span>
184+ <span class="s">&#39;get_keyboard&#39;</span><span class="p">,</span>
185+ <span class="s">&#39;get_pointing_device&#39;</span><span class="p">,</span>
186+ <span class="s">&#39;Header&#39;</span><span class="p">,</span>
187+ <span class="s">&#39;Dialog&#39;</span><span class="p">,</span>
188+ <span class="s">&#39;listitems&#39;</span><span class="p">,</span>
189+ <span class="s">&#39;UCListItem&#39;</span><span class="p">,</span>
190+ <span class="s">&#39;MainView&#39;</span><span class="p">,</span>
191+ <span class="s">&#39;OptionSelector&#39;</span><span class="p">,</span>
192+ <span class="s">&#39;pickers&#39;</span><span class="p">,</span>
193+ <span class="s">&#39;popups&#39;</span><span class="p">,</span>
194+ <span class="s">&#39;QQuickFlickable&#39;</span><span class="p">,</span>
195+ <span class="s">&#39;QQuickGridView&#39;</span><span class="p">,</span>
196+ <span class="s">&#39;QQuickListView&#39;</span><span class="p">,</span>
197+ <span class="s">&#39;TabBar&#39;</span><span class="p">,</span>
198+ <span class="s">&#39;Tabs&#39;</span><span class="p">,</span>
199+ <span class="s">&#39;tests&#39;</span><span class="p">,</span>
200+ <span class="s">&#39;TextArea&#39;</span><span class="p">,</span>
201+ <span class="s">&#39;TextField&#39;</span><span class="p">,</span>
202+ <span class="s">&#39;Toolbar&#39;</span><span class="p">,</span>
203+ <span class="s">&#39;ToolkitException&#39;</span><span class="p">,</span>
204+ <span class="s">&#39;ubuntu_scenarios&#39;</span><span class="p">,</span>
205+ <span class="s">&#39;UbuntuListView11&#39;</span><span class="p">,</span>
206+ <span class="s">&#39;UbuntuUIToolkitCustomProxyObjectBase&#39;</span><span class="p">,</span>
207+<span class="p">]</span>
208+
209+
210+<span class="kn">from</span> <span class="nn">ubuntuuitoolkit</span> <span class="kn">import</span> <span class="p">(</span>
211+ <span class="n">base</span><span class="p">,</span>
212+ <span class="n">environment</span><span class="p">,</span>
213+ <span class="n">fixture_setup</span><span class="p">,</span>
214+ <span class="n">tests</span><span class="p">,</span>
215+ <span class="n">ubuntu_scenarios</span>
216+<span class="p">)</span>
217+<span class="kn">from</span> <span class="nn">ubuntuuitoolkit._custom_proxy_objects</span> <span class="kn">import</span> <span class="p">(</span>
218+ <span class="n">AppHeader</span><span class="p">,</span>
219+ <span class="n">check_autopilot_version</span><span class="p">,</span>
220+ <span class="n">CheckBox</span><span class="p">,</span>
221+ <span class="n">get_keyboard</span><span class="p">,</span>
222+ <span class="n">get_pointing_device</span><span class="p">,</span>
223+ <span class="n">Header</span><span class="p">,</span>
224+ <span class="n">Dialog</span><span class="p">,</span>
225+ <span class="n">listitems</span><span class="p">,</span>
226+ <span class="n">UCListItem</span><span class="p">,</span>
227+ <span class="n">MainView</span><span class="p">,</span>
228+ <span class="n">OptionSelector</span><span class="p">,</span>
229+ <span class="n">pickers</span><span class="p">,</span>
230+ <span class="n">popups</span><span class="p">,</span>
231+ <span class="n">QQuickFlickable</span><span class="p">,</span>
232+ <span class="n">QQuickGridView</span><span class="p">,</span>
233+ <span class="n">QQuickListView</span><span class="p">,</span>
234+ <span class="n">TabBar</span><span class="p">,</span>
235+ <span class="n">Tabs</span><span class="p">,</span>
236+ <span class="n">TextArea</span><span class="p">,</span>
237+ <span class="n">TextField</span><span class="p">,</span>
238+ <span class="n">Toolbar</span><span class="p">,</span>
239+ <span class="n">ToolkitException</span><span class="p">,</span>
240+ <span class="n">UbuntuUIToolkitCustomProxyObjectBase</span><span class="p">,</span>
241+ <span class="n">UbuntuListView11</span><span class="p">,</span>
242+<span class="p">)</span>
243+</pre></div>
244+
245+ </div>
246+ </div>
247+ <div class="related">
248+ <h3>Navigation</h3>
249+ <ul>
250+ <li class="right" style="margin-right: 10px">
251+ <a href="../genindex.html" title="General Index"
252+ >index</a></li>
253+ <li class="right" >
254+ <a href="../py-modindex.html" title="Python Module Index"
255+ >modules</a> |</li>
256+ <li><a href="../index.html">ubuntu-ui-toolkit-autopilot 15.04 documentation</a> &raquo;</li>
257+ <li><a href="index.html" >Module code</a> &raquo;</li>
258+ </ul>
259+ </div>
260+ <div class="footer">
261+ &copy; Copyright 2015, Canonical.
262+ </div>
263+ </body>
264+</html>
265\ No newline at end of file
266
267=== added directory 'documentation/autopilot-helpers/_build/html/_sources'
268=== added file 'documentation/autopilot-helpers/_build/html/_sources/index.txt'
269--- documentation/autopilot-helpers/_build/html/_sources/index.txt 1970-01-01 00:00:00 +0000
270+++ documentation/autopilot-helpers/_build/html/_sources/index.txt 2015-04-21 12:16:30 +0000
271@@ -0,0 +1,17 @@
272+.. ubuntu-ui-toolkit-autopilot documentation master file, created by
273+ sphinx-quickstart on Thu Jan 8 12:39:43 2015.
274+ You can adapt this file completely to your liking, but it should at least
275+ contain the root `toctree` directive.
276+
277+Welcome to ubuntu-ui-toolkit-autopilot's documentation!
278+======================================
279+
280+Contents:
281+
282+.. toctree::
283+ :maxdepth: 2
284+
285+ ubuntuuitoolkit
286+
287+* :ref:`genindex`
288+
289
290=== added file 'documentation/autopilot-helpers/_build/html/_sources/ubuntuuitoolkit.txt'
291--- documentation/autopilot-helpers/_build/html/_sources/ubuntuuitoolkit.txt 1970-01-01 00:00:00 +0000
292+++ documentation/autopilot-helpers/_build/html/_sources/ubuntuuitoolkit.txt 2015-04-21 12:16:30 +0000
293@@ -0,0 +1,10 @@
294+ubuntuuitoolkit Package
295+=======================
296+
297+:mod:`custom proxy object` Module
298+---------------------------------
299+
300+.. automodule:: ubuntuuitoolkit
301+ :members:
302+ :undoc-members:
303+ :show-inheritance:
304
305=== added directory 'documentation/autopilot-helpers/_build/html/_static'
306=== added file 'documentation/autopilot-helpers/_build/html/_static/ajax-loader.gif'
307Binary files documentation/autopilot-helpers/_build/html/_static/ajax-loader.gif 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/ajax-loader.gif 2015-04-21 12:16:30 +0000 differ
308=== added file 'documentation/autopilot-helpers/_build/html/_static/basic.css'
309--- documentation/autopilot-helpers/_build/html/_static/basic.css 1970-01-01 00:00:00 +0000
310+++ documentation/autopilot-helpers/_build/html/_static/basic.css 2015-04-21 12:16:30 +0000
311@@ -0,0 +1,537 @@
312+/*
313+ * basic.css
314+ * ~~~~~~~~~
315+ *
316+ * Sphinx stylesheet -- basic theme.
317+ *
318+ * :copyright: Copyright 2007-2014 by the Sphinx team, see AUTHORS.
319+ * :license: BSD, see LICENSE for details.
320+ *
321+ */
322+
323+/* -- main layout ----------------------------------------------------------- */
324+
325+div.clearer {
326+ clear: both;
327+}
328+
329+/* -- relbar ---------------------------------------------------------------- */
330+
331+div.related {
332+ width: 100%;
333+ font-size: 90%;
334+}
335+
336+div.related h3 {
337+ display: none;
338+}
339+
340+div.related ul {
341+ margin: 0;
342+ padding: 0 0 0 10px;
343+ list-style: none;
344+}
345+
346+div.related li {
347+ display: inline;
348+}
349+
350+div.related li.right {
351+ float: right;
352+ margin-right: 5px;
353+}
354+
355+/* -- sidebar --------------------------------------------------------------- */
356+
357+div.sphinxsidebarwrapper {
358+ padding: 10px 5px 0 10px;
359+}
360+
361+div.sphinxsidebar {
362+ float: left;
363+ width: 230px;
364+ margin-left: -100%;
365+ font-size: 90%;
366+}
367+
368+div.sphinxsidebar ul {
369+ list-style: none;
370+}
371+
372+div.sphinxsidebar ul ul,
373+div.sphinxsidebar ul.want-points {
374+ margin-left: 20px;
375+ list-style: square;
376+}
377+
378+div.sphinxsidebar ul ul {
379+ margin-top: 0;
380+ margin-bottom: 0;
381+}
382+
383+div.sphinxsidebar form {
384+ margin-top: 10px;
385+}
386+
387+div.sphinxsidebar input {
388+ border: 1px solid #98dbcc;
389+ font-family: sans-serif;
390+ font-size: 1em;
391+}
392+
393+div.sphinxsidebar #searchbox input[type="text"] {
394+ width: 170px;
395+}
396+
397+div.sphinxsidebar #searchbox input[type="submit"] {
398+ width: 30px;
399+}
400+
401+img {
402+ border: 0;
403+ max-width: 100%;
404+}
405+
406+/* -- search page ----------------------------------------------------------- */
407+
408+ul.search {
409+ margin: 10px 0 0 20px;
410+ padding: 0;
411+}
412+
413+ul.search li {
414+ padding: 5px 0 5px 20px;
415+ background-image: url(file.png);
416+ background-repeat: no-repeat;
417+ background-position: 0 7px;
418+}
419+
420+ul.search li a {
421+ font-weight: bold;
422+}
423+
424+ul.search li div.context {
425+ color: #888;
426+ margin: 2px 0 0 30px;
427+ text-align: left;
428+}
429+
430+ul.keywordmatches li.goodmatch a {
431+ font-weight: bold;
432+}
433+
434+/* -- index page ------------------------------------------------------------ */
435+
436+table.contentstable {
437+ width: 90%;
438+}
439+
440+table.contentstable p.biglink {
441+ line-height: 150%;
442+}
443+
444+a.biglink {
445+ font-size: 1.3em;
446+}
447+
448+span.linkdescr {
449+ font-style: italic;
450+ padding-top: 5px;
451+ font-size: 90%;
452+}
453+
454+/* -- general index --------------------------------------------------------- */
455+
456+table.indextable {
457+ width: 100%;
458+}
459+
460+table.indextable td {
461+ text-align: left;
462+ vertical-align: top;
463+}
464+
465+table.indextable dl, table.indextable dd {
466+ margin-top: 0;
467+ margin-bottom: 0;
468+}
469+
470+table.indextable tr.pcap {
471+ height: 10px;
472+}
473+
474+table.indextable tr.cap {
475+ margin-top: 10px;
476+ background-color: #f2f2f2;
477+}
478+
479+img.toggler {
480+ margin-right: 3px;
481+ margin-top: 3px;
482+ cursor: pointer;
483+}
484+
485+div.modindex-jumpbox {
486+ border-top: 1px solid #ddd;
487+ border-bottom: 1px solid #ddd;
488+ margin: 1em 0 1em 0;
489+ padding: 0.4em;
490+}
491+
492+div.genindex-jumpbox {
493+ border-top: 1px solid #ddd;
494+ border-bottom: 1px solid #ddd;
495+ margin: 1em 0 1em 0;
496+ padding: 0.4em;
497+}
498+
499+/* -- general body styles --------------------------------------------------- */
500+
501+a.headerlink {
502+ visibility: hidden;
503+}
504+
505+h1:hover > a.headerlink,
506+h2:hover > a.headerlink,
507+h3:hover > a.headerlink,
508+h4:hover > a.headerlink,
509+h5:hover > a.headerlink,
510+h6:hover > a.headerlink,
511+dt:hover > a.headerlink {
512+ visibility: visible;
513+}
514+
515+div.body p.caption {
516+ text-align: inherit;
517+}
518+
519+div.body td {
520+ text-align: left;
521+}
522+
523+.field-list ul {
524+ padding-left: 1em;
525+}
526+
527+.first {
528+ margin-top: 0 !important;
529+}
530+
531+p.rubric {
532+ margin-top: 30px;
533+ font-weight: bold;
534+}
535+
536+img.align-left, .figure.align-left, object.align-left {
537+ clear: left;
538+ float: left;
539+ margin-right: 1em;
540+}
541+
542+img.align-right, .figure.align-right, object.align-right {
543+ clear: right;
544+ float: right;
545+ margin-left: 1em;
546+}
547+
548+img.align-center, .figure.align-center, object.align-center {
549+ display: block;
550+ margin-left: auto;
551+ margin-right: auto;
552+}
553+
554+.align-left {
555+ text-align: left;
556+}
557+
558+.align-center {
559+ text-align: center;
560+}
561+
562+.align-right {
563+ text-align: right;
564+}
565+
566+/* -- sidebars -------------------------------------------------------------- */
567+
568+div.sidebar {
569+ margin: 0 0 0.5em 1em;
570+ border: 1px solid #ddb;
571+ padding: 7px 7px 0 7px;
572+ background-color: #ffe;
573+ width: 40%;
574+ float: right;
575+}
576+
577+p.sidebar-title {
578+ font-weight: bold;
579+}
580+
581+/* -- topics ---------------------------------------------------------------- */
582+
583+div.topic {
584+ border: 1px solid #ccc;
585+ padding: 7px 7px 0 7px;
586+ margin: 10px 0 10px 0;
587+}
588+
589+p.topic-title {
590+ font-size: 1.1em;
591+ font-weight: bold;
592+ margin-top: 10px;
593+}
594+
595+/* -- admonitions ----------------------------------------------------------- */
596+
597+div.admonition {
598+ margin-top: 10px;
599+ margin-bottom: 10px;
600+ padding: 7px;
601+}
602+
603+div.admonition dt {
604+ font-weight: bold;
605+}
606+
607+div.admonition dl {
608+ margin-bottom: 0;
609+}
610+
611+p.admonition-title {
612+ margin: 0px 10px 5px 0px;
613+ font-weight: bold;
614+}
615+
616+div.body p.centered {
617+ text-align: center;
618+ margin-top: 25px;
619+}
620+
621+/* -- tables ---------------------------------------------------------------- */
622+
623+table.docutils {
624+ border: 0;
625+ border-collapse: collapse;
626+}
627+
628+table.docutils td, table.docutils th {
629+ padding: 1px 8px 1px 5px;
630+ border-top: 0;
631+ border-left: 0;
632+ border-right: 0;
633+ border-bottom: 1px solid #aaa;
634+}
635+
636+table.field-list td, table.field-list th {
637+ border: 0 !important;
638+}
639+
640+table.footnote td, table.footnote th {
641+ border: 0 !important;
642+}
643+
644+th {
645+ text-align: left;
646+ padding-right: 5px;
647+}
648+
649+table.citation {
650+ border-left: solid 1px gray;
651+ margin-left: 1px;
652+}
653+
654+table.citation td {
655+ border-bottom: none;
656+}
657+
658+/* -- other body styles ----------------------------------------------------- */
659+
660+ol.arabic {
661+ list-style: decimal;
662+}
663+
664+ol.loweralpha {
665+ list-style: lower-alpha;
666+}
667+
668+ol.upperalpha {
669+ list-style: upper-alpha;
670+}
671+
672+ol.lowerroman {
673+ list-style: lower-roman;
674+}
675+
676+ol.upperroman {
677+ list-style: upper-roman;
678+}
679+
680+dl {
681+ margin-bottom: 15px;
682+}
683+
684+dd p {
685+ margin-top: 0px;
686+}
687+
688+dd ul, dd table {
689+ margin-bottom: 10px;
690+}
691+
692+dd {
693+ margin-top: 3px;
694+ margin-bottom: 10px;
695+ margin-left: 30px;
696+}
697+
698+dt:target, .highlighted {
699+ background-color: #fbe54e;
700+}
701+
702+dl.glossary dt {
703+ font-weight: bold;
704+ font-size: 1.1em;
705+}
706+
707+.field-list ul {
708+ margin: 0;
709+ padding-left: 1em;
710+}
711+
712+.field-list p {
713+ margin: 0;
714+}
715+
716+.optional {
717+ font-size: 1.3em;
718+}
719+
720+.versionmodified {
721+ font-style: italic;
722+}
723+
724+.system-message {
725+ background-color: #fda;
726+ padding: 5px;
727+ border: 3px solid red;
728+}
729+
730+.footnote:target {
731+ background-color: #ffa;
732+}
733+
734+.line-block {
735+ display: block;
736+ margin-top: 1em;
737+ margin-bottom: 1em;
738+}
739+
740+.line-block .line-block {
741+ margin-top: 0;
742+ margin-bottom: 0;
743+ margin-left: 1.5em;
744+}
745+
746+.guilabel, .menuselection {
747+ font-family: sans-serif;
748+}
749+
750+.accelerator {
751+ text-decoration: underline;
752+}
753+
754+.classifier {
755+ font-style: oblique;
756+}
757+
758+abbr, acronym {
759+ border-bottom: dotted 1px;
760+ cursor: help;
761+}
762+
763+/* -- code displays --------------------------------------------------------- */
764+
765+pre {
766+ overflow: auto;
767+ overflow-y: hidden; /* fixes display issues on Chrome browsers */
768+}
769+
770+td.linenos pre {
771+ padding: 5px 0px;
772+ border: 0;
773+ background-color: transparent;
774+ color: #aaa;
775+}
776+
777+table.highlighttable {
778+ margin-left: 0.5em;
779+}
780+
781+table.highlighttable td {
782+ padding: 0 0.5em 0 0.5em;
783+}
784+
785+tt.descname {
786+ background-color: transparent;
787+ font-weight: bold;
788+ font-size: 1.2em;
789+}
790+
791+tt.descclassname {
792+ background-color: transparent;
793+}
794+
795+tt.xref, a tt {
796+ background-color: transparent;
797+ font-weight: bold;
798+}
799+
800+h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
801+ background-color: transparent;
802+}
803+
804+.viewcode-link {
805+ float: right;
806+}
807+
808+.viewcode-back {
809+ float: right;
810+ font-family: sans-serif;
811+}
812+
813+div.viewcode-block:target {
814+ margin: -1px -10px;
815+ padding: 0 10px;
816+}
817+
818+/* -- math display ---------------------------------------------------------- */
819+
820+img.math {
821+ vertical-align: middle;
822+}
823+
824+div.body div.math p {
825+ text-align: center;
826+}
827+
828+span.eqno {
829+ float: right;
830+}
831+
832+/* -- printout stylesheet --------------------------------------------------- */
833+
834+@media print {
835+ div.document,
836+ div.documentwrapper,
837+ div.bodywrapper {
838+ margin: 0 !important;
839+ width: 100%;
840+ }
841+
842+ div.sphinxsidebar,
843+ div.related,
844+ div.footer,
845+ #top-link {
846+ display: none;
847+ }
848+}
849\ No newline at end of file
850
851=== added file 'documentation/autopilot-helpers/_build/html/_static/comment-bright.png'
852Binary files documentation/autopilot-helpers/_build/html/_static/comment-bright.png 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/comment-bright.png 2015-04-21 12:16:30 +0000 differ
853=== added file 'documentation/autopilot-helpers/_build/html/_static/comment-close.png'
854Binary files documentation/autopilot-helpers/_build/html/_static/comment-close.png 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/comment-close.png 2015-04-21 12:16:30 +0000 differ
855=== added file 'documentation/autopilot-helpers/_build/html/_static/comment.png'
856Binary files documentation/autopilot-helpers/_build/html/_static/comment.png 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/comment.png 2015-04-21 12:16:30 +0000 differ
857=== added file 'documentation/autopilot-helpers/_build/html/_static/default.css'
858--- documentation/autopilot-helpers/_build/html/_static/default.css 1970-01-01 00:00:00 +0000
859+++ documentation/autopilot-helpers/_build/html/_static/default.css 2015-04-21 12:16:30 +0000
860@@ -0,0 +1,256 @@
861+/*
862+ * default.css_t
863+ * ~~~~~~~~~~~~~
864+ *
865+ * Sphinx stylesheet -- default theme.
866+ *
867+ * :copyright: Copyright 2007-2014 by the Sphinx team, see AUTHORS.
868+ * :license: BSD, see LICENSE for details.
869+ *
870+ */
871+
872+@import url("basic.css");
873+
874+/* -- page layout ----------------------------------------------------------- */
875+
876+body {
877+ font-family: sans-serif;
878+ font-size: 100%;
879+ background-color: #11303d;
880+ color: #000;
881+ margin: 0;
882+ padding: 0;
883+}
884+
885+div.document {
886+ background-color: #1c4e63;
887+}
888+
889+div.documentwrapper {
890+ float: left;
891+ width: 100%;
892+}
893+
894+div.bodywrapper {
895+ margin: 0 0 0 230px;
896+}
897+
898+div.body {
899+ background-color: #ffffff;
900+ color: #000000;
901+ padding: 0 20px 30px 20px;
902+}
903+
904+div.footer {
905+ color: #ffffff;
906+ width: 100%;
907+ padding: 9px 0 9px 0;
908+ text-align: center;
909+ font-size: 75%;
910+}
911+
912+div.footer a {
913+ color: #ffffff;
914+ text-decoration: underline;
915+}
916+
917+div.related {
918+ background-color: #133f52;
919+ line-height: 30px;
920+ color: #ffffff;
921+}
922+
923+div.related a {
924+ color: #ffffff;
925+}
926+
927+div.sphinxsidebar {
928+}
929+
930+div.sphinxsidebar h3 {
931+ font-family: 'Trebuchet MS', sans-serif;
932+ color: #ffffff;
933+ font-size: 1.4em;
934+ font-weight: normal;
935+ margin: 0;
936+ padding: 0;
937+}
938+
939+div.sphinxsidebar h3 a {
940+ color: #ffffff;
941+}
942+
943+div.sphinxsidebar h4 {
944+ font-family: 'Trebuchet MS', sans-serif;
945+ color: #ffffff;
946+ font-size: 1.3em;
947+ font-weight: normal;
948+ margin: 5px 0 0 0;
949+ padding: 0;
950+}
951+
952+div.sphinxsidebar p {
953+ color: #ffffff;
954+}
955+
956+div.sphinxsidebar p.topless {
957+ margin: 5px 10px 10px 10px;
958+}
959+
960+div.sphinxsidebar ul {
961+ margin: 10px;
962+ padding: 0;
963+ color: #ffffff;
964+}
965+
966+div.sphinxsidebar a {
967+ color: #98dbcc;
968+}
969+
970+div.sphinxsidebar input {
971+ border: 1px solid #98dbcc;
972+ font-family: sans-serif;
973+ font-size: 1em;
974+}
975+
976+
977+
978+/* -- hyperlink styles ------------------------------------------------------ */
979+
980+a {
981+ color: #355f7c;
982+ text-decoration: none;
983+}
984+
985+a:visited {
986+ color: #355f7c;
987+ text-decoration: none;
988+}
989+
990+a:hover {
991+ text-decoration: underline;
992+}
993+
994+
995+
996+/* -- body styles ----------------------------------------------------------- */
997+
998+div.body h1,
999+div.body h2,
1000+div.body h3,
1001+div.body h4,
1002+div.body h5,
1003+div.body h6 {
1004+ font-family: 'Trebuchet MS', sans-serif;
1005+ background-color: #f2f2f2;
1006+ font-weight: normal;
1007+ color: #20435c;
1008+ border-bottom: 1px solid #ccc;
1009+ margin: 20px -20px 10px -20px;
1010+ padding: 3px 0 3px 10px;
1011+}
1012+
1013+div.body h1 { margin-top: 0; font-size: 200%; }
1014+div.body h2 { font-size: 160%; }
1015+div.body h3 { font-size: 140%; }
1016+div.body h4 { font-size: 120%; }
1017+div.body h5 { font-size: 110%; }
1018+div.body h6 { font-size: 100%; }
1019+
1020+a.headerlink {
1021+ color: #c60f0f;
1022+ font-size: 0.8em;
1023+ padding: 0 4px 0 4px;
1024+ text-decoration: none;
1025+}
1026+
1027+a.headerlink:hover {
1028+ background-color: #c60f0f;
1029+ color: white;
1030+}
1031+
1032+div.body p, div.body dd, div.body li {
1033+ text-align: justify;
1034+ line-height: 130%;
1035+}
1036+
1037+div.admonition p.admonition-title + p {
1038+ display: inline;
1039+}
1040+
1041+div.admonition p {
1042+ margin-bottom: 5px;
1043+}
1044+
1045+div.admonition pre {
1046+ margin-bottom: 5px;
1047+}
1048+
1049+div.admonition ul, div.admonition ol {
1050+ margin-bottom: 5px;
1051+}
1052+
1053+div.note {
1054+ background-color: #eee;
1055+ border: 1px solid #ccc;
1056+}
1057+
1058+div.seealso {
1059+ background-color: #ffc;
1060+ border: 1px solid #ff6;
1061+}
1062+
1063+div.topic {
1064+ background-color: #eee;
1065+}
1066+
1067+div.warning {
1068+ background-color: #ffe4e4;
1069+ border: 1px solid #f66;
1070+}
1071+
1072+p.admonition-title {
1073+ display: inline;
1074+}
1075+
1076+p.admonition-title:after {
1077+ content: ":";
1078+}
1079+
1080+pre {
1081+ padding: 5px;
1082+ background-color: #eeffcc;
1083+ color: #333333;
1084+ line-height: 120%;
1085+ border: 1px solid #ac9;
1086+ border-left: none;
1087+ border-right: none;
1088+}
1089+
1090+tt {
1091+ background-color: #ecf0f3;
1092+ padding: 0 1px 0 1px;
1093+ font-size: 0.95em;
1094+}
1095+
1096+th {
1097+ background-color: #ede;
1098+}
1099+
1100+.warning tt {
1101+ background: #efc2c2;
1102+}
1103+
1104+.note tt {
1105+ background: #d6d6d6;
1106+}
1107+
1108+.viewcode-back {
1109+ font-family: sans-serif;
1110+}
1111+
1112+div.viewcode-block:target {
1113+ background-color: #f4debf;
1114+ border-top: 1px solid #ac9;
1115+ border-bottom: 1px solid #ac9;
1116+}
1117\ No newline at end of file
1118
1119=== added file 'documentation/autopilot-helpers/_build/html/_static/doctools.js'
1120--- documentation/autopilot-helpers/_build/html/_static/doctools.js 1970-01-01 00:00:00 +0000
1121+++ documentation/autopilot-helpers/_build/html/_static/doctools.js 2015-04-21 12:16:30 +0000
1122@@ -0,0 +1,238 @@
1123+/*
1124+ * doctools.js
1125+ * ~~~~~~~~~~~
1126+ *
1127+ * Sphinx JavaScript utilities for all documentation.
1128+ *
1129+ * :copyright: Copyright 2007-2014 by the Sphinx team, see AUTHORS.
1130+ * :license: BSD, see LICENSE for details.
1131+ *
1132+ */
1133+
1134+/**
1135+ * select a different prefix for underscore
1136+ */
1137+$u = _.noConflict();
1138+
1139+/**
1140+ * make the code below compatible with browsers without
1141+ * an installed firebug like debugger
1142+if (!window.console || !console.firebug) {
1143+ var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
1144+ "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
1145+ "profile", "profileEnd"];
1146+ window.console = {};
1147+ for (var i = 0; i < names.length; ++i)
1148+ window.console[names[i]] = function() {};
1149+}
1150+ */
1151+
1152+/**
1153+ * small helper function to urldecode strings
1154+ */
1155+jQuery.urldecode = function(x) {
1156+ return decodeURIComponent(x).replace(/\+/g, ' ');
1157+};
1158+
1159+/**
1160+ * small helper function to urlencode strings
1161+ */
1162+jQuery.urlencode = encodeURIComponent;
1163+
1164+/**
1165+ * This function returns the parsed url parameters of the
1166+ * current request. Multiple values per key are supported,
1167+ * it will always return arrays of strings for the value parts.
1168+ */
1169+jQuery.getQueryParameters = function(s) {
1170+ if (typeof s == 'undefined')
1171+ s = document.location.search;
1172+ var parts = s.substr(s.indexOf('?') + 1).split('&');
1173+ var result = {};
1174+ for (var i = 0; i < parts.length; i++) {
1175+ var tmp = parts[i].split('=', 2);
1176+ var key = jQuery.urldecode(tmp[0]);
1177+ var value = jQuery.urldecode(tmp[1]);
1178+ if (key in result)
1179+ result[key].push(value);
1180+ else
1181+ result[key] = [value];
1182+ }
1183+ return result;
1184+};
1185+
1186+/**
1187+ * highlight a given string on a jquery object by wrapping it in
1188+ * span elements with the given class name.
1189+ */
1190+jQuery.fn.highlightText = function(text, className) {
1191+ function highlight(node) {
1192+ if (node.nodeType == 3) {
1193+ var val = node.nodeValue;
1194+ var pos = val.toLowerCase().indexOf(text);
1195+ if (pos >= 0 && !jQuery(node.parentNode).hasClass(className)) {
1196+ var span = document.createElement("span");
1197+ span.className = className;
1198+ span.appendChild(document.createTextNode(val.substr(pos, text.length)));
1199+ node.parentNode.insertBefore(span, node.parentNode.insertBefore(
1200+ document.createTextNode(val.substr(pos + text.length)),
1201+ node.nextSibling));
1202+ node.nodeValue = val.substr(0, pos);
1203+ }
1204+ }
1205+ else if (!jQuery(node).is("button, select, textarea")) {
1206+ jQuery.each(node.childNodes, function() {
1207+ highlight(this);
1208+ });
1209+ }
1210+ }
1211+ return this.each(function() {
1212+ highlight(this);
1213+ });
1214+};
1215+
1216+/**
1217+ * Small JavaScript module for the documentation.
1218+ */
1219+var Documentation = {
1220+
1221+ init : function() {
1222+ this.fixFirefoxAnchorBug();
1223+ this.highlightSearchWords();
1224+ this.initIndexTable();
1225+ },
1226+
1227+ /**
1228+ * i18n support
1229+ */
1230+ TRANSLATIONS : {},
1231+ PLURAL_EXPR : function(n) { return n == 1 ? 0 : 1; },
1232+ LOCALE : 'unknown',
1233+
1234+ // gettext and ngettext don't access this so that the functions
1235+ // can safely bound to a different name (_ = Documentation.gettext)
1236+ gettext : function(string) {
1237+ var translated = Documentation.TRANSLATIONS[string];
1238+ if (typeof translated == 'undefined')
1239+ return string;
1240+ return (typeof translated == 'string') ? translated : translated[0];
1241+ },
1242+
1243+ ngettext : function(singular, plural, n) {
1244+ var translated = Documentation.TRANSLATIONS[singular];
1245+ if (typeof translated == 'undefined')
1246+ return (n == 1) ? singular : plural;
1247+ return translated[Documentation.PLURALEXPR(n)];
1248+ },
1249+
1250+ addTranslations : function(catalog) {
1251+ for (var key in catalog.messages)
1252+ this.TRANSLATIONS[key] = catalog.messages[key];
1253+ this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
1254+ this.LOCALE = catalog.locale;
1255+ },
1256+
1257+ /**
1258+ * add context elements like header anchor links
1259+ */
1260+ addContextElements : function() {
1261+ $('div[id] > :header:first').each(function() {
1262+ $('<a class="headerlink">\u00B6</a>').
1263+ attr('href', '#' + this.id).
1264+ attr('title', _('Permalink to this headline')).
1265+ appendTo(this);
1266+ });
1267+ $('dt[id]').each(function() {
1268+ $('<a class="headerlink">\u00B6</a>').
1269+ attr('href', '#' + this.id).
1270+ attr('title', _('Permalink to this definition')).
1271+ appendTo(this);
1272+ });
1273+ },
1274+
1275+ /**
1276+ * workaround a firefox stupidity
1277+ */
1278+ fixFirefoxAnchorBug : function() {
1279+ if (document.location.hash && $.browser.mozilla)
1280+ window.setTimeout(function() {
1281+ document.location.href += '';
1282+ }, 10);
1283+ },
1284+
1285+ /**
1286+ * highlight the search words provided in the url in the text
1287+ */
1288+ highlightSearchWords : function() {
1289+ var params = $.getQueryParameters();
1290+ var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
1291+ if (terms.length) {
1292+ var body = $('div.body');
1293+ if (!body.length) {
1294+ body = $('body');
1295+ }
1296+ window.setTimeout(function() {
1297+ $.each(terms, function() {
1298+ body.highlightText(this.toLowerCase(), 'highlighted');
1299+ });
1300+ }, 10);
1301+ $('<p class="highlight-link"><a href="javascript:Documentation.' +
1302+ 'hideSearchWords()">' + _('Hide Search Matches') + '</a></p>')
1303+ .appendTo($('#searchbox'));
1304+ }
1305+ },
1306+
1307+ /**
1308+ * init the domain index toggle buttons
1309+ */
1310+ initIndexTable : function() {
1311+ var togglers = $('img.toggler').click(function() {
1312+ var src = $(this).attr('src');
1313+ var idnum = $(this).attr('id').substr(7);
1314+ $('tr.cg-' + idnum).toggle();
1315+ if (src.substr(-9) == 'minus.png')
1316+ $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
1317+ else
1318+ $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
1319+ }).css('display', '');
1320+ if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
1321+ togglers.click();
1322+ }
1323+ },
1324+
1325+ /**
1326+ * helper function to hide the search marks again
1327+ */
1328+ hideSearchWords : function() {
1329+ $('#searchbox .highlight-link').fadeOut(300);
1330+ $('span.highlighted').removeClass('highlighted');
1331+ },
1332+
1333+ /**
1334+ * make the url absolute
1335+ */
1336+ makeURL : function(relativeURL) {
1337+ return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
1338+ },
1339+
1340+ /**
1341+ * get the current relative url
1342+ */
1343+ getCurrentURL : function() {
1344+ var path = document.location.pathname;
1345+ var parts = path.split(/\//);
1346+ $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
1347+ if (this == '..')
1348+ parts.pop();
1349+ });
1350+ var url = parts.join('/');
1351+ return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
1352+ }
1353+};
1354+
1355+// quick alias for translations
1356+_ = Documentation.gettext;
1357+
1358+$(document).ready(function() {
1359+ Documentation.init();
1360+});
1361
1362=== added file 'documentation/autopilot-helpers/_build/html/_static/down-pressed.png'
1363Binary files documentation/autopilot-helpers/_build/html/_static/down-pressed.png 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/down-pressed.png 2015-04-21 12:16:30 +0000 differ
1364=== added file 'documentation/autopilot-helpers/_build/html/_static/down.png'
1365Binary files documentation/autopilot-helpers/_build/html/_static/down.png 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/down.png 2015-04-21 12:16:30 +0000 differ
1366=== added file 'documentation/autopilot-helpers/_build/html/_static/favicon.ico'
1367Binary files documentation/autopilot-helpers/_build/html/_static/favicon.ico 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/favicon.ico 2015-04-21 12:16:30 +0000 differ
1368=== added file 'documentation/autopilot-helpers/_build/html/_static/file.png'
1369Binary files documentation/autopilot-helpers/_build/html/_static/file.png 1970-01-01 00:00:00 +0000 and documentation/autopilot-helpers/_build/html/_static/file.png 2015-04-21 12:16:30 +0000 differ
1370=== added file 'documentation/autopilot-helpers/_build/html/_static/jquery.js'
1371--- documentation/autopilot-helpers/_build/html/_static/jquery.js 1970-01-01 00:00:00 +0000
1372+++ documentation/autopilot-helpers/_build/html/_static/jquery.js 2015-04-21 12:16:30 +0000
1373@@ -0,0 +1,9404 @@
1374+/*!
1375+ * jQuery JavaScript Library v1.7.2
1376+ * http://jquery.com/
1377+ *
1378+ * Copyright 2011, John Resig
1379+ * Dual licensed under the MIT or GPL Version 2 licenses.
1380+ * http://jquery.org/license
1381+ *
1382+ * Includes Sizzle.js
1383+ * http://sizzlejs.com/
1384+ * Copyright 2011, The Dojo Foundation
1385+ * Released under the MIT, BSD, and GPL Licenses.
1386+ *
1387+ * Date: Wed Jul 30 14:06:55 UTC 2014
1388+ */
1389+(function( window, undefined ) {
1390+
1391+// Use the correct document accordingly with window argument (sandbox)
1392+var document = window.document,
1393+ navigator = window.navigator,
1394+ location = window.location;
1395+var jQuery = (function() {
1396+
1397+// Define a local copy of jQuery
1398+var jQuery = function( selector, context ) {
1399+ // The jQuery object is actually just the init constructor 'enhanced'
1400+ return new jQuery.fn.init( selector, context, rootjQuery );
1401+ },
1402+
1403+ // Map over jQuery in case of overwrite
1404+ _jQuery = window.jQuery,
1405+
1406+ // Map over the $ in case of overwrite
1407+ _$ = window.$,
1408+
1409+ // A central reference to the root jQuery(document)
1410+ rootjQuery,
1411+
1412+ // A simple way to check for HTML strings or ID strings
1413+ // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
1414+ quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
1415+
1416+ // Check if a string has a non-whitespace character in it
1417+ rnotwhite = /\S/,
1418+
1419+ // Used for trimming whitespace
1420+ trimLeft = /^\s+/,
1421+ trimRight = /\s+$/,
1422+
1423+ // Match a standalone tag
1424+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
1425+
1426+ // JSON RegExp
1427+ rvalidchars = /^[\],:{}\s]*$/,
1428+ rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
1429+ rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
1430+ rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
1431+
1432+ // Useragent RegExp
1433+ rwebkit = /(webkit)[ \/]([\w.]+)/,
1434+ ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
1435+ rmsie = /(msie) ([\w.]+)/,
1436+ rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
1437+
1438+ // Matches dashed string for camelizing
1439+ rdashAlpha = /-([a-z]|[0-9])/ig,
1440+ rmsPrefix = /^-ms-/,
1441+
1442+ // Used by jQuery.camelCase as callback to replace()
1443+ fcamelCase = function( all, letter ) {
1444+ return ( letter + "" ).toUpperCase();
1445+ },
1446+
1447+ // Keep a UserAgent string for use with jQuery.browser
1448+ userAgent = navigator.userAgent,
1449+
1450+ // For matching the engine and version of the browser
1451+ browserMatch,
1452+
1453+ // The deferred used on DOM ready
1454+ readyList,
1455+
1456+ // The ready event handler
1457+ DOMContentLoaded,
1458+
1459+ // Save a reference to some core methods
1460+ toString = Object.prototype.toString,
1461+ hasOwn = Object.prototype.hasOwnProperty,
1462+ push = Array.prototype.push,
1463+ slice = Array.prototype.slice,
1464+ trim = String.prototype.trim,
1465+ indexOf = Array.prototype.indexOf,
1466+
1467+ // [[Class]] -> type pairs
1468+ class2type = {};
1469+
1470+jQuery.fn = jQuery.prototype = {
1471+ constructor: jQuery,
1472+ init: function( selector, context, rootjQuery ) {
1473+ var match, elem, ret, doc;
1474+
1475+ // Handle $(""), $(null), or $(undefined)
1476+ if ( !selector ) {
1477+ return this;
1478+ }
1479+
1480+ // Handle $(DOMElement)
1481+ if ( selector.nodeType ) {
1482+ this.context = this[0] = selector;
1483+ this.length = 1;
1484+ return this;
1485+ }
1486+
1487+ // The body element only exists once, optimize finding it
1488+ if ( selector === "body" && !context && document.body ) {
1489+ this.context = document;
1490+ this[0] = document.body;
1491+ this.selector = selector;
1492+ this.length = 1;
1493+ return this;
1494+ }
1495+
1496+ // Handle HTML strings
1497+ if ( typeof selector === "string" ) {
1498+ // Are we dealing with HTML string or an ID?
1499+ if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
1500+ // Assume that strings that start and end with <> are HTML and skip the regex check
1501+ match = [ null, selector, null ];
1502+
1503+ } else {
1504+ match = quickExpr.exec( selector );
1505+ }
1506+
1507+ // Verify a match, and that no context was specified for #id
1508+ if ( match && (match[1] || !context) ) {
1509+
1510+ // HANDLE: $(html) -> $(array)
1511+ if ( match[1] ) {
1512+ context = context instanceof jQuery ? context[0] : context;
1513+ doc = ( context ? context.ownerDocument || context : document );
1514+
1515+ // If a single string is passed in and it's a single tag
1516+ // just do a createElement and skip the rest
1517+ ret = rsingleTag.exec( selector );
1518+
1519+ if ( ret ) {
1520+ if ( jQuery.isPlainObject( context ) ) {
1521+ selector = [ document.createElement( ret[1] ) ];
1522+ jQuery.fn.attr.call( selector, context, true );
1523+
1524+ } else {
1525+ selector = [ doc.createElement( ret[1] ) ];
1526+ }
1527+
1528+ } else {
1529+ ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
1530+ selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
1531+ }
1532+
1533+ return jQuery.merge( this, selector );
1534+
1535+ // HANDLE: $("#id")
1536+ } else {
1537+ elem = document.getElementById( match[2] );
1538+
1539+ // Check parentNode to catch when Blackberry 4.6 returns
1540+ // nodes that are no longer in the document #6963
1541+ if ( elem && elem.parentNode ) {
1542+ // Handle the case where IE and Opera return items
1543+ // by name instead of ID
1544+ if ( elem.id !== match[2] ) {
1545+ return rootjQuery.find( selector );
1546+ }
1547+
1548+ // Otherwise, we inject the element directly into the jQuery object
1549+ this.length = 1;
1550+ this[0] = elem;
1551+ }
1552+
1553+ this.context = document;
1554+ this.selector = selector;
1555+ return this;
1556+ }
1557+
1558+ // HANDLE: $(expr, $(...))
1559+ } else if ( !context || context.jquery ) {
1560+ return ( context || rootjQuery ).find( selector );
1561+
1562+ // HANDLE: $(expr, context)
1563+ // (which is just equivalent to: $(context).find(expr)
1564+ } else {
1565+ return this.constructor( context ).find( selector );
1566+ }
1567+
1568+ // HANDLE: $(function)
1569+ // Shortcut for document ready
1570+ } else if ( jQuery.isFunction( selector ) ) {
1571+ return rootjQuery.ready( selector );
1572+ }
1573+
1574+ if ( selector.selector !== undefined ) {
1575+ this.selector = selector.selector;
1576+ this.context = selector.context;
1577+ }
1578+
1579+ return jQuery.makeArray( selector, this );
1580+ },
1581+
1582+ // Start with an empty selector
1583+ selector: "",
1584+
1585+ // The current version of jQuery being used
1586+ jquery: "1.7.2",
1587+
1588+ // The default length of a jQuery object is 0
1589+ length: 0,
1590+
1591+ // The number of elements contained in the matched element set
1592+ size: function() {
1593+ return this.length;
1594+ },
1595+
1596+ toArray: function() {
1597+ return slice.call( this, 0 );
1598+ },
1599+
1600+ // Get the Nth element in the matched element set OR
1601+ // Get the whole matched element set as a clean array
1602+ get: function( num ) {
1603+ return num == null ?
1604+
1605+ // Return a 'clean' array
1606+ this.toArray() :
1607+
1608+ // Return just the object
1609+ ( num < 0 ? this[ this.length + num ] : this[ num ] );
1610+ },
1611+
1612+ // Take an array of elements and push it onto the stack
1613+ // (returning the new matched element set)
1614+ pushStack: function( elems, name, selector ) {
1615+ // Build a new jQuery matched element set
1616+ var ret = this.constructor();
1617+
1618+ if ( jQuery.isArray( elems ) ) {
1619+ push.apply( ret, elems );
1620+
1621+ } else {
1622+ jQuery.merge( ret, elems );
1623+ }
1624+
1625+ // Add the old object onto the stack (as a reference)
1626+ ret.prevObject = this;
1627+
1628+ ret.context = this.context;
1629+
1630+ if ( name === "find" ) {
1631+ ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
1632+ } else if ( name ) {
1633+ ret.selector = this.selector + "." + name + "(" + selector + ")";
1634+ }
1635+
1636+ // Return the newly-formed element set
1637+ return ret;
1638+ },
1639+
1640+ // Execute a callback for every element in the matched set.
1641+ // (You can seed the arguments with an array of args, but this is
1642+ // only used internally.)
1643+ each: function( callback, args ) {
1644+ return jQuery.each( this, callback, args );
1645+ },
1646+
1647+ ready: function( fn ) {
1648+ // Attach the listeners
1649+ jQuery.bindReady();
1650+
1651+ // Add the callback
1652+ readyList.add( fn );
1653+
1654+ return this;
1655+ },
1656+
1657+ eq: function( i ) {
1658+ i = +i;
1659+ return i === -1 ?
1660+ this.slice( i ) :
1661+ this.slice( i, i + 1 );
1662+ },
1663+
1664+ first: function() {
1665+ return this.eq( 0 );
1666+ },
1667+
1668+ last: function() {
1669+ return this.eq( -1 );
1670+ },
1671+
1672+ slice: function() {
1673+ return this.pushStack( slice.apply( this, arguments ),
1674+ "slice", slice.call(arguments).join(",") );
1675+ },
1676+
1677+ map: function( callback ) {
1678+ return this.pushStack( jQuery.map(this, function( elem, i ) {
1679+ return callback.call( elem, i, elem );
1680+ }));
1681+ },
1682+
1683+ end: function() {
1684+ return this.prevObject || this.constructor(null);
1685+ },
1686+
1687+ // For internal use only.
1688+ // Behaves like an Array's method, not like a jQuery method.
1689+ push: push,
1690+ sort: [].sort,
1691+ splice: [].splice
1692+};
1693+
1694+// Give the init function the jQuery prototype for later instantiation
1695+jQuery.fn.init.prototype = jQuery.fn;
1696+
1697+jQuery.extend = jQuery.fn.extend = function() {
1698+ var options, name, src, copy, copyIsArray, clone,
1699+ target = arguments[0] || {},
1700+ i = 1,
1701+ length = arguments.length,
1702+ deep = false;
1703+
1704+ // Handle a deep copy situation
1705+ if ( typeof target === "boolean" ) {
1706+ deep = target;
1707+ target = arguments[1] || {};
1708+ // skip the boolean and the target
1709+ i = 2;
1710+ }
1711+
1712+ // Handle case when target is a string or something (possible in deep copy)
1713+ if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
1714+ target = {};
1715+ }
1716+
1717+ // extend jQuery itself if only one argument is passed
1718+ if ( length === i ) {
1719+ target = this;
1720+ --i;
1721+ }
1722+
1723+ for ( ; i < length; i++ ) {
1724+ // Only deal with non-null/undefined values
1725+ if ( (options = arguments[ i ]) != null ) {
1726+ // Extend the base object
1727+ for ( name in options ) {
1728+ src = target[ name ];
1729+ copy = options[ name ];
1730+
1731+ // Prevent never-ending loop
1732+ if ( target === copy ) {
1733+ continue;
1734+ }
1735+
1736+ // Recurse if we're merging plain objects or arrays
1737+ if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
1738+ if ( copyIsArray ) {
1739+ copyIsArray = false;
1740+ clone = src && jQuery.isArray(src) ? src : [];
1741+
1742+ } else {
1743+ clone = src && jQuery.isPlainObject(src) ? src : {};
1744+ }
1745+
1746+ // Never move original objects, clone them
1747+ target[ name ] = jQuery.extend( deep, clone, copy );
1748+
1749+ // Don't bring in undefined values
1750+ } else if ( copy !== undefined ) {
1751+ target[ name ] = copy;
1752+ }
1753+ }
1754+ }
1755+ }
1756+
1757+ // Return the modified object
1758+ return target;
1759+};
1760+
1761+jQuery.extend({
1762+ noConflict: function( deep ) {
1763+ if ( window.$ === jQuery ) {
1764+ window.$ = _$;
1765+ }
1766+
1767+ if ( deep && window.jQuery === jQuery ) {
1768+ window.jQuery = _jQuery;
1769+ }
1770+
1771+ return jQuery;
1772+ },
1773+
1774+ // Is the DOM ready to be used? Set to true once it occurs.
1775+ isReady: false,
1776+
1777+ // A counter to track how many items to wait for before
1778+ // the ready event fires. See #6781
1779+ readyWait: 1,
1780+
1781+ // Hold (or release) the ready event
1782+ holdReady: function( hold ) {
1783+ if ( hold ) {
1784+ jQuery.readyWait++;
1785+ } else {
1786+ jQuery.ready( true );
1787+ }
1788+ },
1789+
1790+ // Handle when the DOM is ready
1791+ ready: function( wait ) {
1792+ // Either a released hold or an DOMready/load event and not yet ready
1793+ if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
1794+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
1795+ if ( !document.body ) {
1796+ return setTimeout( jQuery.ready, 1 );
1797+ }
1798+
1799+ // Remember that the DOM is ready
1800+ jQuery.isReady = true;
1801+
1802+ // If a normal DOM Ready event fired, decrement, and wait if need be
1803+ if ( wait !== true && --jQuery.readyWait > 0 ) {
1804+ return;
1805+ }
1806+
1807+ // If there are functions bound, to execute
1808+ readyList.fireWith( document, [ jQuery ] );
1809+
1810+ // Trigger any bound ready events
1811+ if ( jQuery.fn.trigger ) {
1812+ jQuery( document ).trigger( "ready" ).off( "ready" );
1813+ }
1814+ }
1815+ },
1816+
1817+ bindReady: function() {
1818+ if ( readyList ) {
1819+ return;
1820+ }
1821+
1822+ readyList = jQuery.Callbacks( "once memory" );
1823+
1824+ // Catch cases where $(document).ready() is called after the
1825+ // browser event has already occurred.
1826+ if ( document.readyState === "complete" ) {
1827+ // Handle it asynchronously to allow scripts the opportunity to delay ready
1828+ return setTimeout( jQuery.ready, 1 );
1829+ }
1830+
1831+ // Mozilla, Opera and webkit nightlies currently support this event
1832+ if ( document.addEventListener ) {
1833+ // Use the handy event callback
1834+ document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
1835+
1836+ // A fallback to window.onload, that will always work
1837+ window.addEventListener( "load", jQuery.ready, false );
1838+
1839+ // If IE event model is used
1840+ } else if ( document.attachEvent ) {
1841+ // ensure firing before onload,
1842+ // maybe late but safe also for iframes
1843+ document.attachEvent( "onreadystatechange", DOMContentLoaded );
1844+
1845+ // A fallback to window.onload, that will always work
1846+ window.attachEvent( "onload", jQuery.ready );
1847+
1848+ // If IE and not a frame
1849+ // continually check to see if the document is ready
1850+ var toplevel = false;
1851+
1852+ try {
1853+ toplevel = window.frameElement == null;
1854+ } catch(e) {}
1855+
1856+ if ( document.documentElement.doScroll && toplevel ) {
1857+ doScrollCheck();
1858+ }
1859+ }
1860+ },
1861+
1862+ // See test/unit/core.js for details concerning isFunction.
1863+ // Since version 1.3, DOM methods and functions like alert
1864+ // aren't supported. They return false on IE (#2968).
1865+ isFunction: function( obj ) {
1866+ return jQuery.type(obj) === "function";
1867+ },
1868+
1869+ isArray: Array.isArray || function( obj ) {
1870+ return jQuery.type(obj) === "array";
1871+ },
1872+
1873+ isWindow: function( obj ) {
1874+ return obj != null && obj == obj.window;
1875+ },
1876+
1877+ isNumeric: function( obj ) {
1878+ return !isNaN( parseFloat(obj) ) && isFinite( obj );
1879+ },
1880+
1881+ type: function( obj ) {
1882+ return obj == null ?
1883+ String( obj ) :
1884+ class2type[ toString.call(obj) ] || "object";
1885+ },
1886+
1887+ isPlainObject: function( obj ) {
1888+ // Must be an Object.
1889+ // Because of IE, we also have to check the presence of the constructor property.
1890+ // Make sure that DOM nodes and window objects don't pass through, as well
1891+ if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
1892+ return false;
1893+ }
1894+
1895+ try {
1896+ // Not own constructor property must be Object
1897+ if ( obj.constructor &&
1898+ !hasOwn.call(obj, "constructor") &&
1899+ !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
1900+ return false;
1901+ }
1902+ } catch ( e ) {
1903+ // IE8,9 Will throw exceptions on certain host objects #9897
1904+ return false;
1905+ }
1906+
1907+ // Own properties are enumerated firstly, so to speed up,
1908+ // if last one is own, then all properties are own.
1909+
1910+ var key;
1911+ for ( key in obj ) {}
1912+
1913+ return key === undefined || hasOwn.call( obj, key );
1914+ },
1915+
1916+ isEmptyObject: function( obj ) {
1917+ for ( var name in obj ) {
1918+ return false;
1919+ }
1920+ return true;
1921+ },
1922+
1923+ error: function( msg ) {
1924+ throw new Error( msg );
1925+ },
1926+
1927+ parseJSON: function( data ) {
1928+ if ( typeof data !== "string" || !data ) {
1929+ return null;
1930+ }
1931+
1932+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
1933+ data = jQuery.trim( data );
1934+
1935+ // Attempt to parse using the native JSON parser first
1936+ if ( window.JSON && window.JSON.parse ) {
1937+ return window.JSON.parse( data );
1938+ }
1939+
1940+ // Make sure the incoming data is actual JSON
1941+ // Logic borrowed from http://json.org/json2.js
1942+ if ( rvalidchars.test( data.replace( rvalidescape, "@" )
1943+ .replace( rvalidtokens, "]" )
1944+ .replace( rvalidbraces, "")) ) {
1945+
1946+ return ( new Function( "return " + data ) )();
1947+
1948+ }
1949+ jQuery.error( "Invalid JSON: " + data );
1950+ },
1951+
1952+ // Cross-browser xml parsing
1953+ parseXML: function( data ) {
1954+ if ( typeof data !== "string" || !data ) {
1955+ return null;
1956+ }
1957+ var xml, tmp;
1958+ try {
1959+ if ( window.DOMParser ) { // Standard
1960+ tmp = new DOMParser();
1961+ xml = tmp.parseFromString( data , "text/xml" );
1962+ } else { // IE
1963+ xml = new ActiveXObject( "Microsoft.XMLDOM" );
1964+ xml.async = "false";
1965+ xml.loadXML( data );
1966+ }
1967+ } catch( e ) {
1968+ xml = undefined;
1969+ }
1970+ if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
1971+ jQuery.error( "Invalid XML: " + data );
1972+ }
1973+ return xml;
1974+ },
1975+
1976+ noop: function() {},
1977+
1978+ // Evaluates a script in a global context
1979+ // Workarounds based on findings by Jim Driscoll
1980+ // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
1981+ globalEval: function( data ) {
1982+ if ( data && rnotwhite.test( data ) ) {
1983+ // We use execScript on Internet Explorer
1984+ // We use an anonymous function so that context is window
1985+ // rather than jQuery in Firefox
1986+ ( window.execScript || function( data ) {
1987+ window[ "eval" ].call( window, data );
1988+ } )( data );
1989+ }
1990+ },
1991+
1992+ // Convert dashed to camelCase; used by the css and data modules
1993+ // Microsoft forgot to hump their vendor prefix (#9572)
1994+ camelCase: function( string ) {
1995+ return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
1996+ },
1997+
1998+ nodeName: function( elem, name ) {
1999+ return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
2000+ },
2001+
2002+ // args is for internal usage only
2003+ each: function( object, callback, args ) {
2004+ var name, i = 0,
2005+ length = object.length,
2006+ isObj = length === undefined || jQuery.isFunction( object );
2007+
2008+ if ( args ) {
2009+ if ( isObj ) {
2010+ for ( name in object ) {
2011+ if ( callback.apply( object[ name ], args ) === false ) {
2012+ break;
2013+ }
2014+ }
2015+ } else {
2016+ for ( ; i < length; ) {
2017+ if ( callback.apply( object[ i++ ], args ) === false ) {
2018+ break;
2019+ }
2020+ }
2021+ }
2022+
2023+ // A special, fast, case for the most common use of each
2024+ } else {
2025+ if ( isObj ) {
2026+ for ( name in object ) {
2027+ if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
2028+ break;
2029+ }
2030+ }
2031+ } else {
2032+ for ( ; i < length; ) {
2033+ if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
2034+ break;
2035+ }
2036+ }
2037+ }
2038+ }
2039+
2040+ return object;
2041+ },
2042+
2043+ // Use native String.trim function wherever possible
2044+ trim: trim ?
2045+ function( text ) {
2046+ return text == null ?
2047+ "" :
2048+ trim.call( text );
2049+ } :
2050+
2051+ // Otherwise use our own trimming functionality
2052+ function( text ) {
2053+ return text == null ?
2054+ "" :
2055+ text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
2056+ },
2057+
2058+ // results is for internal usage only
2059+ makeArray: function( array, results ) {
2060+ var ret = results || [];
2061+
2062+ if ( array != null ) {
2063+ // The window, strings (and functions) also have 'length'
2064+ // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
2065+ var type = jQuery.type( array );
2066+
2067+ if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
2068+ push.call( ret, array );
2069+ } else {
2070+ jQuery.merge( ret, array );
2071+ }
2072+ }
2073+
2074+ return ret;
2075+ },
2076+
2077+ inArray: function( elem, array, i ) {
2078+ var len;
2079+
2080+ if ( array ) {
2081+ if ( indexOf ) {
2082+ return indexOf.call( array, elem, i );
2083+ }
2084+
2085+ len = array.length;
2086+ i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
2087+
2088+ for ( ; i < len; i++ ) {
2089+ // Skip accessing in sparse arrays
2090+ if ( i in array && array[ i ] === elem ) {
2091+ return i;
2092+ }
2093+ }
2094+ }
2095+
2096+ return -1;
2097+ },
2098+
2099+ merge: function( first, second ) {
2100+ var i = first.length,
2101+ j = 0;
2102+
2103+ if ( typeof second.length === "number" ) {
2104+ for ( var l = second.length; j < l; j++ ) {
2105+ first[ i++ ] = second[ j ];
2106+ }
2107+
2108+ } else {
2109+ while ( second[j] !== undefined ) {
2110+ first[ i++ ] = second[ j++ ];
2111+ }
2112+ }
2113+
2114+ first.length = i;
2115+
2116+ return first;
2117+ },
2118+
2119+ grep: function( elems, callback, inv ) {
2120+ var ret = [], retVal;
2121+ inv = !!inv;
2122+
2123+ // Go through the array, only saving the items
2124+ // that pass the validator function
2125+ for ( var i = 0, length = elems.length; i < length; i++ ) {
2126+ retVal = !!callback( elems[ i ], i );
2127+ if ( inv !== retVal ) {
2128+ ret.push( elems[ i ] );
2129+ }
2130+ }
2131+
2132+ return ret;
2133+ },
2134+
2135+ // arg is for internal usage only
2136+ map: function( elems, callback, arg ) {
2137+ var value, key, ret = [],
2138+ i = 0,
2139+ length = elems.length,
2140+ // jquery objects are treated as arrays
2141+ isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
2142+
2143+ // Go through the array, translating each of the items to their
2144+ if ( isArray ) {
2145+ for ( ; i < length; i++ ) {
2146+ value = callback( elems[ i ], i, arg );
2147+
2148+ if ( value != null ) {
2149+ ret[ ret.length ] = value;
2150+ }
2151+ }
2152+
2153+ // Go through every key on the object,
2154+ } else {
2155+ for ( key in elems ) {
2156+ value = callback( elems[ key ], key, arg );
2157+
2158+ if ( value != null ) {
2159+ ret[ ret.length ] = value;
2160+ }
2161+ }
2162+ }
2163+
2164+ // Flatten any nested arrays
2165+ return ret.concat.apply( [], ret );
2166+ },
2167+
2168+ // A global GUID counter for objects
2169+ guid: 1,
2170+
2171+ // Bind a function to a context, optionally partially applying any
2172+ // arguments.
2173+ proxy: function( fn, context ) {
2174+ if ( typeof context === "string" ) {
2175+ var tmp = fn[ context ];
2176+ context = fn;
2177+ fn = tmp;
2178+ }
2179+
2180+ // Quick check to determine if target is callable, in the spec
2181+ // this throws a TypeError, but we will just return undefined.
2182+ if ( !jQuery.isFunction( fn ) ) {
2183+ return undefined;
2184+ }
2185+
2186+ // Simulated bind
2187+ var args = slice.call( arguments, 2 ),
2188+ proxy = function() {
2189+ return fn.apply( context, args.concat( slice.call( arguments ) ) );
2190+ };
2191+
2192+ // Set the guid of unique handler to the same of original handler, so it can be removed
2193+ proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
2194+
2195+ return proxy;
2196+ },
2197+
2198+ // Mutifunctional method to get and set values to a collection
2199+ // The value/s can optionally be executed if it's a function
2200+ access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
2201+ var exec,
2202+ bulk = key == null,
2203+ i = 0,
2204+ length = elems.length;
2205+
2206+ // Sets many values
2207+ if ( key && typeof key === "object" ) {
2208+ for ( i in key ) {
2209+ jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
2210+ }
2211+ chainable = 1;
2212+
2213+ // Sets one value
2214+ } else if ( value !== undefined ) {
2215+ // Optionally, function values get executed if exec is true
2216+ exec = pass === undefined && jQuery.isFunction( value );
2217+
2218+ if ( bulk ) {
2219+ // Bulk operations only iterate when executing function values
2220+ if ( exec ) {
2221+ exec = fn;
2222+ fn = function( elem, key, value ) {
2223+ return exec.call( jQuery( elem ), value );
2224+ };
2225+
2226+ // Otherwise they run against the entire set
2227+ } else {
2228+ fn.call( elems, value );
2229+ fn = null;
2230+ }
2231+ }
2232+
2233+ if ( fn ) {
2234+ for (; i < length; i++ ) {
2235+ fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
2236+ }
2237+ }
2238+
2239+ chainable = 1;
2240+ }
2241+
2242+ return chainable ?
2243+ elems :
2244+
2245+ // Gets
2246+ bulk ?
2247+ fn.call( elems ) :
2248+ length ? fn( elems[0], key ) : emptyGet;
2249+ },
2250+
2251+ now: function() {
2252+ return ( new Date() ).getTime();
2253+ },
2254+
2255+ // Use of jQuery.browser is frowned upon.
2256+ // More details: http://docs.jquery.com/Utilities/jQuery.browser
2257+ uaMatch: function( ua ) {
2258+ ua = ua.toLowerCase();
2259+
2260+ var match = rwebkit.exec( ua ) ||
2261+ ropera.exec( ua ) ||
2262+ rmsie.exec( ua ) ||
2263+ ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
2264+ [];
2265+
2266+ return { browser: match[1] || "", version: match[2] || "0" };
2267+ },
2268+
2269+ sub: function() {
2270+ function jQuerySub( selector, context ) {
2271+ return new jQuerySub.fn.init( selector, context );
2272+ }
2273+ jQuery.extend( true, jQuerySub, this );
2274+ jQuerySub.superclass = this;
2275+ jQuerySub.fn = jQuerySub.prototype = this();
2276+ jQuerySub.fn.constructor = jQuerySub;
2277+ jQuerySub.sub = this.sub;
2278+ jQuerySub.fn.init = function init( selector, context ) {
2279+ if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
2280+ context = jQuerySub( context );
2281+ }
2282+
2283+ return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
2284+ };
2285+ jQuerySub.fn.init.prototype = jQuerySub.fn;
2286+ var rootjQuerySub = jQuerySub(document);
2287+ return jQuerySub;
2288+ },
2289+
2290+ browser: {}
2291+});
2292+
2293+// Populate the class2type map
2294+jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
2295+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
2296+});
2297+
2298+browserMatch = jQuery.uaMatch( userAgent );
2299+if ( browserMatch.browser ) {
2300+ jQuery.browser[ browserMatch.browser ] = true;
2301+ jQuery.browser.version = browserMatch.version;
2302+}
2303+
2304+// Deprecated, use jQuery.browser.webkit instead
2305+if ( jQuery.browser.webkit ) {
2306+ jQuery.browser.safari = true;
2307+}
2308+
2309+// IE doesn't match non-breaking spaces with \s
2310+if ( rnotwhite.test( "\xA0" ) ) {
2311+ trimLeft = /^[\s\xA0]+/;
2312+ trimRight = /[\s\xA0]+$/;
2313+}
2314+
2315+// All jQuery objects should point back to these
2316+rootjQuery = jQuery(document);
2317+
2318+// Cleanup functions for the document ready method
2319+if ( document.addEventListener ) {
2320+ DOMContentLoaded = function() {
2321+ document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
2322+ jQuery.ready();
2323+ };
2324+
2325+} else if ( document.attachEvent ) {
2326+ DOMContentLoaded = function() {
2327+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
2328+ if ( document.readyState === "complete" ) {
2329+ document.detachEvent( "onreadystatechange", DOMContentLoaded );
2330+ jQuery.ready();
2331+ }
2332+ };
2333+}
2334+
2335+// The DOM ready check for Internet Explorer
2336+function doScrollCheck() {
2337+ if ( jQuery.isReady ) {
2338+ return;
2339+ }
2340+
2341+ try {
2342+ // If IE is used, use the trick by Diego Perini
2343+ // http://javascript.nwbox.com/IEContentLoaded/
2344+ document.documentElement.doScroll("left");
2345+ } catch(e) {
2346+ setTimeout( doScrollCheck, 1 );
2347+ return;
2348+ }
2349+
2350+ // and execute any waiting functions
2351+ jQuery.ready();
2352+}
2353+
2354+return jQuery;
2355+
2356+})();
2357+
2358+
2359+// String to Object flags format cache
2360+var flagsCache = {};
2361+
2362+// Convert String-formatted flags into Object-formatted ones and store in cache
2363+function createFlags( flags ) {
2364+ var object = flagsCache[ flags ] = {},
2365+ i, length;
2366+ flags = flags.split( /\s+/ );
2367+ for ( i = 0, length = flags.length; i < length; i++ ) {
2368+ object[ flags[i] ] = true;
2369+ }
2370+ return object;
2371+}
2372+
2373+/*
2374+ * Create a callback list using the following parameters:
2375+ *
2376+ * flags: an optional list of space-separated flags that will change how
2377+ * the callback list behaves
2378+ *
2379+ * By default a callback list will act like an event callback list and can be
2380+ * "fired" multiple times.
2381+ *
2382+ * Possible flags:
2383+ *
2384+ * once: will ensure the callback list can only be fired once (like a Deferred)
2385+ *
2386+ * memory: will keep track of previous values and will call any callback added
2387+ * after the list has been fired right away with the latest "memorized"
2388+ * values (like a Deferred)
2389+ *
2390+ * unique: will ensure a callback can only be added once (no duplicate in the list)
2391+ *
2392+ * stopOnFalse: interrupt callings when a callback returns false
2393+ *
2394+ */
2395+jQuery.Callbacks = function( flags ) {
2396+
2397+ // Convert flags from String-formatted to Object-formatted
2398+ // (we check in cache first)
2399+ flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
2400+
2401+ var // Actual callback list
2402+ list = [],
2403+ // Stack of fire calls for repeatable lists
2404+ stack = [],
2405+ // Last fire value (for non-forgettable lists)
2406+ memory,
2407+ // Flag to know if list was already fired
2408+ fired,
2409+ // Flag to know if list is currently firing
2410+ firing,
2411+ // First callback to fire (used internally by add and fireWith)
2412+ firingStart,
2413+ // End of the loop when firing
2414+ firingLength,
2415+ // Index of currently firing callback (modified by remove if needed)
2416+ firingIndex,
2417+ // Add one or several callbacks to the list
2418+ add = function( args ) {
2419+ var i,
2420+ length,
2421+ elem,
2422+ type,
2423+ actual;
2424+ for ( i = 0, length = args.length; i < length; i++ ) {
2425+ elem = args[ i ];
2426+ type = jQuery.type( elem );
2427+ if ( type === "array" ) {
2428+ // Inspect recursively
2429+ add( elem );
2430+ } else if ( type === "function" ) {
2431+ // Add if not in unique mode and callback is not in
2432+ if ( !flags.unique || !self.has( elem ) ) {
2433+ list.push( elem );
2434+ }
2435+ }
2436+ }
2437+ },
2438+ // Fire callbacks
2439+ fire = function( context, args ) {
2440+ args = args || [];
2441+ memory = !flags.memory || [ context, args ];
2442+ fired = true;
2443+ firing = true;
2444+ firingIndex = firingStart || 0;
2445+ firingStart = 0;
2446+ firingLength = list.length;
2447+ for ( ; list && firingIndex < firingLength; firingIndex++ ) {
2448+ if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
2449+ memory = true; // Mark as halted
2450+ break;
2451+ }
2452+ }
2453+ firing = false;
2454+ if ( list ) {
2455+ if ( !flags.once ) {
2456+ if ( stack && stack.length ) {
2457+ memory = stack.shift();
2458+ self.fireWith( memory[ 0 ], memory[ 1 ] );
2459+ }
2460+ } else if ( memory === true ) {
2461+ self.disable();
2462+ } else {
2463+ list = [];
2464+ }
2465+ }
2466+ },
2467+ // Actual Callbacks object
2468+ self = {
2469+ // Add a callback or a collection of callbacks to the list
2470+ add: function() {
2471+ if ( list ) {
2472+ var length = list.length;
2473+ add( arguments );
2474+ // Do we need to add the callbacks to the
2475+ // current firing batch?
2476+ if ( firing ) {
2477+ firingLength = list.length;
2478+ // With memory, if we're not firing then
2479+ // we should call right away, unless previous
2480+ // firing was halted (stopOnFalse)
2481+ } else if ( memory && memory !== true ) {
2482+ firingStart = length;
2483+ fire( memory[ 0 ], memory[ 1 ] );
2484+ }
2485+ }
2486+ return this;
2487+ },
2488+ // Remove a callback from the list
2489+ remove: function() {
2490+ if ( list ) {
2491+ var args = arguments,
2492+ argIndex = 0,
2493+ argLength = args.length;
2494+ for ( ; argIndex < argLength ; argIndex++ ) {
2495+ for ( var i = 0; i < list.length; i++ ) {
2496+ if ( args[ argIndex ] === list[ i ] ) {
2497+ // Handle firingIndex and firingLength
2498+ if ( firing ) {
2499+ if ( i <= firingLength ) {
2500+ firingLength--;
2501+ if ( i <= firingIndex ) {
2502+ firingIndex--;
2503+ }
2504+ }
2505+ }
2506+ // Remove the element
2507+ list.splice( i--, 1 );
2508+ // If we have some unicity property then
2509+ // we only need to do this once
2510+ if ( flags.unique ) {
2511+ break;
2512+ }
2513+ }
2514+ }
2515+ }
2516+ }
2517+ return this;
2518+ },
2519+ // Control if a given callback is in the list
2520+ has: function( fn ) {
2521+ if ( list ) {
2522+ var i = 0,
2523+ length = list.length;
2524+ for ( ; i < length; i++ ) {
2525+ if ( fn === list[ i ] ) {
2526+ return true;
2527+ }
2528+ }
2529+ }
2530+ return false;
2531+ },
2532+ // Remove all callbacks from the list
2533+ empty: function() {
2534+ list = [];
2535+ return this;
2536+ },
2537+ // Have the list do nothing anymore
2538+ disable: function() {
2539+ list = stack = memory = undefined;
2540+ return this;
2541+ },
2542+ // Is it disabled?
2543+ disabled: function() {
2544+ return !list;
2545+ },
2546+ // Lock the list in its current state
2547+ lock: function() {
2548+ stack = undefined;
2549+ if ( !memory || memory === true ) {
2550+ self.disable();
2551+ }
2552+ return this;
2553+ },
2554+ // Is it locked?
2555+ locked: function() {
2556+ return !stack;
2557+ },
2558+ // Call all callbacks with the given context and arguments
2559+ fireWith: function( context, args ) {
2560+ if ( stack ) {
2561+ if ( firing ) {
2562+ if ( !flags.once ) {
2563+ stack.push( [ context, args ] );
2564+ }
2565+ } else if ( !( flags.once && memory ) ) {
2566+ fire( context, args );
2567+ }
2568+ }
2569+ return this;
2570+ },
2571+ // Call all the callbacks with the given arguments
2572+ fire: function() {
2573+ self.fireWith( this, arguments );
2574+ return this;
2575+ },
2576+ // To know if the callbacks have already been called at least once
2577+ fired: function() {
2578+ return !!fired;
2579+ }
2580+ };
2581+
2582+ return self;
2583+};
2584+
2585+
2586+
2587+
2588+var // Static reference to slice
2589+ sliceDeferred = [].slice;
2590+
2591+jQuery.extend({
2592+
2593+ Deferred: function( func ) {
2594+ var doneList = jQuery.Callbacks( "once memory" ),
2595+ failList = jQuery.Callbacks( "once memory" ),
2596+ progressList = jQuery.Callbacks( "memory" ),
2597+ state = "pending",
2598+ lists = {
2599+ resolve: doneList,
2600+ reject: failList,
2601+ notify: progressList
2602+ },
2603+ promise = {
2604+ done: doneList.add,
2605+ fail: failList.add,
2606+ progress: progressList.add,
2607+
2608+ state: function() {
2609+ return state;
2610+ },
2611+
2612+ // Deprecated
2613+ isResolved: doneList.fired,
2614+ isRejected: failList.fired,
2615+
2616+ then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
2617+ deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
2618+ return this;
2619+ },
2620+ always: function() {
2621+ deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
2622+ return this;
2623+ },
2624+ pipe: function( fnDone, fnFail, fnProgress ) {
2625+ return jQuery.Deferred(function( newDefer ) {
2626+ jQuery.each( {
2627+ done: [ fnDone, "resolve" ],
2628+ fail: [ fnFail, "reject" ],
2629+ progress: [ fnProgress, "notify" ]
2630+ }, function( handler, data ) {
2631+ var fn = data[ 0 ],
2632+ action = data[ 1 ],
2633+ returned;
2634+ if ( jQuery.isFunction( fn ) ) {
2635+ deferred[ handler ](function() {
2636+ returned = fn.apply( this, arguments );
2637+ if ( returned && jQuery.isFunction( returned.promise ) ) {
2638+ returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
2639+ } else {
2640+ newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
2641+ }
2642+ });
2643+ } else {
2644+ deferred[ handler ]( newDefer[ action ] );
2645+ }
2646+ });
2647+ }).promise();
2648+ },
2649+ // Get a promise for this deferred
2650+ // If obj is provided, the promise aspect is added to the object
2651+ promise: function( obj ) {
2652+ if ( obj == null ) {
2653+ obj = promise;
2654+ } else {
2655+ for ( var key in promise ) {
2656+ obj[ key ] = promise[ key ];
2657+ }
2658+ }
2659+ return obj;
2660+ }
2661+ },
2662+ deferred = promise.promise({}),
2663+ key;
2664+
2665+ for ( key in lists ) {
2666+ deferred[ key ] = lists[ key ].fire;
2667+ deferred[ key + "With" ] = lists[ key ].fireWith;
2668+ }
2669+
2670+ // Handle state
2671+ deferred.done( function() {
2672+ state = "resolved";
2673+ }, failList.disable, progressList.lock ).fail( function() {
2674+ state = "rejected";
2675+ }, doneList.disable, progressList.lock );
2676+
2677+ // Call given func if any
2678+ if ( func ) {
2679+ func.call( deferred, deferred );
2680+ }
2681+
2682+ // All done!
2683+ return deferred;
2684+ },
2685+
2686+ // Deferred helper
2687+ when: function( firstParam ) {
2688+ var args = sliceDeferred.call( arguments, 0 ),
2689+ i = 0,
2690+ length = args.length,
2691+ pValues = new Array( length ),
2692+ count = length,
2693+ pCount = length,
2694+ deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
2695+ firstParam :
2696+ jQuery.Deferred(),
2697+ promise = deferred.promise();
2698+ function resolveFunc( i ) {
2699+ return function( value ) {
2700+ args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
2701+ if ( !( --count ) ) {
2702+ deferred.resolveWith( deferred, args );
2703+ }
2704+ };
2705+ }
2706+ function progressFunc( i ) {
2707+ return function( value ) {
2708+ pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
2709+ deferred.notifyWith( promise, pValues );
2710+ };
2711+ }
2712+ if ( length > 1 ) {
2713+ for ( ; i < length; i++ ) {
2714+ if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
2715+ args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
2716+ } else {
2717+ --count;
2718+ }
2719+ }
2720+ if ( !count ) {
2721+ deferred.resolveWith( deferred, args );
2722+ }
2723+ } else if ( deferred !== firstParam ) {
2724+ deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
2725+ }
2726+ return promise;
2727+ }
2728+});
2729+
2730+
2731+
2732+
2733+jQuery.support = (function() {
2734+
2735+ var support,
2736+ all,
2737+ a,
2738+ select,
2739+ opt,
2740+ input,
2741+ fragment,
2742+ tds,
2743+ events,
2744+ eventName,
2745+ i,
2746+ isSupported,
2747+ div = document.createElement( "div" ),
2748+ documentElement = document.documentElement;
2749+
2750+ // Preliminary tests
2751+ div.setAttribute("className", "t");
2752+ div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
2753+
2754+ all = div.getElementsByTagName( "*" );
2755+ a = div.getElementsByTagName( "a" )[ 0 ];
2756+
2757+ // Can't get basic test support
2758+ if ( !all || !all.length || !a ) {
2759+ return {};
2760+ }
2761+
2762+ // First batch of supports tests
2763+ select = document.createElement( "select" );
2764+ opt = select.appendChild( document.createElement("option") );
2765+ input = div.getElementsByTagName( "input" )[ 0 ];
2766+
2767+ support = {
2768+ // IE strips leading whitespace when .innerHTML is used
2769+ leadingWhitespace: ( div.firstChild.nodeType === 3 ),
2770+
2771+ // Make sure that tbody elements aren't automatically inserted
2772+ // IE will insert them into empty tables
2773+ tbody: !div.getElementsByTagName("tbody").length,
2774+
2775+ // Make sure that link elements get serialized correctly by innerHTML
2776+ // This requires a wrapper element in IE
2777+ htmlSerialize: !!div.getElementsByTagName("link").length,
2778+
2779+ // Get the style information from getAttribute
2780+ // (IE uses .cssText instead)
2781+ style: /top/.test( a.getAttribute("style") ),
2782+
2783+ // Make sure that URLs aren't manipulated
2784+ // (IE normalizes it by default)
2785+ hrefNormalized: ( a.getAttribute("href") === "/a" ),
2786+
2787+ // Make sure that element opacity exists
2788+ // (IE uses filter instead)
2789+ // Use a regex to work around a WebKit issue. See #5145
2790+ opacity: /^0.55/.test( a.style.opacity ),
2791+
2792+ // Verify style float existence
2793+ // (IE uses styleFloat instead of cssFloat)
2794+ cssFloat: !!a.style.cssFloat,
2795+
2796+ // Make sure that if no value is specified for a checkbox
2797+ // that it defaults to "on".
2798+ // (WebKit defaults to "" instead)
2799+ checkOn: ( input.value === "on" ),
2800+
2801+ // Make sure that a selected-by-default option has a working selected property.
2802+ // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
2803+ optSelected: opt.selected,
2804+
2805+ // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
2806+ getSetAttribute: div.className !== "t",
2807+
2808+ // Tests for enctype support on a form(#6743)
2809+ enctype: !!document.createElement("form").enctype,
2810+
2811+ // Makes sure cloning an html5 element does not cause problems
2812+ // Where outerHTML is undefined, this still works
2813+ html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
2814+
2815+ // Will be defined later
2816+ submitBubbles: true,
2817+ changeBubbles: true,
2818+ focusinBubbles: false,
2819+ deleteExpando: true,
2820+ noCloneEvent: true,
2821+ inlineBlockNeedsLayout: false,
2822+ shrinkWrapBlocks: false,
2823+ reliableMarginRight: true,
2824+ pixelMargin: true
2825+ };
2826+
2827+ // jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead
2828+ jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat");
2829+
2830+ // Make sure checked status is properly cloned
2831+ input.checked = true;
2832+ support.noCloneChecked = input.cloneNode( true ).checked;
2833+
2834+ // Make sure that the options inside disabled selects aren't marked as disabled
2835+ // (WebKit marks them as disabled)
2836+ select.disabled = true;
2837+ support.optDisabled = !opt.disabled;
2838+
2839+ // Test to see if it's possible to delete an expando from an element
2840+ // Fails in Internet Explorer
2841+ try {
2842+ delete div.test;
2843+ } catch( e ) {
2844+ support.deleteExpando = false;
2845+ }
2846+
2847+ if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
2848+ div.attachEvent( "onclick", function() {
2849+ // Cloning a node shouldn't copy over any
2850+ // bound event handlers (IE does this)
2851+ support.noCloneEvent = false;
2852+ });
2853+ div.cloneNode( true ).fireEvent( "onclick" );
2854+ }
2855+
2856+ // Check if a radio maintains its value
2857+ // after being appended to the DOM
2858+ input = document.createElement("input");
2859+ input.value = "t";
2860+ input.setAttribute("type", "radio");
2861+ support.radioValue = input.value === "t";
2862+
2863+ input.setAttribute("checked", "checked");
2864+
2865+ // #11217 - WebKit loses check when the name is after the checked attribute
2866+ input.setAttribute( "name", "t" );
2867+
2868+ div.appendChild( input );
2869+ fragment = document.createDocumentFragment();
2870+ fragment.appendChild( div.lastChild );
2871+
2872+ // WebKit doesn't clone checked state correctly in fragments
2873+ support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
2874+
2875+ // Check if a disconnected checkbox will retain its checked
2876+ // value of true after appended to the DOM (IE6/7)
2877+ support.appendChecked = input.checked;
2878+
2879+ fragment.removeChild( input );
2880+ fragment.appendChild( div );
2881+
2882+ // Technique from Juriy Zaytsev
2883+ // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
2884+ // We only care about the case where non-standard event systems
2885+ // are used, namely in IE. Short-circuiting here helps us to
2886+ // avoid an eval call (in setAttribute) which can cause CSP
2887+ // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
2888+ if ( div.attachEvent ) {
2889+ for ( i in {
2890+ submit: 1,
2891+ change: 1,
2892+ focusin: 1
2893+ }) {
2894+ eventName = "on" + i;
2895+ isSupported = ( eventName in div );
2896+ if ( !isSupported ) {
2897+ div.setAttribute( eventName, "return;" );
2898+ isSupported = ( typeof div[ eventName ] === "function" );
2899+ }
2900+ support[ i + "Bubbles" ] = isSupported;
2901+ }
2902+ }
2903+
2904+ fragment.removeChild( div );
2905+
2906+ // Null elements to avoid leaks in IE
2907+ fragment = select = opt = div = input = null;
2908+
2909+ // Run tests that need a body at doc ready
2910+ jQuery(function() {
2911+ var container, outer, inner, table, td, offsetSupport,
2912+ marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight,
2913+ paddingMarginBorderVisibility, paddingMarginBorder,
2914+ body = document.getElementsByTagName("body")[0];
2915+
2916+ if ( !body ) {
2917+ // Return for frameset docs that don't have a body
2918+ return;
2919+ }
2920+
2921+ conMarginTop = 1;
2922+ paddingMarginBorder = "padding:0;margin:0;border:";
2923+ positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;";
2924+ paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;";
2925+ style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;";
2926+ html = "<div " + style + "display:block;'><div style='" + paddingMarginBorder + "0;display:block;overflow:hidden;'></div></div>" +
2927+ "<table " + style + "' cellpadding='0' cellspacing='0'>" +
2928+ "<tr><td></td></tr></table>";
2929+
2930+ container = document.createElement("div");
2931+ container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
2932+ body.insertBefore( container, body.firstChild );
2933+
2934+ // Construct the test element
2935+ div = document.createElement("div");
2936+ container.appendChild( div );
2937+
2938+ // Check if table cells still have offsetWidth/Height when they are set
2939+ // to display:none and there are still other visible table cells in a
2940+ // table row; if so, offsetWidth/Height are not reliable for use when
2941+ // determining if an element has been hidden directly using
2942+ // display:none (it is still safe to use offsets if a parent element is
2943+ // hidden; don safety goggles and see bug #4512 for more information).
2944+ // (only IE 8 fails this test)
2945+ div.innerHTML = "<table><tr><td style='" + paddingMarginBorder + "0;display:none'></td><td>t</td></tr></table>";
2946+ tds = div.getElementsByTagName( "td" );
2947+ isSupported = ( tds[ 0 ].offsetHeight === 0 );
2948+
2949+ tds[ 0 ].style.display = "";
2950+ tds[ 1 ].style.display = "none";
2951+
2952+ // Check if empty table cells still have offsetWidth/Height
2953+ // (IE <= 8 fail this test)
2954+ support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
2955+
2956+ // Check if div with explicit width and no margin-right incorrectly
2957+ // gets computed margin-right based on width of container. For more
2958+ // info see bug #3333
2959+ // Fails in WebKit before Feb 2011 nightlies
2960+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
2961+ if ( window.getComputedStyle ) {
2962+ div.innerHTML = "";
2963+ marginDiv = document.createElement( "div" );
2964+ marginDiv.style.width = "0";
2965+ marginDiv.style.marginRight = "0";
2966+ div.style.width = "2px";
2967+ div.appendChild( marginDiv );
2968+ support.reliableMarginRight =
2969+ ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
2970+ }
2971+
2972+ if ( typeof div.style.zoom !== "undefined" ) {
2973+ // Check if natively block-level elements act like inline-block
2974+ // elements when setting their display to 'inline' and giving
2975+ // them layout
2976+ // (IE < 8 does this)
2977+ div.innerHTML = "";
2978+ div.style.width = div.style.padding = "1px";
2979+ div.style.border = 0;
2980+ div.style.overflow = "hidden";
2981+ div.style.display = "inline";
2982+ div.style.zoom = 1;
2983+ support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
2984+
2985+ // Check if elements with layout shrink-wrap their children
2986+ // (IE 6 does this)
2987+ div.style.display = "block";
2988+ div.style.overflow = "visible";
2989+ div.innerHTML = "<div style='width:5px;'></div>";
2990+ support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
2991+ }
2992+
2993+ div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility;
2994+ div.innerHTML = html;
2995+
2996+ outer = div.firstChild;
2997+ inner = outer.firstChild;
2998+ td = outer.nextSibling.firstChild.firstChild;
2999+
3000+ offsetSupport = {
3001+ doesNotAddBorder: ( inner.offsetTop !== 5 ),
3002+ doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
3003+ };
3004+
3005+ inner.style.position = "fixed";
3006+ inner.style.top = "20px";
3007+
3008+ // safari subtracts parent border width here which is 5px
3009+ offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
3010+ inner.style.position = inner.style.top = "";
3011+
3012+ outer.style.overflow = "hidden";
3013+ outer.style.position = "relative";
3014+
3015+ offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
3016+ offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
3017+
3018+ if ( window.getComputedStyle ) {
3019+ div.style.marginTop = "1%";
3020+ support.pixelMargin = ( window.getComputedStyle( div, null ) || { marginTop: 0 } ).marginTop !== "1%";
3021+ }
3022+
3023+ if ( typeof container.style.zoom !== "undefined" ) {
3024+ container.style.zoom = 1;
3025+ }
3026+
3027+ body.removeChild( container );
3028+ marginDiv = div = container = null;
3029+
3030+ jQuery.extend( support, offsetSupport );
3031+ });
3032+
3033+ return support;
3034+})();
3035+
3036+
3037+
3038+
3039+var rbrace = /^(?:\{.*\}|\[.*\])$/,
3040+ rmultiDash = /([A-Z])/g;
3041+
3042+jQuery.extend({
3043+ cache: {},
3044+
3045+ // Please use with caution
3046+ uuid: 0,
3047+
3048+ // Unique for each copy of jQuery on the page
3049+ // Non-digits removed to match rinlinejQuery
3050+ expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
3051+
3052+ // The following elements throw uncatchable exceptions if you
3053+ // attempt to add expando properties to them.
3054+ noData: {
3055+ "embed": true,
3056+ // Ban all objects except for Flash (which handle expandos)
3057+ "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
3058+ "applet": true
3059+ },
3060+
3061+ hasData: function( elem ) {
3062+ elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
3063+ return !!elem && !isEmptyDataObject( elem );
3064+ },
3065+
3066+ data: function( elem, name, data, pvt /* Internal Use Only */ ) {
3067+ if ( !jQuery.acceptData( elem ) ) {
3068+ return;
3069+ }
3070+
3071+ var privateCache, thisCache, ret,
3072+ internalKey = jQuery.expando,
3073+ getByName = typeof name === "string",
3074+
3075+ // We have to handle DOM nodes and JS objects differently because IE6-7
3076+ // can't GC object references properly across the DOM-JS boundary
3077+ isNode = elem.nodeType,
3078+
3079+ // Only DOM nodes need the global jQuery cache; JS object data is
3080+ // attached directly to the object so GC can occur automatically
3081+ cache = isNode ? jQuery.cache : elem,
3082+
3083+ // Only defining an ID for JS objects if its cache already exists allows
3084+ // the code to shortcut on the same path as a DOM node with no cache
3085+ id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
3086+ isEvents = name === "events";
3087+
3088+ // Avoid doing any more work than we need to when trying to get data on an
3089+ // object that has no data at all
3090+ if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
3091+ return;
3092+ }
3093+
3094+ if ( !id ) {
3095+ // Only DOM nodes need a new unique ID for each element since their data
3096+ // ends up in the global cache
3097+ if ( isNode ) {
3098+ elem[ internalKey ] = id = ++jQuery.uuid;
3099+ } else {
3100+ id = internalKey;
3101+ }
3102+ }
3103+
3104+ if ( !cache[ id ] ) {
3105+ cache[ id ] = {};
3106+
3107+ // Avoids exposing jQuery metadata on plain JS objects when the object
3108+ // is serialized using JSON.stringify
3109+ if ( !isNode ) {
3110+ cache[ id ].toJSON = jQuery.noop;
3111+ }
3112+ }
3113+
3114+ // An object can be passed to jQuery.data instead of a key/value pair; this gets
3115+ // shallow copied over onto the existing cache
3116+ if ( typeof name === "object" || typeof name === "function" ) {
3117+ if ( pvt ) {
3118+ cache[ id ] = jQuery.extend( cache[ id ], name );
3119+ } else {
3120+ cache[ id ].data = jQuery.extend( cache[ id ].data, name );
3121+ }
3122+ }
3123+
3124+ privateCache = thisCache = cache[ id ];
3125+
3126+ // jQuery data() is stored in a separate object inside the object's internal data
3127+ // cache in order to avoid key collisions between internal data and user-defined
3128+ // data.
3129+ if ( !pvt ) {
3130+ if ( !thisCache.data ) {
3131+ thisCache.data = {};
3132+ }
3133+
3134+ thisCache = thisCache.data;
3135+ }
3136+
3137+ if ( data !== undefined ) {
3138+ thisCache[ jQuery.camelCase( name ) ] = data;
3139+ }
3140+
3141+ // Users should not attempt to inspect the internal events object using jQuery.data,
3142+ // it is undocumented and subject to change. But does anyone listen? No.
3143+ if ( isEvents && !thisCache[ name ] ) {
3144+ return privateCache.events;
3145+ }
3146+
3147+ // Check for both converted-to-camel and non-converted data property names
3148+ // If a data property was specified
3149+ if ( getByName ) {
3150+
3151+ // First Try to find as-is property data
3152+ ret = thisCache[ name ];
3153+
3154+ // Test for null|undefined property data
3155+ if ( ret == null ) {
3156+
3157+ // Try to find the camelCased property
3158+ ret = thisCache[ jQuery.camelCase( name ) ];
3159+ }
3160+ } else {
3161+ ret = thisCache;
3162+ }
3163+
3164+ return ret;
3165+ },
3166+
3167+ removeData: function( elem, name, pvt /* Internal Use Only */ ) {
3168+ if ( !jQuery.acceptData( elem ) ) {
3169+ return;
3170+ }
3171+
3172+ var thisCache, i, l,
3173+
3174+ // Reference to internal data cache key
3175+ internalKey = jQuery.expando,
3176+
3177+ isNode = elem.nodeType,
3178+
3179+ // See jQuery.data for more information
3180+ cache = isNode ? jQuery.cache : elem,
3181+
3182+ // See jQuery.data for more information
3183+ id = isNode ? elem[ internalKey ] : internalKey;
3184+
3185+ // If there is already no cache entry for this object, there is no
3186+ // purpose in continuing
3187+ if ( !cache[ id ] ) {
3188+ return;
3189+ }
3190+
3191+ if ( name ) {
3192+
3193+ thisCache = pvt ? cache[ id ] : cache[ id ].data;
3194+
3195+ if ( thisCache ) {
3196+
3197+ // Support array or space separated string names for data keys
3198+ if ( !jQuery.isArray( name ) ) {
3199+
3200+ // try the string as a key before any manipulation
3201+ if ( name in thisCache ) {
3202+ name = [ name ];
3203+ } else {
3204+
3205+ // split the camel cased version by spaces unless a key with the spaces exists
3206+ name = jQuery.camelCase( name );
3207+ if ( name in thisCache ) {
3208+ name = [ name ];
3209+ } else {
3210+ name = name.split( " " );
3211+ }
3212+ }
3213+ }
3214+
3215+ for ( i = 0, l = name.length; i < l; i++ ) {
3216+ delete thisCache[ name[i] ];
3217+ }
3218+
3219+ // If there is no data left in the cache, we want to continue
3220+ // and let the cache object itself get destroyed
3221+ if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
3222+ return;
3223+ }
3224+ }
3225+ }
3226+
3227+ // See jQuery.data for more information
3228+ if ( !pvt ) {
3229+ delete cache[ id ].data;
3230+
3231+ // Don't destroy the parent cache unless the internal data object
3232+ // had been the only thing left in it
3233+ if ( !isEmptyDataObject(cache[ id ]) ) {
3234+ return;
3235+ }
3236+ }
3237+
3238+ // Browsers that fail expando deletion also refuse to delete expandos on
3239+ // the window, but it will allow it on all other JS objects; other browsers
3240+ // don't care
3241+ // Ensure that `cache` is not a window object #10080
3242+ if ( jQuery.support.deleteExpando || !cache.setInterval ) {
3243+ delete cache[ id ];
3244+ } else {
3245+ cache[ id ] = null;
3246+ }
3247+
3248+ // We destroyed the cache and need to eliminate the expando on the node to avoid
3249+ // false lookups in the cache for entries that no longer exist
3250+ if ( isNode ) {
3251+ // IE does not allow us to delete expando properties from nodes,
3252+ // nor does it have a removeAttribute function on Document nodes;
3253+ // we must handle all of these cases
3254+ if ( jQuery.support.deleteExpando ) {
3255+ delete elem[ internalKey ];
3256+ } else if ( elem.removeAttribute ) {
3257+ elem.removeAttribute( internalKey );
3258+ } else {
3259+ elem[ internalKey ] = null;
3260+ }
3261+ }
3262+ },
3263+
3264+ // For internal use only.
3265+ _data: function( elem, name, data ) {
3266+ return jQuery.data( elem, name, data, true );
3267+ },
3268+
3269+ // A method for determining if a DOM node can handle the data expando
3270+ acceptData: function( elem ) {
3271+ if ( elem.nodeName ) {
3272+ var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
3273+
3274+ if ( match ) {
3275+ return !(match === true || elem.getAttribute("classid") !== match);
3276+ }
3277+ }
3278+
3279+ return true;
3280+ }
3281+});
3282+
3283+jQuery.fn.extend({
3284+ data: function( key, value ) {
3285+ var parts, part, attr, name, l,
3286+ elem = this[0],
3287+ i = 0,
3288+ data = null;
3289+
3290+ // Gets all values
3291+ if ( key === undefined ) {
3292+ if ( this.length ) {
3293+ data = jQuery.data( elem );
3294+
3295+ if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
3296+ attr = elem.attributes;
3297+ for ( l = attr.length; i < l; i++ ) {
3298+ name = attr[i].name;
3299+
3300+ if ( name.indexOf( "data-" ) === 0 ) {
3301+ name = jQuery.camelCase( name.substring(5) );
3302+
3303+ dataAttr( elem, name, data[ name ] );
3304+ }
3305+ }
3306+ jQuery._data( elem, "parsedAttrs", true );
3307+ }
3308+ }
3309+
3310+ return data;
3311+ }
3312+
3313+ // Sets multiple values
3314+ if ( typeof key === "object" ) {
3315+ return this.each(function() {
3316+ jQuery.data( this, key );
3317+ });
3318+ }
3319+
3320+ parts = key.split( ".", 2 );
3321+ parts[1] = parts[1] ? "." + parts[1] : "";
3322+ part = parts[1] + "!";
3323+
3324+ return jQuery.access( this, function( value ) {
3325+
3326+ if ( value === undefined ) {
3327+ data = this.triggerHandler( "getData" + part, [ parts[0] ] );
3328+
3329+ // Try to fetch any internally stored data first
3330+ if ( data === undefined && elem ) {
3331+ data = jQuery.data( elem, key );
3332+ data = dataAttr( elem, key, data );
3333+ }
3334+
3335+ return data === undefined && parts[1] ?
3336+ this.data( parts[0] ) :
3337+ data;
3338+ }
3339+
3340+ parts[1] = value;
3341+ this.each(function() {
3342+ var self = jQuery( this );
3343+
3344+ self.triggerHandler( "setData" + part, parts );
3345+ jQuery.data( this, key, value );
3346+ self.triggerHandler( "changeData" + part, parts );
3347+ });
3348+ }, null, value, arguments.length > 1, null, false );
3349+ },
3350+
3351+ removeData: function( key ) {
3352+ return this.each(function() {
3353+ jQuery.removeData( this, key );
3354+ });
3355+ }
3356+});
3357+
3358+function dataAttr( elem, key, data ) {
3359+ // If nothing was found internally, try to fetch any
3360+ // data from the HTML5 data-* attribute
3361+ if ( data === undefined && elem.nodeType === 1 ) {
3362+
3363+ var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
3364+
3365+ data = elem.getAttribute( name );
3366+
3367+ if ( typeof data === "string" ) {
3368+ try {
3369+ data = data === "true" ? true :
3370+ data === "false" ? false :
3371+ data === "null" ? null :
3372+ jQuery.isNumeric( data ) ? +data :
3373+ rbrace.test( data ) ? jQuery.parseJSON( data ) :
3374+ data;
3375+ } catch( e ) {}
3376+
3377+ // Make sure we set the data so it isn't changed later
3378+ jQuery.data( elem, key, data );
3379+
3380+ } else {
3381+ data = undefined;
3382+ }
3383+ }
3384+
3385+ return data;
3386+}
3387+
3388+// checks a cache object for emptiness
3389+function isEmptyDataObject( obj ) {
3390+ for ( var name in obj ) {
3391+
3392+ // if the public data object is empty, the private is still empty
3393+ if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
3394+ continue;
3395+ }
3396+ if ( name !== "toJSON" ) {
3397+ return false;
3398+ }
3399+ }
3400+
3401+ return true;
3402+}
3403+
3404+
3405+
3406+
3407+function handleQueueMarkDefer( elem, type, src ) {
3408+ var deferDataKey = type + "defer",
3409+ queueDataKey = type + "queue",
3410+ markDataKey = type + "mark",
3411+ defer = jQuery._data( elem, deferDataKey );
3412+ if ( defer &&
3413+ ( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
3414+ ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
3415+ // Give room for hard-coded callbacks to fire first
3416+ // and eventually mark/queue something else on the element
3417+ setTimeout( function() {
3418+ if ( !jQuery._data( elem, queueDataKey ) &&
3419+ !jQuery._data( elem, markDataKey ) ) {
3420+ jQuery.removeData( elem, deferDataKey, true );
3421+ defer.fire();
3422+ }
3423+ }, 0 );
3424+ }
3425+}
3426+
3427+jQuery.extend({
3428+
3429+ _mark: function( elem, type ) {
3430+ if ( elem ) {
3431+ type = ( type || "fx" ) + "mark";
3432+ jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
3433+ }
3434+ },
3435+
3436+ _unmark: function( force, elem, type ) {
3437+ if ( force !== true ) {
3438+ type = elem;
3439+ elem = force;
3440+ force = false;
3441+ }
3442+ if ( elem ) {
3443+ type = type || "fx";
3444+ var key = type + "mark",
3445+ count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
3446+ if ( count ) {
3447+ jQuery._data( elem, key, count );
3448+ } else {
3449+ jQuery.removeData( elem, key, true );
3450+ handleQueueMarkDefer( elem, type, "mark" );
3451+ }
3452+ }
3453+ },
3454+
3455+ queue: function( elem, type, data ) {
3456+ var q;
3457+ if ( elem ) {
3458+ type = ( type || "fx" ) + "queue";
3459+ q = jQuery._data( elem, type );
3460+
3461+ // Speed up dequeue by getting out quickly if this is just a lookup
3462+ if ( data ) {
3463+ if ( !q || jQuery.isArray(data) ) {
3464+ q = jQuery._data( elem, type, jQuery.makeArray(data) );
3465+ } else {
3466+ q.push( data );
3467+ }
3468+ }
3469+ return q || [];
3470+ }
3471+ },
3472+
3473+ dequeue: function( elem, type ) {
3474+ type = type || "fx";
3475+
3476+ var queue = jQuery.queue( elem, type ),
3477+ fn = queue.shift(),
3478+ hooks = {};
3479+
3480+ // If the fx queue is dequeued, always remove the progress sentinel
3481+ if ( fn === "inprogress" ) {
3482+ fn = queue.shift();
3483+ }
3484+
3485+ if ( fn ) {
3486+ // Add a progress sentinel to prevent the fx queue from being
3487+ // automatically dequeued
3488+ if ( type === "fx" ) {
3489+ queue.unshift( "inprogress" );
3490+ }
3491+
3492+ jQuery._data( elem, type + ".run", hooks );
3493+ fn.call( elem, function() {
3494+ jQuery.dequeue( elem, type );
3495+ }, hooks );
3496+ }
3497+
3498+ if ( !queue.length ) {
3499+ jQuery.removeData( elem, type + "queue " + type + ".run", true );
3500+ handleQueueMarkDefer( elem, type, "queue" );
3501+ }
3502+ }
3503+});
3504+
3505+jQuery.fn.extend({
3506+ queue: function( type, data ) {
3507+ var setter = 2;
3508+
3509+ if ( typeof type !== "string" ) {
3510+ data = type;
3511+ type = "fx";
3512+ setter--;
3513+ }
3514+
3515+ if ( arguments.length < setter ) {
3516+ return jQuery.queue( this[0], type );
3517+ }
3518+
3519+ return data === undefined ?
3520+ this :
3521+ this.each(function() {
3522+ var queue = jQuery.queue( this, type, data );
3523+
3524+ if ( type === "fx" && queue[0] !== "inprogress" ) {
3525+ jQuery.dequeue( this, type );
3526+ }
3527+ });
3528+ },
3529+ dequeue: function( type ) {
3530+ return this.each(function() {
3531+ jQuery.dequeue( this, type );
3532+ });
3533+ },
3534+ // Based off of the plugin by Clint Helfers, with permission.
3535+ // http://blindsignals.com/index.php/2009/07/jquery-delay/
3536+ delay: function( time, type ) {
3537+ time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
3538+ type = type || "fx";
3539+
3540+ return this.queue( type, function( next, hooks ) {
3541+ var timeout = setTimeout( next, time );
3542+ hooks.stop = function() {
3543+ clearTimeout( timeout );
3544+ };
3545+ });
3546+ },
3547+ clearQueue: function( type ) {
3548+ return this.queue( type || "fx", [] );
3549+ },
3550+ // Get a promise resolved when queues of a certain type
3551+ // are emptied (fx is the type by default)
3552+ promise: function( type, object ) {
3553+ if ( typeof type !== "string" ) {
3554+ object = type;
3555+ type = undefined;
3556+ }
3557+ type = type || "fx";
3558+ var defer = jQuery.Deferred(),
3559+ elements = this,
3560+ i = elements.length,
3561+ count = 1,
3562+ deferDataKey = type + "defer",
3563+ queueDataKey = type + "queue",
3564+ markDataKey = type + "mark",
3565+ tmp;
3566+ function resolve() {
3567+ if ( !( --count ) ) {
3568+ defer.resolveWith( elements, [ elements ] );
3569+ }
3570+ }
3571+ while( i-- ) {
3572+ if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
3573+ ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
3574+ jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
3575+ jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
3576+ count++;
3577+ tmp.add( resolve );
3578+ }
3579+ }
3580+ resolve();
3581+ return defer.promise( object );
3582+ }
3583+});
3584+
3585+
3586+
3587+
3588+var rclass = /[\n\t\r]/g,
3589+ rspace = /\s+/,
3590+ rreturn = /\r/g,
3591+ rtype = /^(?:button|input)$/i,
3592+ rfocusable = /^(?:button|input|object|select|textarea)$/i,
3593+ rclickable = /^a(?:rea)?$/i,
3594+ rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
3595+ getSetAttribute = jQuery.support.getSetAttribute,
3596+ nodeHook, boolHook, fixSpecified;
3597+
3598+jQuery.fn.extend({
3599+ attr: function( name, value ) {
3600+ return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
3601+ },
3602+
3603+ removeAttr: function( name ) {
3604+ return this.each(function() {
3605+ jQuery.removeAttr( this, name );
3606+ });
3607+ },
3608+
3609+ prop: function( name, value ) {
3610+ return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
3611+ },
3612+
3613+ removeProp: function( name ) {
3614+ name = jQuery.propFix[ name ] || name;
3615+ return this.each(function() {
3616+ // try/catch handles cases where IE balks (such as removing a property on window)
3617+ try {
3618+ this[ name ] = undefined;
3619+ delete this[ name ];
3620+ } catch( e ) {}
3621+ });
3622+ },
3623+
3624+ addClass: function( value ) {
3625+ var classNames, i, l, elem,
3626+ setClass, c, cl;
3627+
3628+ if ( jQuery.isFunction( value ) ) {
3629+ return this.each(function( j ) {
3630+ jQuery( this ).addClass( value.call(this, j, this.className) );
3631+ });
3632+ }
3633+
3634+ if ( value && typeof value === "string" ) {
3635+ classNames = value.split( rspace );
3636+
3637+ for ( i = 0, l = this.length; i < l; i++ ) {
3638+ elem = this[ i ];
3639+
3640+ if ( elem.nodeType === 1 ) {
3641+ if ( !elem.className && classNames.length === 1 ) {
3642+ elem.className = value;
3643+
3644+ } else {
3645+ setClass = " " + elem.className + " ";
3646+
3647+ for ( c = 0, cl = classNames.length; c < cl; c++ ) {
3648+ if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
3649+ setClass += classNames[ c ] + " ";
3650+ }
3651+ }
3652+ elem.className = jQuery.trim( setClass );
3653+ }
3654+ }
3655+ }
3656+ }
3657+
3658+ return this;
3659+ },
3660+
3661+ removeClass: function( value ) {
3662+ var classNames, i, l, elem, className, c, cl;
3663+
3664+ if ( jQuery.isFunction( value ) ) {
3665+ return this.each(function( j ) {
3666+ jQuery( this ).removeClass( value.call(this, j, this.className) );
3667+ });
3668+ }
3669+
3670+ if ( (value && typeof value === "string") || value === undefined ) {
3671+ classNames = ( value || "" ).split( rspace );
3672+
3673+ for ( i = 0, l = this.length; i < l; i++ ) {
3674+ elem = this[ i ];
3675+
3676+ if ( elem.nodeType === 1 && elem.className ) {
3677+ if ( value ) {
3678+ className = (" " + elem.className + " ").replace( rclass, " " );
3679+ for ( c = 0, cl = classNames.length; c < cl; c++ ) {
3680+ className = className.replace(" " + classNames[ c ] + " ", " ");
3681+ }
3682+ elem.className = jQuery.trim( className );
3683+
3684+ } else {
3685+ elem.className = "";
3686+ }
3687+ }
3688+ }
3689+ }
3690+
3691+ return this;
3692+ },
3693+
3694+ toggleClass: function( value, stateVal ) {
3695+ var type = typeof value,
3696+ isBool = typeof stateVal === "boolean";
3697+
3698+ if ( jQuery.isFunction( value ) ) {
3699+ return this.each(function( i ) {
3700+ jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
3701+ });
3702+ }
3703+
3704+ return this.each(function() {
3705+ if ( type === "string" ) {
3706+ // toggle individual class names
3707+ var className,
3708+ i = 0,
3709+ self = jQuery( this ),
3710+ state = stateVal,
3711+ classNames = value.split( rspace );
3712+
3713+ while ( (className = classNames[ i++ ]) ) {
3714+ // check each className given, space seperated list
3715+ state = isBool ? state : !self.hasClass( className );
3716+ self[ state ? "addClass" : "removeClass" ]( className );
3717+ }
3718+
3719+ } else if ( type === "undefined" || type === "boolean" ) {
3720+ if ( this.className ) {
3721+ // store className if set
3722+ jQuery._data( this, "__className__", this.className );
3723+ }
3724+
3725+ // toggle whole className
3726+ this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
3727+ }
3728+ });
3729+ },
3730+
3731+ hasClass: function( selector ) {
3732+ var className = " " + selector + " ",
3733+ i = 0,
3734+ l = this.length;
3735+ for ( ; i < l; i++ ) {
3736+ if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
3737+ return true;
3738+ }
3739+ }
3740+
3741+ return false;
3742+ },
3743+
3744+ val: function( value ) {
3745+ var hooks, ret, isFunction,
3746+ elem = this[0];
3747+
3748+ if ( !arguments.length ) {
3749+ if ( elem ) {
3750+ hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
3751+
3752+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
3753+ return ret;
3754+ }
3755+
3756+ ret = elem.value;
3757+
3758+ return typeof ret === "string" ?
3759+ // handle most common string cases
3760+ ret.replace(rreturn, "") :
3761+ // handle cases where value is null/undef or number
3762+ ret == null ? "" : ret;
3763+ }
3764+
3765+ return;
3766+ }
3767+
3768+ isFunction = jQuery.isFunction( value );
3769+
3770+ return this.each(function( i ) {
3771+ var self = jQuery(this), val;
3772+
3773+ if ( this.nodeType !== 1 ) {
3774+ return;
3775+ }
3776+
3777+ if ( isFunction ) {
3778+ val = value.call( this, i, self.val() );
3779+ } else {
3780+ val = value;
3781+ }
3782+
3783+ // Treat null/undefined as ""; convert numbers to string
3784+ if ( val == null ) {
3785+ val = "";
3786+ } else if ( typeof val === "number" ) {
3787+ val += "";
3788+ } else if ( jQuery.isArray( val ) ) {
3789+ val = jQuery.map(val, function ( value ) {
3790+ return value == null ? "" : value + "";
3791+ });
3792+ }
3793+
3794+ hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
3795+
3796+ // If set returns undefined, fall back to normal setting
3797+ if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
3798+ this.value = val;
3799+ }
3800+ });
3801+ }
3802+});
3803+
3804+jQuery.extend({
3805+ valHooks: {
3806+ option: {
3807+ get: function( elem ) {
3808+ // attributes.value is undefined in Blackberry 4.7 but
3809+ // uses .value. See #6932
3810+ var val = elem.attributes.value;
3811+ return !val || val.specified ? elem.value : elem.text;
3812+ }
3813+ },
3814+ select: {
3815+ get: function( elem ) {
3816+ var value, i, max, option,
3817+ index = elem.selectedIndex,
3818+ values = [],
3819+ options = elem.options,
3820+ one = elem.type === "select-one";
3821+
3822+ // Nothing was selected
3823+ if ( index < 0 ) {
3824+ return null;
3825+ }
3826+
3827+ // Loop through all the selected options
3828+ i = one ? index : 0;
3829+ max = one ? index + 1 : options.length;
3830+ for ( ; i < max; i++ ) {
3831+ option = options[ i ];
3832+
3833+ // Don't return options that are disabled or in a disabled optgroup
3834+ if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
3835+ (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
3836+
3837+ // Get the specific value for the option
3838+ value = jQuery( option ).val();
3839+
3840+ // We don't need an array for one selects
3841+ if ( one ) {
3842+ return value;
3843+ }
3844+
3845+ // Multi-Selects return an array
3846+ values.push( value );
3847+ }
3848+ }
3849+
3850+ // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
3851+ if ( one && !values.length && options.length ) {
3852+ return jQuery( options[ index ] ).val();
3853+ }
3854+
3855+ return values;
3856+ },
3857+
3858+ set: function( elem, value ) {
3859+ var values = jQuery.makeArray( value );
3860+
3861+ jQuery(elem).find("option").each(function() {
3862+ this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
3863+ });
3864+
3865+ if ( !values.length ) {
3866+ elem.selectedIndex = -1;
3867+ }
3868+ return values;
3869+ }
3870+ }
3871+ },
3872+
3873+ attrFn: {
3874+ val: true,
3875+ css: true,
3876+ html: true,
3877+ text: true,
3878+ data: true,
3879+ width: true,
3880+ height: true,
3881+ offset: true
3882+ },
3883+
3884+ attr: function( elem, name, value, pass ) {
3885+ var ret, hooks, notxml,
3886+ nType = elem.nodeType;
3887+
3888+ // don't get/set attributes on text, comment and attribute nodes
3889+ if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
3890+ return;
3891+ }
3892+
3893+ if ( pass && name in jQuery.attrFn ) {
3894+ return jQuery( elem )[ name ]( value );
3895+ }
3896+
3897+ // Fallback to prop when attributes are not supported
3898+ if ( typeof elem.getAttribute === "undefined" ) {
3899+ return jQuery.prop( elem, name, value );
3900+ }
3901+
3902+ notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
3903+
3904+ // All attributes are lowercase
3905+ // Grab necessary hook if one is defined
3906+ if ( notxml ) {
3907+ name = name.toLowerCase();
3908+ hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
3909+ }
3910+
3911+ if ( value !== undefined ) {
3912+
3913+ if ( value === null ) {
3914+ jQuery.removeAttr( elem, name );
3915+ return;
3916+
3917+ } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
3918+ return ret;
3919+
3920+ } else {
3921+ elem.setAttribute( name, "" + value );
3922+ return value;
3923+ }
3924+
3925+ } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
3926+ return ret;
3927+
3928+ } else {
3929+
3930+ ret = elem.getAttribute( name );
3931+
3932+ // Non-existent attributes return null, we normalize to undefined
3933+ return ret === null ?
3934+ undefined :
3935+ ret;
3936+ }
3937+ },
3938+
3939+ removeAttr: function( elem, value ) {
3940+ var propName, attrNames, name, l, isBool,
3941+ i = 0;
3942+
3943+ if ( value && elem.nodeType === 1 ) {
3944+ attrNames = value.toLowerCase().split( rspace );
3945+ l = attrNames.length;
3946+
3947+ for ( ; i < l; i++ ) {
3948+ name = attrNames[ i ];
3949+
3950+ if ( name ) {
3951+ propName = jQuery.propFix[ name ] || name;
3952+ isBool = rboolean.test( name );
3953+
3954+ // See #9699 for explanation of this approach (setting first, then removal)
3955+ // Do not do this for boolean attributes (see #10870)
3956+ if ( !isBool ) {
3957+ jQuery.attr( elem, name, "" );
3958+ }
3959+ elem.removeAttribute( getSetAttribute ? name : propName );
3960+
3961+ // Set corresponding property to false for boolean attributes
3962+ if ( isBool && propName in elem ) {
3963+ elem[ propName ] = false;
3964+ }
3965+ }
3966+ }
3967+ }
3968+ },
3969+
3970+ attrHooks: {
3971+ type: {
3972+ set: function( elem, value ) {
3973+ // We can't allow the type property to be changed (since it causes problems in IE)
3974+ if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
3975+ jQuery.error( "type property can't be changed" );
3976+ } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
3977+ // Setting the type on a radio button after the value resets the value in IE6-9
3978+ // Reset value to it's default in case type is set after value
3979+ // This is for element creation
3980+ var val = elem.value;
3981+ elem.setAttribute( "type", value );
3982+ if ( val ) {
3983+ elem.value = val;
3984+ }
3985+ return value;
3986+ }
3987+ }
3988+ },
3989+ // Use the value property for back compat
3990+ // Use the nodeHook for button elements in IE6/7 (#1954)
3991+ value: {
3992+ get: function( elem, name ) {
3993+ if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
3994+ return nodeHook.get( elem, name );
3995+ }
3996+ return name in elem ?
3997+ elem.value :
3998+ null;
3999+ },
4000+ set: function( elem, value, name ) {
4001+ if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
4002+ return nodeHook.set( elem, value, name );
4003+ }
4004+ // Does not return so that setAttribute is also used
4005+ elem.value = value;
4006+ }
4007+ }
4008+ },
4009+
4010+ propFix: {
4011+ tabindex: "tabIndex",
4012+ readonly: "readOnly",
4013+ "for": "htmlFor",
4014+ "class": "className",
4015+ maxlength: "maxLength",
4016+ cellspacing: "cellSpacing",
4017+ cellpadding: "cellPadding",
4018+ rowspan: "rowSpan",
4019+ colspan: "colSpan",
4020+ usemap: "useMap",
4021+ frameborder: "frameBorder",
4022+ contenteditable: "contentEditable"
4023+ },
4024+
4025+ prop: function( elem, name, value ) {
4026+ var ret, hooks, notxml,
4027+ nType = elem.nodeType;
4028+
4029+ // don't get/set properties on text, comment and attribute nodes
4030+ if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
4031+ return;
4032+ }
4033+
4034+ notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
4035+
4036+ if ( notxml ) {
4037+ // Fix name and attach hooks
4038+ name = jQuery.propFix[ name ] || name;
4039+ hooks = jQuery.propHooks[ name ];
4040+ }
4041+
4042+ if ( value !== undefined ) {
4043+ if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
4044+ return ret;
4045+
4046+ } else {
4047+ return ( elem[ name ] = value );
4048+ }
4049+
4050+ } else {
4051+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
4052+ return ret;
4053+
4054+ } else {
4055+ return elem[ name ];
4056+ }
4057+ }
4058+ },
4059+
4060+ propHooks: {
4061+ tabIndex: {
4062+ get: function( elem ) {
4063+ // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
4064+ // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
4065+ var attributeNode = elem.getAttributeNode("tabindex");
4066+
4067+ return attributeNode && attributeNode.specified ?
4068+ parseInt( attributeNode.value, 10 ) :
4069+ rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
4070+ 0 :
4071+ undefined;
4072+ }
4073+ }
4074+ }
4075+});
4076+
4077+// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
4078+jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
4079+
4080+// Hook for boolean attributes
4081+boolHook = {
4082+ get: function( elem, name ) {
4083+ // Align boolean attributes with corresponding properties
4084+ // Fall back to attribute presence where some booleans are not supported
4085+ var attrNode,
4086+ property = jQuery.prop( elem, name );
4087+ return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
4088+ name.toLowerCase() :
4089+ undefined;
4090+ },
4091+ set: function( elem, value, name ) {
4092+ var propName;
4093+ if ( value === false ) {
4094+ // Remove boolean attributes when set to false
4095+ jQuery.removeAttr( elem, name );
4096+ } else {
4097+ // value is true since we know at this point it's type boolean and not false
4098+ // Set boolean attributes to the same name and set the DOM property
4099+ propName = jQuery.propFix[ name ] || name;
4100+ if ( propName in elem ) {
4101+ // Only set the IDL specifically if it already exists on the element
4102+ elem[ propName ] = true;
4103+ }
4104+
4105+ elem.setAttribute( name, name.toLowerCase() );
4106+ }
4107+ return name;
4108+ }
4109+};
4110+
4111+// IE6/7 do not support getting/setting some attributes with get/setAttribute
4112+if ( !getSetAttribute ) {
4113+
4114+ fixSpecified = {
4115+ name: true,
4116+ id: true,
4117+ coords: true
4118+ };
4119+
4120+ // Use this for any attribute in IE6/7
4121+ // This fixes almost every IE6/7 issue
4122+ nodeHook = jQuery.valHooks.button = {
4123+ get: function( elem, name ) {
4124+ var ret;
4125+ ret = elem.getAttributeNode( name );
4126+ return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
4127+ ret.nodeValue :
4128+ undefined;
4129+ },
4130+ set: function( elem, value, name ) {
4131+ // Set the existing or create a new attribute node
4132+ var ret = elem.getAttributeNode( name );
4133+ if ( !ret ) {
4134+ ret = document.createAttribute( name );
4135+ elem.setAttributeNode( ret );
4136+ }
4137+ return ( ret.nodeValue = value + "" );
4138+ }
4139+ };
4140+
4141+ // Apply the nodeHook to tabindex
4142+ jQuery.attrHooks.tabindex.set = nodeHook.set;
4143+
4144+ // Set width and height to auto instead of 0 on empty string( Bug #8150 )
4145+ // This is for removals
4146+ jQuery.each([ "width", "height" ], function( i, name ) {
4147+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
4148+ set: function( elem, value ) {
4149+ if ( value === "" ) {
4150+ elem.setAttribute( name, "auto" );
4151+ return value;
4152+ }
4153+ }
4154+ });
4155+ });
4156+
4157+ // Set contenteditable to false on removals(#10429)
4158+ // Setting to empty string throws an error as an invalid value
4159+ jQuery.attrHooks.contenteditable = {
4160+ get: nodeHook.get,
4161+ set: function( elem, value, name ) {
4162+ if ( value === "" ) {
4163+ value = "false";
4164+ }
4165+ nodeHook.set( elem, value, name );
4166+ }
4167+ };
4168+}
4169+
4170+
4171+// Some attributes require a special call on IE
4172+if ( !jQuery.support.hrefNormalized ) {
4173+ jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
4174+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
4175+ get: function( elem ) {
4176+ var ret = elem.getAttribute( name, 2 );
4177+ return ret === null ? undefined : ret;
4178+ }
4179+ });
4180+ });
4181+}
4182+
4183+if ( !jQuery.support.style ) {
4184+ jQuery.attrHooks.style = {
4185+ get: function( elem ) {
4186+ // Return undefined in the case of empty string
4187+ // Normalize to lowercase since IE uppercases css property names
4188+ return elem.style.cssText.toLowerCase() || undefined;
4189+ },
4190+ set: function( elem, value ) {
4191+ return ( elem.style.cssText = "" + value );
4192+ }
4193+ };
4194+}
4195+
4196+// Safari mis-reports the default selected property of an option
4197+// Accessing the parent's selectedIndex property fixes it
4198+if ( !jQuery.support.optSelected ) {
4199+ jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
4200+ get: function( elem ) {
4201+ var parent = elem.parentNode;
4202+
4203+ if ( parent ) {
4204+ parent.selectedIndex;
4205+
4206+ // Make sure that it also works with optgroups, see #5701
4207+ if ( parent.parentNode ) {
4208+ parent.parentNode.selectedIndex;
4209+ }
4210+ }
4211+ return null;
4212+ }
4213+ });
4214+}
4215+
4216+// IE6/7 call enctype encoding
4217+if ( !jQuery.support.enctype ) {
4218+ jQuery.propFix.enctype = "encoding";
4219+}
4220+
4221+// Radios and checkboxes getter/setter
4222+if ( !jQuery.support.checkOn ) {
4223+ jQuery.each([ "radio", "checkbox" ], function() {
4224+ jQuery.valHooks[ this ] = {
4225+ get: function( elem ) {
4226+ // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
4227+ return elem.getAttribute("value") === null ? "on" : elem.value;
4228+ }
4229+ };
4230+ });
4231+}
4232+jQuery.each([ "radio", "checkbox" ], function() {
4233+ jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
4234+ set: function( elem, value ) {
4235+ if ( jQuery.isArray( value ) ) {
4236+ return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
4237+ }
4238+ }
4239+ });
4240+});
4241+
4242+
4243+
4244+
4245+var rformElems = /^(?:textarea|input|select)$/i,
4246+ rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
4247+ rhoverHack = /(?:^|\s)hover(\.\S+)?\b/,
4248+ rkeyEvent = /^key/,
4249+ rmouseEvent = /^(?:mouse|contextmenu)|click/,
4250+ rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
4251+ rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
4252+ quickParse = function( selector ) {
4253+ var quick = rquickIs.exec( selector );
4254+ if ( quick ) {
4255+ // 0 1 2 3
4256+ // [ _, tag, id, class ]
4257+ quick[1] = ( quick[1] || "" ).toLowerCase();
4258+ quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
4259+ }
4260+ return quick;
4261+ },
4262+ quickIs = function( elem, m ) {
4263+ var attrs = elem.attributes || {};
4264+ return (
4265+ (!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
4266+ (!m[2] || (attrs.id || {}).value === m[2]) &&
4267+ (!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
4268+ );
4269+ },
4270+ hoverHack = function( events ) {
4271+ return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
4272+ };
4273+
4274+/*
4275+ * Helper functions for managing events -- not part of the public interface.
4276+ * Props to Dean Edwards' addEvent library for many of the ideas.
4277+ */
4278+jQuery.event = {
4279+
4280+ add: function( elem, types, handler, data, selector ) {
4281+
4282+ var elemData, eventHandle, events,
4283+ t, tns, type, namespaces, handleObj,
4284+ handleObjIn, quick, handlers, special;
4285+
4286+ // Don't attach events to noData or text/comment nodes (allow plain objects tho)
4287+ if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
4288+ return;
4289+ }
4290+
4291+ // Caller can pass in an object of custom data in lieu of the handler
4292+ if ( handler.handler ) {
4293+ handleObjIn = handler;
4294+ handler = handleObjIn.handler;
4295+ selector = handleObjIn.selector;
4296+ }
4297+
4298+ // Make sure that the handler has a unique ID, used to find/remove it later
4299+ if ( !handler.guid ) {
4300+ handler.guid = jQuery.guid++;
4301+ }
4302+
4303+ // Init the element's event structure and main handler, if this is the first
4304+ events = elemData.events;
4305+ if ( !events ) {
4306+ elemData.events = events = {};
4307+ }
4308+ eventHandle = elemData.handle;
4309+ if ( !eventHandle ) {
4310+ elemData.handle = eventHandle = function( e ) {
4311+ // Discard the second event of a jQuery.event.trigger() and
4312+ // when an event is called after a page has unloaded
4313+ return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
4314+ jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
4315+ undefined;
4316+ };
4317+ // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
4318+ eventHandle.elem = elem;
4319+ }
4320+
4321+ // Handle multiple events separated by a space
4322+ // jQuery(...).bind("mouseover mouseout", fn);
4323+ types = jQuery.trim( hoverHack(types) ).split( " " );
4324+ for ( t = 0; t < types.length; t++ ) {
4325+
4326+ tns = rtypenamespace.exec( types[t] ) || [];
4327+ type = tns[1];
4328+ namespaces = ( tns[2] || "" ).split( "." ).sort();
4329+
4330+ // If event changes its type, use the special event handlers for the changed type
4331+ special = jQuery.event.special[ type ] || {};
4332+
4333+ // If selector defined, determine special event api type, otherwise given type
4334+ type = ( selector ? special.delegateType : special.bindType ) || type;
4335+
4336+ // Update special based on newly reset type
4337+ special = jQuery.event.special[ type ] || {};
4338+
4339+ // handleObj is passed to all event handlers
4340+ handleObj = jQuery.extend({
4341+ type: type,
4342+ origType: tns[1],
4343+ data: data,
4344+ handler: handler,
4345+ guid: handler.guid,
4346+ selector: selector,
4347+ quick: selector && quickParse( selector ),
4348+ namespace: namespaces.join(".")
4349+ }, handleObjIn );
4350+
4351+ // Init the event handler queue if we're the first
4352+ handlers = events[ type ];
4353+ if ( !handlers ) {
4354+ handlers = events[ type ] = [];
4355+ handlers.delegateCount = 0;
4356+
4357+ // Only use addEventListener/attachEvent if the special events handler returns false
4358+ if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
4359+ // Bind the global event handler to the element
4360+ if ( elem.addEventListener ) {
4361+ elem.addEventListener( type, eventHandle, false );
4362+
4363+ } else if ( elem.attachEvent ) {
4364+ elem.attachEvent( "on" + type, eventHandle );
4365+ }
4366+ }
4367+ }
4368+
4369+ if ( special.add ) {
4370+ special.add.call( elem, handleObj );
4371+
4372+ if ( !handleObj.handler.guid ) {
4373+ handleObj.handler.guid = handler.guid;
4374+ }
4375+ }
4376+
4377+ // Add to the element's handler list, delegates in front
4378+ if ( selector ) {
4379+ handlers.splice( handlers.delegateCount++, 0, handleObj );
4380+ } else {
4381+ handlers.push( handleObj );
4382+ }
4383+
4384+ // Keep track of which events have ever been used, for event optimization
4385+ jQuery.event.global[ type ] = true;
4386+ }
4387+
4388+ // Nullify elem to prevent memory leaks in IE
4389+ elem = null;
4390+ },
4391+
4392+ global: {},
4393+
4394+ // Detach an event or set of events from an element
4395+ remove: function( elem, types, handler, selector, mappedTypes ) {
4396+
4397+ var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
4398+ t, tns, type, origType, namespaces, origCount,
4399+ j, events, special, handle, eventType, handleObj;
4400+
4401+ if ( !elemData || !(events = elemData.events) ) {
4402+ return;
4403+ }
4404+
4405+ // Once for each type.namespace in types; type may be omitted
4406+ types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
4407+ for ( t = 0; t < types.length; t++ ) {
4408+ tns = rtypenamespace.exec( types[t] ) || [];
4409+ type = origType = tns[1];
4410+ namespaces = tns[2];
4411+
4412+ // Unbind all events (on this namespace, if provided) for the element
4413+ if ( !type ) {
4414+ for ( type in events ) {
4415+ jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
4416+ }
4417+ continue;
4418+ }
4419+
4420+ special = jQuery.event.special[ type ] || {};
4421+ type = ( selector? special.delegateType : special.bindType ) || type;
4422+ eventType = events[ type ] || [];
4423+ origCount = eventType.length;
4424+ namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
4425+
4426+ // Remove matching events
4427+ for ( j = 0; j < eventType.length; j++ ) {
4428+ handleObj = eventType[ j ];
4429+
4430+ if ( ( mappedTypes || origType === handleObj.origType ) &&
4431+ ( !handler || handler.guid === handleObj.guid ) &&
4432+ ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
4433+ ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
4434+ eventType.splice( j--, 1 );
4435+
4436+ if ( handleObj.selector ) {
4437+ eventType.delegateCount--;
4438+ }
4439+ if ( special.remove ) {
4440+ special.remove.call( elem, handleObj );
4441+ }
4442+ }
4443+ }
4444+
4445+ // Remove generic event handler if we removed something and no more handlers exist
4446+ // (avoids potential for endless recursion during removal of special event handlers)
4447+ if ( eventType.length === 0 && origCount !== eventType.length ) {
4448+ if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
4449+ jQuery.removeEvent( elem, type, elemData.handle );
4450+ }
4451+
4452+ delete events[ type ];
4453+ }
4454+ }
4455+
4456+ // Remove the expando if it's no longer used
4457+ if ( jQuery.isEmptyObject( events ) ) {
4458+ handle = elemData.handle;
4459+ if ( handle ) {
4460+ handle.elem = null;
4461+ }
4462+
4463+ // removeData also checks for emptiness and clears the expando if empty
4464+ // so use it instead of delete
4465+ jQuery.removeData( elem, [ "events", "handle" ], true );
4466+ }
4467+ },
4468+
4469+ // Events that are safe to short-circuit if no handlers are attached.
4470+ // Native DOM events should not be added, they may have inline handlers.
4471+ customEvent: {
4472+ "getData": true,
4473+ "setData": true,
4474+ "changeData": true
4475+ },
4476+
4477+ trigger: function( event, data, elem, onlyHandlers ) {
4478+ // Don't do events on text and comment nodes
4479+ if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
4480+ return;
4481+ }
4482+
4483+ // Event object or event type
4484+ var type = event.type || event,
4485+ namespaces = [],
4486+ cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
4487+
4488+ // focus/blur morphs to focusin/out; ensure we're not firing them right now
4489+ if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
4490+ return;
4491+ }
4492+
4493+ if ( type.indexOf( "!" ) >= 0 ) {
4494+ // Exclusive events trigger only for the exact event (no namespaces)
4495+ type = type.slice(0, -1);
4496+ exclusive = true;
4497+ }
4498+
4499+ if ( type.indexOf( "." ) >= 0 ) {
4500+ // Namespaced trigger; create a regexp to match event type in handle()
4501+ namespaces = type.split(".");
4502+ type = namespaces.shift();
4503+ namespaces.sort();
4504+ }
4505+
4506+ if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
4507+ // No jQuery handlers for this event type, and it can't have inline handlers
4508+ return;
4509+ }
4510+
4511+ // Caller can pass in an Event, Object, or just an event type string
4512+ event = typeof event === "object" ?
4513+ // jQuery.Event object
4514+ event[ jQuery.expando ] ? event :
4515+ // Object literal
4516+ new jQuery.Event( type, event ) :
4517+ // Just the event type (string)
4518+ new jQuery.Event( type );
4519+
4520+ event.type = type;
4521+ event.isTrigger = true;
4522+ event.exclusive = exclusive;
4523+ event.namespace = namespaces.join( "." );
4524+ event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
4525+ ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
4526+
4527+ // Handle a global trigger
4528+ if ( !elem ) {
4529+
4530+ // TODO: Stop taunting the data cache; remove global events and always attach to document
4531+ cache = jQuery.cache;
4532+ for ( i in cache ) {
4533+ if ( cache[ i ].events && cache[ i ].events[ type ] ) {
4534+ jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
4535+ }
4536+ }
4537+ return;
4538+ }
4539+
4540+ // Clean up the event in case it is being reused
4541+ event.result = undefined;
4542+ if ( !event.target ) {
4543+ event.target = elem;
4544+ }
4545+
4546+ // Clone any incoming data and prepend the event, creating the handler arg list
4547+ data = data != null ? jQuery.makeArray( data ) : [];
4548+ data.unshift( event );
4549+
4550+ // Allow special events to draw outside the lines
4551+ special = jQuery.event.special[ type ] || {};
4552+ if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
4553+ return;
4554+ }
4555+
4556+ // Determine event propagation path in advance, per W3C events spec (#9951)
4557+ // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
4558+ eventPath = [[ elem, special.bindType || type ]];
4559+ if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
4560+
4561+ bubbleType = special.delegateType || type;
4562+ cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
4563+ old = null;
4564+ for ( ; cur; cur = cur.parentNode ) {
4565+ eventPath.push([ cur, bubbleType ]);
4566+ old = cur;
4567+ }
4568+
4569+ // Only add window if we got to document (e.g., not plain obj or detached DOM)
4570+ if ( old && old === elem.ownerDocument ) {
4571+ eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
4572+ }
4573+ }
4574+
4575+ // Fire handlers on the event path
4576+ for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
4577+
4578+ cur = eventPath[i][0];
4579+ event.type = eventPath[i][1];
4580+
4581+ handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
4582+ if ( handle ) {
4583+ handle.apply( cur, data );
4584+ }
4585+ // Note that this is a bare JS function and not a jQuery handler
4586+ handle = ontype && cur[ ontype ];
4587+ if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
4588+ event.preventDefault();
4589+ }
4590+ }
4591+ event.type = type;
4592+
4593+ // If nobody prevented the default action, do it now
4594+ if ( !onlyHandlers && !event.isDefaultPrevented() ) {
4595+
4596+ if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
4597+ !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
4598+
4599+ // Call a native DOM method on the target with the same name name as the event.
4600+ // Can't use an .isFunction() check here because IE6/7 fails that test.
4601+ // Don't do default actions on window, that's where global variables be (#6170)
4602+ // IE<9 dies on focus/blur to hidden element (#1486)
4603+ if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
4604+
4605+ // Don't re-trigger an onFOO event when we call its FOO() method
4606+ old = elem[ ontype ];
4607+
4608+ if ( old ) {
4609+ elem[ ontype ] = null;
4610+ }
4611+
4612+ // Prevent re-triggering of the same event, since we already bubbled it above
4613+ jQuery.event.triggered = type;
4614+ elem[ type ]();
4615+ jQuery.event.triggered = undefined;
4616+
4617+ if ( old ) {
4618+ elem[ ontype ] = old;
4619+ }
4620+ }
4621+ }
4622+ }
4623+
4624+ return event.result;
4625+ },
4626+
4627+ dispatch: function( event ) {
4628+
4629+ // Make a writable jQuery.Event from the native event object
4630+ event = jQuery.event.fix( event || window.event );
4631+
4632+ var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
4633+ delegateCount = handlers.delegateCount,
4634+ args = [].slice.call( arguments, 0 ),
4635+ run_all = !event.exclusive && !event.namespace,
4636+ special = jQuery.event.special[ event.type ] || {},
4637+ handlerQueue = [],
4638+ i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
4639+
4640+ // Use the fix-ed jQuery.Event rather than the (read-only) native event
4641+ args[0] = event;
4642+ event.delegateTarget = this;
4643+
4644+ // Call the preDispatch hook for the mapped type, and let it bail if desired
4645+ if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
4646+ return;
4647+ }
4648+
4649+ // Determine handlers that should run if there are delegated events
4650+ // Avoid non-left-click bubbling in Firefox (#3861)
4651+ if ( delegateCount && !(event.button && event.type === "click") ) {
4652+
4653+ // Pregenerate a single jQuery object for reuse with .is()
4654+ jqcur = jQuery(this);
4655+ jqcur.context = this.ownerDocument || this;
4656+
4657+ for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
4658+
4659+ // Don't process events on disabled elements (#6911, #8165)
4660+ if ( cur.disabled !== true ) {
4661+ selMatch = {};
4662+ matches = [];
4663+ jqcur[0] = cur;
4664+ for ( i = 0; i < delegateCount; i++ ) {
4665+ handleObj = handlers[ i ];
4666+ sel = handleObj.selector;
4667+
4668+ if ( selMatch[ sel ] === undefined ) {
4669+ selMatch[ sel ] = (
4670+ handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
4671+ );
4672+ }
4673+ if ( selMatch[ sel ] ) {
4674+ matches.push( handleObj );
4675+ }
4676+ }
4677+ if ( matches.length ) {
4678+ handlerQueue.push({ elem: cur, matches: matches });
4679+ }
4680+ }
4681+ }
4682+ }
4683+
4684+ // Add the remaining (directly-bound) handlers
4685+ if ( handlers.length > delegateCount ) {
4686+ handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
4687+ }
4688+
4689+ // Run delegates first; they may want to stop propagation beneath us
4690+ for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
4691+ matched = handlerQueue[ i ];
4692+ event.currentTarget = matched.elem;
4693+
4694+ for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
4695+ handleObj = matched.matches[ j ];
4696+
4697+ // Triggered event must either 1) be non-exclusive and have no namespace, or
4698+ // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
4699+ if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
4700+
4701+ event.data = handleObj.data;
4702+ event.handleObj = handleObj;
4703+
4704+ ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
4705+ .apply( matched.elem, args );
4706+
4707+ if ( ret !== undefined ) {
4708+ event.result = ret;
4709+ if ( ret === false ) {
4710+ event.preventDefault();
4711+ event.stopPropagation();
4712+ }
4713+ }
4714+ }
4715+ }
4716+ }
4717+
4718+ // Call the postDispatch hook for the mapped type
4719+ if ( special.postDispatch ) {
4720+ special.postDispatch.call( this, event );
4721+ }
4722+
4723+ return event.result;
4724+ },
4725+
4726+ // Includes some event props shared by KeyEvent and MouseEvent
4727+ // *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
4728+ props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
4729+
4730+ fixHooks: {},
4731+
4732+ keyHooks: {
4733+ props: "char charCode key keyCode".split(" "),
4734+ filter: function( event, original ) {
4735+
4736+ // Add which for key events
4737+ if ( event.which == null ) {
4738+ event.which = original.charCode != null ? original.charCode : original.keyCode;
4739+ }
4740+
4741+ return event;
4742+ }
4743+ },
4744+
4745+ mouseHooks: {
4746+ props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
4747+ filter: function( event, original ) {
4748+ var eventDoc, doc, body,
4749+ button = original.button,
4750+ fromElement = original.fromElement;
4751+
4752+ // Calculate pageX/Y if missing and clientX/Y available
4753+ if ( event.pageX == null && original.clientX != null ) {
4754+ eventDoc = event.target.ownerDocument || document;
4755+ doc = eventDoc.documentElement;
4756+ body = eventDoc.body;
4757+
4758+ event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
4759+ event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );
4760+ }
4761+
4762+ // Add relatedTarget, if necessary
4763+ if ( !event.relatedTarget && fromElement ) {
4764+ event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
4765+ }
4766+
4767+ // Add which for click: 1 === left; 2 === middle; 3 === right
4768+ // Note: button is not normalized, so don't use it
4769+ if ( !event.which && button !== undefined ) {
4770+ event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
4771+ }
4772+
4773+ return event;
4774+ }
4775+ },
4776+
4777+ fix: function( event ) {
4778+ if ( event[ jQuery.expando ] ) {
4779+ return event;
4780+ }
4781+
4782+ // Create a writable copy of the event object and normalize some properties
4783+ var i, prop,
4784+ originalEvent = event,
4785+ fixHook = jQuery.event.fixHooks[ event.type ] || {},
4786+ copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
4787+
4788+ event = jQuery.Event( originalEvent );
4789+
4790+ for ( i = copy.length; i; ) {
4791+ prop = copy[ --i ];
4792+ event[ prop ] = originalEvent[ prop ];
4793+ }
4794+
4795+ // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
4796+ if ( !event.target ) {
4797+ event.target = originalEvent.srcElement || document;
4798+ }
4799+
4800+ // Target should not be a text node (#504, Safari)
4801+ if ( event.target.nodeType === 3 ) {
4802+ event.target = event.target.parentNode;
4803+ }
4804+
4805+ // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
4806+ if ( event.metaKey === undefined ) {
4807+ event.metaKey = event.ctrlKey;
4808+ }
4809+
4810+ return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
4811+ },
4812+
4813+ special: {
4814+ ready: {
4815+ // Make sure the ready event is setup
4816+ setup: jQuery.bindReady
4817+ },
4818+
4819+ load: {
4820+ // Prevent triggered image.load events from bubbling to window.load
4821+ noBubble: true
4822+ },
4823+
4824+ focus: {
4825+ delegateType: "focusin"
4826+ },
4827+ blur: {
4828+ delegateType: "focusout"
4829+ },
4830+
4831+ beforeunload: {
4832+ setup: function( data, namespaces, eventHandle ) {
4833+ // We only want to do this special case on windows
4834+ if ( jQuery.isWindow( this ) ) {
4835+ this.onbeforeunload = eventHandle;
4836+ }
4837+ },
4838+
4839+ teardown: function( namespaces, eventHandle ) {
4840+ if ( this.onbeforeunload === eventHandle ) {
4841+ this.onbeforeunload = null;
4842+ }
4843+ }
4844+ }
4845+ },
4846+
4847+ simulate: function( type, elem, event, bubble ) {
4848+ // Piggyback on a donor event to simulate a different one.
4849+ // Fake originalEvent to avoid donor's stopPropagation, but if the
4850+ // simulated event prevents default then we do the same on the donor.
4851+ var e = jQuery.extend(
4852+ new jQuery.Event(),
4853+ event,
4854+ { type: type,
4855+ isSimulated: true,
4856+ originalEvent: {}
4857+ }
4858+ );
4859+ if ( bubble ) {
4860+ jQuery.event.trigger( e, null, elem );
4861+ } else {
4862+ jQuery.event.dispatch.call( elem, e );
4863+ }
4864+ if ( e.isDefaultPrevented() ) {
4865+ event.preventDefault();
4866+ }
4867+ }
4868+};
4869+
4870+// Some plugins are using, but it's undocumented/deprecated and will be removed.
4871+// The 1.7 special event interface should provide all the hooks needed now.
4872+jQuery.event.handle = jQuery.event.dispatch;
4873+
4874+jQuery.removeEvent = document.removeEventListener ?
4875+ function( elem, type, handle ) {
4876+ if ( elem.removeEventListener ) {
4877+ elem.removeEventListener( type, handle, false );
4878+ }
4879+ } :
4880+ function( elem, type, handle ) {
4881+ if ( elem.detachEvent ) {
4882+ elem.detachEvent( "on" + type, handle );
4883+ }
4884+ };
4885+
4886+jQuery.Event = function( src, props ) {
4887+ // Allow instantiation without the 'new' keyword
4888+ if ( !(this instanceof jQuery.Event) ) {
4889+ return new jQuery.Event( src, props );
4890+ }
4891+
4892+ // Event object
4893+ if ( src && src.type ) {
4894+ this.originalEvent = src;
4895+ this.type = src.type;
4896+
4897+ // Events bubbling up the document may have been marked as prevented
4898+ // by a handler lower down the tree; reflect the correct value.
4899+ this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
4900+ src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
4901+
4902+ // Event type
4903+ } else {
4904+ this.type = src;
4905+ }
4906+
4907+ // Put explicitly provided properties onto the event object
4908+ if ( props ) {
4909+ jQuery.extend( this, props );
4910+ }
4911+
4912+ // Create a timestamp if incoming event doesn't have one
4913+ this.timeStamp = src && src.timeStamp || jQuery.now();
4914+
4915+ // Mark it as fixed
4916+ this[ jQuery.expando ] = true;
4917+};
4918+
4919+function returnFalse() {
4920+ return false;
4921+}
4922+function returnTrue() {
4923+ return true;
4924+}
4925+
4926+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
4927+// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
4928+jQuery.Event.prototype = {
4929+ preventDefault: function() {
4930+ this.isDefaultPrevented = returnTrue;
4931+
4932+ var e = this.originalEvent;
4933+ if ( !e ) {
4934+ return;
4935+ }
4936+
4937+ // if preventDefault exists run it on the original event
4938+ if ( e.preventDefault ) {
4939+ e.preventDefault();
4940+
4941+ // otherwise set the returnValue property of the original event to false (IE)
4942+ } else {
4943+ e.returnValue = false;
4944+ }
4945+ },
4946+ stopPropagation: function() {
4947+ this.isPropagationStopped = returnTrue;
4948+
4949+ var e = this.originalEvent;
4950+ if ( !e ) {
4951+ return;
4952+ }
4953+ // if stopPropagation exists run it on the original event
4954+ if ( e.stopPropagation ) {
4955+ e.stopPropagation();
4956+ }
4957+ // otherwise set the cancelBubble property of the original event to true (IE)
4958+ e.cancelBubble = true;
4959+ },
4960+ stopImmediatePropagation: function() {
4961+ this.isImmediatePropagationStopped = returnTrue;
4962+ this.stopPropagation();
4963+ },
4964+ isDefaultPrevented: returnFalse,
4965+ isPropagationStopped: returnFalse,
4966+ isImmediatePropagationStopped: returnFalse
4967+};
4968+
4969+// Create mouseenter/leave events using mouseover/out and event-time checks
4970+jQuery.each({
4971+ mouseenter: "mouseover",
4972+ mouseleave: "mouseout"
4973+}, function( orig, fix ) {
4974+ jQuery.event.special[ orig ] = {
4975+ delegateType: fix,
4976+ bindType: fix,
4977+
4978+ handle: function( event ) {
4979+ var target = this,
4980+ related = event.relatedTarget,
4981+ handleObj = event.handleObj,
4982+ selector = handleObj.selector,
4983+ ret;
4984+
4985+ // For mousenter/leave call the handler if related is outside the target.
4986+ // NB: No relatedTarget if the mouse left/entered the browser window
4987+ if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
4988+ event.type = handleObj.origType;
4989+ ret = handleObj.handler.apply( this, arguments );
4990+ event.type = fix;
4991+ }
4992+ return ret;
4993+ }
4994+ };
4995+});
4996+
4997+// IE submit delegation
4998+if ( !jQuery.support.submitBubbles ) {
4999+
5000+ jQuery.event.special.submit = {
The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches