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 Cris Dywan
Status: Approved
Approved by: Martin Pitt
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 Approve
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.
Revision history for this message
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
1491. By Cris Dywan

Ship generated HTML and JSON docs for Autopilot helpers

1492. By Cris Dywan

Exclude _build folders from licence check

Unmerged revisions

1492. By Cris Dywan

Exclude _build folders from licence check

1491. By Cris Dywan

Ship generated HTML and JSON docs for Autopilot helpers

1490. By Zoltan Balogh

Sync from trunk

1489. By Tim Peeters

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

[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

Fix typos and extend navigation in theming tutorial.

Approved by Zsombor Egri, PS Jenkins bot.

1486. By Loïc Molinari

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

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

Re-introduce the panel color properties to Ambience PageHeadStyle.

Approved by PS Jenkins bot, Zsombor Egri.

1483. By Zsombor Egri

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