// Dichiarazione variabili per la gestione dello spostamento degli Splitter
var SplitterMoveStarted = false;        // Indica se è in corso l'operazione di spostamento
var SplitterMoveHandle = "";            // Handle dello Splitter per cui è in corso l'operazione di spostamento
var SplitterMoveDockStyle = "";         // Stile di Dock dello Splitter per cui è in corso l'operazione di spostamento
var SplitterMovePositionBefore = 0;     // Posizione minima, prima dello Splitter, in cui è possibile spostare lo Splitter
var SplitterMovePositionAfter = 0;      // Posizione massima, dopo lo splitter, in cui è possibile spostare lo Splitter
var SplitterMoveMover = null;           // Elemento HTML di gestione dello spostamento
var SplitterMoveOffsetX = 0;            // Offset X della posizione del mouse rispetto alla pagina
var SplitterMoveOffsetY = 0;            // Offset Y della posizione del mouse rispetto alla pagina
var SplitterMoveTop = 0;                // Posizione Top iniziale della splitter rispetto al suo container
var SplitterMoveLeft = 0;               // Posizione Left iniziale della splitter rispetto al suo container

var DragPreStarted = false;             // Indica se è in corso l'operazione di PreDrag
var DragStarted = false;                // Indica se è in corso l'operazione di Drag
var DragAutoStart = false;              // Indica se l'operazione di Drag deve essere avviata automaticamente senza inviare al servizio il comando di OnDragStart 
                                        //       (cio' può avvenire se l'operazione di drag è avviata manualmente con una chiamata alla funzione Control_DragInitialize)
var DragAutoStartDropRectangles = ""    // Rettangoli di drop da utilizzare in caso di drag avviato automaticamente
var DragPreDragHandle = "";             // Handle del Control per cui è in corso l'operazione di PreDrag
var DragHandle = "";                    // Handle del Control per cui è in corso l'operazione di Drag
var DragClientX = 0;                    // Coordinate X durante l'operazione di PreDrag
var DragClientY = 0;                    // Coordinate Y durante l'operazione di PreDrag
var DragOffsetX = 0;                    // Offset X durante l'operazione di Drag
var DragOffsetY = 0;                    // Offset Y durante l'operazione di Drag
var DragDelta = 3;                      // Delta (in pixel) per cui è possibile iniziare l'operazione di Drag
var DragDropRectangles = null;          // Array di DropRectangles
var DragBox = null;                     // Puntatore al Control che fa da DragBox
var DragDropRectangleBackColor = "";    // BackColor del DropRectangle
var DragDropRectangleBorderColor = "";  // BorderColor del DropRectangle
var DragDropRectangleBorderWidth = 2;   // Dimensione del bordo del DropRectangle
var DragSelectedDropRectangleIndex = -1;// Indica del DropRectangle selezionato
var DragDropDragBoxWidth = -1;          // Larghezza del DragBox (-1 automatica)
var DragDropDragBoxHeight = -1;         // Altezza del DragBox (-1 automatica)

var KeyDownFromNumericPadDecimalSeparator = false;
var Control_ScrollTimedOut = false;
var Control_ScrollElement = null;
var Control_ScrollSessionId = 0;
var Control_ScrollHandle = 0;
var GridHostedControlsColors = new Array();

var ImagesViewerHostedControlDragStarted = false;
var ImagesViewerHostedControlInitialX = 0;
var ImagesViewerHostedControlInitialY = 0;
var ImagesViewerHostedControlDraggedElement = null;
var ImagesViewerHostedControlInitialScrollTop = 0;
var ImagesViewerHostedControlInitialScrollLeft = 0;

var ToolTipCounter = 0;                 // Contatore per implementare il meccanismo base che permette di capire quando il ToolTip deve essere visualizzato
var ToolTipX = 0;                       // Posizione X del tooltip
var ToolTipY = 0;                       // Posizione Y del tooltip
var ToolTipShown = 0;                   // Indica se è già stato inviato l'evento di OnToolTipOpen (quindi se deve essere inviato l'evento di OnToolTipClose)
var ToolTipId = 0;                      // Id del ToolTip visualizzato


function TextBox_KeyDown(e, parSessionId, parHandle)
{    
    // Esegue le operazioni su KeyDown delle caselle di testo

    // e            -> EventArgs di KeyPress
    // parSessionId -> SessionId di riferimento
    // parHandle    -> Handle del Control di riferimento

    var tElement;
    var tNewEvent;

    KeyDownFromNumericPadDecimalSeparator = false;
    
    if (e.keyCode == 27)
    {
        // Esegue l'evento di Blur (LostFocus) dell'elemento attivo
        try
        {
            //document.title = document.activeElement.onblur;
            
            if (document.activeElement)
                if (document.activeElement.onblur!=null)
                    document.activeElement.onblur();
        }
        catch (e)
        {
            //document.title = 'eccezione';
        }
    
        // Esegue le operazioni di RoolBack                
        SendCommand(parSessionId, parHandle, 1, 'OnRollBack', '');        
    }
    else if (e.keyCode == 110)
    {
        KeyDownFromNumericPadDecimalSeparator = true;        
    }
    else if (e.keyCode == 13)
    {         
        if (e.srcElement)
            tElement = e.srcElement;
        else
            tElement = e.target;
        
        if (tElement.tagName == "INPUT")        
        {
            // Esegue la simulazione del Tab su pressione del tasto 'Invio'
            if (navigator.userAgent.indexOf('MSIE') < 0)
            {
            /*
                tNewEvent = document.createEvent("KeyEvents");
                tNewEvent.initKeyEvent("keydown", true, true, document.defaultView, e.ctrlKey, e.altKey, e.shiftKey, e.metaKey, 9, 0);
                e.stopPropagation();
                tElement.dispatchEvent(tNewEvent); 
            */
            }
            else
            {                
                e.keyCode = 9;                
            }
        }
        
    }
}

function TextBoxNumeric_KeyPress(e, parSessionId, parHandle)
{
    // Esegue le operazioni su KeyDown delle caselle di testo numeriche

    // e            -> EventArgs di KeyPress
    // parSessionId -> SessionId di riferimento
    // parHandle    -> Handle del Control di riferimento

    if ((!e.which) && (KeyDownFromNumericPadDecimalSeparator))
    {
        e.keyCode = GetDecimalSeparator().charCodeAt(0);
    }
}

function Control_ContextMenuRequest(parElement, parEvent, parSessionId, parHandle)
{
    // Esegue l'evento di ContextMenuRequest del controllo
    
    // parElement   -> Elemento di riferimento
    // parEvent     -> Eventargs
    // parSessionId -> SessionId di riferimento
    // parHandle    -> Handle del Control di riferimento

    var tAbsoluteTop;
    var tAbsoluteLeft;

    //tAbsoluteTop = GetAbsoluteTop(parElement);
    //tAbsoluteLeft = GetAbsoluteLeft(parElement);
    tAbsoluteTop = parEvent.clientY;
    tAbsoluteLeft = parEvent.clientX;

    SendCommand(parSessionId, parHandle, 1, "OnContextMenuRequest", tAbsoluteTop + "|;" + tAbsoluteLeft);    
    
    return false;
}

