/* The functions/classes in this page have been reproduced from DetailPage.js with extra parameters to
 * keep the functionality as general as possible.
 */
 
 function Product(articles)
 {
    this.Articles = articles;
 }
 
 function PopulateVariantsMultiple(ctrl, index, RcnProductIndexID, RcnVariantIndexID, RcnVariantIdID, RcnArticleIndexID)
{
    if( document.getElementById(ctrl) )
    {
        var ddl = document.getElementById(ctrl);
        var selectedText = '';
        var variantIndex = 0;
        var productIndex = GetProductIndexById(RcnProductIndexID);
        var findOption = false;
        
        // delete existing items
        for(i = ddl.options.length; i>0; i--)
            ddl.options[i] = null;
           
        // Add the variants. Observe that VariantIndex 0 represents the article when no variant is selected (i.e. do not render index = 0 to the selectbox options)
        for(j=1; j<ProductsMP[productIndex].Articles[index].Variants.length; j++)
            addOption(ddl,ProductsMP[productIndex].Articles[index].Variants[j].Name,ProductsMP[productIndex].Articles[index].Variants[j].VariantId);

        if(ddl.options.length == 2)
        {
            variantIndex = 1;
            selectedText = ddl.options[1].text; 
            SaveVariantIndexToViewState(1);          
        }
        
        // Try to get previously selected item (variant).
        var previousSelection = ddl.selectedIndex > 0 ? ddl.selectedIndex : (document.getElementById(RcnVariantIndexID).value > 0 ? document.getElementById(RcnVariantIndexID).value : 0)
        if (previousSelection > 0 && previousSelection < ddl.options.length)
        {
            findOption = true;
            selectedText = ddl.options[previousSelection].text;
        }

        if(findOption == true)
        {            
            for(z=0; z<ddl.options.length; z++)
            {
                if(ddl.options[z].text == selectedText)
                    variantIndex = z;
            }            
        }
        
        // Set selected item.
        ddl.selectedIndex = variantIndex;
        
        // Finally save current variant index to the client side "viewState" (hidden input)
        //SaveVariantIndexToViewStateMultiple(variantIndex, RcnVariantIndexID, RcnVariantIdID, RcnArticleIndexID, RcnProductIndex);
        SetVariantIndexToViewState(variantIndex, RcnProductIndexID, RcnVariantIndexID, RcnVariantIdID, RcnArticleIndexID);
        
        // Returns the selected variantIndex
        return variantIndex;
    }
}
 
 function RenderAvailabilityMultiple(RcnProductIndexID, RcnArticleIndexID, RcnVariantIndexID, RcnAvailabilityID, RcnAvailabilityInStockID, RcnAvailabilityNoStockID, RcnAvailabilityDeliveryStatusID, RcnAvailabilityLowStockID, RcnAvailabilityInStockAlmostSoldOutID, RcnAvailabilityDeliveryAlmostSoldOutID)
{
    var productIndex = GetProductIndexById(RcnProductIndexID);
    var articleIndex = document.getElementById(RcnArticleIndexID).value;
    var variantIndex = document.getElementById(RcnVariantIndexID).value;
    var objAvailability = document.getElementById(RcnAvailabilityID);
    var objAvailabilityInStock = document.getElementById(RcnAvailabilityInStockID);
    var objAvailabilityNoStock = document.getElementById(RcnAvailabilityNoStockID);
    var objDeliveryStatus = document.getElementById(RcnAvailabilityDeliveryStatusID);
    var objAvailabilityLowStock = document.getElementById(RcnAvailabilityLowStockID);
    var objAvailabilityInStockAlmostSoldOut = document.getElementById(RcnAvailabilityInStockAlmostSoldOutID);
    var objAvailabilityDeliveryAlmostSoldOut = document.getElementById(RcnAvailabilityDeliveryAlmostSoldOutID);
    
    if(articleIndex == '0' || articleIndex == '')
    {
        articleIndex = 0;
    }
      
    if(variantIndex == '0' || variantIndex == '')
    {
        variantIndex = 0;
    }
    
    // Set DeliveryStatus
    if(ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Availability > 0)
    {
        objAvailability.style.display = 'inline';
        objAvailabilityInStock.style.display = 'none';
        objAvailabilityNoStock.style.display = 'inline';
    }
    else
    {
        objAvailability.style.display = 'none';
        objAvailabilityLowStock.style.display = 'none'; 
    }       
        
    // In Stock
    if(ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Availability == 1)
    {
        objAvailabilityInStock.style.display = 'inline';
        objAvailabilityNoStock.style.display = 'none';
        objAvailabilityLowStock.style.display = 'none';
        objAvailabilityInStockAlmostSoldOut.style.display = 'none';
        objAvailabilityDeliveryAlmostSoldOut.style.display = 'none';
    }
    
    // No Stock
    if(ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Availability == 2)
    {
        objDeliveryStatus.innerHTML = ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].DeliveryStatus;
        objAvailabilityInStock.style.display = 'none';
        objAvailabilityNoStock.style.display = 'inline';
        objAvailabilityLowStock.style.display = 'none';
        objAvailabilityInStockAlmostSoldOut.style.display = 'none';
        objAvailabilityDeliveryAlmostSoldOut.style.display = 'none';
    }
    
    // Sold out
    if(ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Availability == 3)
    {
        // TODO: What todo, should probably never happen
        objDeliveryStatus.innerHTML = ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].DeliveryStatus;
        objAvailabilityInStock.style.display = 'none';
        objAvailabilityNoStock.style.display = 'inline';
    }
    
    /* Low Stock Warning */
    if(ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Availability == 4)
    {       
       objAvailabilityInStock.style.display = 'inline';
       objAvailabilityNoStock.style.display = 'none';
       objAvailabilityLowStock.style.display = 'block'; 
       objAvailabilityInStockAlmostSoldOut.style.display = 'inline';
       objAvailabilityDeliveryAlmostSoldOut.style.display = 'none';       
    }

    /* Low Stock Warning */
    if(ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Availability == 5)
    {
       objDeliveryStatus.innerHTML = ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].DeliveryStatus;
       objAvailabilityInStock.style.display = 'none';
       objAvailabilityNoStock.style.display = 'inline';
       objAvailabilityLowStock.style.display = 'block'; 
       objAvailabilityInStockAlmostSoldOut.style.display = 'none';
       objAvailabilityDeliveryAlmostSoldOut.style.display = 'inline';
    }
}

