var Excim;


Excim = new ExcimBase();

// ========================================================================== //
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

function ExcimBase (cnv, wnd)
{                                            
    this.m_SelectedElement = null;        

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Tämä metodi hakee ja palauttaa elementin sen ID:n mukaisesti. 
/// @return: Osoitin haettuun elementtiin.
/// @par Major changes: 
/// @par                             
/// 28.02.2008 (Kari)<br> 
/// - i: Metodi toteutettu.
////////////////////////////////////////////////////////////////////////////////
this.GetElement = function (
    strID    //! Komponentin nimi
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    return this.m_SelectedElement;
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Tämä metodi hakee ja palauttaa elementin sen ID:n mukaisesti. 
/// @return: Osoitin haettuun elementtiin.
/// @par Major changes: 
/// @par                             
/// 28.02.2008 (Kari)<br> 
/// - i: Commented.       
////////////////////////////////////////////////////////////////////////////////
this.SetText = function (
    strID,    //! Komponentin nimi
    strText    //! Teksti
)
{

    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.value = strText;        
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Tämä metodi disabloi elementin. 
/// @return: -
/// @par Major changes: 
/// @par                             
/// 25.06.2008 (Mikko)<br> 
/// - i: Toteutus aloitettu.       
////////////////////////////////////////////////////////////////////////////////
this.DisableElement = function (
    strID
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.disabled = true;        
    }
}
 
//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Tämä metodi enabloi elementin. 
/// @return: -
/// @par Major changes: 
/// @par                             
/// 25.06.2008 (Mikko)<br> 
/// - i: Toteutus aloitettu.       
////////////////////////////////////////////////////////////////////////////////
this.EnableElement = function (
    strID
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.disabled = false;        
    }
}    

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Tämä metodi hakee ja palauttaa elementin sen ID:n mukaisesti. 
/// @return: Osoitin haettuun elementtiin.
/// @par Major changes: 
/// @par                             
/// 28.02.2008 (Kari)<br> 
/// - i: Commented.       
////////////////////////////////////////////////////////////////////////////////
this.SetBGColor = function (
    strID,    //! Komponentin nimi
    Color     //! Väri
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.bgColor = Color;
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Aseta elementin innerHTML.
/// @return: -
/// @par Major changes: 
/// @par                             
/// 03.03.2008 (Kari)<br> 
/// - i: Commented.       
////////////////////////////////////////////////////////////////////////////////
this.SetInnerHTML = function (
    strID,    //! Komponentin nimi
    strHTML   //! Teksti
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.innerHTML = strHTML;        
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Lisää halutun pätkän elementi innerHTML:n perään.
/// @return: -
/// @par Major changes: 
/// @par                             
/// 19.06.2008 (Mikko)<br> 
/// - i: Toteutus aloitettu.       
////////////////////////////////////////////////////////////////////////////////
this.AddToInnerHTML = function (
    strID,    //! Komponentin nimi
    strHTML   //! Teksti
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.innerHTML += strHTML;        
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Metodi asettaa yksittäiselle komponentille halutut tapahtumien käsittelyt.
/// @return: -
/// @par Major changes: 
/// @par                             
/// 28.02.2008 (Kari)<br> 
/// - i: Toteutus aloitettu, onmouseover vasta toteutettu.      
////////////////////////////////////////////////////////////////////////////////
this.SetEvent = function (
    strID,        //! Komponentin nimi
    strEvent,    //! Eventin nimi
    strFunction    //! Funktion nimi
)
{
    this.m_SelectedElement = document.getElementById(strID);
    
    if (null != this.m_SelectedElement)
    {
        switch (strEvent)
        {
            case "onmouseover":
            {
                this.m_SelectedElement.onmouseover = strFunction;                
                break;
            }
            
            case "onmousedown":
            {
                this.m_SelectedElement.onmousedown = strFunction;                
                break;
            }            
            
            case "onchange":
            {
                this.m_SelectedElement.onchange = strFunction;                
                break;
            }            
        }
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Näytä komponentti, aseta visibility arvoon visible.
/// @return: Osoitin haettuun elementtiin.
/// @par Major changes: 
/// @par                             
/// 03.03.2008 (Kari)<br> 
/// - i: Toteutus aloitettu.       
////////////////////////////////////////////////////////////////////////////////
this.Show = function (
    strID    //! Komponentin nimi
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.style.visibility = "visible";
        this.m_SelectedElement.style.display = "block";
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Piilota komponentti, aseta visibility arvoon hidden.
/// @return: Osoitin haettuun elementtiin.
/// @par Major changes: 
/// @par                             
/// 03.03.2008 (Kari)<br> 
/// - i: Toteutus aloitettu.       
////////////////////////////////////////////////////////////////////////////////
this.Hide = function (
    strID    //! Komponentin nimi
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.style.visibility = "hidden";
        this.m_SelectedElement.style.display = "none";
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Palauta elementin value
/// @return: -
/// @par Major changes: 
/// @par                             
/// 06.03.2008 (Kari)<br> 
/// - i: Toteutus on aloitettu
////////////////////////////////////////////////////////////////////////////////
this.GetValue = function (
    strID   //! Komponentin nimi
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        //var strValue = unescape( encodeURIComponent(this.m_SelectedElement.value) );
        // Asetetaan arvo
        return this.m_SelectedElement.value;        
    }
    
    return "";
}                     

this.SetValue = function (
    strID,      //! Komponentin nimi
    strValue    //! Arvo
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        // Asetetaan arvo
        this.m_SelectedElement.value = strValue;
    }
}  

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Palauta alasvetovalikon valinta. 
/// @return: Value: teksti, Index: valitun indeksin.
/// @par Major changes: 
/// @par                             
/// 11.03.2008 (Kari)<br> 
/// - i: Kommentoitu
/// 26.03.2008 (Kari)<br> 
/// - m: Muutettu niin että palauttaa kaksi arvoa; Valuen ja Indexin.
////////////////////////////////////////////////////////////////////////////////
this.GetDropDownValue = function (
    strID   //! Komponentin nimi
)
{
    // Haetaan elementti, talletetaan samalla se valituksi elementiksi luokkaan.
    this.m_SelectedElement = document.getElementById(strID);
    
    // Jos elementti löytyi, mennään haaraan
    if (null != this.m_SelectedElement)
    {
        iSelectedItem = this.m_SelectedElement.selectedIndex;
        strValue = this.m_SelectedElement [iSelectedItem].value;
        return {Value:strValue, Index:iSelectedItem};
    }
    
    return {Value:-1, Index:-1};
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Hakee komponentin, johon elementti kuuluu. 
/// @return: Osoittimen formiin. Jos taulua ei löydy, null.
/// @par Major changes: 
/// @par                             
/// 10.03.2008 (Kari)<br> 
/// - i: Toteutus aloitettu.
////////////////////////////////////////////////////////////////////////////////
this.GetParent = function (
    SelectedItem,   //! Valittu elementti
    strType         //! Esimerkiksi FORM
    
)
{
    // Hae parentti
    Parent = SelectedItem.parentNode;    
    
    if (null == Parent)
        return null;
    
    // Looppaa niin pitkään, että FORM niminen parent löytyy
    while (Parent.tagName != strType)
    {
        Parent = Parent.parentNode;    
        
        // Jos parenttia ei enää ole, palauta null
        if (Parent == null)
            return "";
    }
    
    return Parent;    
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Valitsee taulusta kokonaisen rivin. Rivin tieto talletetaan taulun
/// attribuutteihin niin, että valittu rivi osataan näyttää näytöllä eri värillä
/// vaikka väriä päivitettäisiin myös hiiren mukaan.
/// @return: -
/// @par Major changes: 
/// @par                             
/// 10.03.2008 (Kari)<br> 
/// - i: Toteutus aloitettu.
/// 03.06.2008 (Mikko)<br>     
/// - a: Päivitetty toimimaan listview uusien funktioiden kanssa
////////////////////////////////////////////////////////////////////////////////
this.SelectTableRow = function (
    SelectedRow //! Valittu rivi
)
{                          
    // Haetaan taulu, johon rivi kuuluu
    Table = this.GetParent (SelectedRow, "TABLE");
    
    // Mikäli taulua ei löydy, palataan välittömästi.
    if (Table == null)
        return;
     
    //! Haetaan div, johon taulu kuuluu,
    Div = this.GetParent (Table, "DIV");           
    
    // Mikäli diviä ei löydy, palataan välittömästi.
    if (Div == null)
        return;
    
    // Talletetaan valittu rivi attribuutteihin
    Table.SelectedRow = SelectedRow;
    
    
    for(j = 0; j < Div.children.length; j++)    
    {               
        // Haetaan taulut rivit
        Rows = Div.children[j].rows;
        
        if(Rows != null)
        {        
            // Loopataan kaikki rivit läpi. Mikäli onclick metodi on 
            // määritetty (eli rivi on valittavissa), asetetaan väriksi valkoinen.
            // Tarkoituksena on siis nollata tilanne ennen valitun rivin merkitsemistä.
            for (i = 0; i < Rows.length; i++)
            {
                if (null != Rows [i].onclick && Table.SelectedRow != Rows [i])
                {
                    this.SetTableRowColor (Rows [i], '#FFFFFF');
                }
            }
        }
    }
     
    // Asetetaan nyt valittu rivi eri väriseksi.
    //Table.SelectedRow.bgColor = '#FF0000';
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Aseta yksittäisen taulun rivin väri. 
/// @return: -
/// @par Major changes: 
/// @par                             
/// 10.03.2008 (Kari)<br> 
/// - i: Toteutus aloitettu.
////////////////////////////////////////////////////////////////////////////////
this.SetTableRowColor = function (
    SelectedRow,    //! Rivi jonka väri halutaan muuttaa
    Color           //! Väri               
)
{
    SelectedRow.bgColor = Color;
    
    Table = this.GetParent (SelectedRow, "TABLE");
    
    if (Table != null)
    {
        if (Table.SelectedRow != null)
        {
            Table.SelectedRow.bgColor = '#FF0000';
        }
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Aseta yksittäisen taulun rivin väri. 
/// @return: -
/// @par Major changes: 
/// @par                             
/// 10.03.2008 (Kari)<br> 
/// - i: Toteutus aloitettu.
////////////////////////////////////////////////////////////////////////////////
this.SetTableRowClass = function (
    SelectedRow,    //! Rivi jonka väri halutaan muuttaa 
    Class  
)
{    
    SelectedRow.firstChild.className = Class;
    
    Table = this.GetParent (SelectedRow, "TABLE");
    
    if (Table != null)
    {
        if (Table.SelectedRow != null)
        {                                                             
            Table.SelectedRow.firstChild.className = "list_row";
        }
    }
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Lähetä formi, lisää formille dynaamisesti oma muuttuja ja aseta sille 
/// haluttu arvo. 
///
/// Esimerkki käytöstä: lisää "TASK_DELETE" formille
/// $g_Table->AddText ("<input type='button' value='Poista valitut' onclick='MSTA.MSTASubmit (this, \"TASK_DELETE\", \"TASK_DELETE\"); return false;'><br/>"); 
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 25.03.2008 (Kari)<br> 
/// - i: Ensimmäinen toteutus valmis
////////////////////////////////////////////////////////////////////////////////
this.ExcimSubmit = function (
    Caller,
    strID,
    strValue
)
{
    // Haetaan formi johon kutsuva komponentti kuuluu
    Form = this.GetParent (Caller, "FORM");
    // Haetaan elementti jonka arvoa halutaan muuttaa
    SubmitObject = this.GetElement (strID);
    // Jos sitä ei vielä ole olemassa, niin luodaan
    if ((null != Form) && (null == SubmitObject))
    {
        // Microsoft menee tämän haaran kautta, ei mozilla
        try 
        {
            str = "<input name='" + strID + "' value='" + strValue + "' type='hidden'>";
            SubmitObject = document.createElement (str);      
        }
        
        // Mozilla taas toimii tätä kautta.
        catch (e)
        {
            SubmitObject = document.createElement("input");
            SubmitObject.setAttribute("name", strID);
            SubmitObject.setAttribute("type", "hidden");
            SubmitObject.setAttribute("value", strValue);
        }
        
        Form.appendChild (SubmitObject);
    }
    
    SubmitObject.value = strValue;        
    Form.submit ();    
}

this.CreateHidden = function (
    strName,
    strValue
)
{
    // Microsoft menee tämän haaran kautta, ei mozilla
    try 
    {
        str = "<input name='" + strName + "' value='" + strValue + "' type='hidden'>";
        SubmitObject = document.createElement (str);      
    }
    
    // Mozilla taas toimii tätä kautta.
    catch (e)
    {
        SubmitObject = document.createElement("input");
        SubmitObject.setAttribute("name", strName);
        SubmitObject.setAttribute("type", "hidden");
        SubmitObject.setAttribute("value", strValue);
    }    
}    

this.MaximizeWidthInCell = function (
    strID
)
{
    CurrentObject = this.GetElement (strID);
    
    if (null == CurrentObject)
        return;
    
    // Hae solu johon kuuluu
    ParentCell = this.GetParent (CurrentObject, "TD");
    
    if (null !=  ParentCell)
    {
        CurrentObject.style.width  = ParentCell.offsetWidth;
    }
}

this.ResizeListView = function (
    strID
)
{
    strID_hdr = strID+"_hdr";
    strID_rows = strID+"_rows";
    
    TableHdr = this.GetElement (strID_hdr);
    TableRows = this.GetElement (strID_rows);
    
    if ((null != TableHdr) && (null != TableRows))
    {
        iCount = 0;
        bLoop = true;
        
        while (bLoop)
        {
            iCount++;
            
            if (iCount == 100)
                bLoop = false;
    
            TableHdr.style.width = TableRows.offsetWidth;
            
            if (TableHdr.offsetWidth == TableRows.offsetWidth)
                bLoop = false;
        }
    }
}

this.SetListViewMaxHeight = function (
    strID,
    iHeight
)
{
    strID_rows = strID+"_rows_div";
    TableRows = this.GetElement (strID_rows);
    
    if (null != TableRows)
    {
        if (TableRows.offsetHeight > iHeight)
            TableRows.style.height = iHeight;
    }
}

this.ToggleGroupBoxVisibility = function (
    grp,
    strID
)
{
    Object = this.GetElement (strID);
    
    if (null == Object)
        return;
        
    if (Object.style.visibility == "visible")
    {
        Object.style.visibility = "hidden";
        Object.style.display = "none";
        grp.innerText = "+";
    }
    
    else
    {
        Object.style.visibility = "visible";
        Object.style.display = "block";
        grp.innerText = "-";
    }
}


this.GetCheckbox = function (
    strID
)
{
    //Object = this.GetElement (strID); 
    this.m_SelectedElement = document.getElementById(strID)        
     
    if (null == this.m_SelectedElement)
        return false;
         
    return this.m_SelectedElement.checked;
}

this.SetCheckbox = function (
    strID,
    bChecked
)
{
    //Object = this.GetElement (strID); 
    this.m_SelectedElement = document.getElementById(strID)        
     
    if (null == this.m_SelectedElement)
        return false;
         
    this.m_SelectedElement.checked = bChecked;
}

this.TabControlChangeTab = function (
    strID,        
    strTabChosenPicture,
    strTabPicture,
    Caller
)
{               
    Parent = Caller.parentNode;          
    
    for(var i=0; i < Parent.childNodes.length; i++)
    {   
        Child = Parent.childNodes[i];
        if(Child.tagName == "TD")
        {                      
            if(Child.id == strID)
            {
            
                //! Näytetään valittu välilehti
                var strTargetID = Child.id + "_BODY";
                this.Show(strTargetID);
                
                //! Muutetaan linkki "valittu" -ulkoasuun
                Child.style.backgroundImage = "url(" + strTabChosenPicture + ")";
                
                //! Muutetaan hiiren kursori normaaliksi tämän tabin päällä
                Child.style.cursor = "";             
            }
            else if(Child.id != "")
            {
                //! Piilotetaan valitsemattomat välilehdet
                var strTargetID = Child.id + "_BODY";
                this.Hide(strTargetID);
                
                //! Muutetaan nämä linkit "ei valittu" -ulkoasuun
                Child.style.backgroundImage = "url(" + strTabPicture + ")";     
                
                //! Muutetaan kursorit "linkki" -tyyppiseksi näiden tabien päällä ollessa
                Child.style.cursor = "Pointer";                              
            }                                                                
        }
    }
}

this.GetWindowSize = function (
)
{
    var x,y;
    
    if (self.innerHeight) // all except Explorer
    {
        x = self.innerWidth;
        y = self.innerHeight;
    }
    else if (document.documentElement && document.documentElement.clientHeight)
    // Explorer 6 Strict Mode
    {
        x = document.documentElement.clientWidth;
        y = document.documentElement.clientHeight;
    }
    else if (document.body) // other Explorers
    {
        x = document.body.clientWidth;
        y = document.body.clientHeight;
    }
    
    retVal = new Array ();
    retVal ["x"]= x;
    retVal ["y"] = y;
    
    return retVal;
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Näytä modaali-ikkuna. Ikkunan sisältö annetaan parametrina, eli se voi olla
/// esimerkiksi kyselykaavake.
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 16.04.2008 (Kari)<br> 
/// - i: Metodi luotu
////////////////////////////////////////////////////////////////////////////////
this.ShowModal = function (
    strContent     //! Näytettävä sisältö HTML-muotoisena    
)
{

// ------------------------------------------------------------------------- //
// Haetaan ensin ikkunan koko.                                               //
// ------------------------------------------------------------------------- //

    aWindowSize = this.GetWindowSize ();
    iWindowWidth = aWindowSize ["x"];
    iWindowHeight = aWindowSize ["y"];    
    
// ------------------------------------------------------------------------- //
// Peitetään tausta, laitetaan hieman läpäisyä muttei liikaa..               //
// ------------------------------------------------------------------------- //

    divModalBackground = this.GetElement ("EXCIM_MODAL_DIV_BACKGROUND");
    
    if (null == divModalBackground)
    {
        divModalBackground = document.createElement ('div');
        divModalBackground.id = "EXCIM_MODAL_DIV_BACKGROUND";
        document.body.appendChild (divModalBackground);    
    }                            
    
    divModalBackground.style.width = iWindowWidth;
    divModalBackground.style.height = iWindowHeight;    
    divModalBackground.style.zIndex = 2;    
    divModalBackground.style.position = "absolute";
    divModalBackground.style.left = 0;
    divModalBackground.style.top = 0;
    divModalBackground.style.backgroundColor = 0x202020;
    divModalBackground.style.visibility = "visible";
    divModalBackground.style.display = "block";
    
    divModalBackground.style.filter = "alpha(opacity=80)";
    divModalBackground.style.opacity = "0.8";
    divModalBackground.style.MozOpacity = "0.8";

// ------------------------------------------------------------------------- //
// Peitetään tausta, laitetaan hieman läpäisyä muttei liikaa..               //
// ------------------------------------------------------------------------- //

    divModalForeground = this.GetElement ("EXCIM_MODAL_DIV_FOREGROUND");
    
    if (null == divModalForeground)
    {
        divModalForeground = document.createElement ('div');
        divModalForeground.id = "EXCIM_MODAL_DIV_FOREGROUND";
        document.body.appendChild (divModalForeground);
    }
    
    divModalForeground.style.zIndex = 3;
    divModalForeground.style.position = "absolute";
    divModalForeground.style.left = 100;
    divModalForeground.style.top = 100;
    divModalForeground.style.backgroundColor = 0xffffff;
    divModalForeground.style.visibility = "visible";
    divModalForeground.style.display = "block";
    divModalForeground.innerHTML = strContent;

    divModalForeground.style.filter = "alpha(opacity=100)";
    divModalForeground.style.opacity = "1.0";
    divModalForeground.style.MozOpacity = "1.0";
            
// ------------------------------------------------------------------------- //
// Asetetaan vielä modaali-ikkunan koko oikeaksi, ilman kummempia kikkailuja.//
// ------------------------------------------------------------------------- //

    divModalForeground.style.left = (iWindowWidth - divModalForeground.offsetWidth) / 2;
    divModalForeground.style.top = 100;
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Piilota modaali-ikkuna. 
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 16.04.2008 (Kari)<br> 
/// - i: Metodi luotu
/// 22.05.2008 (Kari)<br> 
/// - a: Jos järjestelmää ollaan vielä lataamassa, ei välitetä pyynnöstä.
////////////////////////////////////////////////////////////////////////////////
this.HideModal = function (
    strContent  //! Näytettävä sisältö HTML-muotoisena
)
{
    this.Hide ("EXCIM_MODAL_DIV_BACKGROUND");    
    this.Hide ("EXCIM_MODAL_DIV_FOREGROUND");    
}

this.SelectedRadioValue = function (
    FormName,
    strGroupboxName
) 
{
    Form = this.GetElement (FormName);
    
    for (iChild = 0; iChild < Form.all.length; iChild++)
    {
        child = Form.all [iChild];
        
        if (child.type == "radio")
        {
            if ((child.name == strGroupboxName) && (child.checked == true))
                return child.value;
        }
    }
}
  
this.PopupWin = function (
    strUrl,
    strParameters
)
{        
    window.open(strUrl, "", strParameters);
}

this.stopProp = function () 
{        
    //! MIKKO. EI TOIMI FIREFOXILLA
    var evt = window.event;
    if (evt.stopPropagation)
        evt.stopPropagation();
    evt.cancelBubble = true;
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Tämä metodi initialisoi kalenterikomponentin. Tätä tarvitaan erityisesti
/// silloin, kun kalenteria käytetään ajaxilla luoduissa kontrolleissa.
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 02.05.2008 (Kari)<br> 
/// - i: Metodi luotu.
////////////////////////////////////////////////////////////////////////////////
this.OnCalendar = function (
    strInput,
    strTrigger,
    iTime,
    control
)
{
    Component = this.GetElement (strInput);
    
    if (null == Component)
        return;

    // Katsotaan onko time-attribuutti määritelty. Jos on ja  arvo on 1,
    // asetetaan kontrolliin näkyville myös aika
    //iTime = control.getAttribute("time");
    
    if ("1" == iTime)
    {
        Calendar.setup({
            inputField     :    strInput,   // id of the input field
            ifFormat       :    "%Y-%m-%d %H:%M",
            showsTime      :    true,
            timeFormat     :    "24",
            button         :    strTrigger, // trigger for the calendar (button ID)
            align          :    "Tl",       // alignment (defaults to "Bl")
            singleClick    :    true
        });       
    }
    
    else
    {
        Calendar.setup({
            inputField     :    strInput,   // id of the input field
            ifFormat       :    "%Y-%m-%d", // format of the input field
            button         :    strTrigger, // trigger for the calendar (button ID)
            align          :    "Tl",       // alignment (defaults to "Bl")
            singleClick    :    true
        });       
    }
    
    control.onmouseover=""; // this.style.background='red';" 
    control.onmouseout=""; // this.style.background='white';"    
    
    // control.style.background = "red";
    
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// StringReplace, joka toimii. JavaScriptin oma replace ei tunnu toimivan
/// oikealla tavalla.
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 16.05.2008 (Kari)<br> 
/// - i: Kopioitu Mikon viestistä bulletinboardilta.
////////////////////////////////////////////////////////////////////////////////
this.StringReplace = function (haystack, needle, replacement) 
{
    var temp = haystack.split(needle);
    return temp.join(replacement);
}
          
//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Regular expressionia tukeva StringReplace, joka toimii. 
/// JavaScriptin oma replace ei tunnu toimivan oikealla tavalla.
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 16.05.2008 (Kari)<br> 
/// - i: Kopioitu Mikon viestistä bulletinboardilta.
////////////////////////////////////////////////////////////////////////////////
this.StringReplaceReg = function(haystack, needle, replacement) 
{
    var r = new RegExp(needle, 'g');
    return haystack.replace(r, replacement);
} 

          
//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Sajax-luokkaa varten kirjoitettu apumetodi. Perustoteutuksella skandien ja 
/// '+'-merkin välittämisessä oli ongelmia. Sen takia toteutettiin erillinen
/// metodi, joka tekee perus escapen lisäksi vielä '+'-merkin ja muutaman muun
/// erikoismerkin koodaamisen.
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 30.08.2008 (Kari)<br> 
/// - i: Metodi toteutettu.
////////////////////////////////////////////////////////////////////////////////
this.Escape = function (
    str
)
{
    // Kutsutaan javascriptin escapea. Tämä ei kuitenkaan muuta mm. + merkkiä, joka
    // tulkitaan palvelimen päässä välilyönniksi.
    
    str = escape (str);
    str = this.StringReplace (str, "+", "%2B");
    str = this.StringReplace (str, "å", "%86");
    str = this.StringReplace (str, "Å", "%8F");
    
    return str;
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Poista HTML-objekti.
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 05.08.2008 (Kari)<br> 
/// - i: Metodi luotu.
////////////////////////////////////////////////////////////////////////////////
this.DeleteElement = function(
    Obj
)
{
    Parent = Obj.parentElement;
    Parent.removeChild (Obj);
} 

this.DeleteElementByName = function(
    strID
)
{
    Obj = this.GetElement (strID);
    this.DeleteElement (Obj);
} 

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Rakenna formista kaksi taulua, jotka sisältävät input-kenttien nimet ja 
/// arvot. Molemmat sijoitetaan tauluihin base64-koodattuina, ja ne täytyy
/// purkaa vastaanottopäässä.
///
/// @return: Taulu, jossa on nimet ja arvot base64-koodattuina.
/// @par Major changes: 
/// @par                             
/// 18.08.2008 (Kari)<br> 
/// - i: Metodi luotu.
/// 19.08.2008 (Kari)<br> 
/// - m: Metodin nimi muutettu
/// 20.08.2008 (Kari)<br> 
/// - f: Tyhjien kenttien käsittelyä korjattu, ei toiminut aikaisemmin.
/// 25.08.2008 (Kari)<br> 
/// - a: Jos formia ei löydy, palautetaan tyhjä kenttä.
////////////////////////////////////////////////////////////////////////////////
this.GetFormParameters = function(
    strFormName     //! Formin nimi, jota ollaan lähettämässä
)
{
    var aName = new Array ();
    var aValue = new Array ();

    pform = document.forms [strFormName];
    
    if (null == pform)
        return {Names:aName, Values:aValue};
    
    iElements = 0;
    
    for(i=0; i< pform.elements.length; i++)
    {
        e = pform.elements [i];
        
        strName = e.name+"";

        if (e.type=="checkbox")
        {
            if (e.checked == true)
                strValue = "checked";
            else
                strValue = "";
        }
        
        else
        {        
            strValue = e.value+"";
        }
        
        if (strName != "")
            aName [iElements] = base64_encode (strName);
        else
            aName [iElements] = "";
            
        if (strValue != "")
            aValue [iElements++] = base64_encode (strValue);
        else
            aValue [iElements++] = "";            
    }    
    
    return {Names:aName, Values:aValue};     
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Palauta tyhjä parametrilista. Listan muoto on sama kuin formiparametreille.
///
/// @return: Tyhjä taulu. Tähän voi lisätä arvoja AddParameter-metodilla.
/// @par Major changes: 
/// @par                             
/// 18.08.2008 (Kari)<br> 
/// - i: Metodi luotu.
////////////////////////////////////////////////////////////////////////////////
this.ClearParameters = function()
{
    var aName = new Array ();
    var aValue = new Array ();

    return {Names:aName, Values:aValue};     
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Lisää parametri parametrilistaan.
///
/// @return: Array, johon on lisätty haluttu parametri.
/// @par Major changes: 
/// @par                             
/// 18.08.2008 (Kari)<br> 
/// - i: Metodi luotu.
////////////////////////////////////////////////////////////////////////////////
this.AddParameter = function (
    aArray,
    strName,
    strValue
)
{
    strName+="";
    strValue+="";
    
    aArray.Names.push (base64_encode (strName));
    aArray.Values.push (base64_encode (strValue));

    return aArray;
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Rakenna formista kaksi taulua, jotka sisältävät input-kenttien nimet ja 
/// arvot. Molemmat sijoitetaan tauluihin base64-koodattuina, ja ne täytyy
/// purkaa vastaanottopäässä.
///
/// @return: Taulu, jossa on nimet ja arvot base64-koodattuina.
/// @par Major changes: 
/// @par                             
/// 18.08.2008 (Kari)<br> 
/// - i: Metodi luotu.
/// 19.08.2008 (Kari)<br> 
/// - m: Metodin nimi muutettu
/// 20.08.2008 (Kari)<br> 
/// - f: Tyhjien kenttien käsittelyä korjattu, ei toiminut aikaisemmin.
/// 25.08.2008 (Kari)<br> 
/// - a: Jos formia ei löydy, palautetaan tyhjä kenttä.
////////////////////////////////////////////////////////////////////////////////
this.AddFormParameters = function(
    aArray,
    strFormName     //! Formin nimi, jota ollaan lähettämässä
)
{
    pform = document.forms [strFormName];
    
    if (null == pform)
        return aArray;
    
    iElements = 0;
    
    for(i=0; i< pform.elements.length; i++)
    {
        e = pform.elements [i];
        
        strName = e.name+"";

        if (e.type=="checkbox")
        {
            if (e.checked == true)
                strValue = "checked";
            else
                strValue = "";
        }
        
        else
        {        
            strValue = e.value+"";
        }
        
        if (strName != "")
            aArray.Names.push (base64_encode (strName));
        else
            aArray.Names.push ("");
            
        if (strValue != "")
            aArray.Values.push (base64_encode (strValue));
        else
            aArray.Values.push ("");
    }    
    
    return aArray;     
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Lisätään dynaaminen hidden input DynamicParams-diviin.
///
/// @return: -
/// @par Major changes: 
/// @par                             
/// 07.08.2009 (Kari)<br> 
/// - a: Metodi luotu.
/// 12.08.2009 (Kari)<br> 
/// - m: Muokattu niin, että toimii usealle formille. Formin nimi täytyy antaa
///      parametrina.
//////////////////////////////////////////////////////////////////////////////// 
this.SetParameter = function (
    //! Formin nimi
    strFormName,
    //! Kentän mimi
    strName,
    //! Arvo
    strValue
)
{
    try
    {    
        // Nimetään jQueryä varten
        strJName = "#"+strFormName+" #DynamicParams #"+strName;
        // Haetaan vastaava objekti
        object = $(strJName);
        
        // Onko pituus nolla? Jos on, tällä nimellä ei ole vielä elementtiä .. luodaan siis.
        if (0 == object.length)
        {
            str = "<input type='hidden' name='"+strName+"' id='"+strName+"' value='"+strValue+"'/>";
            strName = "#"+strFormName;

            // On siis muotoa #formin_nimi #DynamicParams
            $(strName).find("#DynamicParams").append (str);
        }
        
        // Elementti on jo olemassa, asetetaan nyt vain arvo.
        else
        {
            object.val (strValue);
        }
    }
    
    catch(err)
    {
        txt="Virhe! (Excim.SetParameter)\n\n";
        txt+="Kuvaus: " + err.description + "\n\n";
        txt+="Click OK to continue.\n\n";
        alert(txt);
    }    
}

//////////////////////////////////////////////////////////////////////////////// 
/// @brief
/// Tarkastetaan formin yksittäisen kentän sisältö. Ehdot ovat:
///
/// EMPTY - tarkastaa, että kenttä ei ole tyhjä
/// EMAIL - tarkastaa, että vastaa muodoltaan sähköpostiosoitetta
/// NUMERIC - tarkastaa, että sisältää vain numeron
/// LENGTH>xxx - tarkastaa, että sisällön pituus on yli xxx
///
/// todo: LENGTH<xxx - tarkastaa, että sisällön pituus on alle xxx.
///
/// @return: Integer value:
///          -3 formia ei löydy
///          -2 komponenttia ei löydy
///          -1 ehtoa ei läpäisty
///           0 OK
///        
/// @date: 01.09.2009 (Kari)<br> 
/// - a: Metodin toteutus on aloitettu.
//////////////////////////////////////////////////////////////////////////////// 
this.ValidateForm = function (
    //! Formin nimi
    strFormName,
    //! Kentän mimi
    strName,
    //! Ehto
    strRule
)
{
    // Haetaan formi
    pform = document.forms [strFormName];
    
    // Jos formia ei löydy, palautetaan -2
    if (null == pform)
        return -3;

    e = pform.elements [strName];
    
    if (null == e)
        return -2;

    if (e.type=="checkbox")
    {
        if (e.checked == true)
            strValue = "checked";
        else
            strValue = "";
    }
    
    else
    {        
        strValue = e.value+"";
    }
    
// ------------------------------------------------------------------------- //
// Mikäli kyseessä on yksittäinen sääntökenttä, mennään tänne haaraan.       //    
// ------------------------------------------------------------------------- //    

    switch (strRule)
    {
        case "EMPTY":
        {
            if (0 == strValue.length)
            {
                return -1;
            }
            
            return 0;
        }
        
        case "EMAIL":
        {
            reg = /^([A-Za-z0-9_\-\.])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,4})$/;
            
            if(reg.test(strValue) == false) 
            {
                return -1;
            }
            
            return 0;
        }
        
        case "NUMERIC":
        {
            if (true == isNaN(strValue))
                return -1;
                
            return 0;
        }
    }

    
// ------------------------------------------------------------------------- //
// Mikäli kyseessä on suurempi kuin ehto, mennään tänne haaraan.             //
// ------------------------------------------------------------------------- //    
    
    strs =strRule.split(">");
    
    if (2 == strs.length)
    {
        // Ehto on muotoa LENGTH>10
        if (strs [0] == "LENGTH")
        {
            iMinLength = parseInt (strs [1]);
            
            if (strValue.length < iMinLength)
                return -1;
            
            return 0;
        }
    }

    // Palautetaan ok    
    return 0;
}


} /// Luokka päättyy tähän