/**
 * Passepartout - Rechner
 */



 function berechne_single(noselector)
 {
    //Berechnet einen Auschnitt
    //Und zeigt ihn entstprechend an
    //TRUE heisst das die Position refrsesh wird
    //FALSE heisst keien Position refrshen

    hohegesamtlayer = new Layer_Ref('hohe_gesamt');
    breitegesamtlayer = new Layer_Ref('breite_gesamt');
   // warhinweiselayer = new Layer_Ref('hinweise');
    ausschnittx = new Layer_Ref('auschnittbreite');
    ausschnitty = new Layer_Ref('auschnitthohe');

    abstandoben = new Layer_Ref('abstand_oben');
    abstandlinks = new Layer_Ref('abstand_links');
    abstandrechts = new Layer_Ref('abstand_rechts');
    abstandunten = new Layer_Ref('abstand_unten');

     auschnittlayer = new Layer_Ref('ausschnitt');







    preisfield = new Layer_Ref('preis');

    totalpreisflied = new Layer_Ref('totalpreis');

    stcklayer = new Layer_Ref('stck');
    stcke = stcklayer.value;

    hohegesamt = hohegesamtlayer.value;
    breitegesamt = breitegesamtlayer.value;


    ausschnittlayeruebergabex = ausschnittx.value;
    ausschnittlayeruebergabey = ausschnitty.value;

    abstandobenwert = abstandoben.value;
    abstandlinkswert = abstandlinks.value;
    abstandrechtswert = abstandrechts.value;
    abstanduntenwert = abstandunten.value;


    //Init
   // warhinweiselayer.write(' ');


    //Fehlerprüfungen

	if(hohegesamt == 1000)
	{
	  if(breitegesamt > 700)
	  {
	  	alert('Rahmen zu gross!');  
	  	return false;
	  }
	}
	if(hohegesamt > 1000)
	{
	  alert('Rahmen zu gross!');
	}
	if(breitegesamt == 1000)
	{
	  if(hohegesamt > 700)
	  {
	  	alert('Rahmen zu gross!');  
	  	return false;
	  }
	}
	if(breitegesamt > 1000)
	{
	  alert('Rahmen zu gross!');
	}
	
	

    if(hohegesamt < 90) {
    //    warhinweiselayer.write('<b>Die Höhe muss mind. 90 mm Betragen!</b>');

        preisfield.value = "FEHLER!!!";
        totalpreisflied.value = "FEHLER!!!";
        return false;
      }

    if(breitegesamt < 90) {
     //   warhinweiselayer.write('<b>Die Breite muss mind. 90 mm Betragen!</b>');
        preisfield.value = "FEHLER!!!";
         totalpreisflied.value = "FEHLER!!!";
        return false;
      }


      //Der Ausschnitt kann nicht größer als das Papier sein

      if(ausschnittlayeruebergabex > (breitegesamt - 20) )
      {
       //     warhinweiselayer.write('<b>Ausschnitt zu gros!!!</b>');
        preisfield.value = "FEHLER!!!";
         totalpreisflied.value = "FEHLER!!!";
        return false;
      }

      if(ausschnittlayeruebergabey > (hohegesamt - 20) )
      {
         //   warhinweiselayer.write('<b>Ausschnitt zu gros!!!</b>');
        preisfield.value = "FEHLER!!!";
         totalpreisflied.value = "FEHLER!!!";
        return false;
      }




    //Ausrechnene der Positionseingaben
    //Differenz Ausschnitt / Papier = Rahmen
    differenzhohe = ((hohegesamt - ausschnittlayeruebergabey) / 2);
    differenzbreite = ((breitegesamt - ausschnittlayeruebergabex) / 2);


    if(noselector == false)
    {
    abstandoben.value = differenzhohe;
    abstandunten.value = differenzhohe;

    abstandrechts.value = differenzbreite;
    abstandlinks.value = differenzbreite;
  }
    //Abstand des Ausschints richtig setzten
    //alert(auschnittlayer.style.top);

    //auschnittlayer.style.top = differenzhohe;






     hiddenpreis = new Layer_Ref('direktpreis');

    gesamt = berechne_Preis(hohegesamt,breitegesamt,1);
    hiddenpreis.value = gesamt;
 //   var totalpreiseur   = Math.pow(10, n);

   // totalpreiseur = Math.round;
    //totalprieseur = parseInt(totalprieseur);
   // totalprieseur = Math.round(totalpreiseur);
    

    totalpreiseur = parseInt( (gesamt * stcke) * 100 + .5 ) / 100;
    
    gesamt = gesamt + " EUR";
    preisfield.value = gesamt;


    totalpreiseur = totalpreiseur + " EUR";
    totalpreisflied.value = totalpreiseur;
    hohegesamtlayer.value =  hohegesamt;
    breitegesamtlayer.value = breitegesamt;


     rueckgabewert = new Array();

     rueckgabewert = SetPaper(breitegesamt,hohegesamt); //Das Papier setzten
   // SetAusschnitt(ausschnittlayeruebergabex,ausschnittlayeruebergabey);

    hohenabzug = SetAusschnitt(ausschnittlayeruebergabex,ausschnittlayeruebergabey,rueckgabewert);

    //Differenzhöhe RAND in Pixeln

    differenzhohe =  ((rueckgabewert[1] /rueckgabewert[3]) * differenzhohe );
    differenzbreite = ((rueckgabewert[0] /rueckgabewert[2]) * differenzbreite );



    auschnittlayer.moveTo(new Coord(differenzbreite,differenzhohe));

    rueckgabe = new Array();
    rueckgabe[0] = differenzbreite;
    rueckgabe[1] =  differenzhohe;
    rueckgabe[2] = rueckgabewert[0];
    rueckgabe[3] = rueckgabewert[1];
    rueckgabe[4] = rueckgabewert[2];
    rueckgabe[5] = rueckgabewert[3];
    return rueckgabe;


 }

 function SetAusschnitt(x,y,rueckgabewerte)
 {
   //Den Ausschnitt setzten uns Positionieren, relativ zum ersten versteht sich


   maxX = rueckgabewerte[0]; //X Wert des Rahmens in Pixel
   maxY = rueckgabewerte[1]; //Y Wert des Rahmens in Pixel

   currentsizex = rueckgabewerte[2]; //Größe des Rahmens X in mm
   currentsizey = rueckgabewerte[3]; //Größe des Rahmens Y in mm


   //Größe des Ausschnitss richtig anzeigen
   wertx = ((maxX / currentsizex) * x );
   werty = ((maxY / currentsizey) * y );
   //alert(wertx);

   kreisansicht = new Layer_Ref('inlinebild');
   auschnittlayer = new Layer_Ref('ausschnitt');
   rundlayer = new Layer_Ref('rund');

   if(rundlayer.checked == true)
   {
        auschnittlayer.style.backgroundColor = '#ffffff';

   }
   else
   {
        auschnittlayer.style.backgroundColor = '#df0134';

   }


   kreisansicht.style.width = wertx+ 'px';
   kreisansicht.style.height = werty +'px';

   auschnittlayer.style.width = wertx+ 'px';
   auschnittlayer.style.height = werty+ 'px';

   return werty;
 }


 function SetPaper(x,y)
 {
   //Papiergroße setzten
   //Umrechnen max Breite beträgt 200px / maximale höhe ebenfalls
   //Diese Anzeige dient dazu das Verhältnis anzuzeigen, nicht die Korrekte grösee

   maxX = 200;
   maxY = 88;

   relation = ( x / y);
   if (relation == 1)
   {
        sizex = 88;
        sizey = 88;
   }

   if (relation < 1)
   {
        //Hochkant das heisst Y und X der RELATIONSTEIL

        sizey = 88;
        sizex = (88 * relation);

   }

   if (relation > 1)
   {
        //Hochkant das heisst Y und X der RELATIONSTEIL

        sizex = 88;
        sizey = (88 / relation);
   }



   paper = new Layer_Ref('passmain');
   paper.style.width = sizex+ 'px';
   paper.style.height = sizey +'px';

   //Set Ausschnit, der Ausschnitt muss RELATIV zu der RELATIVEN Paierform berechnet werden
   rueckgabe = new Array();
   rueckgabe[0] = sizex;
   rueckgabe[1] = sizey;
   rueckgabe[2] = x;
   rueckgabe[3] = y;
   return rueckgabe;



 }



 function setzePosNeu(Aufruf)
 {
   //Soll die Position neu ausrechnen
   //Das Inputfeld mit dem Aufruf
   //Braucht AbstandTotal horizontal und vertikal


 werte = berechne_single(true);
   abstandoben = new Layer_Ref('abstand_oben');
   abstandunten = new Layer_Ref('abstand_unten');
   abstandklinks = new Layer_Ref('abstand_links');
   abstandrechts = new Layer_Ref('abstand_rechts');

   breitegesamt = new Layer_Ref('breite_gesamt');
   hohegesamt = new Layer_Ref('hohe_gesamt');

    ausschnittlayerbreite = new Layer_Ref('auschnittbreite');
    ausschnittlayerhohe= new Layer_Ref('auschnitthohe');

   unten = abstandunten.value;
   oben = abstandoben.value;
   links = abstandklinks.value;
   rechts = abstandrechts.value;


    //4 Breite in mm vom Passpartout
    //5 höhe  in mm vom Passpartout

    //3 Abstand GESASMT OBEN + UNTEN
    //4 Abstand GESAMT LINKS + RECHTS


    if(unten < 10)
    {
	WriteError('Rand zu dünn!');
	return false;
}

       if(oben < 10)
    {
	WriteError('Rand zu dünn!');
	return false;
}
       if(links < 10)
     {
	WriteError('Rand zu dünn!');
	return false;
}
       if(rechts < 10)
     {
	WriteError('Rand zu dünn!');
	return false;
}
     breitegesamt = new Layer_Ref('breite_gesamt');
   hohegesamt = new Layer_Ref('hohe_gesamt');

    gesamtbreite = breitegesamt.value;
    gesamthohe = hohegesamt.value;

	//Werte neu berechnen und ausgeben

	if(Aufruf == 'unten')
    {
            hoheenwert = ausschnittlayerhohe.value;
              neuerwert = (gesamthohe - unten - hoheenwert);
		  if(neuerwert > (gesamthohe - 10))
		{

			WriteError('Rand zu dünn!');
			return false;
  		}
  		if(neuerwert < 10)
  		{

			WriteError('Rand zu dünn!');
			return false;
  		}
        abstandoben.value = neuerwert;

    }

	if(Aufruf == 'oben')
    {
// alert(neuerwert);
//alert(gesamthohe);
//alert('hallo');

 hoheenwert = ausschnittlayerhohe.value;
            neuerwert = (gesamthohe - oben - hoheenwert);


		  if(neuerwert > (gesamthohe - 10))
		{

			WriteError('Rand zu dünn!');
			return false;
  		}
  		if(neuerwert < 10)
  		{

			WriteError('Rand zu dünn!');
			return false;
  		}
        abstandunten.value = neuerwert;
        
    }
    if(Aufruf == 'links')
    {
breiteausschnitt = ausschnittlayerbreite.value;
            neuerwert = (gesamtbreite - links - breiteausschnitt);
		  if(neuerwert > (gesamtbreite - 10))
		{

			WriteError('Rand zu dünn!');
			return false;
  		}
  		if(neuerwert < 10)
  		{

			WriteError('Rand zu dünn!');
			return false;
  		}
        abstandrechts.value = neuerwert;
    }
    
    if(Aufruf == 'rechts')
    {
    breiteausschnitt = ausschnittlayerbreite.value;
    neuerwert = (gesamtbreite - rechts - breiteausschnitt);
		  if(neuerwert > (gesamtbreite - 10 - breiteausschnitt))
		{
			WriteError('Rand zu dünn!');
			return false;
  		}
  		if(neuerwert < 10)
  		{

			WriteError('Rand zu dünn!');
			return false;
  		}
        abstandlinks.value = neuerwert;
    }

    //NeuePosition anzeigen
	//Muss wissen was 1mm in Pixel ist


    //Verhältnis Pixel zu mm

    relation = (werte[2] / werte[4]);


    //Abstand von oben =
    abstandvonoben = (abstandoben.value * relation);
    abstandvonlinks = (abstandlinks.value * relation);
    //alert(abstandvonlinks);

     auschnittlayer = new Layer_Ref('ausschnitt');
	auschnittlayer.moveTo(new Coord(abstandvonlinks,abstandvonoben));
}


