// ----------------------------------------------------------------------------
// --- File-Name:    pgf_functions.js
// --- Version:      2.0.1 - PictureGalleryFSO (FSO)
// --- Author:       PFE - Peter Falz
// --- Date-Created: 2004-01-05
// ----------------------------------------------------------------------------
// --- Definieren der JavaScript Funktionen
// ---
// --- Aufruf erfolgt von allen ASP-Seiten
// ----------------------------------------------------------------------------
// --- Changes:      
// ---  
// ----------------------------------------------------------------------------
// --- Bedingungen zur Ausführung
// --- Dieser Version ist ausschliesslich auf IE 6 getestet worden
// ----------------------------------------------------------------------------

// var brwNS4 = (navigator.appName.indexOf("Netscape") >= 0 && parseFloat(navigator.appVersion) >= 4) ? 1 : 0;
// var brwNS6 = (brwNS4 && document.getElementById) ? 1 : 0;
// if (brwNS6)
//     {
// 	brwNS4 = 0;
// 	}
// var brwIE4 = (document.all) ? 1 : 0;
// var brwIE5 = (brwIE4 && navigator.appVersion.indexOf("5.") >= 0) ? 1 : 0;
// var brwIE6 = (brwIE4 && navigator.appVersion.indexOf("6.") >= 0) ? 1 : 0;
    
var pgf_xPos = 0;
var pgf_yPos = 0;

var pgf_xMPos = 0;
var pgf_yMPos = 0;

var pgf_xMPosDown = 0;
var pgf_yMPosDown = 0;

var pgf_xMPosUp = 0;
var pgf_yMPosUp = 0;

var pgf_elem;
var pgf_oForm;

var pgf_bDEBUG = true;

var pgf_bAction = false;
var pgf_oActionElem = null;
var pgf_oMouseUpElem = null;
var pgf_sActionType = '';
var pgf_iActionIndex = -1;

var pgf_iPosDiffX1;
var pgf_iPosDiffY1;
var pgf_iDiffX1;
var pgf_iDiffY1;
var pgf_iPosDiffX2;
var pgf_iPosDiffY2;
var pgf_iDiffX2;
var pgf_iDiffY2;

var pgf_iEventX;
var pgf_iEventY;

var pgf_iLastP1X;
var pgf_iLastP1Y;
var pgf_iLastP2X;
var pgf_iLastP2Y;

var pgf_iOrigWidth;
var pgf_iOrigHeight;

// --- Prüfen, ob DHTML-Variable bereits initialisiert ist
// --- Wenn ja, dann ist diese Anwendung in eine bestehende Anwendung integriert worden
if ( typeof( DHTML ) == "undefined" )
{
    var DHTML = 0, DOM = 0, MS = 0, NS = 0, OP = 0;
        pgf_DHTML_init();
}

function pgf_init()
{
}




// ----------------------------------------------------------------------------
// --- Existing funcitons
// ----------------------------------------------------------------------------
// pgClearField
// pgOpenWindws
// pgQuickWindow
// pgfToggleDisplay
// pgfMouseOver
// pgfMouseDown
// pgfMouseUp
// pgfMouseMove
// pgfMouseOut
// pgfShowEditPictureWindow
// DHTML_init
// pgfShowLayer
// pgfHideLayer
// ----------------------------------------------------------------------------

function pgClearField( sElemID , sDefaultText )
{
    // ------------------------------------------------------------------------
    // --- Description:  If the content of the specified field is the default-
    // ---               text, clear the field.
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- sElemID               : string    : Content of ID
    // --- sDefaultText          : string    : the defaulttext for compare
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
        pgf_elem = document.getElementById( sElemID ); 
        
        if (pgf_elem.value == sDefaultText )
        {
            pgf_elem.value = ""
        }
}
// ----------------------------------------------------------------------------
function pgOpenWindow( URL, XPOS, YPOS, WIDTH, HEIGHT, SCROLL )
    {
    // ------------------------------------------------------------------------
    // --- Description:  
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- strFormName           : string    : 
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    var newWindow = open( URL, "NeuesFenster", "width="+WIDTH+",height="+HEIGHT+",left="+XPOS+",top="+YPOS+",screenX="+XPOS+",screenY="+YPOS+",channelmode=0,dependent=0,directories=0,fullscreen=0,location=0,menubar=0,resizable=0,toolbar=0,status=0,scrollbars="+SCROLL);
    }
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
function pgQuickWindow( strURL )
    {
    // ------------------------------------------------------------------------
    // --- Description:  
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- strFormName           : string    : 
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    pgOpenWindow( strURL, 10, 10, 550, 550, 1 );
    //alert('test');
    }
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
function pgfToggleDisplay( sElemID )
{
    // ------------------------------------------------------------------------
    // --- Description:  Toggle this content of "style.display" between
    // ---               the values "none" and "".
    // ---   ATTENTION:  If the initial value should be "none", do not set this
    // ---               one in CSS, but set it in the i.e. DIV-Tag.
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- imgID                 : string    : Content of ID
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
        pgf_elem = document.getElementById( sElemID ); 

    var bVisibility = ( pgf_elem.style.display != "none" ) ? true : false;
        pgf_elem.style.display = bVisibility ? "none" : "";
}