function Control_MouseDown(parEvent, parSessionId, parHandle, parEventType, parArgument)
{
    // Esegue l'evento di MouseDown del controllo
    
    // parEvent     -> EventArgs
    // parSessionId -> SesionId di riferimento
    // panHandle    -> Handle del Control di riferimento
    // parEventType -> Tipo di evento da gestire (1-MouseDown; 2-PreDrag; 3-MouseDown e PreDrag)
    // parArgument  -> Argomento aggiuntivo (specifico per ogni controllo)

    var tControlKeyPressed;
    var tShiftKeyPressed;
    var tAltKeyPressed;    
    var tClientX;
    var tClientY;    
    var tMouseButton;
    
    // Recupera i pulsanti premuti durante l'operazione di MouseDown
    if (parEvent.ctrlKey)
        tControlKeyPressed = 1;
    else
        tControlKeyPressed = 0;

    if (parEvent.shiftKey)
        tShiftKeyPressed = 1;
    else
        tShiftKeyPressed = 0;

    if (parEvent.altKey)
        tAltKeyPressed = 1;
    else
        tAltKeyPressed = 0;
    
    tClientX = parEvent.clientX;
    tClientY = parEvent.clientY;
    tMouseButton = GetMouseButton(parEvent);
         
    // Invia l'evento di MouseDown
    if ((parEventType == 1) || (parEventType == 3))
        SendCommand(parSessionId, parHandle, 1, 'OnMouseDown', tClientX + "|;" + tClientY + "|;" + tControlKeyPressed + "|;" + tShiftKeyPressed + "|;" + tAltKeyPressed + "|;" + tMouseButton);
        
    // Imposta l'operazione di PreDrag
    if ((tMouseButton == 1) && ((parEventType == 2) || (parEventType == 3)))
        ControlDragInitialize(parHandle, tClientX, tClientY, false, '');
}

function Control_Click(parElement, parEvent, parSessionId, parHandle)
{
    // Esegue l'evento di Click del controllo

    // parElement   -> Elemento di riferimento
    // parEvent     -> EventArgs
    // parSessionId -> SessionId di riferimento
    // parHandle    -> Handle del Control di riferimento
 
    var tControlKeyPressed;
    var tShiftKeyPressed;
    var tAltKeyPressed;    
    var tOffsetX;
    var tOffsetY;
 
    // Esegue l'evento di Blur (LostFocus) dell'elemento attivo
    try
    {
        if (document.activeElement)
            if (document.activeElement.onblur!=null)
                document.activeElement.onblur();
    }
    catch (e)
    {
    }
 
    // Recupera i pulsanti premuti durante l'operazione di Click
    if (parEvent.ctrlKey)
        tControlKeyPressed = 1;
    else
        tControlKeyPressed = 0;

    if (parEvent.shiftKey)
        tShiftKeyPressed = 1;
    else
        tShiftKeyPressed = 0;

    if (parEvent.altKey)
        tAltKeyPressed = 1;
    else
        tAltKeyPressed = 0;
         
    if (navigator.userAgent.indexOf('MSIE')<0)
    {
        tOffsetX = parEvent.layerX;
        tOffsetY = parEvent.layerY;
    }
    else
    {
        tOffsetX = parEvent.offsetX;
        tOffsetY = parEvent.offsetY;
    }   

    // Invia l'evento di Click
    SendCommand(parSessionId, parHandle, 1, 'OnClick', tControlKeyPressed + "|;" + tShiftKeyPressed + "|;" + tAltKeyPressed + "|;" + tOffsetX + "|;" + tOffsetY);        
}

function Control_DoubleClick(parElement, parEvent, parSessionId, parHandle)
{
    // Esegue l'evento di Click del controllo

    // parElement   -> Elemento di riferimento
    // parEvent     -> Eventargs
    // parSessionId -> SessionId di riferimento
    // parHandle    -> Handle del Control di riferimento
 
    var tControlKeyPressed;
    var tShiftKeyPressed;
    var tAltKeyPressed;  
    var tOffsetX;
    var tOffsetY;      
 
    // Recupera i pulsanti premuti durante l'operazione di Click
    if (parEvent.ctrlKey)
        tControlKeyPressed = 1;
    else
        tControlKeyPressed = 0;

    if (parEvent.shiftKey)
        tShiftKeyPressed = 1;
    else
        tShiftKeyPressed = 0;

    if (parEvent.altKey)
        tAltKeyPressed = 1;
    else
        tAltKeyPressed = 0;
     
    if (navigator.userAgent.indexOf('MSIE')<0)
    {
        tOffsetX = parEvent.layerX;
        tOffsetY = parEvent.layerY;
    }
    else
    {
        tOffsetX = parEvent.offsetX;
        tOffsetY = parEvent.offsetY;
    }   
    
    // Invia l'evento di Click
    SendCommand(parSessionId, parHandle, 1, 'OnDoubleClick', tControlKeyPressed + "|;" + tShiftKeyPressed + "|;" + tAltKeyPressed + "|;" + tOffsetX + "|;" + tOffsetY);
}

function ListViewItem_MouseEnter(parElement, parBackgroundColor, parForegroundColor)
{
    // Esegue le operazioni su MouseEnter di un ListItem
    
    // parElement           -> Elemento di riferimento
    // parBackgroundColor   -> Colore di sfondo
    // parForegroundColor   -> Colore in primo piano
    
    parElement.style.backgroundColor = parBackgroundColor;
    parElement.style.color = parForegroundColor;
    
}

function ListViewItem_MouseLeave(parElement, parBackgroundColor, parForegroundColor)
{
    // Esegue le operazioni su MouseLeave di un ListItem
    
    // parElement           -> Elemento di riferimento
    // parBackgroundColor   -> Colore di sfondo
    // parForegroundColor   -> Colore in primo piano
    
    parElement.style.backgroundColor = parBackgroundColor;
    parElement.style.color = parForegroundColor;
    
}

function Control_Scroll(parElement, parSessionId, parHandle , parArgument)
{
    var tHandles;    
    var iHandle;
    var tElement;
    var tHandleSplit;

    if (!LockScrollEvents)
    {
        // Se sono stati passati argomenti aggiuntivi
        if (parArgument != "")
        {
            // Esegue lo split degli elementi
            tHandles = parArgument.split("|");
            
            // Scorre l'elenco degli elementi passati
            for (iHandle = 0; iHandle < tHandles.length; iHandle++)
            {
                tHandleSplit = tHandles[iHandle].split(";");
            
                if (tHandleSplit.length==2)
                {
                    // Preleva il puntatore all'elemento
                    tElement = document.getElementById(tHandleSplit[1]);

                    // Ricalcola il left dell'elemento in base allo ScrollLeft dell'elemento che ha generato l'evento di Scroll
                    if (tElement!=null)
                    {
                        if ((tHandleSplit[0] == "H") || (tHandleSplit[0] == "B"))
                            tElement.style.left = (-parElement.scrollLeft) + "px";

                        if ((tHandleSplit[0] == "V") || (tHandleSplit[0] == "B"))
                            tElement.style.top = (-parElement.scrollTop) + "px";
                    }
                    
                    // Libera le risorse
                    tElement = null;                
                }
            }
        }

        if (!Control_ScrollTimedOut)
        {
            Control_ScrollTimedOut = true;
            Control_ScrollElement = parElement;
            Control_ScrollSessionId = parSessionId;
            Control_ScrollHandle = parHandle;
            Control_ScrollArgument = parArgument;            
            window.setTimeout("Control_ScrollExecuter()", 50);
        }
    }
}