function RenderArticleNoMultiple(index, RcnProductIndexID, RcnArticleIndexID, RcnVariantIndexID, RcnArticleNoID, RcnArticleNoTextID)
{
     var productIndex = GetProductIndexById(RcnProductIndexID);
    
    // if called without parameters then display text from "ViewState"
    if( index == '-1')
        index = document.getElementById(RcnArticleIndexID).value;

    if (index == '')
        index = 0;

    var variantIndex = document.getElementById(RcnVariantIndexID).value;

    if(variantIndex == '0' || variantIndex == '')
    {
        variantIndex = 0;
    }

    var objArticleDisplay = document.getElementById(RcnArticleNoID);
    var objArticleText = document.getElementById(RcnArticleNoTextID);

    if (ProductsMP[productIndex].Articles[index].ArticleId != -1 && ProductsMP[productIndex].Articles[index].Variants[variantIndex].BookingNo != '')
    {
        objArticleText.style.display ='inline';
        objArticleDisplay.innerHTML = ": " + ProductsMP[productIndex].Articles[index].Variants[variantIndex].BookingNo;//+ A[index].ArticleId;
    }
    else 
    {
        objArticleText.style.display='none';
        objArticleDisplay.innerHTML = "";
    }
}

function RenderPriceInfoMultiple(PCAlternatePriceID, PCFromPriceID, PCPriceID, PCNicePriceID, PCDateID, PCDiscountInfoTextID, RcnProductIndexID, RcnArticleIndexID, RcnVariantIndexID)
{
    // TODO: Check that the object above exist before rendering...
    var objAlternatePrice = document.getElementById(PCAlternatePriceID);
    var objFromPrice = document.getElementById(PCFromPriceID);
    var objPrice = document.getElementById(PCPriceID);

    var objNicePrice = document.getElementById(PCNicePriceID);
    var objDate = document.getElementById(PCDateID);
    var objDiscountInfoText = document.getElementById(PCDiscountInfoTextID);
    
    // Get article- and variant index from the hidden state controls.
    var productIndex = GetProductIndexById(RcnProductIndexID);
    var articleIndex = document.getElementById(RcnArticleIndexID).value;
    var variantIndex = document.getElementById(RcnVariantIndexID).value;
        
    if(articleIndex == '0' || articleIndex == '')
        articleIndex = 0;
      
    if(variantIndex == '0' || variantIndex == '')
        variantIndex = 0;
           
    
    // Alternate price
    if( ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].HasAlternatePrice == 1 )
    {
        objAlternatePrice.innerHTML = '(' + ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].AlternatePrice + ')';
        objAlternatePrice.style.display = 'inline';
    }
    else
    {
        objAlternatePrice.style.display = 'none';
    }
    
    // Current Price
    objPrice.innerHTML = ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Price;
    objNicePrice.innerHTML = ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].Price;
    objFromPrice.innerHTML = ProductsMP[productIndex].Articles[articleIndex].PricePrefix;
    if( ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].IsAffectedByDiscount == 1 && ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].HasAlternatePrice == 1)
    {
        objNicePrice.style.display = 'inline';
        objPrice.style.display = 'none';
    }
    else
    {
        objNicePrice.style.display = 'none';
        objPrice.style.display = 'inline';
    }
    
    // Show PricePrefix
    if( ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].IsFromPrice == 1)
        objFromPrice.style.display = 'inline';
    else
        objFromPrice.style.display = 'none';

    // Show date.
    if( ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].HasDate == 1)
    {
        objDate.innerHTML = ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].DateDisplay;
        objDate.style.display = 'inline';
    }
    else
    {
        objDate.style.display = 'none';
    }

    // Info text.
    if( ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].HasDiscountInfoText == 1)
    {
        objDiscountInfoText.innerHTML = ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].DiscountInfoTextDisplay;
        objDiscountInfoText.style.display = 'inline';
    }
    else
    {
        objDiscountInfoText.style.display = 'none';
    }
}