// ----------------------------------------------------------------------------
function pgfToggleDisplay_Structure( sElemID )
{
    // ------------------------------------------------------------------------
    // --- Description:  Toggle this content of "style.display" between
    // ---               the values "none" and "".
    // ---   ATTENTION:  If the initial value should be "none", do not set this
    // ---               one in CSS, but set it in the i.e. DIV-Tag.
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- imgID                 : string    : Content of ID
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
        pgf_elem = document.getElementById( sElemID ); 

    var bVisibility = ( pgf_elem.style.display != "none" ) ? true : false;
        pgf_elem.style.display = bVisibility ? "none" : "";
        
        bVisibility ? pgfToggleDisplay_Picture( sElemID + "_MINUS" , sElemID + "_PLUS" ) : pgfToggleDisplay_Picture( sElemID + "_PLUS" , sElemID + "_MINUS" );
}

// ----------------------------------------------------------------------------
function pgfToggleDisplay_Picture( sElemID , sElemID2)
{
    // ------------------------------------------------------------------------
    // --- Description:  Toggle this content of "style.display" between
    // ---               the values "none" and "".
    // ---   ATTENTION:  If the initial value should be "none", do not set this
    // ---               one in CSS, but set it in the i.e. DIV-Tag.
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- imgID                 : string    : Content of ID
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
        pgf_elem = document.getElementById( sElemID ); 
    var bVisibility = ( pgf_elem.style.display != "none" ) ? true : false;
        pgf_elem.style.display = bVisibility ? "none" : "";

        pgf_elem = document.getElementById( sElemID2 ); 
        bVisibility = ( pgf_elem.style.display != "none" ) ? true : false;
        pgf_elem.style.display = bVisibility ? "none" : "";
}


// ----------------------------------------------------------------------------
function pgfMouseOver( sElemID , e )
{
    // ------------------------------------------------------------------------
    // --- Description:  WIRD IM MOMENT NICHT VERWENDET
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- imgID                 : string    : Content of ID
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    var iX = e.x;
    var iY = e.y;
        pgf_elem = document.getElementById( sElemID );
        pgf_elem.style.cursor = "hand";
}


// ----------------------------------------------------------------------------
function pgfMouseDown( e )
{
    // ------------------------------------------------------------------------
    // --- Description:  Wird bei "onmousedown"-Event durchlaufen
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- e                     : event     : Eventhandler
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    var sMoveType;

        // --- Ist das Actionflag gesetzt oder es wurde nicht die linke Maustaste betätitgt,
        // --- wird direkt in "pgMouseMove" verzweigt
        if ( pgf_bAction || event.button != 1 )
        { 
            pgfMouseMove( e , '' );
            return false; 
        }
        
        // --- Ermittlung des Eventelementes (2 mal)
        // --- Dies wird in "pgMouseMove" benötigt
        pgf_oActionElem = event.srcElement
        
        // --- Dies wird bei "pgMouseUp" benötigt.
        // --- Erklärung, siehe dort
        pgf_oMouseUpElem = pgf_oActionElem;
        switch ( pgf_oActionElem.parentElement.id )
        {
            // --- Wenn Event durch die Resizer aktiviert wurde
            case 'pge_imgGetBorder0DIV':
            case 'pge_imgGetBorder1DIV':
            case 'pge_imgGetBorder2DIV':
            case 'pge_imgGetBorder3DIV':
            case 'pge_imgGetBorder4DIV':
            case 'pge_imgGetBorder5DIV':
            case 'pge_imgGetBorder6DIV':
            case 'pge_imgGetBorder7DIV':
            
                pgf_iPosDiffX1 = 'resize';
                pgf_iPosDiffY1 = 'resize';
                
                // --- Ermittlung, welcher Resizer betätigt wurde
                pgf_iActionIndex = pgf_oActionElem.parentElement.id.substr( pgf_oActionElem.parentElement.id.indexOf( "DIV" ) - 1 , 1 );
                
                // --- ResizerOFF erhöht die Performance
                pge_oBorder.setResizerOFF( pgf_iActionIndex );
                
                // --- Der Aktionstype wird gesetzt, hier resize
                // --- Der Type der Einzelaktion wird gesetzt, hier ebenfalls resize
                pgf_sActionType = 'resize';
                sMoveType = 'resize';
                break;

            // --- Wenn Event durch die Borderline und ein existierender Bildrahmen (Ausschnitt) aktiviert wurde
            case 'pge_imgCutBorderLine0DIV':
            case 'pge_imgCutBorderLine1DIV':
            case 'pge_imgCutBorderLine2DIV':
            case 'pge_imgCutBorderLine3DIV':
            case 'pge_imgCutDIV':
            
                pgf_iOrigWidth = pge_oBorder.width();
                pgf_iOrigHeight = pge_oBorder.height();
                
                pgf_iPosDiffX1 = 'move';
                pgf_iPosDiffY1 = 'move';

                // --- ResizerOFF erhöht die Performance
                pge_oBorder.setResizerOFF();

                // --- Der Aktionstype wird gesetzt, hier move
                // --- Der Type der Einzelaktion wird gesetzt, hier ebenfalls move
                pgf_sActionType = 'move';
                sMoveType = 'move';
                break;
                
            // --- Es soll ein neuer Bildrahmen (Ausschnitt) erzeugt werden
            default:
            
                // --- ResizerOFF erhöht die Performance
                pge_oBorder.setResizerOFF();

                // --- Die Bildkoordinaten werden auf Null -nicht NULL- gesetzt, da diese Aktion idR. der Ermittlung von P1 gilt
                pge_oBorder.resizeImage( pge_RESIZETONULL );

                // --- Der Aktionstype wird gesetzt, hier create
                // --- Der Type der Einzelaktion wird gesetzt, hier ebenfalls click zur Ermittlung der ersten Punktkoordinaten
                pgf_sActionType = 'create';
                sMoveType = 'click';
                break;
        }
        
        // --- Es findet eine Aktion statt und die alten Bildrahmen (Ausschnitt)-Koordinaten werden gesichert
        pgf_bAction = true;
        pge_oBorder.copyCoords();

        // --- Die eigentlich Steuerung findet in "pgMouseMove" statt
        pgfMouseMove( e , sMoveType );
}