function Control_ScrollExecuter()
{
    // Invia le informazioni di ScrollTop e ScrollLeft dell'elemento

    // Control_ScrollElement   -> Elemento di riferimento
    // Control_ScrollSessionId -> SessionId di riferimento
    // Control_ScrollHandle    -> Handle del Control di riferimento
    // Control_ScrollArgument  -> Argomento facoltativo (Handle di elementi da riposizionare separati da |)
    
    var tScrollTop;
    var tScrollLeft;
    var tHandles;    
    var iHandle;
    var tElement;

    // Calcola le posizione di ScrollTop e ScrollLeft dell'elemento
    tScrollTop = Control_ScrollElement.scrollTop;
    tScrollLeft = Control_ScrollElement.scrollLeft;
 
    // Invia le informazioni di ScrollTop e ScrollLeft dell'elemento
    SendCommand(Control_ScrollSessionId, Control_ScrollHandle, 1, 'OnScroll', tScrollTop + "|;" + tScrollLeft);
    
    Control_ScrollTimedOut = false;
}

function Control_MouseLeave(e, parElement, parSessionId, parHandle, parSendCommand, parArgument)
{
    // Esegue le operazioni su MouseLeave di un Control
    
    // e                -> EventArgs di OnMouseEnter
    // parElement       -> Elemento di riferimento
    // parSessionId     -> SessionId di riferimento    
    // parHandle        -> Handle del controllo di riferimento
    // parSendCommand   -> Se diverso da zero indica di inviare al server il comando di OnMouseEnter
    // parArgument      -> Argomenti opzionali (colore da impostare per l'elemento)
    
    var tSendCommand;
    var tElement;
    
    if (parSendCommand != 0)
    {
        tSendCommand = true;
    
        if (navigator.userAgent.indexOf('MSIE')<0)
        {
            tElement = e.explicitOriginalTarget;            
            
            while (tElement.parentNode != null)
            {
                if (tElement.parentNode == e.currentTarget)
                {
                    tSendCommand = false;
                    break;
                }
                else
                    tElement = tElement.parentNode;
            }            
        }
        
        if (tSendCommand)
            SendCommand(parSessionId, parHandle, 1, 'OnMouseLeave', '');        
    }
}

function GridHostedControl_MouseEnter(e, parElement, parSessionId, parHandle, parSendCommand, parArgument)
{
    // Esegue le operazioni su MouseEnter di un HostedControl della Grid
    
    // e                -> EventArgs di OnMouseEnter
    // parElement       -> Elemento di riferimento
    // parSessionId     -> SessionId di riferimento    
    // parHandle        -> Handle del controllo di riferimento
    // parSendCommand   -> Se diverso da zero indica di inviare al server il comando di OnMouseEnter
    // parArgument      -> Argomenti opzionali (colore da impostare per l'elemento)

    GridHostedControlSetBackgroundColor(parElement, parArgument);

    if (parSendCommand != 0)
        SendCommand(parSessionId, parHandle, 1, 'OnMouseEnter', '');
}

function GridHostedControlsCellColor()
{
    this.Element=null;
    this.BackColor="";
}

function GridHostedControlSetBackgroundColor(parElement, parColor)
{
    var iElement;    
    var tElement;
    var tAverageColor;
    var tGridHostedControlsCellColor;
    var tChildNodes;
    
    tChildNodes = parElement.childNodes;
    for (iElement = 0; iElement < tChildNodes.length; iElement++)
    {
        tElement = tChildNodes[iElement];
        
        if (tElement.style)
        {
            tGridHostedControlsCellColor=new GridHostedControlsCellColor();
            tGridHostedControlsCellColor.Element = tElement;
            tGridHostedControlsCellColor.BackColor = tElement.style.backgroundColor;
        
            GridHostedControlsColors.push(tGridHostedControlsCellColor);
            
            tAverageColor = GetAverageColor(tGridHostedControlsCellColor.BackColor, parColor);
            
            tElement.style.backgroundColor = tAverageColor;
        }

        if (tElement.childNodes.length>0)
            GridHostedControlSetBackgroundColor(tElement, parColor);
        
        tElement = null;
    }    
}

function GridHostedControlResetBackgroundColor()
{
    // Reimposta i colori di sfondo per gli elementi presenti nella collection GridHostedControlsColors

    var tHostedControlColor;
    var tElement;    

    while (GridHostedControlsColors.length>0)
    {
        tHostedControlColor = GridHostedControlsColors[0];
        
        tElement = tHostedControlColor.Element;
        
        if (tElement!=null)
            tElement.style.backgroundColor = tHostedControlColor.BackColor;
        
        tElement = null;
        tHostedControlColor = null;
        
        GridHostedControlsColors.shift();
    }
}

function GridHostedControl_MouseLeave(e, parElement, parSessionId, parHandle, parSendCommand, parArgument)
{
    // e                -> EventArgs di OnMouseEnter
    // parElement       -> Elemento di riferimento
    // parSessionId     -> SessionId di riferimento    
    // parHandle        -> Handle del controllo di riferimento
    // parSendCommand   -> Se diverso da zero indica di inviare al server il comando di OnMouseEnter
    // parArgument      -> Argomenti opzionali (nessun argomento)
                   
    GridHostedControlResetBackgroundColor();
               
    if (parSendCommand != 0)
        SendCommand(parSessionId, parHandle, 1, 'OnMouseLeave', '');    
}