function WriteError(Fehler){

    preisfield = new Layer_Ref('preis');
    totalpreisflied = new Layer_Ref('totalpreis');
  //  warhinweiselayer = new Layer_Ref('hinweise');


     preisfield.value = "FEHLER!";
    totalpreisflied.value = "FEHLER!";
  //  warhinweiselayer.value = Fehler;
  //  alert(warhinweiselayer.value);
}


 function berechne_Preis(werty,wertx,Ausschnitte)
 {
   
   werty = werty / 10;
   wertx = wertx / 10;
   
   //alert(wertx);
   //alert(werty);
     SizeXArray = new Array();
   SizeYArray = new Array();
   PreisArray = new Array();

//modifiziert ch 01.01.08 Folge aufsteigend x, neue Preise
   SizeXArray[0] = 9;
   SizeYArray[0] = 9;
   PreisArray[0] = 1.94;
   
   SizeXArray[1] = 10;
   SizeYArray[1] = 15;
   PreisArray[1] = 1.94;

   SizeXArray[2] = 13;
   SizeYArray[2] = 18;
   PreisArray[2] = 2.15;
   
   SizeXArray[3] = 15;
   SizeYArray[3] = 21;
   PreisArray[3] = 2.37;
   
   SizeXArray[4] = 18;
   SizeYArray[4] = 24;
   PreisArray[4] = 2.64;
   
   SizeXArray[5] = 20;
   SizeYArray[5] = 20;
   PreisArray[5] = 2.57;
   
   SizeXArray[6] = 21; 
   SizeYArray[6] = 30;
   PreisArray[6] = 4.39;
   
   SizeXArray[7] = 24; 
   SizeYArray[7] = 30;
   PreisArray[7] = 4.50;
   
   SizeXArray[8] = 24; 
   SizeYArray[8] = 32;
   PreisArray[8] = 4.50;
      
   SizeXArray[9] = 25;
   SizeYArray[9] = 60;
   PreisArray[9] = 3.64;
   
   SizeXArray[10] = 28; 
   SizeYArray[10] = 35;
   PreisArray[10] = 4.76;
     
   SizeXArray[11] = 30; 
   SizeYArray[11] = 30;
   PreisArray[11] = 4.62;
   
   SizeXArray[12] = 30; 
   SizeYArray[12] = 40;
   PreisArray[12] = 4.60;
   
    SizeXArray[13] = 35; 
   SizeYArray[13] = 50;
   PreisArray[13] = 4.92;
   
    SizeXArray[14] = 40;
   SizeYArray[14] = 40;
   PreisArray[14] = 4.87;
   
    SizeXArray[15] = 40; 
   SizeYArray[15] = 50;
   PreisArray[15] = 5.12;
   
    SizeXArray[16] = 40; 
   SizeYArray[16] = 60;
   PreisArray[16] = 5.66;
   
   SizeXArray[17] = 40;
   SizeYArray[17] = 100;
   PreisArray[17] = 7.83;
   
    SizeXArray[18] = 45; 
   SizeYArray[18] = 60;
   PreisArray[18] = 5.94;
      
    SizeXArray[19] = 50; 
   SizeYArray[19] = 50;
   PreisArray[19] = 5.76;
   
     SizeXArray[20] = 50; 
   SizeYArray[20] = 60;
   PreisArray[20] = 6.10;
   
     SizeXArray[21] = 50; 
   SizeYArray[21] = 65;
   PreisArray[21] = 6.27;
   
   SizeXArray[22] = 50; 
   SizeYArray[22] = 70;
   PreisArray[22] = 6.46;
   
    SizeXArray[23] = 56;
   SizeYArray[23] = 71;
   PreisArray[23] = 6.80;
      
    SizeXArray[24] = 60;
   SizeYArray[24] = 60;
   PreisArray[24] = 6.52;

  SizeXArray[25] = 60;
   SizeYArray[25] = 80;
   PreisArray[25] = 7.37;
      
    SizeXArray[26] = 70; 
   SizeYArray[26] = 70;
   PreisArray[26] = 7.47;
   
    SizeXArray[27] = 70; 
   SizeYArray[27] = 90;
   PreisArray[27] = 9.02;
   
    SizeXArray[28] = 70; 
   SizeYArray[28] = 100;
   PreisArray[28] = 9.54;   
 
   //wertX als den kleinsten wert 
   
   tempwertx = wertx;
   tempwerty = werty;
   
   if(tempwerty > tempwertx)	
   {
     //Tauschen
	  werty = tempwertx; 
	  wertx = tempwerty; 
   }
   
   //Anhand der X Achse aussuchen
   
   for(i=0;i<29;i++) //modifiziert ch 03.07.07
   {
    //alert(SizeXArray[i]);
    //alert(wertx);
      if(SizeYArray[i] >= wertx)
      {
	   if(SizeXArray[i] >= werty)
       {
	      // alert(i);
		   return PreisArray[i];   
	       
	   }
	  }
	  
  } 
  return PreisArray[23];  
  
  }
  /// Für Doppel-Passepartout
  
  
 /*function isNoOverlap (minXA, maxXA, minYA, maxYA, minXB, maxXB, minYB, maxYB, spacing) {
		if (maxXA < minXB) maxXA = maxXA + spacing;
		else if (minXA > maxXB) maxXB = maxXB + spacing;
		if (maxYA < minYB) maxYA = maxYA + spacing;
		else if (minYA > maxYB) maxYB = maxYB + spacing;

		return ((maxXA <= minXB) || (minXA >= maxXB) || (maxYA <= minYB) || (minYA >= maxYB));
	}

	function isInArea (maxX, maxY, widthArea, heightArea) {
		return ((maxX <= widthArea) && (maxY <= heightArea));
	}

	function checkAreas (heightArea, widthArea,
					  	intervalTopA, intervalLeftA, heightA, widthA,
					   	intervalTopB, intervalLeftB, heightB, widthB,
					    spacing) {

		var minXA = intervalLeftA;
		var maxXA = intervalLeftA + widthA;
		var minYA = intervalTopA;
		var maxYA = intervalTopA + heightA;
		var minXB = intervalLeftB;
		var maxXB = intervalLeftB + widthB;
		var minYB = intervalTopB;
		var maxYB = intervalTopB + heightB;

		if ( isInArea (maxXA, maxYA, widthArea, heightArea) &&
				 isInArea (maxXB, maxYB, widthArea, heightArea) &&
				 isNoOverlap (minXA, maxXA, minYA, maxYA, minXB, maxXB, minYB, maxYB, spacing)) {
			return true;
		} else if (!isInArea (maxXA, maxYA, widthArea, heightArea))	{
			return 'Ausschnitt 1 passt nicht in Passepartout!';
		} else if (!isInArea (maxXB, maxYB, widthArea, heightArea)) {
			return 'Ausschnitt 2 passt nicht ins Passepartout!';
		} else {
			return 'Die Ausschnitte überlappen sich!';
		}
	} */
	
	 function testPosition (intervalTopA, intervalLeftA, heightA, widthA,
		 					intervalTopB, intervalLeftB, heightB, widthB) {
	 
	 	var minXA = parseInt(intervalLeftA);		
		var maxXA = minXA + parseInt(widthA);
		var minYA = parseInt(intervalTopA);		
		var maxYA = minYA + parseInt(heightA);
		var minXB = parseInt(intervalLeftB);		
		var maxXB = minXB + parseInt(widthB);
		var minYB = parseInt(intervalTopB);		
		var maxYB = minYB + parseInt(heightB);		
	 	 	
		if ((maxXA < minXB) || (minXA > maxXB)) {
			return 'breite';
		}
		else if ((maxYA < minYB) || (minYA > maxYB)) {
			return 'hohe';
		}
		else {
			return 1;
		}
	 }
	
	
	 function isNoOverlap (minXA, maxXA, minYA, maxYA, minXB, maxXB, minYB, maxYB, spacing) {	
	 
	  //  alert (minXB);
	  //alert ('ende');
		if (maxXA < minXB) maxXA = maxXA + spacing;
		else if (minXA > maxXB) maxXB = maxXB + spacing;
		if (maxYA < minYB) maxYA = maxYA + spacing;
		else if (minYA > maxYB) maxYB = maxYB + spacing;	
		
		//alert (maxXA);
		//alert (minXB);
		//if (maxXA <= minXB) alert ('ja');
		
		if ((maxXA <= minXB) || (minXA >= maxXB)) {
			return 'breite';
		}
		else if ((maxYA <= minYB) || (minYA >= maxYB)) {
			return 'hohe';
		}
		else {
			//alert ('Die Ausschnitte überlappen sich!');
			return false;		
		}	
	}
	
	function isInArea (maxX, maxY, heightArea, widthArea) {
		
		//alert (maxX);
		//alert (maxY);		
		//alert (heightArea);
		//alert (widthArea);
		//alert ('breack');		
		
		return ((maxX <= (widthArea - 10)) && (maxY <= (heightArea - 10)));
	}
   
   
   function validateParameter (heightArea, widthArea, 
					  		   intervalTopA, intervalLeftA, heightA, widthA,
					   		   intervalTopB, intervalLeftB, heightB, widthB,						
					    	   spacing) {       
   }
   
   //Die höhe und breite sind bei der übergabe verwechselt worden, sollte jemals korregiert werden - widthArea und heightArea tauschen  
   function checkAreas (heightArea, widthArea, 
					  	intervalTopA, intervalLeftA, heightA, widthA,
					   	intervalTopB, intervalLeftB, heightB, widthB,						
					    spacing) { 
					   			
					   		
		var minXA = parseInt(intervalLeftA);		
		var maxXA = minXA + parseInt(widthA);
		var minYA = parseInt(intervalTopA);		
		var maxYA = minYA + parseInt(heightA);
		var minXB = parseInt(intervalLeftB);		
		var maxXB = minXB + parseInt(widthB);
		var minYB = parseInt(intervalTopB);		
		var maxYB = minYB + parseInt(heightB);	
		
		//alert (heightArea);
		//alert (widthArea);
		
		spacing = parseInt(spacing);		
		if ((!spacing) || (spacing < 10)) { 
			spacing = 10;
		}	
		
		//heightArea = heightArea - 20;
		//widthArea = widthArea - 20;		
			
		if (!isInArea (maxXA, maxYA, heightArea, widthArea)) {			     
				//alert ('Der Ausschnitt 1 passt nicht in den Rahmen!');
				return false;
		}	else if (!isInArea (maxXB, maxYB, heightArea, widthArea)) {
				//alert ('Der Ausschnitt 2 passt nicht in den Rahmen!');
				return false;
		}  else {		
			return isNoOverlap (minXA, maxXA, minYA, maxYA, minXB, maxXB, minYB, maxYB, spacing); 
		}			
				
		
	} 	
	
	function berechne_doppel()
	{
        //Zeige den Hintergrund relativ
         hohegesamtlayer = new Layer_Ref('hohe_gesamt');
         breitegesamtlayer = new Layer_Ref('breite_gesamt');
         
         if(hohegesamtlayer.value == 1000)
         {
           if(breitegesamtlayer.value > 700)
           {
           	//alert('Rahmen zu groß');
           	return 0;
           }
           
         }
         if(hohegesamtlayer.value > 1000)
         {
            //alert('Rahmen zu groß');
         }
        
        
          if(breitegesamtlayer.value == 1000)
         {
           if(hohegesamtlayer.value > 700)
           {
           //	alert('Rahmen zu groß');
           	return 0;
           }
           
         }
         if(breitegesamtlayer.value > 1000)
         {
           // alert('Rahmen zu groß');
         }
         

        
         papierdaten = SetPaper(breitegesamtlayer.value,hohegesamtlayer.value);
          
         preisfield = new Layer_Ref('preis');

         totalpreisflied = new Layer_Ref('totalpreis');
        direktpreisfeld = new Layer_Ref('direktpreis');
         stcklayer = new Layer_Ref('stck');

          gesamt = parseInt( (berechne_Preis(breitegesamtlayer.value,hohegesamtlayer.value,1) + 1.50) * 100 + .5 ) / 100;
direktpreisfeld.value = gesamt;
totalpreiseur = parseInt( (gesamt * stcklayer.value) * 100 + .5 ) / 100;
         
    gesamt = gesamt + " EUR";
    preisfield.value = gesamt;


    totalpreiseur = totalpreiseur + " EUR";
    totalpreisflied.value = totalpreiseur;


    //Verschieben vom Layer

    
    


     //Die beiden Divs größengerecht anzeigen


     //Die beiden Divs setzten

     	//erster.moveTo(new Coord(0,1));
     	//

        erstebreite = new Layer_Ref('x1');
        erstehohe  = new Layer_Ref('y1');
         
        zweitebreite = new Layer_Ref('x2');
        zweitehohe  = new Layer_Ref('y2');
        
        //alert(erstehohe.value -(-20));
        if((erstehohe.value -(-20)) >= hohegesamtlayer.value)
        {
            //alert('Auschnitt 1 ist zu groß!');
            return 0;
        }
        if((erstebreite.value -(20)) >= breitegesamtlayer.value)
        {
            //alert('Auschnitt 1 ist zu groß!');
            return 0;
        }
        
        
          if((zweitehohe.value -(-20)) >= hohegesamtlayer.value)
        {
            //alert('Auschnitt 2 ist zu groß!');
            return 0;
        }
        if((zweitebreite.value -(20)) >= breitegesamtlayer.value)
        {
            //alert('Auschnitt 2 ist zu groß!');
            return 0;
        }
        
        

     	SetzeBeideAusschnitte(erstebreite.value,erstehohe.value,zweitebreite.value,zweitehohe.value,papierdaten);
     		
     	auschnittlayer1.moveTo(new Coord(0,0));
     	auschnittlayer2.moveTo(new Coord(0,0));
     	
      
     	auschnittlayer1.moveTo(new Coord(15,0));
     	auschnittlayer2.moveTo(new Coord(110,0));
     
     
        //Definiere Ränder und Abstände für erst-auswahl
        
        //Ränder und Abstände für ersten DIV
        //Höhe bzw Abstand von oben
        abstandoben1 = new Layer_Ref('1oben');
        abstandunten1 = new Layer_Ref('1unten');
        zwischenabstand =  new Layer_Ref('steg');
        
        abstandoben1.value = ((hohegesamtlayer.value - erstehohe.value) / 2);
        abstandunten1.value = ((hohegesamtlayer.value - erstehohe.value) / 2);
        
        abstandoben2 = new Layer_Ref('2oben');
        abstandunten2 = new Layer_Ref('2unten');

        abstandoben2.value = ((hohegesamtlayer.value - zweitehohe.value) / 2);
        abstandunten2.value = ((hohegesamtlayer.value - zweitehohe.value) / 2);

        //Ränder nach links in mm
        //Den gesamten Layer virtuell durch 2 teilen

        //virtuelle linke hälfe & virtuelle rechte hälfte
        virtualbreite = (breitegesamtlayer.value / 2);



         abstandlinks1 = new Layer_Ref('1links');
         abstandlinks2 = new Layer_Ref('2links');
         
         abstandrechts1 = new Layer_Ref('1rechts');
         abstandrechts2 = new Layer_Ref('2rechts');
         
         abstandlinks1.value = ((virtualbreite - erstebreite.value) / 2);
         linkerabstand = ((virtualbreite - erstebreite.value) / 2);
         abstandrechts1.value = (breitegesamtlayer.value - erstebreite.value) - ((virtualbreite - erstebreite.value) / 2);
         
        //Für den zweiten DIV
        //Abstand nach Links ist gleich =
        //Abstandlinks DIV1 + breite div 2 + steg
       
        abstandlinkszwei = (zwischenabstand.value) - (- erstebreite.value) - (- linkerabstand);
        
        //Abstand rechts
        //DIV1 breite +
        
       // abstandlinkszwei = (1 + (abstandlinks1.value) + (erstebreite.value) + (zwischenabstand.value));
        
        
         abstandlinks2.value = abstandlinkszwei *1;
         allevonlinks = (zwischenabstand.value) - (- erstebreite.value) - (- linkerabstand) -(- zweitebreite.value);
         abstandrechts2.value = (breitegesamtlayer.value - allevonlinks);
      
         
        // checkAreas(breitegesamtlayer.value,hohegesamtlayer.value,  abstandoben1.value,abstandlinks1.value,erstehohe.value,erstebreite.value, 	abstandoben2.value,abstandlinks2.value,zweitehohe.value,zweitebreite.value, stcklayer.value);
        
         
         SetPosDoppel(0);
        // alert(abstandrechts2.value);
        
}

