// CopyFromOneDoc2Another.jsx 
 
QuellDoc = app.documents[0]; 
ZielDoc = app.documents[1]; 
 
// Seitenumfang abgleichen 
if (ZielDoc.pages.length < QuellDoc.pages.length) 
{ 
	myP2add = QuellDoc.pages.length - ZielDoc.pages.length; 
	for (onePage = 0; onePage < myP2add; onePage++) 
	{ 
		ZielDoc.pages.add(); 
	} 
} 
 
// Ebenen abgleichen 
myLayers = QuellDoc.layers 
for (oneLayer = myLayers.length-1; oneLayer >= 0; oneLayer--) 
{ 
	try 
	{ 
		ZielDoc.layers.add({name:myLayers[oneLayer].name}) 
	} 
	catch(e){} 
} 
 
// Seitwärts vorgehen 
for (onePage = 0; onePage < QuellDoc.pages.length; onePage++) 
{ 
	app.select(NothingEnum.nothing); // ggf. vorhandene Auswahl löschen 
	for (oneItem = 0; oneItem < QuellDoc.pages[onePage].pageItems.length; oneItem++ ) 
	{ 
		myCollection = QuellDoc.pages[onePage].pageItems[oneItem].select(SelectionOptions.addTo) 
	} 
	if (app.selection.length > 0) 
	{ 
		app.copy(); 
		app.layoutWindows[1].bringToFront(); 
		app.layoutWindows[0].activePage = app.documents[0].pages[onePage]; 
		app.pasteInPlace(); 
		app.layoutWindows[1].bringToFront(); 
	} 
} 

// CopyFromOneDoc2Another_LayerSensitive.jsx  
  
var QuellDoc = app.documents[0];  
var ZielDoc = app.documents[1];  
var myCheck = myDisplayDialog() 
 
// Ebenen abgleichen  
myLayers = QuellDoc.layers  
for (oneLayer = myLayers.length-1; oneLayer >= 0; oneLayer--)  
{  
	try  
	{  
		ZielDoc.layers.add({name:myLayers[oneLayer].name})  
	}  
	catch(e){}  
	ZielDoc.layers.item(myLayers[oneLayer].name).visible = true; 
	ZielDoc.layers.item(myLayers[oneLayer].name).locked = false; 
}  
 
// Seitenumfang bei Textseiten abgleichen  
if (ZielDoc.pages.length < QuellDoc.pages.length)  
{  
	myP2add = QuellDoc.pages.length - ZielDoc.pages.length;  
	for (onePage = 0; onePage < myP2add; onePage++) ZielDoc.pages.add();  
}  
 
// Seitenumfang bei Musterseiten abgleichen  
if (ZielDoc.masterSpreads.length < QuellDoc.masterSpreads.length)  
{  
	myM2add = QuellDoc.masterSpreads.length - ZielDoc.masterSpreads.length;  
	for (oneSpread = 0; oneSpread < myM2add; oneSpread++) ZielDoc.masterSpreads.add();  
}  
 
// Doppelseitwärts vorgehen auf Textseiten 
if (myCheck[1] == true) 
	for (oneSpread = 0; oneSpread < QuellDoc.spreads.length; oneSpread++)  
		theCopyPaste(QuellDoc.spreads[oneSpread]) 
 
// Doppelseitwärts vorgehen auf Musterseiten 
if (myCheck[2] == true) 
	for (oneMSpread = 0; oneMSpread < QuellDoc.masterSpreads.length; oneMSpread++)   
		theCopyPaste(QuellDoc.masterSpreads[oneMSpread])  
	 
	 
// Dialog 
function myDisplayDialog() 
{ 
	var myFieldWidth = 150; 
	var myDialog = app.dialogs.add({name:"Ebenen kopieren"}); 
	with(myDialog.dialogColumns.add()){ 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				staticTexts.add({staticLabel:"Quelldokument: " + QuellDoc.name, minWidth:myFieldWidth});  
			}  
		}  
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				staticTexts.add({staticLabel:"Zieldokument: " + ZielDoc.name, minWidth:myFieldWidth});  
			}  
		}  
 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				var myVisibleLayers = checkboxControls.add({staticLabel:"nur sichtbare Ebenen", checkedState: true});  
			}  
		}  
 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				var myMainPages = checkboxControls.add({staticLabel:"aus Dokumentseiten kopieren", checkedState : true});  
			}  
		}  
 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				var myMasterPages = checkboxControls.add({staticLabel:"aus Musterseiten kopieren", checkedState : false});  
			}  
		}  
	} 
	var theResult = myDialog.show(); 
	if(theResult == true){ 
		var myVL = myVisibleLayers.checkedState; 
		var myMainP = myMainPages.checkedState; 
		var myMasterP = myMasterPages.checkedState;		 
		myDialog.destroy(); 
	} 
	else{ 
		myDialog.destroy(); 
		exit(); 
	} 
	return [myVL, myMainP, myMasterP]; 
} 
 