function RenderProductImageMultiple(index, productIndex, htmlAnchorId, htmlImageId)
{    
   if(arguments.length < 1)
        index = 0;
    
    // Check that we have an element to render to.
    if (!document.getElementById(htmlImageId))
    {
        alert('RcnProductImage not found');
        return;
    }   
    var objImg = document.getElementById(htmlImageId);
    
    if (!document.getElementById(htmlAnchorId))
    {
        alert('RcnProductImageLink not found');
        return;
    }    
    var objLink = document.getElementById(htmlAnchorId);
            
    // set image src
    objImg.src = ProductsMP[productIndex].Articles[index].ImgPath;

    // set a href to pop zoom window
    objLink.href = PopupZoomUrl(ProductsMP[productIndex].Articles[index].Img);
}

function GetProductIndexById(RcnProductIndexID)
{
    var productIndex = document.getElementById(RcnProductIndexID).value;
    if(productIndex == '0' || productIndex == '')
    {
        productIndex = 0;
    }
    return productIndex;
}

function GetProductArticleOnIndex(productIndex, articleIndex)
{
    return ProductsMP[productIndex].Articles[articleIndex];
}

function GetArticleIndexOnArticleIdMultiple(productIndex, articleId)
{
    var index = 0;
    for(i=0; i<ProductsMP[productIndex].Articles.length; i++)
    {
        if( ProductsMP[productIndex].Articles[i].ArticleId == articleId)
            index = i;
    }
    return index;
}