function berechneStegAktiv()
{
  //alert('steg aktiv');
        // Berechnet bei einer neueingabe des steges den abstand von links für das zweite div neu
         stegwert = new Layer_Ref('steg');
        werta = stegwert.value;
         if(stegwert.value < 10)
         {
           alert('Der Steg muss min 10 mm breit sein');
           return 0;
         }
        erstebreite = new Layer_Ref('x1');
		zweitebreite = new Layer_Ref('x2');
		zweitehohe =  new Layer_Ref('y2');
		erstehohe =  new Layer_Ref('y2');
         abstandlinks1 = new Layer_Ref('1links');
         abstandlinks2 = new Layer_Ref('2links');
		 abstandoben2 =  new Layer_Ref('2oben');
		  abstandoben1 =  new Layer_Ref('1oben');
		   breitegesamtlayer = new Layer_Ref('breite_gesamt');
      hohegesamtlayer = new Layer_Ref('hohe_gesamt');
		 
		//breitegesamtlayer.value, hohegesamtlayer.value,  
		 
checking = testPosition(abstandoben1.value, abstandlinks1.value, erstehohe.value,erstebreite.value, 	
						abstandoben2.value,abstandlinks2.value, zweitehohe.value,zweitebreite.value);
       
//alert(checking);
         if(checking == 'breite')
         {
         erstebreite = new Layer_Ref('x1');
         abstandlinks1 = new Layer_Ref('1links');
         abstandlinks2 = new Layer_Ref('2links');
         //Abstand zweiter DIV von links = Abstand erster DIV links + Breite DIV1 + steg
         abstandlinks2.value = (stegwert.value - (- erstebreite.value) - (- abstandlinks1.value));
            stegwert.value = werta;
			  //checking = checkAreas(breitegesamtlayer.value, hohegesamtlayer.value,
							//   abstandoben1.value, abstandlinks1.value, erstehohe.value,erstebreite.value,
							  // abstandoben2.value,abstandlinks2.value,zweitehohe.value,zweitebreite.value,
							  //werta);
			
         SetPosDoppel();
     
      }
      else
      {
      
         erstehohe = new Layer_Ref('y1');
         oben1 = new Layer_Ref('1oben');
         zweioben = new Layer_Ref('2oben');
         //Abstand zweiter DIV von links = Abstand erster DIV oben + hohe DIV1 + steg
         zweioben.value = (stegwert.value - (- erstehohe.value) - (- oben1.value));
       //  alert(zweioben.value);
	   // checking = checkAreas(breitegesamtlayer.value, hohegesamtlayer.value,
		//					   abstandoben1.value, abstandlinks1.value, erstehohe.value,erstebreite.value,
		//					   abstandoben2.value,abstandlinks2.value,zweitehohe.value,zweitebreite.value,
		//					  werta);
		stegwert.value = werta;
         SetPosDoppel();
        
       
      }
        
}
function berechneStegPassiv()
{
     //Wird aufgerufen wenn sich eine Position verschoben hat, also auch von berechneStegAktiv()
     //Steg = Abstand Links DIV1 + breite div 1 + breite div2 + abstand rechts div2 - gesamte breite
     //x ist entweder breite oder hohe
     
     
      erstebreite = new Layer_Ref('x1');
      erstehohe = new Layer_Ref('y1');
      zweitebreite = new Layer_Ref('x2');
      zweitehohe = new Layer_Ref('y2');
      abstandlinks1 = new Layer_Ref('1links');
      abstandrechts2 = new Layer_Ref('2rechts');
      abstandoben1 = new Layer_Ref('1oben');
      abstandoben2 = new Layer_Ref('2unten');
      breitegesamtlayer = new Layer_Ref('breite_gesamt');
      hohegesamtlayer = new Layer_Ref('hohe_gesamt');
      stegwert = new Layer_Ref('steg');
     
      checking = testPosition(abstandoben1.value, abstandlinks1.value, erstehohe.value,erstebreite.value,
						abstandoben2.value,abstandlinks2.value, zweitehohe.value,zweitebreite.value);
       //alert('ausgeführt');
       
     //alert(checking);
     if(checking == 'breite')
     {
        neuersteg = breitegesamtlayer.value - abstandrechts2.value - abstandlinks1.value - zweitebreite.value - erstebreite.value;
        stegwert.value = neuersteg;
     }
    else
    {
      neuersteg = hohegesamtlayer.value - abstandoben1.value - abstandoben2.value - erstehohe.value - zweitehohe.value;
        stegwert.value = neuersteg;
     }
   //  alert(checking);
     

}