function SplitterMoveStart(e, parHandle, parMarginBefore, parMarginAfter, parContainerControlHandle)
{
    // e                            -> EventArgs di OnMouseEnter
    // parHandle                    -> Handle del controllo di riferimento
    // parMarginBefore              -> Margine minimo prima dello Splitter 
    // parMarginAfter               -> Margine minimo dopo lo splitter
    // parContainerControlHandle    -> Handle del ContainerControl di riferimento
    
    var tElement;
    var tParentElement;
    var tContainerControlElement;    
    var tTempElement;
    
    var tTop;
    var tLeft;
    var tWidth;
    var tHeight;
    var iElement;
    var tDockStyle;    
    var tContainerControlTop;
    var tContainerControlLeft;
    var tContainerControlWidth;
    var tContainerControlHeight;    
    var tElementTop;
    var tElementLeft;
    var tElementWidth;
    var tElementHeight;
    var tUseContainerControl;
    
    var tFillElement;
    var tCellIndex;
    var tRowIndex;
    var tHTML;
    var tAllowMove;
    var tParentHandle;
    var tCursor;
    
    // Preleva il puntatore all'elemento di riferimento
    tElement = document.getElementById(parHandle);
    
    if (tElement!=null)
    {
        // Inizializzazione variabili
        tAllowMove = false;
        SplitterMoveStarted = false;
        SplitterMoveHandle = parHandle;
        SplitterMoveDockStyle = "";
        SplitterMovePositionBefore = 0;
        SplitterMovePositionAfter = 0;
            
        // Preleva il puntatore al Control padre
        tParentElement = tElement.parentNode;
        
        // Preleva il puntatore al ContainerControl di riferimento
        tContainerControlElement = document.getElementById(parContainerControlHandle);

        if ((tParentElement != null) && (tContainerControlElement != null))
        {            
            tParentHandle = tParentElement.id;
        
            // Calcola posizione e dimensione dello Splitter
            tTop = tElement.offsetTop;
            tLeft = tElement.offsetLeft;
            tHeight = tElement.offsetHeight;
            tWidth = tElement.offsetWidth;
        
            // Calcola posizione e dimensione del ContainerControl
            tContainerControlTop = tContainerControlElement.offsetTop;
            tContainerControlLeft = tContainerControlElement.offsetLeft;
            tContainerControlHeight = tContainerControlElement.offsetHeight;
            tContainerControlWidth = tContainerControlElement.offsetWidth;
            
            // Calcola lo stile di Dock dello Splitter
            tDockStyle = "";
            if ((tLeft < tContainerControlLeft) && (tTop <= tContainerControlTop))
                tDockStyle = "LEFT";
            else
            {
                if ((tTop < tContainerControlTop) && (tLeft == tContainerControlLeft))
                    tDockStyle = "TOP";
                else
                {
                    if ((tLeft > tContainerControlLeft) && (tTop <= tContainerControlTop))
                        tDockStyle = "RIGHT";
                    else
                    {
                        if ((tTop > tContainerControlTop)  && (tLeft == tContainerControlLeft))
                            tDockStyle = "BOTTOM";
                    }
                }
            }
            
            if (tDockStyle != "")
            {
                tUseContainerControl = true;
            
                SplitterMovePositionBefore = 0;                
                SplitterMovePositionAfter = 100000;
            
                // Scorre la collection di element per trovare l'offset di spostamento
                for (iElement = 0; iElement < tParentElement.childNodes.length; iElement++)
                {                    
                    tTempElement = tParentElement.childNodes[iElement];
                    
                    tElementTop = tTempElement.offsetTop;
                    tElementLeft = tTempElement.offsetLeft;
                    tElementWidth = tTempElement.offsetWidth;
                    tElementHeight = tTempElement.offsetHeight;
                    
                    if (tTempElement != tElement)
                    {
                        switch (tDockStyle)
                        {
                            case "TOP":
                            
                                if ((tTempElement.offsetWidth == tContainerControlWidth) && (tElementTop < tContainerControlTop))
                                {
                                    if ((tElementTop < tTop) && (tElementTop > SplitterMovePositionBefore))
                                        SplitterMovePositionBefore = tElementTop;
                                    else
                                    {
                                        if ((tElementTop > tTop) && (tElementTop + tElementHeight < SplitterMovePositionAfter))
                                        {
                                            SplitterMovePositionAfter = tElementTop + tElementHeight;
                                            tUseContainerControl = false;
                                        }
                                    }                                    
                                }
                                
                                break;
                                
                            case "LEFT":
                            
                                if ((tTempElement.offsetHeight >= tContainerControlHeight) && (tElementLeft < tContainerControlLeft))
                                {
                                    if ((tElementLeft < tLeft) && (tElementLeft > SplitterMovePositionBefore))
                                        SplitterMovePositionBefore = tElementLeft;
                                    else
                                    {
                                        if ((tElementLeft > tLeft) && (tElementLeft + tElementWidth < SplitterMovePositionAfter))
                                        {
                                            SplitterMovePositionAfter = tElementLeft + tElementWidth;
                                            tUseContainerControl = false;
                                        }
                                    }
                                }
                                break;
                                
                            case "BOTTOM":
                            
                                if ((tTempElement.offsetWidth == tContainerControlWidth) && (tElementTop > tContainerControlTop))
                                {
                                    if ((tElementTop < tTop) && (tElementTop > SplitterMovePositionBefore))
                                    {
                                        SplitterMovePositionBefore = tElementTop;
                                        tUseContainerControl = false;
                                    }
                                    else
                                    {
                                        if ((tElementTop > tTop) && (tElementTop + tElementHeight < SplitterMovePositionAfter))
                                            SplitterMovePositionAfter = tElementTop + tElementHeight;
                                    }                                    
                                }
                                break;
                                
                            case "RIGHT":
                            
                                if ((tTempElement.offsetHeight >= tContainerControlHeight) && (tElementLeft > tContainerControlLeft))
                                {
                                    if ((tElementLeft < tLeft) && (tElementLeft > SplitterMovePositionBefore))
                                    {
                                        SplitterMovePositionBefore = tElementLeft;
                                        tUseContainerControl = false;
                                    }
                                    else
                                    {
                                        if ((tElementLeft > tLeft) && (tElementLeft + tElementWidth < SplitterMovePositionAfter))
                                            SplitterMovePositionAfter = tElementLeft + tElementWidth;
                                    }
                                }
                                break;
                        }
                    }
                    
                    tTempElement = null;
                }
                
                if (tUseContainerControl)
                {
                    switch (tDockStyle)
                    {
                        case "TOP":
                        
                            SplitterMovePositionAfter = tContainerControlTop + tContainerControlHeight;
                            break;
                            
                        case "LEFT":
                        
                            SplitterMovePositionAfter = tContainerControlLeft + tContainerControlWidth;
                            break;
                            
                        case "BOTTOM":
                        
                            SplitterMovePositionBefore = tContainerControlTop;
                            break;
                            
                        case "RIGHT":
                        
                            SplitterMovePositionBefore = tContainerControlLeft;
                            break;
                    }
                }
                
                if (parMarginAfter<0)
                {
                    if ((tDockStyle == "TOP") || (tDockStyle == "LEFT"))
                        SplitterMovePositionAfter = -1;
                    else
                        SplitterMovePositionBefore = -1;
                }
                else
                {
                    if ((tDockStyle == "TOP") || (tDockStyle == "LEFT"))
                        SplitterMovePositionAfter = SplitterMovePositionAfter - parMarginAfter;
                    else
                        SplitterMovePositionBefore = SplitterMovePositionBefore + parMarginAfter;
                }                
                    
                if (parMarginBefore<0)
                {
                    if ((tDockStyle == "TOP") || (tDockStyle == "LEFT"))
                        SplitterMovePositionBefore = -1;
                    else
                        SplitterMovePositionAfter = -1;
                }
                else
                {
                    if ((tDockStyle == "TOP") || (tDockStyle == "LEFT"))
                        SplitterMovePositionBefore = SplitterMovePositionBefore + parMarginBefore;
                    else
                        SplitterMovePositionAfter = SplitterMovePositionAfter - parMarginBefore;
                }                
                
                tHTML = "";
                tHTML += "<div id=SplitterMover style=\"";
                tHTML += "position:absolute;overflow:hidden;";
                tHTML += "top:" + tTop + "px;";
                tHTML += "left:" + tLeft + "px;";
                tHTML += "width:" + tElement.offsetWidth + "px;";
                tHTML += "height:" + tElement.offsetHeight + "px;";
                tHTML += "border: none 0px;";
                tHTML += "background-color:silver;";
                tHTML += "z-index: 10000;";
                            
                if (SplitterMoveDockStyle == "TOP")
                {
                    tCursor = "n-resize";
                }
                else if (SplitterMoveDockStyle == "LEFT")                
                {
                    tCursor = "w-resize";
                }
                else if (SplitterMoveDockStyle == "BOTTOM")                
                {
                    tCursor = "s-resize";
                }
                else if (SplitterMoveDockStyle == "RIGHT")                
                {
                    tCursor = "e-resize";
                }
                tHTML += "cursor:" + tCursor + ";";
                tHTML += "\" contenteditable=false unselectable=on></div>";
                        
                AddHandle(tParentHandle, tHTML);
                SplitterMoveMover = document.getElementById("SplitterMover");
            
                // Imposta il cursore del document
                document.getElementById("ApplicationLayer").style.cursor = tCursor;

                // Calcola gli offset e la posizione iniziale dello Splitter
                SplitterMoveOffsetX = e.clientX;
                SplitterMoveOffsetY = e.clientY;        
                SplitterMoveTop = tElement.offsetTop;
                SplitterMoveLeft = tElement.offsetLeft;
                SplitterMoveDockStyle = tDockStyle
            
                SplitterMoveStarted = true;
            }            
        }
    }
    
    // Libera le risorse
    tElement = null;    
}

