Ubuntu UI Toolkit

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

  1. generatedApDocs
  2. Merge into vivid
Proposed by Christian Dywan on 2015-04-21
Status: Approved
Approved by: Martin Pitt on 2015-04-22
Approved revision: 1492
Proposed branch: lp:~ubuntu-sdk-team/ubuntu-ui-toolkit/generatedApDocs
Merge into: lp:ubuntu/vivid/ubuntu-ui-toolkit
Diff against target: 15750 lines (+15498/-3)
35 files modified
debian/control (+0/-1)
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 (+865/-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)
To merge this branch: bzr merge lp:~ubuntu-sdk-team/ubuntu-ui-toolkit/generatedApDocs
Reviewer Review Type Date Requested Status
Martin Pitt 2015-04-21 Approve on 2015-04-21
Review via email: mp+256910@code.launchpad.net

This proposal has been superseded by a proposal from 2015-04-21.

Commit Message

Ship generated HTML and JSON docs for Autopilot helpers

To post a comment you must log in.
Martin Pitt (pitti) wrote :

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
lp:~ubuntu-sdk-team/ubuntu-ui-toolkit/generatedApDocs updated on 2015-04-21
1491. By Christian Dywan on 2015-04-21

Ship generated HTML and JSON docs for Autopilot helpers

1492. By Christian Dywan on 2015-04-21

Exclude _build folders from licence check

Unmerged revisions

1492. By Christian Dywan on 2015-04-21

Exclude _build folders from licence check

1491. By Christian Dywan on 2015-04-21

Ship generated HTML and JSON docs for Autopilot helpers

1490. By Zoltan Balogh on 2015-04-21

Sync from trunk

1489. By Tim Peeters on 2015-04-20

Create a list of Actions from a list of Tabs so that OverflowPanel only needs one type of model.

Approved by PS Jenkins bot, Christian Dywan.

1488. By Loïc Molinari on 2015-04-20

[UbuntuShape] FBO redirected shapes must be y-flipped only when not rotated. Fixes: https://bugs.launchpad.net/bugs/1446279.

Approved by PS Jenkins bot, Tim Peeters.

1487. By Tim Peeters on 2015-04-20

Fix typos and extend navigation in theming tutorial.

Approved by Zsombor Egri, PS Jenkins bot.

1486. By Loïc Molinari on 2015-04-20

Fixed rendering with VMware's Gallium 0.4 on SVGA3D. Fixes: https://bugs.launchpad.net/bugs/1444975.

Approved by Tim Peeters, PS Jenkins bot.

1485. By Leo Arias on 2015-04-17

Removed python2 support from autopilot tests and helpers. Fixes: https://bugs.launchpad.net/bugs/1429163.

Approved by Christian Dywan, PS Jenkins bot.

1484. By Tim Peeters on 2015-04-17

Re-introduce the panel color properties to Ambience PageHeadStyle.

Approved by PS Jenkins bot, Zsombor Egri.

1483. By Zsombor Egri on 2015-04-17

Theming tutorial.

Approved by Zoltan Balogh, PS Jenkins bot.

Preview Diff

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

Subscribers

People subscribed via source and target branches