//Kopieren und  Hin- und Her-Springen 
function theCopyPaste(theSpread) 
{ 
	app.select(NothingEnum.nothing); // ggf. vorhandene Auswahl löschen  
	for (oneItem = 0; oneItem < theSpread.pageItems.length; oneItem++ )  
	{  
		myObject = theSpread.pageItems[oneItem]; 
		if (myCheck[0] == true) 
		{ 
			if (myObject.itemLayer.visible == true)  
				myObject.select(SelectionOptions.addTo)  
		} 
		else 
		{ 
			myObject.select(SelectionOptions.addTo) 
		} 
	}  
	if (app.selection.length > 0)  
	{  
		app.copy();  
		app.layoutWindows[1].bringToFront();  
		app.layoutWindows[0].activeSpread = theSpread;  
		app.pasteInPlace();  
		app.layoutWindows[1].bringToFront();  
	}  
 
} 

// Fenster in den Vordergrund stellen 
function theBringToFront(myDocName) 
{ 
	for (oneWindow = 0; oneWindow < app.windows.length; oneWindow++)  
	{ 
		if (app.windows[oneWindow].parent.name == myDocName) 
		{ 
			app.windows[oneWindow].bringToFront(); 
			return; 
		} 
	} 
} 

var docName = "Treffer"; 
 
for(i=0; i<app.documents.length; i++){ 
	app.activeDocument = app.documents.item(i); 
	if(app.activeDocument.name.substring(0, app.activeDocument.name.lastIndexOf(".")) == docName){ 
		//... 
		break; 
	} 
} 

app.documents.item("PfundsDoc.indd").windows[0].bringToFront(); 

// CopyFromOneDoc2Another_LayerSensitiveWithDocSelection.jsx  
//DESCRIPTION: Kopiert (alle) Objekte von einem Quelldokument in ein Zieldokument. Die Auswahl der zu kopierenden Objekte läßt sich auf die sichtbaren Ebenen beschränken. 
 
if (app.documents.length <2) 
{ 
	alert("Fehler!\rEs müssen mindestens zwei Dokumente geöffnet sein."); 
	exit(); 
}  
var myCheck = myDisplayDialog() 
 
/* 
// Kleiner Umweg, um Quell- und Zieldokument über ihre Namen zu referenzieren  
//Dieser Umweg ist dank des Hinweises von Tio  
//(http://www.hilfdirselbst.ch/foren/Ebenen_aus_einem_vorhandenen_Dokument_in_ein_neues_Dokument_importieren_P240590.html#240590) 
//nicht mehr notwendig. 
//Dank an Tio und Dave Saunders. 
 
var myQuellDocName =  eval("app.documents[" + myCheck[3] + "]").name;  
var myZielDocName = eval("app.documents[" + myCheck[4] + "]").name;  
var QuellDoc = app.documents.item(myQuellDocName);   
var ZielDoc = app.documents.item(myZielDocName);   
*/ 
var QuellDoc = app.documents[ myCheck[3] ].getElements()[0];  
var ZielDoc = app.documents[ myCheck[4] ].getElements()[0];  
 
// Herstellung der Reihenfolge der Fenster 
ZielDoc.windows[0].bringToFront(); 
QuellDoc.windows[0].bringToFront(); 
 
// Ebenen abgleichen  
var myLayers = QuellDoc.layers;  
for (oneLayer = myLayers.length-1; oneLayer >= 0; oneLayer--)  
{  
	if (myCheck[0] == true)  
	{ 
		if (myLayers[oneLayer].visible == true) 
			makeNewLayer(myLayers[oneLayer].name) 
	} 
	else 
		makeNewLayer(myLayers[oneLayer].name) 
}  
 