// ----------------------------------------------------------------------------
function pgfMouseUp( e )
{
    // ------------------------------------------------------------------------
    // --- Description:  
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- e                     : event     : Eventhandler
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    var sMoveType;

        // --- Ist das Actionflag nicht gesetzt oder es wurde nicht die linke Maustaste betätigt,
        // --- dann findet keine weiteren Operations statt
        if ( !pg_bAction || event.button != 1 )
        { return false; }

        // --- NICHT VERWENDEN --- pgf_oActionElem = event.srcElement.parentElement;
        
        // --- Das Event auslösende Element muss nicht ermittelt werden, da auf Basis des ermittelten
        // --- Eventelementes in pgfMouseDown verfahren wird
        switch ( pgf_oMouseUpElem.parentElement.id )
        {
            case 'pge_imgGetBorder0DIV':
            case 'pge_imgGetBorder1DIV':
            case 'pge_imgGetBorder2DIV':
            case 'pge_imgGetBorder3DIV':
            case 'pge_imgGetBorder4DIV':
            case 'pge_imgGetBorder5DIV':
            case 'pge_imgGetBorder6DIV':
            case 'pge_imgGetBorder7DIV':

                // --- Der Aktionstype wird gesetzt, hier resize_end
                // --- Der Type der Einzelaktion wird auf leer gesetzt
                pgf_sActionType = 'resize_end';
                sMoveType = '';

                // --- Die Nummer des Resizer's wird ausgeschaltet
                pgf_iActionIndex = -1;

                // --- Die Resizer werden wieder eingeschaltet
                pge_oBorder.setResizerON();
                break;

            case 'pge_imgCutBorderLine0DIV':
            case 'pge_imgCutBorderLine1DIV':
            case 'pge_imgCutBorderLine2DIV':
            case 'pge_imgCutBorderLine3DIV':
            case 'pge_imgCutDIV':

                // --- Wenn der alte Aktiontype nicht "create" dann muss es "move" sein.
                // --- "create" kann auch sein, da "pge_imgCutDIV" sowohl für "create", als auch für "move"
                // --- Events erzeugen kann
                if ( pgf_sActionType != 'create' )
                {
                    // --- Der Aktionstype wird gesetzt, hier create_end
                    // --- Der Type der Einzelaktion wird auf leer gesetzt
                    pgf_sActionType = 'move_end';
                    sMoveType = '';

                    // --- Die Resizer werden wieder eingeschaltet
                    pge_oBorder.setResizerON();
                    break;
                }

            default:

                // --- Der Aktionstype wird gesetzt, hier create_end
                // --- Der Type der Einzelaktion wird gesetzt, hier ebenfalls click zur Ermittlung der zweiten Punktkoordinaten
                pgf_sActionType = 'create_end';
                sMoveType = 'click';

                // --- Die Resizer werden wieder eingeschaltet
                pge_oBorder.setResizerON();
                break;
        }

        // --- Die eigentlich Steuerung findet in "pgMouseMove" statt
        pgfMouseMove( e , sMoveType );

        // --- Die gesicherten Koordinaten werden wieder auf Null -nicht NULL- gesetzt
        pge_oBorder.resetCopyCoords();

        // --- Die Actionflag wird ausgeschaltet
        pgf_bAction = false;
        
        // --- Die Objektvariablen für die Eventsteuerung werden zurückgesetzt
        pgf_oActionElem = null;
        pgf_oMouseUpElem = null;
}