function GetProductVariantIdOnIndex(productIndex, articleIndex, variantIndex)
{
    return ProductsMP[productIndex].Articles[articleIndex].Variants[variantIndex].VariantId;
}

function SetArticleIndexToViewState(index, RcnProductIndexID, RcnArticleIndexID, RcnArticleIdID)
{
    if(!document.getElementById(RcnArticleIndexID))
        return;
    document.getElementById(RcnArticleIndexID).value = index;
    
    // Save articleId to hidden field.
    if(!document.getElementById(RcnArticleIdID))
    {
        alert('Missing element ' + RcnArticleId);
        return
    }
    document.getElementById(RcnArticleIdID).value = GetProductArticleOnIndex(GetProductIndexById(RcnProductIndexID), index).ArticleId;
}

function SetVariantIndexToViewState(index, RcnProductIndexID, RcnVariantIndexID, RcnVariantIdID, RcnArticleIndexID)
{
    if(!document.getElementById(RcnVariantIndexID))
        return;
    document.getElementById(RcnVariantIndexID).value = index;
    
    // Save variantId to hidden field.
    if(!document.getElementById(RcnVariantIdID))
    {
        alert('Missing element '+ RcnVariantIdID);
        return
    }
    document.getElementById(RcnVariantIdID).value = GetProductVariantIdOnIndex(GetProductIndexById(RcnProductIndexID), document.getElementById(RcnArticleIndexID).value, index);
}

function SetVariantIdToViewState(variantId, RcnVariantIdID)
{
    if(!document.getElementById(RcnVariantIdID))
        return;
    document.getElementById(RcnVariantIdID).value = variantId;
}

function InitAndSetVariantMultiple(articleSelectId, variantSelectId, RcnVariantIndexID)
{
    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(RcnVariantIndexID).value;
            
            // trigger onchange event to init variant dropdown
            selArt.onchange();
            if(selVar.options.length == 2)
                variantIndex = 1;
            selVar.selectedIndex = variantIndex;
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
// RcnSelectorMultiple  Class attach to <div><select1/><select2/></div>
// Pass ID of hidden fields RcnVariantIndex, RcnVariantId, RcnArticleIndex and RcnArticleId
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnSelectorMultiple, RcnElementEventPublisherSubscriber);

function RcnSelectorMultiple(id, idArticle, idVariant, idProductIndex, idArticleIndex, idArticleId, idVariantIndex, idVariantId, checkBoxID, validationGrp)
{
    if ( arguments.length )
        this.InitInstance(id, idArticle, idVariant, idProductIndex, idArticleIndex, idArticleId, idVariantIndex, idVariantId, checkBoxID, validationGrp);
}

RcnSelectorMultiple.prototype.InitInstance = function(id, idArticle, idVariant, idProductIndex, idArticleIndex, idArticleId, idVariantIndex, idVariantId, checkBoxID, validationGrp)
{
    RcnSelector.baseClass.InitInstance.call(this, id);
    
    this.articleElement = document.getElementById(idArticle);
    this.variantElement = document.getElementById(idVariant);
    
    this.productIndex = idProductIndex;
    
    this.articleId = idArticleId;
    this.articleIndex = idArticleIndex;
    
    this.variantId = idVariantId;
    this.variantIndex = idVariantIndex;
    
    this.checkBox = document.getElementById(checkBoxID);
    this.validationGroup = validationGrp;
        
    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
    }
}

RcnSelectorMultiple.prototype.OnArticleSelectChangeHandler = function()
{   
    RcnClientFx.GetRcnObject(this).ArticleSelectChange();
}

RcnSelectorMultiple.prototype.OnVariantSelectChangeHandler = function()
{   
    RcnClientFx.GetRcnObject(this).VariantSelectChange();
}

