////////////////////////////////////////////////////////////////////////////////
// AbstractLotteryComponents.AbstractLotterySelectorComponent

AbstractLotteryComponents.AbstractLotterySelectorComponent = function AbstractLotteryComponents_AbstractLotterySelectorComponent() {
    this._currentIDFOSport$1 = String.Empty;
    AbstractLotteryComponents.AbstractLotterySelectorComponent.constructBase(this);
}
AbstractLotteryComponents.AbstractLotterySelectorComponent.prototype = {
    _parameters$1: null,
    _navigationService$1: null,
    _numbersService$1: null,
    _fireNumbersChanged$1: true,
    _repaintOnLotteryChanged$1: false,
	_tempElement : "",
    
    setNavigationService: function AbstractLotteryComponents_AbstractLotterySelectorComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService$1 = navigationService;
        this._navigationService$1.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractLotteryComponents_AbstractLotterySelectorComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this.repaint();
    },
    
    setNumbersService: function AbstractLotteryComponents_AbstractLotterySelectorComponent$setNumbersService(numbersService) {
        this._log.debug('SetNumbersService');
        this._numbersService$1 = numbersService;
        this._numbersService$1.registerLotteryChangedListener(this);
    },
    
    onLotteryChanged: function AbstractLotteryComponents_AbstractLotterySelectorComponent$onLotteryChanged(eventSource, idfoSport) {
        this._currentIDFOSport$1 = idfoSport;
        try {
            this._fireNumbersChanged$1 = false;
            if (this._repaintOnLotteryChanged$1) {
                var imgSelectors = this._environment.getDomElement(this._domElementId).getElementsByTagName('DIV');
                for (var i = 0; i < imgSelectors.length; i++) {
                    var ancElement = imgSelectors[i];
                    if (ancElement) {
                        if (ancElement.id.indexOf('-imageselector-') > 0) {
                            if (ancElement.id.indexOf(idfoSport) > 0) {
                                ancElement.className = 'current';
                            }
                            else {
                                ancElement.className = 'normal';
                            }
                        }
                    }
                }
            }
            var select = this._environment.getDomElement(this._domElementId + '-select');
            if (select && select.value !== idfoSport) {
                select.value = idfoSport;
            }
        }
        finally {
            this._fireNumbersChanged$1 = true;
        }
    },
    
    init: function AbstractLotteryComponents_AbstractLotterySelectorComponent$init(environment, componentInstanceName, domElementId, parameters) {
        AbstractLotteryComponents.AbstractLotterySelectorComponent.callBase(this, 'init', [ environment, componentInstanceName, domElementId, parameters ]);
        this._parameters$1 = new Framework.CommonComponentParameters(parameters);
        if (Object.keyExists(parameters, 'repaint-on-lottery-changed')) {
            this._repaintOnLotteryChanged$1 = Boolean.parse(parameters['repaint-on-lottery-changed'].toString());
        }
				
    },
    
    start: function AbstractLotteryComponents_AbstractLotterySelectorComponent$start() {
        this.repaint();
    },
    
    repaint: function AbstractLotteryComponents_AbstractLotterySelectorComponent$repaint() {
        this._log.debug('Repaint');
        if (this.isVisible(this._parameters$1.get_visibleOn(), this._parameters$1.get_notVisibleOn(), this._navigationService$1.getAction())) {
            this.show();
            var xsltParameters = {};
			
			xsltParameters['component-instance-name'] = this._componentInstanceName;
            xsltParameters['component-dom-element-id'] = this._domElementId;
			/* C Cubbin Override to implement specific lotto markets to be opened */
			
			var pageFilter = this._navigationService$1.getPageFilter();

			if(pageFilter["lottoType"]!= null){
			  var currentLotto = pageFilter["lottoType"];
			    if (this._numbersService$1.getLottery() !== currentLotto) {
                this._numbersService$1.setLottery(currentLotto);
				document.getElementById("cc").className=currentLotto ;			
				}		  
			}
			/* End changes */
	
			
            if (!String.isNullOrEmpty(this._currentIDFOSport$1)) {
                xsltParameters['idfosport'] = this._currentIDFOSport$1;
            }
			
			else if (!String.isNullOrEmpty(this._numbersService$1.getLottery())){
				xsltParameters['idfosport'] = this._numbersService$1.getLottery();
			}
			else {
                xsltParameters['idfosport'] = "IRISHLOTTERY";
				this._numbersService$1.setLottery("IRISHLOTTERY");

            }
            this._environment.transformAndUpdate(this._domElementId, this._parameters$1.get_contentUrl().replace('${language}', this._environment.getLanguage()), this._parameters$1.get_xsltUrl(), xsltParameters, Delegate.create(this, this._afterRepaint$1));
       
	   }
        else {
            this.hide();
        }
    },
    
    _repaintAfterSelectedLotteryChanged$1: function AbstractLotteryComponents_AbstractLotterySelectorComponent$_repaintAfterSelectedLotteryChanged$1(idfosport, callback) {
        this._log.debug('Repaint');
        if (this.isVisible(this._parameters$1.get_visibleOn(), this._parameters$1.get_notVisibleOn(), this._navigationService$1.getAction())) {
            this.show();
            var xsltParameters = {};
            xsltParameters['component-instance-name'] = this._componentInstanceName;
            xsltParameters['component-dom-element-id'] = this._domElementId;
            xsltParameters['idfosport'] = idfosport;
            this._environment.transformAndUpdate(this._domElementId, this._parameters$1.get_contentUrl().replace('${language}', this._environment.getLanguage()), this._parameters$1.get_xsltUrl(), xsltParameters, callback);
        }
        else {
            this.hide();
        }
    },
    
    _afterRepaint$1: function AbstractLotteryComponents_AbstractLotterySelectorComponent$_afterRepaint$1() {
        Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(this._domElementId), (this));
		/* C Cubbin
		Class switching on the lottery selector links at the top of the page to allow selected link to be highlighted 
		Also the references to the drop down box removed, as we no longer require it
		*/
		var idfoSport = this._numbersService$1.getLottery();					
		var ele = this._environment.getDomElement(idfoSport +"-link");
		if (ele) {	 
			ele.className = ele.className.replace('lottoBall', 'lottoBall-active');
			this._tempElement = ele;
			}
    },
    
    _selectLottery$1: function AbstractLotteryComponents_AbstractLotterySelectorComponent$_selectLottery$1(IDFOSport) {
        if (this._fireNumbersChanged$1) {
            if (this._numbersService$1.getLottery() !== IDFOSport) {
                this._numbersService$1.setLottery(IDFOSport);
            }
        }
    },
    
    selectLotteryEventHandler: function AbstractLotteryComponents_AbstractLotterySelectorComponent$selectLotteryEventHandler(sender, eventArgs) {
        this._selectLottery$1((eventArgs.domElement).value);
    },
    
    clickSelectLotteryEventHandler: function AbstractLotteryComponents_AbstractLotterySelectorComponent$clickSelectLotteryEventHandler(sender, eventArgs) {
  
	   this._selectLottery$1(eventArgs.parameters.getAsString('idfosport'));
       /*C Cubbin
       idfosport is needed for the LotteryBetSlipComponent regional balls styling so below line added
       Also a href is needed on the ancors, so I have added a line to return the window event as false to fix an issue with ie
        */
        document.getElementById("cc").className=eventArgs.parameters._parameters["idfosport"];
		/* C Cubbin
		Class switching on the lottery selector links at the top of the page to allow selected link to be highlighted 
		*/
		
		var ele = this._environment.getDomElement(eventArgs.domElement.id);
		if(this._tempElement !=""){
			this._tempElement.className = ele.className.replace("lottoBall-active", 'lottoBall');
		}

		if (ele) {	 
			ele.className = ele.className.replace('lottoBall', 'lottoBall-active');
			this._tempElement = ele;
			}

        window.event.returnValue = false;
        
        
    },
    
    openPopupEventHandler: function AbstractLotteryComponents_AbstractLotterySelectorComponent$openPopupEventHandler(sender, eventArgs) {
        window.open(eventArgs.parameters.getAsString('url'), eventArgs.parameters.getAsString('target'), eventArgs.parameters.getAsString('features'));
        window.event.returnValue = false;
    }
}