// Seitenumfang bei Textseiten abgleichen  
if (ZielDoc.pages.length < QuellDoc.pages.length)  
	ZielDoc.documentPreferences.pagesPerDocument = QuellDoc.pages.length; 
 
// Seitenumfang bei Musterseiten abgleichen  
if (ZielDoc.masterSpreads.length < QuellDoc.masterSpreads.length)  
{  
	myM2add = QuellDoc.masterSpreads.length - ZielDoc.masterSpreads.length;  
	for (oneSpread = 0; oneSpread < myM2add; oneSpread++) ZielDoc.masterSpreads.add();  
}  
  
// Doppelseitwärts vorgehen auf Textseiten 
if (myCheck[1] == true) 
	for (oneSpread = 0; oneSpread < QuellDoc.spreads.length; oneSpread++)  
		theCopyPaste(QuellDoc.spreads[oneSpread]) 
 
// Doppelseitwärts vorgehen auf Musterseiten 
if (myCheck[2] == true) 
	for (oneMSpread = 0; oneMSpread < QuellDoc.masterSpreads.length; oneMSpread++)   
		theCopyPaste(QuellDoc.masterSpreads[oneMSpread])  
	 
// Zieldokument am Ende wieder in Vordergrund 
ZielDoc.windows[0].bringToFront(); 
alert("Fix und fertig."); 
 
// ---------------------------------------------------------------------- 
// 									Dialog 
// ---------------------------------------------------------------------- 
function myDisplayDialog() 
{ 
	var myFieldWidth = 150; 
	var myDialog = app.dialogs.add({name:"Ebenen kopieren"}); 
	with(myDialog.dialogColumns.add()){ 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				staticTexts.add({staticLabel:"Quelldokument:", minWidth:myFieldWidth});  
			}  
			with(dialogColumns.add()){  
				var mySourceFileDropdown = dropdowns.add({stringList:app.documents.everyItem().name, selectedIndex:0});  
			}  
		}  
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				staticTexts.add({staticLabel:"Zieldokument:", minWidth:myFieldWidth});  
			}  
			with(dialogColumns.add()){  
				var myTargetFileDropdown = dropdowns.add({stringList:app.documents.everyItem().name, selectedIndex:1});  
			}  
		}  
 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				var myVisibleLayers = checkboxControls.add({staticLabel:"nur sichtbare Ebenen", checkedState: true});  
			}  
		}  
 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				var myMainPages = checkboxControls.add({staticLabel:"aus Dokumentseiten kopieren", checkedState : true});  
			}  
		}  
 
		with(dialogRows.add()){  
			with(dialogColumns.add()){  
				var myMasterPages = checkboxControls.add({staticLabel:"aus Musterseiten kopieren", checkedState : false});  
			}  
		}  
	} 
	var theResult = myDialog.show(); 
	if(theResult == true){ 
		var myVL = myVisibleLayers.checkedState; 
		var myMainP = myMainPages.checkedState; 
		var myMasterP = myMasterPages.checkedState;		 
		var mySourceDoc = mySourceFileDropdown.selectedIndex;  
		var myTargetDoc = myTargetFileDropdown.selectedIndex;  
		myDialog.destroy(); 
	} 
	else{ 
		myDialog.destroy(); 
		exit(); 
	} 
	return [myVL, myMainP, myMasterP, mySourceDoc, myTargetDoc]; 
} 
 
// ---------------------------------------------------------------------- 
// 	korrespondierende Ebenen im Zieldokument einblenden und entsperren 
// ---------------------------------------------------------------------- 
function makeLayerEditable(aLayer) 
{ 
	aLayer.visible = true; 
	aLayer.locked = false; 
} 
 
// ---------------------------------------------------------------------- 
// 	stellt neue Ebene mit dem übergebenen Namen her (falls noch nicht vorhanden 
// ---------------------------------------------------------------------- 
function makeNewLayer (aLayer) 
{ 
	try  
	{  
		ZielDoc.layers.add({name:aLayer})  
	}  
	catch(e){}  
	makeLayerEditable(ZielDoc.layers.item(aLayer)) 
} 
 