function SplitterMoveExecute(e, parHandle)
{
    // Esegue lo spostamento dello Splitter

    // e            -> EventArgs di MouseMove
    // parHandle    -> Handle dello Splitter di riferimento

    var tTop;
    var tLeft;

    if ((SplitterMoveStarted) && (SplitterMoveHandle == parHandle))
    {
        if ((SplitterMoveDockStyle == "LEFT") || (SplitterMoveDockStyle == "RIGHT"))
        {
            tLeft = SplitterMoveLeft + (e.clientX - SplitterMoveOffsetX);
            
            if (tLeft < SplitterMovePositionBefore)
                tLeft = SplitterMovePositionBefore;
                
            if ((tLeft > SplitterMovePositionAfter) && (SplitterMovePositionAfter>=0))
                tLeft = SplitterMovePositionAfter;
            
            SplitterMoveMover.style.left = tLeft + "px";
        }
        else
        {
            tTop = SplitterMoveTop + (e.clientY - SplitterMoveOffsetY);
            
            if (tTop < SplitterMovePositionBefore)
                tTop = SplitterMovePositionBefore;
                
            if ((tTop > SplitterMovePositionAfter) && (SplitterMovePositionAfter>=0))
                tTop = SplitterMovePositionAfter;
                
            SplitterMoveMover.style.top = tTop + "px";   
        }        
    }
}

function SplitterMoveStop(e, parHandle)
{
    // Termina l'operazione di spostamento dello Splitter    
    
    // e            -> EventArgs di MouseMove
    // parHandle    -> Handle dello Splitter di riferimento

    var tOffset;
    var tSessionId;

    if ((SplitterMoveStarted) && (SplitterMoveHandle == parHandle))
    {
        // Calcola l'Offset di spostamento
        if ((SplitterMoveDockStyle == "LEFT") || (SplitterMoveDockStyle == "RIGHT"))
            tOffset = SplitterMoveMover.offsetLeft - SplitterMoveLeft;
        else
            tOffset = SplitterMoveMover.offsetTop - SplitterMoveTop;

        // Rimuove il layer di spostamento
        SplitterMoveMover.parentNode.removeChild(SplitterMoveMover);
        SplitterMoveMover = null;

        // Reimposta il cursore del document
        document.getElementById("ApplicationLayer").style.cursor = "";
    
        // Termina la sessione di spostamento
        SplitterMoveHandle = "";
        SplitterMoveStarted = false;        
        
        // Preleva il SessionId corrente                    
        tSessionId = document.getElementById("SessionId").value;
        
        // Invia le informazioni di posizione e dimensione al server
        SendCommand(tSessionId, parHandle, 1, "OnMove", tOffset);        
    }    
}

function FileUploaderSmoothButton_Browse(parIFrameSubHandle)
{
    // Consente di caricare un file sul server tramite File Browser
    
    // parIFrameSubHandle -> Nome del IFrame che consente l'effettivo invio lato server del file
    
    var tFrameDocument;
    
    // Apre il File Browser
    tFrameDocument = document.getElementById(parIFrameSubHandle).contentDocument;
    
    alert("Fatto1!");
    if (tFrameDocument!= null)
    {
        // Invia il file al server
        if (tFrameDocument.getElementById('UploadFile').value != "")
        {
            tFrameDocument.getElementById('UploadSubmit').click();
            alert("Fatto2!");
        }
    }       
}

function ControlDragInitialize(parHandle, parClientX, parClientY, parDragAutoStart, parDropRectangles)
{
    // Inizializza i parametri per avviare un'operazione di Drag    
    DragPreStarted = true;
    DragStarted = false;
    DragPreDragHandle = parHandle;
    DragHandle = "";
    DragClientX = parClientX;
    DragClientY = parClientY;
    DragAutoStart = parDragAutoStart;    
    DragAutoStartDropRectangles = parDropRectangles;
}

function ControlPreDragCheck(e)
{
    // Controlla se lo spostamento dal punto iniziale di PreDrag è sufficiente ad iniziale l'operazione di Drag
    
    // e            -> EventArgs di MouseMove
        
    if ((Math.abs(DragClientX - e.clientX) >= DragDelta) || (Math.abs(DragClientY - e.clientY) >= DragDelta))
    {
        // Termina l'operazione di PreDrag
        DragPreStarted = false;
        DragStarted = false;        
    
        // Se il Drag non deve essere avviato automaticamente, invia lato server il comando di OnDragStart
        if(!DragAutoStart)
            SendCommand(document.getElementById("SessionId").value, DragPreDragHandle, 1, 'OnDragStart', DragClientX + "|;" + DragClientY);
        
        // Se il Drag deve essere avviato automaticamente, lo avvia
        else
            ControlDragStart(DragAutoStartDropRectangles);
    }
}

