'),
overlay = $(''),
wrap = $('')
);
outer = $('')
.append('')
.appendTo( wrap );
outer.append(
content = $(''),
close = $(''),
title = $(''),
nav_left = $(''),
nav_right = $('')
);
close.click($.fancybox.close);
loading.click($.fancybox.cancel);
nav_left.click(function(e) {
e.preventDefault();
$.fancybox.prev();
});
nav_right.click(function(e) {
e.preventDefault();
$.fancybox.next();
});
if ($.fn.mousewheel) {
wrap.bind('mousewheel.fb', function(e, delta) {
if (busy) {
e.preventDefault();
} else if ($(e.target).get(0).clientHeight == 0 || $(e.target).get(0).scrollHeight === $(e.target).get(0).clientHeight) {
e.preventDefault();
$.fancybox[ delta > 0 ? 'prev' : 'next']();
}
});
}
if (!$.support.opacity) {
wrap.addClass('fancybox-ie');
}
if (isIE6) {
loading.addClass('fancybox-ie6');
wrap.addClass('fancybox-ie6');
$('').prependTo(outer);
}
};
$.fn.fancybox.defaults = {
padding : 10,
margin : 40,
opacity : false,
modal : false,
cyclic : false,
scrolling : 'auto', // 'auto', 'yes' or 'no'
width : 560,
height : 340,
autoScale : true,
autoDimensions : true,
centerOnScroll : false,
ajax : {},
swf : { wmode: 'transparent' },
hideOnOverlayClick : true,
hideOnContentClick : false,
overlayShow : true,
overlayOpacity : 0.7,
overlayColor : '#777',
titleShow : true,
titlePosition : 'float', // 'float', 'outside', 'inside' or 'over'
titleFormat : null,
titleFromAlt : false,
transitionIn : 'fade', // 'elastic', 'fade' or 'none'
transitionOut : 'fade', // 'elastic', 'fade' or 'none'
speedIn : 300,
speedOut : 300,
changeSpeed : 300,
changeFade : 'fast',
easingIn : 'swing',
easingOut : 'swing',
showCloseButton : true,
showNavArrows : true,
enableEscapeButton : true,
enableKeyboardNav : true,
onStart : function(){},
onCancel : function(){},
onComplete : function(){},
onCleanup : function(){},
onClosed : function(){},
onError : function(){}
};
$(document).ready(function() {
$.fancybox.init();
});
})(jQuery);
/*
Watermark plugin for jQuery
Version: 3.0.6
http://jquery-watermark.googlecode.com/
Copyright (c) 2009-2010 Todd Northrop
http://www.speednet.biz/
June 21, 2010
Requires: jQuery 1.2.3+
Dual licensed under the MIT or GPL Version 2 licenses.
See mit-license.txt and gpl2-license.txt in the project root for details.
------------------------------------------------------*/
(function ($) {
var
// Will speed up references to undefined
undefined,
// String constants for data names
dataFlag = "watermark",
dataClass = "watermarkClass",
dataFocus = "watermarkFocus",
dataFormSubmit = "watermarkSubmit",
dataMaxLen = "watermarkMaxLength",
dataPassword = "watermarkPassword",
dataText = "watermarkText",
// Includes only elements with watermark defined
selWatermarkDefined = ":data(" + dataFlag + ")",
// Includes only elements capable of having watermark
selWatermarkAble = ":text,:password,:search,textarea",
// triggerFns:
// Array of function names to look for in the global namespace.
// Any such functions found will be hijacked to trigger a call to
// hideAll() any time they are called. The default value is the
// ASP.NET function that validates the controls on the page
// prior to a postback.
//
// Am I missing other important trigger function(s) to look for?
// Please leave me feedback:
// http://code.google.com/p/jquery-watermark/issues/list
triggerFns = [
"Page_ClientValidate"
],
// Holds a value of true if a watermark was displayed since the last
// hideAll() was executed. Avoids repeatedly calling hideAll().
pageDirty = false;
//Extends jQuery with a custom selector - ":data(...)"
//:data() Includes elements that have a specific name defined in the jQuery data collection. (Only the existence of the name is checked; the value is ignored.)
//:data(=) Includes elements that have a specific jQuery data name defined, with a specific value associated with it.
//:data(!=) Includes elements that have a specific jQuery data name defined, with a value that is not equal to the value specified.
//:data(^=) Includes elements that have a specific jQuery data name defined, with a value that starts with the value specified.
//:data($=) Includes elements that have a specific jQuery data name defined, with a value that ends with the value specified.
//:data(*=) Includes elements that have a specific jQuery data name defined, with a value that contains the value specified.
$.extend($.expr[":"], {
"search": function (elem) {
return "search" === (elem.type || "");
},
"data": function (element, index, matches, set) {
var data, parts = /^((?:[^=!^$*]|[!^$*](?!=))+)(?:([!^$*]?=)(.*))?$/.exec(matches[3]);
if (parts) {
data = $(element).data(parts[1]);
if (data !== undefined) {
if (parts[2]) {
data = "" + data;
switch (parts[2]) {
case "=":
return (data == parts[3]);
case "!=":
return (data != parts[3]);
case "^=":
return (data.slice(0, parts[3].length) == parts[3]);
case "$=":
return (data.slice(-parts[3].length) == parts[3]);
case "*=":
return (data.indexOf(parts[3]) !== -1);
}
}
return true;
}
}
return false;
}
});
$.watermark = {
// Current version number of the plugin
version: "3.0.6",
// Default options used when watermarks are instantiated.
// Can be changed to affect the default behavior for all
// new or updated watermarks.
// BREAKING CHANGE: The $.watermark.className
// property that was present prior to version 3.0.2 must
// be changed to $.watermark.options.className
options: {
// Default class name for all watermarks
className: "watermark",
// If true, plugin will detect and use native browser support for
// watermarks, if available. (e.g., WebKit's placeholder attribute.)
useNative: true
},
// Hide one or more watermarks by specifying any selector type
// i.e., DOM element, string selector, jQuery matched set, etc.
hide: function (selector) {
$(selector).filter(selWatermarkDefined).each(
function () {
$.watermark._hide($(this));
}
);
},
// Internal use only.
_hide: function ($input, focus) {
var inputVal = $input.val() || "",
inputWm = $input.data(dataText) || "",
maxLen = $input.data(dataMaxLen) || 0,
className = $input.data(dataClass);
if ((inputWm.length) && (inputVal == inputWm)) {
$input.val("");
// Password type?
if ($input.data(dataPassword)) {
if (($input.attr("type") || "") === "text") {
var $pwd = $input.data(dataPassword) || [],
$wrap = $input.parent() || [];
if (($pwd.length) && ($wrap.length)) {
$wrap[0].removeChild($input[0]); // Can't use jQuery methods, because they destroy data
$wrap[0].appendChild($pwd[0]);
$input = $pwd;
}
}
}
if (maxLen) {
$input.attr("maxLength", maxLen);
$input.removeData(dataMaxLen);
}
if (focus) {
$input.attr("autocomplete", "off"); // Avoid NS_ERROR_XPC_JS_THREW_STRING error in Firefox
window.setTimeout(
function () {
$input.select(); // Fix missing cursor in IE
}
, 1);
}
}
className && $input.removeClass(className);
},
// Display one or more watermarks by specifying any selector type
// i.e., DOM element, string selector, jQuery matched set, etc.
// If conditions are not right for displaying a watermark, ensures that watermark is not shown.
show: function (selector) {
$(selector).filter(selWatermarkDefined).each(
function () {
$.watermark._show($(this));
}
);
},
// Internal use only.
_show: function ($input) {
var val = $input.val() || "",
text = $input.data(dataText) || "",
type = $input.attr("type") || "",
className = $input.data(dataClass);
if (((val.length == 0) || (val == text)) && (!$input.data(dataFocus))) {
pageDirty = true;
// Password type?
if ($input.data(dataPassword)) {
if (type === "password") {
var $pwd = $input.data(dataPassword) || [],
$wrap = $input.parent() || [];
if (($pwd.length) && ($wrap.length)) {
$wrap[0].removeChild($input[0]); // Can't use jQuery methods, because they destroy data
$wrap[0].appendChild($pwd[0]);
$input = $pwd;
$input.attr("maxLength", text.length);
}
}
}
// Ensure maxLength big enough to hold watermark (input of type="text" or type="search" only)
if ((type === "text") || (type === "search")) {
var maxLen = $input.attr("maxLength") || 0;
if ((maxLen > 0) && (text.length > maxLen)) {
$input.data(dataMaxLen, maxLen);
$input.attr("maxLength", text.length);
}
}
className && $input.addClass(className);
$input.val(text);
}
else {
$.watermark._hide($input);
}
},
// Hides all watermarks on the current page.
hideAll: function () {
if (pageDirty) {
$.watermark.hide(selWatermarkAble);
pageDirty = false;
}
},
// Displays all watermarks on the current page.
showAll: function () {
$.watermark.show(selWatermarkAble);
}
};
$.fn.watermark = function (text, options) {
///
/// Set watermark text and class name on all input elements of type="text/password/search" and
/// textareas within the matched set. If className is not specified in options, the default is
/// "watermark". Within the matched set, only input elements with type="text/password/search"
/// and textareas are affected; all other elements are ignored.
///
///
/// Returns the original jQuery matched set (not just the input and texarea elements).
///
///
/// Text to display as a watermark when the input or textarea element has an empty value and does not
/// have focus. The first time watermark() is called on an element, if this argument is empty (or not
/// a String type), then the watermark will have the net effect of only changing the class name when
/// the input or textarea element's value is empty and it does not have focus.
///
///
/// Provides the ability to override the default watermark options ($.watermark.options). For backward
/// compatibility, if a string value is supplied, it is used as the class name that overrides the class
/// name in $.watermark.options.className. Properties include:
/// className: When the watermark is visible, the element will be styled using this class name.
/// useNative (Boolean or Function): Specifies if native browser support for watermarks will supersede
/// plugin functionality. If useNative is a function, the return value from the function will
/// determine if native support is used. The function is passed one argument -- a jQuery object
/// containing the element being tested as the only element in its matched set -- and the DOM
/// element being tested is the object on which the function is invoked (the value of "this").
///
///
/// The effect of changing the text and class name on an input element is called a watermark because
/// typically light gray text is used to provide a hint as to what type of input is required. However,
/// the appearance of the watermark can be something completely different: simply change the CSS style
/// pertaining to the supplied class name.
///
/// The first time watermark() is called on an element, the watermark text and class name are initialized,
/// and the focus and blur events are hooked in order to control the display of the watermark. Also, as
/// of version 3.0, drag and drop events are hooked to guard against dropped text being appended to the
/// watermark. If native watermark support is provided by the browser, it is detected and used, unless
/// the useNative option is set to false.
///
/// Subsequently, watermark() can be called again on an element in order to change the watermark text
/// and/or class name, and it can also be called without any arguments in order to refresh the display.
///
/// For example, after changing the value of the input or textarea element programmatically, watermark()
/// should be called without any arguments to refresh the display, because the change event is only
/// triggered by user actions, not by programmatic changes to an input or textarea element's value.
///
/// The one exception to programmatic updates is for password input elements: you are strongly cautioned
/// against changing the value of a password input element programmatically (after the page loads).
/// The reason is that some fairly hairy code is required behind the scenes to make the watermarks bypass
/// IE security and switch back and forth between clear text (for watermarks) and obscured text (for
/// passwords). It is *possible* to make programmatic changes, but it must be done in a certain way, and
/// overall it is not recommended.
///
if (!this.length) {
return this;
}
var hasClass = false,
hasText = (typeof(text) === "string");
if (typeof(options) === "object") {
hasClass = (typeof(options.className) === "string");
options = $.extend({}, $.watermark.options, options);
}
else if (typeof(options) === "string") {
hasClass = true;
options = $.extend({}, $.watermark.options, {className: options});
}
else {
options = $.watermark.options;
}
if (typeof(options.useNative) !== "function") {
options.useNative = options.useNative? function () { return true; } : function () { return false; };
}
return this.each(
function () {
var $input = $(this);
if (!$input.is(selWatermarkAble)) {
return;
}
// Watermark already initialized?
if ($input.data(dataFlag)) {
// If re-defining text or class, first remove existing watermark, then make changes
if (hasText || hasClass) {
$.watermark._hide($input);
if (hasText) {
$input.data(dataText, text);
}
if (hasClass) {
$input.data(dataClass, options.className);
}
}
}
else {
// Detect and use native browser support, if enabled in options
if (options.useNative.call(this, $input)) {
// Placeholder attribute (WebKit)
// Big thanks to Opera for the wacky test required
if ((("" + $input.css("-webkit-appearance")).replace("undefined", "") !== "") && (($input.attr("tagName") || "") !== "TEXTAREA")) {
// className is not set because WebKit doesn't appear to have
// a separate class name property for placeholders (watermarks).
if (hasText) {
$input.attr("placeholder", text);
}
// Only set data flag for non-native watermarks (purposely commented-out)
// $input.data(dataFlag, 1);
return;
}
}
$input.data(dataText, hasText? text : "");
$input.data(dataClass, options.className);
$input.data(dataFlag, 1); // Flag indicates watermark was initialized
// Special processing for password type
if (($input.attr("type") || "") === "password") {
var $wrap = $input.wrap("").parent(),
$wm = $($wrap.html().replace(/type=["']?password["']?/i, 'type="text"'));
$wm.data(dataText, $input.data(dataText));
$wm.data(dataClass, $input.data(dataClass));
$wm.data(dataFlag, 1);
$wm.attr("maxLength", text.length);
$wm.focus(
function () {
$.watermark._hide($wm, true);
}
).bind("dragenter",
function () {
$.watermark._hide($wm);
}
).bind("dragend",
function () {
window.setTimeout(function () { $wm.blur(); }, 1);
}
);
$input.blur(
function () {
$.watermark._show($input);
}
).bind("dragleave",
function () {
$.watermark._show($input);
}
);
$wm.data(dataPassword, $input);
$input.data(dataPassword, $wm);
}
else {
$input.focus(
function () {
$input.data(dataFocus, 1);
$.watermark._hide($input, true);
}
).blur(
function () {
$input.data(dataFocus, 0);
$.watermark._show($input);
}
).bind("dragenter",
function () {
$.watermark._hide($input);
}
).bind("dragleave",
function () {
$.watermark._show($input);
}
).bind("dragend",
function () {
window.setTimeout(function () { $.watermark._show($input); }, 1);
}
).bind("drop",
// Firefox makes this lovely function necessary because the dropped text
// is merged with the watermark before the drop event is called.
function (evt) {
var dropText = evt.originalEvent.dataTransfer.getData("Text");
if ($input.val().replace(dropText, "") === $input.data(dataText)) {
$input.val(dropText);
}
$input.focus();
}
);
}
// In order to reliably clear all watermarks before form submission,
// we need to replace the form's submit function with our own
// function. Otherwise watermarks won't be cleared when the form
// is submitted programmatically.
if (this.form) {
var form = this.form,
$form = $(form);
if (!$form.data(dataFormSubmit)) {
$form.submit($.watermark.hideAll);
// form.submit exists for all browsers except Google Chrome
// (see "else" below for explanation)
if (form.submit) {
$form.data(dataFormSubmit, form.submit);
form.submit = (function (f, $f) {
return function () {
var nativeSubmit = $f.data(dataFormSubmit);
$.watermark.hideAll();
if (nativeSubmit.apply) {
nativeSubmit.apply(f, Array.prototype.slice.call(arguments));
}
else {
nativeSubmit();
}
};
})(form, $form);
}
else {
$form.data(dataFormSubmit, 1);
// This strangeness is due to the fact that Google Chrome's
// form.submit function is not visible to JavaScript (identifies
// as "undefined"). I had to invent a solution here because hours
// of Googling (ironically) for an answer did not turn up anything
// useful. Within my own form.submit function I delete the form's
// submit function, and then call the non-existent function --
// which, in the world of Google Chrome, still exists.
form.submit = (function (f) {
return function () {
$.watermark.hideAll();
delete f.submit;
f.submit();
};
})(form);
}
}
}
}
$.watermark._show($input);
}
);
};
//Hijack any functions found in the triggerFns list
if (triggerFns.length) {
// Wait until DOM is ready before searching
$(function () {
var i, name, fn;
for (i=triggerFns.length-1; i>=0; i--) {
name = triggerFns[i];
fn = window[name];
if (typeof(fn) === "function") {
window[name] = (function (origFn) {
return function () {
$.watermark.hideAll();
return origFn.apply(null, Array.prototype.slice.call(arguments));
};
})(fn);
}
}
});
}
})(jQuery);
(function($) {
$.fn.tipsy = function(options) {
options = $.extend({}, $.fn.tipsy.defaults, options);
return this.each(function() {
var opts = $.fn.tipsy.elementOptions(this, options);
$(this).hover(function() {
$.data(this, 'cancel.tipsy', true);
var tip = $.data(this, 'active.tipsy');
if (!tip) {
tip = $('
');
tip.css({position: 'absolute', zIndex: 100000});
$.data(this, 'active.tipsy', tip);
}
if ($(this).attr('title') || typeof($(this).attr('original-title')) != 'string') {
$(this).attr('original-title', $(this).attr('title') || '').removeAttr('title');
}
var title;
if (typeof opts.title == 'string') {
title = $(this).attr(opts.title == 'title' ? 'original-title' : opts.title);
} else if (typeof opts.title == 'function') {
title = opts.title.call(this);
}
tip.find('.tipsy-inner')[opts.html ? 'html' : 'text'](title || opts.fallback);
var pos = $.extend({}, $(this).offset(), {width: this.offsetWidth, height: this.offsetHeight});
tip.get(0).className = 'tipsy'; // reset classname in case of dynamic gravity
tip.remove().css({top: 0, left: 0, visibility: 'hidden', display: 'block'}).appendTo(document.body);
var actualWidth = tip[0].offsetWidth, actualHeight = tip[0].offsetHeight;
var gravity = (typeof opts.gravity == 'function') ? opts.gravity.call(this) : opts.gravity;
switch (gravity.charAt(0)) {
case 'n':
tip.css({top: pos.top + pos.height, left: pos.left + pos.width / 2 - actualWidth / 2}).addClass('tipsy-north');
break;
case 's':
tip.css({top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2}).addClass('tipsy-south');
break;
case 'e':
tip.css({top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth}).addClass('tipsy-east');
break;
case 'w':
tip.css({top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width}).addClass('tipsy-west');
break;
}
if (opts.fade) {
tip.css({opacity: 0, display: 'block', visibility: 'visible'}).animate({opacity: 0.8});
} else {
tip.css({visibility: 'visible'});
}
}, function() {
$.data(this, 'cancel.tipsy', false);
var self = this;
setTimeout(function() {
if ($.data(this, 'cancel.tipsy')) return;
var tip = $.data(self, 'active.tipsy');
if (opts.fade) {
tip.stop().fadeOut(function() { $(this).remove(); });
} else {
tip.remove();
}
}, 100);
});
});
};
// Overwrite this method to provide options on a per-element basis.
// For example, you could store the gravity in a 'tipsy-gravity' attribute:
// return $.extend({}, options, {gravity: $(ele).attr('tipsy-gravity') || 'n' });
// (remember - do not modify 'options' in place!)
$.fn.tipsy.elementOptions = function(ele, options) {
return $.metadata ? $.extend({}, options, $(ele).metadata()) : options;
};
$.fn.tipsy.defaults = {
fade: false,
fallback: '',
gravity: 'n',
html: false,
title: 'title'
};
$.fn.tipsy.autoNS = function() {
return $(this).offset().top > ($(document).scrollTop() + $(window).height() / 2) ? 's' : 'n';
};
$.fn.tipsy.autoWE = function() {
return $(this).offset().left > ($(document).scrollLeft() + $(window).width() / 2) ? 'e' : 'w';
};
})(jQuery);
$().ready(function(){
$("a[rel='productimage']").fancybox({type:'image'});
$("#LetTrigger").click(function(){
$(this).toggleClass("active");
$('#QuickContactForm').slideToggle("slow");
return false;
});
$('#q').watermark('Enter keyword', {className: 'watermark'});
// Yes this sucks, but XHTML 1.1 has no target attribute so your pages would === FAIL in the validator
$('a.new-window').click(function(){
window.open(this.href);
return false;
});
$('a.ColourTip').click(function(){
return false;
});
$('a.ColourTip').tipsy({gravity: 'n',fade:true});
});