// ---------------------------------------------------------------------- 
// 				Kopieren und Hin- und Herspringen 
// ---------------------------------------------------------------------- 
function theCopyPaste(theSpread) 
{ 
	app.select(NothingEnum.nothing); // ggf. vorhandene Auswahl löschen  
	for (oneItem = 0; oneItem < theSpread.pageItems.length; oneItem++ )  
	{  
		myObject = theSpread.pageItems[oneItem]; 
		if (myCheck[0] == true) 
		{ 
			if (myObject.itemLayer.visible == true)  
				myObject.select(SelectionOptions.addTo)  
		} 
		else 
		{ 
			myObject.select(SelectionOptions.addTo) 
		} 
		 
	}  
	if (app.selection.length > 0)  
	{  
		app.copy();  
		ZielDoc.windows[0].bringToFront();  
		if (theSpread.constructor.name == "Spread") 
		{ 
			app.layoutWindows[0].activeSpread = ZielDoc.spreads[theSpread.index];  
		} 
		else 
		{ 
			app.layoutWindows[0].activeSpread = ZielDoc.masterSpreads[theSpread.index];  
		} 
		app.pasteInPlace();  
		QuellDoc.windows[0].bringToFront();  
	}  
} 

// Kleiner Umweg, um Quell- und Zieldokument über ihre Namen zu referenzieren  
var myQuellDocName =  eval("app.documents[" + myCheck[3] + "]").name;  
var myZielDocName = eval("app.documents[" + myCheck[4] + "]").name;  
var QuellDoc = app.documents.item(myQuellDocName);   
var ZielDoc = app.documents.item(myZielDocName); 

var QuellDoc = app.documents[ myCheck[3] ];   
var ZielDoc = app.documents[ myCheck[4] ]; 

var QuellDoc = app.documents[ myCheck[3] ].getElements()[0]; 
var ZielDoc = app.documents[ myCheck[4] ].getElements()[0]; 

var doc = app.documents[0]; 

// CopyFromOneDoc2Another_LayerSensitiveWithDocSelection2.jsx   
//DESCRIPTION: Kopiert (alle) Objekte von einem Quelldokument in ein Zieldokument. Die Auswahl der zu kopierenden Objekte läßt sich auf die sichtbaren Ebenen beschränken.  
 
// Verknüpfte Textrahmen im Quelldokument werden wieder zu verknüpften Textrahmen im Zieldokument 
 
if (app.documents.length <2)  
{  
	alert("Fehler!\rEs müssen mindestens zwei Dokumente geöffnet sein.");  
	exit();  
}   
var myCheck = myDisplayDialog()  
 
var myOldPasteRemembersLayers = app.clipboardPreferences.pasteRemembersLayers; 
app.clipboardPreferences.pasteRemembersLayers = true; 
 
var QuellDoc = app.documents[ myCheck.source ].getElements()[0];   
var ZielDoc = app.documents[ myCheck.target ].getElements()[0];   
 
// Initialisierung Textverkettungen 
var myStories = QuellDoc.stories; 
var myFramesOfStory = new Array; 
for ( var s = 0; s < myStories.length; s++ )  
{ 
	myFramesOfStory[s] = new Array; 
	for ( var f = 0; f < myStories.item(s).textContainers.length; f++ )  
	{ 
		myStories.item(s).textContainers[f].label =  s + ':' + f; 
		myFramesOfStory[s].push(f); 
	} 
} 
  
// Herstellung der Reihenfolge der Fenster  
ZielDoc.windows[0].bringToFront();  
QuellDoc.windows[0].bringToFront();  
  
// Ebenen abgleichen   
var myLayers = QuellDoc.layers;   
for (oneLayer = myLayers.length-1; oneLayer >= 0; oneLayer--)   
{   
	if (myCheck.visibleLayers == true)   
	{  
		if (myLayers[oneLayer].visible == true)  
			makeNewLayer(myLayers[oneLayer].name)  
	}  
	else  
		makeNewLayer(myLayers[oneLayer].name)  
}   
  
// Seitenumfang bei Textseiten abgleichen   
if (ZielDoc.pages.length < QuellDoc.pages.length)   
	ZielDoc.documentPreferences.pagesPerDocument = QuellDoc.pages.length;  
  
// Seitenumfang bei Musterseiten abgleichen   
if (ZielDoc.masterSpreads.length < QuellDoc.masterSpreads.length)   
{   
	var myM2add = QuellDoc.masterSpreads.length - ZielDoc.masterSpreads.length;   
	for (oneSpread = 0; oneSpread < myM2add; oneSpread++) ZielDoc.masterSpreads.add();   
}   
   