function ControlDragStart(parDropRectangles)
{
    // Attiva l'operazione di Drag
    
    // parDropRectangles    -> Stringa di DropRectangles
    
    var tDropRectanglesSplit;
    
    if (parDropRectangles != "")
    {    
        tDropRectanglesSplit = parDropRectangles.split('|');
    
        // Imposta l'Handle dell'elemento di cui eseguire l'operazione di Drag
        DragHandle = tDropRectanglesSplit[0];
        
        // Imposta i colori da utilizzare per il DropRectangle
        DragDropRectangleBackColor = tDropRectanglesSplit[1];
        DragDropRectangleBorderColor = tDropRectanglesSplit[2];
        DragDropDragBoxWidth = tDropRectanglesSplit[3];
        DragDropDragBoxHeight = tDropRectanglesSplit[4];
    
        // Calcola gli Offset di Drag
        CalculateDragOffsets();
    
        // Popola l'array di DropRectangles
        FillDropRectangles(tDropRectanglesSplit);
        
        // Crea il DragBox
        CreateDragBox();
        
        // Avvia l'operazione dri Drag
        DragPreStarted = false;
        DragStarted = true;        
    }
    else
    {
        // Termina l'operazione di Drag
        ControlDragAbort(true);
    }
}

function CalculateDragOffsets()
{
    // Calcola gli Offset di Drag
    
    var tDragHandle;
    var tDragHandleTop;
    var tDragHandleLeft;
    var tDragPreDragHandle;
    var tDragPreDragHandleTop;
    var tDragPreDragHandleLeft;
    
    // Preleva il puntatore all'elemento di Drag
    tDragHandle = document.getElementById(DragHandle);
    
    if (tDragHandle != null)
    {
        tDragHandleTop = GetAbsoluteTop(tDragHandle);
        tDragHandleLeft = GetAbsoluteLeft(tDragHandle);

        DragOffsetX = DragClientX - tDragHandleLeft;
        DragOffsetY = DragClientY - tDragHandleTop;        
    }    
}

function FillDropRectangles(parDropRectanglesSplit)
{    
    // Popola l'array di DropRectangles

    // parDropRectangles    -> Stringa di DropRectangles

    var tRectangleSplit;
    var iRectanglesSplit;
    var tX;
    var tY;
    var tWidth;
    var tHeight;

    // Inizializza l'array dei Rectangles
    DragDropRectangles = new Array();            
    
    // Scorre la lista di Rectangles
    for (iRectanglesSplit = 5; iRectanglesSplit < parDropRectanglesSplit.length;iRectanglesSplit++)
    {
        if (parDropRectanglesSplit[iRectanglesSplit] != "")
        {
            // Esegue lo split per separare le coordinate e le dimensione del Rectangle
            tRectangleSplit = parDropRectanglesSplit[iRectanglesSplit].split(';');
            
            if (tRectangleSplit.length == 4)
            {
                // Estrae le dimensione e le coordinate del Rectangle
                tX = parseInt(tRectangleSplit[0]);
                tY = parseInt(tRectangleSplit[1]);
                tWidth = parseInt(tRectangleSplit[2]);
                tHeight = parseInt(tRectangleSplit[3]);
                
                if (navigator.userAgent.indexOf('MSIE')>=0)
                {
                    tWidth += 2;    
                    tHeight += 2;
                }
                
                // Inizializza il Recntalge e lo inserisce nell'array di Rectangles
                DragDropRectangles.push(new Rectangle(tX, tY, tWidth, tHeight));                    
            }                
        }
    }        
}

function CreateDragBox()
{
    // Crea il DragBox
    
    var tElement;
    var tHTML;
    var tDragHandleHTML;
    var tTop;
    var tLeft;
    var tWidth;
    var tHeight;
        
    tElement = document.getElementById(DragHandle);
    
    if (tElement != null)
    {  
        // Calcola le coordinate assolute del Control di cui eseguire l'operazione di Drag
        tTop = GetAbsoluteTop(tElement);
        tLeft = GetAbsoluteLeft(tElement);
        
        // Preleva l'HTML del Control di cui eseguire l'operazione di Drag
        tDragHandleHTML = GetOuterHTML(DragHandle);
        
        if (DragDropDragBoxWidth == -1)
            tWidth = tElement.offsetWidth;
        else
            tWidth = DragDropDragBoxWidth;

        if (DragDropDragBoxHeight == -1)
            tHeight = tElement.offsetHeight;
        else
            tHeight = DragDropDragBoxHeight;
        
        
        // Definisce il DragBox
        tHTML = ""; 
        tHTML += "<div id=DragBox style=\"";
        tHTML += "position: absolute;";
        tHTML += "top: " + tTop + "px;";
        tHTML += "left: " + tLeft + "px;";
        tHTML += "width: " + tWidth + "px;";
        tHTML += "height: " + tHeight + "px;";
        tHTML += "background-color: " + tElement.style.backgroundColor + ";";
        tHTML += "z-index: 10000;";
        tHTML += "filter:alpha(opacity=50);opacity:.50;";
        tHTML += "border-style:none; border-width:0px;";
        tHTML += "\" contenteditable=false unselectable=on>";
        tHTML += tDragHandleHTML.replace("id=", "id=D");
        tHTML += "</div>";              
    
        // Aggiunge il DragBox
        AddHandle("ApplicationLayer", tHTML);
        
        // Posiziona il contenuto del DragBox
        tElement = document.getElementById("D" + DragHandle);
        if (tElement != null)
        {
            tElement.style.top = "0px";
            tElement.style.left = "0px";
        }
        tElement = null;
        
        // Imposta il puntatore al DragBox
        DragBox = document.getElementById("DragBox");
    }
    
    tElement = null;    
}

function Rectangle(parX, parY, parWidth, parHeight)
{
    // Classe Rectangle

    this.X = parX;
    this.Y = parY;
    this.Width = parWidth;
    this.Height = parHeight;
    this.IntersectsWith = IntersectsWith;
    
    function IntersectsWith(parX, parY)
    {
        // Restituisce true se le coordinate passate intersecano il Rectangle
        
        return ((this.X < parX) && (this.X + this.Width > parX) && (this.Y < parY) && (this.Y + this.Height > parY));
    }    
}

