by "+reviews[prodNo][i].nickname+"";
html+=""+reviews[prodNo][i].detail+"
";
}
$('prodCommentsBody').update(html);
}
function goPrev()
{
picList.unshift(picList.pop());
prevSel=curSel;
globalPos--;
curSel--;
draw();
}
function goNext()
{
picList.push(picList.shift());
prevSel=curSel;
globalPos++;
curSel++;
draw();
}
function filterProducts(event,tagId)
{
Event.stop(event);
var html='';
imgCnt=0;
currentTag='All occasions';
for(i=0;i0)
{
for (k=0;k';
imgCnt++;
}
}
productCount=imgCnt;
curSel=0;
$('carousel').update(html);
initCarousel();
}
function submitComment()
{
$$('#errorDialog .msg')[0].update("So sorry, but we cannot submit your comment at this time. Please try again later.");
$('errorDialog').hide();
$$('#updatingDialog .msg')[0].update("Saving your review...");
$('updatingDialog').show();
new Ajax.Request($('commentForm').action+"id/"+currentId, {
method: 'post',
parameters: $('commentForm').serialize(),
onSuccess: function(transport) {
$('updatingDialog').hide();
openPostDialogConfirm();
},
onException: function(req,ex)
{
$('updatingDialog').hide();
$('errorDialog').show();
},
onFailure: function()
{
$('updatingDialog').hide();
$('errorDialog').show();
}
});
}
function updateContent(transport)
{
try
{
response = eval('(' + transport.responseText + ')');
}
catch (e)
{
response = {};
}
if (response.update_sections)
{
for (var i=0;i0) elements[0].replace(section.html);
}
}
}
function imageClicked(event)
{
Event.stop(event);
var x=Event.pointerX(event);
var off=$('carousel').viewportOffset();
x-=off.left;
if (x>657&&x<916)
{
goNext();
}
else if (x>0&&x<255)
{
goPrev();
}
else //if (ids[target.readAttribute('rel')]*1==currentId)
{
toggleProductDetails(event);
//openFullDialog("");
}
}
function toggleProductDetails(event)
{
Event.stop(event);
/*
if (descOpen)
{
new Effect.Fade('prodDetails');
descOpen=false;
}
else
{
$('prodDetails').show();
new Effect.Fade('prodDetails',{duration: 1,from: 0, to: 1 });
Effect.ScrollTo('carousel',{duration: 0.5, transition:Effect.Transitions.Expo.easeOut});
descOpen=true;
}
*/
jQuery('#prodDetails a').click();
if (jQuery('#prodDetails h3.ui-state-active').length>0)
{
Effect.ScrollTo('carousel',{duration: 0.5, transition:Effect.Transitions.Expo.easeOut});
}
return false;
}
/////////
Object.extend(Effect.Transitions, (function() {
//----------------------------------------------------------------------
// Function transformations
//----------------------------------------------------------------------
// easeIn to easeOut and vice versa
function reverse(eq, t)
{
return 1 - eq(1 - t);
}
// easeIn to easeInOut
function easeInToEaseInOut(easeIn, t)
{
t = 2 * t;
return 0.5 * (t < 1 ? easeIn(t) : 2 - easeIn(2 - t));
}
// easeOut to easeInOut
function easeOutToEaseInOut(easeOut, t)
{
t = 2 * t;
return 0.5 * (t < 1 ? 1 - easeOut(1 - t) : 1 + easeOut(t - 1));
}
// easeIn / easeOut pair to easeInOut
function easeInOutPairToEaseInOut(easeIn, easeOut, t)
{
t = 2 * t;
return 0.5 * (t < 1 ? easeIn(t) : 1 + easeOut(t - 1));
}
//----------------------------------------------------------------------
// Function set builders
//----------------------------------------------------------------------
// Build a function set from a complete set of easing functions
function functionSet(easeIn, easeOut, easeInOut)
{
return {
easeIn : easeIn,
easeOut : easeOut,
easeInOut: easeInOut
};
}
// Build a complete function set from just an easeIn
function functionSetFromEaseIn(easeIn)
{
return {
easeIn : easeIn,
easeOut : reverse.curry(easeIn),
easeInOut: easeInToEaseInOut.curry(easeIn)
};
}
// Build a complete function set from just an easeOut
function functionSetFromEaseOut(easeOut)
{
return {
easeIn : reverse.curry(easeOut),
easeOut : easeOut,
easeInOut: easeOutToEaseInOut.curry(easeOut)
};
}
// Build a complete function set from an easeIn / easeOut pair
function functionSetFromEaseInOutPair(easeIn, easeOut)
{
return {
easeIn : easeIn,
easeOut : easeOut,
easeInOut: easeInOutPairToEaseInOut.curry(easeIn, easeOut)
};
}
// Build a complete function set from just an easeIn,
// where the given function has custom parameters
function customizableFunctionSetFromEaseIn()
{
var args = $A(arguments);
var easeIn = args.shift();
function customEaseIn()
{
var args = [0].concat($A(arguments));
return function(t)
{
args[0] = t;
return easeIn.apply(this, args);
};
}
function customEaseOut()
{
return reverse.curry(customEaseIn.apply(this, arguments));
}
function customEaseInOut()
{
return easeInToEaseInOut.curry(customEaseIn.apply(this, arguments));
}
var myEaseIn = customEaseIn.apply(this, args);
myEaseIn.custom = customEaseIn;
var myEaseOut = reverse.curry(myEaseIn);
myEaseOut.custom = customEaseOut;
var myEaseInOut = easeInToEaseInOut.curry(myEaseIn);
myEaseInOut.custom = customEaseInOut;
return {
easeIn : myEaseIn,
easeOut : myEaseOut,
easeInOut: myEaseInOut
};
}
//----------------------------------------------------------------------
// Useful pre-computed values
//----------------------------------------------------------------------
var HALF_PI = Math.PI / 2;
var TWO_PI = 2 * Math.PI;
//----------------------------------------------------------------------
// Penner's tween equations, simplified for Scriptaculous
//----------------------------------------------------------------------
function Quad_easeIn(t)
{
return t * t;
}
function Cubic_easeIn(t)
{
return t * t * t;
}
function Quart_easeIn(t)
{
return t * t * t * t;
}
function Quint_easeIn(t)
{
return t * t * t * t * t;
}
// This one is not Penner's: it's just a generalized case, for use when
// i.e. Quad is too "soft" for your tastes but Cubic is too "quick"
// (in this specific case you could use Pow.custom(2.5) for example)
function Pow_easeIn(t, p)
{
return Math.pow(t, p);
}
function Back_easeIn(t, s)
{
return t * t * ((s + 1) * t - s);
}
// TODO (maybe): customize (customizableize? :-) ) this one
function Bounce_easeOut(t)
{
if (t < (1 / 2.75))
return 7.5625 * t * t;
if (t < (2 / 2.75))
return 7.5625 * (t-= (1.5 / 2.75)) * t + 0.75;
if (t < (2.5 / 2.75))
return 7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375;
return 7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375;
}
function Circ_easeIn(t)
{
return -1 * (Math.sqrt(1 - t * t) - 1);
}
function Circ_easeOut(t)
{
t -= 1;
return Math.sqrt(1 - t * t);
}
function Elastic_easeIn(t, a, p)
{
if (t == 0) return 0;
if (t == 1) return 1;
if (a < 1)
{
a = 1;
var s = p / 4;
}
else
{
var s = p / TWO_PI * Math.asin(1 / a);
}
return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TWO_PI / p));
}
function Expo_easeIn(t)
{
return (t == 0) ? 0 : Math.pow(2, 10 * (t - 1));
}
function Expo_easeOut(t)
{
return (t == 1) ? 1 : 1 - Math.pow(2, -10 * t);
}
function Sine_easeIn(t)
{
return Math.cos(t * HALF_PI) + 1;
}
function Sine_easeOut(t)
{
return Math.sin(t * HALF_PI);
}
function Sine_easeInOut(t)
{
return -0.5 * (Math.cos(Math.PI * t) - 1);
}
//--------------------------------------------------------------------------
// Build and return the equation sets
//--------------------------------------------------------------------------
return {
Quad : functionSetFromEaseIn(Quad_easeIn),
Cubic : functionSetFromEaseIn(Cubic_easeIn),
Quart : functionSetFromEaseIn(Quart_easeIn),
Quint : functionSetFromEaseIn(Quint_easeIn),
Pow : customizableFunctionSetFromEaseIn(Pow_easeIn, 2), // Defaults to Quad
Back : customizableFunctionSetFromEaseIn(Back_easeIn, 1.70158),
Bounce : functionSetFromEaseOut(Bounce_easeOut),
Circ : functionSetFromEaseInOutPair(Circ_easeIn, Circ_easeOut),
Elastic: customizableFunctionSetFromEaseIn(Elastic_easeIn, 1, 0.3),
Expo : functionSetFromEaseInOutPair(Expo_easeIn, Expo_easeOut),
Sine : functionSet(Sine_easeIn, Sine_easeOut, Sine_easeInOut)
};
})());
ImagesObserver = Class.create({
initialize: function(el, options) {
this.options = {
onImagesLoaded: Prototype.emptyFunction
};
Object.extend(this.options, options || { });
this.el = $(document.body);
if (typeof el != 'undefined') this.el = $(el);
this.pe = new PeriodicalExecuter(this._checkImagesState.bind(this), (1/10));
},
_checkImagesState: function() {
if (this._areImagesLoaded(this.el)) {
this.pe.stop();
if (this.options.onImagesLoaded != Prototype.emptyFunction)
this.options.onImagesLoaded(this.el);
else
document.fire('images:loaded', { el: this.el });
}
},
_areImagesLoaded: function(el) {
return el.select('img').all(function(img) {
return (img.readyState == 'complete' || img.complete ||
!(typeof img.naturalWidth != 'undefined' && img.naturalWidth == 0));
});
}
});
// EOF
//document.observe('dom:loaded', pageLoad);
//Event.observe(window,'load', pageLoad);
if (IS_IE6)
{
Event.observe(window,'load', pageLoad);//window.setTimeout(pageLoad,1000)
}
else
{
document.observe('images:loaded', pageLoad);
new ImagesObserver();
}