//
// Функции для калькулятора "страхования путешественников"
//
// $Id: traveller-functions.js,v 1.1 2006/12/07 13:50:46 alex Exp $
//

function load()
{
    o=document.getElementById('in_program');

    for (i=0;i<__programs.length;i++)
    {
        vmv_select_add_option(o,__programs[i]['name'],__programs[i]['id']);
    }

    o=document.getElementById('in_variant');

    for (i=0;i<__variants.length;i++)
    {
        vmv_select_add_option(o,__variants[i]['name'],__variants[i]['id']);
    }

    o=document.getElementById('in_sum');

    for (i=0;i<__sums.length;i++)
    {
        vmv_select_add_option(o,__sums[i]['name'],__sums[i]['id']);
        if (__sums_default_id==__sums[i]['id']) o.selectedIndex=i;
    }

    o=document.getElementById('in_currency');

    for (i=0;i<__currencies.length;i++)
    {
        vmv_select_add_option(o,__currencies[i]['name'],__currencies[i]['id']);
    }

    o=document.getElementById('in_age1');
    for (i=0;i<__ages.length;i++) vmv_select_add_option(o,__ages[i]['name'],__ages[i]['c']);
    o.selectedIndex=__ages_default1;

    o=document.getElementById('in_age2');
    for (i=0;i<__ages.length;i++) vmv_select_add_option(o,__ages[i]['name'],__ages[i]['c']);
    o.selectedIndex=__ages_default2;

    o=document.getElementById('in_age3');
    for (i=0;i<__ages.length;i++) vmv_select_add_option(o,__ages[i]['name'],__ages[i]['c']);
    o.selectedIndex=__ages_default3;

    o=document.getElementById('in_age4');
    for (i=0;i<__ages.length;i++) vmv_select_add_option(o,__ages[i]['name'],__ages[i]['c']);
    o.selectedIndex=__ages_default4;

    o=document.getElementById('in_age5');
    for (i=0;i<__ages.length;i++) vmv_select_add_option(o,__ages[i]['name'],__ages[i]['c']);
    o.selectedIndex=__ages_default5;

    document.getElementById('in_days').focus();
    calc();
}


function calc()
{
    var i,p;

    var days=document.getElementById('in_days').value;
    if (days.is_int_str())
        days=days.str2int();
    else
    {
        document.getElementById('out_premium').value='';
        return false;
    }

// коэффициент зоны
    var c_zone=(document.getElementById('in_zone').checked)?__zone:1;

// возрастные коэффициенты
    var c_age1=document.getElementById('in_age1').value*1;
    var c_age2=document.getElementById('in_age2').value*1;
    var c_age3=document.getElementById('in_age3').value*1;
    var c_age4=document.getElementById('in_age4').value*1;
    var c_age5=document.getElementById('in_age5').value*1;

    var program=document.getElementById('in_program').value;
    var variant=document.getElementById('in_variant').value;
    var sum=document.getElementById('in_sum').value*1;

    var tariff=0;
    for (i=0;i<__prices.length;i++)
    {
        p=__prices[i];
        if (p.sum==sum && p.program==program && p.variant==variant && days>=p.days_min && (days<=p.days_max || p.days_max==0))
        {
            tariff=p.tariff;
            break;
        }
    }
	var SKIDKA = document.getElementById('inp_variant').value*1;
	var all_tarrif = tariff*c_zone*SKIDKA;
	all_tarrif = all_tarrif.toFixed(2);
    var premium=all_tarrif*days;
	
    premium=premium*c_age1+premium*c_age2+premium*c_age3+premium*c_age4+premium*c_age5;

    //premium*=document.getElementById('inp_variant').value*1;

    if (premium>0)
        document.getElementById('out_premium').value=premium.float2str(2)+' '+document.getElementById('in_currency').value;
    else
        document.getElementById('out_premium').value='';
	
		
	document.getElementById('out_txt_prem').innerHTML = document.getElementById('out_premium').value;
}


function form_keydown()
{
    if (event.keyCode==13)
        if (event.srcElement.tagName.indexOf('TEXTAREA')!=0 && event.srcElement.id.indexOf('button')!=0) event.keyCode=9;
}

//
// Библиотечные функции
//

// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
Number.prototype.roundTo=function()
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var x=0;
    if (arguments.length>0)
        if (typeof(arguments[0])=='number')
            if (arguments[0].is_int())
                if (arguments[0]>=-5 && arguments[0]<=5) x=arguments[0];
    var i=Math.pow(10,x);
    return Math.round(this*i)/i;
    
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.rtrim=function()
// убирает все пробелы в конце строки
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var r=/\s+$/g;
    return this.replace(r,'');
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.ltrim=function()
// убирает все пробелы в начале строки
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var r=/^\s+/g;
    return this.replace(r,'');
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.trim=function()
// убирает все пробелы в начале и в конце строки
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    return this.ltrim().rtrim();
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.mtrim=function()
// убирает все пробелы в начале и в конце строки
// помимо этого заменяет несколько подряд идущих пробелов внутри строки на один пробел 
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var r=/\s\s+/g;
    return this.trim().replace(r,' ');
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.alltrim=function()
// убирает все пробелы в строке s
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var r=/\s+/g;
    return this.replace(r,'');
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.repeat=function(n)
// повторяет строку n раз
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (typeof(n)=='number' && n>0)
    {
        var r='';
        for (var i=1; i<=n; i++) r+=this;
        return r;
    }
    else
        return '';
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.rpad=function(n)
// дополняет строку справа до длины n
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (typeof(n)=='number' && n>0)
    {
        var l=this.length;
        var c=' ';
        if (arguments.length>1)
            if (typeof(arguments[1])=='string')
                if (arguments[1].length>0)
                    c=arguments[1].substr(0,1);
        if (l>n)
            return this.substr(0,n);
        else
            if (l==n)
                return this;
            else
                return this+c.repeat(n-l);
    }
    else
        return '';
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.lpad=function(n)
// дополняет строку слева до длины n
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (typeof(n)=='number' && n>0)
    {
        var l=this.length;
        var c=' ';
        if (arguments.length>1)
            if (typeof(arguments[1])=='string')
                if (arguments[1].length>0)
                    c=arguments[1].substr(0,1);
        if (l>n)
            return this.substr(l-n);
        else
            if (l==n)
                return this;
            else
                return c.repeat(n-l)+this;
    }
    else
        return '';
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_int=function()
// проверяет, является ли строка целым числом
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var r=/^[+\-]?\d+$/;
    return r.test(this);
}
Number.prototype.is_int=function()
{
    return (Math.round(this)==this);
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_int_str=function()
// проверяет, является ли строка форматированным целым числом
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    return this.alltrim().is_int();
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_float=function()
// проверяет, является ли строка дробным числом с разделителем "точка"
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var r=/^([+\-]\d)?\d*(\.\d|\d\.)?\d*$/;
    return r.test(this) && this!='';
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_float_str=function()
// проверяет, является ли строка дробным числом с разделителем "запятая" или "точка" и (возможно) с разделением групп цифр пробелом
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    return this.alltrim().replace(',','.').is_float();
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_float_period_str=function()
// проверяет, является ли строка дробным числом с разделителем "запятая" или "точка" и (возможно) с разделением групп цифр пробелом
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var separator='*';
    var p=this.indexOf(separator);

    if (p==-1)
        return this.is_float_str();
    else
    {
        var x1=this.substr(0,p);
        var x2=this.substr(p+1);
        return ((x1.is_float_str() || x1.length==0) && (x2.is_float_str() || x2.length==0) && (x1.length>0 || x2.length>0));
    }
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_date=function()
// проверяет, является ли строка s датой в формате YYYY-MM-DD
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var r=/^(\d{4})-(\d{2})-(\d{2})$/;
    if (r.test(this))
    {
        var y=RegExp.$1*1; var m=RegExp.$2*1; var d=RegExp.$3*1;
        var test=new Date(y,m-1,d);
        return (test.getFullYear()==y && test.getMonth()==m-1 && test.getDate()==d);
    }
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_date_str=function()
// проверяет, является ли строка s датой в формате DD.MM.YYYY
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var s=this;
    var correct=false;
    if (arguments.length>0) correct=arguments[0];
    if (correct) s=s.correct_date_str();

    var r=/^(\d{2})\.(\d{2})\.(\d{4})$/;
    if (r.test(s))
    {
        var d=RegExp.$1*1; var m=RegExp.$2*1; var y=RegExp.$3*1;
        var test=new Date(y,m-1,d);
        return (test.getFullYear()==y && test.getMonth()==m-1 && test.getDate()==d);
    }
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.is_date_period_str=function()
// проверяет, является ли строка s датой в формате DD.MM.YYYY*DD.MM.YYYY
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var correct=false;
    if (arguments.length>0) correct=arguments[0];

    var separator='*';
    var p=this.indexOf(separator);

    if (p==-1)
        return this.is_date_str(correct);
    else
    {
        var x1=this.substr(0,p);
        var x2=this.substr(p+1);
        return ((x1.is_date_str(correct) || x1.length==0) && (x2.is_date_str(correct) || x2.length==0) && (x1.length>0 || x2.length>0));
    }
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.str2int=function()
// конвертирует строку в целое число
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (this.is_int_str())
        return (this.alltrim())*1;
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
Number.prototype.str2int=function()
{
    return Math.round(this.valueOf);
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.str2float=function()
// конвертирует строку в дробное число
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (this.is_float_str())
        return (this.alltrim().replace(',','.'))*1;
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
Number.prototype.str2float=function()
{
    return this.valueOf;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
Number.prototype.float2str=function()
// конвертирует строку в дробное число
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var d=0;
    if (arguments.length>0)
        if (typeof(arguments[0])=='number')
            if (arguments[0].is_int())
                if (arguments[0]>=-5 && arguments[0]<=5) d=arguments[0];


    var s=this.roundTo(d).toString().replace('.',',');
    if (d>0)
    {
        var n=s.indexOf(',');
        if (n==-1)
            s+=','+'0'.repeat(d);
        else
            s+='0'.repeat(d-(s.length-n-1));
    }
    return s;
}

// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.float2str=function()
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (this.is_float_str())
    {
        var x=(this.alltrim().replace(',','.'))*1;
        if (arguments.length>0)
            return x.float2str(arguments[0]);
        else
            return x.float2str();
    }
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------



// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.date2str=function()
// конвертирует дату из формата YYYY-MM-DD в формат DD.MM.YYYY
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (this.is_date())
        return this.substr(8,2)+'.'+this.substr(5,2)+'.'+this.substr(0,4);
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------



// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.str2date=function()
// конвертирует дату из формата DD.MM.YYYY в формат YYYY-MM-DD
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
//  s=vmv_strings_correct_date_str(s);
    if (this.is_date_str())
        return this.substr(6,4)+'-'+this.substr(3,2)+'-'+this.substr(0,2);
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------




// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.str2dateobj=function()
// конвертирует дату из формата DD.MM.YYYY в объект Date
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
//  s=vmv_strings_correct_date_str(s);
    if (this.is_date_str())
        return new Date(this.substr(6,4)*1,this.substr(3,2)*1-1,this.substr(0,2)*1);
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.date2dateobj=function()
// конвертирует дату из формата YYYY-MM-DD в объект Date
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
//  s=vmv_strings_correct_date_str(s);
    if (this.is_date())
        return new Date(this.substr(0,4)*1,this.substr(5,2)*1-1,this.substr(8,2)*1);
    else
        return false;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
Date.prototype.dateobj2str=function()
// конвертирует дату из объекта Date в строку DD.MM.YYYY
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var y=this.getFullYear();
    var m=this.getMonth()+1;
    var d=this.getDate();
    return ((d<10)?('0'+d):(d))+'.'+((m<10)?('0'+m):(m))+'.'+y;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
Date.prototype.dateobj2date=function()
// конвертирует дату из объекта Date в строку YYYY-MM-DD
// в случае ошибки возвращает false
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var y=this.getFullYear();
    var m=this.getMonth()+1;
    var d=this.getDate();
    return y+'-'+((m<10)?('0'+m):(m))+'-'+((d<10)?('0'+d):(d));
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.correct_int_str=function(d)
// пытается представить строку s в виде целого числа
// если не получилось, возвращает исходную строку
{
    if (this.is_int_str())
        return this.float2str();
    else
        return this;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.correct_float_str=function(d)
// пытается представить строку s в виде дробного числа с кол-вом знаков после запятой d
// если не получилось, возвращает исходную строку
{
    if (this.is_float_str())
        return this.float2str(d);
    else
        return this;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.correct_date_str=function()
// пытается представить строку в виде даты DD.MM.YYYY
// если не получилось, возвращает исходную строку
{
// без разделителей
    var r1=/^(\d{1,2})$/;                   // D(D)
    var r2=/^(\d{2})(\d{1,2})$/;                // DDM(M)
    var r3=/^(\d{2})(\d{2})(\d{2})$/;           // DDMMYY
    var r4=/^(\d{2})(\d{2})(\d{4})$/;           // DDMMYYYY

// с разделителями
    var r11=/^(\d{1,2})[\.\-\/](\d{1,2})$/;         // D(D).M(M)
    var r12=/^(\d{1,2})[\.\-\/](\d{1,2})[\.\-\/](\d{2})$/;  // D(D).M(M).YY
    var r13=/^(\d{1,2})[\.\-\/](\d{1,2})[\.\-\/](\d{4})$/;  // D(D).M(M).YYYY

// если строка не удовлетворяет ни одному из форматов, возвратим саму строку
    if (!r1.test(this)) if (!r2.test(this)) if (!r3.test(this)) if (!r4.test(this)) if (!r11.test(this)) if (!r12.test(this)) if (!r13.test(this)) return this;

    var test=new Date();

    var d=RegExp.$1*1;
    var m=(RegExp.$2=='')?(test.getMonth()+1):(RegExp.$2*1);
    var y=(RegExp.$3=='')?(test.getFullYear()):(RegExp.$3*1);

// добавляем недостающие цифры к году
    if (RegExp.$3.length==2)
    {
        y+=test.getFullYear()-test.getFullYear()%100;
        if (y>test.getFullYear()+20) y-=100;
    }
    
// проверяем получившуюся дату на правильность
    test=new Date(y,m-1,d);
    if (test.getFullYear()==y && test.getMonth()==m-1 && test.getDate()==d)
    {
        return ((d<10)?('0'+d):(d))+'.'+((m<10)?('0'+m):(m))+'.'+y;
    }
    else
        return this;
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.correct_date_period_str=function()
// пытается представить строку в виде даты DD.MM.YYYY*DD.MM.YYYY
// если не получилось, возвращает исходную строку
{
    var separator='*';
    var p=this.indexOf(separator);

    if (p==-1)
        return this.correct_date_str();
    else
    {
        var d1=this.substr(0,p);
        var d2=this.substr(p+1);
        return d1.correct_date_str()+separator+d2.correct_date_str();
    }
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
String.prototype.correct_float_period_str=function(d)
// пытается представить строку в виде X*Y
// если не получилось, возвращает исходную строку
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    var separator='*';
    var p=this.indexOf(separator);

    if (p==-1)
        return this.correct_float_str(d);
    else
    {
        var x1=this.substr(0,p);
        var x2=this.substr(p+1);
        return x1.correct_float_str(d)+separator+x2.correct_float_str(d);
    }
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------




// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
function vmv_correct_int_str(o)
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (o)
    {
        o.value=o.value.correct_int_str();
        return true;
    }
    else
        return false;

}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
function vmv_correct_float_str(o,d)
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
{
    if (o)
    {
        o.value=o.value.correct_float_str(d);
        return true;
    }
    else
        return false;

}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
function vmv_correct_date_str(o)
{
    if (o)
    {
        o.value=o.value.correct_date_str();
        return true;
    }
    else
        return false;

}


// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
function vmv_get_date_period_str_delta(d1,d2,p)
{
    if (typeof(d1)!='string' || typeof(d2)!='string' || typeof(p)!='string') return false;
    if (!d1.is_date_str() || !d2.is_date_str()) return false;

    p=p.toUpperCase();
    if (p!='D' && p!='Y') return false;

    var dt1=d1.str2dateobj();
    var dt2=d2.str2dateobj();

    var r;

    if (p=='D')
        r=Math.round((dt2-dt1)/1000/60/60/24)+1;
    else
        if (p=='Y')
        {
            r=dt2.getFullYear()-dt1.getFullYear();
            if (dt1.getMonth()>dt2.getMonth() || dt1.getMonth()==dt2.getMonth() && dt1.getDate()>dt2.getDate()) r--;
        }
    return r;
}


function vmv_select_add_option(o,t,v)
{
    if (o.options)
    {
        var oOption=document.createElement("OPTION");
        oOption.text=t;
        oOption.value=v;
        o.options.add(oOption);
    }
}