function SetPosDoppel(chng)
{
  //Setzt Position für Doppel
  //chng enthaält welches Feld aufgerufen wurde
  //paperset die Pixel zu mm Werte
   hohegesamtlayer = new Layer_Ref('hohe_gesamt');
   breitegesamtlayer = new Layer_Ref('breite_gesamt');
        
   erstebreite = new Layer_Ref('x1');
   erstehohe  = new Layer_Ref('y1');

   zweitebreite = new Layer_Ref('x2');
   zweitehohe  = new Layer_Ref('y2');
   
   //Superabstand
   
   vertikal1 = (hohegesamtlayer.value - erstehohe.value);
   vertikal2 = (hohegesamtlayer.value - zweitehohe.value);
   
   
       
   //Abstände neu errechnen
   // alert('HIEEER');

   if(chng)
   {
        //Berechne gegenüberlegende Position
         obenabstand1 = new Layer_Ref('1oben');
         untenabstand1 = new Layer_Ref('1unten');
         
          obenabstand2 = new Layer_Ref('2oben');
         untenabstand2 = new Layer_Ref('2unten');
         
         rechtsabstand1 = new Layer_Ref('1rechts');
         linkerabstand1 = new Layer_Ref('1links');
         
             rechtsabstand2 = new Layer_Ref('2rechts');
         linkerabstand2 = new Layer_Ref('2links');
         
         
        
         //paddingobenunten1 = obenabstand1.value - (- untenabstand1.value);
         if(chng == '1unten')
         {
            berechneStegPassiv();
             if((vertikal1 - untenabstand1.value) < 10 || untenabstand1.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            obenabstand1.value = (vertikal1 - untenabstand1.value);
         }
        if(chng == '1oben')
             {
                berechneStegPassiv();
            if((vertikal1 - obenabstand1.value) < 10 || obenabstand1.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            untenabstand1.value = (vertikal1 - obenabstand1.value);
         }
         
         if(chng == '2unten')
         {
            berechneStegPassiv();
           //alert('hallo');
             if((vertikal2 - untenabstand2.value) < 10 || untenabstand2.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            obenabstand2.value = (vertikal2 - untenabstand2.value);
         }
         
        if(chng == '2oben')
        {
           berechneStegPassiv();
            if((vertikal2 - obenabstand2.value) < 10 || obenabstand2.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            untenabstand2.value = (vertikal2 - obenabstand2.value);
         }
         
       //Links und rechts
       //Für DIV 1
       
       //Links
       horizontal1 = (breitegesamtlayer.value - erstebreite.value);
       horizontal2 = (breitegesamtlayer.value - zweitebreite.value);
       //alert(horizontal1);
       erstebreite = new Layer_Ref('x1');
         if(chng == '1links')
        {
           berechneStegPassiv();
            if((horizontal1 - rechtsabstand1.value) < 10 || linkerabstand1.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            rechtsabstand1.value = (horizontal1 - linkerabstand1.value);
         }
          if(chng == '1rechts')
        {

           berechneStegPassiv();
            if((horizontal2 - linkerabstand1.value) < 10 || rechtsabstand1.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            linkerabstand1.value = (horizontal2 - rechtsabstand1.value);
         }


      //Für das zweite DIV
      //
       horizontal2 = (breitegesamtlayer.value - zweitebreite.value);
       
          if(chng == '2links')
        {
           berechneStegPassiv();
            if((horizontal2 - rechtsabstand2.value) < 10 || linkerabstand2.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            rechtsabstand2.value = (horizontal2 - linkerabstand2.value);
         }
      
          if(chng == '2rechts')
        {
           berechneStegPassiv();
            if((horizontal2 - linkerabstand2.value) < 10 || rechtsabstand2.value < 10 ) {alert('Abstand zu klein, min. 10mm'); return false;}
            linkerabstand2.value = (horizontal2 - rechtsabstand2.value);
         }
       
       
       
       
        berechneStegPassiv();

}
else
{

}

        
        
   abstandoben1 = new Layer_Ref('1oben');

   abstandunten1 = new Layer_Ref('1unten');
   
   abstandklinks1 = new Layer_Ref('1links');

   abstandrechts1 = new Layer_Ref('1rechts');

   unten1 = abstandunten1.value;
   oben1 = abstandoben1.value;
   links1 = abstandklinks1.value;
   rechts1 = abstandrechts1.value;
   
   abstandoben2 = new Layer_Ref('2oben');

   abstandunten2 = new Layer_Ref('2unten');

   abstandklinks2 = new Layer_Ref('2links');

   abstandrechts2 = new Layer_Ref('2rechts');

   unten2 = abstandunten2.value;
   oben2 = abstandoben2.value;
   links2 = abstandklinks2.value;
   rechts2 = abstandrechts2.value;  
   
     zwischenabstand =  new Layer_Ref('steg'); 
	 
	 //alert('test');
	// alert('h:'+hohegesamtlayer.value);
	 //alert('b:'+breitegesamtlayer.value);
	 //alert('abstandoben1:'+abstandoben1.value);
	 //alert('abstandlinks1:'+abstandlinks1.value);
	 //alert('erstehohe:'+erstehohe.value);
	 //alert('erstebreite:'+erstebreite.value);
	 //alert('abstandoben2:'+abstandoben2.value);
	 //alert('abstandlinks1:'+abstandlinks2.value);
	 //alert('zweitehohe:'+zweitehohe.value);
	 //alert('zweitebreite:'+zweitebreite.value);

	
	 
	 //alert('hier');
	  zwischenabstand =  new Layer_Ref('steg');
	  //	 alert('zwischenabstand:'+zwischenabstand.value);
        checking = checkAreas(hohegesamtlayer.value, breitegesamtlayer.value,
				   abstandoben1.value, abstandlinks1.value, erstehohe.value, erstebreite.value,
				   abstandoben2.value, abstandlinks2.value, zweitehohe.value, zweitebreite.value,
				   zwischenabstand.value);
   
 if(!((checking == 'breite') || (checking == 'hohe')))
 {
   //alert('break');
   //location.reload();
   return 0;
 }
   
//berechneStegPassiv();
paperset = new Array();

   paperset = SetPaper(breitegesamtlayer.value,hohegesamtlayer.value);
   relation = (paperset[0] / paperset[2]);


    //Abstand von oben =
    abstandvonoben1 = (abstandoben1.value * relation);
    abstandvonlinks1 = (abstandlinks1.value * relation);
    // oben1 = abstandoben1.value;,
      abstandoben2 = new Layer_Ref('2oben');
   // alert(abstandoben2.value);
   abstandklinks2 = new Layer_Ref('2links');
  // alert(abstandklinks2.value);
     abstandvonoben2 = (abstandoben2.value * relation);
    abstandvonlinks2 = (abstandlinks2.value * relation);
//alert(relation);
    //alert(abstandvonlinks2);
    //alert(abstandvonlinks);

  auschnittlayer1 = new Layer_Ref('ausschnitt1');
  auschnittlayer2 = new Layer_Ref('ausschnitt2');
  //Positionen setzen

  auschnittlayer1.moveTo(new Coord(abstandvonlinks1,abstandvonoben1));
  auschnittlayer2.moveTo(new Coord(abstandvonlinks2,abstandvonoben2));
 // auschnittlayer2.moveTo(new Coord(110,0));
  
  
  
}
    
 function SetzeBeideAusschnitte(x1,y1,x2,y2,rueckgabewerte)
 {
   
   //Den Ausschnitt setzten uns Positionieren, relativ zum ersten versteht sich


   maxX = rueckgabewerte[0]; //X Wert des Rahmens in Pixel
   maxY = rueckgabewerte[1]; //Y Wert des Rahmens in Pixel

   currentsizex = rueckgabewerte[2]; //Größe des Rahmens X in mm
   currentsizey = rueckgabewerte[3]; //Größe des Rahmens Y in mm


   //Größe des Ausschnitss richtig anzeigen
   wertx1 = ((maxX / currentsizex) * x1 );
   werty1 = ((maxY / currentsizey) * y1 );
   //alert(wertx);
   
   //Zweiter ausschnitt
   wertx2 = ((maxX / currentsizex) * x2 );
   werty2 = ((maxY / currentsizey) * y2 );

  
   auschnittlayer1 = new Layer_Ref('ausschnitt1');
  auschnittlayer2 = new Layer_Ref('ausschnitt2');

   
  
   

   auschnittlayer1.style.width = wertx1+ 'px';
   auschnittlayer1.style.height = werty1+ 'px';

 auschnittlayer2.style.width = wertx2+ 'px';
   auschnittlayer2.style.height = werty2+ 'px';
    

   return 1;
 }