// ----------------------------------------------------------------------------
function pgfMouseMove( e , sType )
    {
    // ------------------------------------------------------------------------
    // --- Description:  
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- e                     : event     : Eventhandler
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    
    var iWidth;
    var iHeight;
    
    var iTemp;
    
    var oEvElem;
    var iX;
    var iY;
    
    var iP1X;
    var iP1Y;
    var iP2X;
    var iP2Y;

        oEvElem = event.srcElement;
        document.getElementById("eTarget").innerText = event.srcElement;
        document.getElementById("srcElement").innerText = oEvElem.parentElement.id
                                                          + '\npixL:' + oEvElem.style.pixelLeft
                                                          + '\npixT:' + oEvElem.style.pixelTop
                                                          + '\noffL:' + oEvElem.offsetLeft
                                                          + '\noffT:' + oEvElem.offsetTop
                                                          + '\nWid :' + oEvElem.width
                                                          + '\nHeig:' + oEvElem.height
                                                          + '\nClip:' + oEvElem.style.clip;
    
        document.getElementById("EventType").innerText = pgf_sActionType + '\n' + sType;
        
        pgf_iEventX = event.x + document.body.scrollLeft;
        pgf_iEventY = event.y + document.body.scrollTop;
        
        iX = pgf_xMPos = pgf_iEventX;
        iY = pgf_yMPos = pgf_iEventY;
    
        // --- Wenn eine dieser Aktiontypen auftritt und P1 ist gesetzt, dann wird das auslösende Event ausgeschaltet, damit
        // --- es nicht von anderen Applikationen oder -teilen, vor allem aber der IE, aufgenommen werden kann. 
        // --- Es sollte erst hier ausgeschaltet werden, da es vorab noch für Berechnung benötigt wird,.
        if ( ( pgf_sActionType == 'create' || pgf_sActionType == 'move' || pgf_sActionType == 'resize' ) && pge_oBorder.m_arPoint[pge_P1][pge_PSET] )
        {
            event.returnValue = false;
        }
            
        switch( pgf_sActionType )
        {
            case 'create':
            case 'create_end':
            // --- Einen Rahmen erstellen
                // --- Wenn die ermittelte Punkteposition kleiner oder größer dem zulässigen Wert ist (Randbereiche des 
                // --- Bildes) werden die entsprechenden absolut möglichen Werte von den Randbereichen zugewiesen
                iX = ( pgf_iEventX < pge_oImage.m_arAbsolute[pge_P1][pge_X] )
                       ? pge_oImage.m_arAbsolute[pge_P1][pge_X]
                       : ( pgf_iEventX > pge_oImage.m_arAbsolute[pge_P2][pge_X] )
                           ?  pge_oImage.m_arAbsolute[pge_P2][pge_X]
                           :  pgf_iEventX
                       ;
                iY = ( pgf_iEventY < pge_oImage.m_arAbsolute[pge_P1][pge_Y] ) 
                       ? pge_oImage.m_arAbsolute[pge_P1][pge_Y]
                       : ( pgf_iEventY > pge_oImage.m_arAbsolute[pge_P2][pge_Y] ) 
                           ?  pge_oImage.m_arAbsolute[pge_P2][pge_Y]
                           :  pgf_iEventY
                       ;
                
                // --- Ist noch kein Punkt (P1 ist der erste zugewiesene Punkt) zugewiesen und der übergebene Type (sType) ist
                // --- "click" (hier durch MouseDown) ausgelöst, wird P1 gesetzt
                if( !pge_oBorder.m_arPoint[pge_P1][pge_PSET] && sType == 'click' )
                {
                    pge_oBorder.setCoords( pge_P1 , iX , iY , pge_SET );
                }
                
                     // --- Ist P2 gesetzt (dieser Zustand kann nur eintreten, wenn auch P1 gesetzt ist) und der übergebene Type ist
                     // --- "click" werden die Koordinaten mit allen Komponenten wie BorderLine und Resizer gelöscht (auf Null -nicht NULL-
                     // --- gesetzt) und der ermittelte Punkt als P1 gesetzt
                else if( pge_oBorder.m_arPoint[pge_P2][pge_PSET] && sType == 'click' )
                    {
                        pge_oBorder.resizeImage( pge_RESIZETONULL );
                        pge_oBorder.setCoords( pge_P1 , iX , iY , pge_SET );
                    }
                    else
                    {
                        // --- Ist P1 gesetzt und P2 nicht, dann wird dieser Teil ausgeführt
                        
                        // --- Ist der übergebene Type "click", dann wird P2 gesetzt, die gespeicherten Koordinaten "gefixed"
                        // --- und im HTML-Formular für eine eventuell weitere Verwendung gespeichert
                        if ( sType == 'click' )
                        {
                            pge_oBorder.setCoords( pge_P2 , iX , iY , pge_SET );
                            pge_oBorder.fixCoords( true );
                            pge_oBorder.setCoordsToForm( pge_FORMFIELD_X , pge_FORMFIELD_Y , pge_FORMFIELD_WIDTH , pge_FORMFIELD_HEIGHT )
                        }
                             // --- Der übergebene Type war nicht "click", P1 ist gesetzt (durch drücken der linken Maustaste), aber die
                             // --- Maustaste wurde noch nicht losgelassen, dann muss der Rahmen entsprechend der Mausbewegung gezeichnet
                             // --- werden. Dies erfolgt durch Speicherung der Mausposition als Punkt P2 mit SET-Wert PRESET
                        else if ( !pge_oBorder.fixCoords() && pge_oBorder.m_arPoint[pge_P1][pge_PSET] ) 
                            { pge_oBorder.setCoords( pge_P2 , iX , iY , pge_PRESET ); }

                        // --- Den Rahmen entsprechend den gespeicherten Punkte darstellen
                        pge_oBorder.resizeImage( pge_RESIZEBYPOINT );
                    }
                break;
            
            case 'move':
            // --- Den Rahmen verschieben    
                    if ( pgf_iPosDiffX1 == 'move' )
                    {
                        // --- Initialisierung der Aktion
                        pgf_iPosDiffX1 = iX;
                        pgf_iPosDiffY1 = iY;
                    }
                    else
                    {
                        // --- Differenzermittlung (Zuweisung in der Addition) und Punktewertermittlung
                        iP1X = pge_oBorder.left( pge_P1 , pge_GETABSOLUTE ) + ( pgf_iDiffX1 = iX - pgf_iPosDiffX1 );
                        iP1Y = pge_oBorder.top( pge_P1 , pge_GETABSOLUTE ) + ( pgf_iDiffY1 = iY - pgf_iPosDiffY1 );

                        iP2X = pge_oBorder.left( pge_P2 , pge_GETABSOLUTE ) + pgf_iDiffX1;
                        iP2Y = pge_oBorder.top( pge_P2 , pge_GETABSOLUTE ) + pgf_iDiffY1;

                        // --- Bei verschieben ohne loslassen der Maustaste, wird die Width/Height bis zur maximal zuletzt
                        // --- gespeicherten Größe wiederhergestellt (Verschiebung des Rahmens in den Randbereich und wieder
                        // --- hinaus
                        iP1X = ( iP1X < pge_oImage.m_arAbsolute[pge_P1][pge_X] ) ? pge_oImage.m_arAbsolute[pge_P1][pge_X] : iP1X;
                        if ( pgf_iOrigWidth > ( iP2X - iP1X ) && pgf_iLastP1X == pge_oImage.m_arAbsolute[pge_P1][pge_X] && ( ( iP1X = iP2X - pgf_iOrigWidth ) < pge_oImage.m_arAbsolute[pge_P1][pge_X] ) )
                        { iP1X = pge_oImage.m_arAbsolute[pge_P1][pge_X]; }
                        
                        iP2X = ( iP2X > pge_oImage.m_arAbsolute[pge_P2][pge_X] ) ? pge_oImage.m_arAbsolute[pge_P2][pge_X] : iP2X;
                        if ( pgf_iOrigWidth > ( iP2X - iP1X ) && pgf_iLastP2X == pge_oImage.m_arAbsolute[pge_P2][pge_X] && ( ( iP2X = iP1X + pgf_iOrigWidth ) > pge_oImage.m_arAbsolute[pge_P2][pge_X] ) )
                        { iP2X = pge_oImage.m_arAbsolute[pge_P2][pge_X]; }

                        iP1Y = ( iP1Y < pge_oImage.m_arAbsolute[pge_P1][pge_Y] ) ? pge_oImage.m_arAbsolute[pge_P1][pge_Y] : iP1Y;
                        if ( pgf_iOrigHeight > ( iP2Y - iP1Y ) && pgf_iLastP1Y == pge_oImage.m_arAbsolute[pge_P1][pge_Y] && ( ( iP1Y = iP2Y - pgf_iOrigHeight ) < pge_oImage.m_arAbsolute[pge_P1][pge_Y] ) )
                        { iP1Y = pge_oImage.m_arAbsolute[pge_P1][pge_Y]; }

                        iP2Y = ( iP2Y > pge_oImage.m_arAbsolute[pge_P2][pge_Y] ) ? pge_oImage.m_arAbsolute[pge_P2][pge_Y] : iP2Y;   
                        if ( pgf_iOrigHeight > ( iP2Y - iP1Y ) && pgf_iLastP2Y == pge_oImage.m_arAbsolute[pge_P2][pge_Y] && ( ( iP2Y = iP1Y + pgf_iOrigHeight ) > pge_oImage.m_arAbsolute[pge_P2][pge_Y] ) )
                        { iP2Y = pge_oImage.m_arAbsolute[pge_P2][pge_Y]; }
                        
                        // --- Wenn die ermittelte Punkteposition kleiner oder größer dem zulässigen Wert ist (Randbereiche des 
                        // --- Bildes) werden die entsprechenden absolut möglichen Werte von den Randbereichen zugewiesen
                        iP1X = ( iP1X < pge_oImage.m_arAbsolute[pge_P1][pge_X] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P1][pge_X] 
                                 : ( iP1X > pge_oImage.m_arAbsolute[pge_P2][pge_X] )
                                     ? pge_oImage.m_arAbsolute[pge_P2][pge_X]
                                     : iP1X;
                                     
                        iP2X = ( iP2X > pge_oImage.m_arAbsolute[pge_P2][pge_X] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P2][pge_X] 
                                 : ( iP2X < pge_oImage.m_arAbsolute[pge_P1][pge_X] ) 
                                     ? pge_oImage.m_arAbsolute[pge_P1][pge_X]
                                     : iP2X;
                        
                        iP1Y = ( iP1Y < pge_oImage.m_arAbsolute[pge_P1][pge_Y] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P1][pge_Y] 
                                 : ( iP1Y > pge_oImage.m_arAbsolute[pge_P2][pge_Y] )
                                     ? pge_oImage.m_arAbsolute[pge_P2][pge_Y]
                                     : iP1Y;
                                     
                        iP2Y = ( iP2Y > pge_oImage.m_arAbsolute[pge_P2][pge_Y] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P2][pge_Y] 
                                 : ( iP2Y < pge_oImage.m_arAbsolute[pge_P1][pge_Y] )
                                     ? pge_oImage.m_arAbsolute[pge_P1][pge_Y]
                                     : iP2Y;   


                        pgf_iPosDiffX1 = iX;
                        pgf_iPosDiffY1 = iY;
                        
                        pge_oBorder.showCoords( iP1X , iP1Y , iP2X , iP2Y , false );

                        pgf_iLastP1X = iP1X;
                        pgf_iLastP2X = iP2X;

                        pgf_iLastP1Y = iP1Y;
                        pgf_iLastP2Y = iP2Y;
                    }
                break;
                
            case 'resize':
            // --- Den Rahmen in der Größe verändern
                    if ( pgf_iPosDiffX1 == 'resize' )
                    {
                        // --- Initialisierung der Aktion
                        pgf_iPosDiffX1 = iX;
                        pgf_iPosDiffY1 = iY;
                    }
                    else
                    {
                        // --- Differenzermittlung
                        pgf_iDiffX1 = iX - pgf_iPosDiffX1;
                        pgf_iDiffY1 = iY - pgf_iPosDiffY1;


                        // --- Entsprechend dem benutzten Resizebutton, werden die Punktewerte zurückgegeben
                        iP1X = ( pgf_iActionIndex == 6 || pgf_iActionIndex == 7 || pgf_iActionIndex == 0 ) ? ( pge_oBorder.left( pge_P1 , pge_GETABSOLUTE ) + pgf_iDiffX1 ) : pge_oBorder.left( pge_P1 , pge_GETABSOLUTE );
                        iP2X = ( pgf_iActionIndex == 2 || pgf_iActionIndex == 3 || pgf_iActionIndex == 4 ) ? ( pge_oBorder.left( pge_P2 , pge_GETABSOLUTE ) + pgf_iDiffX1 ) : pge_oBorder.left( pge_P2 , pge_GETABSOLUTE );

                        iP1Y = ( pgf_iActionIndex == 0 || pgf_iActionIndex == 1 || pgf_iActionIndex == 2 ) ? ( pge_oBorder.top(  pge_P1 , pge_GETABSOLUTE ) + pgf_iDiffY1 ) : pge_oBorder.top(  pge_P1 , pge_GETABSOLUTE );
                        iP2Y = ( pgf_iActionIndex == 4 || pgf_iActionIndex == 5 || pgf_iActionIndex == 6 ) ? ( pge_oBorder.top(  pge_P2 , pge_GETABSOLUTE ) + pgf_iDiffY1 ) : pge_oBorder.top(  pge_P2 , pge_GETABSOLUTE );

                        // --- Wenn die ermittelte Punkteposition kleiner oder größer dem zulässigen Wert ist (Randbereiche des 
                        // --- Bildes) werden die entsprechenden absolut möglichen Werte von den Randbereichen zugewiesen
                        iP1X = ( iP1X < pge_oImage.m_arAbsolute[pge_P1][pge_X] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P1][pge_X] 
                                 : ( iP1X > pge_oImage.m_arAbsolute[pge_P2][pge_X] )
                                     ? pge_oImage.m_arAbsolute[pge_P2][pge_X]
                                     : iP1X;
                                     
                        iP2X = ( iP2X > pge_oImage.m_arAbsolute[pge_P2][pge_X] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P2][pge_X] 
                                 : ( iP2X < pge_oImage.m_arAbsolute[pge_P1][pge_X] ) 
                                     ? pge_oImage.m_arAbsolute[pge_P1][pge_X]
                                     : iP2X;
                        
                        iP1Y = ( iP1Y < pge_oImage.m_arAbsolute[pge_P1][pge_Y] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P1][pge_Y] 
                                 : ( iP1Y > pge_oImage.m_arAbsolute[pge_P2][pge_Y] )
                                     ? pge_oImage.m_arAbsolute[pge_P2][pge_Y]
                                     : iP1Y;
                                     
                        iP2Y = ( iP2Y > pge_oImage.m_arAbsolute[pge_P2][pge_Y] ) 
                                 ? pge_oImage.m_arAbsolute[pge_P2][pge_Y] 
                                 : ( iP2Y < pge_oImage.m_arAbsolute[pge_P1][pge_Y] )
                                     ? pge_oImage.m_arAbsolute[pge_P1][pge_Y]
                                     : iP2Y;   

                        pgf_iPosDiffX1 = iX;
                        pgf_iPosDiffY1 = iY;

                        pge_oBorder.showCoords( iP1X , iP1Y , iP2X , iP2Y , false ); // nicht fixen
                    }
                break;
        }
            
        
        // --- Ist die Aktion abgeschlossen, werden die gespeicherten Koordinaten "gefixed" und das der Rahmen oder betreffende Objekt
        // --- nochmals auf dem Bildschirm ausgegeben und die Koordinaten in die HTML-Seite für eventuelle spätere Verarbeitung
        // --- gespeichert
        if ( pgf_sActionType.indexOf( '_end' ) > 0 )
        {
            pge_oBorder.fixCoords( true );
            pge_oBorder.resizeImage( pge_RESIZEBYPOINT );
            pgf_bAction = false;
            // pgf_sActionType = '';
            pgf_oActionElem = null;
            pge_oBorder.setCoordsToForm( pge_FORMFIELD_X , pge_FORMFIELD_Y , pge_FORMFIELD_WIDTH , pge_FORMFIELD_HEIGHT )
        }
    
        // --- Sind die Punkte P1 und P2 gleich und die Koordinaten wurden "gefixed", also die Aktion ist abgeschlossen,
        // --- dann wird der Rahmen mit den dazugehörigen Komponenten wie BorderLine und Resizer ausgeblendet
        if ( ( pge_oBorder.m_arPoint[pge_P1][pge_X] == pge_oBorder.m_arPoint[pge_P2][pge_X] ) 
           && ( pge_oBorder.m_arPoint[pge_P1][pge_Y] == pge_oBorder.m_arPoint[pge_P2][pge_Y] ) 
           // && ( pge_oBorder.m_arPoint[pge_P1][pge_PSET] )
           // && ( pge_oBorder.m_arPoint[pge_P2][pge_PSET] )
           && ( pge_oBorder.fixCoords() )
           )
        {
            pge_oBorder.resizeImage( pge_RESIZETONULL );
        }
    
    
        document.getElementById("posMouseX").innerText = pgf_xMPos;
        document.getElementById("posMouseY").innerText = pgf_yMPos;
    
        document.getElementById("posMouseXDownO").innerText = pge_oBorder.m_arPoint[ pge_P1 ][ pge_X ] + '\n' + pge_oBorder.m_arPoint[ pge_P1 ][ pge_Y ];
        document.getElementById("posMouseYDownO").innerText = pge_oBorder.m_arPoint[ pge_P1 ][ pge_PSET ];
        document.getElementById("posMouseXUpO").innerText = pge_oBorder.m_arPoint[ pge_P2 ][ pge_X ] + '\n' + pge_oBorder.m_arPoint[ pge_P2 ][ pge_Y ];
        document.getElementById("posMouseYUpO").innerText = pge_oBorder.m_arPoint[ pge_P2 ][ pge_PSET ] + '\n\n\n' + pge_oBorder.m_bFixed;
    }

