(Not implemented)
// articleIndex: The selected article index (Not implemented)
// argument(2 ... N): RcnArticleImage. syntax: new RcnArticleImage("imgId", articleIndex)
/////////////////////////////////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleImages, RcnElementEventPublisherSubscriber);
function RcnArticleImages(id, articleIndex) {
if (arguments.length)
this.InitInstance.apply(this, arguments);
}
RcnArticleImages.prototype.InitInstance = function(id, articleIndex) {
RcnArticleImages.baseClass.InitInstance.call(this, id);
for (i = 2; i <= arguments.length - 1; i++) {
this.AttachEvent(new RcnArticleEvent(null, 0), arguments[i]);
arguments[i].AttachEvent(new RcnArticleEvent, this);
}
RcnArticleImages.prototype.HandleEvent = function(eventObj) {
this.TrigEvent(eventObj);
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnArticleImage: Class attach to the Article Image
// id: The element id of the HTMLImage
![]()
.
// articleIndex: The article index representing this image.
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleImage, RcnElementEventPublisherSubscriber);
function RcnArticleImage(id, articleIndex) {
if (arguments.length)
this.InitInstance(id, articleIndex);
}
RcnArticleImage.prototype.InitInstance = function(id, articleIndex) {
RcnArticleImage.baseClass.InitInstance.call(this, id);
this.articleImageElement = document.getElementById(id);
this.articleImageIndex = articleIndex;
if (this.articleImageElement) {
// onClick
this.articleImageElement.onclick = this.OnClickHandler;
// onMouseOver
this.articleImageElement.onmouseover = this.OnMouseOverHandler;
// onMouseOut
this.articleImageElement.onmouseout = this.OnMouseOutHandler;
}
}
RcnArticleImage.prototype.OnClickHandler = function() {
RcnClientFx.GetRcnObject(this).ArticleImageClick();
}
RcnArticleImage.prototype.ArticleImageClick = function() {
// Store the articleIndex
SaveArticleIndexToViewState(this.articleImageIndex);
// Trigger the RcnArticleEvent
this.TrigEvent(new RcnArticleEvent(this, this.articleImageIndex));
}
RcnArticleImage.prototype.OnMouseOverHandler = function() {
RcnClientFx.GetRcnObject(this).ArticleImageOnMouseOver();
}
RcnArticleImage.prototype.ArticleImageOnMouseOver = function() {
// Trigger the RcnArticleOnMouseOverEvent
this.TrigEvent(new RcnArticleOnMouseOverEvent(this, this.articleImageIndex));
}
RcnArticleImage.prototype.OnMouseOutHandler = function() {
RcnClientFx.GetRcnObject(this).ArticleImageOnMouseOut();
}
RcnArticleImage.prototype.ArticleImageOnMouseOut = function() {
this.TrigEvent(new RcnArticleOnMouseOutEvent(this, this.articleImageIndex));
}
RcnArticleImage.prototype.HandleEvent = function(eventObj) {
if (eventObj.ClassName() == "RcnArticleEvent") {
if (eventObj.ArticleIndex() == this.articleImageIndex) {
// Call function that renders a border round the selected article image.
RenderArticleImageBorder(this.articleImageIndex);
}
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnSelector Class attach to
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnSelector, RcnElementEventPublisherSubscriber);
function RcnSelector(id, idArticle, idVariant) {
if (arguments.length)
this.InitInstance(id, idArticle, idVariant);
}
RcnSelector.prototype.InitInstance = function(id, idArticle, idVariant) {
RcnSelector.baseClass.InitInstance.call(this, id);
this.articleElement = document.getElementById(idArticle);
this.variantElement = document.getElementById(idVariant);
if (this.articleElement) {
RcnClientFx.AttachRcnObject(this.articleElement, this);
this.articleElement.onchange = this.OnArticleSelectChangeHandler
}
if (this.variantElement) {
RcnClientFx.AttachRcnObject(this.variantElement, this);
this.variantElement.onchange = this.OnVariantSelectChangeHandler
}
}
RcnSelector.prototype.OnArticleSelectChangeHandler = function() {
RcnClientFx.GetRcnObject(this).ArticleSelectChange();
}
RcnSelector.prototype.OnVariantSelectChangeHandler = function() {
RcnClientFx.GetRcnObject(this).VariantSelectChange();
}
RcnSelector.prototype.ArticleSelectChange = function() {
// Store the articleIndex
SaveArticleIndexToViewState(this.articleElement.selectedIndex);
// Mark the article image
RenderArticleImageBorder(this.articleElement.selectedIndex);
// Populate variants and get the new variantId, trigger events.
// But, only if the variant select box is redered to page.
if (this.variantElement) {
PopulateVariantList(this.articleElement.selectedIndex);
var selectedVariantIndex = PopulateVariants(this.variantElement.id, this.articleElement.selectedIndex);
// Trigger events
this.TrigEvent(new RcnVariantEvent(this, selectedVariantIndex));
this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, selectedVariantIndex));
}
else {
var oldVariantIndex = document.getElementById('RcnVariantIndex').value;
var selectedVariantIndex = 0;
if (this.articleElement.selectedIndex > 0)
selectedVariantIndex = 1;
// Store the variantIndex
SaveVariantIndexToViewState(selectedVariantIndex);
if (oldVariantIndex != selectedVariantIndex) {
// Trigger events
this.TrigEvent(new RcnVariantEvent(this, selectedVariantIndex));
this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, selectedVariantIndex));
}
}
// Trigger events.
this.TrigEvent(new RcnArticleEvent(this, this.articleElement.selectedIndex));
}
RcnSelector.prototype.VariantSelectChange = function() {
// Store the variantIndex
SaveVariantIndexToViewState(this.variantElement.selectedIndex);
this.TrigEvent(new RcnVariantEvent(this, this.variantElement.selectedIndex));
this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, this.variantElement.selectedIndex));
}
RcnSelector.prototype.HandleEvent = function(eventObj) {
// I only let my RcnSelector attach to the ArticleImages and not to itself. Therefore some "events are handled" in the ArticleSelectChange function above...
if (eventObj.ClassName() == 'RcnArticleEvent') {
// The user has clicked on an article image.
// Change selected index of the article HTMLSelect
SetSelectedIndex(this.articleElement.id, eventObj.ArticleIndex());
// Re-populate Variants, if the variant select box exist
if (this.variantElement) {
PopulateVariantList(eventObj.ArticleIndex());
var selectedVariantIndex = PopulateVariants(this.variantElement.id, eventObj.ArticleIndex());
// Trigger events
this.TrigEvent(new RcnVariantEvent(this, selectedVariantIndex));
this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, selectedVariantIndex));
}
else {
var oldVariantIndex = document.getElementById('RcnVariantIndex').value;
var selectedVariantIndex = 0;
if (this.articleElement.selectedIndex > 0)
selectedVariantIndex = 1;
// Store the variantIndex
SaveVariantIndexToViewState(selectedVariantIndex);
if (oldVariantIndex != selectedVariantIndex) {
// Trigger events
this.TrigEvent(new RcnVariantEvent(this, selectedVariantIndex));
this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, selectedVariantIndex));
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnDivMatchSet Test class attach to the MatchSet
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnDivMatchSet, RcnElementEventSubscriber);
function RcnDivMatchSet(id) {
if (arguments.length)
this.InitInstance(id);
}
RcnDivMatchSet.prototype.InitInstance = function(id) {
RcnDivMatchSet.baseClass.InitInstance.call(this, id);
}
RcnDivMatchSet.prototype.HandleEvent = function(eventObj) {
if (eventObj.ClassName() == "RcnArticleEvent") {
RenderMatchSet(eventObj.ArticleIndex(), this.Element().id);
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnArticleDisplay
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleDisplay, RcnElementEventSubscriber);
function RcnArticleDisplay(id) {
if (arguments.length)
this.InitInstance(id);
}
RcnArticleDisplay.prototype.InitInstance = function(id) {
RcnArticleDisplay.baseClass.InitInstance.call(this, id);
}
RcnArticleDisplay.prototype.HandleEvent = function(eventObj) {
if (eventObj.ClassName() == "RcnArticleEvent") {
RenderArticleDisplay(eventObj.ArticleIndex());
RenderArticleNo(eventObj.ArticleIndex());
}
if (eventObj.ClassName() == "RcnArticleOnMouseOverEvent") {
RenderArticleDisplay(eventObj.ArticleIndex());
}
if (eventObj.ClassName() == "RcnArticleOnMouseOutEvent") {
// call RenderArticleDisplay() without parameters to reset text.
RenderArticleDisplay();
}
//Added: Boris Estrada, Guide Konsult Gbg AB, 2006-10-03 (EL99160).
if (eventObj.ClassName() == "RcnArticleVariantEvent") {
RenderArticleNo(eventObj.ArticleIndex());
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnProductImage Class attach to the RcnProductImage control
![]()
// parameters: htmlAnchorId: the element id of
surrounding the ![]()
product image.
// htmlImageId: the element id of ![]()
the product image.
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnProductImage, RcnElementEventSubscriber);
function RcnProductImage(htmlAnchorId, htmlImageId) {
if (arguments.length)
this.InitInstance(htmlAnchorId, htmlImageId);
}
RcnProductImage.prototype.InitInstance = function(htmlAnchorId, htmlImageId) {
RcnProductImage.baseClass.InitInstance.call(this, htmlAnchorId, htmlImageId);
this.htmlAnchorElement = document.getElementById(htmlAnchorId);
this.htmlImageElement = document.getElementById(htmlImageId);
}
RcnProductImage.prototype.HandleEvent = function(eventObj) {
if (eventObj.ClassName() == "RcnArticleEvent") {
RenderProductImage(eventObj.ArticleIndex(), this.htmlAnchorElement.id, this.htmlImageElement.id);
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnProductZoom Class attach to the RcnProductZoom control
// parameters: htmlAnchorId: the element id of
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnProductZoom, RcnElementEventSubscriber);
function RcnProductZoom(htmlAnchorId) {
if (arguments.length)
this.InitInstance(htmlAnchorId);
}
RcnProductZoom.prototype.InitInstance = function(htmlAnchorId) {
RcnProductZoom.baseClass.InitInstance.call(this, htmlAnchorId);
this.htmlAnchorElement = document.getElementById(htmlAnchorId);
}
RcnProductZoom.prototype.HandleEvent = function(eventObj) {
if (eventObj.ClassName() == "RcnArticleEvent") {
RenderProductZoomLink(eventObj.ArticleIndex(), this.htmlAnchorElement.id);
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnPriceCommunicator Class attach to the Price Communicator on DetailPage
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnPriceCommunicator, RcnElementEventSubscriber);
function RcnPriceCommunicator(id) {
if (arguments.length)
this.InitInstance(id);
}
RcnPriceCommunicator.prototype.InitInstance = function(id) {
RcnPriceCommunicator.baseClass.InitInstance.call(this, id);
}
RcnPriceCommunicator.prototype.HandleEvent = function(eventObj) {
if (eventObj.ClassName() == "RcnArticleEvent") {
RenderPriceInfo();
}
if (eventObj.ClassName() == "RcnVariantEvent") {
RenderPriceInfo();
}
if (eventObj.ClassName() == "RcnArticleVariantEvent") {
RenderPriceInfo();
}
}
///////////////////////////////////////////////////////////////////////////////
// RcnAvailability
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnAvailability, RcnElementEventSubscriber);
function RcnAvailability(id) {
if (arguments.length)
this.InitInstance(id);
}
RcnAvailability.prototype.InitInstance = function(id) {
RcnAvailability.baseClass.InitInstance.call(this, id);
}
RcnAvailability.prototype.HandleEvent = function(eventObj) {
if (eventObj.ClassName() == "RcnArticleEvent") {
RenderAvailability();
}
if (eventObj.ClassName() == "RcnVariantEvent") {
RenderAvailability();
}
if (eventObj.ClassName() == "RcnArticleVariantEvent") {
RenderAvailability();
}
}
/** Event Section ***********************************************************/
///////////////////////////////////////////////////////////////////////////////
// RcnArticleEvent
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleEvent, RcnEvent);
function RcnArticleEvent(src, articleIndex) {
if (arguments.length)
this.InitInstance(src, articleIndex);
}
RcnArticleEvent.prototype.InitInstance = function(src, articleIndex) {
RcnArticleEvent.baseClass.InitInstance.call(this, src);
this.articleIndex = articleIndex;
}
RcnArticleEvent.prototype.ArticleIndex = function() {
//set
if (arguments.length)
this.articleIndex = arguments[0];
//get
return this.articleIndex;
}
///////////////////////////////////////////////////////////////////////////////
// RcnVariantEvent
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnVariantEvent, RcnEvent);
function RcnVariantEvent(src, variantIndex) {
if (arguments.length)
this.InitInstance(src, variantIndex);
}
RcnVariantEvent.prototype.InitInstance = function(src, variantIndex) {
RcnVariantEvent.baseClass.InitInstance.call(this, src);
this.variantIndex = variantIndex;
}
RcnVariantEvent.prototype.VariantIndex = function() {
//set
if (arguments.length)
this.variantIndex = arguments[0];
//get
return this.variantIndex;
}
///////////////////////////////////////////////////////////////////////////////
// RcnArticleVariantEvent
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleVariantEvent, RcnEvent);
function RcnArticleVariantEvent(src, articleIndex, variantIndex) {
if (arguments.length)
this.InitInstance(src, articleIndex, variantIndex);
}
RcnArticleVariantEvent.prototype.InitInstance = function(src, articleIndex, variantIndex) {
RcnArticleVariantEvent.baseClass.InitInstance.call(this, src);
this.articleIndex = articleIndex;
this.variantIndex = variantIndex;
}
RcnArticleVariantEvent.prototype.ArticleIndex = function() {
//set
if (arguments.length)
this.articleIndex = arguments[0];
//get
return this.articleIndex;
}
RcnArticleVariantEvent.prototype.VariantIndex = function() {
//set
if (arguments.length)
this.variantIndex = arguments[0];
//get
return this.variantIndex;
}
///////////////////////////////////////////////////////////////////////////////
// RcnArticleOnMouseOverEvent
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleOnMouseOverEvent, RcnEvent);
function RcnArticleOnMouseOverEvent(src, articleIndex) {
if (arguments.length)
this.InitInstance(src, articleIndex);
}
RcnArticleOnMouseOverEvent.prototype.InitInstance = function(src, articleIndex) {
RcnArticleOnMouseOverEvent.baseClass.InitInstance.call(this, src);
this.articleIndex = articleIndex;
}
RcnArticleOnMouseOverEvent.prototype.ArticleIndex = function() {
//set
if (arguments.length)
this.articleIndex = arguments[0];
//get
return this.articleIndex;
}
///////////////////////////////////////////////////////////////////////////////
// RcnArticleOnMouseOutEvent
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleOnMouseOutEvent, RcnEvent);
function RcnArticleOnMouseOutEvent(src, articleIndex) {
if (arguments.length)
this.InitInstance(src, articleIndex);
}
RcnArticleOnMouseOutEvent.prototype.InitInstance = function(src, articleIndex) {
RcnArticleOnMouseOutEvent.baseClass.InitInstance.call(this, src);
this.articleIndex = articleIndex;
}
RcnArticleOnMouseOutEvent.prototype.ArticleIndex = function() {
//set
if (arguments.length)
this.articleIndex = arguments[0];
//get
return this.articleIndex;
}
function ChangeToAlternateProductImage(fullpath, image, zoomImgPath) {
if (!rcnProductImage)
return false;
var objImg = rcnProductImage.htmlImageElement;
objImg.src = fullpath;
var zoomExt = Sys.UI.Behavior.getBehaviorByName(objImg, 'ZoomImageBehavior');
if (zoomExt) {
zoomExt.set_onClickScript("PopupZoom('" + image + "');");
zoomExt.set_zoomImageSrc(zoomImgPath);
}
document.getElementById('RcnProductImageLink').href = PopupZoomUrl(image);
if (document.getElementById('RcnProductZoom'))
document.getElementById('RcnProductZoom').href = PopupZoomUrl(image);
var maxlbls = 4;
var index = 1;
for (index = 1; index < (maxlbls + 1); index++) {
var lbl = getLabelPos(index);
if (lbl != null) {
lbl.style.display = '';
}
}
return true;
}
function InitAndSetVariant(articleSelectId, variantSelectId) {
var selArt = document.getElementById(articleSelectId);
var selVar = document.getElementById(variantSelectId);
if (selArt != null && selVar != null) {
// If an article is selected and variants are not initialized
if (selArt.selectedIndex != 0 && selVar.options.length <= 1) {
// store variantindex from hidden control because it gets
// overwritten in the onchange event
var variantIndex = document.getElementById('RcnVariantIndex').value;
// trigger onchange event to init variant dropdown
selArt.onchange();
if (selVar.options.length == 2)
variantIndex = 1;
selVar.selectedIndex = variantIndex;
}
}
}
'
}
for (i = 0; i < M[index].Item.length; i++) {
// Price communication
if (M[index].Item[i].IsFromPrice == 1)
price = '' + M[index].PricePrefix + '';
price += '' + M[index].Item[i].Price + '';
if (M[index].Item[i].HasAlternatePrice == 1)
price = '' + M[index].Item[i].Price + '
' + M[index].BuyText + '';
}
s += '' + M[index].Item[i].Name + '