function ControlDragExecute(e)
{
    // Esegue l'operazione di Drag
    
    var tTop;
    var tLeft;
    var iDropRectangle;
    var tDropRectangle;
    var tFoundDropRectangle;
    var tHTML;
    var tWidth;
    var tHeight;
    
    if (DragBox != null)
    {
        if (GetMouseButton(e)==1)
        {
            // Calcola le coordinate in cui posizionare il DragBox
            tTop = e.clientY - DragOffsetY;
            tLeft = e.clientX - DragOffsetX;
            
            // Posizione il DragBox alle coordinate calcolate
            DragBox.style.top = tTop + "px";
            DragBox.style.left = tLeft + "px";
            
            // Scorre l'Array di DropRectangles per controllare se ci si trova sopra uno di essi
            tFoundDropRectangle = false;    
            for (iDropRectangle = 0; iDropRectangle < DragDropRectangles.length; iDropRectangle++)
            {
                // Preleva il puntatore al DropRectangle
                tDropRectangle = DragDropRectangles[iDropRectangle];
                
                // Se le coordinate del mouse si trovano all'interno del DropRectangle ...
                if (tDropRectangle.IntersectsWith(e.clientX , e.clientY))
                {
                    // ... disegna il DropRectangle
                    tFoundDropRectangle = true;                               
                    
                    if (iDropRectangle != DragSelectedDropRectangleIndex)
                    {
                        // Rimuove l'eventuale DropRectangle già presente
                        if (DragSelectedDropRectangleIndex != -1)
                            RemoveHandle("DropRectangle");
                        
                        // Imposta l'indice del DropRectangle selezionato    
                        DragSelectedDropRectangleIndex = iDropRectangle;
                        
                        // Calcola le dimensioni grafiche del DropRectangle
                        tWidth = tDropRectangle.Width - (2 * DragDropRectangleBorderWidth);
                        tHeight = tDropRectangle.Height - (2 * DragDropRectangleBorderWidth);
                        
                        if (navigator.userAgent.indexOf('MSIE')>=0)
                        {
                            DragBox.style.filter = "alpha(opacity=10)";
                        }
                        else
                        {                    
                            DragBox.style.opacity = ".10";
                        }
                        
                        tHTML = "";
                        tHTML += "<div id=DropRectangle style=\"";
                        tHTML += "position: absolute;";
                        tHTML += "overflow: hidden;";
                        tHTML += "top: " + tDropRectangle.Y + "px;";
                        tHTML += "left: " + tDropRectangle.X + "px;";
                        tHTML += "width: " + tWidth + "px;";
                        tHTML += "height: " + tHeight + "px;";
                        tHTML += "background-color: " + DragDropRectangleBackColor + ";";
                        tHTML += "z-index: 9999;";
                        tHTML += "filter:alpha(opacity=50);opacity:.50;";
                        tHTML += "border-top: " + DragDropRectangleBorderColor + " " + DragDropRectangleBorderWidth + "px solid;";
                        tHTML += "border-bottom: " + DragDropRectangleBorderColor + " " + DragDropRectangleBorderWidth + "px solid;";
                        tHTML += "border-left: " + DragDropRectangleBorderColor + " " + DragDropRectangleBorderWidth + "px solid;";
                        tHTML += "border-right: " + DragDropRectangleBorderColor + " " + DragDropRectangleBorderWidth + "px solid;";
                        tHTML += "\" contenteditable=false unselectable=on>";                    
                        tHTML += "</div>";              
                        
                        // Aggiunge il DropRectangle
                        AddHandle("ApplicationLayer", tHTML);
                    }
                    
                    tDropRectangle = null;
                    break;
                }
                
                tDropRectangle = null;
            }
            
            // Se non è stato trovato nessun DropRectangle elimina quello presente (se presente)
            if ((!tFoundDropRectangle) && (DragSelectedDropRectangleIndex != -1))
            {
                RemoveHandle("DropRectangle");
                DragSelectedDropRectangleIndex = -1;
                if (navigator.userAgent.indexOf('MSIE')>=0)
                    DragBox.style.filter = "alpha(opacity=50)";
                else
                    DragBox.style.opacity = ".50";
            }        
        }
        else
        {
            ControlDragEnd(e);    
        }
    }    
}

function ControlDragEnd(e)
{
    // Esegue il comando di DragEnd

    var tTop;
    var tLeft;

    // Calcola le coordinate di Drop
    tTop = e.clientY - DragOffsetY;
    tLeft = e.clientX - DragOffsetX;

    SendCommand(document.getElementById("SessionId").value, DragPreDragHandle, 1, 'OnDragEnd', tLeft + "|;" + tTop + "|;" + DragSelectedDropRectangleIndex);
    
    // Termina l'operazione di Drag
    ControlDragAbort(false);
}

function ControlDragAbort(parSendDragAbort)
{
    // Annulla l'operazione di Drag

    // parSendDragAbort -> Indica se inviare il comando di DragAbort

    if (parSendDragAbort)
        SendCommand(document.getElementById("SessionId").value, DragPreDragHandle, 1, 'OnDragAbort', "");
    
    RemoveHandle("DragBox");
    RemoveHandle("DropRectangle");
    DragPreStarted = false;
    DragStarted = false;
    DragPreDragHandle = "";
    DragHandle = "";    
    DragClientX = 0;
    DragClientY = 0;
    DragOffsetX = 0;
    DragOffsetY = 0;
    DragDropRectangles = null;
    DragBox = null;
    DragDropRectangleBackColor = "";
    DragDropRectangleBorderColor = "";
    DragSelectedDropRectangleIndex = -1;
}

function ImagesViewerHostedControlMouseDown(parEvent, parSessionId, parHandle, parEventType, parArgument)
{
    // Esegue l'evento di MouseDown del controllo HostedControl dell'ImagesViewer
    
    // parEvent     -> EventArgs
    // parSessionId -> SesionId di riferimento
    // panHandle    -> Handle del Control di riferimento
    // parEventType -> Tipo di evento da gestire (1-MouseDown; 2-PreDrag; 3-MouseDown e PreDrag)
    // parArgument  -> Handle del controllo che contiene gli HostedControl (cioè il MainContainer del Repeater)
    

    // Avvia l'operazione di Drag
    if ((parArgument != '') && (GetMouseButton(parEvent) == 1))
    {
        if(document.getElementById(parHandle).style.cursor == "pointer")
        {    
            ImagesViewerHostedControlDragStarted = true;
            ImagesViewerHostedControlInitialX = parEvent.clientX;
            ImagesViewerHostedControlInitialY = parEvent.clientY;
            ImagesViewerHostedControlDraggedElement = document.getElementById(parArgument);
            ImagesViewerHostedControlInitialScrollTop = ImagesViewerHostedControlDraggedElement.scrollTop;
            ImagesViewerHostedControlInitialScrollLeft = ImagesViewerHostedControlDraggedElement.scrollLeft;            
            return false;
        }
    }
    
    // Richiama il gestore del MouseDown standard     
    Control_MouseDown(parEvent, parSessionId, parHandle, parEventType, parArgument);        
}

function ImagesViewerHostedControlMouseMove(parEvent)
{
    // Esegue l'evento di MouseMove del controllo HostedControl dell'ImagesViewer    
    
    if (GetMouseButton(parEvent) == 1)
    {
        ImagesViewerHostedControlDraggedElement.scrollTop = ImagesViewerHostedControlInitialScrollTop + (ImagesViewerHostedControlInitialY - parEvent.clientY);
        ImagesViewerHostedControlDraggedElement.scrollLeft = ImagesViewerHostedControlInitialScrollLeft + (ImagesViewerHostedControlInitialX - parEvent.clientX);                
    }
    else    
    {
        ImagesViewerHostedControlDragStarted = false;
        ImagesViewerHostedControlInitialX = 0;
        ImagesViewerHostedControlInitialY = 0;
        ImagesViewerHostedControlDraggedElement = null;
        ImagesViewerHostedControlInitialScrollTop = 0;
    }    
}