// Doppelseitwärts vorgehen auf Textseiten  
if (myCheck.layoutPages == true)  
	for (oneSpread = 0; oneSpread < QuellDoc.spreads.length; oneSpread++)   
		theCopyPaste(QuellDoc.spreads[oneSpread])  
  
// Doppelseitwärts vorgehen auf Musterseiten  
if (myCheck.masterPages == true)  
	for (oneMSpread = 0; oneMSpread < QuellDoc.masterSpreads.length; oneMSpread++)    
		theCopyPaste(QuellDoc.masterSpreads[oneMSpread])   
ZielDoc.windows[0].bringToFront();  
 
// Neuverkettung der ursprünglich verketten Textrahmen aus dem Quelldokument 
for ( var i = 0; i < myFramesOfStory.length; i++ )  
{ 
	for ( var k = 0; k < myFramesOfStory[i].length-1; k++ )  
	{ 
		var myRefFrame = ZielDoc.textFrames.item(i + ':' + myFramesOfStory[i][k]); 
		if (myRefFrame.nextTextFrame == null)  
		{ 
			var myNextFrame = ZielDoc.textFrames.item(i + ':' + myFramesOfStory[i][k+1]); 
			myRefFrame.nextTextFrame = myNextFrame; 
		} 
		myRefFrame.label = ''; 
	} 
	if ( ZielDoc.textFrames.item(i + ':' + myFramesOfStory[i][myFramesOfStory[i].length-1]) != null ) 
		ZielDoc.textFrames.item(i + ':' + myFramesOfStory[i][myFramesOfStory[i].length-1]).label = ''; 
} 
// Entlabelung der Textrahmen des Quelldokuments. 
QuellDoc.textFrames.everyItem().label = ''; 
 
 
// Zieldokument am Ende wieder in Vordergrund  
ZielDoc.windows[0].bringToFront();  
app.clipboardPreferences.pasteRemembersLayers = myOldPasteRemembersLayers; 
 
alert("Fertig.");  
  
// ----------------------------------------------------------------------  
// 									Dialog  
// ----------------------------------------------------------------------  
function myDisplayDialog()  
{  
	var myFieldWidth = 150;  
	var myDialog = app.dialogs.add({name:"Ebenen kopieren"});  
	with(myDialog.dialogColumns.add()){  
		with(dialogRows.add()){   
			with(dialogColumns.add()){   
				staticTexts.add({staticLabel:"Quelldokument:",  minWidth:myFieldWidth});   
			}   
			with(dialogColumns.add()){   
				var mySourceFileDropdown = dropdowns.add({stringList:app.documents.everyItem().name,  selectedIndex:0});   
			}   
		}   
		with(dialogRows.add()){   
			with(dialogColumns.add()){   
				staticTexts.add({staticLabel:"Zieldokument:",  minWidth:myFieldWidth});   
			}   
			with(dialogColumns.add()){   
				var myTargetFileDropdown = dropdowns.add({stringList:app.documents.everyItem().name,  selectedIndex:1});   
			}   
		}   
  
		with(dialogRows.add()){   
			with(dialogColumns.add()){   
				var myVisibleLayers = checkboxControls.add({staticLabel:"nur sichtbare Ebenen", checkedState: true});   
			}   
		}   
  
		with(dialogRows.add()){   
			with(dialogColumns.add()){   
				var myMainPages = checkboxControls.add({staticLabel:"aus Dokumentseiten kopieren", checkedState : true});   
			}   
		}   
  
		with(dialogRows.add()){   
			with(dialogColumns.add()){   
				var myMasterPages = checkboxControls.add({staticLabel:"aus Musterseiten kopieren", checkedState : false});   
			}   
		}   
	}  
	var theResult = myDialog.show();  
	if(theResult == true){  
		var myVL = myVisibleLayers.checkedState;  
		var myMainP = myMainPages.checkedState;  
		var myMasterP = myMasterPages.checkedState;		  
		var mySourceDoc = mySourceFileDropdown.selectedIndex;   
		var myTargetDoc = myTargetFileDropdown.selectedIndex;   
		myDialog.destroy();  
	}  
	else{  
		myDialog.destroy();  
		exit();  
	}  
	//return [myVL, myMainP, myMasterP, mySourceDoc, myTargetDoc];  
	return{visibleLayers:myVL, layoutPages:myMainP, masterPages:myMasterP, source:mySourceDoc, target:myTargetDoc}; 
}  
  