////////////////////////////////////////////////////////////////////////////////
// AbstractLotteryComponents.AbstractTicketBuilderComponent

AbstractLotteryComponents.AbstractTicketBuilderComponent = function AbstractLotteryComponents_AbstractTicketBuilderComponent() {
    this._lastNumbers$1 = new Array(0);
    this._lastidfolotterydrawpatterns$1 = new Array(0);
    AbstractLotteryComponents.AbstractTicketBuilderComponent.constructBase(this);
}
AbstractLotteryComponents.AbstractTicketBuilderComponent.prototype = {
    _parameters$1: null,
    _navigationService: null,
    _numbersService: null,
    
    setNavigationService: function AbstractLotteryComponents_AbstractTicketBuilderComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
        this._navigationService.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this.repaint();
    },
    
    setNumbersService: function AbstractLotteryComponents_AbstractTicketBuilderComponent$setNumbersService(numbersService) {
        this._log.debug('SetNumbersService');
        this._numbersService = numbersService;
        this._numbersService.registerLotteryChangedListener(this);
        this._numbersService.registerNumbersChangedListener(this);
        this._numbersService.registerDrawsChangedListener(this);
        this._numbersService.registerCurrentBallSetChangedListener(this);
    },
    
    onLotteryChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onLotteryChanged(eventSource, idfosport) {
		//Selecting a different market, we want to clear any exisitng user input
		this._numbersService.clearBalls();  
		this.clearSectionTwo();
		this.repaintWithLottery(idfosport);

    },
    
    onNumbersChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onNumbersChanged(eventSource, ballset, isCurrentBallSet) {
		if (!isCurrentBallSet) {
            return;
        }
        var balls = ballset.getBalls();
        var numbers = this._numbersService.getNumbers(balls);
        var $enum1 = this._lastNumbers$1.getEnumerator();
        while ($enum1.moveNext()) {
            var number = $enum1.get_current();
            if (!numbers.contains(number)) {
                var ele = this._environment.getDomElement(String.format('{0}-ball-{1}', this._domElementId, number));
                if (ele) {
                    var className = String.format('{0}{1}', ' ticketbuilder-nch', number);
                    ele.className = ele.className.replace(className, '');
                }
            }
        }
        var $enum2 = numbers.getEnumerator();
        while ($enum2.moveNext()) {
            var number = $enum2.get_current();
            if (!this._lastNumbers$1.contains(number)) {
                var ele = this._environment.getDomElement(String.format('{0}-ball-{1}', this._domElementId, number));
                if (ele) {
                    var className = String.format('{0}{1}', ' ticketbuilder-nch', number);
                    if (ele.className.indexOf(className) < 0) {
                        ele.className = ele.className + '' + className;
                    }
                }
            }
        }
        this._lastNumbers$1 = numbers;
    },
    
    onMarketsChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onMarketsChanged(eventSource, idfomarkets) {
    },
    
    onWeeksSubscribedChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onWeeksSubscribedChanged(eventSource, weeksAhead) {
    },
    
    onDrawsChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onDrawsChanged(eventSource, idfolotterydrawpatterns, includeBonusBall, idfoPriceType) {
        var no = this._environment.getDomElement(String.format('{0}-bonusball-no', this._domElementId));
        var yes = this._environment.getDomElement(String.format('{0}-bonusball-yes', this._domElementId));
        if (no && yes) {
            if (includeBonusBall) {
                no.checked = false;
                yes.checked = true;
            }
            else {
                no.checked = true;
                yes.checked = false;
            }
        }
        var $enum1 = this._lastidfolotterydrawpatterns$1.getEnumerator();
        while ($enum1.moveNext()) {
            var pattern = $enum1.get_current();
            if (!idfolotterydrawpatterns.contains(pattern)) {
                var ele = this._environment.getDomElement(String.format('{0}-drawpattern-{1}', this._domElementId, pattern));
                if (ele) {
                    ele.checked = false;
                }
            }
        }
        var $enum2 = idfolotterydrawpatterns.getEnumerator();
        while ($enum2.moveNext()) {
            var pattern = $enum2.get_current();
            if (!this._lastidfolotterydrawpatterns$1.contains(pattern)) {
                var ele = this._environment.getDomElement(String.format('{0}-drawpattern-{1}', this._domElementId, pattern));
                if (ele && !ele.disabled) {
                    ele.checked = true;
                }
            }
        }
        this._lastidfolotterydrawpatterns$1 = idfolotterydrawpatterns;
    },
    
    onCurrentBallsetChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onCurrentBallsetChanged(eventSource, ballset) {
        this.onNumbersChanged(eventSource, ballset, true);
    },
    
    onCurrentBallsetBetsChanged: function AbstractLotteryComponents_AbstractTicketBuilderComponent$onCurrentBallsetBetsChanged(eventSource, ballset) {
    },
    
    init: function AbstractLotteryComponents_AbstractTicketBuilderComponent$init(environment, componentInstanceName, domElementId, parameters) {
        AbstractLotteryComponents.AbstractTicketBuilderComponent.callBase(this, 'init', [ environment, componentInstanceName, domElementId, parameters ]);
        this._parameters$1 = new Framework.CommonComponentParameters(parameters);

    },
    
    start: function AbstractLotteryComponents_AbstractTicketBuilderComponent$start() {
        this.repaint();
    },
    
    repaint: function AbstractLotteryComponents_AbstractTicketBuilderComponent$repaint() {
        this.repaintWithLottery(this._numbersService.getLottery());

		
    },
    
    repaintWithLottery: function AbstractLotteryComponents_AbstractTicketBuilderComponent$repaintWithLottery(idfoSport) {
        this._log.debug('Repaint');
        if (this.isVisible(this._parameters$1.get_visibleOn(), this._parameters$1.get_notVisibleOn(), this._navigationService.getAction()) && idfoSport && idfoSport.trim().length > 0) {
            this.show();
            var xsltParameters = {};
            xsltParameters['component-instance-name'] = this._componentInstanceName;
            xsltParameters['component-dom-element-id'] = this._domElementId;
            this._environment.transformAndUpdate(this._domElementId, this._parameters$1.get_contentUrl().replace('${language}', this._environment.getLanguage()).replace('${idfoSport}', idfoSport), this._parameters$1.get_xsltUrl(), xsltParameters, Delegate.create(this, this._afterRepaint$1));
	   }
        else {
            this.hide();
        }
    },
    
    _afterRepaint$1: function AbstractLotteryComponents_AbstractTicketBuilderComponent$_afterRepaint$1() {

        Framework.Behavior.Binding.BehaviorBinder.autoBind(this._environment.getDomElement(this._domElementId), (this));
        this._lastNumbers$1 = new Array(0);
        this._lastidfolotterydrawpatterns$1 = new Array(0);
        var inlcudeBonusBall = this._numbersService.getIncludeBonusBall();
        this.onDrawsChanged(this._numbersService, this._numbersService.getDrawPatterns(), inlcudeBonusBall, this._numbersService.getPriceType(inlcudeBonusBall));
        this.onNumbersChanged(this._numbersService, this._numbersService.getCurrentBallSet(), true);
		this._numbersService.clearBalls();  
		this.clearSectionTwo();
    },
    
    toggleBonusBallEventHandler: function AbstractLotteryComponents_AbstractTicketBuilderComponent$toggleBonusBallEventHandler(sender, eventArgs) {
        this._numbersService.setIncludeBonusBall(eventArgs.parameters.getAsBoolean('include'));
		//clear Section two tickboxes
		this.clearSectionTwo();
    },
    
    pickRandomBallsEventHandler: function AbstractLotteryComponents_AbstractTicketBuilderComponent$pickRandomBallsEventHandler(sender, eventArgs) {
        this._numbersService.pickRandomBalls(eventArgs.parameters.getAsNumber('numbertopick'), eventArgs.parameters.getAsNumber('numberofballs'));
        /*fix for ie 6 C Cubbin */
        window.event.returnValue = false;
    },
    
    clearBallsEventHandler: function AbstractLotteryComponents_AbstractTicketBuilderComponent$clearBallsEventHandler(sender, eventArgs) {
        this._numbersService.clearBalls();
        /*fix for ie 6 C Cubbin */
        window.event.returnValue = false;
    },
    
    weeksAheadChangedEventHandler: function AbstractLotteryComponents_AbstractTicketBuilderComponent$weeksAheadChangedEventHandler(sender, eventArgs) {
        this._numbersService.set_weeksAhead(eventArgs.parameters.getAsNumber('weeksahead'));
    },
    
    selectNumberEventHandler: function AbstractLotteryComponents_AbstractTicketBuilderComponent$selectNumberEventHandler(sender, eventArgs) {
        var numberSelected = eventArgs.parameters.getAsNumber('number');
        var className = String.format('{0}{1}', 'ticketbuilder-nch', numberSelected);
        if (eventArgs.domElement.className.indexOf(className) > -1) {
            try {
                this._numbersService.removeBall(numberSelected);
            }
            catch (e) {
                alert(this._numbersService.getErrorMessage(this._domElementId, e));
            }
        }
        else {
            try {
                this._numbersService.addBall(numberSelected);
            }
            catch (e) {
                alert(this._numbersService.getErrorMessage(this._domElementId, e));
            }
        }
    },
    
    toggleDrawPatternEventHandler: function AbstractLotteryComponents_AbstractTicketBuilderComponent$toggleDrawPatternEventHandler(sender, eventArgs) {
			var idOfPattern = eventArgs.parameters.getAsString('idfolotterydrawpattern');
			var idOfElement = 'DrawPatternContainer-'+ eventArgs.parameters.getAsString('idfolotterydrawpattern');
        if ((eventArgs.domElement).checked) {
            this._numbersService.addDraw(eventArgs.parameters.getAsString('idfolotterydrawpattern'), eventArgs.parameters.getAsString('csvavailablebettypes'));

			if(document.getElementById(idOfElement)) {
				document.getElementById(idOfElement).style.display = 'block';
				this.clearDrawMessage();
			}
		
		}
        else {
            this._numbersService.removeDraw(eventArgs.parameters.getAsString('idfolotterydrawpattern'));
			
			if(document.getElementById(idOfElement)) {
				document.getElementById(idOfElement).style.display = 'none';		
			}
		
        }
    },
	
	 clearSectionTwo: function AbstractLotteryComponents_AbstractTicketBuilderComponent$clearSectionTwo() {
		var aTmp = Framework.ADxMenu.getElementsByClassName('ticketbuilder-drawpattern', document, 'input');
		var aTmpid = new Array();
		var idOfDrawPattern;
		// uncheck tickboxes and remove draws
		if (aTmp && aTmp.length) {
			for (var i=0;i<aTmp.length;i++) {
				if(aTmp[i].checked == true){			
					aTmp[i].checked = false;														
					idOfDrawPattern = aTmp[i].getAttribute('behavior.toggledrawpattern.idfolotterydrawpattern');
					this._numbersService.removeDraw(idOfDrawPattern);					
				}
			}
		}
			
    },
	
	clearDrawMessage: function AbstractLotteryComponents_AbstractTicketBuilderComponent$clearDrawMessage() {
		var aTmp = Framework.ADxMenu.getElementsByClassName('drawMessage', document, 'div');
		if (aTmp && aTmp.length) {
			for (var i=0;i<aTmp.length;i++) {
				aTmp[i].style.display = 'none';
			}
		}
			
    }
	
}