function ImagesViewerHostedControlMouseUp(parEvent)
{
    // Esegue l'evento di MouseUp del controllo HostedControl dell'ImagesViewer    
    if (GetMouseButton(parEvent) == 1)
    {
        ImagesViewerHostedControlDraggedElement.scrollTop = ImagesViewerHostedControlInitialScrollTop + (ImagesViewerHostedControlInitialY - parEvent.clientY);
        ImagesViewerHostedControlDraggedElement.scrollLeft = ImagesViewerHostedControlInitialScrollLeft + (ImagesViewerHostedControlInitialX - parEvent.clientX);
    }
    
    ImagesViewerHostedControlDragStarted = false;
    ImagesViewerHostedControlInitialX = 0;
    ImagesViewerHostedControlInitialY = 0;
    ImagesViewerHostedControlDraggedElement = null;
    ImagesViewerHostedControlInitialScrollTop = 0;       
}

/*
* Sull'evento di MouseMove determina se deve essere chiuso il ToolTip eventualmente aperto
*/
function Control_ToolTipMouseMove(parElement, parEvent, parSessionId, parHandle)
{            
    var tToolTipX;
    var tToolTipY;

    if (navigator.userAgent.indexOf('MSIE')<0)
    {
        tToolTipX = parEvent.layerX;
        tToolTipY = parEvent.layerY;
    }
    else
    {
        tToolTipX = parEvent.offsetX;
        tToolTipY = parEvent.offsetY;
    }

    // Se c'è un ToolTip aperto..
    if (ToolTipShown) 
    {
        // .. invia l'evento di chiusura del ToolTip, se il mouse si è spostato di più di 5 pixel        
        if ((tToolTipX < ToolTipX - 5) || (tToolTipX > ToolTipX + 5) || (tToolTipY < ToolTipY - 5) || (tToolTipY > ToolTipY + 5))
        {
            
            // .. ed avvia il timeout per visualizzare il tooltip
            ToolTip_Close(parSessionId, parHandle, -1);                    
        }
    }
    
    // Se non c'è un ToolTip aperto..
    if (!ToolTipShown) 
    {
        // .. incrementa il contatore
        if(ToolTipCounter++ > 9999999)
            ToolTipCounter = 0;
        
        // .. ed avvia il timeout per visualizzare il tooltip
        if (navigator.userAgent.indexOf('MSIE')<0)
        {
            tToolTipX = parEvent.layerX;
            tToolTipY = parEvent.layerY;
        }
        else
        {
            tToolTipX = parEvent.offsetX;
            tToolTipY = parEvent.offsetY;
        }
        setTimeout('ToolTip_Open(' + + parSessionId + ',' + parHandle + ',' + tToolTipX + ',' + tToolTipY + ',' + ToolTipCounter + ');' , 400);
    }
}

/*
* Sull'evento di MouseLeave chiude il ToolTip eventualmente aperto
*/
function Control_ToolTipMouseLeave(parElement, parEvent, parSessionId, parHandle)
{
    ToolTip_Close(parSessionId, parHandle, -1);
    
    // Incrementa il contatore
    if(ToolTipCounter++ > 9999999)
        ToolTipCounter = 0;
}

/*
* Questa funzione invia l'evento di apertura di un ToolTip
*/
function ToolTip_Open(parSessionId, parHandle, parToolTipX, parToolTipY, parToolTipCounter)
{

    // Se il counter non è cambiato (cioè se non c'è stato un MouseLeave o un MouseMove rilevante nel frattempo)
    if (ToolTipCounter == parToolTipCounter)
    {
        
        // .. memorizza le coordinate del mouse
        ToolTipX = parToolTipX;
        ToolTipY = parToolTipY;
        
        // .. assegna un Id al ToolTip che sta per essere aperto
        ToolTipId = ToolTipId + 1;
        
        // .. invia l'evento di apertura del ToolTip
        ToolTipShown = true;    
        SendCommand(parSessionId, parHandle, 1, 'OnShowToolTip', ToolTipX + "|;" + ToolTipY);
        
        // .. avvia il timer di chiusura automatica del ToolTip
        setTimeout('ToolTip_Close(' + parSessionId + ',' + parHandle + ',' + ToolTipId + ')' , 4000);
    }
}

/*
* Questa funzione invia l'evento di chiusura di un ToolTip
*/
function ToolTip_Close(parSessionId, parHandle, parToolTipId)
{

    // Se l'evento di OnToolTipOpen è già stato inviato..
    if ((ToolTipShown) && ((parToolTipId == -1) || (parToolTipId == ToolTipId)))
    {
        // .. invia l'evento di chiusura del ToolTip
        SendCommand(parSessionId, parHandle, 1, 'OnHideToolTip', '');
        ToolTipShown = false;
    }
}

/*
* Esegue il Fade del controllo specificato. Al termine del Fade invia un evento di FadeCompleted.
*/
function Control_Fade(parSessionId, parHandle, parInitialOpacity, parFinalOpacity, parStep)
{

    // Recupera il riferimento al controllo sul quale effettuare il fade
    tElement = document.getElementById(parHandle);
    
    // Parserizza i parametri
    tInitialOpacity = parseFloat(parInitialOpacity);
    tFinalOpacity = parseFloat(parFinalOpacity);
    tStep = parseFloat(parStep);
    
    // Se l'elemento è ancora presente nell'HTML..
    if (tElement != null)
    {
    
        // .. se la procedura di Fade non è ancora terminata..
        if(tInitialOpacity != tFinalOpacity)        
        {
        
            // .. calcola il nuovo livello di trasparenza del controllo
            tInitialOpacity += tStep;
            if (tInitialOpacity < 0)
                tInitialOpacity = 0;
            if (tInitialOpacity > 1)
                tInitialOpacity = 1;
             
            if ((tStep > 0) && (tInitialOpacity > tFinalOpacity))
                tInitialOpacity = tFinalOpacity;
            if ((tStep < 0) && (tInitialOpacity < tFinalOpacity))
                tInitialOpacity = tFinalOpacity;
            
            // .. assegna al controllo il livello di trasparenza calcolato
            setOpacity(tElement, tInitialOpacity);
            
            // .. schedula la prossima esecuzione della funzione
            setTimeout('Control_Fade(\'' + parSessionId + '\',\'' +  parHandle + '\',\'' + tInitialOpacity + '\', \'' + tFinalOpacity + '\', \'' + tStep + '\');');
        }
        
        // .. se la procedura di Fade è terminata..
        else
        {
            // .. invia un evento di FadeCompleted
            SendCommand(parSessionId, parHandle, 1, 'OnFadeCompleted', '');
        }
    }
}

/*
*  Funzione cross-browser per l'impostazione del valore Alfa di una immagine
*/
function setOpacity(parElement, parOpacity)
{        
    if(typeof parElement.style.opacity != "undefined")        
        parElement.style.opacity = parOpacity;         
    else if(typeof parElement.style.MozOpacity != "undefined")
        parElement.style.MozOpacity = parOpacity; 
    else if (typeof parElement.style.filter != "undefined") 
        parElement.style.filter = "alpha(opacity=" + Math.round(parOpacity * 100) + ")";
}