// ----------------------------------------------------------------------  
// 	korrespondierende Ebenen im Zieldokument einblenden und entsperren  
// ----------------------------------------------------------------------  
function makeLayerEditable(aLayer)  
{  
	aLayer.visible = true;  
	aLayer.locked = false;  
}  
  
// ----------------------------------------------------------------------  
// 	stellt neue Ebene mit dem übergebenen Namen her (falls noch nicht vorhanden  
// ----------------------------------------------------------------------  
function makeNewLayer (aLayer)  
{  
	try   
	{   
		ZielDoc.layers.add({name:aLayer})   
	}   
	catch(e){}   
	makeLayerEditable(ZielDoc.layers.item(aLayer))  
}  
  
// ----------------------------------------------------------------------  
// 				Kopieren und Hin- und Herspringen  
// ----------------------------------------------------------------------  
function theCopyPaste(theSpread)  
{  
	app.select(NothingEnum.nothing); // ggf. vorhandene Auswahl löschen   
	for (oneItem = 0; oneItem < theSpread.pageItems.length; oneItem++ )   
	{   
		myObject = theSpread.pageItems[oneItem];  
		if (myCheck[0] == true)  
		{  
			if (myObject.itemLayer.visible == true)   
				myObject.select(SelectionOptions.addTo)   
		}  
		else  
		{  
			myObject.select(SelectionOptions.addTo)  
		}  
		  
	}   
	if (app.selection.length > 0)   
	{   
		app.copy();   
		ZielDoc.windows[0].bringToFront();   
		if (theSpread.constructor.name == "Spread")  
		{  
			app.layoutWindows[0].activeSpread = ZielDoc.spreads[theSpread.index];   
		}  
		else  
		{  
			app.layoutWindows[0].activeSpread = ZielDoc.masterSpreads[theSpread.index];   
		}  
		app.pasteInPlace();   
		QuellDoc.windows[0].bringToFront();   
	}   
} 

  // Kopiert den Inhalt einer Ebene aus docMaster => docSlave 
  // Voraussetzung docMaster und docSlave sind strukturell identisch  
   
  var ii = 0;             // index of layer to copy 
 
  // alle Inhalte dieser Ebene im Slave löschen 
  var slavePageItems = docSlave.layers[ii].pageItems; 
  var s = slavePageItems.itemByRange(0, slavePageItems.length -1); 
  s.remove(); 
   
  // alle Inhalte dieser Ebene im Master in die Zwischenablage 
  docMaster.windows[0].bringToFront();   
  app.select(NothingEnum.nothing); // ggf. vorhandene Auswahl löschen    
  var masterPageItems = docMaster.layers[ii].pageItems; 
  var m = masterPageItems.itemByRange(0, masterPageItems.length -1); 
  m.select(SelectionOptions.addTo); 
 
  // alle Inhalte der Zwischenablage in die identische Ebene im Slave 
  if (app.selection.length > 0) { 
    app.copy(); 
    docSlave.windows[0].bringToFront();    
    app.layoutWindows[0].activeLayer =  docSlave.layers[ii]; 
    app.pasteInPlace(); 
  } // end if 

// Layer "Text static" von doc1 => doc2 kopieren 
var doc1 = app.documents.item("doc1.indd"); 
var doc2 = app.documents.item("doc2.indd"); 
 
var layerDoc1 = doc1.layers.item('Text static'); 
var layerDoc2 = doc2.layers.item('Text static'); 
 
layerDoc2.pageItems.everyItem().remove();     // layer in doc2 leeren 
layerDoc1.pageItems.everyItem().duplicate(layerDoc2);   // direkt in layer2 duplizieren 

app.selection[0].duplicate(); 

var sel = app.selection[0]; 
 
var x = sel.geometricBounds[1]; 
var y = sel.geometricBounds[0]; 
 
var dup = sel.duplicate(); 
 
var xd = dup.geometricBounds[1]; 
var yd = dup.geometricBounds[0]; 
 
dup.move(undefined,[x-xd,y-yd]);