Changeset 167

User picture

Author: Mighty Gorgon

(2010/01/26 22:58) About 2 years ago

Bugs fixed:
* Added some conditions in sitemap.js to prevent all h2 to be altered
* Added some extra files to simplify forms and db class implementation
* Added a new function to database_update.php
* Some adjustments to all common CSS
* Minor W3C and syntax corrections (thanks to KugeLSichA and TuningBEB 2008)

Affected files

Updated ip/trunk/adm/admin_jr_admin.php Download diff

166167
255
	while ($row = $db->sql_fetchrow($result))
255
	while ($row = $db->sql_fetchrow($result))
256
	{
256
	{
257
		$jr_admin_row = jr_admin_get_user_info($row['user_id']);
257
		$jr_admin_row = jr_admin_get_user_info($row['user_id']);
258
		$module_count = (!empty($jr_admin_row['user_jr_admin'])) ? count(explode(EXPLODE_SEPERATOR_CHAR, $jr_admin_row['user_jr_admin'])) : 0;
258
		$module_count = (!empty($jr_admin_row['user_jr_admin'])) ? sizeof(explode(EXPLODE_SEPERATOR_CHAR, $jr_admin_row['user_jr_admin'])) : 0;
259
		$block_text = 'userrow';
259
		$block_text = 'userrow';
260
260
261
		$template->assign_block_vars($block_text, array(
261
		$template->assign_block_vars($block_text, array(

Updated ip/trunk/adm/admin_rate.php Download diff

166167
86
				SET config_value =" . $var_value . "
86
				SET config_value =" . $var_value . "
87
				WHERE config_name ='" . $configs_name[$i] . "'";
87
				WHERE config_name ='" . $configs_name[$i] . "'";
88
				$result = $db->sql_query($sql);
88
				$result = $db->sql_query($sql);
89
				$admin_message .= '<br />' . $lang['Update'] . ":&nbsp;&nbsp;&nbsp;" . $configs_desc[$i];
89
				$admin_message .= '<br />' . $lang['Update'] . ':&nbsp;&nbsp;&nbsp;' . $configs_desc[$i];
90
				$config[$configs_name[$i]] = $var_value;
90
				$config[$configs_name[$i]] = $var_value;
91
			}
91
			}
92
		}
92
		}

Updated ip/trunk/adm/xs_clone.php Download diff

166167
136
	$vars = array('clone_tpl', 'clone_style_name', 'total');
136
	$vars = array('clone_tpl', 'clone_style_name', 'total');
137
	$count = 0;
137
	$count = 0;
138
	$list = array();
138
	$list = array();
139
	for($i=0; $i<$total; $i++)
139
	for($i = 0; $i<$total; $i++)
140
	{
140
	{
141
		$vars[] = 'clone_style_id_'.$i;
141
		$vars[] = 'clone_style_id_'.$i;
142
		$vars[] = 'clone_style_'.$i;
142
		$vars[] = 'clone_style_'.$i;

Updated ip/trunk/album_nuffload.php Download diff

166167
70
	{
70
	{
71
		$qstr = "";
71
		$qstr = "";
72
		$key_names = array_keys($_GET);
72
		$key_names = array_keys($_GET);
73
		for($a=0;$a< sizeof($key_names);$a++)
73
		for($a = 0; $a < sizeof($key_names); $a++)
74
		{
74
		{
75
			$qstr .= "&" . $key_names[$a] . "=" . $_GET[$key_names[$a]];
75
			$qstr .= "&" . $key_names[$a] . "=" . $_GET[$key_names[$a]];
76
		}
76
		}

Updated ip/trunk/ctracker/engines/ct_security.php Download diff

166167
211
	'menu_name', 'menu_desc', 'menu_name_lang', 'remove', 'add', 'add_cat', 'add_item',
211
	'menu_name', 'menu_desc', 'menu_name_lang', 'remove', 'add', 'add_cat', 'add_item',
212
	'autologin', 'current_email', 'download', 'menu_link', 'new_password', 'password_confirm',
212
	'autologin', 'current_email', 'download', 'menu_link', 'new_password', 'password_confirm',
213
	'deleteall', 'cat_title', 'cat_desc', 'news_category_edit', 'pm_delete_attach',
213
	'deleteall', 'cat_title', 'cat_desc', 'news_category_edit', 'pm_delete_attach',
214
	'topic_title', 'topic_id', 'friendname', 'friendemail', 'drafts_list',
214
	'topic_title', 'topic_id', 'friendname', 'friendemail', 'drafts_list', 'agreed',
215
	// '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
215
	// '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
216
);
216
);
217
217

Updated ip/trunk/docs/faqs.html Download diff

166167
1
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2
<html>
2
<html xmlns="http://www.w3.org/1999/xhtml">
3
<head>
3
<head>
4
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
4
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
5
	<meta http-equiv="content-style-type" content="text/css" />
5
	<meta http-equiv="content-style-type" content="text/css" />

Updated ip/trunk/docs/ip_coding_standards.html Download diff

166167
1
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2
<html>
2
<html xmlns="http://www.w3.org/1999/xhtml">
3
<head>
3
<head>
4
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
4
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
5
	<meta http-equiv="content-style-type" content="text/css" />
5
	<meta http-equiv="content-style-type" content="text/css" />

Updated ip/trunk/docs/readme_english.html Download diff

166167
1
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
1
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2
<html>
2
<html xmlns="http://www.w3.org/1999/xhtml">
3
<head>
3
<head>
4
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
4
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
5
	<meta http-equiv="content-style-type" content="text/css" />
5
	<meta http-equiv="content-style-type" content="text/css" />

Updated ip/trunk/includes/class_mcp.php Download diff

166167
262
	{
262
	{
263
		global $db, $cache, $lang, $is_auth;
263
		global $db, $cache, $lang, $is_auth;
264
264
265
		if($status == 'sticky' && !$is_auth['auth_sticky'])
265
		if(($status == 'sticky') && !$is_auth['auth_sticky'])
266
		{
266
		{
267
			$message = sprintf($lang['Sorry_auth_sticky'], $is_auth['auth_sticky_type']);
267
			$message = sprintf($lang['Sorry_auth_sticky'], $is_auth['auth_sticky_type']);
268
			message_die(GENERAL_MESSAGE, $message);
268
			message_die(GENERAL_MESSAGE, $message);
269
		}
269
		}
270
		if($status == 'announce' && !$is_auth['auth_announce'])
270
		if(($status == 'announce') && !$is_auth['auth_announce'])
271
		{
271
		{
272
			$message = sprintf($lang['Sorry_auth_announce'], $is_auth['auth_announce_type']);
272
			$message = sprintf($lang['Sorry_auth_announce'], $is_auth['auth_announce_type']);
273
			message_die(GENERAL_MESSAGE, $message);
273
			message_die(GENERAL_MESSAGE, $message);
274
		}
274
		}
275
		if($status == 'super_announce' && !$is_auth['auth_globalannounce'])
275
		if(($status == 'super_announce') && !$is_auth['auth_globalannounce'])
276
		{
276
		{
277
			$message = sprintf($lang['Sorry_auth_announce'], $is_auth['auth_announce_type']);
277
			$message = sprintf($lang['Sorry_auth_announce'], $is_auth['auth_announce_type']);
278
			message_die(GENERAL_MESSAGE, $message);
278
			message_die(GENERAL_MESSAGE, $message);
279
		}
279
		}
280
		if(empty($_POST['topic_id_list']) && empty($topic_id))
280
		if(empty($_POST['topic_id_list']) && empty($topics))
281
		{
281
		{
282
			message_die(GENERAL_MESSAGE, $lang['None_selected']);
282
			message_die(GENERAL_MESSAGE, $lang['None_selected']);
283
		}
283
		}

Updated ip/trunk/includes/class_plugins.php Download diff

166167
18
*/
18
*/
19
class class_plugins
19
class class_plugins
20
{
20
{
21
21
	/*
22
	/*
22
	* Get plugins list
23
	* Get plugins list
23
	*/
24
	*/
...
...
98
			//$db->clear_cache('config_plugins_');
99
			//$db->clear_cache('config_plugins_');
99
		}
100
		}
100
	}
101
	}
102
101
}
103
}
102
104
103
?>
105
?>

Added ip/trunk/includes/common_forms.php

Show contents

Updated ip/trunk/includes/functions_dbmtnc.php Download diff

166167
987
987
988
	if (!$cat_created)
988
	if (!$cat_created)
989
	{
989
	{
990
		// Höchten Wert von cat_order ermitteln
990
		// Identify the highest value of cat_order
991
		$sql = 'SELECT MAX(forum_id) AS forum_id, MAX(forum_order) AS forum_order
991
		$sql = 'SELECT MAX(forum_id) AS forum_id, MAX(forum_order) AS forum_order
992
			FROM ' . FORUMS_TABLE;
992
			FROM ' . FORUMS_TABLE;
993
		$db->sql_return_on_error(true);
993
		$db->sql_return_on_error(true);
...
...
1032
1032
1033
	if (!$forum_created)
1033
	if (!$forum_created)
1034
	{
1034
	{
1035
		// Höchten Wert von forum_id ermitteln
1035
		// Identify the highest value of forum_id
1036
		$sql = 'SELECT MAX(forum_id) AS forum_id
1036
		$sql = 'SELECT MAX(forum_id) AS forum_id
1037
						FROM ' . FORUMS_TABLE;
1037
						FROM ' . FORUMS_TABLE;
1038
		$db->sql_return_on_error(true);
1038
		$db->sql_return_on_error(true);
...
...
1049
			throw_error("Couldn't get forum data!", __LINE__, __FILE__, $sql);
1049
			throw_error("Couldn't get forum data!", __LINE__, __FILE__, $sql);
1050
		}
1050
		}
1051
		$next_forum_id = $row['forum_id'] + 1;
1051
		$next_forum_id = $row['forum_id'] + 1;
1052
		// Höchten Wert von forum_order ermitteln
1052
		// Identify the highest value of forum_order
1053
		$sql = 'SELECT MAX(forum_order) AS forum_order
1053
		$sql = 'SELECT MAX(forum_order) AS forum_order
1054
				FROM ' . FORUMS_TABLE;
1054
				FROM ' . FORUMS_TABLE;
1055
		$db->sql_return_on_error(true);
1055
		$db->sql_return_on_error(true);

Updated ip/trunk/includes/functions_jr_admin.php Download diff

166167
459
{
459
{
460
	global $template, $lang, $module, $userdata, $config;
460
	global $template, $lang, $module, $userdata, $config;
461
461
462
	/* Debug? Changes the status stnading of ADMIN!!!  You are warned */
462
	/* Debug? Changes the status standing of ADMIN!!! You are warned */
463
	$debug = false;
463
	$debug = false;
464
464
465
	if (($userdata['user_level'] != ADMIN) || $debug)
465
	if (($userdata['user_level'] != ADMIN) || $debug)

Updated ip/trunk/install/includes/functions_install.php Download diff

166167
2274
			define('FORUM_CAT', 0);
2274
			define('FORUM_CAT', 0);
2275
		}
2275
		}
2276
2276
2277
		$sql = 'SHOW TABLES LIKE ' . CATEGORIES_TABLE;
2278
		$result = $db->sql_query($sql);
2279
		$row = $db->sql_fetchrow($result);
2280
		if (empty($row))
2281
		{
2282
			return false;
2283
		}
2284
2277
		// Determine the highest id used within the old forums table (we add the categories after the forum ids)
2285
		// Determine the highest id used within the old forums table (we add the categories after the forum ids)
2278
		$sql = 'SELECT MAX(forum_id) AS max_forum_id
2286
		$sql = 'SELECT MAX(forum_id) AS max_forum_id
2279
			FROM ' . FORUMS_TABLE;
2287
			FROM ' . FORUMS_TABLE;

Updated ip/trunk/install/includes/ip_tools.php Download diff

166167
565
				$sql_results_ok .= '<li>' . $sql[$i] . '<br /> +++ <span style="color:' . $page_framework->color_ok . ';"><b>' .
$lang['Successful'] . '</b></span><br /><br /></li>' . "\n";
565
				$sql_results_ok .= '<li>' . $sql[$i] . '<br /> +++ <span style="color:' . $page_framework->color_ok . ';"><b>' .
$lang['Successful'] . '</b></span><br /><br /></li>' . "\n";
566
			}
566
			}
567
		}
567
		}
568
		if (defined('FIX_FORUMS') && FIX_FORUMS)
569
		{
570
			$page_framework->convert_forums();
571
			empty_cache_folders();
572
		}
568
		$page_framework->table_begin($lang['IcyPhoenix'] . ' - ' . $lang['UpdateInProgress'], 'row-post');
573
		$page_framework->table_begin($lang['IcyPhoenix'] . ' - ' . $lang['UpdateInProgress'], 'row-post');
569
		echo('<div class="post-text">' . "\n");
574
		echo('<div class="post-text">' . "\n");
570
		echo('<b>' . $lang['DBUpdate_Errors'] . ':</b><br />' . "\n");
575
		echo('<b>' . $lang['DBUpdate_Errors'] . ':</b><br />' . "\n");

Updated ip/trunk/install/schemas/mysql_basic.sql Download diff

166167
1557
1557
1558
## `phpbb_smilies`
1558
## `phpbb_smilies`
1559
##
1559
##
1560
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (1, ':D', 'icon_biggrin.gif', 'Very Happy', 0);
1560
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (1, ':D', 'icon_biggrin.gif', 'Very Happy', 1);
1561
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (2, ':-D', 'icon_biggrin.gif', 'Very Happy', 0);
1561
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (2, ':-D', 'icon_biggrin.gif', 'Very Happy', 2);
1562
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (3, ':grin:', 'icon_biggrin.gif', 'Very Happy', 0);
1562
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (3, ':grin:', 'icon_biggrin.gif', 'Very Happy', 3);
1563
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (4, ':)', 'icon_smile.gif', 'Smile', 0);
1563
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (4, ':)', 'icon_smile.gif', 'Smile', 4);
1564
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (5, ':-)', 'icon_smile.gif', 'Smile', 0);
1564
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (5, ':-)', 'icon_smile.gif', 'Smile', 5);
1565
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (6, ':smile:', 'icon_smile.gif', 'Smile', 0);
1565
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (6, ':smile:', 'icon_smile.gif', 'Smile', 6);
1566
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (7, ':(', 'icon_sad.gif', 'Sad', 0);
1566
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (7, ':(', 'icon_sad.gif', 'Sad', 7);
1567
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (8, ':-(', 'icon_sad.gif', 'Sad', 0);
1567
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (8, ':-(', 'icon_sad.gif', 'Sad', 8);
1568
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (9, ':sad:', 'icon_sad.gif', 'Sad', 0);
1568
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (9, ':sad:', 'icon_sad.gif', 'Sad', 9);
1569
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (10, ':o', 'icon_surprised.gif', 'Surprised', 0);
1569
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (10, ':o', 'icon_surprised.gif', 'Surprised', 10);
1570
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (11, ':-o', 'icon_surprised.gif', 'Surprised', 0);
1570
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (11, ':-o', 'icon_surprised.gif', 'Surprised', 11);
1571
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (12, ':eek:', 'icon_surprised.gif', 'Surprised', 0);
1571
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (12, ':eek:', 'icon_surprised.gif', 'Surprised', 12);
1572
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (13, ':shock:', 'icon_eek.gif', 'Shocked', 0);
1572
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (13, ':shock:', 'icon_eek.gif', 'Shocked', 13);
1573
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (14, ':?', 'icon_confused.gif', 'Confused', 0);
1573
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (14, ':?', 'icon_confused.gif', 'Confused', 14);
1574
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (15, ':-?', 'icon_confused.gif', 'Confused', 0);
1574
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (15, ':-?', 'icon_confused.gif', 'Confused', 15);
1575
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (16, ':???:', 'icon_confused.gif', 'Confused', 0);
1575
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (16, ':???:', 'icon_confused.gif', 'Confused', 16);
1576
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (17, '8)', 'icon_cool.gif', 'Cool', 0);
1576
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (17, '8)', 'icon_cool.gif', 'Cool', 17);
1577
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (18, '8-)', 'icon_cool.gif', 'Cool', 0);
1577
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (18, '8-)', 'icon_cool.gif', 'Cool', 18);
1578
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (19, ':cool:', 'icon_cool.gif', 'Cool', 0);
1578
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (19, ':cool:', 'icon_cool.gif', 'Cool', 19);
1579
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (20, ':lol:', 'icon_lol.gif', 'Laughing', 0);
1579
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (20, ':lol:', 'icon_lol.gif', 'Laughing', 20);
1580
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (21, ':x', 'icon_mad.gif', 'Mad', 0);
1580
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (21, ':x', 'icon_mad.gif', 'Mad', 21);
1581
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (22, ':-x', 'icon_mad.gif', 'Mad', 0);
1581
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (22, ':-x', 'icon_mad.gif', 'Mad', 22);
1582
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (23, ':mad:', 'icon_mad.gif', 'Mad', 0);
1582
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (23, ':mad:', 'icon_mad.gif', 'Mad', 23);
1583
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (24, ':P', 'icon_razz.gif', 'Razz', 0);
1583
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (24, ':P', 'icon_razz.gif', 'Razz', 24);
1584
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (25, ':-P', 'icon_razz.gif', 'Razz', 0);
1584
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (25, ':-P', 'icon_razz.gif', 'Razz', 25);
1585
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (26, ':razz:', 'icon_razz.gif', 'Razz', 0);
1585
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (26, ':razz:', 'icon_razz.gif', 'Razz', 26);
1586
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (27, ':oops:', 'icon_redface.gif', 'Embarassed', 0);
1586
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (27, ':oops:', 'icon_redface.gif', 'Embarassed', 27);
1587
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (28, ':cry:', 'icon_cry.gif', 'Crying or Very sad', 0);
1587
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (28, ':cry:', 'icon_cry.gif', 'Crying or Very sad', 28);
1588
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (29, ':evil:', 'icon_evil.gif', 'Evil or Very Mad', 0);
1588
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (29, ':evil:', 'icon_evil.gif', 'Evil or Very Mad', 29);
1589
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (30, ':twisted:', 'icon_twisted.gif', 'Twisted Evil', 0);
1589
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (30, ':twisted:', 'icon_twisted.gif', 'Twisted Evil', 30);
1590
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (31, ':roll:', 'icon_rolleyes.gif', 'Rolling Eyes', 0);
1590
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (31, ':roll:', 'icon_rolleyes.gif', 'Rolling Eyes', 31);
1591
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (32, ':wink:', 'icon_wink.gif', 'Wink', 0);
1591
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (32, ':wink:', 'icon_wink.gif', 'Wink', 32);
1592
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (33, ';)', 'icon_wink.gif', 'Wink', 0);
1592
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (33, ';)', 'icon_wink.gif', 'Wink', 33);
1593
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (34, ';-)', 'icon_wink.gif', 'Wink', 0);
1593
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (34, ';-)', 'icon_wink.gif', 'Wink', 34);
1594
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (35, ':!:', 'icon_exclaim.gif', 'Exclamation', 0);
1594
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (35, ':!:', 'icon_exclaim.gif', 'Exclamation', 35);
1595
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (36, ':?:', 'icon_question.gif', 'Question', 0);
1595
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (36, ':?:', 'icon_question.gif', 'Question', 36);
1596
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (37, ':idea:', 'icon_idea.gif', 'Idea', 0);
1596
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (37, ':idea:', 'icon_idea.gif', 'Idea', 37);
1597
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (38, ':arrow:', 'icon_arrow.gif', 'Arrow', 0);
1597
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (38, ':arrow:', 'icon_arrow.gif', 'Arrow', 38);
1598
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (39, ':|', 'icon_neutral.gif', 'Neutral', 0);
1598
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (39, ':|', 'icon_neutral.gif', 'Neutral', 39);
1599
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (40, ':-|', 'icon_neutral.gif', 'Neutral', 0);
1599
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (40, ':-|', 'icon_neutral.gif', 'Neutral', 40);
1600
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (41, ':neutral:', 'icon_neutral.gif', 'Neutral', 0);
1600
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (41, ':neutral:', 'icon_neutral.gif', 'Neutral', 41);
1601
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (42, ':mricy:', 'icon_mricy.gif', 'Mr. Ycy', 0);
1601
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (42, ':mricy:', 'icon_mricy.gif', 'Mr. Icy', 42);
1602
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (43, ':mrblue:', 'icon_mrblue.gif', 'Mr. Blue', 0);
1602
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (43, ':mrblue:', 'icon_mrblue.gif', 'Mr. Blue', 43);
1603
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (44, ':mrgreen:', 'icon_mrgreen.gif', 'Mr. Green', 0);
1603
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (44, ':mrgreen:', 'icon_mrgreen.gif', 'Mr. Green', 44);
1604
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (45, ':mrorange:', 'icon_mrorange.gif', 'Mr. Orange', 0);
1604
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (45, ':mrorange:', 'icon_mrorange.gif', 'Mr. Orange', 45);
1605
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (46, ':mrviolet:', 'icon_mrviolet.gif', 'Mr. Violet', 0);
1605
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (46, ':mrviolet:', 'icon_mrviolet.gif', 'Mr. Violet', 46);
1606
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (47, ':mryellow:', 'icon_mryellow.gif', 'Mr. Yellow', 0);
1606
INSERT INTO `phpbb_smilies` (`smilies_id`, `code`, `smile_url`, `emoticon`, `smilies_order`) VALUES (47, ':mryellow:', 'icon_mryellow.gif', 'Mr. Yellow', 47);
1607
1607
1608
## `phpbb_stats_config`
1608
## `phpbb_stats_config`
1609
##
1609
##

Updated ip/trunk/install/schemas/mysql_schema.sql Download diff

166167
1199
	`file_id` int(10) NOT NULL auto_increment,
1199
	`file_id` int(10) NOT NULL auto_increment,
1200
	`user_id` mediumint(8) NOT NULL DEFAULT '0',
1200
	`user_id` mediumint(8) NOT NULL DEFAULT '0',
1201
	`poster_ip` varchar(8) NOT NULL DEFAULT '',
1201
	`poster_ip` varchar(8) NOT NULL DEFAULT '',
1202
	`file_name` TEXT NOT NULL,
1202
	`file_name` text NOT NULL,
1203
	`file_size` int(20) NOT NULL DEFAULT '0',
1203
	`file_size` int(20) NOT NULL DEFAULT '0',
1204
	`unique_name` varchar(255) NOT NULL DEFAULT '',
1204
	`unique_name` varchar(255) NOT NULL DEFAULT '',
1205
	`real_name` varchar(255) NOT NULL DEFAULT '',
1205
	`real_name` varchar(255) NOT NULL DEFAULT '',
1206
	`file_dir` varchar(255) NOT NULL DEFAULT '',
1206
	`file_dir` varchar(255) NOT NULL DEFAULT '',
1207
	`file_desc` TEXT NOT NULL,
1207
	`file_desc` text NOT NULL,
1208
	`file_creator` TEXT NOT NULL,
1208
	`file_creator` text NOT NULL,
1209
	`file_version` TEXT NOT NULL,
1209
	`file_version` text NOT NULL,
1210
	`file_longdesc` TEXT NOT NULL,
1210
	`file_longdesc` text NOT NULL,
1211
	`file_ssurl` TEXT NOT NULL,
1211
	`file_ssurl` text NOT NULL,
1212
	`file_sshot_link` tinyint(2) NOT NULL DEFAULT '0',
1212
	`file_sshot_link` tinyint(2) NOT NULL DEFAULT '0',
1213
	`file_dlurl` TEXT NOT NULL,
1213
	`file_dlurl` text NOT NULL,
1214
	`file_time` int(50) DEFAULT NULL,
1214
	`file_time` int(50) DEFAULT NULL,
1215
	`file_update_time` int(50) NOT NULL DEFAULT '0',
1215
	`file_update_time` int(50) NOT NULL DEFAULT '0',
1216
	`file_catid` int(10) DEFAULT NULL,
1216
	`file_catid` int(10) DEFAULT NULL,
1217
	`file_posticon` TEXT NOT NULL,
1217
	`file_posticon` text NOT NULL,
1218
	`file_license` int(10) DEFAULT NULL,
1218
	`file_license` int(10) DEFAULT NULL,
1219
	`file_dls` int(10) DEFAULT NULL,
1219
	`file_dls` int(10) DEFAULT NULL,
1220
	`file_last` int(50) DEFAULT NULL,
1220
	`file_last` int(50) DEFAULT NULL,
1221
	`file_pin` int(2) DEFAULT NULL,
1221
	`file_pin` int(2) DEFAULT NULL,
1222
	`file_docsurl` TEXT NOT NULL,
1222
	`file_docsurl` text NOT NULL,
1223
	`file_approved` tinyint(1) NOT NULL DEFAULT '1',
1223
	`file_approved` tinyint(1) NOT NULL DEFAULT '1',
1224
	`file_broken` tinyint(1) NOT NULL DEFAULT '0',
1224
	`file_broken` tinyint(1) NOT NULL DEFAULT '0',
1225
	PRIMARY KEY (`file_id`)
1225
	PRIMARY KEY (`file_id`)
...
...
1283
## `phpbb_plugins`
1283
## `phpbb_plugins`
1284
1284
1285
CREATE TABLE phpbb_plugins (
1285
CREATE TABLE phpbb_plugins (
1286
	plugin_name VARCHAR(255) NOT NULL DEFAULT '',
1286
	plugin_name varchar(255) NOT NULL DEFAULT '',
1287
	plugin_dir VARCHAR(255) NOT NULL DEFAULT '',
1287
	plugin_dir varchar(255) NOT NULL DEFAULT '',
1288
	plugin_enabled tinyint(2) NOT NULL DEFAULT 0,
1288
	plugin_enabled tinyint(2) NOT NULL DEFAULT 0,
1289
	PRIMARY KEY (plugin_name)
1289
	PRIMARY KEY (plugin_name)
1290
);
1290
);
...
...
1305
	`poster_ip` varchar(8) NOT NULL DEFAULT '',
1305
	`poster_ip` varchar(8) NOT NULL DEFAULT '',
1306
	`post_username` varchar(25) DEFAULT NULL,
1306
	`post_username` varchar(25) DEFAULT NULL,
1307
	`post_subject` varchar(255) DEFAULT NULL,
1307
	`post_subject` varchar(255) DEFAULT NULL,
1308
	`post_text` TEXT NOT NULL,
1308
	`post_text` text NOT NULL,
1309
	`post_text_compiled` TEXT NOT NULL,
1309
	`post_text_compiled` TEXT NOT NULL,
1310
	`enable_bbcode` tinyint(1) NOT NULL DEFAULT '1',
1310
	`enable_bbcode` tinyint(1) NOT NULL DEFAULT '1',
1311
	`enable_html` tinyint(1) NOT NULL DEFAULT '0',
1311
	`enable_html` tinyint(1) NOT NULL DEFAULT '0',
1312
	`enable_smilies` tinyint(1) NOT NULL DEFAULT '1',
1312
	`enable_smilies` tinyint(1) NOT NULL DEFAULT '1',
1313
	`enable_autolinks_acronyms` tinyint(1) NOT NULL DEFAULT '1',
1313
	`enable_autolinks_acronyms` tinyint(1) NOT NULL DEFAULT '1',
1314
	`enable_sig` tinyint(1) NOT NULL DEFAULT '1',
1314
	`enable_sig` tinyint(1) NOT NULL DEFAULT '1',
1315
	`edit_notes` MEDIUMTEXT,
1315
	`edit_notes` mediumtext,
1316
	`post_edit_time` int(11) DEFAULT NULL,
1316
	`post_edit_time` int(11) DEFAULT NULL,
1317
	`post_edit_count` smallint(5) unsigned NOT NULL DEFAULT '0',
1317
	`post_edit_count` smallint(5) unsigned NOT NULL DEFAULT '0',
1318
	`post_edit_id` mediumint(8) NOT NULL DEFAULT '0',
1318
	`post_edit_id` mediumint(8) NOT NULL DEFAULT '0',
...
...
1336
	`privmsgs_id` mediumint(8) unsigned NOT NULL auto_increment,
1336
	`privmsgs_id` mediumint(8) unsigned NOT NULL auto_increment,
1337
	`privmsgs_type` tinyint(4) NOT NULL DEFAULT '0',
1337
	`privmsgs_type` tinyint(4) NOT NULL DEFAULT '0',
1338
	`privmsgs_subject` varchar(255) NOT NULL DEFAULT '',
1338
	`privmsgs_subject` varchar(255) NOT NULL DEFAULT '',
1339
	`privmsgs_text` TEXT NOT NULL,
1339
	`privmsgs_text` text NOT NULL,
1340
	`privmsgs_from_userid` mediumint(8) NOT NULL DEFAULT '0',
1340
	`privmsgs_from_userid` mediumint(8) NOT NULL DEFAULT '0',
1341
	`privmsgs_to_userid` mediumint(8) NOT NULL DEFAULT '0',
1341
	`privmsgs_to_userid` mediumint(8) NOT NULL DEFAULT '0',
1342
	`privmsgs_date` int(11) NOT NULL DEFAULT '0',
1342
	`privmsgs_date` int(11) NOT NULL DEFAULT '0',
...
...
1363
	`privmsgs_id` mediumint(8) unsigned NOT NULL auto_increment,
1363
	`privmsgs_id` mediumint(8) unsigned NOT NULL auto_increment,
1364
	`privmsgs_type` tinyint(4) NOT NULL DEFAULT '0',
1364
	`privmsgs_type` tinyint(4) NOT NULL DEFAULT '0',
1365
	`privmsgs_subject` varchar(255) NOT NULL DEFAULT '',
1365
	`privmsgs_subject` varchar(255) NOT NULL DEFAULT '',
1366
	`privmsgs_text` TEXT NOT NULL,
1366
	`privmsgs_text` text NOT NULL,
1367
	`privmsgs_from_userid` mediumint(8) NOT NULL DEFAULT '0',
1367
	`privmsgs_from_userid` mediumint(8) NOT NULL DEFAULT '0',
1368
	`privmsgs_to_userid` mediumint(8) NOT NULL DEFAULT '0',
1368
	`privmsgs_to_userid` mediumint(8) NOT NULL DEFAULT '0',
1369
	`privmsgs_date` int(11) NOT NULL DEFAULT '0',
1369
	`privmsgs_date` int(11) NOT NULL DEFAULT '0',
...
...
1396
	`text_area_default` TEXT NOT NULL,
1396
	`text_area_default` TEXT NOT NULL,
1397
	`text_area_maxlen` int(255) unsigned NOT NULL DEFAULT '1024',
1397
	`text_area_maxlen` int(255) unsigned NOT NULL DEFAULT '1024',
1398
	`radio_button_default` varchar(255) DEFAULT NULL,
1398
	`radio_button_default` varchar(255) DEFAULT NULL,
1399
	`radio_button_values` TEXT NOT NULL,
1399
	`radio_button_values` text NOT NULL,
1400
	`checkbox_default` TEXT NOT NULL,
1400
	`checkbox_default` text NOT NULL,
1401
	`checkbox_values` TEXT NOT NULL,
1401
	`checkbox_values` text NOT NULL,
1402
	`is_required` tinyint(2) unsigned NOT NULL DEFAULT '0',
1402
	`is_required` tinyint(2) unsigned NOT NULL DEFAULT '0',
1403
	`users_can_view` tinyint(2) unsigned NOT NULL DEFAULT '1',
1403
	`users_can_view` tinyint(2) unsigned NOT NULL DEFAULT '1',
1404
	`view_in_profile` tinyint(2) unsigned NOT NULL DEFAULT '1',
1404
	`view_in_profile` tinyint(2) unsigned NOT NULL DEFAULT '1',

Updated ip/trunk/install/schemas/sql_update_ip.php Download diff

166167
3582
3582
3583
		/* Updating from IP 1.3.1.54 */
3583
		/* Updating from IP 1.3.1.54 */
3584
		case '1.3.1.54':
3584
		case '1.3.1.54':
3585
		define('FIX_FORUMS', true);
3585
		$sql[] = "INSERT INTO `" . $table_prefix . "config` (`config_name`, `config_value`) VALUES ('forum_limit_edit_time_interval', '1440')";
3586
		$sql[] = "INSERT INTO `" . $table_prefix . "config` (`config_name`, `config_value`) VALUES ('forum_limit_edit_time_interval', '1440')";
3586
3587
3587
		$sql[] = "ALTER TABLE `" . $table_prefix . "forums` CHANGE `cat_id` `parent_id` mediumint(8) UNSIGNED NOT NULL DEFAULT '0'";
3588
		$sql[] = "ALTER TABLE `" . $table_prefix . "forums` CHANGE `cat_id` `parent_id` mediumint(8) UNSIGNED NOT NULL DEFAULT '0'";

Updated ip/trunk/install/style/style.css Download diff

166167
538
}
538
}
539
539
540
.nav-links-left {
540
.nav-links-left {
541
	position: relative;
542
	float: left;
541
	float: left;
543
	text-align: left;
542
	text-align: left;
544
}
543
}

Updated ip/trunk/language/lang_english/lang_main.php Download diff

166167
2261
	'AJAX_SHOUTBOX_PVT_LINK' => 'Direct chat with this user',
2261
	'AJAX_SHOUTBOX_PVT_LINK' => 'Direct chat with this user',
2262
	'AJAX_SHOUTBOX_PVT_ALERT' => 'You have a chat request',
2262
	'AJAX_SHOUTBOX_PVT_ALERT' => 'You have a chat request',
2263
2263
2264
	// COMMON DB - BEGIN
2265
	'SELECT_SORT_METHOD' => 'Sort by',
2266
	'ORDER' => 'Sort method',
2267
	'SUBMIT' => 'Submit',
2268
	'DATE' => 'Date',
2269
	'USERID' => 'User ID',
2270
	'USERNAME' => 'Username',
2271
	'EMAIL' => 'Email',
2272
	'WEBSITE' => 'Website',
2273
	'EDIT' => 'Edit',
2274
	'DELETE' => 'Delete',
2275
	'YES' => 'Yes',
2276
	'NO' => 'No',
2277
2278
	'DB_ITEM_VIEW' => 'View Item',
2279
	'DB_ITEM_UPDATED' => 'Item updated successfully',
2280
	'DB_ITEM_ADD' => 'Add Item',
2281
	'DB_ITEM_ADDED' => 'Item added successfully',
2282
	'DB_ITEM_REMOVED' => 'Item removed successfully',
2283
	'DB_ITEM_NO_ITEMS' => 'No Items',
2284
	'DB_ITEM_CLICK_VIEW_ITEM' => 'Click %sHere%s to view added data',
2285
	'DB_ITEM_CLICK_RETURN_ITEMS' => 'Click %sHere%s to return to list page',
2286
	// COMMON DB - END
2287
2264
	)
2288
	)
2265
);
2289
);
2266
2290

Updated ip/trunk/modcp.php Download diff

166167
657
			$topic_subject = trim(htmlspecialchars($_POST['subject']));
657
			$topic_subject = trim(htmlspecialchars($_POST['subject']));
658
			if(empty($topic_subject))
658
			if(empty($topic_subject))
659
			{
659
			{
660
			message_die(GENERAL_MESSAGE, $lang['Empty_subject']);
660
				message_die(GENERAL_MESSAGE, $lang['Empty_subject']);
661
			}
661
			}
662
662
663
			$new_topic_id = $mcp_topic->topic_split($posts, $forum_id, $fid, $topic_id, $split_beyond, $topic_subject);
663
			$new_topic_id = $mcp_topic->topic_split($posts, $forum_id, $fid, $topic_id, $split_beyond, $topic_subject);

Updated ip/trunk/templates/common/acp.css Download diff

166167
540
}
540
}
541
541
542
.nav-links-left {
542
.nav-links-left {
543
	position: relative;
544
	float: left;
543
	float: left;
545
	text-align: left;
544
	text-align: left;
546
}
545
}

Added ip/trunk/templates/common/border-radius.htc

Show contents

Updated ip/trunk/templates/common/cms.css Download diff

166167
212
}
212
}
213
213
214
.nav-links-left {
214
.nav-links-left {
215
	position: relative;
216
	float: left;
215
	float: left;
217
	text-align: left;
216
	text-align: left;
218
}
217
}

Updated ip/trunk/templates/common/jquery/jquery.js Download diff

166167
1
/*!
1
/*!
2
 * jQuery JavaScript Library v1.3.2
2
 * jQuery JavaScript Library v1.4
3
 * http://jquery.com/
3
 * http://jquery.com/
4
 *
4
 *
5
 * Copyright (c) 2009 John Resig
5
 * Copyright 2010, John Resig
6
 * Dual licensed under the MIT and GPL licenses.
6
 * Dual licensed under the MIT or GPL Version 2 licenses.
7
 * http://docs.jquery.com/License
7
 * http://docs.jquery.com/License
8
 *
8
 *
9
 * Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)
9
 * Includes Sizzle.js
10
 * Revision: 6246
10
 * http://sizzlejs.com/
11
 */
11
 * Copyright 2010, The Dojo Foundation
12
(function(){
12
 * Released under the MIT, BSD, and GPL Licenses.
13
13
 *
14
var
14
 * Date: Wed Jan 13 15:23:05 2010 -0500
15
	// Will speed up references to window, and allows munging its name.
15
 */
16
	window = this,
16
(function( window, undefined ) {
17
	// Will speed up references to undefined, and allows munging its name.
17
18
	undefined,
18
// Define a local copy of jQuery
19
	// Map over jQuery in case of overwrite
19
var jQuery = function( selector, context ) {
20
	_jQuery = window.jQuery,
20
		// The jQuery object is actually just the init constructor 'enhanced'
21
	// Map over the $ in case of overwrite
21
		return new jQuery.fn.init( selector, context );
22
	_$ = window.$,
22
	},
23
23
24
	jQuery = window.jQuery = window.$ = function( selector, context ) {
24
	// Map over jQuery in case of overwrite
25
		// The jQuery object is actually just the init constructor 'enhanced'
25
	_jQuery = window.jQuery,
26
		return new jQuery.fn.init( selector, context );
26
27
	},
27
	// Map over the $ in case of overwrite
28
28
	_$ = window.$,
29
	// A simple way to check for HTML strings or ID strings
29
30
	// (both of which we optimize for)
30
	// Use the correct document accordingly with window argument (sandbox)
31
	quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
31
	document = window.document,
32
	// Is it a simple selector
32
33
	isSimple = /^.[^:#\[\.,]*$/;
33
	// A central reference to the root jQuery(document)
34
34
	rootjQuery,
35
jQuery.fn = jQuery.prototype = {
35
36
	init: function( selector, context ) {
36
	// A simple way to check for HTML strings or ID strings
37
		// Make sure that a selection was provided
37
	// (both of which we optimize for)
38
		selector = selector || document;
38
	quickExpr = /^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,
39
39
40
		// Handle $(DOMElement)
40
	// Is it a simple selector
41
		if ( selector.nodeType ) {
41
	isSimple = /^.[^:#\[\.,]*$/,
42
			this[0] = selector;
42
43
			this.length = 1;
43
	// Check if a string has a non-whitespace character in it
44
			this.context = selector;
44
	rnotwhite = /\S/,
45
			return this;
45
46
		}
46
	// Used for trimming whitespace
47
		// Handle HTML strings
47
	rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g,
48
		if ( typeof selector === "string" ) {
48
49
			// Are we dealing with HTML string or an ID?
49
	// Match a standalone tag
50
			var match = quickExpr.exec( selector );
50
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
51
51
52
			// Verify a match, and that no context was specified for #id
52
	// Keep a UserAgent string for use with jQuery.browser
53
			if ( match && (match[1] || !context) ) {
53
	userAgent = navigator.userAgent,
54
54
55
				// HANDLE: $(html) -> $(array)
55
	// For matching the engine and version of the browser
56
				if ( match[1] )
56
	browserMatch,
57
					selector = jQuery.clean( [ match[1] ], context );
57
	
58
58
	// Has the ready events already been bound?
59
				// HANDLE: $("#id")
59
	readyBound = false,
60
				else {
60
	
61
					var elem = document.getElementById( match[3] );
61
	// The functions to execute on DOM ready
62
62
	readyList = [],
63
					// Handle the case where IE and Opera return items
63
64
					// by name instead of ID
64
	// The ready event handler
65
					if ( elem && elem.id != match[3] )
65
	DOMContentLoaded,
66
						return jQuery().find( selector );
66
67
67
	// Save a reference to some core methods
68
					// Otherwise, we inject the element directly into the jQuery object
68
	toString = Object.prototype.toString,
69
					var ret = jQuery( elem || [] );
69
	hasOwnProperty = Object.prototype.hasOwnProperty,
70
					ret.context = document;
70
	push = Array.prototype.push,
71
					ret.selector = selector;
71
	slice = Array.prototype.slice,
72
					return ret;
72
	indexOf = Array.prototype.indexOf;
73
				}
73
74
74
jQuery.fn = jQuery.prototype = {
75
			// HANDLE: $(expr, [context])
75
	init: function( selector, context ) {
76
			// (which is just equivalent to: $(content).find(expr)
76
		var match, elem, ret, doc;
77
			} else
77
78
				return jQuery( context ).find( selector );
78
		// Handle $(""), $(null), or $(undefined)
79
79
		if ( !selector ) {
80
		// HANDLE: $(function)
80
			return this;
81
		// Shortcut for document ready
81
		}
82
		} else if ( jQuery.isFunction( selector ) )
82
83
			return jQuery( document ).ready( selector );
83
		// Handle $(DOMElement)
84
84
		if ( selector.nodeType ) {
85
		// Make sure that old selector state is passed along
85
			this.context = this[0] = selector;
86
		if ( selector.selector && selector.context ) {
86
			this.length = 1;
87
			this.selector = selector.selector;
87
			return this;
88
			this.context = selector.context;
88
		}
89
		}
89
90
90
		// Handle HTML strings
91
		return this.setArray(jQuery.isArray( selector ) ?
91
		if ( typeof selector === "string" ) {
92
			selector :
92
			// Are we dealing with HTML string or an ID?
93
			jQuery.makeArray(selector));
93
			match = quickExpr.exec( selector );
94
	},
94
95
95
			// Verify a match, and that no context was specified for #id
96
	// Start with an empty selector
96
			if ( match && (match[1] || !context) ) {
97
	selector: "",
97
98
98
				// HANDLE: $(html) -> $(array)
99
	// The current version of jQuery being used
99
				if ( match[1] ) {
100
	jquery: "1.3.2",
100
					doc = (context ? context.ownerDocument || context : document);
101
101
102
	// The number of elements contained in the matched element set
102
					// If a single string is passed in and it's a single tag
103
	size: function() {
103
					// just do a createElement and skip the rest
104
		return this.length;
104
					ret = rsingleTag.exec( selector );
105
	},
105
106
106
					if ( ret ) {
107
	// Get the Nth element in the matched element set OR
107
						if ( jQuery.isPlainObject( context ) ) {
108
	// Get the whole matched element set as a clean array
108
							selector = [ document.createElement( ret[1] ) ];
109
	get: function( num ) {
109
							jQuery.fn.attr.call( selector, context, true );
110
		return num === undefined ?
110
111
111
						} else {
112
			// Return a 'clean' array
112
							selector = [ doc.createElement( ret[1] ) ];
113
			Array.prototype.slice.call( this ) :
113
						}
114
114
115
			// Return just the object
115
					} else {
116
			this[ num ];
116
						ret = buildFragment( [ match[1] ], [ doc ] );
117
	},
117
						selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
118
118
					}
119
	// Take an array of elements and push it onto the stack
119
120
	// (returning the new matched element set)
120
				// HANDLE: $("#id")
121
	pushStack: function( elems, name, selector ) {
121
				} else {
122
		// Build a new jQuery matched element set
122
					elem = document.getElementById( match[2] );
123
		var ret = jQuery( elems );
123
124
124
					if ( elem ) {
125
		// Add the old object onto the stack (as a reference)
125
						// Handle the case where IE and Opera return items
126
		ret.prevObject = this;
126
						// by name instead of ID
127
127
						if ( elem.id !== match[2] ) {
128
		ret.context = this.context;
128
							return rootjQuery.find( selector );
129
129
						}
130
		if ( name === "find" )
130
131
			ret.selector = this.selector + (this.selector ? " " : "") + selector;
131
						// Otherwise, we inject the element directly into the jQuery object
132
		else if ( name )
132
						this.length = 1;
133
			ret.selector = this.selector + "." + name + "(" + selector + ")";
133
						this[0] = elem;
134
134
					}
135
		// Return the newly-formed element set
135
136
		return ret;
136
					this.context = document;
137
	},
137
					this.selector = selector;
138
138
					return this;
139
	// Force the current matched set of elements to become
139
				}
140
	// the specified array of elements (destroying the stack in the process)
140
141
	// You should use pushStack() in order to do this, but maintain the stack
141
			// HANDLE: $("TAG")
142
	setArray: function( elems ) {
142
			} else if ( !context && /^\w+$/.test( selector ) ) {
143
		// Resetting the length to 0, then using the native Array push
143
				this.selector = selector;
144
		// is a super-fast way to populate an object with array-like properties
144
				this.context = document;
145
		this.length = 0;
145
				selector = document.getElementsByTagName( selector );
146
		Array.prototype.push.apply( this, elems );
146
147
147
			// HANDLE: $(expr, $(...))
148
		return this;
148
			} else if ( !context || context.jquery ) {
149
	},
149
				return (context || rootjQuery).find( selector );
150
150
151
	// Execute a callback for every element in the matched set.
151
			// HANDLE: $(expr, context)
152
	// (You can seed the arguments with an array of args, but this is
152
			// (which is just equivalent to: $(context).find(expr)
153
	// only used internally.)
153
			} else {
154
	each: function( callback, args ) {
154
				return jQuery( context ).find( selector );
155
		return jQuery.each( this, callback, args );
155
			}
156
	},
156
157
157
		// HANDLE: $(function)
158
	// Determine the position of an element within
158
		// Shortcut for document ready
159
	// the matched set of elements
159
		} else if ( jQuery.isFunction( selector ) ) {
160
	index: function( elem ) {
160
			return rootjQuery.ready( selector );
161
		// Locate the position of the desired element
161
		}
162
		return jQuery.inArray(
162
163
			// If it receives a jQuery object, the first element is used
163
		if (selector.selector !== undefined) {
164
			elem && elem.jquery ? elem[0] : elem
164
			this.selector = selector.selector;
165
		, this );
165
			this.context = selector.context;
166
	},
166
		}
167
167
168
	attr: function( name, value, type ) {
168
		return jQuery.isArray( selector ) ?
169
		var options = name;
169
			this.setArray( selector ) :
170
170
			jQuery.makeArray( selector, this );
171
		// Look for the case where we're accessing a style value
171
	},
172
		if ( typeof name === "string" )
172
173
			if ( value === undefined )
173
	// Start with an empty selector
174
				return this[0] && jQuery[ type || "attr" ]( this[0], name );
174
	selector: "",
175
175
176
			else {
176
	// The current version of jQuery being used
177
				options = {};
177
	jquery: "1.4",
178
				options[ name ] = value;
178
179
			}
179
	// The default length of a jQuery object is 0
180
180
	length: 0,
181
		// Check to see if we're setting style values
181
182
		return this.each(function(i){
182
	// The number of elements contained in the matched element set
183
			// Set all the styles
183
	size: function() {
184
			for ( name in options )
184
		return this.length;
185
				jQuery.attr(
185
	},
186
					type ?
186
187
						this.style :
187
	toArray: function() {
188
						this,
188
		return slice.call( this, 0 );
189
					name, jQuery.prop( this, options[ name ], type, i, name )
189
	},
190
				);
190
191
		});
191
	// Get the Nth element in the matched element set OR
192
	},
192
	// Get the whole matched element set as a clean array
193
193
	get: function( num ) {
194
	css: function( key, value ) {
194
		return num == null ?
195
		// ignore negative width and height values
195
196
		if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
196
			// Return a 'clean' array
197
			value = undefined;
197
			this.toArray() :
198
		return this.attr( key, value, "curCSS" );
198
199
	},
199
			// Return just the object
200
200
			( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
201
	text: function( text ) {
201
	},
202
		if ( typeof text !== "object" && text != null )
202
203
			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
203
	// Take an array of elements and push it onto the stack
204
204
	// (returning the new matched element set)
205
		var ret = "";
205
	pushStack: function( elems, name, selector ) {
206
206
		// Build a new jQuery matched element set
207
		jQuery.each( text || this, function(){
207
		var ret = jQuery( elems || null );
208
			jQuery.each( this.childNodes, function(){
208
209
				if ( this.nodeType != 8 )
209
		// Add the old object onto the stack (as a reference)
210
					ret += this.nodeType != 1 ?
210
		ret.prevObject = this;
211
						this.nodeValue :
211
212
						jQuery.fn.text( [ this ] );
212
		ret.context = this.context;
213
			});
213
214
		});
214
		if ( name === "find" ) {
215
215
			ret.selector = this.selector + (this.selector ? " " : "") + selector;
216
		return ret;
216
		} else if ( name ) {
217
	},
217
			ret.selector = this.selector + "." + name + "(" + selector + ")";
218
218
		}
219
	wrapAll: function( html ) {
219
220
		if ( this[0] ) {
220
		// Return the newly-formed element set
221
			// The elements to wrap the target around
221
		return ret;
222
			var wrap = jQuery( html, this[0].ownerDocument ).clone();
222
	},
223
223
224
			if ( this[0].parentNode )
224
	// Force the current matched set of elements to become
225
				wrap.insertBefore( this[0] );
225
	// the specified array of elements (destroying the stack in the process)
226
226
	// You should use pushStack() in order to do this, but maintain the stack
227
			wrap.map(function(){
227
	setArray: function( elems ) {
228
				var elem = this;
228
		// Resetting the length to 0, then using the native Array push
229
229
		// is a super-fast way to populate an object with array-like properties
230
				while ( elem.firstChild )
230
		this.length = 0;
231
					elem = elem.firstChild;
231
		push.apply( this, elems );
232
232
233
				return elem;
233
		return this;
234
			}).append(this);
234
	},
235
		}
235
236
236
	// Execute a callback for every element in the matched set.
237
		return this;
237
	// (You can seed the arguments with an array of args, but this is
238
	},
238
	// only used internally.)
239
239
	each: function( callback, args ) {
240
	wrapInner: function( html ) {
240
		return jQuery.each( this, callback, args );
241
		return this.each(function(){
241
	},
242
			jQuery( this ).contents().wrapAll( html );
242
	
243
		});
243
	ready: function( fn ) {
244
	},
244
		// Attach the listeners
245
245
		jQuery.bindReady();
246
	wrap: function( html ) {
246
247
		return this.each(function(){
247
		// If the DOM is already ready
248
			jQuery( this ).wrapAll( html );
248
		if ( jQuery.isReady ) {
249
		});
249
			// Execute the function immediately
250
	},
250
			fn.call( document, jQuery );
251
251
252
	append: function() {
252
		// Otherwise, remember the function for later
253
		return this.domManip(arguments, true, function(elem){
253
		} else if ( readyList ) {
254
			if (this.nodeType == 1)
254
			// Add the function to the wait list
255
				this.appendChild( elem );
255
			readyList.push( fn );
256
		});
256
		}
257
	},
257
258
258
		return this;
259
	prepend: function() {
259
	},
260
		return this.domManip(arguments, true, function(elem){
260
	
261
			if (this.nodeType == 1)
261
	eq: function( i ) {
262
				this.insertBefore( elem, this.firstChild );
262
		return i === -1 ?
263
		});
263
			this.slice( i ) :
264
	},
264
			this.slice( i, +i + 1 );
265
265
	},
266
	before: function() {
266
267
		return this.domManip(arguments, false, function(elem){
267
	first: function() {
268
			this.parentNode.insertBefore( elem, this );
268
		return this.eq( 0 );
269
		});
269
	},
270
	},
270
271
271
	last: function() {
272
	after: function() {
272
		return this.eq( -1 );
273
		return this.domManip(arguments, false, function(elem){
273
	},
274
			this.parentNode.insertBefore( elem, this.nextSibling );
274
275
		});
275
	slice: function() {
276
	},
276
		return this.pushStack( slice.apply( this, arguments ),
277
277
			"slice", slice.call(arguments).join(",") );
278
	end: function() {
278
	},
279
		return this.prevObject || jQuery( [] );
279
280
	},
280
	map: function( callback ) {
281
281
		return this.pushStack( jQuery.map(this, function( elem, i ) {
282
	// For internal use only.
282
			return callback.call( elem, i, elem );
283
	// Behaves like an Array's method, not like a jQuery method.
283
		}));
284
	push: [].push,
284
	},
285
	sort: [].sort,
285
	
286
	splice: [].splice,
286
	end: function() {
287
287
		return this.prevObject || jQuery(null);
288
	find: function( selector ) {
288
	},
289
		if ( this.length === 1 ) {
289
290
			var ret = this.pushStack( [], "find", selector );
290
	// For internal use only.
291
			ret.length = 0;
291
	// Behaves like an Array's method, not like a jQuery method.
292
			jQuery.find( selector, this[0], ret );
292
	push: push,
293
			return ret;
293
	sort: [].sort,
294
		} else {
294
	splice: [].splice
295
			return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){
295
};
296
				return jQuery.find( selector, elem );
296
297
			})), "find", selector );
297
// Give the init function the jQuery prototype for later instantiation
298
		}
298
jQuery.fn.init.prototype = jQuery.fn;
299
	},
299
300
300
jQuery.extend = jQuery.fn.extend = function() {
301
	clone: function( events ) {
301
	// copy reference to target object
302
		// Do the clone
302
	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
303
		var ret = this.map(function(){
303
304
			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
304
	// Handle a deep copy situation
305
				// IE copies events bound via attachEvent when
305
	if ( typeof target === "boolean" ) {
306
				// using cloneNode. Calling detachEvent on the
306
		deep = target;
307
				// clone will also remove the events from the orignal
307
		target = arguments[1] || {};
308
				// In order to get around this, we use innerHTML.
308
		// skip the boolean and the target
309
				// Unfortunately, this means some modifications to
309
		i = 2;
310
				// attributes in IE that are actually only stored
310
	}
311
				// as properties will not be copied (such as the
311
312
				// the name attribute on an input).
312
	// Handle case when target is a string or something (possible in deep copy)
313
				var html = this.outerHTML;
313
	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
314
				if ( !html ) {
314
		target = {};
315
					var div = this.ownerDocument.createElement("div");
315
	}
316
					div.appendChild( this.cloneNode(true) );
316
317
					html = div.innerHTML;
317
	// extend jQuery itself if only one argument is passed
318
				}
318
	if ( length === i ) {
319
319
		target = this;
320
				return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];
320
		--i;
321
			} else
321
	}
322
				return this.cloneNode(true);
322
323
		});
323
	for ( ; i < length; i++ ) {
324
324
		// Only deal with non-null/undefined values
325
		// Copy the events from the original to the clone
325
		if ( (options = arguments[ i ]) != null ) {
326
		if ( events === true ) {
326
			// Extend the base object
327
			var orig = this.find("*").andSelf(), i = 0;
327
			for ( name in options ) {
328
328
				src = target[ name ];
329
			ret.find("*").andSelf().each(function(){
329
				copy = options[ name ];
330
				if ( this.nodeName !== orig[i].nodeName )
330
331
					return;
331
				// Prevent never-ending loop
332
332
				if ( target === copy ) {
333
				var events = jQuery.data( orig[i], "events" );
333
					continue;
334
334
				}
335
				for ( var type in events ) {
335
336
					for ( var handler in events[ type ] ) {
336
				// Recurse if we're merging object literal values or arrays
337
						jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
337
				if ( deep && copy && ( jQuery.isPlainObject(copy) || jQuery.isArray(copy) ) ) {
338
					}
338
					var clone = src && ( jQuery.isPlainObject(src) || jQuery.isArray(src) ) ? src
339
				}
339
						: jQuery.isArray(copy) ? [] : {};
340
340
341
				i++;
341
					// Never move original objects, clone them
342
			});
342
					target[ name ] = jQuery.extend( deep, clone, copy );
343
		}
343
344
344
				// Don't bring in undefined values
345
		// Return the cloned set
345
				} else if ( copy !== undefined ) {
346
		return ret;
346
					target[ name ] = copy;
347
	},
347
				}
348
348
			}
349
	filter: function( selector ) {
349
		}
350
		return this.pushStack(
350
	}
351
			jQuery.isFunction( selector ) &&
351
352
			jQuery.grep(this, function(elem, i){
352
	// Return the modified object
353
				return selector.call( elem, i );
353
	return target;
354
			}) ||
354
};
355
355
356
			jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
356
jQuery.extend({
357
				return elem.nodeType === 1;
357
	noConflict: function( deep ) {
358
			}) ), "filter", selector );
358
		window.$ = _$;
359
	},
359
360
360
		if ( deep ) {
361
	closest: function( selector ) {
361
			window.jQuery = _jQuery;
362
		var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null,
362
		}
363
			closer = 0;
363
364
364
		return jQuery;
365
		return this.map(function(){
365
	},
366
			var cur = this;
366
	
367
			while ( cur && cur.ownerDocument ) {
367
	// Is the DOM ready to be used? Set to true once it occurs.
368
				if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) {
368
	isReady: false,
369
					jQuery.data(cur, "closest", closer);
369
	
370
					return cur;
370
	// Handle when the DOM is ready
371
				}
371
	ready: function() {
372
				cur = cur.parentNode;
372
		// Make sure that the DOM is not already loaded
373
				closer++;
373
		if ( !jQuery.isReady ) {
374
			}
374
			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
375
		});
375
			if ( !document.body ) {
376
	},
376
				return setTimeout( jQuery.ready, 13 );
377
377
			}
378
	not: function( selector ) {
378
379
		if ( typeof selector === "string" )
379
			// Remember that the DOM is ready
380
			// test special case where just one selector is passed in
380
			jQuery.isReady = true;
381
			if ( isSimple.test( selector ) )
381
382
				return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
382
			// If there are functions bound, to execute
383
			else
383
			if ( readyList ) {
384
				selector = jQuery.multiFilter( selector, this );
384
				// Execute all of them
385
385
				var fn, i = 0;
386
		var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
386
				while ( (fn = readyList[ i++ ]) ) {
387
		return this.filter(function() {
387
					fn.call( document, jQuery );
388
			return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
388
				}
389
		});
389
390
	},
390
				// Reset the list of functions
391
391
				readyList = null;
392
	add: function( selector ) {
392
			}
393
		return this.pushStack( jQuery.unique( jQuery.merge(
393
394
			this.get(),
394
			// Trigger any bound ready events
395
			typeof selector === "string" ?
395
			if ( jQuery.fn.triggerHandler ) {
396
				jQuery( selector ) :
396
				jQuery( document ).triggerHandler( "ready" );
397
				jQuery.makeArray( selector )
397
			}
398
		)));
398
		}
399
	},
399
	},
400
400
	
401
	is: function( selector ) {
401
	bindReady: function() {
402
		return !!selector && jQuery.multiFilter( selector, this ).length > 0;
402
		if ( readyBound ) {
403
	},
403
			return;
404
404
		}
405
	hasClass: function( selector ) {
405
406
		return !!selector && this.is( "." + selector );
406
		readyBound = true;
407
	},
407
408
408
		// Catch cases where $(document).ready() is called after the
409
	val: function( value ) {
409
		// browser event has already occurred.
410
		if ( value === undefined ) {
410
		if ( document.readyState === "complete" ) {
411
			var elem = this[0];
411
			return jQuery.ready();
412
412
		}
413
			if ( elem ) {
413
414
				if( jQuery.nodeName( elem, 'option' ) )
414
		// Mozilla, Opera and webkit nightlies currently support this event
415
					return (elem.attributes.value || {}).specified ? elem.value : elem.text;
415
		if ( document.addEventListener ) {
416
416
			// Use the handy event callback
417
				// We need to handle select boxes special
417
			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
418
				if ( jQuery.nodeName( elem, "select" ) ) {
418
			
419
					var index = elem.selectedIndex,
419
			// A fallback to window.onload, that will always work
420
						values = [],
420
			window.addEventListener( "load", jQuery.ready, false );
421
						options = elem.options,
421
422
						one = elem.type == "select-one";
422
		// If IE event model is used
423
423
		} else if ( document.attachEvent ) {
424
					// Nothing was selected
424
			// ensure firing before onload,
425
					if ( index < 0 )
425
			// maybe late but safe also for iframes
426
						return null;
426
			document.attachEvent("onreadystatechange", DOMContentLoaded);
427
427
			
428
					// Loop through all the selected options
428
			// A fallback to window.onload, that will always work
429
					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
429
			window.attachEvent( "onload", jQuery.ready );
430
						var option = options[ i ];
430
431
431
			// If IE and not a frame
432
						if ( option.selected ) {
432
			// continually check to see if the document is ready
433
							// Get the specifc value for the option
433
			var toplevel = false;
434
							value = jQuery(option).val();
434
435
435
			try {
436
							// We don't need an array for one selects
436
				toplevel = window.frameElement == null;
437
							if ( one )
437
			} catch(e) {}
438
								return value;
438
439
439
			if ( document.documentElement.doScroll && toplevel ) {
440
							// Multi-Selects return an array
440
				doScrollCheck();
441
							values.push( value );
441
			}
442
						}
442
		}
443
					}
443
	},
444
444
445
					return values;
445
	// See test/unit/core.js for details concerning isFunction.
446
				}
446
	// Since version 1.3, DOM methods and functions like alert
447
447
	// aren't supported. They return false on IE (#2968).
448
				// Everything else, we just grab the value
448
	isFunction: function( obj ) {
449
				return (elem.value || "").replace(/\r/g, "");
449
		return toString.call(obj) === "[object Function]";
450
450
	},
451
			}
451
452
452
	isArray: function( obj ) {
453
			return undefined;
453
		return toString.call(obj) === "[object Array]";
454
		}
454
	},
455
455
456
		if ( typeof value === "number" )
456
	isPlainObject: function( obj ) {
457
			value += '';
457
		// Must be an Object.
458
458
		// Because of IE, we also have to check the presence of the constructor property.
459
		return this.each(function(){
459
		// Make sure that DOM nodes and window objects don't pass through, as well
460
			if ( this.nodeType != 1 )
460
		if ( !obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval ) {
461
				return;
461
			return false;
462
462
		}
463
			if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
463
		
464
				this.checked = (jQuery.inArray(this.value, value) >= 0 ||
464
		// Not own constructor property must be Object
465
					jQuery.inArray(this.name, value) >= 0);
465
		if ( obj.constructor
466
466
			&& !hasOwnProperty.call(obj, "constructor")
467
			else if ( jQuery.nodeName( this, "select" ) ) {
467
			&& !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) {
468
				var values = jQuery.makeArray(value);
468
			return false;
469
469
		}
470
				jQuery( "option", this ).each(function(){
470
		
471
					this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
471
		// Own properties are enumerated firstly, so to speed up,
472
						jQuery.inArray( this.text, values ) >= 0);
472
		// if last one is own, then all properties are own.
473
				});
473
	
474
474
		var key;
475
				if ( !values.length )
475
		for ( key in obj ) {}
476
					this.selectedIndex = -1;
476
		
477
477
		return key === undefined || hasOwnProperty.call( obj, key );
478
			} else
478
	},
479
				this.value = value;
479
480
		});
480
	isEmptyObject: function( obj ) {
481
	},
481
		for ( var name in obj ) {
482
482
			return false;
483
	html: function( value ) {
483
		}
484
		return value === undefined ?
484
		return true;
485
			(this[0] ?
485
	},
486
				this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :
486
487
				null) :
487
	noop: function() {},
488
			this.empty().append( value );
488
489
	},
489
	// Evalulates a script in a global context
490
490
	globalEval: function( data ) {
491
	replaceWith: function( value ) {
491
		if ( data && rnotwhite.test(data) ) {
492
		return this.after( value ).remove();
492
			// Inspired by code by Andrea Giammarchi
493
	},
493
			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
494
494
			var head = document.getElementsByTagName("head")[0] || document.documentElement,
495
	eq: function( i ) {
495
				script = document.createElement("script");
496
		return this.slice( i, +i + 1 );
496
497
	},
497
			script.type = "text/javascript";
498
498
499
	slice: function() {
499
			if ( jQuery.support.scriptEval ) {
500
		return this.pushStack( Array.prototype.slice.apply( this, arguments ),
500
				script.appendChild( document.createTextNode( data ) );
501
			"slice", Array.prototype.slice.call(arguments).join(",") );
501
			} else {
502
	},
502
				script.text = data;
503
503
			}
504
	map: function( callback ) {
504
505
		return this.pushStack( jQuery.map(this, function(elem, i){
505
			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
506
			return callback.call( elem, i, elem );
506
			// This arises when a base node is used (#2709).
507
		}));
507
			head.insertBefore( script, head.firstChild );
508
	},
508
			head.removeChild( script );
509
509
		}
510
	andSelf: function() {
510
	},
511
		return this.add( this.prevObject );
511
512
	},
512
	nodeName: function( elem, name ) {
513
513
		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
514
	domManip: function( args, table, callback ) {
514
	},
515
		if ( this[0] ) {
515
516
			var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
516
	// args is for internal usage only
517
				scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
517
	each: function( object, callback, args ) {
518
				first = fragment.firstChild;
518
		var name, i = 0,
519
519
			length = object.length,
520
			if ( first )
520
			isObj = length === undefined || jQuery.isFunction(object);
521
				for ( var i = 0, l = this.length; i < l; i++ )
521
522
					callback.call( root(this[i], first), this.length > 1 || i > 0 ?
522
		if ( args ) {
523
							fragment.cloneNode(true) : fragment );
523
			if ( isObj ) {
524
524
				for ( name in object ) {
525
			if ( scripts )
525
					if ( callback.apply( object[ name ], args ) === false ) {
526
				jQuery.each( scripts, evalScript );
526
						break;
527
		}
527
					}
528
528
				}
529
		return this;
529
			} else {
530
530
				for ( ; i < length; ) {
531
		function root( elem, cur ) {
531
					if ( callback.apply( object[ i++ ], args ) === false ) {
532
			return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
532
						break;
533
				(elem.getElementsByTagName("tbody")[0] ||
533
					}
534
				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
534
				}
535
				elem;
535
			}
536
		}
536
537
	}
537
		// A special, fast, case for the most common use of each
538
};
538
		} else {
539
539
			if ( isObj ) {
540
// Give the init function the jQuery prototype for later instantiation
540
				for ( name in object ) {
541
jQuery.fn.init.prototype = jQuery.fn;
541
					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
542
542
						break;
543
function evalScript( i, elem ) {
543
					}
544
	if ( elem.src )
544
				}
545
		jQuery.ajax({
545
			} else {
546
			url: elem.src,
546
				for ( var value = object[0];
547
			async: false,
547
					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
548
			dataType: "script"
548
			}
549
		});
549
		}
550
550
551
	else
551
		return object;
552
		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
552
	},
553
553
554
	if ( elem.parentNode )
554
	trim: function( text ) {
555
		elem.parentNode.removeChild( elem );
555
		return (text || "").replace( rtrim, "" );
556
}
556
	},
557
557
558
function now(){
558
	// results is for internal usage only
559
	return +new Date;
559
	makeArray: function( array, results ) {
560
}
560
		var ret = results || [];
561
561
562
jQuery.extend = jQuery.fn.extend = function() {
562
		if ( array != null ) {
563
	// copy reference to target object
563
			// The window, strings (and functions) also have 'length'
564
	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
564
			// The extra typeof function check is to prevent crashes
565
565
			// in Safari 2 (See: #3039)
566
	// Handle a deep copy situation
566
			if ( array.length == null || typeof array === "string" || jQuery.isFunction(array) || (typeof array !== "function" && array.setInterval) ) {
567
	if ( typeof target === "boolean" ) {
567
				push.call( ret, array );
568
		deep = target;
568
			} else {
569
		target = arguments[1] || {};
569
				jQuery.merge( ret, array );
570
		// skip the boolean and the target
570
			}
571
		i = 2;
571
		}
572
	}
572
573
573
		return ret;
574
	// Handle case when target is a string or something (possible in deep copy)
574
	},
575
	if ( typeof target !== "object" && !jQuery.isFunction(target) )
575
576
		target = {};
576
	inArray: function( elem, array ) {
577
577
		if ( array.indexOf ) {
578
	// extend jQuery itself if only one argument is passed
578
			return array.indexOf( elem );
579
	if ( length == i ) {
579
		}
580
		target = this;
580
581
		--i;
581
		for ( var i = 0, length = array.length; i < length; i++ ) {
582
	}
582
			if ( array[ i ] === elem ) {
583
583
				return i;
584
	for ( ; i < length; i++ )
584
			}
585
		// Only deal with non-null/undefined values
585
		}
586
		if ( (options = arguments[ i ]) != null )
586
587
			// Extend the base object
587
		return -1;
588
			for ( var name in options ) {
588
	},
589
				var src = target[ name ], copy = options[ name ];
589
590
590
	merge: function( first, second ) {
591
				// Prevent never-ending loop
591
		var i = first.length, j = 0;
592
				if ( target === copy )
592
593
					continue;
593
		if ( typeof second.length === "number" ) {
594
594
			for ( var l = second.length; j < l; j++ ) {
595
				// Recurse if we're merging object values
595
				first[ i++ ] = second[ j ];
596
				if ( deep && copy && typeof copy === "object" && !copy.nodeType )
596
			}
597
					target[ name ] = jQuery.extend( deep,
597
		} else {
598
						// Never move original objects, clone them
598
			while ( second[j] !== undefined ) {
599
						src || ( copy.length != null ? [ ] : { } )
599
				first[ i++ ] = second[ j++ ];
600
					, copy );
600
			}
601
601
		}
602
				// Don't bring in undefined values
602
603
				else if ( copy !== undefined )
603
		first.length = i;
604
					target[ name ] = copy;
604
605
605
		return first;
606
			}
606
	},
607
607
608
	// Return the modified object
608
	grep: function( elems, callback, inv ) {
609
	return target;
609
		var ret = [];
610
};
610
611
611
		// Go through the array, only saving the items
612
// exclude the following css properties to add px
612
		// that pass the validator function
613
var	exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
613
		for ( var i = 0, length = elems.length; i < length; i++ ) {
614
	// cache defaultView
614
			if ( !inv !== !callback( elems[ i ], i ) ) {
615
	defaultView = document.defaultView || {},
615
				ret.push( elems[ i ] );
616
	toString = Object.prototype.toString;
616
			}
617
617
		}
618
jQuery.extend({
618
619
	noConflict: function( deep ) {
619
		return ret;
620
		window.$ = _$;
620
	},
621
621
622
		if ( deep )
622
	// arg is for internal usage only
623
			window.jQuery = _jQuery;
623
	map: function( elems, callback, arg ) {
624
624
		var ret = [], value;
625
		return jQuery;
625
626
	},
626
		// Go through the array, translating each of the items to their
627
627
		// new value (or values).
628
	// See test/unit/core.js for details concerning isFunction.
628
		for ( var i = 0, length = elems.length; i < length; i++ ) {
629
	// Since version 1.3, DOM methods and functions like alert
629
			value = callback( elems[ i ], i, arg );
630
	// aren't supported. They return false on IE (#2968).
630
631
	isFunction: function( obj ) {
631
			if ( value != null ) {
632
		return toString.call(obj) === "[object Function]";
632
				ret[ ret.length ] = value;
633
	},
633
			}
634
634
		}
635
	isArray: function( obj ) {
635
636
		return toString.call(obj) === "[object Array]";
636
		return ret.concat.apply( [], ret );
637
	},
637
	},
638
638
639
	// check if an element is in a (or is an) XML document
639
	// A global GUID counter for objects
640
	isXMLDoc: function( elem ) {
640
	guid: 1,
641
		return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
641
642
			!!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );
642
	proxy: function( fn, proxy, thisObject ) {
643
	},
643
		if ( arguments.length === 2 ) {
644
644
			if ( typeof proxy === "string" ) {
645
	// Evalulates a script in a global context
645
				thisObject = fn;
646
	globalEval: function( data ) {
646
				fn = thisObject[ proxy ];
647
		if ( data && /\S/.test(data) ) {
647
				proxy = undefined;
648
			// Inspired by code by Andrea Giammarchi
648
649
			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
649
			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
650
			var head = document.getElementsByTagName("head")[0] || document.documentElement,
650
				thisObject = proxy;
651
				script = document.createElement("script");
651
				proxy = undefined;
652
652
			}
653
			script.type = "text/javascript";
653
		}
654
			if ( jQuery.support.scriptEval )
654
655
				script.appendChild( document.createTextNode( data ) );
655
		if ( !proxy && fn ) {
656
			else
656
			proxy = function() {
657
				script.text = data;
657
				return fn.apply( thisObject || this, arguments );
658
658
			};
659
			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
659
		}
660
			// This arises when a base node is used (#2709).
660
661
			head.insertBefore( script, head.firstChild );
661
		// Set the guid of unique handler to the same of original handler, so it can be removed
662
			head.removeChild( script );
662
		if ( fn ) {
663
		}
663
			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
664
	},
664
		}
665
665
666
	nodeName: function( elem, name ) {
666
		// So proxy can be declared as an argument
667
		return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
667
		return proxy;
668
	},
668
	},
669
669
670
	// args is for internal usage only
670
	// Use of jQuery.browser is frowned upon.
671
	each: function( object, callback, args ) {
671
	// More details: http://docs.jquery.com/Utilities/jQuery.browser
672
		var name, i = 0, length = object.length;
672
	uaMatch: function( ua ) {
673
673
		var ret = { browser: "" };
674
		if ( args ) {
674
675
			if ( length === undefined ) {
675
		ua = ua.toLowerCase();
676
				for ( name in object )
676
677
					if ( callback.apply( object[ name ], args ) === false )
677
		if ( /webkit/.test( ua ) ) {
678
						break;
678
			ret = { browser: "webkit", version: /webkit[\/ ]([\w.]+)/ };
679
			} else
679
680
				for ( ; i < length; )
680
		} else if ( /opera/.test( ua ) ) {
681
					if ( callback.apply( object[ i++ ], args ) === false )
681
			ret = { browser: "opera", version:  /version/.test( ua ) ? /version[\/ ]([\w.]+)/ : /opera[\/ ]([\w.]+)/ };
682
						break;
682
			
683
683
		} else if ( /msie/.test( ua ) ) {
684
		// A special, fast, case for the most common use of each
684
			ret = { browser: "msie", version: /msie ([\w.]+)/ };
685
		} else {
685
686
			if ( length === undefined ) {
686
		} else if ( /mozilla/.test( ua ) && !/compatible/.test( ua ) ) {
687
				for ( name in object )
687
			ret = { browser: "mozilla", version: /rv:([\w.]+)/ };
688
					if ( callback.call( object[ name ], name, object[ name ] ) === false )
688
		}
689
						break;
689
690
			} else
690
		ret.version = (ret.version && ret.version.exec( ua ) || [0, "0"])[1];
691
				for ( var value = object[0];
691
692
					i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
692
		return ret;
693
		}
693
	},
694
694
695
		return object;
695
	browser: {}
696
	},
696
});
697
697
698
	prop: function( elem, value, type, i, name ) {
698
browserMatch = jQuery.uaMatch( userAgent );
699
		// Handle executable functions
699
if ( browserMatch.browser ) {
700
		if ( jQuery.isFunction( value ) )
700
	jQuery.browser[ browserMatch.browser ] = true;
701
			value = value.call( elem, i );
701
	jQuery.browser.version = browserMatch.version;
702
702
}
703
		// Handle passing in a number to a CSS property
703
704
		return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
704
// Deprecated, use jQuery.browser.webkit instead
705
			value + "px" :
705
if ( jQuery.browser.webkit ) {
706
			value;
706
	jQuery.browser.safari = true;
707
	},
707
}
708
708
709
	className: {
709
if ( indexOf ) {
710
		// internal only, use addClass("class")
710
	jQuery.inArray = function( elem, array ) {
711
		add: function( elem, classNames ) {
711
		return indexOf.call( array, elem );
712
			jQuery.each((classNames || "").split(/\s+/), function(i, className){
712
	};
713
				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
713
}
714
					elem.className += (elem.className ? " " : "") + className;
714
715
			});
715
// All jQuery objects should point back to these
716
		},
716
rootjQuery = jQuery(document);
717
717
718
		// internal only, use removeClass("class")
718
// Cleanup functions for the document ready method
719
		remove: function( elem, classNames ) {
719
if ( document.addEventListener ) {
720
			if (elem.nodeType == 1)
720
	DOMContentLoaded = function() {
721
				elem.className = classNames !== undefined ?
721
		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
722
					jQuery.grep(elem.className.split(/\s+/), function(className){
722
		jQuery.ready();
723
						return !jQuery.className.has( classNames, className );
723
	};
724
					}).join(" ") :
724
725
					"";
725
} else if ( document.attachEvent ) {
726
		},
726
	DOMContentLoaded = function() {
727
727
		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
728
		// internal only, use hasClass("class")
728
		if ( document.readyState === "complete" ) {
729
		has: function( elem, className ) {
729
			document.detachEvent( "onreadystatechange", DOMContentLoaded );
730
			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
730
			jQuery.ready();
731
		}
731
		}
732
	},
732
	};
733
733
}
734
	// A method for quickly swapping in/out CSS properties to get correct calculations
734
735
	swap: function( elem, options, callback ) {
735
// The DOM ready check for Internet Explorer
736
		var old = {};
736
function doScrollCheck() {
737
		// Remember the old values, and insert the new ones
737
	if ( jQuery.isReady ) {
738
		for ( var name in options ) {
738
		return;
739
			old[ name ] = elem.style[ name ];
739
	}
740
			elem.style[ name ] = options[ name ];
740
741
		}
741
	try {
742
742
		// If IE is used, use the trick by Diego Perini
743
		callback.call( elem );
743
		// http://javascript.nwbox.com/IEContentLoaded/
744
744
		document.documentElement.doScroll("left");
745
		// Revert the old values
745
	} catch( error ) {
746
		for ( var name in options )
746
		setTimeout( doScrollCheck, 1 );
747
			elem.style[ name ] = old[ name ];
747
		return;
748
	},
748
	}
749
749
750
	css: function( elem, name, force, extra ) {
750
	// and execute any waiting functions
751
		if ( name == "width" || name == "height" ) {
751
	jQuery.ready();
752
			var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
752
}
753
753
754
			function getWH() {
754
if ( indexOf ) {
755
				val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
755
	jQuery.inArray = function( elem, array ) {
756
756
		return indexOf.call( array, elem );
757
				if ( extra === "border" )
757
	};
758
					return;
758
}
759
759
760
				jQuery.each( which, function() {
760
function evalScript( i, elem ) {
761
					if ( !extra )
761
	if ( elem.src ) {
762
						val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
762
		jQuery.ajax({
763
					if ( extra === "margin" )
763
			url: elem.src,
764
						val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
764
			async: false,
765
					else
765
			dataType: "script"
766
						val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
766
		});
767
				});
767
	} else {
768
			}
768
		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
769
769
	}
770
			if ( elem.offsetWidth !== 0 )
770
771
				getWH();
771
	if ( elem.parentNode ) {
772
			else
772
		elem.parentNode.removeChild( elem );
773
				jQuery.swap( elem, props, getWH );
773
	}
774
774
}
775
			return Math.max(0, Math.round(val));
775
776
		}
776
// Mutifunctional method to get and set values to a collection
777
777
// The value/s can be optionally by executed if its a function
778
		return jQuery.curCSS( elem, name, force );
778
function access( elems, key, value, exec, fn, pass ) {
779
	},
779
	var length = elems.length;
780
780
	
781
	curCSS: function( elem, name, force ) {
781
	// Setting many attributes
782
		var ret, style = elem.style;
782
	if ( typeof key === "object" ) {
783
783
		for ( var k in key ) {
784
		// We need to handle opacity special in IE
784
			access( elems, k, key[k], exec, fn, value );
785
		if ( name == "opacity" && !jQuery.support.opacity ) {
785
		}
786
			ret = jQuery.attr( style, "opacity" );
786
		return elems;
787
787
	}
788
			return ret == "" ?
788
	
789
				"1" :
789
	// Setting one attribute
790
				ret;
790
	if ( value !== undefined ) {
791
		}
791
		// Optionally, function values get executed if exec is true
792
792
		exec = !pass && exec && jQuery.isFunction(value);
793
		// Make sure we're using the right name for getting the float value
793
		
794
		if ( name.match( /float/i ) )
794
		for ( var i = 0; i < length; i++ ) {
795
			name = styleFloat;
795
			fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
796
796
		}
797
		if ( !force && style && style[ name ] )
797
		
798
			ret = style[ name ];
798
		return elems;
799
799
	}
800
		else if ( defaultView.getComputedStyle ) {
800
	
801
801
	// Getting an attribute
802
			// Only "float" is needed here
802
	return length ? fn( elems[0], key ) : null;
803
			if ( name.match( /float/i ) )
803
}
804
				name = "float";
804
805
805
function now() {
806
			name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
806
	return (new Date).getTime();
807
807
}
808
			var computedStyle = defaultView.getComputedStyle( elem, null );
808
(function() {
809
809
810
			if ( computedStyle )
810
	jQuery.support = {};
811
				ret = computedStyle.getPropertyValue( name );
811
812
812
	var root = document.documentElement,
813
			// We should always get a number back from opacity
813
		script = document.createElement("script"),
814
			if ( name == "opacity" && ret == "" )
814
		div = document.createElement("div"),
815
				ret = "1";
815
		id = "script" + now();
816
816
817
		} else if ( elem.currentStyle ) {
817
	div.style.display = "none";
818
			var camelCase = name.replace(/\-(\w)/g, function(all, letter){
818
	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
819
				return letter.toUpperCase();
819
820
			});
820
	var all = div.getElementsByTagName("*"),
821
821
		a = div.getElementsByTagName("a")[0];
822
			ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
822
823
823
	// Can't get basic test support
824
			// From the awesome hack by Dean Edwards
824
	if ( !all || !all.length || !a ) {
825
			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
825
		return;
826
826
	}
827
			// If we're not dealing with a regular pixel number
827
828
			// but a number that has a weird ending, we need to convert it to pixels
828
	jQuery.support = {
829
			if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
829
		// IE strips leading whitespace when .innerHTML is used
830
				// Remember the original values
830
		leadingWhitespace: div.firstChild.nodeType === 3,
831
				var left = style.left, rsLeft = elem.runtimeStyle.left;
831
832
832
		// Make sure that tbody elements aren't automatically inserted
833
				// Put in the new values to get a computed value out
833
		// IE will insert them into empty tables
834
				elem.runtimeStyle.left = elem.currentStyle.left;
834
		tbody: !div.getElementsByTagName("tbody").length,
835
				style.left = ret || 0;
835
836
				ret = style.pixelLeft + "px";
836
		// Make sure that link elements get serialized correctly by innerHTML
837
837
		// This requires a wrapper element in IE
838
				// Revert the changed values
838
		htmlSerialize: !!div.getElementsByTagName("link").length,
839
				style.left = left;
839
840
				elem.runtimeStyle.left = rsLeft;
840
		// Get the style information from getAttribute
841
			}
841
		// (IE uses .cssText insted)
842
		}
842
		style: /red/.test( a.getAttribute("style") ),
843
843
844
		return ret;
844
		// Make sure that URLs aren't manipulated
845
	},
845
		// (IE normalizes it by default)
846
846
		hrefNormalized: a.getAttribute("href") === "/a",
847
	clean: function( elems, context, fragment ) {
847
848
		context = context || document;
848
		// Make sure that element opacity exists
849
849
		// (IE uses filter instead)
850
		// !context.createElement fails in IE with an error but returns typeof 'object'
850
		// Use a regex to work around a WebKit issue. See #5145
851
		if ( typeof context.createElement === "undefined" )
851
		opacity: /^0.55$/.test( a.style.opacity ),
852
			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
852
853
853
		// Verify style float existence
854
		// If a single string is passed in and it's a single tag
854
		// (IE uses styleFloat instead of cssFloat)
855
		// just do a createElement and skip the rest
855
		cssFloat: !!a.style.cssFloat,
856
		if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
856
857
			var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
857
		// Make sure that if no value is specified for a checkbox
858
			if ( match )
858
		// that it defaults to "on".
859
				return [ context.createElement( match[1] ) ];
859
		// (WebKit defaults to "" instead)
860
		}
860
		checkOn: div.getElementsByTagName("input")[0].value === "on",
861
861
862
		var ret = [], scripts = [], div = context.createElement("div");
862
		// Make sure that a selected-by-default option has a working selected property.
863
863
		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
864
		jQuery.each(elems, function(i, elem){
864
		optSelected: document.createElement("select").appendChild( document.createElement("option") ).selected,
865
			if ( typeof elem === "number" )
865
866
				elem += '';
866
		// Will be defined later
867
867
		scriptEval: false,
868
			if ( !elem )
868
		noCloneEvent: true,
869
				return;
869
		boxModel: null
870
870
	};
871
			// Convert html string into DOM nodes
871
872
			if ( typeof elem === "string" ) {
872
	script.type = "text/javascript";
873
				// Fix "XHTML"-style tags in all browsers
873
	try {
874
				elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
874
		script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
875
					return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
875
	} catch(e) {}
876
						all :
876
877
						front + "></" + tag + ">";
877
	root.insertBefore( script, root.firstChild );
878
				});
878
879
879
	// Make sure that the execution of code works by injecting a script
880
				// Trim whitespace, otherwise indexOf won't work as expected
880
	// tag with appendChild/createTextNode
881
				var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();
881
	// (IE doesn't support this, fails, and uses .text instead)
882
882
	if ( window[ id ] ) {
883
				var wrap =
883
		jQuery.support.scriptEval = true;
884
					// option or optgroup
884
		delete window[ id ];
885
					!tags.indexOf("<opt") &&
885
	}
886
					[ 1, "<select multiple='multiple'>", "</select>" ] ||
886
887
887
	root.removeChild( script );
888
					!tags.indexOf("<leg") &&
888
889
					[ 1, "<fieldset>", "</fieldset>" ] ||
889
	if ( div.attachEvent && div.fireEvent ) {
890
890
		div.attachEvent("onclick", function click() {
891
					tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
891
			// Cloning a node shouldn't copy over any
892
					[ 1, "<table>", "</table>" ] ||
892
			// bound event handlers (IE does this)
893
893
			jQuery.support.noCloneEvent = false;
894
					!tags.indexOf("<tr") &&
894
			div.detachEvent("onclick", click);
895
					[ 2, "<table><tbody>", "</tbody></table>" ] ||
895
		});
896
896
		div.cloneNode(true).fireEvent("onclick");
897
				 	// <thead> matched above
897
	}
898
					(!tags.indexOf("<td") || !tags.indexOf("<th")) &&
898
899
					[ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
899
	// Figure out if the W3C box model works as expected
900
900
	// document.body must exist before we can do this
901
					!tags.indexOf("<col") &&
901
	// TODO: This timeout is temporary until I move ready into core.js.
902
					[ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
902
	jQuery(function() {
903
903
		var div = document.createElement("div");
904
					// IE can't serialize <link> and <script> tags normally
904
		div.style.width = div.style.paddingLeft = "1px";
905
					!jQuery.support.htmlSerialize &&
905
906
					[ 1, "div<div>", "</div>" ] ||
906
		document.body.appendChild( div );
907
907
		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
908
					[ 0, "", "" ];
908
		document.body.removeChild( div ).style.display = 'none';
909
909
		div = null;
910
				// Go to html and back, then peel off extra wrappers
910
	});
911
				div.innerHTML = wrap[1] + elem + wrap[2];
911
912
912
	// Technique from Juriy Zaytsev
913
				// Move to the right depth
913
	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
914
				while ( wrap[0]-- )
914
	var eventSupported = function( eventName ) { 
915
					div = div.lastChild;
915
		var el = document.createElement("div"); 
916
916
		eventName = "on" + eventName; 
917
				// Remove IE's autoinserted <tbody> from table fragments
917
918
				if ( !jQuery.support.tbody ) {
918
		var isSupported = (eventName in el); 
919
919
		if ( !isSupported ) { 
920
					// String was a <table>, *may* have spurious <tbody>
920
			el.setAttribute(eventName, "return;"); 
921
					var hasBody = /<tbody/i.test(elem),
921
			isSupported = typeof el[eventName] === "function"; 
922
						tbody = !tags.indexOf("<table") && !hasBody ?
922
		} 
923
							div.firstChild && div.firstChild.childNodes :
923
		el = null; 
924
924
925
						// String was a bare <thead> or <tfoot>
925
		return isSupported; 
926
						wrap[1] == "<table>" && !hasBody ?
926
	};
927
							div.childNodes :
927
	
928
							[];
928
	jQuery.support.submitBubbles = eventSupported("submit");
929
929
	jQuery.support.changeBubbles = eventSupported("change");
930
					for ( var j = tbody.length - 1; j >= 0 ; --j )
930
931
						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
931
	// release memory in IE
932
							tbody[ j ].parentNode.removeChild( tbody[ j ] );
932
	root = script = div = all = a = null;
933
933
})();
934
					}
934
935
935
jQuery.props = {
936
				// IE completely kills leading whitespace when innerHTML is used
936
	"for": "htmlFor",
937
				if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
937
	"class": "className",
938
					div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
938
	readonly: "readOnly",
939
939
	maxlength: "maxLength",
940
				elem = jQuery.makeArray( div.childNodes );
940
	cellspacing: "cellSpacing",
941
			}
941
	rowspan: "rowSpan",
942
942
	colspan: "colSpan",
943
			if ( elem.nodeType )
943
	tabindex: "tabIndex",
944
				ret.push( elem );
944
	usemap: "useMap",
945
			else
945
	frameborder: "frameBorder"
946
				ret = jQuery.merge( ret, elem );
946
};
947
947
var expando = "jQuery" + now(), uuid = 0, windowData = {};
948
		});
948
var emptyObject = {};
949
949
950
		if ( fragment ) {
950
jQuery.extend({
951
			for ( var i = 0; ret[i]; i++ ) {
951
	cache: {},
952
				if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
952
	
953
					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
953
	expando:expando,
954
				} else {
954
955
					if ( ret[i].nodeType === 1 )
955
	// The following elements throw uncatchable exceptions if you
956
						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
956
	// attempt to add expando properties to them.
957
					fragment.appendChild( ret[i] );
957
	noData: {
958
				}
958
		"embed": true,
959
			}
959
		"object": true,
960
960
		"applet": true
961
			return scripts;
961
	},
962
		}
962
963
963
	data: function( elem, name, data ) {
964
		return ret;
964
		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
965
	},
965
			return;
966
966
		}
967
	attr: function( elem, name, value ) {
967
968
		// don't set attributes on text and comment nodes
968
		elem = elem == window ?
969
		if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
969
			windowData :
970
			return undefined;
970
			elem;
971
971
972
		var notxml = !jQuery.isXMLDoc( elem ),
972
		var id = elem[ expando ], cache = jQuery.cache, thisCache;
973
			// Whether we are setting (or getting)
973
974
			set = value !== undefined;
974
		// Handle the case where there's no name immediately
975
975
		if ( !name && !id ) {
976
		// Try to normalize/fix the name
976
			return null;
977
		name = notxml && jQuery.props[ name ] || name;
977
		}
978
978
979
		// Only do all the following if this is a node (faster for style)
979
		// Compute a unique ID for the element
980
		// IE elem.getAttribute passes even for style
980
		if ( !id ) { 
981
		if ( elem.tagName ) {
981
			id = ++uuid;
982
982
		}
983
			// These attributes require special treatment
983
984
			var special = /href|src|style/.test( name );
984
		// Avoid generating a new cache unless none exists and we
985
985
		// want to manipulate it.
986
			// Safari mis-reports the default selected property of a hidden option
986
		if ( typeof name === "object" ) {
987
			// Accessing the parent's selectedIndex property fixes it
987
			elem[ expando ] = id;
988
			if ( name == "selected" && elem.parentNode )
988
			thisCache = cache[ id ] = jQuery.extend(true, {}, name);
989
				elem.parentNode.selectedIndex;
989
		} else if ( cache[ id ] ) {
990
990
			thisCache = cache[ id ];
991
			// If applicable, access the attribute via the DOM 0 way
991
		} else if ( typeof data === "undefined" ) {
992
			if ( name in elem && notxml && !special ) {
992
			thisCache = emptyObject;
993
				if ( set ){
993
		} else {
994
					// We can't allow the type property to be changed (since it causes problems in IE)
994
			thisCache = cache[ id ] = {};
995
					if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
995
		}
996
						throw "type property can't be changed";
996
997
997
		// Prevent overriding the named cache with undefined values
998
					elem[ name ] = value;
998
		if ( data !== undefined ) {
999
				}
999
			elem[ expando ] = id;
1000
1000
			thisCache[ name ] = data;
1001
				// browsers index elements by id/name on forms, give priority to attributes.
1001
		}
1002
				if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
1002
1003
					return elem.getAttributeNode( name ).nodeValue;
1003
		return typeof name === "string" ? thisCache[ name ] : thisCache;
1004
1004
	},
1005
				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1005
1006
				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1006
	removeData: function( elem, name ) {
1007
				if ( name == "tabIndex" ) {
1007
		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
1008
					var attributeNode = elem.getAttributeNode( "tabIndex" );
1008
			return;
1009
					return attributeNode && attributeNode.specified
1009
		}
1010
						? attributeNode.value
1010
1011
						: elem.nodeName.match(/(button|input|object|select|textarea)/i)
1011
		elem = elem == window ?
1012
							? 0
1012
			windowData :
1013
							: elem.nodeName.match(/^(a|area)$/i) && elem.href
1013
			elem;
1014
								? 0
1014
1015
								: undefined;
1015
		var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ];
1016
				}
1016
1017
1017
		// If we want to remove a specific section of the element's data
1018
				return elem[ name ];
1018
		if ( name ) {
1019
			}
1019
			if ( thisCache ) {
1020
1020
				// Remove the section of cache data
1021
			if ( !jQuery.support.style && notxml &&  name == "style" )
1021
				delete thisCache[ name ];
1022
				return jQuery.attr( elem.style, "cssText", value );
1022
1023
1023
				// If we've removed all the data, remove the element's cache
1024
			if ( set )
1024
				if ( jQuery.isEmptyObject(thisCache) ) {
1025
				// convert the value to a string (all browsers do this but IE) see #1070
1025
					jQuery.removeData( elem );
1026
				elem.setAttribute( name, "" + value );
1026
				}
1027
1027
			}
1028
			var attr = !jQuery.support.hrefNormalized && notxml && special
1028
1029
					// Some attributes require a special call on IE
1029
		// Otherwise, we want to remove all of the element's data
1030
					? elem.getAttribute( name, 2 )
1030
		} else {
1031
					: elem.getAttribute( name );
1031
			// Clean up the element expando
1032
1032
			try {
1033
			// Non-existent attributes return null, we normalize to undefined
1033
				delete elem[ expando ];
1034
			return attr === null ? undefined : attr;
1034
			} catch( e ) {
1035
		}
1035
				// IE has trouble directly removing the expando
1036
1036
				// but it's ok with using removeAttribute
1037
		// elem is actually elem.style ... set the style
1037
				if ( elem.removeAttribute ) {
1038
1038
					elem.removeAttribute( expando );
1039
		// IE uses filters for opacity
1039
				}
1040
		if ( !jQuery.support.opacity && name == "opacity" ) {
1040
			}
1041
			if ( set ) {
1041
1042
				// IE has trouble with opacity if it does not have layout
1042
			// Completely remove the data cache
1043
				// Force it by setting the zoom level
1043
			delete cache[ id ];
1044
				elem.zoom = 1;
1044
		}
1045
1045
	}
1046
				// Set the alpha filter to set the opacity
1046
});
1047
				elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
1047
1048
					(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1048
jQuery.fn.extend({
1049
			}
1049
	data: function( key, value ) {
1050
1050
		if ( typeof key === "undefined" && this.length ) {
1051
			return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1051
			return jQuery.data( this[0] );
1052
				(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1052
1053
				"";
1053
		} else if ( typeof key === "object" ) {
1054
		}
1054
			return this.each(function() {
1055
1055
				jQuery.data( this, key );
1056
		name = name.replace(/-([a-z])/ig, function(all, letter){
1056
			});
1057
			return letter.toUpperCase();
1057
		}
1058
		});
1058
1059
1059
		var parts = key.split(".");
1060
		if ( set )
1060
		parts[1] = parts[1] ? "." + parts[1] : "";
1061
			elem[ name ] = value;
1061
1062
1062
		if ( value === undefined ) {
1063
		return elem[ name ];
1063
			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1064
	},
1064
1065
1065
			if ( data === undefined && this.length ) {
1066
	trim: function( text ) {
1066
				data = jQuery.data( this[0], key );
1067
		return (text || "").replace( /^\s+|\s+$/g, "" );
1067
			}
1068
	},
1068
			return data === undefined && parts[1] ?
1069
1069
				this.data( parts[0] ) :
1070
	makeArray: function( array ) {
1070
				data;
1071
		var ret = [];
1071
		} else {
1072
1072
			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function() {
1073
		if( array != null ){
1073
				jQuery.data( this, key, value );
1074
			var i = array.length;
1074
			});
1075
			// The window, strings (and functions) also have 'length'
1075
		}
1076
			if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
1076
	},
1077
				ret[0] = array;
1077
1078
			else
1078
	removeData: function( key ) {
1079
				while( i )
1079
		return this.each(function() {
1080
					ret[--i] = array[i];
1080
			jQuery.removeData( this, key );
1081
		}
1081
		});
1082
1082
	}
1083
		return ret;
1083
});
1084
	},
1084
jQuery.extend({
1085
1085
	queue: function( elem, type, data ) {
1086
	inArray: function( elem, array ) {
1086
		if ( !elem ) {
1087
		for ( var i = 0, length = array.length; i < length; i++ )
1087
			return;
1088
		// Use === because on IE, window == document
1088
		}
1089
			if ( array[ i ] === elem )
1089
1090
				return i;
1090
		type = (type || "fx") + "queue";
1091
1091
		var q = jQuery.data( elem, type );
1092
		return -1;
1092
1093
	},
1093
		// Speed up dequeue by getting out quickly if this is just a lookup
1094
1094
		if ( !data ) {
1095
	merge: function( first, second ) {
1095
			return q || [];
1096
		// We have to loop this way because IE & Opera overwrite the length
1096
		}
1097
		// expando of getElementsByTagName
1097
1098
		var i = 0, elem, pos = first.length;
1098
		if ( !q || jQuery.isArray(data) ) {
1099
		// Also, we need to make sure that the correct elements are being returned
1099
			q = jQuery.data( elem, type, jQuery.makeArray(data) );
1100
		// (IE returns comment nodes in a '*' query)
1100
1101
		if ( !jQuery.support.getAll ) {
1101
		} else {
1102
			while ( (elem = second[ i++ ]) != null )
1102
			q.push( data );
1103
				if ( elem.nodeType != 8 )
1103
		}
1104
					first[ pos++ ] = elem;
1104
1105
1105
		return q;
1106
		} else
1106
	},
1107
			while ( (elem = second[ i++ ]) != null )
1107
1108
				first[ pos++ ] = elem;
1108
	dequeue: function( elem, type ) {
1109
1109
		type = type || "fx";
1110
		return first;
1110
1111
	},
1111
		var queue = jQuery.queue( elem, type ), fn = queue.shift();
1112
1112
1113
	unique: function( array ) {
1113
		// If the fx queue is dequeued, always remove the progress sentinel
1114
		var ret = [], done = {};
1114
		if ( fn === "inprogress" ) {
1115
1115
			fn = queue.shift();
1116
		try {
1116
		}
1117
1117
1118
			for ( var i = 0, length = array.length; i < length; i++ ) {
1118
		if ( fn ) {
1119
				var id = jQuery.data( array[ i ] );
1119
			// Add a progress sentinel to prevent the fx queue from being
1120
1120
			// automatically dequeued
1121
				if ( !done[ id ] ) {
1121
			if ( type === "fx" ) {
1122
					done[ id ] = true;
1122
				queue.unshift("inprogress");
1123
					ret.push( array[ i ] );
1123
			}
1124
				}
1124
1125
			}
1125
			fn.call(elem, function() {
1126
1126
				jQuery.dequeue(elem, type);
1127
		} catch( e ) {
1127
			});
1128
			ret = array;
1128
		}
1129
		}
1129
	}
1130
1130
});
1131
		return ret;
1131
1132
	},
1132
jQuery.fn.extend({
1133
1133
	queue: function( type, data ) {
1134
	grep: function( elems, callback, inv ) {
1134
		if ( typeof type !== "string" ) {
1135
		var ret = [];
1135
			data = type;
1136
1136
			type = "fx";
1137
		// Go through the array, only saving the items
1137
		}
1138
		// that pass the validator function
1138
1139
		for ( var i = 0, length = elems.length; i < length; i++ )
1139
		if ( data === undefined ) {
1140
			if ( !inv != !callback( elems[ i ], i ) )
1140
			return jQuery.queue( this[0], type );
1141
				ret.push( elems[ i ] );
1141
		}
1142
1142
		return this.each(function( i, elem ) {
1143
		return ret;
1143
			var queue = jQuery.queue( this, type, data );
1144
	},
1144
1145
1145
			if ( type === "fx" && queue[0] !== "inprogress" ) {
1146
	map: function( elems, callback ) {
1146
				jQuery.dequeue( this, type );
1147
		var ret = [];
1147
			}
1148
1148
		});
1149
		// Go through the array, translating each of the items to their
1149
	},
1150
		// new value (or values).
1150
	dequeue: function( type ) {
1151
		for ( var i = 0, length = elems.length; i < length; i++ ) {
1151
		return this.each(function() {
1152
			var value = callback( elems[ i ], i );
1152
			jQuery.dequeue( this, type );
1153
1153
		});
1154
			if ( value != null )
1154
	},
1155
				ret[ ret.length ] = value;
1155
1156
		}
1156
	// Based off of the plugin by Clint Helfers, with permission.
1157
1157
	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1158
		return ret.concat.apply( [], ret );
1158
	delay: function( time, type ) {
1159
	}
1159
		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1160
});
1160
		type = type || "fx";
1161
1161
1162
// Use of jQuery.browser is deprecated.
1162
		return this.queue( type, function() {
1163
// It's included for backwards compatibility and plugins,
1163
			var elem = this;
1164
// although they should work to migrate away.
1164
			setTimeout(function() {
1165
1165
				jQuery.dequeue( elem, type );
1166
var userAgent = navigator.userAgent.toLowerCase();
1166
			}, time );
1167
1167
		});
1168
// Figure out what browser is being used
1168
	},
1169
jQuery.browser = {
1169
1170
	version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
1170
	clearQueue: function( type ) {
1171
	safari: /webkit/.test( userAgent ),
1171
		return this.queue( type || "fx", [] );
1172
	opera: /opera/.test( userAgent ),
1172
	}
1173
	msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1173
});
1174
	mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
1174
var rclass = /[\n\t]/g,
1175
};
1175
	rspace = /\s+/,
1176
1176
	rreturn = /\r/g,
1177
jQuery.each({
1177
	rspecialurl = /href|src|style/,
1178
	parent: function(elem){return elem.parentNode;},
1178
	rtype = /(button|input)/i,
1179
	parents: function(elem){return jQuery.dir(elem,"parentNode");},
1179
	rfocusable = /(button|input|object|select|textarea)/i,
1180
	next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1180
	rclickable = /^(a|area)$/i,
1181
	prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1181
	rradiocheck = /radio|checkbox/;
1182
	nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1182
1183
	prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1183
jQuery.fn.extend({
1184
	siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1184
	attr: function( name, value ) {
1185
	children: function(elem){return jQuery.sibling(elem.firstChild);},
1185
		return access( this, name, value, true, jQuery.attr );
1186
	contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1186
	},
1187
}, function(name, fn){
1187
1188
	jQuery.fn[ name ] = function( selector ) {
1188
	removeAttr: function( name, fn ) {
1189
		var ret = jQuery.map( this, fn );
1189
		return this.each(function(){
1190
1190
			jQuery.attr( this, name, "" );
1191
		if ( selector && typeof selector == "string" )
1191
			if ( this.nodeType === 1 ) {
1192
			ret = jQuery.multiFilter( selector, ret );
1192
				this.removeAttribute( name );
1193
1193
			}
1194
		return this.pushStack( jQuery.unique( ret ), name, selector );
1194
		});
1195
	};
1195
	},
1196
});
1196
1197
1197
	addClass: function( value ) {
1198
jQuery.each({
1198
		if ( jQuery.isFunction(value) ) {
1199
	appendTo: "append",
1199
			return this.each(function(i) {
1200
	prependTo: "prepend",
1200
				var self = jQuery(this);
1201
	insertBefore: "before",
1201
				self.addClass( value.call(this, i, self.attr("class")) );
1202
	insertAfter: "after",
1202
			});
1203
	replaceAll: "replaceWith"
1203
		}
1204
}, function(name, original){
1204
1205
	jQuery.fn[ name ] = function( selector ) {
1205
		if ( value && typeof value === "string" ) {
1206
		var ret = [], insert = jQuery( selector );
1206
			var classNames = (value || "").split( rspace );
1207
1207
1208
		for ( var i = 0, l = insert.length; i < l; i++ ) {
1208
			for ( var i = 0, l = this.length; i < l; i++ ) {
1209
			var elems = (i > 0 ? this.clone(true) : this).get();
1209
				var elem = this[i];
1210
			jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
1210
1211
			ret = ret.concat( elems );
1211
				if ( elem.nodeType === 1 ) {
1212
		}
1212
					if ( !elem.className ) {
1213
1213
						elem.className = value;
1214
		return this.pushStack( ret, name, selector );
1214
1215
	};
1215
					} else {
1216
});
1216
						var className = " " + elem.className + " ";
1217
1217
						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1218
jQuery.each({
1218
							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1219
	removeAttr: function( name ) {
1219
								elem.className += " " + classNames[c];
1220
		jQuery.attr( this, name, "" );
1220
							}
1221
		if (this.nodeType == 1)
1221
						}
1222
			this.removeAttribute( name );
1222
					}
1223
	},
1223
				}
1224
1224
			}
1225
	addClass: function( classNames ) {
1225
		}
1226
		jQuery.className.add( this, classNames );
1226
1227
	},
1227
		return this;
1228
1228
	},
1229
	removeClass: function( classNames ) {
1229
1230
		jQuery.className.remove( this, classNames );
1230
	removeClass: function( value ) {
1231
	},
1231
		if ( jQuery.isFunction(value) ) {
1232
1232
			return this.each(function(i) {
1233
	toggleClass: function( classNames, state ) {
1233
				var self = jQuery(this);
1234
		if( typeof state !== "boolean" )
1234
				self.removeClass( value.call(this, i, self.attr("class")) );
1235
			state = !jQuery.className.has( this, classNames );
1235
			});
1236
		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1236
		}
1237
	},
1237
1238
1238
		if ( (value && typeof value === "string") || value === undefined ) {
1239
	remove: function( selector ) {
1239
			var classNames = (value || "").split(rspace);
1240
		if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
1240
1241
			// Prevent memory leaks
1241
			for ( var i = 0, l = this.length; i < l; i++ ) {
1242
			jQuery( "*", this ).add([this]).each(function(){
1242
				var elem = this[i];
1243
				jQuery.event.remove(this);
1243
1244
				jQuery.removeData(this);
1244
				if ( elem.nodeType === 1 && elem.className ) {
1245
			});
1245
					if ( value ) {
1246
			if (this.parentNode)
1246
						var className = (" " + elem.className + " ").replace(rclass, " ");
1247
				this.parentNode.removeChild( this );
1247
						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1248
		}
1248
							className = className.replace(" " + classNames[c] + " ", " ");
1249
	},
1249
						}
1250
1250
						elem.className = className.substring(1, className.length - 1);
1251
	empty: function() {
1251
1252
		// Remove element nodes and prevent memory leaks
1252
					} else {
1253
		jQuery(this).children().remove();
1253
						elem.className = "";
1254
1254
					}
1255
		// Remove any remaining nodes
1255
				}
1256
		while ( this.firstChild )
1256
			}
1257
			this.removeChild( this.firstChild );
1257
		}
1258
	}
1258
1259
}, function(name, fn){
1259
		return this;
1260
	jQuery.fn[ name ] = function(){
1260
	},
1261
		return this.each( fn, arguments );
1261
1262
	};
1262
	toggleClass: function( value, stateVal ) {
1263
});
1263
		var type = typeof value, isBool = typeof stateVal === "boolean";
1264
1264
1265
// Helper function used by the dimensions and offset modules
1265
		if ( jQuery.isFunction( value ) ) {
1266
function num(elem, prop) {
1266
			return this.each(function(i) {
1267
	return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
1267
				var self = jQuery(this);
1268
}
1268
				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1269
var expando = "jQuery" + now(), uuid = 0, windowData = {};
1269
			});
1270
1270
		}
1271
jQuery.extend({
1271
1272
	cache: {},
1272
		return this.each(function() {
1273
1273
			if ( type === "string" ) {
1274
	data: function( elem, name, data ) {
1274
				// toggle individual class names
1275
		elem = elem == window ?
1275
				var className, i = 0, self = jQuery(this),
1276
			windowData :
1276
					state = stateVal,
1277
			elem;
1277
					classNames = value.split( rspace );
1278
1278
1279
		var id = elem[ expando ];
1279
				while ( (className = classNames[ i++ ]) ) {
1280
1280
					// check each className given, space seperated list
1281
		// Compute a unique ID for the element
1281
					state = isBool ? state : !self.hasClass( className );
1282
		if ( !id )
1282
					self[ state ? "addClass" : "removeClass" ]( className );
1283
			id = elem[ expando ] = ++uuid;
1283
				}
1284
1284
1285
		// Only generate the data cache if we're
1285
			} else if ( type === "undefined" || type === "boolean" ) {
1286
		// trying to access or manipulate it
1286
				if ( this.className ) {
1287
		if ( name && !jQuery.cache[ id ] )
1287
					// store className if set
1288
			jQuery.cache[ id ] = {};
1288
					jQuery.data( this, "__className__", this.className );
1289
1289
				}
1290
		// Prevent overriding the named cache with undefined values
1290
1291
		if ( data !== undefined )
1291
				// toggle whole className
1292
			jQuery.cache[ id ][ name ] = data;
1292
				this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1293
1293
			}
1294
		// Return the named cache data, or the ID for the element
1294
		});
1295
		return name ?
1295
	},
1296
			jQuery.cache[ id ][ name ] :
1296
1297
			id;
1297
	hasClass: function( selector ) {
1298
	},
1298
		var className = " " + selector + " ";
1299
1299
		for ( var i = 0, l = this.length; i < l; i++ ) {
1300
	removeData: function( elem, name ) {
1300
			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1301
		elem = elem == window ?
1301
				return true;
1302
			windowData :
1302
			}
1303
			elem;
1303
		}
1304
1304
1305
		var id = elem[ expando ];
1305
		return false;
1306
1306
	},
1307
		// If we want to remove a specific section of the element's data
1307
1308
		if ( name ) {
1308
	val: function( value ) {
1309
			if ( jQuery.cache[ id ] ) {
1309
		if ( value === undefined ) {
1310
				// Remove the section of cache data
1310
			var elem = this[0];
1311
				delete jQuery.cache[ id ][ name ];
1311
1312
1312
			if ( elem ) {
1313
				// If we've removed all the data, remove the element's cache
1313
				if ( jQuery.nodeName( elem, "option" ) ) {
1314
				name = "";
1314
					return (elem.attributes.value || {}).specified ? elem.value : elem.text;
1315
1315
				}
1316
				for ( name in jQuery.cache[ id ] )
1316
1317
					break;
1317
				// We need to handle select boxes special
1318
1318
				if ( jQuery.nodeName( elem, "select" ) ) {
1319
				if ( !name )
1319
					var index = elem.selectedIndex,
1320
					jQuery.removeData( elem );
1320
						values = [],
1321
			}
1321
						options = elem.options,
1322
1322
						one = elem.type === "select-one";
1323
		// Otherwise, we want to remove all of the element's data
1323
1324
		} else {
1324
					// Nothing was selected
1325
			// Clean up the element expando
1325
					if ( index < 0 ) {
1326
			try {
1326
						return null;
1327
				delete elem[ expando ];
1327
					}
1328
			} catch(e){
1328
1329
				// IE has trouble directly removing the expando
1329
					// Loop through all the selected options
1330
				// but it's ok with using removeAttribute
1330
					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1331
				if ( elem.removeAttribute )
1331
						var option = options[ i ];
1332
					elem.removeAttribute( expando );
1332
1333
			}
1333
						if ( option.selected ) {
1334
1334
							// Get the specifc value for the option
1335
			// Completely remove the data cache
1335
							value = jQuery(option).val();
1336
			delete jQuery.cache[ id ];
1336
1337
		}
1337
							// We don't need an array for one selects
1338
	},
1338
							if ( one ) {
1339
	queue: function( elem, type, data ) {
1339
								return value;
1340
		if ( elem ){
1340
							}
1341
1341
1342
			type = (type || "fx") + "queue";
1342
							// Multi-Selects return an array
1343
1343
							values.push( value );
1344
			var q = jQuery.data( elem, type );
1344
						}
1345
1345
					}
1346
			if ( !q || jQuery.isArray(data) )
1346
1347
				q = jQuery.data( elem, type, jQuery.makeArray(data) );
1347
					return values;
1348
			else if( data )
1348
				}
1349
				q.push( data );
1349
1350
1350
				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1351
		}
1351
				if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1352
		return q;
1352
					return elem.getAttribute("value") === null ? "on" : elem.value;
1353
	},
1353
				}
1354
1354
				
1355
	dequeue: function( elem, type ){
1355
1356
		var queue = jQuery.queue( elem, type ),
1356
				// Everything else, we just grab the value
1357
			fn = queue.shift();
1357
				return (elem.value || "").replace(rreturn, "");
1358
1358
1359
		if( !type || type === "fx" )
1359
			}
1360
			fn = queue[0];
1360
1361
1361
			return undefined;
1362
		if( fn !== undefined )
1362
		}
1363
			fn.call(elem);
1363
1364
	}
1364
		var isFunction = jQuery.isFunction(value);
1365
});
1365
1366
1366
		return this.each(function(i) {
1367
jQuery.fn.extend({
1367
			var self = jQuery(this), val = value;
1368
	data: function( key, value ){
1368
1369
		var parts = key.split(".");
1369
			if ( this.nodeType !== 1 ) {
1370
		parts[1] = parts[1] ? "." + parts[1] : "";
1370
				return;
1371
1371
			}
1372
		if ( value === undefined ) {
1372
1373
			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1373
			if ( isFunction ) {
1374
1374
				val = value.call(this, i, self.val());
1375
			if ( data === undefined && this.length )
1375
			}
1376
				data = jQuery.data( this[0], key );
1376
1377
1377
			// Typecast each time if the value is a Function and the appended
1378
			return data === undefined && parts[1] ?
1378
			// value is therefore different each time.
1379
				this.data( parts[0] ) :
1379
			if ( typeof val === "number" ) {
1380
				data;
1380
				val += "";
1381
		} else
1381
			}
1382
			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
1382
1383
				jQuery.data( this, key, value );
1383
			if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1384
			});
1384
				this.checked = jQuery.inArray( self.val(), val ) >= 0;
1385
	},
1385
1386
1386
			} else if ( jQuery.nodeName( this, "select" ) ) {
1387
	removeData: function( key ){
1387
				var values = jQuery.makeArray(val);
1388
		return this.each(function(){
1388
1389
			jQuery.removeData( this, key );
1389
				jQuery( "option", this ).each(function() {
1390
		});
1390
					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1391
	},
1391
				});
1392
	queue: function(type, data){
1392
1393
		if ( typeof type !== "string" ) {
1393
				if ( !values.length ) {
1394
			data = type;
1394
					this.selectedIndex = -1;
1395
			type = "fx";
1395
				}
1396
		}
1396
1397
1397
			} else {
1398
		if ( data === undefined )
1398
				this.value = val;
1399
			return jQuery.queue( this[0], type );
1399
			}
1400
1400
		});
1401
		return this.each(function(){
1401
	}
1402
			var queue = jQuery.queue( this, type, data );
1402
});
1403
1403
1404
			 if( type == "fx" && queue.length == 1 )
1404
jQuery.extend({
1405
				queue[0].call(this);
1405
	attrFn: {
1406
		});
1406
		val: true,
1407
	},
1407
		css: true,
1408
	dequeue: function(type){
1408
		html: true,
1409
		return this.each(function(){
1409
		text: true,
1410
			jQuery.dequeue( this, type );
1410
		data: true,
1411
		});
1411
		width: true,
1412
	}
1412
		height: true,
1413
});/*!
1413
		offset: true
1414
 * Sizzle CSS Selector Engine - v0.9.3
1414
	},
1415
 *  Copyright 2009, The Dojo Foundation
1415
		
1416
 *  Released under the MIT, BSD, and GPL Licenses.
1416
	attr: function( elem, name, value, pass ) {
1417
 *  More information: http://sizzlejs.com/
1417
		// don't set attributes on text and comment nodes
1418
 */
1418
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1419
(function(){
1419
			return undefined;
1420
1420
		}
1421
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
1421
1422
	done = 0,
1422
		if ( pass && name in jQuery.attrFn ) {
1423
	toString = Object.prototype.toString;
1423
			return jQuery(elem)[name](value);
1424
1424
		}
1425
var Sizzle = function(selector, context, results, seed) {
1425
1426
	results = results || [];
1426
		var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1427
	context = context || document;
1427
			// Whether we are setting (or getting)
1428
1428
			set = value !== undefined;
1429
	if ( context.nodeType !== 1 && context.nodeType !== 9 )
1429
1430
		return [];
1430
		// Try to normalize/fix the name
1431
1431
		name = notxml && jQuery.props[ name ] || name;
1432
	if ( !selector || typeof selector !== "string" ) {
1432
1433
		return results;
1433
		// Only do all the following if this is a node (faster for style)
1434
	}
1434
		if ( elem.nodeType === 1 ) {
1435
1435
			// These attributes require special treatment
1436
	var parts = [], m, set, checkSet, check, mode, extra, prune = true;
1436
			var special = rspecialurl.test( name );
1437
1437
1438
	// Reset the position of the chunker regexp (start from head)
1438
			// Safari mis-reports the default selected property of an option
1439
	chunker.lastIndex = 0;
1439
			// Accessing the parent's selectedIndex property fixes it
1440
1440
			if ( name === "selected" && !jQuery.support.optSelected ) {
1441
	while ( (m = chunker.exec(selector)) !== null ) {
1441
				var parent = elem.parentNode;
1442
		parts.push( m[1] );
1442
				if ( parent ) {
1443
1443
					parent.selectedIndex;
1444
		if ( m[2] ) {
1444
	
1445
			extra = RegExp.rightContext;
1445
					// Make sure that it also works with optgroups, see #5701
1446
			break;
1446
					if ( parent.parentNode ) {
1447
		}
1447
						parent.parentNode.selectedIndex;
1448
	}
1448
					}
1449
1449
				}
1450
	if ( parts.length > 1 && origPOS.exec( selector ) ) {
1450
			}
1451
		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
1451
1452
			set = posProcess( parts[0] + parts[1], context );
1452
			// If applicable, access the attribute via the DOM 0 way
1453
		} else {
1453
			if ( name in elem && notxml && !special ) {
1454
			set = Expr.relative[ parts[0] ] ?
1454
				if ( set ) {
1455
				[ context ] :
1455
					// We can't allow the type property to be changed (since it causes problems in IE)
1456
				Sizzle( parts.shift(), context );
1456
					if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
1457
1457
						throw "type property can't be changed";
1458
			while ( parts.length ) {
1458
					}
1459
				selector = parts.shift();
1459
1460
1460
					elem[ name ] = value;
1461
				if ( Expr.relative[ selector ] )
1461
				}
1462
					selector += parts.shift();
1462
1463
1463
				// browsers index elements by id/name on forms, give priority to attributes.
1464
				set = posProcess( selector, set );
1464
				if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
1465
			}
1465
					return elem.getAttributeNode( name ).nodeValue;
1466
		}
1466
				}
1467
	} else {
1467
1468
		var ret = seed ?
1468
				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1469
			{ expr: parts.pop(), set: makeArray(seed) } :
1469
				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1470
			Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
1470
				if ( name === "tabIndex" ) {
1471
		set = Sizzle.filter( ret.expr, ret.set );
1471
					var attributeNode = elem.getAttributeNode( "tabIndex" );
1472
1472
1473
		if ( parts.length > 0 ) {
1473
					return attributeNode && attributeNode.specified ?
1474
			checkSet = makeArray(set);
1474
						attributeNode.value :
1475
		} else {
1475
						rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
1476
			prune = false;
1476
							0 :
1477
		}
1477
							undefined;
1478
1478
				}
1479
		while ( parts.length ) {
1479
1480
			var cur = parts.pop(), pop = cur;
1480
				return elem[ name ];
1481
1481
			}
1482
			if ( !Expr.relative[ cur ] ) {
1482
1483
				cur = "";
1483
			if ( !jQuery.support.style && notxml && name === "style" ) {
1484
			} else {
1484
				if ( set ) {
1485
				pop = parts.pop();
1485
					elem.style.cssText = "" + value;
1486
			}
1486
				}
1487
1487
1488
			if ( pop == null ) {
1488
				return elem.style.cssText;
1489
				pop = context;
1489
			}
1490
			}
1490
1491
1491
			if ( set ) {
1492
			Expr.relative[ cur ]( checkSet, pop, isXML(context) );
1492
				// convert the value to a string (all browsers do this but IE) see #1070
1493
		}
1493
				elem.setAttribute( name, "" + value );
1494
	}
1494
			}
1495
1495
1496
	if ( !checkSet ) {
1496
			var attr = !jQuery.support.hrefNormalized && notxml && special ?
1497
		checkSet = set;
1497
					// Some attributes require a special call on IE
1498
	}
1498
					elem.getAttribute( name, 2 ) :
1499
1499
					elem.getAttribute( name );
1500
	if ( !checkSet ) {
1500
1501
		throw "Syntax error, unrecognized expression: " + (cur || selector);
1501
			// Non-existent attributes return null, we normalize to undefined
1502
	}
1502
			return attr === null ? undefined : attr;
1503
1503
		}
1504
	if ( toString.call(checkSet) === "[object Array]" ) {
1504
1505
		if ( !prune ) {
1505
		// elem is actually elem.style ... set the style
1506
			results.push.apply( results, checkSet );
1506
		// Using attr for specific style information is now deprecated. Use style insead.
1507
		} else if ( context.nodeType === 1 ) {
1507
		return jQuery.style( elem, name, value );
1508
			for ( var i = 0; checkSet[i] != null; i++ ) {
1508
	}
1509
				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
1509
});
1510
					results.push( set[i] );
1510
var fcleanup = function( nm ) {
1511
				}
1511
	return nm.replace(/[^\w\s\.\|`]/g, function( ch ) {
1512
			}
1512
		return "\\" + ch;
1513
		} else {
1513
	});
1514
			for ( var i = 0; checkSet[i] != null; i++ ) {
1514
};
1515
				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
1515
1516
					results.push( set[i] );
1516
/*
1517
				}
1517
 * A number of helper functions used for managing events.
1518
			}
1518
 * Many of the ideas behind this code originated from
1519
		}
1519
 * Dean Edwards' addEvent library.
1520
	} else {
1520
 */
1521
		makeArray( checkSet, results );
1521
jQuery.event = {
1522
	}
1522
1523
1523
	// Bind an event to an element
1524
	if ( extra ) {
1524
	// Original by Dean Edwards
1525
		Sizzle( extra, context, results, seed );
1525
	add: function( elem, types, handler, data ) {
1526
1526
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1527
		if ( sortOrder ) {
1527
			return;
1528
			hasDuplicate = false;
1528
		}
1529
			results.sort(sortOrder);
1529
1530
1530
		// For whatever reason, IE has trouble passing the window object
1531
			if ( hasDuplicate ) {
1531
		// around, causing it to be cloned in the process
1532
				for ( var i = 1; i < results.length; i++ ) {
1532
		if ( elem.setInterval && ( elem !== window && !elem.frameElement ) ) {
1533
					if ( results[i] === results[i-1] ) {
1533
			elem = window;
1534
						results.splice(i--, 1);
1534
		}
1535
					}
1535
1536
				}
1536
		// Make sure that the function being executed has a unique ID
1537
			}
1537
		if ( !handler.guid ) {
1538
		}
1538
			handler.guid = jQuery.guid++;
1539
	}
1539
		}
1540
1540
1541
	return results;
1541
		// if data is passed, bind to handler
1542
};
1542
		if ( data !== undefined ) {
1543
1543
			// Create temporary function pointer to original handler
1544
Sizzle.matches = function(expr, set){
1544
			var fn = handler;
1545
	return Sizzle(expr, null, null, set);
1545
1546
};
1546
			// Create unique handler function, wrapped around original handler
1547
1547
			handler = jQuery.proxy( fn );
1548
Sizzle.find = function(expr, context, isXML){
1548
1549
	var set, match;
1549
			// Store data in unique handler
1550
1550
			handler.data = data;
1551
	if ( !expr ) {
1551
		}
1552
		return [];
1552
1553
	}
1553
		// Init the element's event structure
1554
1554
		var events = jQuery.data( elem, "events" ) || jQuery.data( elem, "events", {} ),
1555
	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
1555
			handle = jQuery.data( elem, "handle" ), eventHandle;
1556
		var type = Expr.order[i], match;
1556
1557
1557
		if ( !handle ) {
1558
		if ( (match = Expr.match[ type ].exec( expr )) ) {
1558
			eventHandle = function() {
1559
			var left = RegExp.leftContext;
1559
				// Handle the second event of a trigger and when
1560
1560
				// an event is called after a page has unloaded
1561
			if ( left.substr( left.length - 1 ) !== "\\" ) {
1561
				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
1562
				match[1] = (match[1] || "").replace(/\\/g, "");
1562
					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
1563
				set = Expr.find[ type ]( match, context, isXML );
1563
					undefined;
1564
				if ( set != null ) {
1564
			};
1565
					expr = expr.replace( Expr.match[ type ], "" );
1565
1566
					break;
1566
			handle = jQuery.data( elem, "handle", eventHandle );
1567
				}
1567
		}
1568
			}
1568
1569
		}
1569
		// If no handle is found then we must be trying to bind to one of the
1570
	}
1570
		// banned noData elements
1571
1571
		if ( !handle ) {
1572
	if ( !set ) {
1572
			return;
1573
		set = context.getElementsByTagName("*");
1573
		}
1574
	}
1574
1575
1575
		// Add elem as a property of the handle function
1576
	return {set: set, expr: expr};
1576
		// This is to prevent a memory leak with non-native
1577
};
1577
		// event in IE.
1578
1578
		handle.elem = elem;
1579
Sizzle.filter = function(expr, set, inplace, not){
1579
1580
	var old = expr, result = [], curLoop = set, match, anyFound,
1580
		// Handle multiple events separated by a space
1581
		isXMLFilter = set && set[0] && isXML(set[0]);
1581
		// jQuery(...).bind("mouseover mouseout", fn);
1582
1582
		types = types.split( /\s+/ );
1583
	while ( expr && set.length ) {
1583
		var type, i=0;
1584
		for ( var type in Expr.filter ) {
1584
		while ( (type = types[ i++ ]) ) {
1585
			if ( (match = Expr.match[ type ].exec( expr )) != null ) {
1585
			// Namespaced event handlers
1586
				var filter = Expr.filter[ type ], found, item;
1586
			var namespaces = type.split(".");
1587
				anyFound = false;
1587
			type = namespaces.shift();
1588
1588
			handler.type = namespaces.slice(0).sort().join(".");
1589
				if ( curLoop == result ) {
1589
1590
					result = [];
1590
			// Get the current list of functions bound to this event
1591
				}
1591
			var handlers = events[ type ],
1592
1592
				special = this.special[ type ] || {};
1593
				if ( Expr.preFilter[ type ] ) {
1593
1594
					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
1594
			
1595
1595
1596
					if ( !match ) {
1596
			// Init the event handler queue
1597
						anyFound = found = true;
1597
			if ( !handlers ) {
1598
					} else if ( match === true ) {
1598
				handlers = events[ type ] = {};
1599
						continue;
1599
1600
					}
1600
				// Check for a special event handler
1601
				}
1601
				// Only use addEventListener/attachEvent if the special
1602
1602
				// events handler returns false
1603
				if ( match ) {
1603
				if ( !special.setup || special.setup.call( elem, data, namespaces, handler) === false ) {
1604
					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
1604
					// Bind the global event handler to the element
1605
						if ( item ) {
1605
					if ( elem.addEventListener ) {
1606
							found = filter( item, match, i, curLoop );
1606
						elem.addEventListener( type, handle, false );
1607
							var pass = not ^ !!found;
1607
					} else if ( elem.attachEvent ) {
1608
1608
						elem.attachEvent( "on" + type, handle );
1609
							if ( inplace && found != null ) {
1609
					}
1610
								if ( pass ) {
1610
				}
1611
									anyFound = true;
1611
			}
1612
								} else {
1612
			
1613
									curLoop[i] = false;
1613
			if ( special.add ) { 
1614
								}
1614
				var modifiedHandler = special.add.call( elem, handler, data, namespaces, handlers ); 
1615
							} else if ( pass ) {
1615
				if ( modifiedHandler && jQuery.isFunction( modifiedHandler ) ) { 
1616
								result.push( item );
1616
					modifiedHandler.guid = modifiedHandler.guid || handler.guid; 
1617
								anyFound = true;
1617
					handler = modifiedHandler; 
1618
							}
1618
				} 
1619
						}
1619
			} 
1620
					}
1620
			
1621
				}
1621
			// Add the function to the element's handler list
1622
1622
			handlers[ handler.guid ] = handler;
1623
				if ( found !== undefined ) {
1623
1624
					if ( !inplace ) {
1624
			// Keep track of which events have been used, for global triggering
1625
						curLoop = result;
1625
			this.global[ type ] = true;
1626
					}
1626
		}
1627
1627
1628
					expr = expr.replace( Expr.match[ type ], "" );
1628
		// Nullify elem to prevent memory leaks in IE
1629
1629
		elem = null;
1630
					if ( !anyFound ) {
1630
	},
1631
						return [];
1631
1632
					}
1632
	global: {},
1633
1633
1634
					break;
1634
	// Detach an event or set of events from an element
1635
				}
1635
	remove: function( elem, types, handler ) {
1636
			}
1636
		// don't do events on text and comment nodes
1637
		}
1637
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1638
1638
			return;
1639
		// Improper expression
1639
		}
1640
		if ( expr == old ) {
1640
1641
			if ( anyFound == null ) {
1641
		var events = jQuery.data( elem, "events" ), ret, type, fn;
1642
				throw "Syntax error, unrecognized expression: " + expr;
1642
1643
			} else {
1643
		if ( events ) {
1644
				break;
1644
			// Unbind all events for the element
1645
			}
1645
			if ( types === undefined || (typeof types === "string" && types.charAt(0) === ".") ) {
1646
		}
1646
				for ( type in events ) {
1647
1647
					this.remove( elem, type + (types || "") );
1648
		old = expr;
1648
				}
1649
	}
1649
			} else {
1650
1650
				// types is actually an event object here
1651
	return curLoop;
1651
				if ( types.type ) {
1652
};
1652
					handler = types.handler;
1653
1653
					types = types.type;
1654
var Expr = Sizzle.selectors = {
1654
				}
1655
	order: [ "ID", "NAME", "TAG" ],
1655
1656
	match: {
1656
				// Handle multiple events separated by a space
1657
		ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1657
				// jQuery(...).unbind("mouseover mouseout", fn);
1658
		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1658
				types = types.split(/\s+/);
1659
		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
1659
				var i = 0;
1660
		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
1660
				while ( (type = types[ i++ ]) ) {
1661
		TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
1661
					// Namespaced event handlers
1662
		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
1662
					var namespaces = type.split(".");
1663
		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
1663
					type = namespaces.shift();
1664
		PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
1664
					var all = !namespaces.length,
1665
	},
1665
						cleaned = jQuery.map( namespaces.slice(0).sort(), fcleanup ),
1666
	attrMap: {
1666
						namespace = new RegExp("(^|\\.)" + cleaned.join("\\.(?:.*\\.)?") + "(\\.|$)"),
1667
		"class": "className",
1667
						special = this.special[ type ] || {};
1668
		"for": "htmlFor"
1668
1669
	},
1669
					if ( events[ type ] ) {
1670
	attrHandle: {
1670
						// remove the given handler for the given type
1671
		href: function(elem){
1671
						if ( handler ) {
1672
			return elem.getAttribute("href");
1672
							fn = events[ type ][ handler.guid ];
1673
		}
1673
							delete events[ type ][ handler.guid ];
1674
	},
1674
1675
	relative: {
1675
						// remove all handlers for the given type
1676
		"+": function(checkSet, part, isXML){
1676
						} else {
1677
			var isPartStr = typeof part === "string",
1677
							for ( var handle in events[ type ] ) {
1678
				isTag = isPartStr && !/\W/.test(part),
1678
								// Handle the removal of namespaced events
1679
				isPartStrNotTag = isPartStr && !isTag;
1679
								if ( all || namespace.test( events[ type ][ handle ].type ) ) {
1680
1680
									delete events[ type ][ handle ];
1681
			if ( isTag && !isXML ) {
1681
								}
1682
				part = part.toUpperCase();
1682
							}
1683
			}
1683
						}
1684
1684
1685
			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
1685
						if ( special.remove ) {
1686
				if ( (elem = checkSet[i]) ) {
1686
							special.remove.call( elem, namespaces, fn);
1687
					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
1687
						}
1688
1688
1689
					checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
1689
						// remove generic event handler if no more handlers exist
1690
						elem || false :
1690
						for ( ret in events[ type ] ) {
1691
						elem === part;
1691
							break;
1692
				}
1692
						}
1693
			}
1693
						if ( !ret ) {
1694
1694
							if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
1695
			if ( isPartStrNotTag ) {
1695
								if ( elem.removeEventListener ) {
1696
				Sizzle.filter( part, checkSet, true );
1696
									elem.removeEventListener( type, jQuery.data( elem, "handle" ), false );
1697
			}
1697
								} else if ( elem.detachEvent ) {
1698
		},
1698
									elem.detachEvent( "on" + type, jQuery.data( elem, "handle" ) );
1699
		">": function(checkSet, part, isXML){
1699
								}
1700
			var isPartStr = typeof part === "string";
1700
							}
1701
1701
							ret = null;
1702
			if ( isPartStr && !/\W/.test(part) ) {
1702
							delete events[ type ];
1703
				part = isXML ? part : part.toUpperCase();
1703
						}
1704
1704
					}
1705
				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1705
				}
1706
					var elem = checkSet[i];
1706
			}
1707
					if ( elem ) {
1707
1708
						var parent = elem.parentNode;
1708
			// Remove the expando if it's no longer used
1709
						checkSet[i] = parent.nodeName === part ? parent : false;
1709
			for ( ret in events ) {
1710
					}
1710
				break;
1711
				}
1711
			}
1712
			} else {
1712
			if ( !ret ) {
1713
				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1713
				var handle = jQuery.data( elem, "handle" );
1714
					var elem = checkSet[i];
1714
				if ( handle ) {
1715
					if ( elem ) {
1715
					handle.elem = null;
1716
						checkSet[i] = isPartStr ?
1716
				}
1717
							elem.parentNode :
1717
				jQuery.removeData( elem, "events" );
1718
							elem.parentNode === part;
1718
				jQuery.removeData( elem, "handle" );
1719
					}
1719
			}
1720
				}
1720
		}
1721
1721
	},
1722
				if ( isPartStr ) {
1722
1723
					Sizzle.filter( part, checkSet, true );
1723
	// bubbling is internal
1724
				}
1724
	trigger: function( event, data, elem /*, bubbling */ ) {
1725
			}
1725
		// Event object or event type
1726
		},
1726
		var type = event.type || event,
1727
		"": function(checkSet, part, isXML){
1727
			bubbling = arguments[3];
1728
			var doneName = done++, checkFn = dirCheck;
1728
1729
1729
		if ( !bubbling ) {
1730
			if ( !part.match(/\W/) ) {
1730
			event = typeof event === "object" ?
1731
				var nodeCheck = part = isXML ? part : part.toUpperCase();
1731
				// jQuery.Event object
1732
				checkFn = dirNodeCheck;
1732
				event[expando] ? event :
1733
			}
1733
				// Object literal
1734
1734
				jQuery.extend( jQuery.Event(type), event ) :
1735
			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
1735
				// Just the event type (string)
1736
		},
1736
				jQuery.Event(type);
1737
		"~": function(checkSet, part, isXML){
1737
1738
			var doneName = done++, checkFn = dirCheck;
1738
			if ( type.indexOf("!") >= 0 ) {
1739
1739
				event.type = type = type.slice(0, -1);
1740
			if ( typeof part === "string" && !part.match(/\W/) ) {
1740
				event.exclusive = true;
1741
				var nodeCheck = part = isXML ? part : part.toUpperCase();
1741
			}
1742
				checkFn = dirNodeCheck;
1742
1743
			}
1743
			// Handle a global trigger
1744
1744
			if ( !elem ) {
1745
			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
1745
				// Don't bubble custom events when global (to avoid too much overhead)
1746
		}
1746
				event.stopPropagation();
1747
	},
1747
1748
	find: {
1748
				// Only trigger if we've ever bound an event for it
1749
		ID: function(match, context, isXML){
1749
				if ( this.global[ type ] ) {
1750
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
1750
					jQuery.each( jQuery.cache, function() {
1751
				var m = context.getElementById(match[1]);
1751
						if ( this.events && this.events[type] ) {
1752
				return m ? [m] : [];
1752
							jQuery.event.trigger( event, data, this.handle.elem );
1753
			}
1753
						}
1754
		},
1754
					});
1755
		NAME: function(match, context, isXML){
1755
				}
1756
			if ( typeof context.getElementsByName !== "undefined" ) {
1756
			}
1757
				var ret = [], results = context.getElementsByName(match[1]);
1757
1758
1758
			// Handle triggering a single element
1759
				for ( var i = 0, l = results.length; i < l; i++ ) {
1759
1760
					if ( results[i].getAttribute("name") === match[1] ) {
1760
			// don't do events on text and comment nodes
1761
						ret.push( results[i] );
1761
			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1762
					}
1762
				return undefined;
1763
				}
1763
			}
1764
1764
1765
				return ret.length === 0 ? null : ret;
1765
			// Clean up in case it is reused
1766
			}
1766
			event.result = undefined;
1767
		},
1767
			event.target = elem;
1768
		TAG: function(match, context){
1768
1769
			return context.getElementsByTagName(match[1]);
1769
			// Clone the incoming data, if any
1770
		}
1770
			data = jQuery.makeArray( data );
1771
	},
1771
			data.unshift( event );
1772
	preFilter: {
1772
		}
1773
		CLASS: function(match, curLoop, inplace, result, not, isXML){
1773
1774
			match = " " + match[1].replace(/\\/g, "") + " ";
1774
		event.currentTarget = elem;
1775
1775
1776
			if ( isXML ) {
1776
		// Trigger the event, it is assumed that "handle" is a function
1777
				return match;
1777
		var handle = jQuery.data( elem, "handle" );
1778
			}
1778
		if ( handle ) {
1779
1779
			handle.apply( elem, data );
1780
			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
1780
		}
1781
				if ( elem ) {
1781
1782
					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
1782
		var nativeFn, nativeHandler;
1783
						if ( !inplace )
1783
		try {
1784
							result.push( elem );
1784
			if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
1785
					} else if ( inplace ) {
1785
				nativeFn = elem[ type ];
1786
						curLoop[i] = false;
1786
				nativeHandler = elem[ "on" + type ];
1787
					}
1787
			}
1788
				}
1788
		// prevent IE from throwing an error for some elements with some event types, see #3533
1789
			}
1789
		} catch (e) {}
1790
1790
1791
			return false;
1791
		var isClick = jQuery.nodeName(elem, "a") && type === "click";
1792
		},
1792
1793
		ID: function(match){
1793
		// Trigger the native events (except for clicks on links)
1794
			return match[1].replace(/\\/g, "");
1794
		if ( !bubbling && nativeFn && !event.isDefaultPrevented() && !isClick ) {
1795
		},
1795
			this.triggered = true;
1796
		TAG: function(match, curLoop){
1796
			try {
1797
			for ( var i = 0; curLoop[i] === false; i++ ){}
1797
				elem[ type ]();
1798
			return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
1798
			// prevent IE from throwing an error for some hidden elements
1799
		},
1799
			} catch (e) {}
1800
		CHILD: function(match){
1800
1801
			if ( match[1] == "nth" ) {
1801
		// Handle triggering native .onfoo handlers
1802
				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1802
		} else if ( nativeHandler && elem[ "on" + type ].apply( elem, data ) === false ) {
1803
				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
1803
			event.result = false;
1804
					match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
1804
		}
1805
					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
1805
1806
1806
		this.triggered = false;
1807
				// calculate the numbers (first)n+(last) including if they are negative
1807
1808
				match[2] = (test[1] + (test[2] || 1)) - 0;
1808
		if ( !event.isPropagationStopped() ) {
1809
				match[3] = test[3] - 0;
1809
			var parent = elem.parentNode || elem.ownerDocument;
1810
			}
1810
			if ( parent ) {
1811
1811
				jQuery.event.trigger( event, data, parent, true );
1812
			// TODO: Move to normal caching system
1812
			}
1813
			match[0] = done++;
1813
		}
1814
1814
	},
1815
			return match;
1815
1816
		},
1816
	handle: function( event ) {
1817
		ATTR: function(match, curLoop, inplace, result, not, isXML){
1817
		// returned undefined or false
1818
			var name = match[1].replace(/\\/g, "");
1818
		var all, handlers;
1819
1819
1820
			if ( !isXML && Expr.attrMap[name] ) {
1820
		event = arguments[0] = jQuery.event.fix( event || window.event );
1821
				match[1] = Expr.attrMap[name];
1821
		event.currentTarget = this;
1822
			}
1822
1823
1823
		// Namespaced event handlers
1824
			if ( match[2] === "~=" ) {
1824
		var namespaces = event.type.split(".");
1825
				match[4] = " " + match[4] + " ";
1825
		event.type = namespaces.shift();
1826
			}
1826
1827
1827
		// Cache this now, all = true means, any handler
1828
			return match;
1828
		all = !namespaces.length && !event.exclusive;
1829
		},
1829
1830
		PSEUDO: function(match, curLoop, inplace, result, not){
1830
		var namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
1831
			if ( match[1] === "not" ) {
1831
1832
				// If we're dealing with a complex expression, or a simple one
1832
		handlers = ( jQuery.data(this, "events") || {} )[ event.type ];
1833
				if ( match[3].match(chunker).length > 1 || /^\w/.test(match[3]) ) {
1833
1834
					match[3] = Sizzle(match[3], null, null, curLoop);
1834
		for ( var j in handlers ) {
1835
				} else {
1835
			var handler = handlers[ j ];
1836
					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
1836
1837
					if ( !inplace ) {
1837
			// Filter the functions by class
1838
						result.push.apply( result, ret );
1838
			if ( all || namespace.test(handler.type) ) {
1839
					}
1839
				// Pass in a reference to the handler function itself
1840
					return false;
1840
				// So that we can later remove it
1841
				}
1841
				event.handler = handler;
1842
			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
1842
				event.data = handler.data;
1843
				return true;
1843
1844
			}
1844
				var ret = handler.apply( this, arguments );
1845
1845
1846
			return match;
1846
				if ( ret !== undefined ) {
1847
		},
1847
					event.result = ret;
1848
		POS: function(match){
1848
					if ( ret === false ) {
1849
			match.unshift( true );
1849
						event.preventDefault();
1850
			return match;
1850
						event.stopPropagation();
1851
		}
1851
					}
1852
	},
1852
				}
1853
	filters: {
1853
1854
		enabled: function(elem){
1854
				if ( event.isImmediatePropagationStopped() ) {
1855
			return elem.disabled === false && elem.type !== "hidden";
1855
					break;
1856
		},
1856
				}
1857
		disabled: function(elem){
1857
1858
			return elem.disabled === true;
1858
			}
1859
		},
1859
		}
1860
		checked: function(elem){
1860
1861
			return elem.checked === true;
1861
		return event.result;
1862
		},
1862
	},
1863
		selected: function(elem){
1863
1864
			// Accessing this property makes selected-by-default
1864
	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
1865
			// options in Safari work properly
1865
1866
			elem.parentNode.selectedIndex;
1866
	fix: function( event ) {
1867
			return elem.selected === true;
1867
		if ( event[ expando ] ) {
1868
		},
1868
			return event;
1869
		parent: function(elem){
1869
		}
1870
			return !!elem.firstChild;
1870
1871
		},
1871
		// store a copy of the original event object
1872
		empty: function(elem){
1872
		// and "clone" to set read-only properties
1873
			return !elem.firstChild;
1873
		var originalEvent = event;
1874
		},
1874
		event = jQuery.Event( originalEvent );
1875
		has: function(elem, i, match){
1875
1876
			return !!Sizzle( match[3], elem ).length;
1876
		for ( var i = this.props.length, prop; i; ) {
1877
		},
1877
			prop = this.props[ --i ];
1878
		header: function(elem){
1878
			event[ prop ] = originalEvent[ prop ];
1879
			return /h\d/i.test( elem.nodeName );
1879
		}
1880
		},
1880
1881
		text: function(elem){
1881
		// Fix target property, if necessary
1882
			return "text" === elem.type;
1882
		if ( !event.target ) {
1883
		},
1883
			event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
1884
		radio: function(elem){
1884
		}
1885
			return "radio" === elem.type;
1885
1886
		},
1886
		// check if target is a textnode (safari)
1887
		checkbox: function(elem){
1887
		if ( event.target.nodeType === 3 ) {
1888
			return "checkbox" === elem.type;
1888
			event.target = event.target.parentNode;
1889
		},
1889
		}
1890
		file: function(elem){
1890
1891
			return "file" === elem.type;
1891
		// Add relatedTarget, if necessary
1892
		},
1892
		if ( !event.relatedTarget && event.fromElement ) {
1893
		password: function(elem){
1893
			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1894
			return "password" === elem.type;
1894
		}
1895
		},
1895
1896
		submit: function(elem){
1896
		// Calculate pageX/Y if missing and clientX/Y available
1897
			return "submit" === elem.type;
1897
		if ( event.pageX == null && event.clientX != null ) {
1898
		},
1898
			var doc = document.documentElement, body = document.body;
1899
		image: function(elem){
1899
			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1900
			return "image" === elem.type;
1900
			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
1901
		},
1901
		}
1902
		reset: function(elem){
1902
1903
			return "reset" === elem.type;
1903
		// Add which for key events
1904
		},
1904
		if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) {
1905
		button: function(elem){
1905
			event.which = event.charCode || event.keyCode;
1906
			return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
1906
		}
1907
		},
1907
1908
		input: function(elem){
1908
		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
1909
			return /input|select|textarea|button/i.test(elem.nodeName);
1909
		if ( !event.metaKey && event.ctrlKey ) {
1910
		}
1910
			event.metaKey = event.ctrlKey;
1911
	},
1911
		}
1912
	setFilters: {
1912
1913
		first: function(elem, i){
1913
		// Add which for click: 1 === left; 2 === middle; 3 === right
1914
			return i === 0;
1914
		// Note: button is not normalized, so don't use it
1915
		},
1915
		if ( !event.which && event.button !== undefined ) {
1916
		last: function(elem, i, match, array){
1916
			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
1917
			return i === array.length - 1;
1917
		}
1918
		},
1918
1919
		even: function(elem, i){
1919
		return event;
1920
			return i % 2 === 0;
1920
	},
1921
		},
1921
1922
		odd: function(elem, i){
1922
	// Deprecated, use jQuery.guid instead
1923
			return i % 2 === 1;
1923
	guid: 1E8,
1924
		},
1924
1925
		lt: function(elem, i, match){
1925
	// Deprecated, use jQuery.proxy instead
1926
			return i < match[3] - 0;
1926
	proxy: jQuery.proxy,
1927
		},
1927
1928
		gt: function(elem, i, match){
1928
	special: {
1929
			return i > match[3] - 0;
1929
		ready: {
1930
		},
1930
			// Make sure the ready event is setup
1931
		nth: function(elem, i, match){
1931
			setup: jQuery.bindReady,
1932
			return match[3] - 0 == i;
1932
			teardown: jQuery.noop
1933
		},
1933
		},
1934
		eq: function(elem, i, match){
1934
1935
			return match[3] - 0 == i;
1935
		live: {
1936
		}
1936
			add: function( proxy, data, namespaces, live ) {
1937
	},
1937
				jQuery.extend( proxy, data || {} );
1938
	filter: {
1938
1939
		PSEUDO: function(elem, match, i, array){
1939
				proxy.guid += data.selector + data.live; 
1940
			var name = match[1], filter = Expr.filters[ name ];
1940
				jQuery.event.add( this, data.live, liveHandler, data ); 
1941
1941
				
1942
			if ( filter ) {
1942
			},
1943
				return filter( elem, i, match, array );
1943
1944
			} else if ( name === "contains" ) {
1944
			remove: function( namespaces ) {
1945
				return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
1945
				if ( namespaces.length ) {
1946
			} else if ( name === "not" ) {
1946
					var remove = 0, name = new RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
1947
				var not = match[3];
1947
1948
1948
					jQuery.each( (jQuery.data(this, "events").live || {}), function() {
1949
				for ( var i = 0, l = not.length; i < l; i++ ) {
1949
						if ( name.test(this.type) ) {
1950
					if ( not[i] === elem ) {
1950
							remove++;
1951
						return false;
1951
						}
1952
					}
1952
					});
1953
				}
1953
1954
1954
					if ( remove < 1 ) {
1955
				return true;
1955
						jQuery.event.remove( this, namespaces[0], liveHandler );
1956
			}
1956
					}
1957
		},
1957
				}
1958
		CHILD: function(elem, match){
1958
			},
1959
			var type = match[1], node = elem;
1959
			special: {}
1960
			switch (type) {
1960
		},
1961
				case 'only':
1961
		beforeunload: {
1962
				case 'first':
1962
			setup: function( data, namespaces, fn ) {
1963
					while (node = node.previousSibling)  {
1963
				// We only want to do this special case on windows
1964
						if ( node.nodeType === 1 ) return false;
1964
				if ( this.setInterval ) {
1965
					}
1965
					this.onbeforeunload = fn;
1966
					if ( type == 'first') return true;
1966
				}
1967
					node = elem;
1967
1968
				case 'last':
1968
				return false;
1969
					while (node = node.nextSibling)  {
1969
			},
1970
						if ( node.nodeType === 1 ) return false;
1970
			teardown: function( namespaces, fn ) {
1971
					}
1971
				if ( this.onbeforeunload === fn ) {
1972
					return true;
1972
					this.onbeforeunload = null;
1973
				case 'nth':
1973
				}
1974
					var first = match[2], last = match[3];
1974
			}
1975
1975
		}
1976
					if ( first == 1 && last == 0 ) {
1976
	}
1977
						return true;
1977
};
1978
					}
1978
1979
1979
jQuery.Event = function( src ) {
1980
					var doneName = match[0],
1980
	// Allow instantiation without the 'new' keyword
1981
						parent = elem.parentNode;
1981
	if ( !this.preventDefault ) {
1982
1982
		return new jQuery.Event( src );
1983
					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
1983
	}
1984
						var count = 0;
1984
1985
						for ( node = parent.firstChild; node; node = node.nextSibling ) {
1985
	// Event object
1986
							if ( node.nodeType === 1 ) {
1986
	if ( src && src.type ) {
1987
								node.nodeIndex = ++count;
1987
		this.originalEvent = src;
1988
							}
1988
		this.type = src.type;
1989
						}
1989
	// Event type
1990
						parent.sizcache = doneName;
1990
	} else {
1991
					}
1991
		this.type = src;
1992
1992
	}
1993
					var diff = elem.nodeIndex - last;
1993
1994
					if ( first == 0 ) {
1994
	// timeStamp is buggy for some events on Firefox(#3843)
1995
						return diff == 0;
1995
	// So we won't rely on the native value
1996
					} else {
1996
	this.timeStamp = now();
1997
						return ( diff % first == 0 && diff / first >= 0 );
1997
1998
					}
1998
	// Mark it as fixed
1999
			}
1999
	this[ expando ] = true;
2000
		},
2000
};
2001
		ID: function(elem, match){
2001
2002
			return elem.nodeType === 1 && elem.getAttribute("id") === match;
2002
function returnFalse() {
2003
		},
2003
	return false;
2004
		TAG: function(elem, match){
2004
}
2005
			return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
2005
function returnTrue() {
2006
		},
2006
	return true;
2007
		CLASS: function(elem, match){
2007
}
2008
			return (" " + (elem.className || elem.getAttribute("class")) + " ")
2008
2009
				.indexOf( match ) > -1;
2009
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2010
		},
2010
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2011
		ATTR: function(elem, match){
2011
jQuery.Event.prototype = {
2012
			var name = match[1],
2012
	preventDefault: function() {
2013
				result = Expr.attrHandle[ name ] ?
2013
		this.isDefaultPrevented = returnTrue;
2014
					Expr.attrHandle[ name ]( elem ) :
2014
2015
					elem[ name ] != null ?
2015
		var e = this.originalEvent;
2016
						elem[ name ] :
2016
		if ( !e ) {
2017
						elem.getAttribute( name ),
2017
			return;
2018
				value = result + "",
2018
		}
2019
				type = match[2],
2019
		
2020
				check = match[4];
2020
		// if preventDefault exists run it on the original event
2021
2021
		if ( e.preventDefault ) {
2022
			return result == null ?
2022
			e.preventDefault();
2023
				type === "!=" :
2023
		}
2024
				type === "=" ?
2024
		// otherwise set the returnValue property of the original event to false (IE)
2025
				value === check :
2025
		e.returnValue = false;
2026
				type === "*=" ?
2026
	},
2027
				value.indexOf(check) >= 0 :
2027
	stopPropagation: function() {
2028
				type === "~=" ?
2028
		this.isPropagationStopped = returnTrue;
2029
				(" " + value + " ").indexOf(check) >= 0 :
2029
2030
				!check ?
2030
		var e = this.originalEvent;
2031
				value && result !== false :
2031
		if ( !e ) {
2032
				type === "!=" ?
2032
			return;
2033
				value != check :
2033
		}
2034
				type === "^=" ?
2034
		// if stopPropagation exists run it on the original event
2035
				value.indexOf(check) === 0 :
2035
		if ( e.stopPropagation ) {
2036
				type === "$=" ?
2036
			e.stopPropagation();
2037
				value.substr(value.length - check.length) === check :
2037
		}
2038
				type === "|=" ?
2038
		// otherwise set the cancelBubble property of the original event to true (IE)
2039
				value === check || value.substr(0, check.length + 1) === check + "-" :
2039
		e.cancelBubble = true;
2040
				false;
2040
	},
2041
		},
2041
	stopImmediatePropagation: function() {
2042
		POS: function(elem, match, i, array){
2042
		this.isImmediatePropagationStopped = returnTrue;
2043
			var name = match[2], filter = Expr.setFilters[ name ];
2043
		this.stopPropagation();
2044
2044
	},
2045
			if ( filter ) {
2045
	isDefaultPrevented: returnFalse,
2046
				return filter( elem, i, match, array );
2046
	isPropagationStopped: returnFalse,
2047
			}
2047
	isImmediatePropagationStopped: returnFalse
2048
		}
2048
};
2049
	}
2049
2050
};
2050
// Checks if an event happened on an element within another element
2051
2051
// Used in jQuery.event.special.mouseenter and mouseleave handlers
2052
var origPOS = Expr.match.POS;
2052
var withinElement = function( event ) {
2053
2053
	// Check if mouse(over|out) are still within the same parent element
2054
for ( var type in Expr.match ) {
2054
	var parent = event.relatedTarget;
2055
	Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
2055
2056
}
2056
	// Traverse up the tree
2057
2057
	while ( parent && parent !== this ) {
2058
var makeArray = function(array, results) {
2058
		// Firefox sometimes assigns relatedTarget a XUL element
2059
	array = Array.prototype.slice.call( array );
2059
		// which we cannot access the parentNode property of
2060
2060
		try {
2061
	if ( results ) {
2061
			parent = parent.parentNode;
2062
		results.push.apply( results, array );
2062
2063
		return results;
2063
		// assuming we've left the element since we most likely mousedover a xul element
2064
	}
2064
		} catch(e) {
2065
2065
			break;
2066
	return array;
2066
		}
2067
};
2067
	}
2068
2068
2069
// Perform a simple check to determine if the browser is capable of
2069
	if ( parent !== this ) {
2070
// converting a NodeList to an array using builtin methods.
2070
		// set the correct event type
2071
try {
2071
		event.type = event.data;
2072
	Array.prototype.slice.call( document.documentElement.childNodes );
2072
2073
2073
		// handle event if we actually just moused on to a non sub-element
2074
// Provide a fallback method if it does not work
2074
		jQuery.event.handle.apply( this, arguments );
2075
} catch(e){
2075
	}
2076
	makeArray = function(array, results) {
2076
2077
		var ret = results || [];
2077
},
2078
2078
2079
		if ( toString.call(array) === "[object Array]" ) {
2079
// In case of event delegation, we only need to rename the event.type,
2080
			Array.prototype.push.apply( ret, array );
2080
// liveHandler will take care of the rest.
2081
		} else {
2081
delegate = function( event ) {
2082
			if ( typeof array.length === "number" ) {
2082
	event.type = event.data;
2083
				for ( var i = 0, l = array.length; i < l; i++ ) {
2083
	jQuery.event.handle.apply( this, arguments );
2084
					ret.push( array[i] );
2084
};
2085
				}
2085
2086
			} else {
2086
// Create mouseenter and mouseleave events
2087
				for ( var i = 0; array[i]; i++ ) {
2087
jQuery.each({
2088
					ret.push( array[i] );
2088
	mouseenter: "mouseover",
2089
				}
2089
	mouseleave: "mouseout"
2090
			}
2090
}, function( orig, fix ) {
2091
		}
2091
	jQuery.event.special[ orig ] = {
2092
2092
		setup: function( data ) {
2093
		return ret;
2093
			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2094
	};
2094
		},
2095
}
2095
		teardown: function( data ) {
2096
2096
			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2097
var sortOrder;
2097
		}
2098
2098
	};
2099
if ( document.documentElement.compareDocumentPosition ) {
2099
});
2100
	sortOrder = function( a, b ) {
2100
2101
		var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
2101
// submit delegation
2102
		if ( ret === 0 ) {
2102
if ( !jQuery.support.submitBubbles ) {
2103
			hasDuplicate = true;
2103
2104
		}
2104
jQuery.event.special.submit = {
2105
		return ret;
2105
	setup: function( data, namespaces, fn ) {
2106
	};
2106
		if ( this.nodeName.toLowerCase() !== "form" ) {
2107
} else if ( "sourceIndex" in document.documentElement ) {
2107
			jQuery.event.add(this, "click.specialSubmit." + fn.guid, function( e ) {
2108
	sortOrder = function( a, b ) {
2108
				var elem = e.target, type = elem.type;
2109
		var ret = a.sourceIndex - b.sourceIndex;
2109
2110
		if ( ret === 0 ) {
2110
				if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2111
			hasDuplicate = true;
2111
					return trigger( "submit", this, arguments );
2112
		}
2112
				}
2113
		return ret;
2113
			});
2114
	};
2114
	 
2115
} else if ( document.createRange ) {
2115
			jQuery.event.add(this, "keypress.specialSubmit." + fn.guid, function( e ) {
2116
	sortOrder = function( a, b ) {
2116
				var elem = e.target, type = elem.type;
2117
		var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
2117
2118
		aRange.selectNode(a);
2118
				if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2119
		aRange.collapse(true);
2119
					return trigger( "submit", this, arguments );
2120
		bRange.selectNode(b);
2120
				}
2121
		bRange.collapse(true);
2121
			});
2122
		var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
2122
2123
		if ( ret === 0 ) {
2123
		} else {
2124
			hasDuplicate = true;
2124
			return false;
2125
		}
2125
		}
2126
		return ret;
2126
	},
2127
	};
2127
2128
}
2128
	remove: function( namespaces, fn ) {
2129
2129
		jQuery.event.remove( this, "click.specialSubmit" + (fn ? "."+fn.guid : "") );
2130
// Check to see if the browser returns elements by name when
2130
		jQuery.event.remove( this, "keypress.specialSubmit" + (fn ? "."+fn.guid : "") );
2131
// querying by getElementById (and provide a workaround)
2131
	}
2132
(function(){
2132
};
2133
	// We're going to inject a fake input element with a specified name
2133
2134
	var form = document.createElement("form"),
2134
}
2135
		id = "script" + (new Date).getTime();
2135
2136
	form.innerHTML = "<input name='" + id + "'/>";
2136
// change delegation, happens here so we have bind.
2137
2137
if ( !jQuery.support.changeBubbles ) {
2138
	// Inject it into the root element, check its status, and remove it quickly
2138
2139
	var root = document.documentElement;
2139
var formElems = /textarea|input|select/i;
2140
	root.insertBefore( form, root.firstChild );
2140
2141
2141
function getVal( elem ) {
2142
	// The workaround has to do additional checks after a getElementById
2142
	var type = elem.type, val = elem.value;
2143
	// Which slows things down for other browsers (hence the branching)
2143
2144
	if ( !!document.getElementById( id ) ) {
2144
	if ( type === "radio" || type === "checkbox" ) {
2145
		Expr.find.ID = function(match, context, isXML){
2145
		val = elem.checked;
2146
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
2146
2147
				var m = context.getElementById(match[1]);
2147
	} else if ( type === "select-multiple" ) {
2148
				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
2148
		val = elem.selectedIndex > -1 ?
2149
			}
2149
			jQuery.map( elem.options, function( elem ) {
2150
		};
2150
				return elem.selected;
2151
2151
			}).join("-") :
2152
		Expr.filter.ID = function(elem, match){
2152
			"";
2153
			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
2153
2154
			return elem.nodeType === 1 && node && node.nodeValue === match;
2154
	} else if ( elem.nodeName.toLowerCase() === "select" ) {
2155
		};
2155
		val = elem.selectedIndex;
2156
	}
2156
	}
2157
2157
2158
	root.removeChild( form );
2158
	return val;
2159
})();
2159
}
2160
2160
2161
(function(){
2161
function testChange( e ) {
2162
	// Check to see if the browser returns only elements
2162
		var elem = e.target, data, val;
2163
	// when doing getElementsByTagName("*")
2163
2164
2164
		if ( !formElems.test( elem.nodeName ) || elem.readOnly ) {
2165
	// Create a fake element
2165
			return;
2166
	var div = document.createElement("div");
2166
		}
2167
	div.appendChild( document.createComment("") );
2167
2168
2168
		data = jQuery.data( elem, "_change_data" );
2169
	// Make sure no comments are found
2169
		val = getVal(elem);
2170
	if ( div.getElementsByTagName("*").length > 0 ) {
2170
2171
		Expr.find.TAG = function(match, context){
2171
		if ( val === data ) {
2172
			var results = context.getElementsByTagName(match[1]);
2172
			return;
2173
2173
		}
2174
			// Filter out possible comments
2174
2175
			if ( match[1] === "*" ) {
2175
		// the current data will be also retrieved by beforeactivate
2176
				var tmp = [];
2176
		if ( e.type !== "focusout" || elem.type !== "radio" ) {
2177
2177
			jQuery.data( elem, "_change_data", val );
2178
				for ( var i = 0; results[i]; i++ ) {
2178
		}
2179
					if ( results[i].nodeType === 1 ) {
2179
2180
						tmp.push( results[i] );
2180
		if ( elem.type !== "select" && (data != null || val) ) {
2181
					}
2181
			e.type = "change";
2182
				}
2182
			return jQuery.event.trigger( e, arguments[1], this );
2183
2183
		}
2184
				results = tmp;
2184
}
2185
			}
2185
2186
2186
jQuery.event.special.change = {
2187
			return results;
2187
	filters: {
2188
		};
2188
		focusout: testChange, 
2189
	}
2189
2190
2190
		click: function( e ) {
2191
	// Check to see if an attribute returns normalized href attributes
2191
			var elem = e.target, type = elem.type;
2192
	div.innerHTML = "<a href='#'></a>";
2192
2193
	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
2193
			if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2194
			div.firstChild.getAttribute("href") !== "#" ) {
2194
				return testChange.call( this, e );
2195
		Expr.attrHandle.href = function(elem){
2195
			}
2196
			return elem.getAttribute("href", 2);
2196
		},
2197
		};
2197
2198
	}
2198
		// Change has to be called before submit
2199
})();
2199
		// Keydown will be called before keypress, which is used in submit-event delegation
2200
2200
		keydown: function( e ) {
2201
if ( document.querySelectorAll ) (function(){
2201
			var elem = e.target, type = elem.type;
2202
	var oldSizzle = Sizzle, div = document.createElement("div");
2202
2203
	div.innerHTML = "<p class='TEST'></p>";
2203
			if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2204
2204
				(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2205
	// Safari can't handle uppercase or unicode characters when
2205
				type === "select-multiple" ) {
2206
	// in quirks mode.
2206
				return testChange.call( this, e );
2207
	if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
2207
			}
2208
		return;
2208
		},
2209
	}
2209
2210
2210
		// Beforeactivate happens also before the previous element is blurred
2211
	Sizzle = function(query, context, extra, seed){
2211
		// with this event you can't trigger a change event, but you can store
2212
		context = context || document;
2212
		// information/focus[in] is not needed anymore
2213
2213
		beforeactivate: function( e ) {
2214
		// Only use querySelectorAll on non-XML documents
2214
			var elem = e.target;
2215
		// (ID selectors don't work in non-HTML documents)
2215
2216
		if ( !seed && context.nodeType === 9 && !isXML(context) ) {
2216
			if ( elem.nodeName.toLowerCase() === "input" && elem.type === "radio" ) {
2217
			try {
2217
				jQuery.data( elem, "_change_data", getVal(elem) );
2218
				return makeArray( context.querySelectorAll(query), extra );
2218
			}
2219
			} catch(e){}
2219
		}
2220
		}
2220
	},
2221
2221
	setup: function( data, namespaces, fn ) {
2222
		return oldSizzle(query, context, extra, seed);
2222
		for ( var type in changeFilters ) {
2223
	};
2223
			jQuery.event.add( this, type + ".specialChange." + fn.guid, changeFilters[type] );
2224
2224
		}
2225
	Sizzle.find = oldSizzle.find;
2225
2226
	Sizzle.filter = oldSizzle.filter;
2226
		return formElems.test( this.nodeName );
2227
	Sizzle.selectors = oldSizzle.selectors;
2227
	},
2228
	Sizzle.matches = oldSizzle.matches;
2228
	remove: function( namespaces, fn ) {
2229
})();
2229
		for ( var type in changeFilters ) {
2230
2230
			jQuery.event.remove( this, type + ".specialChange" + (fn ? "."+fn.guid : ""), changeFilters[type] );
2231
if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2231
		}
2232
	var div = document.createElement("div");
2232
2233
	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2233
		return formElems.test( this.nodeName );
2234
2234
	}
2235
	// Opera can't find a second classname (in 9.6)
2235
};
2236
	if ( div.getElementsByClassName("e").length === 0 )
2236
2237
		return;
2237
var changeFilters = jQuery.event.special.change.filters;
2238
2238
2239
	// Safari caches class attributes, doesn't catch changes (in 3.2)
2239
}
2240
	div.lastChild.className = "e";
2240
2241
2241
function trigger( type, elem, args ) {
2242
	if ( div.getElementsByClassName("e").length === 1 )
2242
	args[0].type = type;
2243
		return;
2243
	return jQuery.event.handle.apply( elem, args );
2244
2244
}
2245
	Expr.order.splice(1, 0, "CLASS");
2245
2246
	Expr.find.CLASS = function(match, context, isXML) {
2246
// Create "bubbling" focus and blur events
2247
		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2247
if ( document.addEventListener ) {
2248
			return context.getElementsByClassName(match[1]);
2248
	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2249
		}
2249
		jQuery.event.special[ fix ] = {
2250
	};
2250
			setup: function() {
2251
})();
2251
				this.addEventListener( orig, handler, true );
2252
2252
			}, 
2253
function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2253
			teardown: function() { 
2254
	var sibDir = dir == "previousSibling" && !isXML;
2254
				this.removeEventListener( orig, handler, true );
2255
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2255
			}
2256
		var elem = checkSet[i];
2256
		};
2257
		if ( elem ) {
2257
2258
			if ( sibDir && elem.nodeType === 1 ){
2258
		function handler( e ) { 
2259
				elem.sizcache = doneName;
2259
			e = jQuery.event.fix( e );
2260
				elem.sizset = i;
2260
			e.type = fix;
2261
			}
2261
			return jQuery.event.handle.call( this, e );
2262
			elem = elem[dir];
2262
		}
2263
			var match = false;
2263
	});
2264
2264
}
2265
			while ( elem ) {
2265
2266
				if ( elem.sizcache === doneName ) {
2266
jQuery.each(["bind", "one"], function( i, name ) {
2267
					match = checkSet[elem.sizset];
2267
	jQuery.fn[ name ] = function( type, data, fn ) {
2268
					break;
2268
		// Handle object literals
2269
				}
2269
		if ( typeof type === "object" ) {
2270
2270
			for ( var key in type ) {
2271
				if ( elem.nodeType === 1 && !isXML ){
2271
				this[ name ](key, data, type[key], fn);
2272
					elem.sizcache = doneName;
2272
			}
2273
					elem.sizset = i;
2273
			return this;
2274
				}
2274
		}
2275
2275
		
2276
				if ( elem.nodeName === cur ) {
2276
		if ( jQuery.isFunction( data ) ) {
2277
					match = elem;
2277
			thisObject = fn;
2278
					break;
2278
			fn = data;
2279
				}
2279
			data = undefined;
2280
2280
		}
2281
				elem = elem[dir];
2281
2282
			}
2282
		var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2283
2283
			jQuery( this ).unbind( event, handler );
2284
			checkSet[i] = match;
2284
			return fn.apply( this, arguments );
2285
		}
2285
		}) : fn;
2286
	}
2286
2287
}
2287
		return type === "unload" && name !== "one" ?
2288
2288
			this.one( type, data, fn, thisObject ) :
2289
function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2289
			this.each(function() {
2290
	var sibDir = dir == "previousSibling" && !isXML;
2290
				jQuery.event.add( this, type, handler, data );
2291
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2291
			});
2292
		var elem = checkSet[i];
2292
	};
2293
		if ( elem ) {
2293
});
2294
			if ( sibDir && elem.nodeType === 1 ) {
2294
2295
				elem.sizcache = doneName;
2295
jQuery.fn.extend({
2296
				elem.sizset = i;
2296
	unbind: function( type, fn ) {
2297
			}
2297
		// Handle object literals
2298
			elem = elem[dir];
2298
		if ( typeof type === "object" && !type.preventDefault ) {
2299
			var match = false;
2299
			for ( var key in type ) {
2300
2300
				this.unbind(key, type[key]);
2301
			while ( elem ) {
2301
			}
2302
				if ( elem.sizcache === doneName ) {
2302
			return this;
2303
					match = checkSet[elem.sizset];
2303
		}
2304
					break;
2304
2305
				}
2305
		return this.each(function() {
2306
2306
			jQuery.event.remove( this, type, fn );
2307
				if ( elem.nodeType === 1 ) {
2307
		});
2308
					if ( !isXML ) {
2308
	},
2309
						elem.sizcache = doneName;
2309
	trigger: function( type, data ) {
2310
						elem.sizset = i;
2310
		return this.each(function() {
2311
					}
2311
			jQuery.event.trigger( type, data, this );
2312
					if ( typeof cur !== "string" ) {
2312
		});
2313
						if ( elem === cur ) {
2313
	},
2314
							match = true;
2314
2315
							break;
2315
	triggerHandler: function( type, data ) {
2316
						}
2316
		if ( this[0] ) {
2317
2317
			var event = jQuery.Event( type );
2318
					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
2318
			event.preventDefault();
2319
						match = elem;
2319
			event.stopPropagation();
2320
						break;
2320
			jQuery.event.trigger( event, data, this[0] );
2321
					}
2321
			return event.result;
2322
				}
2322
		}
2323
2323
	},
2324
				elem = elem[dir];
2324
2325
			}
2325
	toggle: function( fn ) {
2326
2326
		// Save reference to arguments for access in closure
2327
			checkSet[i] = match;
2327
		var args = arguments, i = 1;
2328
		}
2328
2329
	}
2329
		// link all the functions, so any of them can unbind this click handler
2330
}
2330
		while ( i < args.length ) {
2331
2331
			jQuery.proxy( fn, args[ i++ ] );
2332
var contains = document.compareDocumentPosition ?  function(a, b){
2332
		}
2333
	return a.compareDocumentPosition(b) & 16;
2333
2334
} : function(a, b){
2334
		return this.click( jQuery.proxy( fn, function( event ) {
2335
	return a !== b && (a.contains ? a.contains(b) : true);
2335
			// Figure out which function to execute
2336
};
2336
			var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2337
2337
			jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2338
var isXML = function(elem){
2338
2339
	return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
2339
			// Make sure that clicks stop
2340
		!!elem.ownerDocument && isXML( elem.ownerDocument );
2340
			event.preventDefault();
2341
};
2341
2342
2342
			// and execute the function
2343
var posProcess = function(selector, context){
2343
			return args[ lastToggle ].apply( this, arguments ) || false;
2344
	var tmpSet = [], later = "", match,
2344
		}));
2345
		root = context.nodeType ? [context] : context;
2345
	},
2346
2346
2347
	// Position selectors must be done after the filter
2347
	hover: function( fnOver, fnOut ) {
2348
	// And so must :not(positional) so we move all PSEUDOs to the end
2348
		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2349
	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
2349
	},
2350
		later += match[0];
2350
2351
		selector = selector.replace( Expr.match.PSEUDO, "" );
2351
	live: function( type, data, fn ) {
2352
	}
2352
		if ( jQuery.isFunction( data ) ) {
2353
2353
			fn = data;
2354
	selector = Expr.relative[selector] ? selector + "*" : selector;
2354
			data = undefined;
2355
2355
		}
2356
	for ( var i = 0, l = root.length; i < l; i++ ) {
2356
2357
		Sizzle( selector, root[i], tmpSet );
2357
		jQuery( this.context ).bind( liveConvert( type, this.selector ), {
2358
	}
2358
			data: data, selector: this.selector, live: type
2359
2359
		}, fn );
2360
	return Sizzle.filter( later, tmpSet );
2360
2361
};
2361
		return this;
2362
2362
	},
2363
// EXPOSE
2363
2364
jQuery.find = Sizzle;
2364
	die: function( type, fn ) {
2365
jQuery.filter = Sizzle.filter;
2365
		jQuery( this.context ).unbind( liveConvert( type, this.selector ), fn ? { guid: fn.guid + this.selector + type } : null );
2366
jQuery.expr = Sizzle.selectors;
2366
		return this;
2367
jQuery.expr[":"] = jQuery.expr.filters;
2367
	}
2368
2368
});
2369
Sizzle.selectors.filters.hidden = function(elem){
2369
2370
	return elem.offsetWidth === 0 || elem.offsetHeight === 0;
2370
function liveHandler( event ) {
2371
};
2371
	var stop = true, elems = [], selectors = [], args = arguments,
2372
2372
		related, match, fn, elem, j, i, data,
2373
Sizzle.selectors.filters.visible = function(elem){
2373
		live = jQuery.extend({}, jQuery.data( this, "events" ).live);
2374
	return elem.offsetWidth > 0 || elem.offsetHeight > 0;
2374
2375
};
2375
	for ( j in live ) {
2376
2376
		fn = live[j];
2377
Sizzle.selectors.filters.animated = function(elem){
2377
		if ( fn.live === event.type ||
2378
	return jQuery.grep(jQuery.timers, function(fn){
2378
				fn.altLive && jQuery.inArray(event.type, fn.altLive) > -1 ) {
2379
		return elem === fn.elem;
2379
2380
	}).length;
2380
			data = fn.data;
2381
};
2381
			if ( !(data.beforeFilter && data.beforeFilter[event.type] && 
2382
2382
					!data.beforeFilter[event.type](event)) ) {
2383
jQuery.multiFilter = function( expr, elems, not ) {
2383
				selectors.push( fn.selector );
2384
	if ( not ) {
2384
			}
2385
		expr = ":not(" + expr + ")";
2385
		} else {
2386
	}
2386
			delete live[j];
2387
2387
		}
2388
	return Sizzle.matches(expr, elems);
2388
	}
2389
};
2389
2390
2390
	match = jQuery( event.target ).closest( selectors, event.currentTarget );
2391
jQuery.dir = function( elem, dir ){
2391
2392
	var matched = [], cur = elem[dir];
2392
	for ( i = 0, l = match.length; i < l; i++ ) {
2393
	while ( cur && cur != document ) {
2393
		for ( j in live ) {
2394
		if ( cur.nodeType == 1 )
2394
			fn = live[j];
2395
			matched.push( cur );
2395
			elem = match[i].elem;
2396
		cur = cur[dir];
2396
			related = null;
2397
	}
2397
2398
	return matched;
2398
			if ( match[i].selector === fn.selector ) {
2399
};
2399
				// Those two events require additional checking
2400
2400
				if ( fn.live === "mouseenter" || fn.live === "mouseleave" ) {
2401
jQuery.nth = function(cur, result, dir, elem){
2401
					related = jQuery( event.relatedTarget ).closest( fn.selector )[0];
2402
	result = result || 1;
2402
				}
2403
	var num = 0;
2403
2404
2404
				if ( !related || related !== elem ) {
2405
	for ( ; cur; cur = cur[dir] )
2405
					elems.push({ elem: elem, fn: fn });
2406
		if ( cur.nodeType == 1 && ++num == result )
2406
				}
2407
			break;
2407
			}
2408
2408
		}
2409
	return cur;
2409
	}
2410
};
2410
2411
2411
	for ( i = 0, l = elems.length; i < l; i++ ) {
2412
jQuery.sibling = function(n, elem){
2412
		match = elems[i];
2413
	var r = [];
2413
		event.currentTarget = match.elem;
2414
2414
		event.data = match.fn.data;
2415
	for ( ; n; n = n.nextSibling ) {
2415
		if ( match.fn.apply( match.elem, args ) === false ) {
2416
		if ( n.nodeType == 1 && n != elem )
2416
			stop = false;
2417
			r.push( n );
2417
			break;
2418
	}
2418
		}
2419
2419
	}
2420
	return r;
2420
2421
};
2421
	return stop;
2422
2422
}
2423
return;
2423
2424
2424
function liveConvert( type, selector ) {
2425
window.Sizzle = Sizzle;
2425
	return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "&")].join(".");
2426
2426
}
2427
})();
2427
2428
/*
2428
jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
2429
 * A number of helper functions used for managing events.
2429
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
2430
 * Many of the ideas behind this code originated from
2430
	"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
2431
 * Dean Edwards' addEvent library.
2431
2432
 */
2432
	// Handle event binding
2433
jQuery.event = {
2433
	jQuery.fn[ name ] = function( fn ) {
2434
2434
		return fn ? this.bind( name, fn ) : this.trigger( name );
2435
	// Bind an event to an element
2435
	};
2436
	// Original by Dean Edwards
2436
2437
	add: function(elem, types, handler, data) {
2437
	if ( jQuery.attrFn ) {
2438
		if ( elem.nodeType == 3 || elem.nodeType == 8 )
2438
		jQuery.attrFn[ name ] = true;
2439
			return;
2439
	}
2440
2440
});
2441
		// For whatever reason, IE has trouble passing the window object
2441
2442
		// around, causing it to be cloned in the process
2442
// Prevent memory leaks in IE
2443
		if ( elem.setInterval && elem != window )
2443
// Window isn't included so as not to unbind existing unload events
2444
			elem = window;
2444
// More info:
2445
2445
//  - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2446
		// Make sure that the function being executed has a unique ID
2446
if ( window.attachEvent && !window.addEventListener ) {
2447
		if ( !handler.guid )
2447
	window.attachEvent("onunload", function() {
2448
			handler.guid = this.guid++;
2448
		for ( var id in jQuery.cache ) {
2449
2449
			if ( jQuery.cache[ id ].handle ) {
2450
		// if data is passed, bind to handler
2450
				// Try/Catch is to handle iframes being unloaded, see #4280
2451
		if ( data !== undefined ) {
2451
				try {
2452
			// Create temporary function pointer to original handler
2452
					jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2453
			var fn = handler;
2453
				} catch(e) {}
2454
2454
			}
2455
			// Create unique handler function, wrapped around original handler
2455
		}
2456
			handler = this.proxy( fn );
2456
	});
2457
2457
}
2458
			// Store data in unique handler
2458
/*!
2459
			handler.data = data;
2459
 * Sizzle CSS Selector Engine - v1.0
2460
		}
2460
 *  Copyright 2009, The Dojo Foundation
2461
2461
 *  Released under the MIT, BSD, and GPL Licenses.
2462
		// Init the element's event structure
2462
 *  More information: http://sizzlejs.com/
2463
		var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
2463
 */
2464
			handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
2464
(function(){
2465
				// Handle the second event of a trigger and when
2465
2466
				// an event is called after a page has unloaded
2466
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
2467
				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
2467
	done = 0,
2468
					jQuery.event.handle.apply(arguments.callee.elem, arguments) :
2468
	toString = Object.prototype.toString,
2469
					undefined;
2469
	hasDuplicate = false,
2470
			});
2470
	baseHasDuplicate = true;
2471
		// Add elem as a property of the handle function
2471
2472
		// This is to prevent a memory leak with non-native
2472
// Here we check if the JavaScript engine is using some sort of
2473
		// event in IE.
2473
// optimization where it does not always call our comparision
2474
		handle.elem = elem;
2474
// function. If that is the case, discard the hasDuplicate value.
2475
2475
//   Thus far that includes Google Chrome.
2476
		// Handle multiple events separated by a space
2476
[0, 0].sort(function(){
2477
		// jQuery(...).bind("mouseover mouseout", fn);
2477
	baseHasDuplicate = false;
2478
		jQuery.each(types.split(/\s+/), function(index, type) {
2478
	return 0;
2479
			// Namespaced event handlers
2479
});
2480
			var namespaces = type.split(".");
2480
2481
			type = namespaces.shift();
2481
var Sizzle = function(selector, context, results, seed) {
2482
			handler.type = namespaces.slice().sort().join(".");
2482
	results = results || [];
2483
2483
	var origContext = context = context || document;
2484
			// Get the current list of functions bound to this event
2484
2485
			var handlers = events[type];
2485
	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
2486
2486
		return [];
2487
			if ( jQuery.event.specialAll[type] )
2487
	}
2488
				jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
2488
	
2489
2489
	if ( !selector || typeof selector !== "string" ) {
2490
			// Init the event handler queue
2490
		return results;
2491
			if (!handlers) {
2491
	}
2492
				handlers = events[type] = {};
2492
2493
2493
	var parts = [], m, set, checkSet, extra, prune = true, contextXML = isXML(context),
2494
				// Check for a special event handler
2494
		soFar = selector;
2495
				// Only use addEventListener/attachEvent if the special
2495
	
2496
				// events handler returns false
2496
	// Reset the position of the chunker regexp (start from head)
2497
				if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
2497
	while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) {
2498
					// Bind the global event handler to the element
2498
		soFar = m[3];
2499
					if (elem.addEventListener)
2499
		
2500
						elem.addEventListener(type, handle, false);
2500
		parts.push( m[1] );
2501
					else if (elem.attachEvent)
2501
		
2502
						elem.attachEvent("on" + type, handle);
2502
		if ( m[2] ) {
2503
				}
2503
			extra = m[3];
2504
			}
2504
			break;
2505
2505
		}
2506
			// Add the function to the element's handler list
2506
	}
2507
			handlers[handler.guid] = handler;
2507
2508
2508
	if ( parts.length > 1 && origPOS.exec( selector ) ) {
2509
			// Keep track of which events have been used, for global triggering
2509
		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
2510
			jQuery.event.global[type] = true;
2510
			set = posProcess( parts[0] + parts[1], context );
2511
		});
2511
		} else {
2512
2512
			set = Expr.relative[ parts[0] ] ?
2513
		// Nullify elem to prevent memory leaks in IE
2513
				[ context ] :
2514
		elem = null;
2514
				Sizzle( parts.shift(), context );
2515
	},
2515
2516
2516
			while ( parts.length ) {
2517
	guid: 1,
2517
				selector = parts.shift();
2518
	global: {},
2518
2519
2519
				if ( Expr.relative[ selector ] ) {
2520
	// Detach an event or set of events from an element
2520
					selector += parts.shift();
2521
	remove: function(elem, types, handler) {
2521
				}
2522
		// don't do events on text and comment nodes
2522
				
2523
		if ( elem.nodeType == 3 || elem.nodeType == 8 )
2523
				set = posProcess( selector, set );
2524
			return;
2524
			}
2525
2525
		}
2526
		var events = jQuery.data(elem, "events"), ret, index;
2526
	} else {
2527
2527
		// Take a shortcut and set the context if the root selector is an ID
2528
		if ( events ) {
2528
		// (but not if it'll be faster if the inner selector is an ID)
2529
			// Unbind all events for the element
2529
		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
2530
			if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
2530
				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
2531
				for ( var type in events )
2531
			var ret = Sizzle.find( parts.shift(), context, contextXML );
2532
					this.remove( elem, type + (types || "") );
2532
			context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
2533
			else {
2533
		}
2534
				// types is actually an event object here
2534
2535
				if ( types.type ) {
2535
		if ( context ) {
2536
					handler = types.handler;
2536
			var ret = seed ?
2537
					types = types.type;
2537
				{ expr: parts.pop(), set: makeArray(seed) } :
2538
				}
2538
				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
2539
2539
			set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
2540
				// Handle multiple events seperated by a space
2540
2541
				// jQuery(...).unbind("mouseover mouseout", fn);
2541
			if ( parts.length > 0 ) {
2542
				jQuery.each(types.split(/\s+/), function(index, type){
2542
				checkSet = makeArray(set);
2543
					// Namespaced event handlers
2543
			} else {
2544
					var namespaces = type.split(".");
2544
				prune = false;
2545
					type = namespaces.shift();
2545
			}
2546
					var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
2546
2547
2547
			while ( parts.length ) {
2548
					if ( events[type] ) {
2548
				var cur = parts.pop(), pop = cur;
2549
						// remove the given handler for the given type
2549
2550
						if ( handler )
2550
				if ( !Expr.relative[ cur ] ) {
2551
							delete events[type][handler.guid];
2551
					cur = "";
2552
2552
				} else {
2553
						// remove all handlers for the given type
2553
					pop = parts.pop();
2554
						else
2554
				}
2555
							for ( var handle in events[type] )
2555
2556
								// Handle the removal of namespaced events
2556
				if ( pop == null ) {
2557
								if ( namespace.test(events[type][handle].type) )
2557
					pop = context;
2558
									delete events[type][handle];
2558
				}
2559
2559
2560
						if ( jQuery.event.specialAll[type] )
2560
				Expr.relative[ cur ]( checkSet, pop, contextXML );
2561
							jQuery.event.specialAll[type].teardown.call(elem, namespaces);
2561
			}
2562
2562
		} else {
2563
						// remove generic event handler if no more handlers exist
2563
			checkSet = parts = [];
2564
						for ( ret in events[type] ) break;
2564
		}
2565
						if ( !ret ) {
2565
	}
2566
							if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
2566
2567
								if (elem.removeEventListener)
2567
	if ( !checkSet ) {
2568
									elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
2568
		checkSet = set;
2569
								else if (elem.detachEvent)
2569
	}
2570
									elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
2570
2571
							}
2571
	if ( !checkSet ) {
2572
							ret = null;
2572
		throw "Syntax error, unrecognized expression: " + (cur || selector);
2573
							delete events[type];
2573
	}
2574
						}
2574
2575
					}
2575
	if ( toString.call(checkSet) === "[object Array]" ) {
2576
				});
2576
		if ( !prune ) {
2577
			}
2577
			results.push.apply( results, checkSet );
2578
2578
		} else if ( context && context.nodeType === 1 ) {
2579
			// Remove the expando if it's no longer used
2579
			for ( var i = 0; checkSet[i] != null; i++ ) {
2580
			for ( ret in events ) break;
2580
				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
2581
			if ( !ret ) {
2581
					results.push( set[i] );
2582
				var handle = jQuery.data( elem, "handle" );
2582
				}
2583
				if ( handle ) handle.elem = null;
2583
			}
2584
				jQuery.removeData( elem, "events" );
2584
		} else {
2585
				jQuery.removeData( elem, "handle" );
2585
			for ( var i = 0; checkSet[i] != null; i++ ) {
2586
			}
2586
				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
2587
		}
2587
					results.push( set[i] );
2588
	},
2588
				}
2589
2589
			}
2590
	// bubbling is internal
2590
		}
2591
	trigger: function( event, data, elem, bubbling ) {
2591
	} else {
2592
		// Event object or event type
2592
		makeArray( checkSet, results );
2593
		var type = event.type || event;
2593
	}
2594
2594
2595
		if( !bubbling ){
2595
	if ( extra ) {
2596
			event = typeof event === "object" ?
2596
		Sizzle( extra, origContext, results, seed );
2597
				// jQuery.Event object
2597
		Sizzle.uniqueSort( results );
2598
				event[expando] ? event :
2598
	}
2599
				// Object literal
2599
2600
				jQuery.extend( jQuery.Event(type), event ) :
2600
	return results;
2601
				// Just the event type (string)
2601
};
2602
				jQuery.Event(type);
2602
2603
2603
Sizzle.uniqueSort = function(results){
2604
			if ( type.indexOf("!") >= 0 ) {
2604
	if ( sortOrder ) {
2605
				event.type = type = type.slice(0, -1);
2605
		hasDuplicate = baseHasDuplicate;
2606
				event.exclusive = true;
2606
		results.sort(sortOrder);
2607
			}
2607
2608
2608
		if ( hasDuplicate ) {
2609
			// Handle a global trigger
2609
			for ( var i = 1; i < results.length; i++ ) {
2610
			if ( !elem ) {
2610
				if ( results[i] === results[i-1] ) {
2611
				// Don't bubble custom events when global (to avoid too much overhead)
2611
					results.splice(i--, 1);
2612
				event.stopPropagation();
2612
				}
2613
				// Only trigger if we've ever bound an event for it
2613
			}
2614
				if ( this.global[type] )
2614
		}
2615
					jQuery.each( jQuery.cache, function(){
2615
	}
2616
						if ( this.events && this.events[type] )
2616
2617
							jQuery.event.trigger( event, data, this.handle.elem );
2617
	return results;
2618
					});
2618
};
2619
			}
2619
2620
2620
Sizzle.matches = function(expr, set){
2621
			// Handle triggering a single element
2621
	return Sizzle(expr, null, null, set);
2622
2622
};
2623
			// don't do events on text and comment nodes
2623
2624
			if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 )
2624
Sizzle.find = function(expr, context, isXML){
2625
				return undefined;
2625
	var set, match;
2626
2626
2627
			// Clean up in case it is reused
2627
	if ( !expr ) {
2628
			event.result = undefined;
2628
		return [];
2629
			event.target = elem;
2629
	}
2630
2630
2631
			// Clone the incoming data, if any
2631
	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
2632
			data = jQuery.makeArray(data);
2632
		var type = Expr.order[i], match;
2633
			data.unshift( event );
2633
		
2634
		}
2634
		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
2635
2635
			var left = match[1];
2636
		event.currentTarget = elem;
2636
			match.splice(1,1);
2637
2637
2638
		// Trigger the event, it is assumed that "handle" is a function
2638
			if ( left.substr( left.length - 1 ) !== "\\" ) {
2639
		var handle = jQuery.data(elem, "handle");
2639
				match[1] = (match[1] || "").replace(/\\/g, "");
2640
		if ( handle )
2640
				set = Expr.find[ type ]( match, context, isXML );
2641
			handle.apply( elem, data );
2641
				if ( set != null ) {
2642
2642
					expr = expr.replace( Expr.match[ type ], "" );
2643
		// Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2643
					break;
2644
		if ( (!elem[type] || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2644
				}
2645
			event.result = false;
2645
			}
2646
2646
		}
2647
		// Trigger the native events (except for clicks on links)
2647
	}
2648
		if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2648
2649
			this.triggered = true;
2649
	if ( !set ) {
2650
			try {
2650
		set = context.getElementsByTagName("*");
2651
				elem[ type ]();
2651
	}
2652
			// prevent IE from throwing an error for some hidden elements
2652
2653
			} catch (e) {}
2653
	return {set: set, expr: expr};
2654
		}
2654
};
2655
2655
2656
		this.triggered = false;
2656
Sizzle.filter = function(expr, set, inplace, not){
2657
2657
	var old = expr, result = [], curLoop = set, match, anyFound,
2658
		if ( !event.isPropagationStopped() ) {
2658
		isXMLFilter = set && set[0] && isXML(set[0]);
2659
			var parent = elem.parentNode || elem.ownerDocument;
2659
2660
			if ( parent )
2660
	while ( expr && set.length ) {
2661
				jQuery.event.trigger(event, data, parent, true);
2661
		for ( var type in Expr.filter ) {
2662
		}
2662
			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
2663
	},
2663
				var filter = Expr.filter[ type ], found, item, left = match[1];
2664
2664
				anyFound = false;
2665
	handle: function(event) {
2665
2666
		// returned undefined or false
2666
				match.splice(1,1);
2667
		var all, handlers;
2667
2668
2668
				if ( left.substr( left.length - 1 ) === "\\" ) {
2669
		event = arguments[0] = jQuery.event.fix( event || window.event );
2669
					continue;
2670
		event.currentTarget = this;
2670
				}
2671
2671
2672
		// Namespaced event handlers
2672
				if ( curLoop === result ) {
2673
		var namespaces = event.type.split(".");
2673
					result = [];
2674
		event.type = namespaces.shift();
2674
				}
2675
2675
2676
		// Cache this now, all = true means, any handler
2676
				if ( Expr.preFilter[ type ] ) {
2677
		all = !namespaces.length && !event.exclusive;
2677
					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
2678
2678
2679
		var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
2679
					if ( !match ) {
2680
2680
						anyFound = found = true;
2681
		handlers = ( jQuery.data(this, "events") || {} )[event.type];
2681
					} else if ( match === true ) {
2682
2682
						continue;
2683
		for ( var j in handlers ) {
2683
					}
2684
			var handler = handlers[j];
2684
				}
2685
2685
2686
			// Filter the functions by class
2686
				if ( match ) {
2687
			if ( all || namespace.test(handler.type) ) {
2687
					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
2688
				// Pass in a reference to the handler function itself
2688
						if ( item ) {
2689
				// So that we can later remove it
2689
							found = filter( item, match, i, curLoop );
2690
				event.handler = handler;
2690
							var pass = not ^ !!found;
2691
				event.data = handler.data;
2691
2692
2692
							if ( inplace && found != null ) {
2693
				var ret = handler.apply(this, arguments);
2693
								if ( pass ) {
2694
2694
									anyFound = true;
2695
				if( ret !== undefined ){
2695
								} else {
2696
					event.result = ret;
2696
									curLoop[i] = false;
2697
					if ( ret === false ) {
2697
								}
2698
						event.preventDefault();
2698
							} else if ( pass ) {
2699
						event.stopPropagation();
2699
								result.push( item );
2700
					}
2700
								anyFound = true;
2701
				}
2701
							}
2702
2702
						}
2703
				if( event.isImmediatePropagationStopped() )
2703
					}
2704
					break;
2704
				}
2705
2705
2706
			}
2706
				if ( found !== undefined ) {
2707
		}
2707
					if ( !inplace ) {
2708
	},
2708
						curLoop = result;
2709
2709
					}
2710
	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2710
2711
2711
					expr = expr.replace( Expr.match[ type ], "" );
2712
	fix: function(event) {
2712
2713
		if ( event[expando] )
2713
					if ( !anyFound ) {
2714
			return event;
2714
						return [];
2715
2715
					}
2716
		// store a copy of the original event object
2716
2717
		// and "clone" to set read-only properties
2717
					break;
2718
		var originalEvent = event;
2718
				}
2719
		event = jQuery.Event( originalEvent );
2719
			}
2720
2720
		}
2721
		for ( var i = this.props.length, prop; i; ){
2721
2722
			prop = this.props[ --i ];
2722
		// Improper expression
2723
			event[ prop ] = originalEvent[ prop ];
2723
		if ( expr === old ) {
2724
		}
2724
			if ( anyFound == null ) {
2725
2725
				throw "Syntax error, unrecognized expression: " + expr;
2726
		// Fix target property, if necessary
2726
			} else {
2727
		if ( !event.target )
2727
				break;
2728
			event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2728
			}
2729
2729
		}
2730
		// check if target is a textnode (safari)
2730
2731
		if ( event.target.nodeType == 3 )
2731
		old = expr;
2732
			event.target = event.target.parentNode;
2732
	}
2733
2733
2734
		// Add relatedTarget, if necessary
2734
	return curLoop;
2735
		if ( !event.relatedTarget && event.fromElement )
2735
};
2736
			event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2736
2737
2737
var Expr = Sizzle.selectors = {
2738
		// Calculate pageX/Y if missing and clientX/Y available
2738
	order: [ "ID", "NAME", "TAG" ],
2739
		if ( event.pageX == null && event.clientX != null ) {
2739
	match: {
2740
			var doc = document.documentElement, body = document.body;
2740
		ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2741
			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2741
		CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2742
			event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2742
		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
2743
		}
2743
		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
2744
2744
		TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
2745
		// Add which for key events
2745
		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
2746
		if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2746
		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
2747
			event.which = event.charCode || event.keyCode;
2747
		PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
2748
2748
	},
2749
		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2749
	leftMatch: {},
2750
		if ( !event.metaKey && event.ctrlKey )
2750
	attrMap: {
2751
			event.metaKey = event.ctrlKey;
2751
		"class": "className",
2752
2752
		"for": "htmlFor"
2753
		// Add which for click: 1 == left; 2 == middle; 3 == right
2753
	},
2754
		// Note: button is not normalized, so don't use it
2754
	attrHandle: {
2755
		if ( !event.which && event.button )
2755
		href: function(elem){
2756
			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2756
			return elem.getAttribute("href");
2757
2757
		}
2758
		return event;
2758
	},
2759
	},
2759
	relative: {
2760
2760
		"+": function(checkSet, part){
2761
	proxy: function( fn, proxy ){
2761
			var isPartStr = typeof part === "string",
2762
		proxy = proxy || function(){ return fn.apply(this, arguments); };
2762
				isTag = isPartStr && !/\W/.test(part),
2763
		// Set the guid of unique handler to the same of original handler, so it can be removed
2763
				isPartStrNotTag = isPartStr && !isTag;
2764
		proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
2764
2765
		// So proxy can be declared as an argument
2765
			if ( isTag ) {
2766
		return proxy;
2766
				part = part.toLowerCase();
2767
	},
2767
			}
2768
2768
2769
	special: {
2769
			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
2770
		ready: {
2770
				if ( (elem = checkSet[i]) ) {
2771
			// Make sure the ready event is setup
2771
					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
2772
			setup: bindReady,
2772
2773
			teardown: function() {}
2773
					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
2774
		}
2774
						elem || false :
2775
	},
2775
						elem === part;
2776
2776
				}
2777
	specialAll: {
2777
			}
2778
		live: {
2778
2779
			setup: function( selector, namespaces ){
2779
			if ( isPartStrNotTag ) {
2780
				jQuery.event.add( this, namespaces[0], liveHandler );
2780
				Sizzle.filter( part, checkSet, true );
2781
			},
2781
			}
2782
			teardown:  function( namespaces ){
2782
		},
2783
				if ( namespaces.length ) {
2783
		">": function(checkSet, part){
2784
					var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
2784
			var isPartStr = typeof part === "string";
2785
2785
2786
					jQuery.each( (jQuery.data(this, "events").live || {}), function(){
2786
			if ( isPartStr && !/\W/.test(part) ) {
2787
						if ( name.test(this.type) )
2787
				part = part.toLowerCase();
2788
							remove++;
2788
2789
					});
2789
				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2790
2790
					var elem = checkSet[i];
2791
					if ( remove < 1 )
2791
					if ( elem ) {
2792
						jQuery.event.remove( this, namespaces[0], liveHandler );
2792
						var parent = elem.parentNode;
2793
				}
2793
						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
2794
			}
2794
					}
2795
		}
2795
				}
2796
	}
2796
			} else {
2797
};
2797
				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2798
2798
					var elem = checkSet[i];
2799
jQuery.Event = function( src ){
2799
					if ( elem ) {
2800
	// Allow instantiation without the 'new' keyword
2800
						checkSet[i] = isPartStr ?
2801
	if( !this.preventDefault )
2801
							elem.parentNode :
2802
		return new jQuery.Event(src);
2802
							elem.parentNode === part;
2803
2803
					}
2804
	// Event object
2804
				}
2805
	if( src && src.type ){
2805
2806
		this.originalEvent = src;
2806
				if ( isPartStr ) {
2807
		this.type = src.type;
2807
					Sizzle.filter( part, checkSet, true );
2808
	// Event type
2808
				}
2809
	}else
2809
			}
2810
		this.type = src;
2810
		},
2811
2811
		"": function(checkSet, part, isXML){
2812
	// timeStamp is buggy for some events on Firefox(#3843)
2812
			var doneName = done++, checkFn = dirCheck;
2813
	// So we won't rely on the native value
2813
2814
	this.timeStamp = now();
2814
			if ( typeof part === "string" && !/\W/.test(part) ) {
2815
2815
				var nodeCheck = part = part.toLowerCase();
2816
	// Mark it as fixed
2816
				checkFn = dirNodeCheck;
2817
	this[expando] = true;
2817
			}
2818
};
2818
2819
2819
			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
2820
function returnFalse(){
2820
		},
2821
	return false;
2821
		"~": function(checkSet, part, isXML){
2822
}
2822
			var doneName = done++, checkFn = dirCheck;
2823
function returnTrue(){
2823
2824
	return true;
2824
			if ( typeof part === "string" && !/\W/.test(part) ) {
2825
}
2825
				var nodeCheck = part = part.toLowerCase();
2826
2826
				checkFn = dirNodeCheck;
2827
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2827
			}
2828
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2828
2829
jQuery.Event.prototype = {
2829
			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
2830
	preventDefault: function() {
2830
		}
2831
		this.isDefaultPrevented = returnTrue;
2831
	},
2832
2832
	find: {
2833
		var e = this.originalEvent;
2833
		ID: function(match, context, isXML){
2834
		if( !e )
2834
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
2835
			return;
2835
				var m = context.getElementById(match[1]);
2836
		// if preventDefault exists run it on the original event
2836
				return m ? [m] : [];
2837
		if (e.preventDefault)
2837
			}
2838
			e.preventDefault();
2838
		},
2839
		// otherwise set the returnValue property of the original event to false (IE)
2839
		NAME: function(match, context){
2840
		e.returnValue = false;
2840
			if ( typeof context.getElementsByName !== "undefined" ) {
2841
	},
2841
				var ret = [], results = context.getElementsByName(match[1]);
2842
	stopPropagation: function() {
2842
2843
		this.isPropagationStopped = returnTrue;
2843
				for ( var i = 0, l = results.length; i < l; i++ ) {
2844
2844
					if ( results[i].getAttribute("name") === match[1] ) {
2845
		var e = this.originalEvent;
2845
						ret.push( results[i] );
2846
		if( !e )
2846
					}
2847
			return;
2847
				}
2848
		// if stopPropagation exists run it on the original event
2848
2849
		if (e.stopPropagation)
2849
				return ret.length === 0 ? null : ret;
2850
			e.stopPropagation();
2850
			}
2851
		// otherwise set the cancelBubble property of the original event to true (IE)
2851
		},
2852
		e.cancelBubble = true;
2852
		TAG: function(match, context){
2853
	},
2853
			return context.getElementsByTagName(match[1]);
2854
	stopImmediatePropagation:function(){
2854
		}
2855
		this.isImmediatePropagationStopped = returnTrue;
2855
	},
2856
		this.stopPropagation();
2856
	preFilter: {
2857
	},
2857
		CLASS: function(match, curLoop, inplace, result, not, isXML){
2858
	isDefaultPrevented: returnFalse,
2858
			match = " " + match[1].replace(/\\/g, "") + " ";
2859
	isPropagationStopped: returnFalse,
2859
2860
	isImmediatePropagationStopped: returnFalse
2860
			if ( isXML ) {
2861
};
2861
				return match;
2862
// Checks if an event happened on an element within another element
2862
			}
2863
// Used in jQuery.event.special.mouseenter and mouseleave handlers
2863
2864
var withinElement = function(event) {
2864
			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
2865
	// Check if mouse(over|out) are still within the same parent element
2865
				if ( elem ) {
2866
	var parent = event.relatedTarget;
2866
					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
2867
	// Traverse up the tree
2867
						if ( !inplace ) {
2868
	while ( parent && parent != this )
2868
							result.push( elem );
2869
		try { parent = parent.parentNode; }
2869
						}
2870
		catch(e) { parent = this; }
2870
					} else if ( inplace ) {
2871
2871
						curLoop[i] = false;
2872
	if( parent != this ){
2872
					}
2873
		// set the correct event type
2873
				}
2874
		event.type = event.data;
2874
			}
2875
		// handle event if we actually just moused on to a non sub-element
2875
2876
		jQuery.event.handle.apply( this, arguments );
2876
			return false;
2877
	}
2877
		},
2878
};
2878
		ID: function(match){
2879
2879
			return match[1].replace(/\\/g, "");
2880
jQuery.each({
2880
		},
2881
	mouseover: 'mouseenter',
2881
		TAG: function(match, curLoop){
2882
	mouseout: 'mouseleave'
2882
			return match[1].toLowerCase();
2883
}, function( orig, fix ){
2883
		},
2884
	jQuery.event.special[ fix ] = {
2884
		CHILD: function(match){
2885
		setup: function(){
2885
			if ( match[1] === "nth" ) {
2886
			jQuery.event.add( this, orig, withinElement, fix );
2886
				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
2887
		},
2887
				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
2888
		teardown: function(){
2888
					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
2889
			jQuery.event.remove( this, orig, withinElement );
2889
					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
2890
		}
2890
2891
	};
2891
				// calculate the numbers (first)n+(last) including if they are negative
2892
});
2892
				match[2] = (test[1] + (test[2] || 1)) - 0;
2893
2893
				match[3] = test[3] - 0;
2894
jQuery.fn.extend({
2894
			}
2895
	bind: function( type, data, fn ) {
2895
2896
		return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2896
			// TODO: Move to normal caching system
2897
			jQuery.event.add( this, type, fn || data, fn && data );
2897
			match[0] = done++;
2898
		});
2898
2899
	},
2899
			return match;
2900
2900
		},
2901
	one: function( type, data, fn ) {
2901
		ATTR: function(match, curLoop, inplace, result, not, isXML){
2902
		var one = jQuery.event.proxy( fn || data, function(event) {
2902
			var name = match[1].replace(/\\/g, "");
2903
			jQuery(this).unbind(event, one);
2903
			
2904
			return (fn || data).apply( this, arguments );
2904
			if ( !isXML && Expr.attrMap[name] ) {
2905
		});
2905
				match[1] = Expr.attrMap[name];
2906
		return this.each(function(){
2906
			}
2907
			jQuery.event.add( this, type, one, fn && data);
2907
2908
		});
2908
			if ( match[2] === "~=" ) {
2909
	},
2909
				match[4] = " " + match[4] + " ";
2910
2910
			}
2911
	unbind: function( type, fn ) {
2911
2912
		return this.each(function(){
2912
			return match;
2913
			jQuery.event.remove( this, type, fn );
2913
		},
2914
		});
2914
		PSEUDO: function(match, curLoop, inplace, result, not){
2915
	},
2915
			if ( match[1] === "not" ) {
2916
2916
				// If we're dealing with a complex expression, or a simple one
2917
	trigger: function( type, data ) {
2917
				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
2918
		return this.each(function(){
2918
					match[3] = Sizzle(match[3], null, null, curLoop);
2919
			jQuery.event.trigger( type, data, this );
2919
				} else {
2920
		});
2920
					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
2921
	},
2921
					if ( !inplace ) {
2922
2922
						result.push.apply( result, ret );
2923
	triggerHandler: function( type, data ) {
2923
					}
2924
		if( this[0] ){
2924
					return false;
2925
			var event = jQuery.Event(type);
2925
				}
2926
			event.preventDefault();
2926
			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
2927
			event.stopPropagation();
2927
				return true;
2928
			jQuery.event.trigger( event, data, this[0] );
2928
			}
2929
			return event.result;
2929
			
2930
		}
2930
			return match;
2931
	},
2931
		},
2932
2932
		POS: function(match){
2933
	toggle: function( fn ) {
2933
			match.unshift( true );
2934
		// Save reference to arguments for access in closure
2934
			return match;
2935
		var args = arguments, i = 1;
2935
		}
2936
2936
	},
2937
		// link all the functions, so any of them can unbind this click handler
2937
	filters: {
2938
		while( i < args.length )
2938
		enabled: function(elem){
2939
			jQuery.event.proxy( fn, args[i++] );
2939
			return elem.disabled === false && elem.type !== "hidden";
2940
2940
		},
2941
		return this.click( jQuery.event.proxy( fn, function(event) {
2941
		disabled: function(elem){
2942
			// Figure out which function to execute
2942
			return elem.disabled === true;
2943
			this.lastToggle = ( this.lastToggle || 0 ) % i;
2943
		},
2944
2944
		checked: function(elem){
2945
			// Make sure that clicks stop
2945
			return elem.checked === true;
2946
			event.preventDefault();
2946
		},
2947
2947
		selected: function(elem){
2948
			// and execute the function
2948
			// Accessing this property makes selected-by-default
2949
			return args[ this.lastToggle++ ].apply( this, arguments ) || false;
2949
			// options in Safari work properly
2950
		}));
2950
			elem.parentNode.selectedIndex;
2951
	},
2951
			return elem.selected === true;
2952
2952
		},
2953
	hover: function(fnOver, fnOut) {
2953
		parent: function(elem){
2954
		return this.mouseenter(fnOver).mouseleave(fnOut);
2954
			return !!elem.firstChild;
2955
	},
2955
		},
2956
2956
		empty: function(elem){
2957
	ready: function(fn) {
2957
			return !elem.firstChild;
2958
		// Attach the listeners
2958
		},
2959
		bindReady();
2959
		has: function(elem, i, match){
2960
2960
			return !!Sizzle( match[3], elem ).length;
2961
		// If the DOM is already ready
2961
		},
2962
		if ( jQuery.isReady )
2962
		header: function(elem){
2963
			// Execute the function immediately
2963
			return /h\d/i.test( elem.nodeName );
2964
			fn.call( document, jQuery );
2964
		},
2965
2965
		text: function(elem){
2966
		// Otherwise, remember the function for later
2966
			return "text" === elem.type;
2967
		else
2967
		},
2968
			// Add the function to the wait list
2968
		radio: function(elem){
2969
			jQuery.readyList.push( fn );
2969
			return "radio" === elem.type;
2970
2970
		},
2971
		return this;
2971
		checkbox: function(elem){
2972
	},
2972
			return "checkbox" === elem.type;
2973
2973
		},
2974
	live: function( type, fn ){
2974
		file: function(elem){
2975
		var proxy = jQuery.event.proxy( fn );
2975
			return "file" === elem.type;
2976
		proxy.guid += this.selector + type;
2976
		},
2977
2977
		password: function(elem){
2978
		jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy );
2978
			return "password" === elem.type;
2979
2979
		},
2980
		return this;
2980
		submit: function(elem){
2981
	},
2981
			return "submit" === elem.type;
2982
2982
		},
2983
	die: function( type, fn ){
2983
		image: function(elem){
2984
		jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null );
2984
			return "image" === elem.type;
2985
		return this;
2985
		},
2986
	}
2986
		reset: function(elem){
2987
});
2987
			return "reset" === elem.type;
2988
2988
		},
2989
function liveHandler( event ){
2989
		button: function(elem){
2990
	var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"),
2990
			return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
2991
		stop = true,
2991
		},
2992
		elems = [];
2992
		input: function(elem){
2993
2993
			return /input|select|textarea|button/i.test(elem.nodeName);
2994
	jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){
2994
		}
2995
		if ( check.test(fn.type) ) {
2995
	},
2996
			var elem = jQuery(event.target).closest(fn.data)[0];
2996
	setFilters: {
2997
			if ( elem )
2997
		first: function(elem, i){
2998
				elems.push({ elem: elem, fn: fn });
2998
			return i === 0;
2999
		}
2999
		},
3000
	});
3000
		last: function(elem, i, match, array){
3001
3001
			return i === array.length - 1;
3002
	elems.sort(function(a,b) {
3002
		},
3003
		return jQuery.data(a.elem, "closest") - jQuery.data(b.elem, "closest");
3003
		even: function(elem, i){
3004
	});
3004
			return i % 2 === 0;
3005
3005
		},
3006
	jQuery.each(elems, function(){
3006
		odd: function(elem, i){
3007
		if ( this.fn.call(this.elem, event, this.fn.data) === false )
3007
			return i % 2 === 1;
3008
			return (stop = false);
3008
		},
3009
	});
3009
		lt: function(elem, i, match){
3010
3010
			return i < match[3] - 0;
3011
	return stop;
3011
		},
3012
}
3012
		gt: function(elem, i, match){
3013
3013
			return i > match[3] - 0;
3014
function liveConvert(type, selector){
3014
		},
3015
	return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "|")].join(".");
3015
		nth: function(elem, i, match){
3016
}
3016
			return match[3] - 0 === i;
3017
3017
		},
3018
jQuery.extend({
3018
		eq: function(elem, i, match){
3019
	isReady: false,
3019
			return match[3] - 0 === i;
3020
	readyList: [],
3020
		}
3021
	// Handle when the DOM is ready
3021
	},
3022
	ready: function() {
3022
	filter: {
3023
		// Make sure that the DOM is not already loaded
3023
		PSEUDO: function(elem, match, i, array){
3024
		if ( !jQuery.isReady ) {
3024
			var name = match[1], filter = Expr.filters[ name ];
3025
			// Remember that the DOM is ready
3025
3026
			jQuery.isReady = true;
3026
			if ( filter ) {
3027
3027
				return filter( elem, i, match, array );
3028
			// If there are functions bound, to execute
3028
			} else if ( name === "contains" ) {
3029
			if ( jQuery.readyList ) {
3029
				return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
3030
				// Execute all of them
3030
			} else if ( name === "not" ) {
3031
				jQuery.each( jQuery.readyList, function(){
3031
				var not = match[3];
3032
					this.call( document, jQuery );
3032
3033
				});
3033
				for ( var i = 0, l = not.length; i < l; i++ ) {
3034
3034
					if ( not[i] === elem ) {
3035
				// Reset the list of functions
3035
						return false;
3036
				jQuery.readyList = null;
3036
					}
3037
			}
3037
				}
3038
3038
3039
			// Trigger any bound ready events
3039
				return true;
3040
			jQuery(document).triggerHandler("ready");
3040
			} else {
3041
		}
3041
				throw "Syntax error, unrecognized expression: " + name;
3042
	}
3042
			}
3043
});
3043
		},
3044
3044
		CHILD: function(elem, match){
3045
var readyBound = false;
3045
			var type = match[1], node = elem;
3046
3046
			switch (type) {
3047
function bindReady(){
3047
				case 'only':
3048
	if ( readyBound ) return;
3048
				case 'first':
3049
	readyBound = true;
3049
					while ( (node = node.previousSibling) )	 {
3050
3050
						if ( node.nodeType === 1 ) { 
3051
	// Mozilla, Opera and webkit nightlies currently support this event
3051
							return false; 
3052
	if ( document.addEventListener ) {
3052
						}
3053
		// Use the handy event callback
3053
					}
3054
		document.addEventListener( "DOMContentLoaded", function(){
3054
					if ( type === "first" ) { 
3055
			document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
3055
						return true; 
3056
			jQuery.ready();
3056
					}
3057
		}, false );
3057
					node = elem;
3058
3058
				case 'last':
3059
	// If IE event model is used
3059
					while ( (node = node.nextSibling) )	 {
3060
	} else if ( document.attachEvent ) {
3060
						if ( node.nodeType === 1 ) { 
3061
		// ensure firing before onload,
3061
							return false; 
3062
		// maybe late but safe also for iframes
3062
						}
3063
		document.attachEvent("onreadystatechange", function(){
3063
					}
3064
			if ( document.readyState === "complete" ) {
3064
					return true;
3065
				document.detachEvent( "onreadystatechange", arguments.callee );
3065
				case 'nth':
3066
				jQuery.ready();
3066
					var first = match[2], last = match[3];
3067
			}
3067
3068
		});
3068
					if ( first === 1 && last === 0 ) {
3069
3069
						return true;
3070
		// If IE and not an iframe
3070
					}
3071
		// continually check to see if the document is ready
3071
					
3072
		if ( document.documentElement.doScroll && window == window.top ) (function(){
3072
					var doneName = match[0],
3073
			if ( jQuery.isReady ) return;
3073
						parent = elem.parentNode;
3074
3074
	
3075
			try {
3075
					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3076
				// If IE is used, use the trick by Diego Perini
3076
						var count = 0;
3077
				// http://javascript.nwbox.com/IEContentLoaded/
3077
						for ( node = parent.firstChild; node; node = node.nextSibling ) {
3078
				document.documentElement.doScroll("left");
3078
							if ( node.nodeType === 1 ) {
3079
			} catch( error ) {
3079
								node.nodeIndex = ++count;
3080
				setTimeout( arguments.callee, 0 );
3080
							}
3081
				return;
3081
						} 
3082
			}
3082
						parent.sizcache = doneName;
3083
3083
					}
3084
			// and execute any waiting functions
3084
					
3085
			jQuery.ready();
3085
					var diff = elem.nodeIndex - last;
3086
		})();
3086
					if ( first === 0 ) {
3087
	}
3087
						return diff === 0;
3088
3088
					} else {
3089
	// A fallback to window.onload, that will always work
3089
						return ( diff % first === 0 && diff / first >= 0 );
3090
	jQuery.event.add( window, "load", jQuery.ready );
3090
					}
3091
}
3091
			}
3092
3092
		},
3093
jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
3093
		ID: function(elem, match){
3094
	"mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave," +
3094
			return elem.nodeType === 1 && elem.getAttribute("id") === match;
3095
	"change,select,submit,keydown,keypress,keyup,error").split(","), function(i, name){
3095
		},
3096
3096
		TAG: function(elem, match){
3097
	// Handle event binding
3097
			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3098
	jQuery.fn[name] = function(fn){
3098
		},
3099
		return fn ? this.bind(name, fn) : this.trigger(name);
3099
		CLASS: function(elem, match){
3100
	};
3100
			return (" " + (elem.className || elem.getAttribute("class")) + " ")
3101
});
3101
				.indexOf( match ) > -1;
3102
3102
		},
3103
// Prevent memory leaks in IE
3103
		ATTR: function(elem, match){
3104
// And prevent errors on refresh with events like mouseover in other browsers
3104
			var name = match[1],
3105
// Window isn't included so as not to unbind existing unload events
3105
				result = Expr.attrHandle[ name ] ?
3106
jQuery( window ).bind( 'unload', function(){
3106
					Expr.attrHandle[ name ]( elem ) :
3107
	for ( var id in jQuery.cache )
3107
					elem[ name ] != null ?
3108
		// Skip the window
3108
						elem[ name ] :
3109
		if ( id != 1 && jQuery.cache[ id ].handle )
3109
						elem.getAttribute( name ),
3110
			jQuery.event.remove( jQuery.cache[ id ].handle.elem );
3110
				value = result + "",
3111
});
3111
				type = match[2],
3112
(function(){
3112
				check = match[4];
3113
3113
3114
	jQuery.support = {};
3114
			return result == null ?
3115
3115
				type === "!=" :
3116
	var root = document.documentElement,
3116
				type === "=" ?
3117
		script = document.createElement("script"),
3117
				value === check :
3118
		div = document.createElement("div"),
3118
				type === "*=" ?
3119
		id = "script" + (new Date).getTime();
3119
				value.indexOf(check) >= 0 :
3120
3120
				type === "~=" ?
3121
	div.style.display = "none";
3121
				(" " + value + " ").indexOf(check) >= 0 :
3122
	div.innerHTML = '   <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param/></object>';
3122
				!check ?
3123
3123
				value && result !== false :
3124
	var all = div.getElementsByTagName("*"),
3124
				type === "!=" ?
3125
		a = div.getElementsByTagName("a")[0];
3125
				value !== check :
3126
3126
				type === "^=" ?
3127
	// Can't get basic test support
3127
				value.indexOf(check) === 0 :
3128
	if ( !all || !all.length || !a ) {
3128
				type === "$=" ?
3129
		return;
3129
				value.substr(value.length - check.length) === check :
3130
	}
3130
				type === "|=" ?
3131
3131
				value === check || value.substr(0, check.length + 1) === check + "-" :
3132
	jQuery.support = {
3132
				false;
3133
		// IE strips leading whitespace when .innerHTML is used
3133
		},
3134
		leadingWhitespace: div.firstChild.nodeType == 3,
3134
		POS: function(elem, match, i, array){
3135
3135
			var name = match[2], filter = Expr.setFilters[ name ];
3136
		// Make sure that tbody elements aren't automatically inserted
3136
3137
		// IE will insert them into empty tables
3137
			if ( filter ) {
3138
		tbody: !div.getElementsByTagName("tbody").length,
3138
				return filter( elem, i, match, array );
3139
3139
			}
3140
		// Make sure that you can get all elements in an <object> element
3140
		}
3141
		// IE 7 always returns no results
3141
	}
3142
		objectAll: !!div.getElementsByTagName("object")[0]
3142
};
3143
			.getElementsByTagName("*").length,
3143
3144
3144
var origPOS = Expr.match.POS;
3145
		// Make sure that link elements get serialized correctly by innerHTML
3145
3146
		// This requires a wrapper element in IE
3146
for ( var type in Expr.match ) {
3147
		htmlSerialize: !!div.getElementsByTagName("link").length,
3147
	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
3148
3148
	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, function(all, num){
3149
		// Get the style information from getAttribute
3149
		return "\\" + (num - 0 + 1);
3150
		// (IE uses .cssText insted)
3150
	}));
3151
		style: /red/.test( a.getAttribute("style") ),
3151
}
3152
3152
3153
		// Make sure that URLs aren't manipulated
3153
var makeArray = function(array, results) {
3154
		// (IE normalizes it by default)
3154
	array = Array.prototype.slice.call( array, 0 );
3155
		hrefNormalized: a.getAttribute("href") === "/a",
3155
3156
3156
	if ( results ) {
3157
		// Make sure that element opacity exists
3157
		results.push.apply( results, array );
3158
		// (IE uses filter instead)
3158
		return results;
3159
		opacity: a.style.opacity === "0.5",
3159
	}
3160
3160
	
3161
		// Verify style float existence
3161
	return array;
3162
		// (IE uses styleFloat instead of cssFloat)
3162
};
3163
		cssFloat: !!a.style.cssFloat,
3163
3164
3164
// Perform a simple check to determine if the browser is capable of
3165
		// Will be defined later
3165
// converting a NodeList to an array using builtin methods.
3166
		scriptEval: false,
3166
try {
3167
		noCloneEvent: true,
3167
	Array.prototype.slice.call( document.documentElement.childNodes, 0 );
3168
		boxModel: null
3168
3169
	};
3169
// Provide a fallback method if it does not work
3170
3170
} catch(e){
3171
	script.type = "text/javascript";
3171
	makeArray = function(array, results) {
3172
	try {
3172
		var ret = results || [];
3173
		script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
3173
3174
	} catch(e){}
3174
		if ( toString.call(array) === "[object Array]" ) {
3175
3175
			Array.prototype.push.apply( ret, array );
3176
	root.insertBefore( script, root.firstChild );
3176
		} else {
3177
3177
			if ( typeof array.length === "number" ) {
3178
	// Make sure that the execution of code works by injecting a script
3178
				for ( var i = 0, l = array.length; i < l; i++ ) {
3179
	// tag with appendChild/createTextNode
3179
					ret.push( array[i] );
3180
	// (IE doesn't support this, fails, and uses .text instead)
3180
				}
3181
	if ( window[ id ] ) {
3181
			} else {
3182
		jQuery.support.scriptEval = true;
3182
				for ( var i = 0; array[i]; i++ ) {
3183
		delete window[ id ];
3183
					ret.push( array[i] );
3184
	}
3184
				}
3185
3185
			}
3186
	root.removeChild( script );
3186
		}
3187
3187
3188
	if ( div.attachEvent && div.fireEvent ) {
3188
		return ret;
3189
		div.attachEvent("onclick", function(){
3189
	};
3190
			// Cloning a node shouldn't copy over any
3190
}
3191
			// bound event handlers (IE does this)
3191
3192
			jQuery.support.noCloneEvent = false;
3192
var sortOrder;
3193
			div.detachEvent("onclick", arguments.callee);
3193
3194
		});
3194
if ( document.documentElement.compareDocumentPosition ) {
3195
		div.cloneNode(true).fireEvent("onclick");
3195
	sortOrder = function( a, b ) {
3196
	}
3196
		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
3197
3197
			if ( a == b ) {
3198
	// Figure out if the W3C box model works as expected
3198
				hasDuplicate = true;
3199
	// document.body must exist before we can do this
3199
			}
3200
	jQuery(function(){
3200
			return a.compareDocumentPosition ? -1 : 1;
3201
		var div = document.createElement("div");
3201
		}
3202
		div.style.width = div.style.paddingLeft = "1px";
3202
3203
3203
		var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
3204
		document.body.appendChild( div );
3204
		if ( ret === 0 ) {
3205
		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
3205
			hasDuplicate = true;
3206
		document.body.removeChild( div ).style.display = 'none';
3206
		}
3207
	});
3207
		return ret;
3208
})();
3208
	};
3209
3209
} else if ( "sourceIndex" in document.documentElement ) {
3210
var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat";
3210
	sortOrder = function( a, b ) {
3211
3211
		if ( !a.sourceIndex || !b.sourceIndex ) {
3212
jQuery.props = {
3212
			if ( a == b ) {
3213
	"for": "htmlFor",
3213
				hasDuplicate = true;
3214
	"class": "className",
3214
			}
3215
	"float": styleFloat,
3215
			return a.sourceIndex ? -1 : 1;
3216
	cssFloat: styleFloat,
3216
		}
3217
	styleFloat: styleFloat,
3217
3218
	readonly: "readOnly",
3218
		var ret = a.sourceIndex - b.sourceIndex;
3219
	maxlength: "maxLength",
3219
		if ( ret === 0 ) {
3220
	cellspacing: "cellSpacing",
3220
			hasDuplicate = true;
3221
	rowspan: "rowSpan",
3221
		}
3222
	tabindex: "tabIndex"
3222
		return ret;
3223
};
3223
	};
3224
jQuery.fn.extend({
3224
} else if ( document.createRange ) {
3225
	// Keep a copy of the old load
3225
	sortOrder = function( a, b ) {
3226
	_load: jQuery.fn.load,
3226
		if ( !a.ownerDocument || !b.ownerDocument ) {
3227
3227
			if ( a == b ) {
3228
	load: function( url, params, callback ) {
3228
				hasDuplicate = true;
3229
		if ( typeof url !== "string" )
3229
			}
3230
			return this._load( url );
3230
			return a.ownerDocument ? -1 : 1;
3231
3231
		}
3232
		var off = url.indexOf(" ");
3232
3233
		if ( off >= 0 ) {
3233
		var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
3234
			var selector = url.slice(off, url.length);
3234
		aRange.setStart(a, 0);
3235
			url = url.slice(0, off);
3235
		aRange.setEnd(a, 0);
3236
		}
3236
		bRange.setStart(b, 0);
3237
3237
		bRange.setEnd(b, 0);
3238
		// Default to a GET request
3238
		var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
3239
		var type = "GET";
3239
		if ( ret === 0 ) {
3240
3240
			hasDuplicate = true;
3241
		// If the second parameter was provided
3241
		}
3242
		if ( params )
3242
		return ret;
3243
			// If it's a function
3243
	};
3244
			if ( jQuery.isFunction( params ) ) {
3244
}
3245
				// We assume that it's the callback
3245
3246
				callback = params;
3246
// Utility function for retreiving the text value of an array of DOM nodes
3247
				params = null;
3247
function getText( elems ) {
3248
3248
	var ret = "", elem;
3249
			// Otherwise, build a param string
3249
3250
			} else if( typeof params === "object" ) {
3250
	for ( var i = 0; elems[i]; i++ ) {
3251
				params = jQuery.param( params );
3251
		elem = elems[i];
3252
				type = "POST";
3252
3253
			}
3253
		// Get the text from text nodes and CDATA nodes
3254
3254
		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
3255
		var self = this;
3255
			ret += elem.nodeValue;
3256
3256
3257
		// Request the remote document
3257
		// Traverse everything else, except comment nodes
3258
		jQuery.ajax({
3258
		} else if ( elem.nodeType !== 8 ) {
3259
			url: url,
3259
			ret += getText( elem.childNodes );
3260
			type: type,
3260
		}
3261
			dataType: "html",
3261
	}
3262
			data: params,
3262
3263
			complete: function(res, status){
3263
	return ret;
3264
				// If successful, inject the HTML into all the matched elements
3264
}
3265
				if ( status == "success" || status == "notmodified" )
3265
3266
					// See if a selector was specified
3266
// Check to see if the browser returns elements by name when
3267
					self.html( selector ?
3267
// querying by getElementById (and provide a workaround)
3268
						// Create a dummy div to hold the results
3268
(function(){
3269
						jQuery("<div/>")
3269
	// We're going to inject a fake input element with a specified name
3270
							// inject the contents of the document in, removing the scripts
3270
	var form = document.createElement("div"),
3271
							// to avoid any 'Permission Denied' errors in IE
3271
		id = "script" + (new Date).getTime();
3272
							.append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
3272
	form.innerHTML = "<a name='" + id + "'/>";
3273
3273
3274
							// Locate the specified elements
3274
	// Inject it into the root element, check its status, and remove it quickly
3275
							.find(selector) :
3275
	var root = document.documentElement;
3276
3276
	root.insertBefore( form, root.firstChild );
3277
						// If not, just inject the full result
3277
3278
						res.responseText );
3278
	// The workaround has to do additional checks after a getElementById
3279
3279
	// Which slows things down for other browsers (hence the branching)
3280
				if( callback )
3280
	if ( document.getElementById( id ) ) {
3281
					self.each( callback, [res.responseText, status, res] );
3281
		Expr.find.ID = function(match, context, isXML){
3282
			}
3282
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
3283
		});
3283
				var m = context.getElementById(match[1]);
3284
		return this;
3284
				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
3285
	},
3285
			}
3286
3286
		};
3287
	serialize: function() {
3287
3288
		return jQuery.param(this.serializeArray());
3288
		Expr.filter.ID = function(elem, match){
3289
	},
3289
			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
3290
	serializeArray: function() {
3290
			return elem.nodeType === 1 && node && node.nodeValue === match;
3291
		return this.map(function(){
3291
		};
3292
			return this.elements ? jQuery.makeArray(this.elements) : this;
3292
	}
3293
		})
3293
3294
		.filter(function(){
3294
	root.removeChild( form );
3295
			return this.name && !this.disabled &&
3295
	root = form = null; // release memory in IE
3296
				(this.checked || /select|textarea/i.test(this.nodeName) ||
3296
})();
3297
					/text|hidden|password|search/i.test(this.type));
3297
3298
		})
3298
(function(){
3299
		.map(function(i, elem){
3299
	// Check to see if the browser returns only elements
3300
			var val = jQuery(this).val();
3300
	// when doing getElementsByTagName("*")
3301
			return val == null ? null :
3301
3302
				jQuery.isArray(val) ?
3302
	// Create a fake element
3303
					jQuery.map( val, function(val, i){
3303
	var div = document.createElement("div");
3304
						return {name: elem.name, value: val};
3304
	div.appendChild( document.createComment("") );
3305
					}) :
3305
3306
					{name: elem.name, value: val};
3306
	// Make sure no comments are found
3307
		}).get();
3307
	if ( div.getElementsByTagName("*").length > 0 ) {
3308
	}
3308
		Expr.find.TAG = function(match, context){
3309
});
3309
			var results = context.getElementsByTagName(match[1]);
3310
3310
3311
// Attach a bunch of functions for handling common AJAX events
3311
			// Filter out possible comments
3312
jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
3312
			if ( match[1] === "*" ) {
3313
	jQuery.fn[o] = function(f){
3313
				var tmp = [];
3314
		return this.bind(o, f);
3314
3315
	};
3315
				for ( var i = 0; results[i]; i++ ) {
3316
});
3316
					if ( results[i].nodeType === 1 ) {
3317
3317
						tmp.push( results[i] );
3318
var jsc = now();
3318
					}
3319
3319
				}
3320
jQuery.extend({
3320
3321
3321
				results = tmp;
3322
	get: function( url, data, callback, type ) {
3322
			}
3323
		// shift arguments if data argument was ommited
3323
3324
		if ( jQuery.isFunction( data ) ) {
3324
			return results;
3325
			callback = data;
3325
		};
3326
			data = null;
3326
	}
3327
		}
3327
3328
3328
	// Check to see if an attribute returns normalized href attributes
3329
		return jQuery.ajax({
3329
	div.innerHTML = "<a href='#'></a>";
3330
			type: "GET",
3330
	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
3331
			url: url,
3331
			div.firstChild.getAttribute("href") !== "#" ) {
3332
			data: data,
3332
		Expr.attrHandle.href = function(elem){
3333
			success: callback,
3333
			return elem.getAttribute("href", 2);
3334
			dataType: type
3334
		};
3335
		});
3335
	}
3336
	},
3336
3337
3337
	div = null; // release memory in IE
3338
	getScript: function( url, callback ) {
3338
})();
3339
		return jQuery.get(url, null, callback, "script");
3339
3340
	},
3340
if ( document.querySelectorAll ) {
3341
3341
	(function(){
3342
	getJSON: function( url, data, callback ) {
3342
		var oldSizzle = Sizzle, div = document.createElement("div");
3343
		return jQuery.get(url, data, callback, "json");
3343
		div.innerHTML = "<p class='TEST'></p>";
3344
	},
3344
3345
3345
		// Safari can't handle uppercase or unicode characters when
3346
	post: function( url, data, callback, type ) {
3346
		// in quirks mode.
3347
		if ( jQuery.isFunction( data ) ) {
3347
		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
3348
			callback = data;
3348
			return;
3349
			data = {};
3349
		}
3350
		}
3350
	
3351
3351
		Sizzle = function(query, context, extra, seed){
3352
		return jQuery.ajax({
3352
			context = context || document;
3353
			type: "POST",
3353
3354
			url: url,
3354
			// Only use querySelectorAll on non-XML documents
3355
			data: data,
3355
			// (ID selectors don't work in non-HTML documents)
3356
			success: callback,
3356
			if ( !seed && context.nodeType === 9 && !isXML(context) ) {
3357
			dataType: type
3357
				try {
3358
		});
3358
					return makeArray( context.querySelectorAll(query), extra );
3359
	},
3359
				} catch(e){}
3360
3360
			}
3361
	ajaxSetup: function( settings ) {
3361
		
3362
		jQuery.extend( jQuery.ajaxSettings, settings );
3362
			return oldSizzle(query, context, extra, seed);
3363
	},
3363
		};
3364
3364
3365
	ajaxSettings: {
3365
		for ( var prop in oldSizzle ) {
3366
		url: location.href,
3366
			Sizzle[ prop ] = oldSizzle[ prop ];
3367
		global: true,
3367
		}
3368
		type: "GET",
3368
3369
		contentType: "application/x-www-form-urlencoded",
3369
		div = null; // release memory in IE
3370
		processData: true,
3370
	})();
3371
		async: true,
3371
}
3372
		/*
3372
3373
		timeout: 0,
3373
(function(){
3374
		data: null,
3374
	var div = document.createElement("div");
3375
		username: null,
3375
3376
		password: null,
3376
	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
3377
		*/
3377
3378
		// Create the request object; Microsoft failed to properly
3378
	// Opera can't find a second classname (in 9.6)
3379
		// implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
3379
	// Also, make sure that getElementsByClassName actually exists
3380
		// This function can be overriden by calling jQuery.ajaxSetup
3380
	if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
3381
		xhr:function(){
3381
		return;
3382
			return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
3382
	}
3383
		},
3383
3384
		accepts: {
3384
	// Safari caches class attributes, doesn't catch changes (in 3.2)
3385
			xml: "application/xml, text/xml",
3385
	div.lastChild.className = "e";
3386
			html: "text/html",
3386
3387
			script: "text/javascript, application/javascript",
3387
	if ( div.getElementsByClassName("e").length === 1 ) {
3388
			json: "application/json, text/javascript",
3388
		return;
3389
			text: "text/plain",
3389
	}
3390
			_default: "*/*"
3390
	
3391
		}
3391
	Expr.order.splice(1, 0, "CLASS");
3392
	},
3392
	Expr.find.CLASS = function(match, context, isXML) {
3393
3393
		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
3394
	// Last-Modified header cache for next request
3394
			return context.getElementsByClassName(match[1]);
3395
	lastModified: {},
3395
		}
3396
3396
	};
3397
	ajax: function( s ) {
3397
3398
		// Extend the settings, but re-extend 's' so that it can be
3398
	div = null; // release memory in IE
3399
		// checked again later (in the test suite, specifically)
3399
})();
3400
		s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
3400
3401
3401
function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3402
		var jsonp, jsre = /=\?(&|$)/g, status, data,
3402
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3403
			type = s.type.toUpperCase();
3403
		var elem = checkSet[i];
3404
3404
		if ( elem ) {
3405
		// convert data if not already a string
3405
			elem = elem[dir];
3406
		if ( s.data && s.processData && typeof s.data !== "string" )
3406
			var match = false;
3407
			s.data = jQuery.param(s.data);
3407
3408
3408
			while ( elem ) {
3409
		// Handle JSONP Parameter Callbacks
3409
				if ( elem.sizcache === doneName ) {
3410
		if ( s.dataType == "jsonp" ) {
3410
					match = checkSet[elem.sizset];
3411
			if ( type == "GET" ) {
3411
					break;
3412
				if ( !s.url.match(jsre) )
3412
				}
3413
					s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
3413
3414
			} else if ( !s.data || !s.data.match(jsre) )
3414
				if ( elem.nodeType === 1 && !isXML ){
3415
				s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
3415
					elem.sizcache = doneName;
3416
			s.dataType = "json";
3416
					elem.sizset = i;
3417
		}
3417
				}
3418
3418
3419
		// Build temporary JSONP function
3419
				if ( elem.nodeName.toLowerCase() === cur ) {
3420
		if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
3420
					match = elem;
3421
			jsonp = "jsonp" + jsc++;
3421
					break;
3422
3422
				}
3423
			// Replace the =? sequence both in the query string and the data
3423
3424
			if ( s.data )
3424
				elem = elem[dir];
3425
				s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
3425
			}
3426
			s.url = s.url.replace(jsre, "=" + jsonp + "$1");
3426
3427
3427
			checkSet[i] = match;
3428
			// We need to make sure
3428
		}
3429
			// that a JSONP style response is executed properly
3429
	}
3430
			s.dataType = "script";
3430
}
3431
3431
3432
			// Handle JSONP-style loading
3432
function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3433
			window[ jsonp ] = function(tmp){
3433
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3434
				data = tmp;
3434
		var elem = checkSet[i];
3435
				success();
3435
		if ( elem ) {
3436
				complete();
3436
			elem = elem[dir];
3437
				// Garbage collect
3437
			var match = false;
3438
				window[ jsonp ] = undefined;
3438
3439
				try{ delete window[ jsonp ]; } catch(e){}
3439
			while ( elem ) {
3440
				if ( head )
3440
				if ( elem.sizcache === doneName ) {
3441
					head.removeChild( script );
3441
					match = checkSet[elem.sizset];
3442
			};
3442
					break;
3443
		}
3443
				}
3444
3444
3445
		if ( s.dataType == "script" && s.cache == null )
3445
				if ( elem.nodeType === 1 ) {
3446
			s.cache = false;
3446
					if ( !isXML ) {
3447
3447
						elem.sizcache = doneName;
3448
		if ( s.cache === false && type == "GET" ) {
3448
						elem.sizset = i;
3449
			var ts = now();
3449
					}
3450
			// try replacing _= if it is there
3450
					if ( typeof cur !== "string" ) {
3451
			var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
3451
						if ( elem === cur ) {
3452
			// if nothing was replaced, add timestamp to the end
3452
							match = true;
3453
			s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
3453
							break;
3454
		}
3454
						}
3455
3455
3456
		// If data is available, append data to url for get requests
3456
					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
3457
		if ( s.data && type == "GET" ) {
3457
						match = elem;
3458
			s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
3458
						break;
3459
3459
					}
3460
			// IE likes to send both get and post data, prevent this
3460
				}
3461
			s.data = null;
3461
3462
		}
3462
				elem = elem[dir];
3463
3463
			}
3464
		// Watch for a new set of requests
3464
3465
		if ( s.global && ! jQuery.active++ )
3465
			checkSet[i] = match;
3466
			jQuery.event.trigger( "ajaxStart" );
3466
		}
3467
3467
	}
3468
		// Matches an absolute URL, and saves the domain
3468
}
3469
		var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url );
3469
3470
3470
var contains = document.compareDocumentPosition ? function(a, b){
3471
		// If we're requesting a remote document
3471
	return a.compareDocumentPosition(b) & 16;
3472
		// and trying to load JSON or Script with a GET
3472
} : function(a, b){
3473
		if ( s.dataType == "script" && type == "GET" && parts
3473
	return a !== b && (a.contains ? a.contains(b) : true);
3474
			&& ( parts[1] && parts[1] != location.protocol || parts[2] != location.host )){
3474
};
3475
3475
3476
			var head = document.getElementsByTagName("head")[0];
3476
var isXML = function(elem){
3477
			var script = document.createElement("script");
3477
	// documentElement is verified for cases where it doesn't yet exist
3478
			script.src = s.url;
3478
	// (such as loading iframes in IE - #4833) 
3479
			if (s.scriptCharset)
3479
	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
3480
				script.charset = s.scriptCharset;
3480
	return documentElement ? documentElement.nodeName !== "HTML" : false;
3481
3481
};
3482
			// Handle Script loading
3482
3483
			if ( !jsonp ) {
3483
var posProcess = function(selector, context){
3484
				var done = false;
3484
	var tmpSet = [], later = "", match,
3485
3485
		root = context.nodeType ? [context] : context;
3486
				// Attach handlers for all browsers
3486
3487
				script.onload = script.onreadystatechange = function(){
3487
	// Position selectors must be done after the filter
3488
					if ( !done && (!this.readyState ||
3488
	// And so must :not(positional) so we move all PSEUDOs to the end
3489
							this.readyState == "loaded" || this.readyState == "complete") ) {
3489
	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
3490
						done = true;
3490
		later += match[0];
3491
						success();
3491
		selector = selector.replace( Expr.match.PSEUDO, "" );
3492
						complete();
3492
	}
3493
3493
3494
						// Handle memory leak in IE
3494
	selector = Expr.relative[selector] ? selector + "*" : selector;
3495
						script.onload = script.onreadystatechange = null;
3495
3496
						head.removeChild( script );
3496
	for ( var i = 0, l = root.length; i < l; i++ ) {
3497
					}
3497
		Sizzle( selector, root[i], tmpSet );
3498
				};
3498
	}
3499
			}
3499
3500
3500
	return Sizzle.filter( later, tmpSet );
3501
			head.appendChild(script);
3501
};
3502
3502
3503
			// We handle everything using the script element injection
3503
// EXPOSE
3504
			return undefined;
3504
jQuery.find = Sizzle;
3505
		}
3505
jQuery.expr = Sizzle.selectors;
3506
3506
jQuery.expr[":"] = jQuery.expr.filters;
3507
		var requestDone = false;
3507
jQuery.unique = Sizzle.uniqueSort;
3508
3508
jQuery.getText = getText;
3509
		// Create the request object
3509
jQuery.isXMLDoc = isXML;
3510
		var xhr = s.xhr();
3510
jQuery.contains = contains;
3511
3511
3512
		// Open the socket
3512
return;
3513
		// Passing null username, generates a login popup on Opera (#2865)
3513
3514
		if( s.username )
3514
window.Sizzle = Sizzle;
3515
			xhr.open(type, s.url, s.async, s.username, s.password);
3515
3516
		else
3516
})();
3517
			xhr.open(type, s.url, s.async);
3517
var runtil = /Until$/,
3518
3518
	rparentsprev = /^(?:parents|prevUntil|prevAll)/,
3519
		// Need an extra try/catch for cross domain requests in Firefox 3
3519
	// Note: This RegExp should be improved, or likely pulled from Sizzle
3520
		try {
3520
	rmultiselector = /,/,
3521
			// Set the correct header, if data is being sent
3521
	slice = Array.prototype.slice;
3522
			if ( s.data )
3522
3523
				xhr.setRequestHeader("Content-Type", s.contentType);
3523
// Implement the identical functionality for filter and not
3524
3524
var winnow = function( elements, qualifier, keep ) {
3525
			// Set the If-Modified-Since header, if ifModified mode.
3525
	if ( jQuery.isFunction( qualifier ) ) {
3526
			if ( s.ifModified )
3526
		return jQuery.grep(elements, function( elem, i ) {
3527
				xhr.setRequestHeader("If-Modified-Since",
3527
			return !!qualifier.call( elem, i, elem ) === keep;
3528
					jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
3528
		});
3529
3529
3530
			// Set header so the called script knows that it's an XMLHttpRequest
3530
	} else if ( qualifier.nodeType ) {
3531
			xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
3531
		return jQuery.grep(elements, function( elem, i ) {
3532
3532
			return (elem === qualifier) === keep;
3533
			// Set the Accepts header for the server, depending on the dataType
3533
		});
3534
			xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
3534
3535
				s.accepts[ s.dataType ] + ", */*" :
3535
	} else if ( typeof qualifier === "string" ) {
3536
				s.accepts._default );
3536
		var filtered = jQuery.grep(elements, function( elem ) {
3537
		} catch(e){}
3537
			return elem.nodeType === 1;
3538
3538
		});
3539
		// Allow custom headers/mimetypes and early abort
3539
3540
		if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
3540
		if ( isSimple.test( qualifier ) ) {
3541
			// Handle the global AJAX counter
3541
			return jQuery.filter(qualifier, filtered, !keep);
3542
			if ( s.global && ! --jQuery.active )
3542
		} else {
3543
				jQuery.event.trigger( "ajaxStop" );
3543
			qualifier = jQuery.filter( qualifier, elements );
3544
			// close opended socket
3544
		}
3545
			xhr.abort();
3545
	}
3546
			return false;
3546
3547
		}
3547
	return jQuery.grep(elements, function( elem, i ) {
3548
3548
		return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
3549
		if ( s.global )
3549
	});
3550
			jQuery.event.trigger("ajaxSend", [xhr, s]);
3550
};
3551
3551
3552
		// Wait for a response to come back
3552
jQuery.fn.extend({
3553
		var onreadystatechange = function(isTimeout){
3553
	find: function( selector ) {
3554
			// The request was aborted, clear the interval and decrement jQuery.active
3554
		var ret = this.pushStack( "", "find", selector ), length = 0;
3555
			if (xhr.readyState == 0) {
3555
3556
				if (ival) {
3556
		for ( var i = 0, l = this.length; i < l; i++ ) {
3557
					// clear poll interval
3557
			length = ret.length;
3558
					clearInterval(ival);
3558
			jQuery.find( selector, this[i], ret );
3559
					ival = null;
3559
3560
					// Handle the global AJAX counter
3560
			if ( i > 0 ) {
3561
					if ( s.global && ! --jQuery.active )
3561
				// Make sure that the results are unique
3562
						jQuery.event.trigger( "ajaxStop" );
3562
				for ( var n = length; n < ret.length; n++ ) {
3563
				}
3563
					for ( var r = 0; r < length; r++ ) {
3564
			// The transfer is complete and the data is available, or the request timed out
3564
						if ( ret[r] === ret[n] ) {
3565
			} else if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
3565
							ret.splice(n--, 1);
3566
				requestDone = true;
3566
							break;
3567
3567
						}
3568
				// clear poll interval
3568
					}
3569
				if (ival) {
3569
				}
3570
					clearInterval(ival);
3570
			}
3571
					ival = null;
3571
		}
3572
				}
3572
3573
3573
		return ret;
3574
				status = isTimeout == "timeout" ? "timeout" :
3574
	},
3575
					!jQuery.httpSuccess( xhr ) ? "error" :
3575
3576
					s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
3576
	has: function( target ) {
3577
					"success";
3577
		var targets = jQuery( target );
3578
3578
		return this.filter(function() {
3579
				if ( status == "success" ) {
3579
			for ( var i = 0, l = targets.length; i < l; i++ ) {
3580
					// Watch for, and catch, XML document parse errors
3580
				if ( jQuery.contains( this, targets[i] ) ) {
3581
					try {
3581
					return true;
3582
						// process the data (runs the xml through httpData regardless of callback)
3582
				}
3583
						data = jQuery.httpData( xhr, s.dataType, s );
3583
			}
3584
					} catch(e) {
3584
		});
3585
						status = "parsererror";
3585
	},
3586
					}
3586
3587
				}
3587
	not: function( selector ) {
3588
3588
		return this.pushStack( winnow(this, selector, false), "not", selector);
3589
				// Make sure that the request was successful or notmodified
3589
	},
3590
				if ( status == "success" ) {
3590
3591
					// Cache Last-Modified header, if ifModified mode.
3591
	filter: function( selector ) {
3592
					var modRes;
3592
		return this.pushStack( winnow(this, selector, true), "filter", selector );
3593
					try {
3593
	},
3594
						modRes = xhr.getResponseHeader("Last-Modified");
3594
	
3595
					} catch(e) {} // swallow exception thrown by FF if header is not available
3595
	is: function( selector ) {
3596
3596
		return !!selector && jQuery.filter( selector, this ).length > 0;
3597
					if ( s.ifModified && modRes )
3597
	},
3598
						jQuery.lastModified[s.url] = modRes;
3598
3599
3599
	closest: function( selectors, context ) {
3600
					// JSONP handles its own success callback
3600
		if ( jQuery.isArray( selectors ) ) {
3601
					if ( !jsonp )
3601
			var ret = [], cur = this[0], match, matches = {}, selector;
3602
						success();
3602
3603
				} else
3603
			if ( cur && selectors.length ) {
3604
					jQuery.handleError(s, xhr, status);
3604
				for ( var i = 0, l = selectors.length; i < l; i++ ) {
3605
3605
					selector = selectors[i];
3606
				// Fire the complete handlers
3606
3607
				complete();
3607
					if ( !matches[selector] ) {
3608
3608
						matches[selector] = jQuery.expr.match.POS.test( selector ) ? 
3609
				if ( isTimeout )
3609
							jQuery( selector, context || this.context ) :
3610
					xhr.abort();
3610
							selector;
3611
3611
					}
3612
				// Stop memory leaks
3612
				}
3613
				if ( s.async )
3613
3614
					xhr = null;
3614
				while ( cur && cur.ownerDocument && cur !== context ) {
3615
			}
3615
					for ( selector in matches ) {
3616
		};
3616
						match = matches[selector];
3617
3617
3618
		if ( s.async ) {
3618
						if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
3619
			// don't attach the handler to the request, just poll it instead
3619
							ret.push({ selector: selector, elem: cur });
3620
			var ival = setInterval(onreadystatechange, 13);
3620
							delete matches[selector];
3621
3621
						}
3622
			// Timeout checker
3622
					}
3623
			if ( s.timeout > 0 )
3623
					cur = cur.parentNode;
3624
				setTimeout(function(){
3624
				}
3625
					// Check to see if the request is still happening
3625
			}
3626
					if ( xhr && !requestDone )
3626
3627
						onreadystatechange( "timeout" );
3627
			return ret;
3628
				}, s.timeout);
3628
		}
3629
		}
3629
3630
3630
		var pos = jQuery.expr.match.POS.test( selectors ) ? 
3631
		// Send the data
3631
			jQuery( selectors, context || this.context ) : null;
3632
		try {
3632
3633
			xhr.send(s.data);
3633
		return this.map(function( i, cur ) {
3634
		} catch(e) {
3634
			while ( cur && cur.ownerDocument && cur !== context ) {
3635
			jQuery.handleError(s, xhr, null, e);
3635
				if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selectors) ) {
3636
		}
3636
					return cur;
3637
3637
				}
3638
		// firefox 1.5 doesn't fire statechange for sync requests
3638
				cur = cur.parentNode;
3639
		if ( !s.async )
3639
			}
3640
			onreadystatechange();
3640
			return null;
3641
3641
		});
3642
		function success(){
3642
	},
3643
			// If a local callback was specified, fire it and pass it the data
3643
	
3644
			if ( s.success )
3644
	// Determine the position of an element within
3645
				s.success( data, status );
3645
	// the matched set of elements
3646
3646
	index: function( elem ) {
3647
			// Fire the global callback
3647
		if ( !elem || typeof elem === "string" ) {
3648
			if ( s.global )
3648
			return jQuery.inArray( this[0],
3649
				jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
3649
				// If it receives a string, the selector is used
3650
		}
3650
				// If it receives nothing, the siblings are used
3651
3651
				elem ? jQuery( elem ) : this.parent().children() );
3652
		function complete(){
3652
		}
3653
			// Process result
3653
		// Locate the position of the desired element
3654
			if ( s.complete )
3654
		return jQuery.inArray(
3655
				s.complete(xhr, status);
3655
			// If it receives a jQuery object, the first element is used
3656
3656
			elem.jquery ? elem[0] : elem, this );
3657
			// The request was completed
3657
	},
3658
			if ( s.global )
3658
3659
				jQuery.event.trigger( "ajaxComplete", [xhr, s] );
3659
	add: function( selector, context ) {
3660
3660
		var set = typeof selector === "string" ?
3661
			// Handle the global AJAX counter
3661
				jQuery( selector, context || this.context ) :
3662
			if ( s.global && ! --jQuery.active )
3662
				jQuery.makeArray( selector ),
3663
				jQuery.event.trigger( "ajaxStop" );
3663
			all = jQuery.merge( this.get(), set );
3664
		}
3664
3665
3665
		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
3666
		// return XMLHttpRequest to allow aborting the request etc.
3666
			all :
3667
		return xhr;
3667
			jQuery.unique( all ) );
3668
	},
3668
	},
3669
3669
3670
	handleError: function( s, xhr, status, e ) {
3670
	andSelf: function() {
3671
		// If a local callback was specified, fire it
3671
		return this.add( this.prevObject );
3672
		if ( s.error ) s.error( xhr, status, e );
3672
	}
3673
3673
});
3674
		// Fire the global callback
3674
3675
		if ( s.global )
3675
// A painfully simple check to see if an element is disconnected
3676
			jQuery.event.trigger( "ajaxError", [xhr, s, e] );
3676
// from a document (should be improved, where feasible).
3677
	},
3677
function isDisconnected( node ) {
3678
3678
	return !node || !node.parentNode || node.parentNode.nodeType === 11;
3679
	// Counter for holding the number of active queries
3679
}
3680
	active: 0,
3680
3681
3681
jQuery.each({
3682
	// Determines if an XMLHttpRequest was successful or not
3682
	parent: function( elem ) {
3683
	httpSuccess: function( xhr ) {
3683
		var parent = elem.parentNode;
3684
		try {
3684
		return parent && parent.nodeType !== 11 ? parent : null;
3685
			// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
3685
	},
3686
			return !xhr.status && location.protocol == "file:" ||
3686
	parents: function( elem ) {
3687
				( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223;
3687
		return jQuery.dir( elem, "parentNode" );
3688
		} catch(e){}
3688
	},
3689
		return false;
3689
	parentsUntil: function( elem, i, until ) {
3690
	},
3690
		return jQuery.dir( elem, "parentNode", until );
3691
3691
	},
3692
	// Determines if an XMLHttpRequest returns NotModified
3692
	next: function( elem ) {
3693
	httpNotModified: function( xhr, url ) {
3693
		return jQuery.nth( elem, 2, "nextSibling" );
3694
		try {
3694
	},
3695
			var xhrRes = xhr.getResponseHeader("Last-Modified");
3695
	prev: function( elem ) {
3696
3696
		return jQuery.nth( elem, 2, "previousSibling" );
3697
			// Firefox always returns 200. check Last-Modified date
3697
	},
3698
			return xhr.status == 304 || xhrRes == jQuery.lastModified[url];
3698
	nextAll: function( elem ) {
3699
		} catch(e){}
3699
		return jQuery.dir( elem, "nextSibling" );
3700
		return false;
3700
	},
3701
	},
3701
	prevAll: function( elem ) {
3702
3702
		return jQuery.dir( elem, "previousSibling" );
3703
	httpData: function( xhr, type, s ) {
3703
	},
3704
		var ct = xhr.getResponseHeader("content-type"),
3704
	nextUntil: function( elem, i, until ) {
3705
			xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
3705
		return jQuery.dir( elem, "nextSibling", until );
3706
			data = xml ? xhr.responseXML : xhr.responseText;
3706
	},
3707
3707
	prevUntil: function( elem, i, until ) {
3708
		if ( xml && data.documentElement.tagName == "parsererror" )
3708
		return jQuery.dir( elem, "previousSibling", until );
3709
			throw "parsererror";
3709
	},
3710
3710
	siblings: function( elem ) {
3711
		// Allow a pre-filtering function to sanitize the response
3711
		return jQuery.sibling( elem.parentNode.firstChild, elem );
3712
		// s != null is checked to keep backwards compatibility
3712
	},
3713
		if( s && s.dataFilter )
3713
	children: function( elem ) {
3714
			data = s.dataFilter( data, type );
3714
		return jQuery.sibling( elem.firstChild );
3715
3715
	},
3716
		// The filter can actually parse the response
3716
	contents: function( elem ) {
3717
		if( typeof data === "string" ){
3717
		return jQuery.nodeName( elem, "iframe" ) ?
3718
3718
			elem.contentDocument || elem.contentWindow.document :
3719
			// If the type is "script", eval it in global context
3719
			jQuery.makeArray( elem.childNodes );
3720
			if ( type == "script" )
3720
	}
3721
				jQuery.globalEval( data );
3721
}, function( name, fn ) {
3722
3722
	jQuery.fn[ name ] = function( until, selector ) {
3723
			// Get the JavaScript object, if JSON is used.
3723
		var ret = jQuery.map( this, fn, until );
3724
			if ( type == "json" )
3724
		
3725
				data = window["eval"]("(" + data + ")");
3725
		if ( !runtil.test( name ) ) {
3726
		}
3726
			selector = until;
3727
3727
		}
3728
		return data;
3728
3729
	},
3729
		if ( selector && typeof selector === "string" ) {
3730
3730
			ret = jQuery.filter( selector, ret );
3731
	// Serialize an array of form elements or a set of
3731
		}
3732
	// key/values into a query string
3732
3733
	param: function( a ) {
3733
		ret = this.length > 1 ? jQuery.unique( ret ) : ret;
3734
		var s = [ ];
3734
3735
3735
		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
3736
		function add( key, value ){
3736
			ret = ret.reverse();
3737
			s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
3737
		}
3738
		};
3738
3739
3739
		return this.pushStack( ret, name, slice.call(arguments).join(",") );
3740
		// If an array was passed in, assume that it is an array
3740
	};
3741
		// of form elements
3741
});
3742
		if ( jQuery.isArray(a) || a.jquery )
3742
3743
			// Serialize the form elements
3743
jQuery.extend({
3744
			jQuery.each( a, function(){
3744
	filter: function( expr, elems, not ) {
3745
				add( this.name, this.value );
3745
		if ( not ) {
3746
			});
3746
			expr = ":not(" + expr + ")";
3747
3747
		}
3748
		// Otherwise, assume that it's an object of key/value pairs
3748
3749
		else
3749
		return jQuery.find.matches(expr, elems);
3750
			// Serialize the key/values
3750
	},
3751
			for ( var j in a )
3751
	
3752
				// If the value is an array then the key names need to be repeated
3752
	dir: function( elem, dir, until ) {
3753
				if ( jQuery.isArray(a[j]) )
3753
		var matched = [], cur = elem[dir];
3754
					jQuery.each( a[j], function(){
3754
		while ( cur && cur.nodeType !== 9 && (until === undefined || !jQuery( cur ).is( until )) ) {
3755
						add( j, this );
3755
			if ( cur.nodeType === 1 ) {
3756
					});
3756
				matched.push( cur );
3757
				else
3757
			}
3758
					add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
3758
			cur = cur[dir];
3759
3759
		}
3760
		// Return the resulting serialization
3760
		return matched;
3761
		return s.join("&").replace(/%20/g, "+");
3761
	},
3762
	}
3762
3763
3763
	nth: function( cur, result, dir, elem ) {
3764
});
3764
		result = result || 1;
3765
var elemdisplay = {},
3765
		var num = 0;
3766
	timerId,
3766
3767
	fxAttrs = [
3767
		for ( ; cur; cur = cur[dir] ) {
3768
		// height animations
3768
			if ( cur.nodeType === 1 && ++num === result ) {
3769
		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
3769
				break;
3770
		// width animations
3770
			}
3771
		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
3771
		}
3772
		// opacity animations
3772
3773
		[ "opacity" ]
3773
		return cur;
3774
	];
3774
	},
3775
3775
3776
function genFx( type, num ){
3776
	sibling: function( n, elem ) {
3777
	var obj = {};
3777
		var r = [];
3778
	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function(){
3778
3779
		obj[ this ] = type;
3779
		for ( ; n; n = n.nextSibling ) {
3780
	});
3780
			if ( n.nodeType === 1 && n !== elem ) {
3781
	return obj;
3781
				r.push( n );
3782
}
3782
			}
3783
3783
		}
3784
jQuery.fn.extend({
3784
3785
	show: function(speed,callback){
3785
		return r;
3786
		if ( speed ) {
3786
	}
3787
			return this.animate( genFx("show", 3), speed, callback);
3787
});
3788
		} else {
3788
var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
3789
			for ( var i = 0, l = this.length; i < l; i++ ){
3789
	rleadingWhitespace = /^\s+/,
3790
				var old = jQuery.data(this[i], "olddisplay");
3790
	rxhtmlTag = /(<([\w:]+)[^>]*?)\/>/g,
3791
3791
	rselfClosing = /^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,
3792
				this[i].style.display = old || "";
3792
	rtagName = /<([\w:]+)/,
3793
3793
	rtbody = /<tbody/i,
3794
				if ( jQuery.css(this[i], "display") === "none" ) {
3794
	rhtml = /<|&\w+;/,
3795
					var tagName = this[i].tagName, display;
3795
	fcloseTag = function( all, front, tag ) {
3796
3796
		return rselfClosing.test( tag ) ?
3797
					if ( elemdisplay[ tagName ] ) {
3797
			all :
3798
						display = elemdisplay[ tagName ];
3798
			front + "></" + tag + ">";
3799
					} else {
3799
	},
3800
						var elem = jQuery("<" + tagName + " />").appendTo("body");
3800
	wrapMap = {
3801
3801
		option: [ 1, "<select multiple='multiple'>", "</select>" ],
3802
						display = elem.css("display");
3802
		legend: [ 1, "<fieldset>", "</fieldset>" ],
3803
						if ( display === "none" )
3803
		thead: [ 1, "<table>", "</table>" ],
3804
							display = "block";
3804
		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
3805
3805
		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
3806
						elem.remove();
3806
		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
3807
3807
		area: [ 1, "<map>", "</map>" ],
3808
						elemdisplay[ tagName ] = display;
3808
		_default: [ 0, "", "" ]
3809
					}
3809
	};
3810
3810
3811
					jQuery.data(this[i], "olddisplay", display);
3811
wrapMap.optgroup = wrapMap.option;
3812
				}
3812
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
3813
			}
3813
wrapMap.th = wrapMap.td;
3814
3814
3815
			// Set the display of the elements in a second loop
3815
// IE can't serialize <link> and <script> tags normally
3816
			// to avoid the constant reflow
3816
if ( !jQuery.support.htmlSerialize ) {
3817
			for ( var i = 0, l = this.length; i < l; i++ ){
3817
	wrapMap._default = [ 1, "div<div>", "</div>" ];
3818
				this[i].style.display = jQuery.data(this[i], "olddisplay") || "";
3818
}
3819
			}
3819
3820
3820
jQuery.fn.extend({
3821
			return this;
3821
	text: function( text ) {
3822
		}
3822
		if ( jQuery.isFunction(text) ) {
3823
	},
3823
			return this.each(function(i) {
3824
3824
				var self = jQuery(this);
3825
	hide: function(speed,callback){
3825
				return self.text( text.call(this, i, self.text()) );
3826
		if ( speed ) {
3826
			});
3827
			return this.animate( genFx("hide", 3), speed, callback);
3827
		}
3828
		} else {
3828
3829
			for ( var i = 0, l = this.length; i < l; i++ ){
3829
		if ( typeof text !== "object" && text !== undefined ) {
3830
				var old = jQuery.data(this[i], "olddisplay");
3830
			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
3831
				if ( !old && old !== "none" )
3831
		}
3832
					jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
3832
3833
			}
3833
		return jQuery.getText( this );
3834
3834
	},
3835
			// Set the display of the elements in a second loop
3835
3836
			// to avoid the constant reflow
3836
	wrapAll: function( html ) {
3837
			for ( var i = 0, l = this.length; i < l; i++ ){
3837
		if ( jQuery.isFunction( html ) ) {
3838
				this[i].style.display = "none";
3838
			return this.each(function(i) {
3839
			}
3839
				jQuery(this).wrapAll( html.call(this, i) );
3840
3840
			});
3841
			return this;
3841
		}
3842
		}
3842
3843
	},
3843
		if ( this[0] ) {
3844
3844
			// The elements to wrap the target around
3845
	// Save the old toggle function
3845
			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
3846
	_toggle: jQuery.fn.toggle,
3846
3847
3847
			if ( this[0].parentNode ) {
3848
	toggle: function( fn, fn2 ){
3848
				wrap.insertBefore( this[0] );
3849
		var bool = typeof fn === "boolean";
3849
			}
3850
3850
3851
		return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
3851
			wrap.map(function() {
3852
			this._toggle.apply( this, arguments ) :
3852
				var elem = this;
3853
			fn == null || bool ?
3853
3854
				this.each(function(){
3854
				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
3855
					var state = bool ? fn : jQuery(this).is(":hidden");
3855
					elem = elem.firstChild;
3856
					jQuery(this)[ state ? "show" : "hide" ]();
3856
				}
3857
				}) :
3857
3858
				this.animate(genFx("toggle", 3), fn, fn2);
3858
				return elem;
3859
	},
3859
			}).append(this);
3860
3860
		}
3861
	fadeTo: function(speed,to,callback){
3861
3862
		return this.animate({opacity: to}, speed, callback);
3862
		return this;
3863
	},
3863
	},
3864
3864
3865
	animate: function( prop, speed, easing, callback ) {
3865
	wrapInner: function( html ) {
3866
		var optall = jQuery.speed(speed, easing, callback);
3866
		return this.each(function() {
3867
3867
			var self = jQuery( this ), contents = self.contents();
3868
		return this[ optall.queue === false ? "each" : "queue" ](function(){
3868
3869
3869
			if ( contents.length ) {
3870
			var opt = jQuery.extend({}, optall), p,
3870
				contents.wrapAll( html );
3871
				hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
3871
3872
				self = this;
3872
			} else {
3873
3873
				self.append( html );
3874
			for ( p in prop ) {
3874
			}
3875
				if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
3875
		});
3876
					return opt.complete.call(this);
3876
	},
3877
3877
3878
				if ( ( p == "height" || p == "width" ) && this.style ) {
3878
	wrap: function( html ) {
3879
					// Store display property
3879
		return this.each(function() {
3880
					opt.display = jQuery.css(this, "display");
3880
			jQuery( this ).wrapAll( html );
3881
3881
		});
3882
					// Make sure that nothing sneaks out
3882
	},
3883
					opt.overflow = this.style.overflow;
3883
3884
				}
3884
	unwrap: function() {
3885
			}
3885
		return this.parent().each(function() {
3886
3886
			if ( !jQuery.nodeName( this, "body" ) ) {
3887
			if ( opt.overflow != null )
3887
				jQuery( this ).replaceWith( this.childNodes );
3888
				this.style.overflow = "hidden";
3888
			}
3889
3889
		}).end();
3890
			opt.curAnim = jQuery.extend({}, prop);
3890
	},
3891
3891
3892
			jQuery.each( prop, function(name, val){
3892
	append: function() {
3893
				var e = new jQuery.fx( self, opt, name );
3893
		return this.domManip(arguments, true, function( elem ) {
3894
3894
			if ( this.nodeType === 1 ) {
3895
				if ( /toggle|show|hide/.test(val) )
3895
				this.appendChild( elem );
3896
					e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3896
			}
3897
				else {
3897
		});
3898
					var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3898
	},
3899
						start = e.cur(true) || 0;
3899
3900
3900
	prepend: function() {
3901
					if ( parts ) {
3901
		return this.domManip(arguments, true, function( elem ) {
3902
						var end = parseFloat(parts[2]),
3902
			if ( this.nodeType === 1 ) {
3903
							unit = parts[3] || "px";
3903
				this.insertBefore( elem, this.firstChild );
3904
3904
			}
3905
						// We need to compute starting value
3905
		});
3906
						if ( unit != "px" ) {
3906
	},
3907
							self.style[ name ] = (end || 1) + unit;
3907
3908
							start = ((end || 1) / e.cur(true)) * start;
3908
	before: function() {
3909
							self.style[ name ] = start + unit;
3909
		if ( this[0] && this[0].parentNode ) {
3910
						}
3910
			return this.domManip(arguments, false, function( elem ) {
3911
3911
				this.parentNode.insertBefore( elem, this );
3912
						// If a +=/-= token was provided, we're doing a relative animation
3912
			});
3913
						if ( parts[1] )
3913
		} else if ( arguments.length ) {
3914
							end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3914
			var set = jQuery(arguments[0]);
3915
3915
			set.push.apply( set, this.toArray() );
3916
						e.custom( start, end, unit );
3916
			return this.pushStack( set, "before", arguments );
3917
					} else
3917
		}
3918
						e.custom( start, val, "" );
3918
	},
3919
				}
3919
3920
			});
3920
	after: function() {
3921
3921
		if ( this[0] && this[0].parentNode ) {
3922
			// For JS strict compliance
3922
			return this.domManip(arguments, false, function( elem ) {
3923
			return true;
3923
				this.parentNode.insertBefore( elem, this.nextSibling );
3924
		});
3924
			});
3925
	},
3925
		} else if ( arguments.length ) {
3926
3926
			var set = this.pushStack( this, "after", arguments );
3927
	stop: function(clearQueue, gotoEnd){
3927
			set.push.apply( set, jQuery(arguments[0]).toArray() );
3928
		var timers = jQuery.timers;
3928
			return set;
3929
3929
		}
3930
		if (clearQueue)
3930
	},
3931
			this.queue([]);
3931
3932
3932
	clone: function( events ) {
3933
		this.each(function(){
3933
		// Do the clone
3934
			// go in reverse order so anything added to the queue during the loop is ignored
3934
		var ret = this.map(function() {
3935
			for ( var i = timers.length - 1; i >= 0; i-- )
3935
			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
3936
				if ( timers[i].elem == this ) {
3936
				// IE copies events bound via attachEvent when
3937
					if (gotoEnd)
3937
				// using cloneNode. Calling detachEvent on the
3938
						// force the next step to be the last
3938
				// clone will also remove the events from the orignal
3939
						timers[i](true);
3939
				// In order to get around this, we use innerHTML.
3940
					timers.splice(i, 1);
3940
				// Unfortunately, this means some modifications to
3941
				}
3941
				// attributes in IE that are actually only stored
3942
		});
3942
				// as properties will not be copied (such as the
3943
3943
				// the name attribute on an input).
3944
		// start the next in the queue if the last step wasn't forced
3944
				var html = this.outerHTML, ownerDocument = this.ownerDocument;
3945
		if (!gotoEnd)
3945
				if ( !html ) {
3946
			this.dequeue();
3946
					var div = ownerDocument.createElement("div");
3947
3947
					div.appendChild( this.cloneNode(true) );
3948
		return this;
3948
					html = div.innerHTML;
3949
	}
3949
				}
3950
3950
3951
});
3951
				return jQuery.clean([html.replace(rinlinejQuery, "")
3952
3952
					.replace(rleadingWhitespace, "")], ownerDocument)[0];
3953
// Generate shortcuts for custom animations
3953
			} else {
3954
jQuery.each({
3954
				return this.cloneNode(true);
3955
	slideDown: genFx("show", 1),
3955
			}
3956
	slideUp: genFx("hide", 1),
3956
		});
3957
	slideToggle: genFx("toggle", 1),
3957
3958
	fadeIn: { opacity: "show" },
3958
		// Copy the events from the original to the clone
3959
	fadeOut: { opacity: "hide" }
3959
		if ( events === true ) {
3960
}, function( name, props ){
3960
			cloneCopyEvent( this, ret );
3961
	jQuery.fn[ name ] = function( speed, callback ){
3961
			cloneCopyEvent( this.find("*"), ret.find("*") );
3962
		return this.animate( props, speed, callback );
3962
		}
3963
	};
3963
3964
});
3964
		// Return the cloned set
3965
3965
		return ret;
3966
jQuery.extend({
3966
	},
3967
3967
3968
	speed: function(speed, easing, fn) {
3968
	html: function( value ) {
3969
		var opt = typeof speed === "object" ? speed : {
3969
		if ( value === undefined ) {
3970
			complete: fn || !fn && easing ||
3970
			return this[0] && this[0].nodeType === 1 ?
3971
				jQuery.isFunction( speed ) && speed,
3971
				this[0].innerHTML.replace(rinlinejQuery, "") :
3972
			duration: speed,
3972
				null;
3973
			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
3973
3974
		};
3974
		// See if we can take a shortcut and just use innerHTML
3975
3975
		} else if ( typeof value === "string" && !/<script/i.test( value ) &&
3976
		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
3976
			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
3977
			jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
3977
			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
3978
3978
3979
		// Queueing
3979
			try {
3980
		opt.old = opt.complete;
3980
				for ( var i = 0, l = this.length; i < l; i++ ) {
3981
		opt.complete = function(){
3981
					// Remove element nodes and prevent memory leaks
3982
			if ( opt.queue !== false )
3982
					if ( this[i].nodeType === 1 ) {
3983
				jQuery(this).dequeue();
3983
						cleanData( this[i].getElementsByTagName("*") );
3984
			if ( jQuery.isFunction( opt.old ) )
3984
						this[i].innerHTML = value;
3985
				opt.old.call( this );
3985
					}
3986
		};
3986
				}
3987
3987
3988
		return opt;
3988
			// If using innerHTML throws an exception, use the fallback method
3989
	},
3989
			} catch(e) {
3990
3990
				this.empty().append( value );
3991
	easing: {
3991
			}
3992
		linear: function( p, n, firstNum, diff ) {
3992
3993
			return firstNum + diff * p;
3993
		} else if ( jQuery.isFunction( value ) ) {
3994
		},
3994
			this.each(function(i){
3995
		swing: function( p, n, firstNum, diff ) {
3995
				var self = jQuery(this), old = self.html();
3996
			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
3996
				self.empty().append(function(){
3997
		}
3997
					return value.call( this, i, old );
3998
	},
3998
				});
3999
3999
			});
4000
	timers: [],
4000
4001
4001
		} else {
4002
	fx: function( elem, options, prop ){
4002
			this.empty().append( value );
4003
		this.options = options;
4003
		}
4004
		this.elem = elem;
4004
4005
		this.prop = prop;
4005
		return this;
4006
4006
	},
4007
		if ( !options.orig )
4007
4008
			options.orig = {};
4008
	replaceWith: function( value ) {
4009
	}
4009
		if ( this[0] && this[0].parentNode ) {
4010
4010
			// Make sure that the elements are removed from the DOM before they are inserted
4011
});
4011
			// this can help fix replacing a parent with child elements
4012
4012
			if ( !jQuery.isFunction( value ) ) {
4013
jQuery.fx.prototype = {
4013
				value = jQuery( value ).detach();
4014
4014
			}
4015
	// Simple function for setting a style value
4015
4016
	update: function(){
4016
			return this.each(function() {
4017
		if ( this.options.step )
4017
				var next = this.nextSibling, parent = this.parentNode;
4018
			this.options.step.call( this.elem, this.now, this );
4018
4019
4019
				jQuery(this).remove();
4020
		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
4020
4021
4021
				if ( next ) {
4022
		// Set display property to block for height/width animations
4022
					jQuery(next).before( value );
4023
		if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
4023
				} else {
4024
			this.elem.style.display = "block";
4024
					jQuery(parent).append( value );
4025
	},
4025
				}
4026
4026
			});
4027
	// Get the current size
4027
		} else {
4028
	cur: function(force){
4028
			return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4029
		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
4029
		}
4030
			return this.elem[ this.prop ];
4030
	},
4031
4031
4032
		var r = parseFloat(jQuery.css(this.elem, this.prop, force));
4032
	detach: function( selector ) {
4033
		return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
4033
		return this.remove( selector, true );
4034
	},
4034
	},
4035
4035
4036
	// Start an animation from one number to another
4036
	domManip: function( args, table, callback ) {
4037
	custom: function(from, to, unit){
4037
		var results, first, value = args[0], scripts = [];
4038
		this.startTime = now();
4038
4039
		this.start = from;
4039
		if ( jQuery.isFunction(value) ) {
4040
		this.end = to;
4040
			return this.each(function(i) {
4041
		this.unit = unit || this.unit || "px";
4041
				var self = jQuery(this);
4042
		this.now = this.start;
4042
				args[0] = value.call(this, i, table ? self.html() : undefined);
4043
		this.pos = this.state = 0;
4043
				return self.domManip( args, table, callback );
4044
4044
			});
4045
		var self = this;
4045
		}
4046
		function t(gotoEnd){
4046
4047
			return self.step(gotoEnd);
4047
		if ( this[0] ) {
4048
		}
4048
			// If we're in a fragment, just use that instead of building a new one
4049
4049
			if ( args[0] && args[0].parentNode && args[0].parentNode.nodeType === 11 ) {
4050
		t.elem = this.elem;
4050
				results = { fragment: args[0].parentNode };
4051
4051
			} else {
4052
		if ( t() && jQuery.timers.push(t) && !timerId ) {
4052
				results = buildFragment( args, this, scripts );
4053
			timerId = setInterval(function(){
4053
			}
4054
				var timers = jQuery.timers;
4054
4055
4055
			first = results.fragment.firstChild;
4056
				for ( var i = 0; i < timers.length; i++ )
4056
4057
					if ( !timers[i]() )
4057
			if ( first ) {
4058
						timers.splice(i--, 1);
4058
				table = table && jQuery.nodeName( first, "tr" );
4059
4059
4060
				if ( !timers.length ) {
4060
				for ( var i = 0, l = this.length; i < l; i++ ) {
4061
					clearInterval( timerId );
4061
					callback.call(
4062
					timerId = undefined;
4062
						table ?
4063
				}
4063
							root(this[i], first) :
4064
			}, 13);
4064
							this[i],
4065
		}
4065
						results.cacheable || this.length > 1 || i > 0 ?
4066
	},
4066
							results.fragment.cloneNode(true) :
4067
4067
							results.fragment
4068
	// Simple 'show' function
4068
					);
4069
	show: function(){
4069
				}
4070
		// Remember where we started, so that we can go back to it later
4070
			}
4071
		this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
4071
4072
		this.options.show = true;
4072
			if ( scripts ) {
4073
4073
				jQuery.each( scripts, evalScript );
4074
		// Begin the animation
4074
			}
4075
		// Make sure that we start at a small width/height to avoid any
4075
		}
4076
		// flash of content
4076
4077
		this.custom(this.prop == "width" || this.prop == "height" ? 1 : 0, this.cur());
4077
		return this;
4078
4078
4079
		// Start by showing the element
4079
		function root( elem, cur ) {
4080
		jQuery(this.elem).show();
4080
			return jQuery.nodeName(elem, "table") ?
4081
	},
4081
				(elem.getElementsByTagName("tbody")[0] ||
4082
4082
				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
4083
	// Simple 'hide' function
4083
				elem;
4084
	hide: function(){
4084
		}
4085
		// Remember where we started, so that we can go back to it later
4085
	}
4086
		this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
4086
});
4087
		this.options.hide = true;
4087
4088
4088
function cloneCopyEvent(orig, ret) {
4089
		// Begin the animation
4089
	var i = 0;
4090
		this.custom(this.cur(), 0);
4090
4091
	},
4091
	ret.each(function() {
4092
4092
		if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
4093
	// Each step of an animation
4093
			return;
4094
	step: function(gotoEnd){
4094
		}
4095
		var t = now();
4095
4096
4096
		var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events;
4097
		if ( gotoEnd || t >= this.options.duration + this.startTime ) {
4097
4098
			this.now = this.end;
4098
		if ( events ) {
4099
			this.pos = this.state = 1;
4099
			delete curData.handle;
4100
			this.update();
4100
			curData.events = {};
4101
4101
4102
			this.options.curAnim[ this.prop ] = true;
4102
			for ( var type in events ) {
4103
4103
				for ( var handler in events[ type ] ) {
4104
			var done = true;
4104
					jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
4105
			for ( var i in this.options.curAnim )
4105
				}
4106
				if ( this.options.curAnim[i] !== true )
4106
			}
4107
					done = false;
4107
		}
4108
4108
	});
4109
			if ( done ) {
4109
}
4110
				if ( this.options.display != null ) {
4110
4111
					// Reset the overflow
4111
function buildFragment( args, nodes, scripts ) {
4112
					this.elem.style.overflow = this.options.overflow;
4112
	var fragment, cacheable, cached, cacheresults, doc;
4113
4113
4114
					// Reset the display
4114
	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && args[0].indexOf("<option") < 0 ) {
4115
					this.elem.style.display = this.options.display;
4115
		cacheable = true;
4116
					if ( jQuery.css(this.elem, "display") == "none" )
4116
		cacheresults = jQuery.fragments[ args[0] ];
4117
						this.elem.style.display = "block";
4117
		if ( cacheresults ) {
4118
				}
4118
			if ( cacheresults !== 1 ) {
4119
4119
				fragment = cacheresults;
4120
				// Hide the element if the "hide" operation was done
4120
			}
4121
				if ( this.options.hide )
4121
			cached = true;
4122
					jQuery(this.elem).hide();
4122
		}
4123
4123
	}
4124
				// Reset the properties, if the item has been hidden or shown
4124
4125
				if ( this.options.hide || this.options.show )
4125
	if ( !fragment ) {
4126
					for ( var p in this.options.curAnim )
4126
		doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
4127
						jQuery.attr(this.elem.style, p, this.options.orig[p]);
4127
		fragment = doc.createDocumentFragment();
4128
4128
		jQuery.clean( args, doc, fragment, scripts );
4129
				// Execute the complete function
4129
	}
4130
				this.options.complete.call( this.elem );
4130
4131
			}
4131
	if ( cacheable ) {
4132
4132
		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
4133
			return false;
4133
	}
4134
		} else {
4134
4135
			var n = t - this.startTime;
4135
	return { fragment: fragment, cacheable: cacheable };
4136
			this.state = n / this.options.duration;
4136
}
4137
4137
4138
			// Perform the easing function, defaults to swing
4138
jQuery.fragments = {};
4139
			this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
4139
4140
			this.now = this.start + ((this.end - this.start) * this.pos);
4140
jQuery.each({
4141
4141
	appendTo: "append",
4142
			// Perform the next step of the animation
4142
	prependTo: "prepend",
4143
			this.update();
4143
	insertBefore: "before",
4144
		}
4144
	insertAfter: "after",
4145
4145
	replaceAll: "replaceWith"
4146
		return true;
4146
}, function( name, original ) {
4147
	}
4147
	jQuery.fn[ name ] = function( selector ) {
4148
4148
		var ret = [], insert = jQuery( selector );
4149
};
4149
4150
4150
		for ( var i = 0, l = insert.length; i < l; i++ ) {
4151
jQuery.extend( jQuery.fx, {
4151
			var elems = (i > 0 ? this.clone(true) : this).get();
4152
	speeds:{
4152
			jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
4153
		slow: 600,
4153
			ret = ret.concat( elems );
4154
 		fast: 200,
4154
		}
4155
 		// Default speed
4155
		return this.pushStack( ret, name, insert.selector );
4156
 		_default: 400
4156
	};
4157
	},
4157
});
4158
	step: {
4158
4159
4159
jQuery.each({
4160
		opacity: function(fx){
4160
	// keepData is for internal use only--do not document
4161
			jQuery.attr(fx.elem.style, "opacity", fx.now);
4161
	remove: function( selector, keepData ) {
4162
		},
4162
		if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
4163
4163
			if ( !keepData && this.nodeType === 1 ) {
4164
		_default: function(fx){
4164
				cleanData( this.getElementsByTagName("*") );
4165
			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null )
4165
				cleanData( [ this ] );
4166
				fx.elem.style[ fx.prop ] = fx.now + fx.unit;
4166
			}
4167
			else
4167
4168
				fx.elem[ fx.prop ] = fx.now;
4168
			if ( this.parentNode ) {
4169
		}
4169
				 this.parentNode.removeChild( this );
4170
	}
4170
			}
4171
});
4171
		}
4172
if ( document.documentElement["getBoundingClientRect"] )
4172
	},
4173
	jQuery.fn.offset = function() {
4173
4174
		if ( !this[0] ) return { top: 0, left: 0 };
4174
	empty: function() {
4175
		if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4175
		// Remove element nodes and prevent memory leaks
4176
		var box  = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement,
4176
		if ( this.nodeType === 1 ) {
4177
			clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
4177
			cleanData( this.getElementsByTagName("*") );
4178
			top  = box.top  + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
4178
		}
4179
			left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
4179
4180
		return { top: top, left: left };
4180
		// Remove any remaining nodes
4181
	};
4181
		while ( this.firstChild ) {
4182
else
4182
			this.removeChild( this.firstChild );
4183
	jQuery.fn.offset = function() {
4183
		}
4184
		if ( !this[0] ) return { top: 0, left: 0 };
4184
	}
4185
		if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4185
}, function( name, fn ) {
4186
		jQuery.offset.initialized || jQuery.offset.initialize();
4186
	jQuery.fn[ name ] = function() {
4187
4187
		return this.each( fn, arguments );
4188
		var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem,
4188
	};
4189
			doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
4189
});
4190
			body = doc.body, defaultView = doc.defaultView,
4190
4191
			prevComputedStyle = defaultView.getComputedStyle(elem, null),
4191
jQuery.extend({
4192
			top = elem.offsetTop, left = elem.offsetLeft;
4192
	clean: function( elems, context, fragment, scripts ) {
4193
4193
		context = context || document;
4194
		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
4194
4195
			computedStyle = defaultView.getComputedStyle(elem, null);
4195
		// !context.createElement fails in IE with an error but returns typeof 'object'
4196
			top -= elem.scrollTop, left -= elem.scrollLeft;
4196
		if ( typeof context.createElement === "undefined" ) {
4197
			if ( elem === offsetParent ) {
4197
			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
4198
				top += elem.offsetTop, left += elem.offsetLeft;
4198
		}
4199
				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) )
4199
4200
					top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
4200
		var ret = [];
4201
					left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
4201
4202
				prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
4202
		jQuery.each(elems, function( i, elem ) {
4203
			}
4203
			if ( typeof elem === "number" ) {
4204
			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
4204
				elem += "";
4205
				top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
4205
			}
4206
				left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
4206
4207
			prevComputedStyle = computedStyle;
4207
			if ( !elem ) {
4208
		}
4208
				return;
4209
4209
			}
4210
		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" )
4210
4211
			top  += body.offsetTop,
4211
			// Convert html string into DOM nodes
4212
			left += body.offsetLeft;
4212
			if ( typeof elem === "string" && !rhtml.test( elem ) ) {
4213
4213
				elem = context.createTextNode( elem );
4214
		if ( prevComputedStyle.position === "fixed" )
4214
4215
			top  += Math.max(docElem.scrollTop, body.scrollTop),
4215
			} else if ( typeof elem === "string" ) {
4216
			left += Math.max(docElem.scrollLeft, body.scrollLeft);
4216
				// Fix "XHTML"-style tags in all browsers
4217
4217
				elem = elem.replace(rxhtmlTag, fcloseTag);
4218
		return { top: top, left: left };
4218
4219
	};
4219
				// Trim whitespace, otherwise indexOf won't work as expected
4220
4220
				var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
4221
jQuery.offset = {
4221
					wrap = wrapMap[ tag ] || wrapMap._default,
4222
	initialize: function() {
4222
					depth = wrap[0],
4223
		if ( this.initialized ) return;
4223
					div = context.createElement("div");
4224
		var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marginTop,
4224
4225
			html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;" cellpadding="0" cellspacing="0"><tr><td></td></tr></table>';
4225
				// Go to html and back, then peel off extra wrappers
4226
4226
				div.innerHTML = wrap[1] + elem + wrap[2];
4227
		rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' };
4227
4228
		for ( prop in rules ) container.style[prop] = rules[prop];
4228
				// Move to the right depth
4229
4229
				while ( depth-- ) {
4230
		container.innerHTML = html;
4230
					div = div.lastChild;
4231
		body.insertBefore(container, body.firstChild);
4231
				}
4232
		innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;
4232
4233
4233
				// Remove IE's autoinserted <tbody> from table fragments
4234
		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
4234
				if ( !jQuery.support.tbody ) {
4235
		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
4235
4236
4236
					// String was a <table>, *may* have spurious <tbody>
4237
		innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
4237
					var hasBody = rtbody.test(elem),
4238
		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
4238
						tbody = tag === "table" && !hasBody ?
4239
4239
							div.firstChild && div.firstChild.childNodes :
4240
		body.style.marginTop = '1px';
4240
4241
		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
4241
							// String was a bare <thead> or <tfoot>
4242
		body.style.marginTop = bodyMarginTop;
4242
							wrap[1] === "<table>" && !hasBody ?
4243
4243
								div.childNodes :
4244
		body.removeChild(container);
4244
								[];
4245
		this.initialized = true;
4245
4246
	},
4246
					for ( var j = tbody.length - 1; j >= 0 ; --j ) {
4247
4247
						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
4248
	bodyOffset: function(body) {
4248
							tbody[ j ].parentNode.removeChild( tbody[ j ] );
4249
		jQuery.offset.initialized || jQuery.offset.initialize();
4249
						}
4250
		var top = body.offsetTop, left = body.offsetLeft;
4250
					}
4251
		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset )
4251
4252
			top  += parseInt( jQuery.curCSS(body, 'marginTop',  true), 10 ) || 0,
4252
				}
4253
			left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0;
4253
4254
		return { top: top, left: left };
4254
				// IE completely kills leading whitespace when innerHTML is used
4255
	}
4255
				if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
4256
};
4256
					div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
4257
4257
				}
4258
4258
4259
jQuery.fn.extend({
4259
				elem = jQuery.makeArray( div.childNodes );
4260
	position: function() {
4260
			}
4261
		var left = 0, top = 0, results;
4261
4262
4262
			if ( elem.nodeType ) {
4263
		if ( this[0] ) {
4263
				ret.push( elem );
4264
			// Get *real* offsetParent
4264
			} else {
4265
			var offsetParent = this.offsetParent(),
4265
				ret = jQuery.merge( ret, elem );
4266
4266
			}
4267
			// Get correct offsets
4267
4268
			offset       = this.offset(),
4268
		});
4269
			parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
4269
4270
4270
		if ( fragment ) {
4271
			// Subtract element margins
4271
			for ( var i = 0; ret[i]; i++ ) {
4272
			// note: when an element has margin: auto the offsetLeft and marginLeft
4272
				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
4273
			// are the same in Safari causing offset.left to incorrectly be 0
4273
					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
4274
			offset.top  -= num( this, 'marginTop'  );
4274
				} else {
4275
			offset.left -= num( this, 'marginLeft' );
4275
					if ( ret[i].nodeType === 1 ) {
4276
4276
						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
4277
			// Add offsetParent borders
4277
					}
4278
			parentOffset.top  += num( offsetParent, 'borderTopWidth'  );
4278
					fragment.appendChild( ret[i] );
4279
			parentOffset.left += num( offsetParent, 'borderLeftWidth' );
4279
				}
4280
4280
			}
4281
			// Subtract the two offsets
4281
		}
4282
			results = {
4282
4283
				top:  offset.top  - parentOffset.top,
4283
		return ret;
4284
				left: offset.left - parentOffset.left
4284
	}
4285
			};
4285
});
4286
		}
4286
4287
4287
function cleanData( elems ) {
4288
		return results;
4288
	for ( var i = 0, elem, id; (elem = elems[i]) != null; i++ ) {
4289
	},
4289
		if ( !jQuery.noData[elem.nodeName.toLowerCase()] && (id = elem[expando]) ) {
4290
4290
			delete jQuery.cache[ id ];
4291
	offsetParent: function() {
4291
		}
4292
		var offsetParent = this[0].offsetParent || document.body;
4292
	}
4293
		while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
4293
}
4294
			offsetParent = offsetParent.offsetParent;
4294
// exclude the following css properties to add px
4295
		return jQuery(offsetParent);
4295
var rexclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
4296
	}
4296
	ralpha = /alpha\([^)]*\)/,
4297
});
4297
	ropacity = /opacity=([^)]*)/,
4298
4298
	rfloat = /float/i,
4299
4299
	rdashAlpha = /-([a-z])/ig,
4300
// Create scrollLeft and scrollTop methods
4300
	rupper = /([A-Z])/g,
4301
jQuery.each( ['Left', 'Top'], function(i, name) {
4301
	rnumpx = /^-?\d+(?:px)?$/i,
4302
	var method = 'scroll' + name;
4302
	rnum = /^-?\d/,
4303
4303
4304
	jQuery.fn[ method ] = function(val) {
4304
	cssShow = { position: "absolute", visibility: "hidden", display:"block" },
4305
		if (!this[0]) return null;
4305
	cssWidth = [ "Left", "Right" ],
4306
4306
	cssHeight = [ "Top", "Bottom" ],
4307
		return val !== undefined ?
4307
4308
4308
	// cache check for defaultView.getComputedStyle
4309
			// Set the scroll offset
4309
	getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,
4310
			this.each(function() {
4310
	// normalize float css property
4311
				this == window || this == document ?
4311
	styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat",
4312
					window.scrollTo(
4312
	fcamelCase = function( all, letter ) {
4313
						!i ? val : jQuery(window).scrollLeft(),
4313
		return letter.toUpperCase();
4314
						 i ? val : jQuery(window).scrollTop()
4314
	};
4315
					) :
4315
4316
					this[ method ] = val;
4316
jQuery.fn.css = function( name, value ) {
4317
			}) :
4317
	return access( this, name, value, true, function( elem, name, value ) {
4318
4318
		if ( value === undefined ) {
4319
			// Return the scroll offset
4319
			return jQuery.curCSS( elem, name );
4320
			this[0] == window || this[0] == document ?
4320
		}
4321
				self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
4321
		
4322
					jQuery.boxModel && document.documentElement[ method ] ||
4322
		if ( typeof value === "number" && !rexclude.test(name) ) {
4323
					document.body[ method ] :
4323
			value += "px";
4324
				this[0][ method ];
4324
		}
4325
	};
4325
4326
});
4326
		jQuery.style( elem, name, value );
4327
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
4327
	});
4328
jQuery.each([ "Height", "Width" ], function(i, name){
4328
};
4329
4329
4330
	var tl = i ? "Left"  : "Top",  // top or left
4330
jQuery.extend({
4331
		br = i ? "Right" : "Bottom", // bottom or right
4331
	style: function( elem, name, value ) {
4332
		lower = name.toLowerCase();
4332
		// don't set styles on text and comment nodes
4333
4333
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
4334
	// innerHeight and innerWidth
4334
			return undefined;
4335
	jQuery.fn["inner" + name] = function(){
4335
		}
4336
		return this[0] ?
4336
4337
			jQuery.css( this[0], lower, false, "padding" ) :
4337
		// ignore negative width and height values #1599
4338
			null;
4338
		if ( (name === "width" || name === "height") && parseFloat(value) < 0 ) {
4339
	};
4339
			value = undefined;
4340
4340
		}
4341
	// outerHeight and outerWidth
4341
4342
	jQuery.fn["outer" + name] = function(margin) {
4342
		var style = elem.style || elem, set = value !== undefined;
4343
		return this[0] ?
4343
4344
			jQuery.css( this[0], lower, false, margin ? "margin" : "border" ) :
4344
		// IE uses filters for opacity
4345
			null;
4345
		if ( !jQuery.support.opacity && name === "opacity" ) {
4346
	};
4346
			if ( set ) {
4347
4347
				// IE has trouble with opacity if it does not have layout
4348
	var type = name.toLowerCase();
4348
				// Force it by setting the zoom level
4349
4349
				style.zoom = 1;
4350
	jQuery.fn[ type ] = function( size ) {
4350
4351
		// Get window width or height
4351
				// Set the alpha filter to set the opacity
4352
		return this[0] == window ?
4352
				var opacity = parseInt( value, 10 ) + "" === "NaN" ? "" : "alpha(opacity=" + value * 100 + ")";
4353
			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
4353
				var filter = style.filter || jQuery.curCSS( elem, "filter" ) || "";
4354
			document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] ||
4354
				style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : opacity;
4355
			document.body[ "client" + name ] :
4355
			}
4356
4356
4357
			// Get document width or height
4357
			return style.filter && style.filter.indexOf("opacity=") >= 0 ?
4358
			this[0] == document ?
4358
				(parseFloat( ropacity.exec(style.filter)[1] ) / 100) + "":
4359
				// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
4359
				"";
4360
				Math.max(
4360
		}
4361
					document.documentElement["client" + name],
4361
4362
					document.body["scroll" + name], document.documentElement["scroll" + name],
4362
		// Make sure we're using the right name for getting the float value
4363
					document.body["offset" + name], document.documentElement["offset" + name]
4363
		if ( rfloat.test( name ) ) {
4364
				) :
4364
			name = styleFloat;
4365
4365
		}
4366
				// Get or set width or height on the element
4366
4367
				size === undefined ?
4367
		name = name.replace(rdashAlpha, fcamelCase);
4368
					// Get width or height on the element
4368
4369
					(this.length ? jQuery.css( this[0], type ) : null) :
4369
		if ( set ) {
4370
4370
			style[ name ] = value;
4371
					// Set the width or height on the element (default to pixels if value is unitless)
4371
		}
4372
					this.css( type, typeof size === "string" ? size : size + "px" );
4372
4373
	};
4373
		return style[ name ];
4374
4374
	},
4375
});
4375
4376
})();
4376
	css: function( elem, name, force, extra ) {
4377
		if ( name === "width" || name === "height" ) {
4378
			var val, props = cssShow, which = name === "width" ? cssWidth : cssHeight;
4379
4380
			function getWH() {
4381
				val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
4382
4383
				if ( extra === "border" ) {
4384
					return;
4385
				}
4386
4387
				jQuery.each( which, function() {
4388
					if ( !extra ) {
4389
						val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
4390
					}
4391
4392
					if ( extra === "margin" ) {
4393
						val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
4394
					} else {
4395
						val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
4396
					}
4397
				});
4398
			}
4399
4400
			if ( elem.offsetWidth !== 0 ) {
4401
				getWH();
4402
			} else {
4403
				jQuery.swap( elem, props, getWH );
4404
			}
4405
4406
			return Math.max(0, Math.round(val));
4407
		}
4408
4409
		return jQuery.curCSS( elem, name, force );
4410
	},
4411
4412
	curCSS: function( elem, name, force ) {
4413
		var ret, style = elem.style, filter;
4414
4415
		// IE uses filters for opacity
4416
		if ( !jQuery.support.opacity && name === "opacity" && elem.currentStyle ) {
4417
			ret = ropacity.test(elem.currentStyle.filter || "") ?
4418
				(parseFloat(RegExp.$1) / 100) + "" :
4419
				"";
4420
4421
			return ret === "" ?
4422
				"1" :
4423
				ret;
4424
		}
4425
4426
		// Make sure we're using the right name for getting the float value
4427
		if ( rfloat.test( name ) ) {
4428
			name = styleFloat;
4429
		}
4430
4431
		if ( !force && style && style[ name ] ) {
4432
			ret = style[ name ];
4433
4434
		} else if ( getComputedStyle ) {
4435
4436
			// Only "float" is needed here
4437
			if ( rfloat.test( name ) ) {
4438
				name = "float";
4439
			}
4440
4441
			name = name.replace( rupper, "-$1" ).toLowerCase();
4442
4443
			var defaultView = elem.ownerDocument.defaultView;
4444
4445
			if ( !defaultView ) {
4446
				return null;
4447
			}
4448
4449
			var computedStyle = defaultView.getComputedStyle( elem, null );
4450
4451
			if ( computedStyle ) {
4452
				ret = computedStyle.getPropertyValue( name );
4453
			}
4454
4455
			// We should always get a number back from opacity
4456
			if ( name === "opacity" && ret === "" ) {
4457
				ret = "1";
4458
			}
4459
4460
		} else if ( elem.currentStyle ) {
4461
			var camelCase = name.replace(rdashAlpha, fcamelCase);
4462
4463
			ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
4464
4465
			// From the awesome hack by Dean Edwards
4466
			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
4467
4468
			// If we're not dealing with a regular pixel number
4469
			// but a number that has a weird ending, we need to convert it to pixels
4470
			if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
4471
				// Remember the original values
4472
				var left = style.left, rsLeft = elem.runtimeStyle.left;
4473
4474
				// Put in the new values to get a computed value out
4475
				elem.runtimeStyle.left = elem.currentStyle.left;
4476
				style.left = camelCase === "fontSize" ? "1em" : (ret || 0);
4477
				ret = style.pixelLeft + "px";
4478
4479
				// Revert the changed values
4480
				style.left = left;
4481
				elem.runtimeStyle.left = rsLeft;
4482
			}
4483
		}
4484
4485
		return ret;
4486
	},
4487
4488
	// A method for quickly swapping in/out CSS properties to get correct calculations
4489
	swap: function( elem, options, callback ) {
4490
		var old = {};
4491
4492
		// Remember the old values, and insert the new ones
4493
		for ( var name in options ) {
4494
			old[ name ] = elem.style[ name ];
4495
			elem.style[ name ] = options[ name ];
4496
		}
4497
4498
		callback.call( elem );
4499
4500
		// Revert the old values
4501
		for ( var name in options ) {
4502
			elem.style[ name ] = old[ name ];
4503
		}
4504
	}
4505
});
4506
4507
if ( jQuery.expr && jQuery.expr.filters ) {
4508
	jQuery.expr.filters.hidden = function( elem ) {
4509
		var width = elem.offsetWidth, height = elem.offsetHeight,
4510
			skip = elem.nodeName.toLowerCase() === "tr";
4511
4512
		return width === 0 && height === 0 && !skip ?
4513
			true :
4514
			width > 0 && height > 0 && !skip ?
4515
				false :
4516
				jQuery.curCSS(elem, "display") === "none";
4517
	};
4518
4519
	jQuery.expr.filters.visible = function( elem ) {
4520
		return !jQuery.expr.filters.hidden( elem );
4521
	};
4522
}
4523
var jsc = now(),
4524
	rscript = /<script(.|\s)*?\/script>/gi,
4525
	rselectTextarea = /select|textarea/i,
4526
	rinput = /color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,
4527
	jsre = /=\?(&|$)/,
4528
	rquery = /\?/,
4529
	rts = /(\?|&)_=.*?(&|$)/,
4530
	rurl = /^(\w+:)?\/\/([^\/?#]+)/,
4531
	r20 = /%20/g;
4532
4533
jQuery.fn.extend({
4534
	// Keep a copy of the old load
4535
	_load: jQuery.fn.load,
4536
4537
	load: function( url, params, callback ) {
4538
		if ( typeof url !== "string" ) {
4539
			return this._load( url );
4540
4541
		// Don't do a request if no elements are being requested
4542
		} else if ( !this.length ) {
4543
			return this;
4544
		}
4545
4546
		var off = url.indexOf(" ");
4547
		if ( off >= 0 ) {
4548
			var selector = url.slice(off, url.length);
4549
			url = url.slice(0, off);
4550
		}
4551
4552
		// Default to a GET request
4553
		var type = "GET";
4554
4555
		// If the second parameter was provided
4556
		if ( params ) {
4557
			// If it's a function
4558
			if ( jQuery.isFunction( params ) ) {
4559
				// We assume that it's the callback
4560
				callback = params;
4561
				params = null;
4562
4563
			// Otherwise, build a param string
4564
			} else if ( typeof params === "object" ) {
4565
				params = jQuery.param( params, jQuery.ajaxSettings.traditional );
4566
				type = "POST";
4567
			}
4568
		}
4569
4570
		// Request the remote document
4571
		jQuery.ajax({
4572
			url: url,
4573
			type: type,
4574
			dataType: "html",
4575
			data: params,
4576
			context:this,
4577
			complete: function( res, status ) {
4578
				// If successful, inject the HTML into all the matched elements
4579
				if ( status === "success" || status === "notmodified" ) {
4580
					// See if a selector was specified
4581
					this.html( selector ?
4582
						// Create a dummy div to hold the results
4583
						jQuery("<div />")
4584
							// inject the contents of the document in, removing the scripts
4585
							// to avoid any 'Permission Denied' errors in IE
4586
							.append(res.responseText.replace(rscript, ""))
4587
4588
							// Locate the specified elements
4589
							.find(selector) :
4590
4591
						// If not, just inject the full result
4592
						res.responseText );
4593
				}
4594
4595
				if ( callback ) {
4596
					this.each( callback, [res.responseText, status, res] );
4597
				}
4598
			}
4599
		});
4600
4601
		return this;
4602
	},
4603
4604
	serialize: function() {
4605
		return jQuery.param(this.serializeArray());
4606
	},
4607
	serializeArray: function() {
4608
		return this.map(function() {
4609
			return this.elements ? jQuery.makeArray(this.elements) : this;
4610
		})
4611
		.filter(function() {
4612
			return this.name && !this.disabled &&
4613
				(this.checked || rselectTextarea.test(this.nodeName) ||
4614
					rinput.test(this.type));
4615
		})
4616
		.map(function( i, elem ) {
4617
			var val = jQuery(this).val();
4618
4619
			return val == null ?
4620
				null :
4621
				jQuery.isArray(val) ?
4622
					jQuery.map( val, function( val, i ) {
4623
						return { name: elem.name, value: val };
4624
					}) :
4625
					{ name: elem.name, value: val };
4626
		}).get();
4627
	}
4628
});
4629
4630
// Attach a bunch of functions for handling common AJAX events
4631
jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
4632
	jQuery.fn[o] = function( f ) {
4633
		return this.bind(o, f);
4634
	};
4635
});
4636
4637
jQuery.extend({
4638
4639
	get: function( url, data, callback, type ) {
4640
		// shift arguments if data argument was omited
4641
		if ( jQuery.isFunction( data ) ) {
4642
			type = type || callback;
4643
			callback = data;
4644
			data = null;
4645
		}
4646
4647
		return jQuery.ajax({
4648
			type: "GET",
4649
			url: url,
4650
			data: data,
4651
			success: callback,
4652
			dataType: type
4653
		});
4654
	},
4655
4656
	getScript: function( url, callback ) {
4657
		return jQuery.get(url, null, callback, "script");
4658
	},
4659
4660
	getJSON: function( url, data, callback ) {
4661
		return jQuery.get(url, data, callback, "json");
4662
	},
4663
4664
	post: function( url, data, callback, type ) {
4665
		// shift arguments if data argument was omited
4666
		if ( jQuery.isFunction( data ) ) {
4667
			type = type || callback;
4668
			callback = data;
4669
			data = {};
4670
		}
4671
4672
		return jQuery.ajax({
4673
			type: "POST",
4674
			url: url,
4675
			data: data,
4676
			success: callback,
4677
			dataType: type
4678
		});
4679
	},
4680
4681
	ajaxSetup: function( settings ) {
4682
		jQuery.extend( jQuery.ajaxSettings, settings );
4683
	},
4684
4685
	ajaxSettings: {
4686
		url: location.href,
4687
		global: true,
4688
		type: "GET",
4689
		contentType: "application/x-www-form-urlencoded",
4690
		processData: true,
4691
		async: true,
4692
		/*
4693
		timeout: 0,
4694
		data: null,
4695
		username: null,
4696
		password: null,
4697
		traditional: false,
4698
		*/
4699
		// Create the request object; Microsoft failed to properly
4700
		// implement the XMLHttpRequest in IE7 (can't request local files),
4701
		// so we use the ActiveXObject when it is available
4702
		// This function can be overriden by calling jQuery.ajaxSetup
4703
		xhr: window.XMLHttpRequest && (window.location.protocol !== "file:" || !window.ActiveXObject) ?
4704
			function() {
4705
				return new window.XMLHttpRequest();
4706
			} :
4707
			function() {
4708
				try {
4709
					return new window.ActiveXObject("Microsoft.XMLHTTP");
4710
				} catch(e) {}
4711
			},
4712
		accepts: {
4713
			xml: "application/xml, text/xml",
4714
			html: "text/html",
4715
			script: "text/javascript, application/javascript",
4716
			json: "application/json, text/javascript",
4717
			text: "text/plain",
4718
			_default: "*/*"
4719
		}
4720
	},
4721
4722
	// Last-Modified header cache for next request
4723
	lastModified: {},
4724
	etag: {},
4725
4726
	ajax: function( origSettings ) {
4727
		var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings);
4728
		
4729
		var jsonp, status, data,
4730
			callbackContext = s.context || s,
4731
			type = s.type.toUpperCase();
4732
4733
		// convert data if not already a string
4734
		if ( s.data && s.processData && typeof s.data !== "string" ) {
4735
			s.data = jQuery.param( s.data, s.traditional );
4736
		}
4737
4738
		// Handle JSONP Parameter Callbacks
4739
		if ( s.dataType === "jsonp" ) {
4740
			if ( type === "GET" ) {
4741
				if ( !jsre.test( s.url ) ) {
4742
					s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
4743
				}
4744
			} else if ( !s.data || !jsre.test(s.data) ) {
4745
				s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
4746
			}
4747
			s.dataType = "json";
4748
		}
4749
4750
		// Build temporary JSONP function
4751
		if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
4752
			jsonp = s.jsonpCallback || ("jsonp" + jsc++);
4753
4754
			// Replace the =? sequence both in the query string and the data
4755
			if ( s.data ) {
4756
				s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
4757
			}
4758
4759
			s.url = s.url.replace(jsre, "=" + jsonp + "$1");
4760
4761
			// We need to make sure
4762
			// that a JSONP style response is executed properly
4763
			s.dataType = "script";
4764
4765
			// Handle JSONP-style loading
4766
			window[ jsonp ] = window[ jsonp ] || function( tmp ) {
4767
				data = tmp;
4768
				success();
4769
				complete();
4770
				// Garbage collect
4771
				window[ jsonp ] = undefined;
4772
4773
				try {
4774
					delete window[ jsonp ];
4775
				} catch(e) {}
4776
4777
				if ( head ) {
4778
					head.removeChild( script );
4779
				}
4780
			};
4781
		}
4782
4783
		if ( s.dataType === "script" && s.cache === null ) {
4784
			s.cache = false;
4785
		}
4786
4787
		if ( s.cache === false && type === "GET" ) {
4788
			var ts = now();
4789
4790
			// try replacing _= if it is there
4791
			var ret = s.url.replace(rts, "$1_=" + ts + "$2");
4792
4793
			// if nothing was replaced, add timestamp to the end
4794
			s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
4795
		}
4796
4797
		// If data is available, append data to url for get requests
4798
		if ( s.data && type === "GET" ) {
4799
			s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
4800
		}
4801
4802
		// Watch for a new set of requests
4803
		if ( s.global && ! jQuery.active++ ) {
4804
			jQuery.event.trigger( "ajaxStart" );
4805
		}
4806
4807
		// Matches an absolute URL, and saves the domain
4808
		var parts = rurl.exec( s.url ),
4809
			remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
4810
4811
		// If we're requesting a remote document
4812
		// and trying to load JSON or Script with a GET
4813
		if ( s.dataType === "script" && type === "GET" && remote ) {
4814
			var head = document.getElementsByTagName("head")[0] || document.documentElement;
4815
			var script = document.createElement("script");
4816
			script.src = s.url;
4817
			if ( s.scriptCharset ) {
4818
				script.charset = s.scriptCharset;
4819
			}
4820
4821
			// Handle Script loading
4822
			if ( !jsonp ) {
4823
				var done = false;
4824
4825
				// Attach handlers for all browsers
4826
				script.onload = script.onreadystatechange = function() {
4827
					if ( !done && (!this.readyState ||
4828
							this.readyState === "loaded" || this.readyState === "complete") ) {
4829
						done = true;
4830
						success();
4831
						complete();
4832
4833
						// Handle memory leak in IE
4834
						script.onload = script.onreadystatechange = null;
4835
						if ( head && script.parentNode ) {
4836
							head.removeChild( script );
4837
						}
4838
					}
4839
				};
4840
			}
4841
4842
			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
4843
			// This arises when a base node is used (#2709 and #4378).
4844
			head.insertBefore( script, head.firstChild );
4845
4846
			// We handle everything using the script element injection
4847
			return undefined;
4848
		}
4849
4850
		var requestDone = false;
4851
4852
		// Create the request object
4853
		var xhr = s.xhr();
4854
4855
		if ( !xhr ) {
4856
			return;
4857
		}
4858
4859
		// Open the socket
4860
		// Passing null username, generates a login popup on Opera (#2865)
4861
		if ( s.username ) {
4862
			xhr.open(type, s.url, s.async, s.username, s.password);
4863
		} else {
4864
			xhr.open(type, s.url, s.async);
4865
		}
4866
4867
		// Need an extra try/catch for cross domain requests in Firefox 3
4868
		try {
4869
			// Set the correct header, if data is being sent
4870
			if ( s.data || origSettings && origSettings.contentType ) {
4871
				xhr.setRequestHeader("Content-Type", s.contentType);
4872
			}
4873
4874
			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
4875
			if ( s.ifModified ) {
4876
				if ( jQuery.lastModified[s.url] ) {
4877
					xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
4878
				}
4879
4880
				if ( jQuery.etag[s.url] ) {
4881
					xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
4882
				}
4883
			}
4884
4885
			// Set header so the called script knows that it's an XMLHttpRequest
4886
			// Only send the header if it's not a remote XHR
4887
			if ( !remote ) {
4888
				xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
4889
			}
4890
4891
			// Set the Accepts header for the server, depending on the dataType
4892
			xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
4893
				s.accepts[ s.dataType ] + ", */*" :
4894
				s.accepts._default );
4895
		} catch(e) {}
4896
4897
		// Allow custom headers/mimetypes and early abort
4898
		if ( s.beforeSend && s.beforeSend.call(callbackContext, xhr, s) === false ) {
4899
			// Handle the global AJAX counter
4900
			if ( s.global && ! --jQuery.active ) {
4901
				jQuery.event.trigger( "ajaxStop" );
4902
			}
4903
4904
			// close opended socket
4905
			xhr.abort();
4906
			return false;
4907
		}
4908
4909
		if ( s.global ) {
4910
			trigger("ajaxSend", [xhr, s]);
4911
		}
4912
4913
		// Wait for a response to come back
4914
		var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
4915
			// The request was aborted
4916
			if ( !xhr || xhr.readyState === 0 ) {
4917
				// Opera doesn't call onreadystatechange before this point
4918
				// so we simulate the call
4919
				if ( !requestDone ) {
4920
					complete();
4921
				}
4922
4923
				requestDone = true;
4924
				if ( xhr ) {
4925
					xhr.onreadystatechange = jQuery.noop;
4926
				}
4927
4928
			// The transfer is complete and the data is available, or the request timed out
4929
			} else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
4930
				requestDone = true;
4931
				xhr.onreadystatechange = jQuery.noop;
4932
4933
				status = isTimeout === "timeout" ?
4934
					"timeout" :
4935
					!jQuery.httpSuccess( xhr ) ?
4936
						"error" :
4937
						s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
4938
							"notmodified" :
4939
							"success";
4940
4941
				if ( status === "success" ) {
4942
					// Watch for, and catch, XML document parse errors
4943
					try {
4944
						// process the data (runs the xml through httpData regardless of callback)
4945
						data = jQuery.httpData( xhr, s.dataType, s );
4946
					} catch(e) {
4947
						status = "parsererror";
4948
					}
4949
				}
4950
4951
				// Make sure that the request was successful or notmodified
4952
				if ( status === "success" || status === "notmodified" ) {
4953
					// JSONP handles its own success callback
4954
					if ( !jsonp ) {
4955
						success();
4956
					}
4957
				} else {
4958
					jQuery.handleError(s, xhr, status);
4959
				}
4960
4961
				// Fire the complete handlers
4962
				complete();
4963
4964
				if ( isTimeout === "timeout" ) {
4965
					xhr.abort();
4966
				}
4967
4968
				// Stop memory leaks
4969
				if ( s.async ) {
4970
					xhr = null;
4971
				}
4972
			}
4973
		};
4974
4975
		// Override the abort handler, if we can (IE doesn't allow it, but that's OK)
4976
		// Opera doesn't fire onreadystatechange at all on abort
4977
		try {
4978
			var oldAbort = xhr.abort;
4979
			xhr.abort = function() {
4980
				if ( xhr ) {
4981
					oldAbort.call( xhr );
4982
					if ( xhr ) {
4983
						xhr.readyState = 0;
4984
					}
4985
				}
4986
4987
				onreadystatechange();
4988
			};
4989
		} catch(e) { }
4990
4991
		// Timeout checker
4992
		if ( s.async && s.timeout > 0 ) {
4993
			setTimeout(function() {
4994
				// Check to see if the request is still happening
4995
				if ( xhr && !requestDone ) {
4996
					onreadystatechange( "timeout" );
4997
				}
4998
			}, s.timeout);
4999
		}
5000
5001
		// Send the data
5002
		try {
5003
			xhr.send( type === "POST" || type === "PUT" || type === "DELETE" ? s.data : null );
5004
		} catch(e) {
5005
			jQuery.handleError(s, xhr, null, e);
5006
			// Fire the complete handlers
5007
			complete();
5008
		}
5009
5010
		// firefox 1.5 doesn't fire statechange for sync requests
5011
		if ( !s.async ) {
5012
			onreadystatechange();
5013
		}
5014
5015
		function success() {
5016
			// If a local callback was specified, fire it and pass it the data
5017
			if ( s.success ) {
5018
				s.success.call( callbackContext, data, status, xhr );
5019
			}
5020
5021
			// Fire the global callback
5022
			if ( s.global ) {
5023
				trigger( "ajaxSuccess", [xhr, s] );
5024
			}
5025
		}
5026
5027
		function complete() {
5028
			// Process result
5029
			if ( s.complete ) {
5030
				s.complete.call( callbackContext, xhr, status);
5031
			}
5032
5033
			// The request was completed
5034
			if ( s.global ) {
5035
				trigger( "ajaxComplete", [xhr, s] );
5036
			}
5037
5038
			// Handle the global AJAX counter
5039
			if ( s.global && ! --jQuery.active ) {
5040
				jQuery.event.trigger( "ajaxStop" );
5041
			}
5042
		}
5043
		
5044
		function trigger(type, args) {
5045
			(s.context ? jQuery(s.context) : jQuery.event).trigger(type, args);
5046
		}
5047
5048
		// return XMLHttpRequest to allow aborting the request etc.
5049
		return xhr;
5050
	},
5051
5052
	handleError: function( s, xhr, status, e ) {
5053
		// If a local callback was specified, fire it
5054
		if ( s.error ) {
5055
			s.error.call( s.context || window, xhr, status, e );
5056
		}
5057
5058
		// Fire the global callback
5059
		if ( s.global ) {
5060
			(s.context ? jQuery(s.context) : jQuery.event).trigger( "ajaxError", [xhr, s, e] );
5061
		}
5062
	},
5063
5064
	// Counter for holding the number of active queries
5065
	active: 0,
5066
5067
	// Determines if an XMLHttpRequest was successful or not
5068
	httpSuccess: function( xhr ) {
5069
		try {
5070
			// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
5071
			return !xhr.status && location.protocol === "file:" ||
5072
				// Opera returns 0 when status is 304
5073
				( xhr.status >= 200 && xhr.status < 300 ) ||
5074
				xhr.status === 304 || xhr.status === 1223 || xhr.status === 0;
5075
		} catch(e) {}
5076
5077
		return false;
5078
	},
5079
5080
	// Determines if an XMLHttpRequest returns NotModified
5081
	httpNotModified: function( xhr, url ) {
5082
		var lastModified = xhr.getResponseHeader("Last-Modified"),
5083
			etag = xhr.getResponseHeader("Etag");
5084
5085
		if ( lastModified ) {
5086
			jQuery.lastModified[url] = lastModified;
5087
		}
5088
5089
		if ( etag ) {
5090
			jQuery.etag[url] = etag;
5091
		}
5092
5093
		// Opera returns 0 when status is 304
5094
		return xhr.status === 304 || xhr.status === 0;
5095
	},
5096
5097
	httpData: function( xhr, type, s ) {
5098
		var ct = xhr.getResponseHeader("content-type") || "",
5099
			xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
5100
			data = xml ? xhr.responseXML : xhr.responseText;
5101
5102
		if ( xml && data.documentElement.nodeName === "parsererror" ) {
5103
			throw "parsererror";
5104
		}
5105
5106
		// Allow a pre-filtering function to sanitize the response
5107
		// s is checked to keep backwards compatibility
5108
		if ( s && s.dataFilter ) {
5109
			data = s.dataFilter( data, type );
5110
		}
5111
5112
		// The filter can actually parse the response
5113
		if ( typeof data === "string" ) {
5114
			// Get the JavaScript object, if JSON is used.
5115
			if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
5116
				// Make sure the incoming data is actual JSON
5117
				// Logic borrowed from http://json.org/json2.js
5118
				if (/^[\],:{}\s]*$/.test(data.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
5119
					.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]")
5120
					.replace(/(?:^|:|,)(?:\s*\[)+/g, ""))) {
5121
5122
					// Try to use the native JSON parser first
5123
					if ( window.JSON && window.JSON.parse ) {
5124
						data = window.JSON.parse( data );
5125
5126
					} else {
5127
						data = (new Function("return " + data))();
5128
					}
5129
5130
				} else {
5131
					throw "Invalid JSON: " + data;
5132
				}
5133
5134
			// If the type is "script", eval it in global context
5135
			} else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
5136
				jQuery.globalEval( data );
5137
			}
5138
		}
5139
5140
		return data;
5141
	},
5142
5143
	// Serialize an array of form elements or a set of
5144
	// key/values into a query string
5145
	param: function( a, traditional ) {
5146
		
5147
		var s = [];
5148
		
5149
		// Set traditional to true for jQuery <= 1.3.2 behavior.
5150
		if ( traditional === undefined ) {
5151
			traditional = jQuery.ajaxSettings.traditional;
5152
		}
5153
		
5154
		function add( key, value ) {
5155
			// If value is a function, invoke it and return its value
5156
			value = jQuery.isFunction(value) ? value() : value;
5157
			s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
5158
		}
5159
		
5160
		// If an array was passed in, assume that it is an array of form elements.
5161
		if ( jQuery.isArray(a) || a.jquery ) {
5162
			// Serialize the form elements
5163
			jQuery.each( a, function() {
5164
				add( this.name, this.value );
5165
			});
5166
			
5167
		} else {
5168
			// If traditional, encode the "old" way (the way 1.3.2 or older
5169
			// did it), otherwise encode params recursively.
5170
			jQuery.each( a, function buildParams( prefix, obj ) {
5171
				
5172
				if ( jQuery.isArray(obj) ) {
5173
					// Serialize array item.
5174
					jQuery.each( obj, function( i, v ) {
5175
						if ( traditional ) {
5176
							// Treat each array item as a scalar.
5177
							add( prefix, v );
5178
						} else {
5179
							// If array item is non-scalar (array or object), encode its
5180
							// numeric index to resolve deserialization ambiguity issues.
5181
							// Note that rack (as of 1.0.0) can't currently deserialize
5182
							// nested arrays properly, and attempting to do so may cause
5183
							// a server error. Possible fixes are to modify rack's
5184
							// deserialization algorithm or to provide an option or flag
5185
							// to force array serialization to be shallow.
5186
							buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v );
5187
						}
5188
					});
5189
					
5190
				} else if ( !traditional && obj != null && typeof obj === "object" ) {
5191
					// Serialize object item.
5192
					jQuery.each( obj, function( k, v ) {
5193
						buildParams( prefix + "[" + k + "]", v );
5194
					});
5195
					
5196
				} else {
5197
					// Serialize scalar item.
5198
					add( prefix, obj );
5199
				}
5200
			});
5201
		}
5202
		
5203
		// Return the resulting serialization
5204
		return s.join("&").replace(r20, "+");
5205
	}
5206
5207
});
5208
var elemdisplay = {},
5209
	rfxtypes = /toggle|show|hide/,
5210
	rfxnum = /^([+-]=)?([\d+-.]+)(.*)$/,
5211
	timerId,
5212
	fxAttrs = [
5213
		// height animations
5214
		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
5215
		// width animations
5216
		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
5217
		// opacity animations
5218
		[ "opacity" ]
5219
	];
5220
5221
jQuery.fn.extend({
5222
	show: function( speed, callback ) {
5223
		if ( speed != null ) {
5224
			return this.animate( genFx("show", 3), speed, callback);
5225
5226
		} else {
5227
			for ( var i = 0, l = this.length; i < l; i++ ) {
5228
				var old = jQuery.data(this[i], "olddisplay");
5229
5230
				this[i].style.display = old || "";
5231
5232
				if ( jQuery.css(this[i], "display") === "none" ) {
5233
					var nodeName = this[i].nodeName, display;
5234
5235
					if ( elemdisplay[ nodeName ] ) {
5236
						display = elemdisplay[ nodeName ];
5237
5238
					} else {
5239
						var elem = jQuery("<" + nodeName + " />").appendTo("body");
5240
5241
						display = elem.css("display");
5242
5243
						if ( display === "none" ) {
5244
							display = "block";
5245
						}
5246
5247
						elem.remove();
5248
5249
						elemdisplay[ nodeName ] = display;
5250
					}
5251
5252
					jQuery.data(this[i], "olddisplay", display);
5253
				}
5254
			}
5255
5256
			// Set the display of the elements in a second loop
5257
			// to avoid the constant reflow
5258
			for ( var j = 0, k = this.length; j < k; j++ ) {
5259
				this[j].style.display = jQuery.data(this[j], "olddisplay") || "";
5260
			}
5261
5262
			return this;
5263
		}
5264
	},
5265
5266
	hide: function( speed, callback ) {
5267
		if ( speed != null ) {
5268
			return this.animate( genFx("hide", 3), speed, callback);
5269
5270
		} else {
5271
			for ( var i = 0, l = this.length; i < l; i++ ) {
5272
				var old = jQuery.data(this[i], "olddisplay");
5273
				if ( !old && old !== "none" ) {
5274
					jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
5275
				}
5276
			}
5277
5278
			// Set the display of the elements in a second loop
5279
			// to avoid the constant reflow
5280
			for ( var j = 0, k = this.length; j < k; j++ ) {
5281
				this[j].style.display = "none";
5282
			}
5283
5284
			return this;
5285
		}
5286
	},
5287
5288
	// Save the old toggle function
5289
	_toggle: jQuery.fn.toggle,
5290
5291
	toggle: function( fn, fn2 ) {
5292
		var bool = typeof fn === "boolean";
5293
5294
		if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
5295
			this._toggle.apply( this, arguments );
5296
5297
		} else if ( fn == null || bool ) {
5298
			this.each(function() {
5299
				var state = bool ? fn : jQuery(this).is(":hidden");
5300
				jQuery(this)[ state ? "show" : "hide" ]();
5301
			});
5302
5303
		} else {
5304
			this.animate(genFx("toggle", 3), fn, fn2);
5305
		}
5306
5307
		return this;
5308
	},
5309
5310
	fadeTo: function( speed, to, callback ) {
5311
		return this.filter(":hidden").css("opacity", 0).show().end()
5312
					.animate({opacity: to}, speed, callback);
5313
	},
5314
5315
	animate: function( prop, speed, easing, callback ) {
5316
		var optall = jQuery.speed(speed, easing, callback);
5317
5318
		if ( jQuery.isEmptyObject( prop ) ) {
5319
			return this.each( optall.complete );
5320
		}
5321
5322
		return this[ optall.queue === false ? "each" : "queue" ](function() {
5323
			var opt = jQuery.extend({}, optall), p,
5324
				hidden = this.nodeType === 1 && jQuery(this).is(":hidden"),
5325
				self = this;
5326
5327
			for ( p in prop ) {
5328
				var name = p.replace(rdashAlpha, fcamelCase);
5329
5330
				if ( p !== name ) {
5331
					prop[ name ] = prop[ p ];
5332
					delete prop[ p ];
5333
					p = name;
5334
				}
5335
5336
				if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
5337
					return opt.complete.call(this);
5338
				}
5339
5340
				if ( ( p === "height" || p === "width" ) && this.style ) {
5341
					// Store display property
5342
					opt.display = jQuery.css(this, "display");
5343
5344
					// Make sure that nothing sneaks out
5345
					opt.overflow = this.style.overflow;
5346
				}
5347
5348
				if ( jQuery.isArray( prop[p] ) ) {
5349
					// Create (if needed) and add to specialEasing
5350
					(opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
5351
					prop[p] = prop[p][0];
5352
				}
5353
			}
5354
5355
			if ( opt.overflow != null ) {
5356
				this.style.overflow = "hidden";
5357
			}
5358
5359
			opt.curAnim = jQuery.extend({}, prop);
5360
5361
			jQuery.each( prop, function( name, val ) {
5362
				var e = new jQuery.fx( self, opt, name );
5363
5364
				if ( rfxtypes.test(val) ) {
5365
					e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
5366
5367
				} else {
5368
					var parts = rfxnum.exec(val),
5369
						start = e.cur(true) || 0;
5370
5371
					if ( parts ) {
5372
						var end = parseFloat( parts[2] ),
5373
							unit = parts[3] || "px";
5374
5375
						// We need to compute starting value
5376
						if ( unit !== "px" ) {
5377
							self.style[ name ] = (end || 1) + unit;
5378
							start = ((end || 1) / e.cur(true)) * start;
5379
							self.style[ name ] = start + unit;
5380
						}
5381
5382
						// If a +=/-= token was provided, we're doing a relative animation
5383
						if ( parts[1] ) {
5384
							end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
5385
						}
5386
5387
						e.custom( start, end, unit );
5388
5389
					} else {
5390
						e.custom( start, val, "" );
5391
					}
5392
				}
5393
			});
5394
5395
			// For JS strict compliance
5396
			return true;
5397
		});
5398
	},
5399
5400
	stop: function( clearQueue, gotoEnd ) {
5401
		var timers = jQuery.timers;
5402
5403
		if ( clearQueue ) {
5404
			this.queue([]);
5405
		}
5406
5407
		this.each(function() {
5408
			// go in reverse order so anything added to the queue during the loop is ignored
5409
			for ( var i = timers.length - 1; i >= 0; i-- ) {
5410
				if ( timers[i].elem === this ) {
5411
					if (gotoEnd) {
5412
						// force the next step to be the last
5413
						timers[i](true);
5414
					}
5415
5416
					timers.splice(i, 1);
5417
				}
5418
			}
5419
		});
5420
5421
		// start the next in the queue if the last step wasn't forced
5422
		if ( !gotoEnd ) {
5423
			this.dequeue();
5424
		}
5425
5426
		return this;
5427
	}
5428
5429
});
5430
5431
// Generate shortcuts for custom animations
5432
jQuery.each({
5433
	slideDown: genFx("show", 1),
5434
	slideUp: genFx("hide", 1),
5435
	slideToggle: genFx("toggle", 1),
5436
	fadeIn: { opacity: "show" },
5437
	fadeOut: { opacity: "hide" }
5438
}, function( name, props ) {
5439
	jQuery.fn[ name ] = function( speed, callback ) {
5440
		return this.animate( props, speed, callback );
5441
	};
5442
});
5443
5444
jQuery.extend({
5445
	speed: function( speed, easing, fn ) {
5446
		var opt = speed && typeof speed === "object" ? speed : {
5447
			complete: fn || !fn && easing ||
5448
				jQuery.isFunction( speed ) && speed,
5449
			duration: speed,
5450
			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
5451
		};
5452
5453
		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
5454
			jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
5455
5456
		// Queueing
5457
		opt.old = opt.complete;
5458
		opt.complete = function() {
5459
			if ( opt.queue !== false ) {
5460
				jQuery(this).dequeue();
5461
			}
5462
			if ( jQuery.isFunction( opt.old ) ) {
5463
				opt.old.call( this );
5464
			}
5465
		};
5466
5467
		return opt;
5468
	},
5469
5470
	easing: {
5471
		linear: function( p, n, firstNum, diff ) {
5472
			return firstNum + diff * p;
5473
		},
5474
		swing: function( p, n, firstNum, diff ) {
5475
			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
5476
		}
5477
	},
5478
5479
	timers: [],
5480
5481
	fx: function( elem, options, prop ) {
5482
		this.options = options;
5483
		this.elem = elem;
5484
		this.prop = prop;
5485
5486
		if ( !options.orig ) {
5487
			options.orig = {};
5488
		}
5489
	}
5490
5491
});
5492
5493
jQuery.fx.prototype = {
5494
	// Simple function for setting a style value
5495
	update: function() {
5496
		if ( this.options.step ) {
5497
			this.options.step.call( this.elem, this.now, this );
5498
		}
5499
5500
		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
5501
5502
		// Set display property to block for height/width animations
5503
		if ( ( this.prop === "height" || this.prop === "width" ) && this.elem.style ) {
5504
			this.elem.style.display = "block";
5505
		}
5506
	},
5507
5508
	// Get the current size
5509
	cur: function( force ) {
5510
		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
5511
			return this.elem[ this.prop ];
5512
		}
5513
5514
		var r = parseFloat(jQuery.css(this.elem, this.prop, force));
5515
		return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
5516
	},
5517
5518
	// Start an animation from one number to another
5519
	custom: function( from, to, unit ) {
5520
		this.startTime = now();
5521
		this.start = from;
5522
		this.end = to;
5523
		this.unit = unit || this.unit || "px";
5524
		this.now = this.start;
5525
		this.pos = this.state = 0;
5526
5527
		var self = this;
5528
		function t( gotoEnd ) {
5529
			return self.step(gotoEnd);
5530
		}
5531
5532
		t.elem = this.elem;
5533
5534
		if ( t() && jQuery.timers.push(t) && !timerId ) {
5535
			timerId = setInterval(jQuery.fx.tick, 13);
5536
		}
5537
	},
5538
5539
	// Simple 'show' function
5540
	show: function() {
5541
		// Remember where we started, so that we can go back to it later
5542
		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5543
		this.options.show = true;
5544
5545
		// Begin the animation
5546
		// Make sure that we start at a small width/height to avoid any
5547
		// flash of content
5548
		this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
5549
5550
		// Start by showing the element
5551
		jQuery( this.elem ).show();
5552
	},
5553
5554
	// Simple 'hide' function
5555
	hide: function() {
5556
		// Remember where we started, so that we can go back to it later
5557
		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5558
		this.options.hide = true;
5559
5560
		// Begin the animation
5561
		this.custom(this.cur(), 0);
5562
	},
5563
5564
	// Each step of an animation
5565
	step: function( gotoEnd ) {
5566
		var t = now(), done = true;
5567
5568
		if ( gotoEnd || t >= this.options.duration + this.startTime ) {
5569
			this.now = this.end;
5570
			this.pos = this.state = 1;
5571
			this.update();
5572
5573
			this.options.curAnim[ this.prop ] = true;
5574
5575
			for ( var i in this.options.curAnim ) {
5576
				if ( this.options.curAnim[i] !== true ) {
5577
					done = false;
5578
				}
5579
			}
5580
5581
			if ( done ) {
5582
				if ( this.options.display != null ) {
5583
					// Reset the overflow
5584
					this.elem.style.overflow = this.options.overflow;
5585
5586
					// Reset the display
5587
					var old = jQuery.data(this.elem, "olddisplay");
5588
					this.elem.style.display = old ? old : this.options.display;
5589
5590
					if ( jQuery.css(this.elem, "display") === "none" ) {
5591
						this.elem.style.display = "block";
5592
					}
5593
				}
5594
5595
				// Hide the element if the "hide" operation was done
5596
				if ( this.options.hide ) {
5597
					jQuery(this.elem).hide();
5598
				}
5599
5600
				// Reset the properties, if the item has been hidden or shown
5601
				if ( this.options.hide || this.options.show ) {
5602
					for ( var p in this.options.curAnim ) {
5603
						jQuery.style(this.elem, p, this.options.orig[p]);
5604
					}
5605
				}
5606
5607
				// Execute the complete function
5608
				this.options.complete.call( this.elem );
5609
			}
5610
5611
			return false;
5612
5613
		} else {
5614
			var n = t - this.startTime;
5615
			this.state = n / this.options.duration;
5616
5617
			// Perform the easing function, defaults to swing
5618
			var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
5619
			var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
5620
			this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
5621
			this.now = this.start + ((this.end - this.start) * this.pos);
5622
5623
			// Perform the next step of the animation
5624
			this.update();
5625
		}
5626
5627
		return true;
5628
	}
5629
};
5630
5631
jQuery.extend( jQuery.fx, {
5632
	tick: function() {
5633
		var timers = jQuery.timers;
5634
5635
		for ( var i = 0; i < timers.length; i++ ) {
5636
			if ( !timers[i]() ) {
5637
				timers.splice(i--, 1);
5638
			}
5639
		}
5640
5641
		if ( !timers.length ) {
5642
			jQuery.fx.stop();
5643
		}
5644
	},
5645
		
5646
	stop: function() {
5647
		clearInterval( timerId );
5648
		timerId = null;
5649
	},
5650
	
5651
	speeds: {
5652
		slow: 600,
5653
 		fast: 200,
5654
 		// Default speed
5655
 		_default: 400
5656
	},
5657
5658
	step: {
5659
		opacity: function( fx ) {
5660
			jQuery.style(fx.elem, "opacity", fx.now);
5661
		},
5662
5663
		_default: function( fx ) {
5664
			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
5665
				fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
5666
			} else {
5667
				fx.elem[ fx.prop ] = fx.now;
5668
			}
5669
		}
5670
	}
5671
});
5672
5673
if ( jQuery.expr && jQuery.expr.filters ) {
5674
	jQuery.expr.filters.animated = function( elem ) {
5675
		return jQuery.grep(jQuery.timers, function( fn ) {
5676
			return elem === fn.elem;
5677
		}).length;
5678
	};
5679
}
5680
5681
function genFx( type, num ) {
5682
	var obj = {};
5683
5684
	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
5685
		obj[ this ] = type;
5686
	});
5687
5688
	return obj;
5689
}
5690
if ( "getBoundingClientRect" in document.documentElement ) {
5691
	jQuery.fn.offset = function( options ) {
5692
		var elem = this[0];
5693
5694
		if ( !elem || !elem.ownerDocument ) {
5695
			return null;
5696
		}
5697
5698
		if ( options ) { 
5699
			return this.each(function( i ) {
5700
				jQuery.offset.setOffset( this, options, i );
5701
			});
5702
		}
5703
5704
		if ( elem === elem.ownerDocument.body ) {
5705
			return jQuery.offset.bodyOffset( elem );
5706
		}
5707
5708
		var box = elem.getBoundingClientRect(), doc = elem.ownerDocument, body = doc.body, docElem = doc.documentElement,
5709
			clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
5710
			top  = box.top  + (self.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
5711
			left = box.left + (self.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
5712
5713
		return { top: top, left: left };
5714
	};
5715
5716
} else {
5717
	jQuery.fn.offset = function( options ) {
5718
		var elem = this[0];
5719
5720
		if ( !elem || !elem.ownerDocument ) {
5721
			return null;
5722
		}
5723
5724
		if ( options ) { 
5725
			return this.each(function( i ) {
5726
				jQuery.offset.setOffset( this, options, i );
5727
			});
5728
		}
5729
5730
		if ( elem === elem.ownerDocument.body ) {
5731
			return jQuery.offset.bodyOffset( elem );
5732
		}
5733
5734
		jQuery.offset.initialize();
5735
5736
		var offsetParent = elem.offsetParent, prevOffsetParent = elem,
5737
			doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
5738
			body = doc.body, defaultView = doc.defaultView,
5739
			prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
5740
			top = elem.offsetTop, left = elem.offsetLeft;
5741
5742
		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
5743
			if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
5744
				break;
5745
			}
5746
5747
			computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
5748
			top  -= elem.scrollTop;
5749
			left -= elem.scrollLeft;
5750
5751
			if ( elem === offsetParent ) {
5752
				top  += elem.offsetTop;
5753
				left += elem.offsetLeft;
5754
5755
				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.nodeName)) ) {
5756
					top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5757
					left += parseFloat( computedStyle.borderLeftWidth ) || 0;
5758
				}
5759
5760
				prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
5761
			}
5762
5763
			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
5764
				top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5765
				left += parseFloat( computedStyle.borderLeftWidth ) || 0;
5766
			}
5767
5768
			prevComputedStyle = computedStyle;
5769
		}
5770
5771
		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
5772
			top  += body.offsetTop;
5773
			left += body.offsetLeft;
5774
		}
5775
5776
		if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
5777
			top  += Math.max( docElem.scrollTop, body.scrollTop );
5778
			left += Math.max( docElem.scrollLeft, body.scrollLeft );
5779
		}
5780
5781
		return { top: top, left: left };
5782
	};
5783
}
5784
5785
jQuery.offset = {
5786
	initialize: function() {
5787
		var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.curCSS(body, "marginTop", true) ) || 0,
5788
			html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
5789
5790
		jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
5791
5792
		container.innerHTML = html;
5793
		body.insertBefore( container, body.firstChild );
5794
		innerDiv = container.firstChild;
5795
		checkDiv = innerDiv.firstChild;
5796
		td = innerDiv.nextSibling.firstChild.firstChild;
5797
5798
		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
5799
		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
5800
5801
		checkDiv.style.position = "fixed", checkDiv.style.top = "20px";
5802
		// safari subtracts parent border width here which is 5px
5803
		this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
5804
		checkDiv.style.position = checkDiv.style.top = "";
5805
5806
		innerDiv.style.overflow = "hidden", innerDiv.style.position = "relative";
5807
		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
5808
5809
		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
5810
5811
		body.removeChild( container );
5812
		body = container = innerDiv = checkDiv = table = td = null;
5813
		jQuery.offset.initialize = jQuery.noop;
5814
	},
5815
5816
	bodyOffset: function( body ) {
5817
		var top = body.offsetTop, left = body.offsetLeft;
5818
5819
		jQuery.offset.initialize();
5820
5821
		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
5822
			top  += parseFloat( jQuery.curCSS(body, "marginTop",  true) ) || 0;
5823
			left += parseFloat( jQuery.curCSS(body, "marginLeft", true) ) || 0;
5824
		}
5825
5826
		return { top: top, left: left };
5827
	},
5828
	
5829
	setOffset: function( elem, options, i ) {
5830
		// set position first, in-case top/left are set even on static elem
5831
		if ( /static/.test( jQuery.curCSS( elem, "position" ) ) ) {
5832
			elem.style.position = "relative";
5833
		}
5834
		var curElem   = jQuery( elem ),
5835
			curOffset = curElem.offset(),
5836
			curTop    = parseInt( jQuery.curCSS( elem, "top",  true ), 10 ) || 0,
5837
			curLeft   = parseInt( jQuery.curCSS( elem, "left", true ), 10 ) || 0;
5838
5839
		if ( jQuery.isFunction( options ) ) {
5840
			options = options.call( elem, i, curOffset );
5841
		}
5842
5843
		var props = {
5844
			top:  (options.top  - curOffset.top)  + curTop,
5845
			left: (options.left - curOffset.left) + curLeft
5846
		};
5847
		
5848
		if ( "using" in options ) {
5849
			options.using.call( elem, props );
5850
		} else {
5851
			curElem.css( props );
5852
		}
5853
	}
5854
};
5855
5856
5857
jQuery.fn.extend({
5858
	position: function() {
5859
		if ( !this[0] ) {
5860
			return null;
5861
		}
5862
5863
		var elem = this[0],
5864
5865
		// Get *real* offsetParent
5866
		offsetParent = this.offsetParent(),
5867
5868
		// Get correct offsets
5869
		offset       = this.offset(),
5870
		parentOffset = /^body|html$/i.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
5871
5872
		// Subtract element margins
5873
		// note: when an element has margin: auto the offsetLeft and marginLeft
5874
		// are the same in Safari causing offset.left to incorrectly be 0
5875
		offset.top  -= parseFloat( jQuery.curCSS(elem, "marginTop",  true) ) || 0;
5876
		offset.left -= parseFloat( jQuery.curCSS(elem, "marginLeft", true) ) || 0;
5877
5878
		// Add offsetParent borders
5879
		parentOffset.top  += parseFloat( jQuery.curCSS(offsetParent[0], "borderTopWidth",  true) ) || 0;
5880
		parentOffset.left += parseFloat( jQuery.curCSS(offsetParent[0], "borderLeftWidth", true) ) || 0;
5881
5882
		// Subtract the two offsets
5883
		return {
5884
			top:  offset.top  - parentOffset.top,
5885
			left: offset.left - parentOffset.left
5886
		};
5887
	},
5888
5889
	offsetParent: function() {
5890
		return this.map(function() {
5891
			var offsetParent = this.offsetParent || document.body;
5892
			while ( offsetParent && (!/^body|html$/i.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
5893
				offsetParent = offsetParent.offsetParent;
5894
			}
5895
			return offsetParent;
5896
		});
5897
	}
5898
});
5899
5900
5901
// Create scrollLeft and scrollTop methods
5902
jQuery.each( ["Left", "Top"], function( i, name ) {
5903
	var method = "scroll" + name;
5904
5905
	jQuery.fn[ method ] = function(val) {
5906
		var elem = this[0], win;
5907
		
5908
		if ( !elem ) {
5909
			return null;
5910
		}
5911
5912
		if ( val !== undefined ) {
5913
			// Set the scroll offset
5914
			return this.each(function() {
5915
				win = getWindow( this );
5916
5917
				if ( win ) {
5918
					win.scrollTo(
5919
						!i ? val : jQuery(win).scrollLeft(),
5920
						 i ? val : jQuery(win).scrollTop()
5921
					);
5922
5923
				} else {
5924
					this[ method ] = val;
5925
				}
5926
			});
5927
		} else {
5928
			win = getWindow( elem );
5929
5930
			// Return the scroll offset
5931
			return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
5932
				jQuery.support.boxModel && win.document.documentElement[ method ] ||
5933
					win.document.body[ method ] :
5934
				elem[ method ];
5935
		}
5936
	};
5937
});
5938
5939
function getWindow( elem ) {
5940
	return ("scrollTo" in elem && elem.document) ?
5941
		elem :
5942
		elem.nodeType === 9 ?
5943
			elem.defaultView || elem.parentWindow :
5944
			false;
5945
}
5946
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
5947
jQuery.each([ "Height", "Width" ], function( i, name ) {
5948
5949
	var type = name.toLowerCase();
5950
5951
	// innerHeight and innerWidth
5952
	jQuery.fn["inner" + name] = function() {
5953
		return this[0] ?
5954
			jQuery.css( this[0], type, false, "padding" ) :
5955
			null;
5956
	};
5957
5958
	// outerHeight and outerWidth
5959
	jQuery.fn["outer" + name] = function( margin ) {
5960
		return this[0] ?
5961
			jQuery.css( this[0], type, false, margin ? "margin" : "border" ) :
5962
			null;
5963
	};
5964
5965
	jQuery.fn[ type ] = function( size ) {
5966
		// Get window width or height
5967
		var elem = this[0];
5968
		if ( !elem ) {
5969
			return size == null ? null : this;
5970
		}
5971
5972
		return ("scrollTo" in elem && elem.document) ? // does it walk and quack like a window?
5973
			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
5974
			elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
5975
			elem.document.body[ "client" + name ] :
5976
5977
			// Get document width or height
5978
			(elem.nodeType === 9) ? // is it a document
5979
				// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
5980
				Math.max(
5981
					elem.documentElement["client" + name],
5982
					elem.body["scroll" + name], elem.documentElement["scroll" + name],
5983
					elem.body["offset" + name], elem.documentElement["offset" + name]
5984
				) :
5985
5986
				// Get or set width or height on the element
5987
				size === undefined ?
5988
					// Get width or height on the element
5989
					jQuery.css( elem, type ) :
5990
5991
					// Set the width or height on the element (default to pixels if value is unitless)
5992
					this.css( type, typeof size === "string" ? size : size + "px" );
5993
	};
5994
5995
});
5996
// Expose jQuery to the global object
5997
window.jQuery = window.$ = jQuery;
5998
5999
})(window);

Updated ip/trunk/templates/common/jquery/jquery_compressed.js Download diff

File was changed - ok, show the diff

Added ip/trunk/templates/common/jquery/jquery_horiz_menu.js

Show contents

Added ip/trunk/templates/common/jquery/jquery_hoverIntent.js

Show contents

Added ip/trunk/templates/common/jquery/jquery_hoverIntent_compressed.js

Show contents

Added ip/trunk/templates/common/jquery/jquery_slidemenu.css

Show contents

Added ip/trunk/templates/common/jquery/jquery_slidemenu.js

Show contents

Updated ip/trunk/templates/common/js/bbcode.js Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/common/js/ip_scripts.js Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/common/js/sitemap.js Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/bbcb_mg.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/common.css Download diff

File was changed - ok, show the diff

Added ip/trunk/templates/default/items_add_body.tpl

Show contents

Added ip/trunk/templates/default/items_view_body.tpl

Show contents

Added ip/trunk/templates/default/layout/2_column_r.cfg

Show contents

Added ip/trunk/templates/default/layout/2_column_r.tpl

Show contents

Updated ip/trunk/templates/default/layout/portal_body.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/overall_inc_body.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/pa_category_body.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/pa_file_body.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/pa_footer.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/pa_search_result.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/pa_stats_body.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/pa_toplist_body.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/default/pa_viewall_body.tpl Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/icy_phoenix/style_cyan.css Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/icy_phoenix/style_gray.css Download diff

File was changed - ok, show the diff

Updated ip/trunk/templates/icy_phoenix/style_ice.css Download diff

File was changed - ok, show the diff

Updated ip/trunk/viewtopic.php Download diff

File was changed - ok, show the diff