RcnSelectorMultiple.prototype.ArticleSelectChange = function() {
    // Store the articleIndex
    SetArticleIndexToViewState(this.articleElement.selectedIndex, this.productIndex, this.articleIndex, this.articleId);

    if (this.checkBox.checked)
        this.checkBox.checked = Page_ClientValidate(this.validationGroup);

    // 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) {
        var selectedVariantIndex = PopulateVariantsMultiple(this.variantElement.id, this.articleElement.selectedIndex, this.productIndex, this.variantIndex, this.variantId, this.articleIndex);

        // Trigger events
        this.TrigEvent(new RcnVariantEvent(this, selectedVariantIndex));
        this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, selectedVariantIndex));
    }
    else {
        var oldVariantIndex = document.getElementById(this.variantIndex).value;
        var selectedVariantIndex = 0;
        if (this.articleElement.selectedIndex > 0)
            selectedVariantIndex = 1;

        // Store the variantIndex
        SetVariantIndexToViewState(selectedVariantIndex, this.productIndex, this.variantIndex, this.variantId, this.articleIndex);

        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));
}

RcnSelectorMultiple.prototype.VariantSelectChange = function() {
    // Store the variantIndex
    SetVariantIndexToViewState(this.variantElement.selectedIndex, this.productIndex, this.variantIndex, this.variantId, this.articleIndex);

    if (this.checkBox.checked)
        this.checkBox.checked = Page_ClientValidate(this.validationGroup);

    this.TrigEvent(new RcnVariantEvent(this, this.variantElement.selectedIndex));
    this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, this.variantElement.selectedIndex));
}