// ----------------------------------------------------------------------------
function pgfMouseOut( e )
{
    // ------------------------------------------------------------------------
    // --- Description:  WIRD IM MOMENT NICHT VERWENDET
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- imgID                 : string    : Content of ID
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    // alert('MO');
        if ( !pg_bAction )
        { return false; }
        pgf_sActionType = 'end';

        pge_oBorder.resizeImage( pge_RESIZEBYPOINT );
        pgf_sActionType = '';
        pge_oBorder.setCoordsToForm( pge_FORMFIELD_X , pge_FORMFIELD_Y , pge_FORMFIELD_WIDTH , pge_FORMFIELD_HEIGHT )
}

// ----------------------------------------------------------------------------
function pgfShowEditPictureWindow( sLinkParameter )
{
    // ------------------------------------------------------------------------
    // --- Description:  Show a popup with the file explorer
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- sLinkParameter        : string    : Linkparameter for filename
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------

    var sWindowURL      = "picgallery/edit.asp";
    var intShowScrollbar  = 0;

    var iWindowWidth    = screen.width - 50;
    var iWindowHeight   = screen.height - 100;
    var iPosLeft = ( screen.width  / 2 ) - iWindowWidth / 2;
    var iPosTop  = ( screen.height / 2 ) - iWindowHeight / 2 - 25;

    var wndHelp = window.open( sWindowURL + '?FILE=' + sLinkParameter , "none" , 'resizeable=no,scrollbars=yes,width=' + iWindowWidth + ',height=' + iWindowHeight + ',titlebar=no,screenX=' + iPosLeft + ',screenY=' + iPosTop + ',left=' + iPosLeft + ',top=' + iPosTop );

}