AbstractLotteryComponents.AbstractLotterySelectorComponent.createClass('AbstractLotteryComponents.AbstractLotterySelectorComponent', Framework.Component.AbstractComponent, NavigationService.IPageFilterChangedListener, NumbersService.ILotteryChangedListener);
AbstractLotteryComponents.AbstractTicketBuilderComponent.createClass('AbstractLotteryComponents.AbstractTicketBuilderComponent', Framework.Component.AbstractComponent, NavigationService.IPageFilterChangedListener, NumbersService.ILotteryChangedListener, NumbersService.INumbersChangedListener, NumbersService.IDrawsChangedListener, NumbersService.ICurrentBallsetChangedListener);

// ---- Do not remove this footer ----
// Generated using Script# v0.5.1.0 (http://projects.nikhilk.net)
// -----------------------------------

////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.AbstractBetSlipComponent

AbstractMMCoreComponents.AbstractBetSlipComponent = function AbstractMMCoreComponents_AbstractBetSlipComponent() {
    this._absoluteImagePrefix = String.Empty;
    AbstractMMCoreComponents.AbstractBetSlipComponent.constructBase(this);
}
AbstractMMCoreComponents.AbstractBetSlipComponent.prototype = {
    _validationManager: null,
    _showCheckBetslip: false,
    _enableSlipToggling: false,
    _heightThreshold: '-1',
    _expandWhenFirstSelectionAdded: true,
    _autoAdjustHeight: true,
    _updateStakeTextboxOnStateChange: true,
    _doValidation: false,
    _accountService: null,
    
    setAccountService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setAccountService(accountService) {
        this._log.debug('SetAccountService');
        this._accountService = accountService;
    },
    
    onBalanceChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onBalanceChanged(eventSource) {
        this._log.debug('OnBalanceChanged');
        this.toggleFreeBet();
    },
    
    _betSlipService: null,
    
    setBetSlipService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setBetSlipService(betSlipService) {
        this._log.debug('SetBetSlipService');
        this._betSlipService = betSlipService;
    },
    
    onBetSlipSelectionsUpdate: function AbstractMMCoreComponents_AbstractBetSlipComponent$onBetSlipSelectionsUpdate(eventSource) {
        this._log.debug('OnBetSlipSelectionsUpdate');
        if (this.get_isComponentVisible()) {
            this.update();
        }
    },
    
    onSelectionsAdded: function AbstractMMCoreComponents_AbstractBetSlipComponent$onSelectionsAdded(eventSource, selection) {
        this._log.debug('OnSelectionsAdded');
        if (this.get_isComponentVisible()) {
            this.update();
        }
        if (this._expandWhenFirstSelectionAdded && this._betSlipService.getSelectionsCount() === 1) {
            this.expand();
        }
    },
    
    onSelectionsRemoved: function AbstractMMCoreComponents_AbstractBetSlipComponent$onSelectionsRemoved(eventSource, selection) {
        this._log.debug('OnSelectionsRemoved');
        if (this.get_isComponentVisible()) {
            this.update();
        }
        if (this._expandWhenFirstSelectionAdded && !this._betSlipService.getSelectionsCount()) {
            this.collapse();
        }
    },
    
    onAllowedBetTypesChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onAllowedBetTypesChanged(eventSource) {
        this._log.debug('OnAllowedBetTypesChanged');
        if (this.get_isComponentVisible()) {
            this.update();
        }
    },
    
    onBetSlipCalculationChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onBetSlipCalculationChanged(eventSource) {
        this._log.debug('OnBetSlipCalculationChanged');
        if (this.get_isComponentVisible()) {
            this.populateBetSlipCalculation();
        }
    },
    
    _fixedOddsBettingService: null,
    
    setFixedOddsBettingService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setFixedOddsBettingService(fixedOddsBettingService) {
        this._log.debug('SetFixedOddsBettingService');
        this._fixedOddsBettingService = fixedOddsBettingService;
    },
    
    onOddsTypeChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onOddsTypeChanged(fixedOddsBettingService) {
        this._log.debug('OnOddsTypeChanged');
        this.update();
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
        this._navigationService.registerTopicalizedPageFilterChangedListener(this, NavigationService.NavigationService.action);
    },
    
    onPageFilterChanged: function AbstractMMCoreComponents_AbstractBetSlipComponent$onPageFilterChanged(eventSource) {
        this._log.debug('OnPageFilterChanged');
        this.update();
    },
    
    _userService: null,
    
    setUserService: function AbstractMMCoreComponents_AbstractBetSlipComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    init: function AbstractMMCoreComponents_AbstractBetSlipComponent$init(environment, componentInstanceName, domElementId, parameters) {
        this._showCheckBetslip = Boolean.parse(parameters['show-check-betslip']);
        this._enableSlipToggling = Boolean.parse(parameters['enable-slip-toggling']);
        this._heightThreshold = parameters['height-threshold'];
        this._absoluteImagePrefix = parameters['absolute-image-prefix'];
        this._expandWhenFirstSelectionAdded = Boolean.parse(parameters['expand-when-first-selection-added']);
        this._autoAdjustHeight = Boolean.parse(parameters['auto-adjust-height']);
        if (!String.isNullOrEmpty(parameters['update-stake-textbox-on-state-change'])) {
            this._updateStakeTextboxOnStateChange = Boolean.parse(parameters['update-stake-textbox-on-state-change']);
        }
        if (!String.isNullOrEmpty(parameters['do-validation'])) {
            this._doValidation = Boolean.parse(parameters['do-validation']);
        }
        this._validationManager = new Framework.Validation.ValidationManager(this._environment);
    },
    
    preTransformation: function AbstractMMCoreComponents_AbstractBetSlipComponent$preTransformation(eventArgs) {
        var xmlBuilder = new AbstractMMCoreComponents.BetSlipComponent.BetSlipXmlBuilder(this._betSlipService.getBetSlipCalculation(), this._betSlipService.getSelections(), this._betSlipService.getStakePerSelection(), this._betSlipService.getAllowedBetTypes(), this._betSlipService.getStakePerBetType(), this._betSlipService.getIsEachWayPerBetType(), this._betSlipService.getPreviousSelections(), this._fixedOddsBettingService, this._accountService, this._betSlipService);
        eventArgs.get_contextObject().customXmlDocument = xmlBuilder.getBetSlipXML();
        if (!this.get_isComponentVisible()) {
            this._betSlipService.changeBetSlipLiveUpdateTimerStatus(false);
        }
        else {
            this._betSlipService.changeBetSlipLiveUpdateTimerStatus(true);
        }
    },
    
    renderComplete: function AbstractMMCoreComponents_AbstractBetSlipComponent$renderComplete(eventArgs) {
        if (this._doValidation) {
            this._validationManager.clearValidators();
            var $dict1 = this._betSlipService.getSelections();
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                var key = entry.key;
                var selection = entry.value;
                var labelElementID = String.format('{0}-{1}-price-type', this._domElementId, selection.IDFOSelection);
                var _validator = new Framework.Validation.RegexValidator('^\\d*(\\.\\d{1,2})?$');
                _validator.set_applyInputParentElementErrorClassOnError(false);
                _validator.inputElementId = String.format('{0}-{1}-unit-stake', this._domElementId, selection.IDFOSelection);
                _validator.errorElementId = String.format('{0}-{1}-unit-stake-error', this._domElementId, selection.IDFOSelection);
                _validator.set_errorLabelClass('LabelError');
                this._validationManager.registerInputForValidation(_validator);
            }
            for (var i = 0; i < this._betSlipService.getAllowedBetTypes().length; i++) {
                var selection = this._betSlipService.getAllowedBetTypes()[i];
                var _validator = new Framework.Validation.RegexValidator('^\\d*(\\.\\d{1,2})?$');
                _validator.set_applyInputParentElementErrorClassOnError(false);
                _validator.inputElementId = String.format('{0}-{1}-unit-stake', this._domElementId, selection.IDFOBetType);
                _validator.errorElementId = String.format('{0}-{1}-unit-stake-error', this._domElementId, selection.IDFOBetType);
                _validator.set_errorLabelClass('LabelError');
                this._validationManager.registerInputForValidation(_validator);
            }
        }
        if (this._autoAdjustHeight) {
            this.adjustHeight();
        }
    },
    
    get_isComponentVisible: function AbstractMMCoreComponents_AbstractBetSlipComponent$get_isComponentVisible() {
        return this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction());
    },
    
    getXsltParameters: function AbstractMMCoreComponents_AbstractBetSlipComponent$getXsltParameters(contextObject) {
        var xsltParameters = AbstractMMCoreComponents.AbstractBetSlipComponent.callBase(this, 'getXsltParameters', [ contextObject ]);
        if (this._showCheckBetslip) {
            xsltParameters['show-check-betslip'] = true;
        }
        if (this._enableSlipToggling) {
            xsltParameters['enable-slip-toggling'] = true;
        }
        xsltParameters['height-threshold'] = this._heightThreshold;
        xsltParameters['retain-after-placement'] = this._betSlipService.getRetainSelectionsAfterPlacement();
        xsltParameters['is-free-bet'] = this._betSlipService.getIsFree();
        xsltParameters['currency-symbol'] = this._accountService.getCurrencySimbol();
        xsltParameters['absolute-image-prefix'] = this._absoluteImagePrefix;
        var freeAccount = this._accountService.get_freeAccountDetails();
        xsltParameters['show-free-bet'] = (freeAccount && freeAccount.TradingBalance > 0) ? true : false;
        if (this._betSlipService.getIsFree() && (!freeAccount || freeAccount.TradingBalance <= 0)) {
            this._betSlipService.setIsFree(false);
        }
        return xsltParameters;
    },
    
    toggleEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$toggleEventHandler(sender, eventArgs) {
        this._log.debug('Toggle');
        var betslip = this._environment.getDomElement(this._domElementId);
        if (betslip.className.indexOf('bson') === -1) {
            this.expand();
            this.adjustHeight();
        }
        else {
            this.collapse();
        }
        eventArgs.domElement.blur();
        window.event.returnValue = false;
    },
    
    toggleHelpEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$toggleHelpEventHandler(sender, eventArgs) {
        this._log.debug('ToggleHelp');
        var help = this.getPrivateDomElement('betslip-help');
        if (help) {
            if (help.style.display === 'block') {
                help.style.display = 'none';
            }
            else {
                help.style.display = 'block';
                this.adjustHeight();
            }
        }
        eventArgs.domElement.blur();
        window.event.returnValue = false;
    },
    
    setRetainSelectionsAfterPlacementEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setRetainSelectionsAfterPlacementEventHandler(sender, eventArgs) {
        var retain = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetRetainSelectionsAfterPlacement retainSelectionsAfterPlacement=[{0}]', retain));
        this._betSlipService.setRetainSelectionsAfterPlacement(retain);
    },
    
    setIsFreeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setIsFreeEventHandler(sender, eventArgs) {
        var isFree = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetIsFree isFree=[{0}]', isFree));
        this._betSlipService.setIsFree(isFree);
    },
    
    placeBetEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$placeBetEventHandler(sender, eventArgs) {
        this.placeBet();
    },
    
    checkBetSlipEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$checkBetSlipEventHandler(sender, eventArgs) {
        this._log.debug('CheckBetSlip');
        if (this._userService.isLoggedIn()) {
            this.collapse();
        }
        this.startBetPlacement(true);
    },
    
    validateBetslip: function AbstractMMCoreComponents_AbstractBetSlipComponent$validateBetslip() {
        return this._validationManager.validateAll();
    },
    
    validateStakeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$validateStakeEventHandler(sender, eventArgs) {
        this._validationManager.validateAll();
        window.event.returnValue = false;
    },
    
    removeAllSelectionsEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$removeAllSelectionsEventHandler(sender, eventArgs) {
        this._log.debug('RemoveAllSelections');
        this._betSlipService.removeAllSelections();
        window.event.returnValue = false;
    },
    
    showSelectionInfoOutEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$showSelectionInfoOutEventHandler(sender, eventArgs) {
        this._log.debug('ShowSelectionInfoOut');
        var selectionInfo = this.getPrivateDomElement('selection-info');
        if (selectionInfo) {
            selectionInfo.style.visibility = 'hidden';
        }
    },
    
    showSelectionInfoOverEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$showSelectionInfoOverEventHandler(sender, eventArgs) {
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        this._log.debug(String.format('ShowSelectionInfoOver IDFOSelection=[{0}]', IDFOSelection));
        var key = this._betSlipService.getSimpleSelectionKey(IDFOSelection);
        this.showSelectionInfo(key, eventArgs.parameters.getAsNumber('offset'), eventArgs.domElement);
    },
    
    showScorecastSelectionInfoOverEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$showScorecastSelectionInfoOverEventHandler(sender, eventArgs) {
        var IDFOEventScorecast = eventArgs.parameters.getAsNumber('idfoeventscorecast');
        var IDFOSelection1GS = eventArgs.parameters.getAsNumber('idfoselection1gs');
        var IDFOSelectionCS = eventArgs.parameters.getAsNumber('idfoselectioncs');
        this._log.debug(String.format('ShowScorecastSelectionInfoOver IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        var key = this._betSlipService.getScorecastSelectionKey(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        this.showSelectionInfo(key, eventArgs.parameters.getAsNumber('offset'), eventArgs.domElement);
    },
    
    setSimpleSelectionPriceTypeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionPriceTypeEventHandler(sender, eventArgs) {
        this._log.debug(String.format('SetSimpleSelectionPriceType IDFOSelection=[{0}] activePriceType=[{1}]', eventArgs.parameters.getAsNumber('idfoselection'), Number.parse((eventArgs.domElement).value)));
        this._betSlipService.setSimpleSelectionPriceType(eventArgs.parameters.getAsNumber('idfoselection'), Number.parse((eventArgs.domElement).value));
    },
    
    setSimpleSelectionEachWayClickEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionEachWayClickEventHandler(sender, eventArgs) {
        this.setSimpleSelectionEachWay(eventArgs.parameters.getAsNumber('idfoselection'), ((eventArgs.domElement).checked) ? 0 : -1);
    },
    
    setSimpleSelectionEachWayChangeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionEachWayChangeEventHandler(sender, eventArgs) {
        this.setSimpleSelectionEachWay(eventArgs.parameters.getAsNumber('idfoselection'), Number.parse((eventArgs.domElement).value));
    },
    
    setStakePerSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setStakePerSelectionEventHandler(sender, eventArgs) {
        var stake = (eventArgs.domElement).value;
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        this._log.debug(String.format('SetStakePerSelection stake=[{0}] IDFOSelection=[{1}]', stake, IDFOSelection));
        if (this.isValidStake(stake)) {
            var parsedStake = (isNaN(Number.parse(stake))) ? 0 : Number.parse(stake);
            this._betSlipService.setStakePerSelection(IDFOSelection, parsedStake);
        }
    },
    
    setStakePerScorecastSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setStakePerScorecastSelectionEventHandler(sender, eventArgs) {
        var stake = (eventArgs.domElement).value;
        var IDFOEventScorecast = eventArgs.parameters.getAsNumber('idfoeventscorecast');
        var IDFOSelection1GS = eventArgs.parameters.getAsNumber('idfoselection1gs');
        var IDFOSelectionCS = eventArgs.parameters.getAsNumber('idfoselectioncs');
        this._log.debug(String.format('SetStakePerScorecastSelection stake=[{0}] IDFOEventScorecast=[{1}] IDFOSelection1GS=[{2}] IDFOSelectionCS=[{3}]', stake, IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        if (this.isValidStake(stake)) {
            var parsedStake = (isNaN(Number.parse(stake))) ? 0 : Number.parse(stake);
            this._betSlipService.setStakePerScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, parsedStake);
        }
    },
    
    removeSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$removeSelectionEventHandler(sender, eventArgs) {
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        this._log.debug(String.format('RemoveSelection IDFOSelection=[{0}]', IDFOSelection));
        this._betSlipService.removeSelection(IDFOSelection);
        window.event.returnValue = false;
    },
    
    removeScorecastSelectionEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$removeScorecastSelectionEventHandler(sender, eventArgs) {
        var IDFOEventScorecast = eventArgs.parameters.getAsNumber('idfoeventscorecast');
        var IDFOSelection1GS = eventArgs.parameters.getAsNumber('idfoselection1gs');
        var IDFOSelectionCS = eventArgs.parameters.getAsNumber('idfoselectioncs');
        this._log.debug(String.format('RemoveScorecastSelection IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS));
        this._betSlipService.removeScorecastSelection(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS);
        window.event.returnValue = false;
    },
    
    setIsEachWayPerBetTypeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setIsEachWayPerBetTypeEventHandler(sender, eventArgs) {
        var IDFOBetType = eventArgs.parameters.getAsString('idfobettype');
        var isEachWay = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetIsEachWayPerBetType IDFOBetType=[{0}] isEachWay=[{1}]', IDFOBetType, isEachWay));
        this._betSlipService.setIsEachWayPerBetType(IDFOBetType, isEachWay);
    },
    
    setStakePerBetTypeEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setStakePerBetTypeEventHandler(sender, eventArgs) {
        var stake = (eventArgs.domElement).value;
        var IDFOBetType = eventArgs.parameters.getAsString('idfobettype');
        this._log.debug(String.format('SetStakePerBetType stake=[{0}] IDFOBetType=[{1}]', stake, IDFOBetType));
        if (this.isValidStake(stake)) {
            var parsedStake = (isNaN(Number.parse(stake))) ? 0 : Number.parse(stake);
            this._betSlipService.setStakePerBetType(IDFOBetType, parsedStake, false);
        }
    },
    
    closeBetSlipUpdateMessageBarEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$closeBetSlipUpdateMessageBarEventHandler(sender, eventArgs) {
        this.getPrivateDomElement('betslipchanges').style.display = 'none';
        this._betSlipService.clearPreviousSelections();
        window.event.returnValue = false;
    },
    
    setSimpleSelectionIsTrapEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionIsTrapEventHandler(sender, eventArgs) {
        var IDFOSelection = eventArgs.parameters.getAsNumber('idfoselection');
        var isTrap = (eventArgs.domElement).checked;
        this._log.debug(String.format('SetSimpleSelectionIsTrap IDFOSelection=[{0}] isTrap=[{1}]', IDFOSelection, isTrap));
        this._betSlipService.setSimpleSelectionIsTrap(IDFOSelection, isTrap);
    },
    
    checkBetSlipKeyPressEventHandler: function AbstractMMCoreComponents_AbstractBetSlipComponent$checkBetSlipKeyPressEventHandler(sender, eventArgs) {
        if (window.event.srcElement.tagName.toUpperCase() === 'INPUT') {
            var targetElement = window.event.srcElement;
            if (window.event.keyCode === 13 && targetElement.type.toUpperCase() === 'TEXT') {
                targetElement.blur();
                this.placeBet();
                window.event.returnValue = false;
            }
        }
    },
    
    populateBetSlipCalculation: function AbstractMMCoreComponents_AbstractBetSlipComponent$populateBetSlipCalculation() {
        var betSlipCalculation = this._betSlipService.getBetSlipCalculation();
        var totalStake = 0;
        var totalPotentialReturn = 0;
        var totalPotentialReturnType = 0;
        var $dict1 = this._betSlipService.getSelections();
        for (var $key2 in $dict1) {
            var entry = { key: $key2, value: $dict1[$key2] };
            var selection = entry.value;
            var unitStakePerSelection = 0;
            if (Object.keyExists(this._betSlipService.getStakePerSelection(), entry.key)) {
                unitStakePerSelection = this._betSlipService.getStakePerSelection()[entry.key];
            }
            var unitStakeInputElement = this.getPrivateDomElement(String.format('{0}-unit-stake', entry.key));
            if (unitStakeInputElement) {
                if (this._updateStakeTextboxOnStateChange && (Number.parse(unitStakeInputElement.value) !== unitStakePerSelection)) {
                    unitStakeInputElement.value = (!unitStakePerSelection) ? '' : unitStakePerSelection.toString();
                }
            }
            var selectionCalculation = (!unitStakePerSelection && !Object.keyExists(betSlipCalculation.PerSelection, entry.key)) ? null : betSlipCalculation.PerSelection[entry.key];
            var totalStakeDomElement = this.getPrivateDomElement(String.format('{0}-total-stake', entry.key));
            if (totalStakeDomElement) {
                var selectionStake = (!selectionCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(selectionCalculation.TotalStake);
                if (totalStakeDomElement.tagName === 'INPUT') {
                    if (selectionStake !== '') {
                        (totalStakeDomElement).value = selectionStake;
                    }
                }
                else {
                    totalStakeDomElement.innerText = selectionStake;
                }
            }
            var potentialReturnDomElement = this.getPrivateDomElement(String.format('{0}-potential-return', entry.key));
            if (potentialReturnDomElement) {
                var selectionReturn = (!selectionCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(selectionCalculation.PotentialReturn);
                if (potentialReturnDomElement.tagName === 'INPUT') {
                    if ((selectionReturn !== '')) {
                        (potentialReturnDomElement).value = selectionReturn;
                    }
                }
                else {
                    potentialReturnDomElement.innerText = selectionReturn;
                }
            }
            if (selectionCalculation) {
                totalStake += selectionCalculation.TotalStake;
                totalPotentialReturn += (selectionCalculation.PotentialReturn < 0) ? 0 : selectionCalculation.PotentialReturn;
                totalPotentialReturnType = AbstractMMCoreComponents.CommonBetting.updatePotentialReturnType(selectionCalculation.PotentialReturn, totalPotentialReturnType);
            }
        }
        var allowedBetTypes = this._betSlipService.getAllowedBetTypes();
        for (var i = 0; i < allowedBetTypes.length; i++) {
            var unitStakePerBetType = 0;
            if (Object.keyExists(this._betSlipService.getStakePerBetType(), allowedBetTypes[i].IDFOBetType)) {
                unitStakePerBetType = this._betSlipService.getStakePerBetType()[allowedBetTypes[i].IDFOBetType];
            }
            var unitStakeInputElement = this.getPrivateDomElement(String.format('{0}-unit-stake', allowedBetTypes[i].IDFOBetType));
            if (unitStakeInputElement) {
                if (this._updateStakeTextboxOnStateChange && (Number.parse(unitStakeInputElement.value) !== unitStakePerBetType)) {
                    unitStakeInputElement.value = (!unitStakePerBetType) ? '' : unitStakePerBetType.toString();
                }
            }
            var betTypeCalculation = (!unitStakePerBetType && !Object.keyExists(betSlipCalculation.PerBetType, allowedBetTypes[i].IDFOBetType)) ? null : betSlipCalculation.PerBetType[allowedBetTypes[i].IDFOBetType];
            var totalStakeDomElement = this.getPrivateDomElement(String.format('{0}-total-stake', allowedBetTypes[i].IDFOBetType));
            if (totalStakeDomElement) {
                var multipleStake = (!betTypeCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatNumber(betTypeCalculation.TotalStake);
                if (totalStakeDomElement.tagName === 'INPUT') {
                    (totalStakeDomElement).value = multipleStake;
                }
                else {
                    totalStakeDomElement.innerText = multipleStake;
                }
            }
            var potentialReturnDomElement = this.getPrivateDomElement(String.format('{0}-potential-return', allowedBetTypes[i].IDFOBetType));
            if (potentialReturnDomElement) {
                var multipleReturn = (!betTypeCalculation) ? '' : AbstractMMCoreComponents.CommonBetting.formatPotentialReturn(betTypeCalculation.PotentialReturn);
                if (potentialReturnDomElement.tagName === 'INPUT') {
                    (potentialReturnDomElement).value = multipleReturn;
                }
                else {
                    potentialReturnDomElement.innerText = multipleReturn;
                }
            }
            if (betTypeCalculation) {
                totalStake += betTypeCalculation.TotalStake;
                totalPotentialReturn += (betTypeCalculation.PotentialReturn < 0) ? 0 : betTypeCalculation.PotentialReturn;
                totalPotentialReturnType = AbstractMMCoreComponents.CommonBetting.updatePotentialReturnType(betTypeCalculation.PotentialReturn, totalPotentialReturnType);
            }
        }
        var totalStakeDE = this.getPrivateDomElement('total-stake');
        if (totalStakeDE) {
            var totalBetSlipStake = AbstractMMCoreComponents.CommonBetting.formatNumber(totalStake);
            if (totalStakeDE.tagName === 'INPUT') {
                (totalStakeDE).value = totalBetSlipStake;
            }
            else {
                totalStakeDE.innerText = totalBetSlipStake;
            }
        }
        var potentialReturnDE = this.getPrivateDomElement('potential-return');
        if (potentialReturnDE) {
            var totalReturn = AbstractMMCoreComponents.CommonBetting.formatPotentialReturn((totalPotentialReturnType < 0) ? totalPotentialReturnType : totalPotentialReturn);
            if (potentialReturnDE.tagName === 'INPUT') {
                (potentialReturnDE).value = totalReturn;
            }
            else {
                potentialReturnDE.innerText = totalReturn;
            }
        }
    },
    
    toggleFreeBet: function AbstractMMCoreComponents_AbstractBetSlipComponent$toggleFreeBet() {
        var freeBet = this.getPrivateDomElement('is-free-label');
        var freeAccount = this._accountService.get_freeAccountDetails();
        if (freeAccount) {
            if (freeBet) {
                freeBet.style.display = (freeAccount.TradingBalance > 0) ? 'block' : 'none';
            }
        }
        else {
            if (freeBet) {
                freeBet.style.display = 'none';
            }
        }
        if (freeBet && freeBet.style.display === 'none' && this._betSlipService.getIsFree()) {
            this._betSlipService.setIsFree(false);
        }
    },
    
    setBusyStatus: function AbstractMMCoreComponents_AbstractBetSlipComponent$setBusyStatus(isBusy) {
        (this.getPrivateDomElement('place-bet')).disabled = isBusy;
        this._environment.getDomElement(this._domElementId).style.cursor = (isBusy) ? 'wait' : 'default';
    },
    
    isValidStake: function AbstractMMCoreComponents_AbstractBetSlipComponent$isValidStake(s) {
        return new RegExp('^\\d*(\\.\\d{1,2})?$').test(s);
    },
    
    placeBet: function AbstractMMCoreComponents_AbstractBetSlipComponent$placeBet() {
        this._log.debug('PlaceBet');
        if (this._userService.isLoggedIn()) {
            this.collapse();
        }
        if (this.validateBetslip()) {
            this.startBetPlacement(false);
        }
    },
    
    startBetPlacement: function AbstractMMCoreComponents_AbstractBetSlipComponent$startBetPlacement(checkBets) {
        this._log.debug('StartBetPlacement');
        if (!this._userService.isLoggedIn()) {
            alert(this.getTranslation('error-login'));
        }
        else if (!this._betSlipService.checkIfBetSlipHasStake()) {
            alert(this.getTranslation('error-stake'));
        }
        else if (!this._betSlipService.checkIfBetSlipHasCalculation()) {
            alert(this.getTranslation('error-selection'));
        }
        else {
            this._betSlipService.placeBetSlip((checkBets) ? FixedOddsBettingService.OverrideToShowConfirmation.overrideToShowConfirmation : FixedOddsBettingService.OverrideToShowConfirmation.notOverride);
        }
    },
    
    expand: function AbstractMMCoreComponents_AbstractBetSlipComponent$expand() {
        this._log.debug('Expand');
        var betslip = document.getElementById(this._domElementId);
        var betslipaction = this.getPrivateDomElement('acttogglebody');
        betslip.className = betslip.className.replace('bsoff', 'bson');
       // this._environment.updateDomElementDirect(betslipaction, 'close slip');
    },
    
    collapse: function AbstractMMCoreComponents_AbstractBetSlipComponent$collapse() {
        this._log.debug('Collapse');
        var betslip = document.getElementById(this._domElementId);
        var betslipaction = this.getPrivateDomElement('acttogglebody');
        betslip.className = betslip.className.replace('bson', 'bsoff');
     //   this._environment.updateDomElementDirect(betslipaction, 'reveal slip');
    },
    
    adjustHeight: function AbstractMMCoreComponents_AbstractBetSlipComponent$adjustHeight() {
        if (this._autoAdjustHeight) {
            this._log.debug('AdjustHeight');
            if (this._heightThreshold !== '-1') {
                var betslip = document.getElementById(this._domElementId);
                var bstable = document.getElementById(this._domElementId + '-table');
                var bsbody = document.getElementById(this._domElementId + '-bsbody');
				var totalBetslipHeight = bsbody.offsetHeight;				
                if (this._heightThreshold === '0') {			
					
					var clientHeight = document.documentElement.clientHeight-140;
					
					var updateHeight = document.getElementById(this._domElementId + '-betslipchanges');
					var nDiff = clientHeight - totalBetslipHeight;
	
					
                    if (nDiff < 0) {
                        bsbody.style.height = (clientHeight -30) +"px";
                        bsbody.style.overflowY = 'auto';
                    }
					/*
                    else if (nDiff > 0) {
                        bsbody.style.height = 'auto';
                        bsbody.style.overflow = 'visible';
                    }
					*/
                }
                else if (bsbody.offsetHeight > parseInt(this._heightThreshold)) {
                    bsbody.style.height = this._heightThreshold + 'px';
                    bsbody.style.overflow = 'auto';
                }
                else {
                    bsbody.style.height = 'auto';
                    bsbody.style.overflow = 'visible';
                }
            }
        }
    },
    
    showSelectionInfo: function AbstractMMCoreComponents_AbstractBetSlipComponent$showSelectionInfo(selectionKey, offset, parent) {
        var selection = this._betSlipService.getSelections()[selectionKey];
        if (!selection) {
            return;
        }
        var selectionInfo = this.getPrivateDomElement('selection-info');
        if (selectionInfo) {
            this.updatePrivateDomElement('selection-info-eventname', unescape(selection.EventName));
            this.updatePrivateDomElement('selection-info-marketname', unescape(selection.MarketName));
            this.updatePrivateDomElement('selection-info-selectionname', unescape(selection.SelectionName));
            this.updatePrivateDomElement('selection-info-price', this._fixedOddsBettingService.formatOdds(selection.IDFOPriceType[selection.ActivePriceType], selection.PriceUp, selection.PriceDown));
            this.updatePrivateDomElement('selection-info-handicap', (!selection.Handicap) ? 'N/A' : this.getSelectionHandicap(selection));
            selectionInfo.style.visibility = 'visible';
        }
        var actualOffset = (isNaN(offset)) ? 80 : offset;
        if (parent && selectionInfo) {
            selectionInfo.style.top = (parent.offsetTop + actualOffset).toString() + 'px';
        }
    },
    
    setSimpleSelectionEachWay: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionEachWay(IDFOSelection, activeEachWay) {
        this._log.debug(String.format('SetSimpleSelectionEachWay IDFOSelection=[{0}] activeEachWay=[{1}]', IDFOSelection, activeEachWay));
        this._betSlipService.setSimpleSelectionEachWay(IDFOSelection, activeEachWay);
    },
    
    setSimpleSelectionIsTrap: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSimpleSelectionIsTrap(IDFOSelection, isTrap) {
    },
    
    getSelectionHandicap: function AbstractMMCoreComponents_AbstractBetSlipComponent$getSelectionHandicap(selection) {
        var selectionHandicap = '';
        if (selection.Handicap) {
            if (selection.HADValue === 'A') {
                if (selection.Handicap < 0) {
                    selectionHandicap += String.format(' +{0}', selection.Handicap * -1);
                }
                else {
                    selectionHandicap += String.format(' {0}', selection.Handicap * -1);
                }
            }
            else {
                selectionHandicap += String.format(' {0}', selection.Handicap);
            }
        }
        return selectionHandicap;
    },
    
    setSelectionActivity: function AbstractMMCoreComponents_AbstractBetSlipComponent$setSelectionActivity(IDFOSelection, isActive, domElementId) {
        this._log.debug(String.format('SetSelectionActivity IDFOSelection=[{0}] isActive=[{1}] domElementId=[{2}]', IDFOSelection, isActive, domElementId));
        var row = this._environment.getDomElement(domElementId);
        row.className = (isActive) ? 'BSselHi' : 'BSsel';
        this._betSlipService.setSimpleSelectionActivity(IDFOSelection, isActive);
    },
    
    setScorecastSelectionActivity: function AbstractMMCoreComponents_AbstractBetSlipComponent$setScorecastSelectionActivity(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive, domElementId) {
        this._log.debug(String.format('SetSelectionActivity IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}] domElementId=[{4}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive, domElementId));
        var row = this._environment.getDomElement(domElementId);
        row.className = (isActive) ? 'BSselHi' : 'BSsel';
        this._betSlipService.setScorecastSelectionActivity(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, isActive);
    },
    
    setScorecastSelectionPriceType: function AbstractMMCoreComponents_AbstractBetSlipComponent$setScorecastSelectionPriceType(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType) {
        this._log.debug(String.format('SetScorecastSelectionPriceType IDFOEventScorecast=[{0}] IDFOSelection1GS=[{1}] IDFOSelectionCS=[{2}] isActive=[{3}]', IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType));
        this._betSlipService.setScorecastSelectionPriceType(IDFOEventScorecast, IDFOSelection1GS, IDFOSelectionCS, activePriceType);
    }
}

AbstractMMCoreComponents.AbstractBetSlipComponent.createClass('AbstractMMCoreComponents.AbstractBetSlipComponent', Framework.Component.AbstractXsltBasedComponent, AccountService.IBalanceChangedListener, NavigationService.IPageFilterChangedListener, FixedOddsBettingService.IOddsTypeChangedListener, BetSlipService.ISelectionsAddedListener, BetSlipService.ISelectionsRemovedListener, BetSlipService.IAllowedBetTypesChangedListener, BetSlipService.IBetSlipCalculationChangedListener, BetSlipService.IBetSlipSelectionsUpdateListener);



////////////////////////////////////////////////////////////////////////////////
// AbstractMMCoreComponents.AbstractLoginComponent

AbstractMMCoreComponents.AbstractLoginComponent = function AbstractMMCoreComponents_AbstractLoginComponent() {
    AbstractMMCoreComponents.AbstractLoginComponent.constructBase(this);
}
AbstractMMCoreComponents.AbstractLoginComponent.prototype = {
    _supportCryptogramLogin: false,
    _enableRememberMe: false,
    
    usernameOnBlurEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$usernameOnBlurEventHandler(sender, eventArgs) {
        this.onUsernameBlur(eventArgs.domElement);
    },
    
    passwordOnBlurEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$passwordOnBlurEventHandler(sender, eventArgs) {
        this.onPasswordBlur(eventArgs.domElement);
    },
    
    usernameOnFocusEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$usernameOnFocusEventHandler(sender, eventArgs) {
        this.onUsernameFocus(eventArgs.domElement);
    },
    
    passwordOnFocusEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$passwordOnFocusEventHandler(sender, eventArgs) {
        this.onPasswordFocus(eventArgs.domElement);
    },
	
	usernameOnClickEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$usernameOnClickEventHandler(sender, eventArgs) {
        this.onUsernameClick(eventArgs.domElement);
    },
	
	passwordOnClickEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$passwordOnClickEventHandler(sender, eventArgs) {
        this.onPasswordClick(eventArgs.domElement);
    },
    
    bindGoToBehaviorEventHandler: function AbstractMMCoreComponents_AbstractLoginComponent$bindGoToBehaviorEventHandler(sender, eventArgs) {
        new NavigationService.GoToBehavior(eventArgs.domElement, null, this._navigationService);
    },
    
    _navigationService: null,
    
    setNavigationService: function AbstractMMCoreComponents_AbstractLoginComponent$setNavigationService(navigationService) {
        this._log.debug('SetNavigationService');
        this._navigationService = navigationService;
    },
    
    _userService: null,
    
    setUserService: function AbstractMMCoreComponents_AbstractLoginComponent$setUserService(userService) {
        this._log.debug('SetUserService');
        this._userService = userService;
    },
    
    onUserChanged: function AbstractMMCoreComponents_AbstractLoginComponent$onUserChanged(eventSource) {
        this._log.debug('OnUserChanged');
        this.update();
    },
    
    get_usernameTextbox: function AbstractMMCoreComponents_AbstractLoginComponent$get_usernameTextbox() {
        return this._environment.getDomElement(this._domElementId + '.username');
    },
    
    get_passwordTextbox: function AbstractMMCoreComponents_AbstractLoginComponent$get_passwordTextbox() {
        return this._environment.getDomElement(this._domElementId + '.password');
    },
    
    get_rememberMeCheckbox: function AbstractMMCoreComponents_AbstractLoginComponent$get_rememberMeCheckbox() {
        return this._environment.getDomElement(this._domElementId + '.rememberme');
    },
    
    init: function AbstractMMCoreComponents_AbstractLoginComponent$init(environment, componentInstanceName, domElementId, parameters) {
        if (parameters['support-cryptogram-login']) {
            this._supportCryptogramLogin = Boolean.parse(parameters['support-cryptogram-login']);
        }
        if (parameters['enable-remember-me']) {
            this._enableRememberMe = Boolean.parse(parameters['enable-remember-me']);
        }
    },
    
    start: function AbstractMMCoreComponents_AbstractLoginComponent$start() {
        if (this.proceedWithCryptogramLogin()) {
            this._userService.loginWithCryptogram(Delegate.create(this, function(result) {
                this.enable();
                var _filters = this._navigationService.getPageFilter();
                delete _filters.username;
                delete _filters.password;
                this._navigationService.goTo(this._environment.getPageArea(), _filters);
            }), Delegate.create(this, function(exception) {
                var eventArgs = new Framework.Component.LifeCycleManagement.EventArgs.CustomEventArgs();
                eventArgs.parametersDictionary[AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2] = Framework.ExceptionUtil.getExceptionDetails(exception).get_message();
                this.update(this.get_componentElement(), null, this._parameters.get_xsltUrl(), this.getXsltParameters(null), eventArgs);
            }), this._navigationService.getPageFilter()['username'].toString().toLowerCase(), this._navigationService.getPageFilter()['password'].toString().toUpperCase());
        }
    },
    
    get_isComponentVisible: function AbstractMMCoreComponents_AbstractLoginComponent$get_isComponentVisible() {
        return this.isVisible(this._parameters.get_visibleOn(), this._parameters.get_notVisibleOn(), this._navigationService.getAction()) && !this._userService.isLoggedIn();
    },
    
    renderComplete: function AbstractMMCoreComponents_AbstractLoginComponent$renderComplete(eventArgs) {
        this.show();
        if (this._enableRememberMe) {
            if (this.isUsernameRemembered()) {
                this.get_rememberMeCheckbox().checked = true;
            }
        }
        if (this.shouldUsernameBeSetAfterInRepaint()) {
            this.setUsernameFromCookie();
        }
        var loginElement = this.getPrivateDomElement('form');
        if (loginElement) {
            var onLoginClickedBehaviour = new Framework.Behavior.ElementBehavior(loginElement);
            onLoginClickedBehaviour.add_onSubmit(Delegate.create(this, function(sender, ea) {
                this.onLoginClicked();
            }));
        }
        if (eventArgs.get_customEventArgs() && eventArgs.get_customEventArgs().parametersDictionary[AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2]) {
            this.enable();
            alert(eventArgs.get_customEventArgs().parametersDictionary[AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2]);
        }
    },
    
    getXsltParameters: function AbstractMMCoreComponents_AbstractLoginComponent$getXsltParameters(contextObject) {
        var xsltParameters = {};
        xsltParameters['component-dom-element-id'] = this._domElementId;
        xsltParameters['component-instance-name'] = this._componentInstanceName;
        xsltParameters['enable-remember-me'] = this._enableRememberMe;
        return xsltParameters;
    },
    
    shouldUsernameBeSetAfterInRepaint: function AbstractMMCoreComponents_AbstractLoginComponent$shouldUsernameBeSetAfterInRepaint() {
        return true;
    },
    
    setUsernameFromCookie: function AbstractMMCoreComponents_AbstractLoginComponent$setUsernameFromCookie() {
        if (!this.get_usernameTextbox()) {
            return;
        }
        if (this._enableRememberMe) {
			if (this.isUsernameRemembered() && (this.get_usernameTextbox().value =='Username')) {
                this.get_usernameTextbox().value = Framework.CookieUtil.getCookie('username');
            }
        }
    },
    
    onLoginClicked: function AbstractMMCoreComponents_AbstractLoginComponent$onLoginClicked() {
        if (!this.get_usernameTextbox()) {
            return;
        }
        if (!this.get_passwordTextbox()) {
            return;
        }
        var CheckUsernameBlank = this.get_usernameTextbox().value.trim();
        var CheckPassswordBlank = this.get_passwordTextbox().value.trim();
        if (!CheckUsernameBlank.length || !CheckPassswordBlank.length) {
            window.event.returnValue = false;
            return;
        }
        this.disable();
        if (this.get_rememberMeCheckbox()) {
            if (this.get_rememberMeCheckbox().checked) {
                Framework.CookieUtil.setCookie('username', this.get_usernameTextbox().value);
            }
            else {
                Framework.CookieUtil.clearCookie('username');
            }
        }
        this._userService.login(Delegate.create(this, function(result) {
            this.enable();
        }), Delegate.create(this, function(exception) {
            this.enable();
            alert(Framework.ExceptionUtil.getExceptionDetails(exception).get_message());
        }), this.get_usernameTextbox().value, this.get_passwordTextbox().value);
        window.event.returnValue = false;
    },
    
    onUsernameBlur: function AbstractMMCoreComponents_AbstractLoginComponent$onUsernameBlur(element) {
	var clickedElementID =element["id"];	
	var currentPassword =element["value"];	
	if(currentPassword === 'Username'){
		var theElement = document.getElementById(clickedElementID);
		theElement.value ="";
	}
    },
    
    onUsernameFocus: function AbstractMMCoreComponents_AbstractLoginComponent$onUsernameFocus(element) {
	var clickedElementID =element["id"];	
	var currentPassword =element["value"];	
	if(currentPassword === 'Username'){
		var theElement = document.getElementById(clickedElementID);
		theElement.value ="";
	}
    },

    onUsernameClick: function AbstractMMCoreComponents_AbstractLoginComponent$onUsernameClick(element) {
	var clickedElementID =element["id"];	
	var currentPassword =element["value"];	
	if(currentPassword === 'Username'){
		var theElement = document.getElementById(clickedElementID);
		theElement.value ="";
	}
    },

    onPasswordClick: function AbstractMMCoreComponents_AbstractLoginComponent$onPasswordClick(element) {
	var clickedElementID =element["id"];	
	var currentPassword =element["value"];	
	if(currentPassword === 'Password'){
		var theElement = document.getElementById(clickedElementID);
		theElement.value ="";
	}
    },	
    
    onPasswordBlur: function AbstractMMCoreComponents_AbstractLoginComponent$onPasswordBlur(element) {
	var clickedElementID =element["id"];	
	var currentPassword =element["value"];	
	if(currentPassword === 'Password'){
		var theElement = document.getElementById(clickedElementID);
		theElement.value ="";
	}
    },	

    
    onPasswordFocus: function AbstractMMCoreComponents_AbstractLoginComponent$onPasswordFocus(element) {
	var clickedElementID =element["id"];	
	var currentPassword =element["value"];	
	if(currentPassword === 'Password'){
		var theElement = document.getElementById(clickedElementID);
		theElement.value ="";
	}
    },
	
    proceedWithCryptogramLogin: function AbstractMMCoreComponents_AbstractLoginComponent$proceedWithCryptogramLogin() {
        if (!this._supportCryptogramLogin) {
            return false;
        }
        if (!this._navigationService.getPageFilter()['username']) {
            return false;
        }
        if (!this._navigationService.getPageFilter()['password']) {
            return false;
        }
		
        if (this._userService.isLoggedIn()) {
            return false;
        }
        return true;
    },
    
    isUsernameRemembered: function AbstractMMCoreComponents_AbstractLoginComponent$isUsernameRemembered() {
        return !String.isNullOrEmpty(Framework.CookieUtil.getCookie('username'));
    },
    
    enable: function AbstractMMCoreComponents_AbstractLoginComponent$enable() {
        this._environment.safelyRemoveCssClass(this._domElementId + '-form', 'wait');
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, true);
    },
    
    disable: function AbstractMMCoreComponents_AbstractLoginComponent$disable() {
        this._environment.safelySetCssClass(this._domElementId + '-form', 'wait');
        Framework.Component.AbstractComponent.setFormEnabled(this._domElementId, false);
    },
    
    show: function AbstractMMCoreComponents_AbstractLoginComponent$show() {
        this._environment.safelySetAndUnsetCssClass(this._domElementId, 'visible', 'invisible');
    },
    
    hide: function AbstractMMCoreComponents_AbstractLoginComponent$hide() {
        this._environment.safelySetAndUnsetCssClass(this._domElementId, 'invisible', 'visible');
    }
}
AbstractMMCoreComponents.AbstractLoginComponent.createClass('AbstractMMCoreComponents.AbstractLoginComponent', Framework.Component.AbstractXsltBasedComponent, UserService.IUserChangedListener);
AbstractMMCoreComponents.AbstractLoginComponent._erroR_MESSAGE$2 = 'error_message';