RcnSelectorMultiple.prototype.HandleEvent = function(eventObj)
{
    if(eventObj.ClassName() == 'RcnArticleEvent')
    {
        // 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 )
        {
            var selectedVariantIndex = PopulateVariantsMultiple(this.variantElement.id, this.productIndex, eventObj.ArticleIndex(), this.variantIndex, this.variantId, this.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
            SetVariantIndexToViewState(selectedVariantIndex, this.productIndex, this.variantIndex, this.variantId, this.articleIndex);
            
            if(oldVariantIndex != selectedVariantIndex)
            {
                // Trigger events
                this.TrigEvent(new RcnVariantEvent(this, selectedVariantIndex));
                this.TrigEvent(new RcnArticleVariantEvent(this, this.articleElement.selectedIndex, selectedVariantIndex));
            }
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
// RcnAvailabilityMultiple
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnAvailabilityMultiple, RcnElementEventSubscriber);

function RcnAvailabilityMultiple(id, productIndexID, articleIndexID, variantIndexID, availabilityID, availabilityInStockID, availabilityNoStockID, availabilityDeliveryStatusID, availabilityLowStockID, availabilityInStockAlmostSoldOutID, availabilityDeliveryAlmostSoldOutID)
{
    if ( arguments.length )
        this.InitInstance(id, productIndexID, articleIndexID, variantIndexID, availabilityID, availabilityInStockID, availabilityNoStockID, availabilityDeliveryStatusID, availabilityLowStockID, availabilityInStockAlmostSoldOutID, availabilityDeliveryAlmostSoldOutID);
}

RcnAvailabilityMultiple.prototype.InitInstance = function(id, productIndexID, articleIndexID, variantIndexID, availabilityID, availabilityInStockID, availabilityNoStockID, availabilityDeliveryStatusID, availabilityLowStockID, availabilityInStockAlmostSoldOutID, availabilityDeliveryAlmostSoldOutID)
{
    RcnAvailability.baseClass.InitInstance.call(this, id);
    
    this.productIndex = productIndexID;
    this.articleIndex = articleIndexID;
    this.variantIndex = variantIndexID; 
    this.availability = availabilityID; 
    this.availabilityInStock = availabilityInStockID;
    this.availabilityNoStock = availabilityNoStockID;
    this.availabilityDeliveryStatus = availabilityDeliveryStatusID;
    this.availabilityLowStock =  availabilityLowStockID;
    this.availabilityInStockAlmostSoldOut = availabilityInStockAlmostSoldOutID;
    this.availabilityDeliveryAlmostSoldOut = availabilityDeliveryAlmostSoldOutID;
}

RcnAvailabilityMultiple.prototype.HandleEvent = function(eventObj)
{
    if(eventObj.ClassName() == "RcnArticleEvent")
    {
        RenderAvailabilityMultiple(this.productIndex, this.articleIndex, this.variantIndex, this.availability, this.availabilityInStock, this.availabilityNoStock, this.availabilityDeliveryStatus, this.availabilityLowStock, this.availabilityInStockAlmostSoldOut, this.availabilityDeliveryAlmostSoldOut);
    }
    
    if(eventObj.ClassName() == "RcnVariantEvent")
    {
        RenderAvailabilityMultiple(this.productIndex, this.articleIndex, this.variantIndex, this.availability, this.availabilityInStock, this.availabilityNoStock, this.availabilityDeliveryStatus, this.availabilityLowStock, this.availabilityInStockAlmostSoldOut, this.availabilityDeliveryAlmostSoldOut);
    }
    
    if(eventObj.ClassName() == "RcnArticleVariantEvent")
    {
        RenderAvailabilityMultiple(this.productIndex, this.articleIndex, this.variantIndex, this.availability, this.availabilityInStock, this.availabilityNoStock, this.availabilityDeliveryStatus, this.availabilityLowStock, this.availabilityInStockAlmostSoldOut, this.availabilityDeliveryAlmostSoldOut);
    }
}

///////////////////////////////////////////////////////////////////////////////
// RcnPriceCommunicator  Class attach to the Price Communicator on DetailPage   
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnPriceCommunicatorMultiple, RcnElementEventSubscriber);

function RcnPriceCommunicatorMultiple(id, pcAlternatePriceID, pcFromPriceID, pcPriceID, pcNicePriceID, pcDateID, discountInfoTextID, productIndexID, articleIndexID, variantIndexID)
{
    if ( arguments.length )
        this.InitInstance(id, pcAlternatePriceID, pcFromPriceID, pcPriceID, pcNicePriceID, pcDateID, discountInfoTextID, productIndexID, articleIndexID, variantIndexID)
}

RcnPriceCommunicatorMultiple.prototype.InitInstance = function(id, pcAlternatePriceID, pcFromPriceID, pcPriceID, pcNicePriceID, pcDateID, discountInfoTextID, productIndexID, articleIndexID, variantIndexID)
{
    RcnPriceCommunicatorMultiple.baseClass.InitInstance.call(this, id);    
    
    this.pcAlternatePrice = pcAlternatePriceID; 
    this.pcFromPrice = pcFromPriceID; 
    this.pcPrice = pcPriceID; 
    this.pcNicePrice = pcNicePriceID; 
    this.pcDate = pcDateID; 
    this.discountInfoText = discountInfoTextID; 
    this.productIndex = productIndexID;
    this.articleIndex = articleIndexID;
    this.variantIndex = variantIndexID;
}

RcnPriceCommunicatorMultiple.prototype.HandleEvent = function(eventObj)
{
    if(eventObj.ClassName() == "RcnArticleEvent")
    {
        RenderPriceInfoMultiple(this.pcAlternatePrice, this.pcFromPrice, this.pcPrice, this.pcNicePrice, this.pcDate, this.discountInfoText, this.productIndex, this.articleIndex, this.variantIndex);
    }
    
    if(eventObj.ClassName() == "RcnVariantEvent")
    {
        RenderPriceInfoMultiple(this.pcAlternatePrice, this.pcFromPrice, this.pcPrice, this.pcNicePrice, this.pcDate, this.discountInfoText, this.productIndex, this.articleIndex, this.variantIndex);
    }
    
    if(eventObj.ClassName() == "RcnArticleVariantEvent")
    {        
        RenderPriceInfoMultiple(this.pcAlternatePrice, this.pcFromPrice, this.pcPrice, this.pcNicePrice, this.pcDate, this.discountInfoText, this.productIndex, this.articleIndex, this.variantIndex);
    }
}

///////////////////////////////////////////////////////////////////////////////
// RcnProductImage      Class attach to the RcnProductImage control <a><img /></a>
// parameters:          htmlAnchorId: the element id of <a> surrounding the <img> product image.
//                      htmlImageId:  the element id of <img> the product image.
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnProductImageMultiple, RcnElementEventSubscriber);

function RcnProductImageMultiple(htmlAnchorId, htmlImageId, productIndexId)
{
    if ( arguments.length )
        this.InitInstance(htmlAnchorId, htmlImageId, productIndexId);
}

RcnProductImageMultiple.prototype.InitInstance = function(htmlAnchorId, htmlImageId, productIndexId)
{
    RcnProductImage.baseClass.InitInstance.call(this, htmlAnchorId, htmlImageId);
    this.htmlAnchorElement = document.getElementById(htmlAnchorId);
    this.htmlImageElement = document.getElementById(htmlImageId);
    this.productIndex = GetProductIndexById(productIndexId);
}

RcnProductImageMultiple.prototype.HandleEvent = function(eventObj)
{
    if(eventObj.ClassName() == "RcnArticleEvent")
    {
        RenderProductImageMultiple(eventObj.ArticleIndex(), this.productIndex, this.htmlAnchorElement.id, this.htmlImageElement.id);
    }    
}

function RcnCheckWishlist(validationGrp)
{
    if(validationGrp != null && validationGrp != '')
    {
        if(Page_ClientValidate(validationGrp))
        {
            return false;
        }
    }
    
    return false;
}

///////////////////////////////////////////////////////////////////////////////
// RcnArticleDisplay
///////////////////////////////////////////////////////////////////////////////
RcnClientFx.CopyPrototype(RcnArticleDisplayMultiple, RcnElementEventSubscriber);

function RcnArticleDisplayMultiple(id, productIndexID, articleIndexID, variantIndexID, articleNoID, articleNoTextID)
{
    if ( arguments.length )
        this.InitInstance(id, productIndexID, articleIndexID, variantIndexID, articleNoID, articleNoTextID);
}

RcnArticleDisplayMultiple.prototype.InitInstance = function(id, productIndexID, articleIndexID, variantIndexID, articleNoID, articleNoTextID)
{
    RcnArticleDisplayMultiple.baseClass.InitInstance.call(this, id);
    
    this.productIndex = productIndexID;
    this.articleIndex = articleIndexID;
    this.variantIndex = variantIndexID;
    this.articleNo = articleNoID;
    this.articleNoText = articleNoTextID;
}

RcnArticleDisplayMultiple.prototype.HandleEvent = function(eventObj)
{
    if(eventObj.ClassName() == "RcnArticleEvent")
    {
        RenderArticleNoMultiple(eventObj.ArticleIndex(), this.productIndex, this.articleIndex, this.variantIndex, this.articleNo, this.articleNoText);
    }
    
    //Added: Boris Estrada, Guide Konsult Gbg AB, 2006-10-03 (EL99160).
    if(eventObj.ClassName() == "RcnArticleVariantEvent")
    {
        RenderArticleNoMultiple(eventObj.ArticleIndex(), this.productIndex, this.articleIndex, this.variantIndex, this.articleNo, this.articleNoText);
    }
}

function ValidateRow(chkBox, validationGrp) {
    if(chkBox.checked)
        chkBox.checked = Page_ClientValidate(validationGrp);
}

function CheckArticles(chkBox)
{    
    for(i = 0; i < chkBoxes.length; i++)
    {
        var cb = document.getElementById(chkBoxes[i]);
        if(cb.checked)
        {
            if(valGrps[i] != null && valGrps[i] != '')
            {
                cb.checked = (Page_ClientValidate(valGrps[i]));
            }
        }        
    }
}