// ----------------------------------------------------------------------------
function pgf_DHTML_init()
    // ------------------------------------------------------------------------
    // --- Description:  Ermittlung des Browsertypes für die Generierung von 
    // ---               von CrossBrowser-Applikationen
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- -nothing-
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
{
        if (window.opera)
        {
            OP = 1;
        }
        if(document.getElementById)
        {
            DHTML = 1;
            DOM = 1;
        }
        if(document.all && !OP)
        {
            DHTML = 1;
            MS = 1;
        }
        if(window.netscape && window.screen && !DOM && !OP)
        {
            DHTML = 1;
            NS = 1;
        }
}
// ----------------------------------------------------------------------------
function pgfShowLayer( strLayer )
    {
    // ------------------------------------------------------------------------
    // --- Description:  
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- strFormName           : string    : 
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    if( document.getElementById )
        {
        if( document.getElementById( strLayer ).style )
            {
            objLayer = document.getElementById( strLayer ).style;
            }
        else
            {
            objLayer = document.getElementById( strLayer );
            }
        }
    else
        {
        objLayer = eval( 'document.' + strLayer );
        }
    
    if(brwIE4||brwIE5||brwIE6||brwNS6)
        {
        objLayer.visibility = 'visible';
        }
    
    if(brwNS4)
        {
        document.layers[strLayer ].visibility = 'show';
        }
    
    }
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
function pgfHideLayer( strLayer )
    {
    // ------------------------------------------------------------------------
    // --- Description:  
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- strFormName           : string    : 
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------
    if( document.getElementById )
        {
        if( document.getElementById( strLayer ).style )
            {
            objLayer = document.getElementById( strLayer ).style;
            }
        else
            {
            objLayer = document.getElementById( strLayer );
            }
        }
    else
        {
        objLayer = eval( 'document.' + strLayer );
        }

    if(brwIE4||brwIE5||brwIE6||brwNS6)
        {
        objLayer.visibility = 'hidden';
        }

    if(brwNS4)
        {
        document.layers[strLayer ].visibility = 'hide';
        }

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

// ----------------------------------------------------------------------------
function pgfShowMessage( strMessage )
    {
    // ------------------------------------------------------------------------
    // --- Description:  Shows a popup with the given message
    // ------------------------------------------------------------------------
    // --- Parametername         : Datatype  : Use
    // ------------------------------------------------------------------------
    // --- strMessage            : string    : Message to show
    // ------------------------------------------------------------------------
    // --- Return                : -nothing-
    // ------------------------------------------------------------------------

    if( strMessage != "" )
        {
        alert( strMessage );
        }

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