├── create swc from package.jsfl
├── README.md
├── distribute to layers and name instances.jsfl
├── Draw Invisiborder.jsfl
├── fla-text-processor-jsfl-master
    ├── .gitignore
    ├── test-files
    │   ├── import-test.fla
    │   ├── process-test.fla
    │   └── import-test.xml
    ├── TidyCurrentFLA.jsfl
    ├── lib
    │   ├── Logger.jsfl
    │   ├── ImportXMLTemplate.jsfl
    │   ├── ProcessFLATemplate.jsfl
    │   ├── HTMLParser.jsfl
    │   ├── Importer.jsfl
    │   └── Processor.jsfl
    ├── ImportXMLToCurrentFLA.jsfl
    ├── ProcessCurrentFLA.jsfl
    └── README.md
├── Publish All.jsfl
├── open linkage settings.jsfl
├── publish with excludes.zip
├── Funciton Order Library.jsfl
├── Commands
    ├── Publish Settings.jsfl
    ├── New Project.xml
    ├── Batch Compile.jsfl
    ├── Library - Quick Duplicate.xml
    ├── Timeline - Layer Names.jsfl
    ├── Library - New MC.xml
    ├── Timeline - Transform Selected.xml
    ├── Timeline - Layer Settings.xml
    ├── New Project.jsfl
    ├── Library - Link Image.jsfl
    ├── Library - New MC.jsfl
    ├── Timeline - Transform Selected.jsfl
    ├── Timeline - Layer Settings.jsfl
    ├── Library - Quick Duplicate.jsfl
    └── Library - Folder Structure.jsfl
├── Convert Symbol to Flex Component.jsfl
├── unlock all layers.jsfl
├── guide layers of selected instances.jsfl
├── whole pixels.jsfl
├── delete all graphic symbols.jsfl
├── unguide all.jsfl
├── guide all layers.jsfl
├── width height whole numbers.jsfl
├── Make All Caps.jsfl
├── lock selected layers.jsfl
├── Scale To Stage.xml
├── Instance_setSequenceName.xml
├── [TEK]-Lock All Masks.jsfl
├── guide selected layers.jsfl
├── Center Registration Point.jsfl
├── instance names for selected items.jsfl
├── selection to 0-0.jsfl
├── COLOR - match Fill to Stroke.jsfl
├── COLOR - match Stroke to Fill.jsfl
├── lock all masks.jsfl
├── Resize Text.xml
├── publish all 2.jsfl
├── Instance_setMcName.jsfl
├── Apply Library Name to Selected Instances.jsfl
├── Convert TextFields to MovieClips.jsfl
├── xmui
    ├── update all baseclasses to new baseclasses.xml
    └── wrap selected as new symbol.xml
├── Layer Frame Distributer.xml
├── Resize TextField.jsfl
├── update base class on selected.jsfl
├── Insert.xml
├── publish here to right.jsfl
├── update all baseclasses to new baseclass.jsfl
├── Insert Character.jsfl
├── Insert Multiple.xml
├── shape2array.as
├── Combine Textfields.xml
├── Instance_setSequenceName.jsfl
├── duplicateInstance.xml
├── Embed Video into Selected MovieClip.jsfl
├── AIR - Application and Installer Settings.jsfl
├── Distribute to Keyframes.jsfl
├── AIR - Create AIR File.jsfl
├── Insert Multiple.jsfl
├── [ced] Unblur aliased text.jsfl
├── selected items as public vars.jsfl
├── Resize Text.jsfl
├── Scale To Stage.jsfl
├── Slice Bitmap Instance.xml
├── Convert Bitmap To MovieClip.jsfl
├── movieclip to swf.jsfl
├── ExportSounds.jsfl
├── [TEK]-Change Case.jsfl
├── JPEG Compression Settings.jsfl
├── [TEK]-Find In Library.jsfl
├── [TEK]-Clean Up Library.jsfl
├── Round Pixel Coordinates.jsfl
├── [TEK]-Convert Distribute.jsfl
├── [TEK]-Swap Across Layer.jsfl
├── Enable Excludes.jsfl
├── GetProfile.jsfl
├── Disable Excludes.jsfl
├── Convert Symbol to Flex Container.jsfl
├── Bitmaps-Quality.jsfl
├── Browse Installed AS Files.jsfl
├── Funciton Remove Comments.jsfl
├── Generate Webcast.jsfl
├── func_autodoc.jsfl
├── ProjectPanelAPISample.jsfl
├── organize library.jsfl
├── MoveRegpoint.jsfl
├── [ced] Dump library.jsfl
├── Layer Frame Distributer.jsfl
├── ExportSymbols.jsfl
├── Adjust Timeline to FPS.jsfl
├── wrap selected as new symbol.jsfl
├── Combine Textfields.jsfl
├── shape2array.jsfl
├── Export ActionScript.jsfl
├── Slice Bitmap Instance.jsfl
├── Replace associated class text.jsfl
├── _Change AntiAnim to DeviceFonts.jsfl
├── Redundant Text - Shape Optimizer.jsfl
├── ASExpander.jsfl
├── Package for Delivery.jsfl
├── [tkd] timeline_to_class.jsfl
├── describeShape.jsfl
└── publish with excludes.jsfl


/create swc from package.jsfl:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # flash-jsfl-collection
2 | 


--------------------------------------------------------------------------------
/distribute to layers and name instances.jsfl:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/Draw Invisiborder.jsfl:
--------------------------------------------------------------------------------
1 | var dom = fl.getDocumentDOM();
2 | 


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/.gitignore:
--------------------------------------------------------------------------------
1 | log
2 | output/
3 | lock
4 | 


--------------------------------------------------------------------------------
/Publish All.jsfl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vpmedia/flash-jsfl-collection/HEAD/Publish All.jsfl


--------------------------------------------------------------------------------
/open linkage settings.jsfl:
--------------------------------------------------------------------------------
1 | var lib=fl.getDocumentDOM().library;
2 | var items=lib.getSelectedItems();


--------------------------------------------------------------------------------
/publish with excludes.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vpmedia/flash-jsfl-collection/HEAD/publish with excludes.zip


--------------------------------------------------------------------------------
/Funciton Order Library.jsfl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vpmedia/flash-jsfl-collection/HEAD/Funciton Order Library.jsfl


--------------------------------------------------------------------------------
/Commands/Publish Settings.jsfl:
--------------------------------------------------------------------------------
1 | var doc = fl.getDocumentDOM();
doc.as3AutoDeclare = false;
doc.sourcePath = "../src";
doc.libraryPath = "../lib";


--------------------------------------------------------------------------------
/Convert Symbol to Flex Component.jsfl:
--------------------------------------------------------------------------------
1 | fl.runScript(fl.configURI + 'Javascript/MakeFlexComponent.jsfl', 'makeFlexComponent', 'mx.flash.UIMovieClip' )


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/test-files/import-test.fla:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vpmedia/flash-jsfl-collection/HEAD/fla-text-processor-jsfl-master/test-files/import-test.fla


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/test-files/process-test.fla:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vpmedia/flash-jsfl-collection/HEAD/fla-text-processor-jsfl-master/test-files/process-test.fla


--------------------------------------------------------------------------------
/Commands/New Project.xml:
--------------------------------------------------------------------------------
1 | <dialog title="New Project" buttons="accept,cancel">
	
	<label value="Project Name" control="_str" />
	<textbox maxlength="60" multiline="false" value="" id="_str" />
	
</dialog>


--------------------------------------------------------------------------------
/unlock all layers.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Unlocks all layers.
 3 |  */
 4 | var i=0;
 5 | var l=fl.getDocumentDOM().getTimeline().layers.length;
 6 | for(i;i<l;i++)
 7 | {
 8 | 	var layer = fl.getDocumentDOM().getTimeline().layers[i];
 9 | 	layer.locked = false;
10 | }


--------------------------------------------------------------------------------
/guide layers of selected instances.jsfl:
--------------------------------------------------------------------------------
1 | /**
2 |  * Guide's all layers from the selected items on the stage.
3 |  */
4 | var dom=fl.getDocumentDOM();
5 | var selection=dom.selection;
6 | var i=0;
7 | var l=selection.length;
8 | for(i;i<l;i++)selection[i].layer.layerType="guide";


--------------------------------------------------------------------------------
/whole pixels.jsfl:
--------------------------------------------------------------------------------
1 | /**
2 |  * Moves selected objects on the stage to whole pixels
3 |  */
4 | var objects = fl.getDocumentDOM().selection;
5 | for(var i = 0; i < objects.length; i++)
6 | {
7 | 	objects[i].x = Math.round(objects[i].x);
8 | 	objects[i].y = Math.round(objects[i].y);
9 | }


--------------------------------------------------------------------------------
/delete all graphic symbols.jsfl:
--------------------------------------------------------------------------------
1 | /**
2 |  * Deletes all graphic symbols from the library.
3 |  */
4 | var dom = fl.getDocumentDOM();
5 | var items = dom.library.items;
6 | var lib= dom.library;
7 | for(var i=0;i<items.length;i++) if(items[i].itemType=="graphic") lib.deleteItem(items[i].name);


--------------------------------------------------------------------------------
/unguide all.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Unguide all "guide" layers.
 3 |  */
 4 | var doc=fl.getDocumentDOM();
 5 | var tl=doc.getTimeline();
 6 | var layers=tl.layers;
 7 | for(var i=0;i<layers.length;i++)
 8 | {
 9 | 	if(layers[i].layerType=="mask")continue;
10 | 	else layers[i].layerType="normal";
11 | }


--------------------------------------------------------------------------------
/guide all layers.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Guide all layers except masks.
 3 |  */
 4 | var doc=fl.getDocumentDOM();
 5 | var tl=doc.getTimeline();
 6 | var layers=tl.layers;
 7 | for(var i=0;i<layers.length;i++)
 8 | {
 9 | 	if(layers[i].layerType=="mask")continue;
10 | 	else layers[i].layerType="guide";
11 | }


--------------------------------------------------------------------------------
/width height whole numbers.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Rounds the width and height properties on all
 3 |  * selected objects.
 4 |  */
 5 | var objects=fl.getDocumentDOM().selection;
 6 | for(var i=0;i<objects.length;i++)
 7 | {
 8 | 	objects[i].width=Math.round(objects[i].width);
 9 | 	objects[i].height=Math.round(objects[i].height);
10 | }


--------------------------------------------------------------------------------
/Make All Caps.jsfl:
--------------------------------------------------------------------------------
1 | for(selectionIndex=0; selectionIndex<fl.getDocumentDOM().selection.length; selectionIndex++){
2 | 	var selectedItem = fl.getDocumentDOM().selection[selectionIndex];
3 | 	var currText = selectedItem.getTextString().toString();
4 | 	var newText = currText.toUpperCase();
5 | 	selectedItem.setTextString(newText);
6 | }


--------------------------------------------------------------------------------
/lock selected layers.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Toggle the lock option on selected layers.
 3 |  */
 4 | var layers = fl.getDocumentDOM().getTimeline().getSelectedLayers();
 5 | var i=0;
 6 | var l=layers.length;
 7 | for(i;i<l;i++)
 8 | {
 9 | 	var layer = fl.getDocumentDOM().getTimeline().layers[i];
10 | 	layer.locked = !layer.locked;
11 | }


--------------------------------------------------------------------------------
/Scale To Stage.xml:
--------------------------------------------------------------------------------
 1 | <dialog id="gg_dialog" title="Scale To Stage" buttons="accept, cancel" >
 2 | 	<grid>
 3 | 		<columns>
 4 | 			<column />
 5 | 			<column />
 6 | 		</columns>
 7 | 		<rows>
 8 | 			<row>
 9 | 				<label value="Margin:" />
10 | 				<textbox id="margin" value="0" />
11 | 			</row>
12 | 		</rows>
13 | 	</grid>
14 | </dialog>
15 | 


--------------------------------------------------------------------------------
/Instance_setSequenceName.xml:
--------------------------------------------------------------------------------
 1 | <dialog id="ui" title="SetPrefix" buttons="accept, cancel">
 2 | <grid>
 3 |  <columns>
 4 |   <column/>
 5 |   <column/>
 6 |  </columns>
 7 |  <rows>
 8 |   <row>
 9 |     <label value="prefix:   " control="prefix" />
10 |       <textbox id="prefix" width="25pix" /> 
11 |   </row>
12 |  </rows>
13 | </grid>
14 | </dialog>


--------------------------------------------------------------------------------
/[TEK]-Lock All Masks.jsfl:
--------------------------------------------------------------------------------
 1 | var doc=fl.getDocumentDOM();
 2 | var tl=doc.getTimeline();
 3 | var layers=tl.layers;
 4 | 
 5 | for(var i=0;i<layers.length;i++){
 6 | 	if(layers[i].layerType=="mask"){
 7 | 		tl.setSelectedLayers(i,i);
 8 | 		tl.setLayerProperty("locked",true,"selected");
 9 | 		tl.setLayerProperty("visible",false,"selected");
10 | 	}
11 | }
12 | 


--------------------------------------------------------------------------------
/guide selected layers.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Turn's all selected layers into guides.
 3 |  */
 4 | var layerArray=fl.getDocumentDOM().getTimeline().getSelectedLayers();
 5 | var a=0;
 6 | for(a;a<layerArray.length;a++)
 7 | {
 8 | 	var numLayer=layerArray[a];
 9 | 	var thisLayer=fl.getDocumentDOM().getTimeline().layers[numLayer];
10 | 	thisLayer.layerType="guide";
11 | }


--------------------------------------------------------------------------------
/Center Registration Point.jsfl:
--------------------------------------------------------------------------------
1 | var dom = fl.getDocumentDOM();
2 | var selectionCount = dom.selection.length;
3 | 
4 | for (var selectionIndex = 0; selectionIndex < selectionCount; selectionIndex++)
5 | {
6 | 	var selectedItem = fl.getDocumentDOM().selection[selectionIndex];
7 | 	selectedItem.setTransformationPoint({x:selectedItem.width / 2, y:selectedItem.height / 2});
8 | }


--------------------------------------------------------------------------------
/instance names for selected items.jsfl:
--------------------------------------------------------------------------------
1 | var items = fl.getDocumentDOM().selection;
2 | for(var i=0;i<items.length;i++)
3 | {
4 | //	fl.trace(items[i].name);
5 | 	//fl.trace("TEST");
6 | 	//fl.trace(items[i].libraryItem.name.split("/").pop().toString())
7 | 	//items[i].name=items[i].libraryItem.name.split("/").pop().toString();
8 | 	items[i].name = "burt_"+i.toString();
9 | }


--------------------------------------------------------------------------------
/selection to 0-0.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Moves all selected items to 0,0
 3 |  */
 4 | var dom = fl.getDocumentDOM();
 5 | var newSel = [];
 6 | for(i=0;i<dom.selection.length;i++)
 7 | {
 8 | 	var item = dom.selection[i];
 9 | 	var mat = item.matrix;	
10 | 	mat.tx = 0;
11 | 	mat.ty = 0;
12 | 	item.matrix = mat;
13 | 	dom.setTransformationPoint({x:0, y:0});
14 | }
15 | dom.selectNone();


--------------------------------------------------------------------------------
/COLOR - match Fill to Stroke.jsfl:
--------------------------------------------------------------------------------
1 | //Match Fill to Stroke
//by Justin Putney
//http://putney.ajarproductions.com
//version 1.0.0

var dom = fl.getDocumentDOM();
var stroke = dom.getCustomStroke('toolbar'); 

if(stroke.style != "noStroke") {
dom.swapStrokeAndFill();
dom.setCustomStroke(stroke);
}
else {
	var fill = dom.getCustomFill('toolbar');
	fill.style = "noFill";
	dom.setCustomFill( fill );
}


--------------------------------------------------------------------------------
/COLOR - match Stroke to Fill.jsfl:
--------------------------------------------------------------------------------
1 | //Match Stroke to Fill
//by Justin Putney
//http://putney.ajarproductions.com
//version 1.0.0

var dom = fl.getDocumentDOM();

var fill = dom.getCustomFill('toolbar');

if(fill.style != "noFill") {
dom.swapStrokeAndFill();
dom.setCustomFill( fill );
}
else {
	var stroke = dom.getCustomStroke('toolbar'); 
	stroke.style = "noStroke";
	dom.setCustomStroke(stroke);
}


--------------------------------------------------------------------------------
/Commands/Batch Compile.jsfl:
--------------------------------------------------------------------------------
1 | /**
 * A batch compiler that publishes each opened FLA.
 * Created by Colin Duffy on 3/27/2011
 * http://blog.tomorrowevening.com/
 */
 
var docs = fl.documents;
var totalDocs = docs.length;
if( totalDocs > 0 ) {
	var log = "Batch Compiled";
	for( var i = 0; i < totalDocs; i++ ) {
		log += "\n  + " + docs[i].name;
		docs[i].publish();
	}
	fl.trace( log );
	log = null;
}


--------------------------------------------------------------------------------
/lock all masks.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Lock's all mask layers.
 3 |  */
 4 | var doc=fl.getDocumentDOM();
 5 | var tl=doc.getTimeline();
 6 | var layers=tl.layers;
 7 | for(var i=0;i<layers.length;i++)
 8 | {
 9 | 	if(layers[i].layerType=="mask")
10 | 	{
11 | 		tl.setSelectedLayers(i,i);
12 | 		tl.setLayerProperty("locked",true,"selected");
13 | 		tl.setLayerProperty("visible",false,"selected");
14 | 	}
15 | }


--------------------------------------------------------------------------------
/Commands/Library - Quick Duplicate.xml:
--------------------------------------------------------------------------------
1 | <dialog buttons="accept,cancel" title="Quick Duplicate">
	
	<!--  Duplicates  -->
	
	<label value="Duplicate Amounts" control="_num" />
	<textbox multiline="false" value="" id="_num" />
	
	<label value="Folder Name:" control="folderName" />
	<textbox multiline="false" value="" id="folderName" /> 
	
	<checkbox id="copyBaseClass" label="Copy BaseClass" checked="false" />
	
</dialog>


--------------------------------------------------------------------------------
/Commands/Timeline - Layer Names.jsfl:
--------------------------------------------------------------------------------
1 | /**
 * Created by Colin Duffy on 06/29/2010
 */
 
var doc = fl.getDocumentDOM();
doc.selectNone();
doc.getTimeline().addNewLayer("Labels", "normal", true);
doc.getTimeline().addNewLayer("Actions", "normal", true);
doc.getTimeline().layers[0].locked = true;
doc.getTimeline().layers[1].locked = true;
//doc.getTimeline().layers[2].name = "Content";
doc.getTimeline().setSelectedLayers(2);
doc.selectNone();


--------------------------------------------------------------------------------
/Resize Text.xml:
--------------------------------------------------------------------------------
 1 | <dialog id="gg_dialog" title="Resize Text" buttons="accept, cancel" >
 2 | 	<grid>
 3 | 		<columns>
 4 | 			<column />
 5 | 			<column />
 6 | 		</columns>
 7 | 		<rows>
 8 | 			<row>
 9 | 				<label value="Width:" />
10 | 				<textbox id="w" value="550" />
11 | 			</row>
12 | 			<row>
13 | 				<label value="Height:" />
14 | 				<textbox id="h" value="400" />
15 | 			</row>
16 | 		</rows>
17 | 	</grid>
18 | </dialog>
19 | 


--------------------------------------------------------------------------------
/Commands/Library - New MC.xml:
--------------------------------------------------------------------------------
1 | <dialog buttons="accept,cancel" title="New MovieClip">
	
	<label value="New MovieClip Name" control="mcName" />
	<textbox maxlength="80" multiline="false" value="" id="mcName" /> 
	<label value="Class" control="mcClass" />
	<textbox maxlength="80" multiline="false" value="" id="mcClass" /> 
	<label value="Base Class" control="mcBase" />
	<textbox maxlength="80" multiline="false" value="" id="mcBase" /> 
	
</dialog>


--------------------------------------------------------------------------------
/Commands/Timeline - Transform Selected.xml:
--------------------------------------------------------------------------------
 1 | <dialog buttons="accept,cancel" title="Transform Selected Objects">
 2 | 	
 3 | 	<checkbox label="Transform Scale" id="_scale" checked="true" />
 4 | 	
 5 | 	<label value="Width" control="_wid" />
 6 | 	<textbox maxlength="5" multiline="false" value="100" id="_wid" /> 
 7 | 	<label value="Height" control="_hei" />
 8 | 	<textbox maxlength="5" multiline="false" value="100" id="_hei" /> 
 9 | 	
10 | </dialog>


--------------------------------------------------------------------------------
/publish all 2.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Publishes all open documents, and closes all swf
 3 |  * windows, except the last published SWF.
 4 |  */
 5 | var l = fl.documents.length;
 6 | var count = -1;
 7 | function publishNext()
 8 | {
 9 | 	count++;
10 | 	if(count == l) return;
11 | 	else if(count == l - 1) fl.closeAllPlayerDocuments();
12 | 	fl.setActiveWindow(fl.documents[count]);
13 | 	fl.getDocumentDOM().testMovie();
14 | 	publishNext();
15 | }
16 | publishNext();


--------------------------------------------------------------------------------
/Instance_setMcName.jsfl:
--------------------------------------------------------------------------------
 1 | //=====================================================	
 2 | // Instance : setMcName1.0
 3 | // hisayuki takagi | www.wildcard.jp.org
 4 | //=====================================================	
 5 | var cur_doc = fl.getDocumentDOM();
 6 | for(var i1=0; i1<cur_doc.selection.length; i1++){
 7 | 	if(cur_doc.selection[i1].elementType == "instance"){
 8 | 		cur_doc.selection[i1].name = cur_doc.selection[i1].libraryItem.name
 9 | 	}
10 | }
11 | 
12 | 
13 | 


--------------------------------------------------------------------------------
/Apply Library Name to Selected Instances.jsfl:
--------------------------------------------------------------------------------
 1 | var doc = fl.getDocumentDOM();
 2 | var sel = doc.selection;
 3 | 
 4 | var itemCount = sel.length;
 5 | for (var itemIndex = 0; itemIndex < itemCount; itemIndex++)
 6 | {
 7 | 	var item = sel[itemIndex];
 8 | 	if (item.symbolType == "movie clip")
 9 | 	{
10 | 		var newName = item.libraryItem.name;
11 | 		newName = newName.toLowerCase().split(" ").join("_").split(".").join("");
12 | 		doc.selectNone();
13 | 		doc.selection = [item];
14 | 		doc.setElementProperty("name", newName);
15 | 	}
16 | }


--------------------------------------------------------------------------------
/Convert TextFields to MovieClips.jsfl:
--------------------------------------------------------------------------------
 1 | var dom = fl.getDocumentDOM();
 2 | var sel = dom.selection;
 3 | var selectionCount = sel.length;
 4 | 
 5 | for (var selectionIndex = 0; selectionIndex < selectionCount; selectionIndex++)
 6 | {
 7 | 	var selectedItem = sel[selectionIndex];
 8 | 	var currText = selectedItem.getTextString().toString();
 9 | 	
10 | 	dom.selectNone();
11 | 	dom.selection = [sel[selectionIndex]];
12 | 	dom.convertToSymbol("movie clip", "\"" + currText.substr(0, 30) + "\"", "top left");
13 | }
14 | 
15 | fl.outputPanel.trace("Conversion Complete!");


--------------------------------------------------------------------------------
/xmui/update all baseclasses to new baseclasses.xml:
--------------------------------------------------------------------------------
 1 | <dialog id="updateAllBaseClassesToNew" title="Update All Matching Base Classes" buttons="accept,cancel">
 2 | 	<grid>
 3 | 		<columns>
 4 | 			<column/>
 5 | 			<column/>
 6 | 		</columns>
 7 | 		<row>
 8 | 			<label value="Current Base Class " control="currentBaseClassControl" /><textbox id="currentBaseClass" value="" maxlength="512" />
 9 | 		</row>
10 | 		<row>
11 | 			<label value="New Base Class " control="newBaseClassControl" /><textbox id="newBaseClass" value="" maxlength="512" />
12 | 		</row>
13 | 	</grid>
14 | </dialog>
15 | 


--------------------------------------------------------------------------------
/Layer Frame Distributer.xml:
--------------------------------------------------------------------------------
 1 | <dialog title="Layer to Frame / Frame to Layer" buttons="accept,cancel">
 2 | <radiogroup id="switchMethod">
 3 | 	<radio value="0" label="Layer to Frame: Bottom First" />     
 4 | 	<radio value="1" label="Layer to Frame: Top First" />
 5 | 	<separator />
 6 | 	<radio value="2" label="Frame to Layer: Starting Frame as Top" />      
 7 | 	<radio value="3" label="Frame to Layer: Last Frame as Top" />   
 8 | </radiogroup>
 9 | <separator />
10 | <checkbox id="isDelete" label="Delete Frame Element" checked="true" accesskey="d" align="right" />
11 | </dialog>
12 | 


--------------------------------------------------------------------------------
/Resize TextField.jsfl:
--------------------------------------------------------------------------------
 1 | function resizeSelectedTextFields(){
 2 | 	var dom = fl.getDocumentDOM();
 3 | 	var sel = dom.selection;
 4 | 	var txt, w, h;
 5 | 	for (var i=0; i<sel.length; i++){
 6 | 		txt = sel[i];
 7 | 		if (txt.__proto__ == Text.prototype){
 8 | 			w = prompt("TextField Width (pixels):", txt.width);
 9 | 			h = prompt("TextField Height (pixels):", txt.height);
10 | 			if (!isNaN(w) && !isNaN(h)) dom.setTextRectangle({left:0, top:0, right:parseFloat(w)-2, bottom:parseFloat(h)-2});
11 | 			else alert("invalid")
12 | 			return (0);
13 | 		}
14 | 	}
15 | }
16 | resizeSelectedTextFields();
17 | 


--------------------------------------------------------------------------------
/update base class on selected.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Prompts for a new base class, that will be set
 3 |  * on all selected items in the library.
 4 |  */
 5 | var newBaseClass=prompt("Enter the new base class","");
 6 | if(newBaseClass)
 7 | {
 8 | 	var items=fl.getDocumentDOM().library.getSelectedItems();
 9 | 	var i=0;
10 | 	for(i;i<items.length;i++)
11 | 	{
12 | 		var item=items[i];
13 | 		var t=item.itemType;
14 | 		if(t!="movie clip"&&t!="font"&&t!="sound"&&t!="bitmap")continue;
15 | 		item.linkageExportForAS=true;
16 | 		item.linkageBaseClass=newBaseClass;
17 | 		item.linkageExportInFirstFrame=true;
18 | 	}
19 | }


--------------------------------------------------------------------------------
/Insert.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8" ?>
 2 | <dialog title="Insert character"  buttons="accept,cancel" buttonlabelcancel="Cancel" buttonlabelaccept="Insert">
 3 | 	<caption label="Characters" />
 4 | 	<radiogroup id="choices">
 5 | 		<radio id="reg" label="�" value="reg" />
 6 | 		<radio id="trade" label="TM" value="trade" />
 7 | 		<radio id="copy" label="�" value="copy" />
 8 | 		<radio id="bullet" label="&lt;bullet&gt;" value="bullet" />
 9 | 		<radio id="apos" label="’" value="apos" />
10 | 	</radiogroup>
11 | 	<separator />
12 | 	<checkbox id="superscript" label="Superscript" checked="true" />
13 | </dialog> 


--------------------------------------------------------------------------------
/publish here to right.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Publishes the current document, plus all
 3 |  * the documents to the right of the current tab, and
 4 |  * closes all swf windows, except the last published swf.
 5 |  */
 6 | var l = fl.documents.length;
 7 | var firstIndex = fl.findDocumentIndex(fl.getDocumentDOM().name);
 8 | var count = firstIndex - 1;
 9 | function publishNext()
10 | {
11 | 	count++;
12 | 	if(count == l) return;
13 | 	else if(count == l - 1) fl.closeAllPlayerDocuments();
14 | 	fl.setActiveWindow(fl.documents[count]);
15 | 	fl.getDocumentDOM().testMovie();
16 | 	publishNext();
17 | }
18 | publishNext();
19 | fl.setActiveWindow(fl.documents[firstIndex]);


--------------------------------------------------------------------------------
/update all baseclasses to new baseclass.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Updates all movie clips in the library whos ExportClass matches
 3 |  * the target class, and updates it to the new one provided.
 4 |  */
 5 | var fld=fl.getDocumentDOM();
 6 | var lib=fld.library;
 7 | var items=lib.items;
 8 | var xmui=fld.xmlPanel(fl.configURI+"Commands/xmui/update all baseclasses to new baseclasses.xml");
 9 | if(xmui.dismiss=="accept")
10 | {
11 | 	if(!xmui.currentBaseClass&&!xmui.newBaseClass)return;
12 | 	var k=items.length;
13 | 	var item;
14 | 	var i=0;
15 | 	for(i;i<k;i++)
16 | 	{
17 | 		item=items[i];
18 | 		if(item.linkageBaseClass==xmui.currentBaseClass)item.linkageBaseClass=xmui.newBaseClass;
19 | 	}
20 | }


--------------------------------------------------------------------------------
/Insert Character.jsfl:
--------------------------------------------------------------------------------
 1 | var doc = fl.getDocumentDOM();
 2 | var panel = doc.xmlPanel(fl.configURI + "Commands/Insert.xml");
 3 | 
 4 | var selectionArray = {trade:"™", copy:"©", reg:"®", bullet:"•", apos:"’"};
 5 | 
 6 | if (panel.dismiss == "accept")
 7 | {
 8 | 	var insert = selectionArray[panel.choices];
 9 | 	var txt = doc.selection[0];
10 | 	var origStart = txt.selectionStart;
11 | 	var origEnd = txt.selectionEnd;
12 | 	txt.setTextString(insert, origStart, origEnd);
13 | 	
14 | 	doc.setTextSelection(origStart, origStart + insert.length);
15 | 	var newEnd = origStart + insert.length;
16 | 	
17 | 	if (panel.superscript == "true") txt.setTextAttr("characterPosition", "superscript", origStart, newEnd); 
18 | }


--------------------------------------------------------------------------------
/Insert Multiple.xml:
--------------------------------------------------------------------------------
 1 | <dialog id="gg_dialog" title="Insert Multiple" buttons="accept, cancel" >
 2 | 	<grid>
 3 | 		<columns>
 4 | 			<column />
 5 | 			<column />
 6 | 		</columns>
 7 | 		<rows>
 8 | 			<row>
 9 | 				<label value="Quantity: "/>
10 | 				<textbox id="quantity" value="10" />
11 | 			</row>
12 | 			<row>
13 | 				<label value="Type: "/>
14 | 				<menulist id="frameType">
15 | 					<menupop>
16 | 						<menuitem label="Frame" value="frame" />
17 | 						<menuitem label="Keyframe" value="keyframe" />
18 | 						<menuitem label="Blank Keyframe" value="blankkeyframe" />
19 | 						<menuitem label="Layer" value="layer" />
20 | 					</menupop>
21 | 				</menulist>
22 | 
23 | 			</row>
24 | 		</rows>
25 | 	</grid>
26 | </dialog>
27 | 


--------------------------------------------------------------------------------
/Commands/Timeline - Layer Settings.xml:
--------------------------------------------------------------------------------
 1 | <dialog buttons="accept,cancel" title="Layer Properties">
 2 | 
 3 | 	<!--  Layer Properties  -->
 4 | 	<checkbox label="Shown" id="_seen" checked="true" />
 5 | 	<checkbox label="Locked" id="_locked" checked="false" />
 6 | 	
 7 | 	<label value="Layer Type:" control="_type" />
 8 | 	<menulist id="_type">
 9 | 		<menuitem label="Normal" value="_normal" />
10 | 		<menuitem label="Guide" value="_guide" />
11 | 		<menuitem label="Mask" value="_mask" />
12 | 		<menuitem label="Folder" value="_folder" />
13 | 	</menulist>
14 | 	
15 | 	<!--  Color Properties  -->
16 | 	
17 | 	<label value="Outline Color:" control="_color" />
18 | 	<textbox maxlength="6" multiline="false" value="" id="_color" /> 
19 | 	
20 | </dialog>


--------------------------------------------------------------------------------
/Commands/New Project.jsfl:
--------------------------------------------------------------------------------
1 | var doc = fl.getDocumentDOM();
var settings = doc.xmlPanel(fl.configURI + "Commands/New Project.xml");
	
if (settings.dismiss == "accept") {
	newProject( settings._str );
}

function newProject( projectName )
{
	var folderURI = fl.browseForFolderURL ("Select a save location for your project.");
	if( folderURI != null && folderURI != "null" ) {
		
		createFolder( folderURI, projectName );
		
		folderURI += "/" + projectName;
		createFolder( folderURI, "Flash" );
		
		folderURI += "/Flash";
		createFolder( folderURI, "bin" );
		createFolder( folderURI, "fla" );
		createFolder( folderURI, "lib" );
		createFolder( folderURI, "src" );
	}
}

function createFolder( begin, folderName )
{
	FLfile.createFolder( begin + "/" + folderName );
}


--------------------------------------------------------------------------------
/shape2array.as:
--------------------------------------------------------------------------------
 1 | // draw the new extracted image
 2 | function drawArray (_arr:Array) {
 3 | 	// trace ("drawArray ");
 4 | 	var _shape:Shape = new Shape();
 5 | 	_shape.graphics.lineStyle (1, 0x333333, 1);
 6 | 	_shape.graphics.beginFill (0xcccccc);
 7 | 	_shape.graphics.moveTo (_arr[0][0], _arr[0][1]); // starting point
 8 | 	for (var i=1; i<=_arr.length; i+=3) {
 9 | 		_shape.graphics.curveTo (_arr[i][0], _arr[i][1] , _arr[i+1][0], _arr[i+1][1]);
10 | 		// _shape.graphics.lineTo (_arr[i+1][0], _arr[i+1][1]);
11 | 	}
12 | 	_shape.graphics.endFill ();
13 | 	this.drawContainer_mc.addChild (_shape);
14 | }
15 | 
16 | // jumpstart everything
17 | function init (){
18 | 	for (var j=0; j<shapeArrayz.length; j++) {
19 | 		// trace(shapeArrayz[j])
20 | 		drawArray (shapeArrayz[j]);
21 | 	}
22 | }
23 | init ();
24 | 


--------------------------------------------------------------------------------
/Combine Textfields.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <dialog id="combineTF" title="Combine TextFields" buttons="accept,cancel">
 3 | 	
 4 | 		<vbox>
 5 | 			<label value="Sort from:" />
 6 | 			<radiogroup id="sortby" tabindex="5">
 7 | 				<radio label="top" accesskey="t" selected="true"/>
 8 | 				<radio label="left" accesskey="l" />
 9 | 				<radio label="bottom" accesskey="b" />
10 | 				<radio label="right" accesskey="r" />
11 | 			</radiogroup>
12 | 		</vbox>
13 | 		<spacer />
14 | 		<hbox>
15 | 			<label value="Separator:" />
16 | 		</hbox>
17 | 		<hbox>
18 | 			<label value="(\r = hard return, \n = soft return)" />
19 | 		</hbox>
20 | 		<hbox>
21 | 			<textbox id="separator" maxlength="20" multiline="false" value="" tabindex="1" size="12" literal="false" />
22 | 		</hbox>
23 | 	
24 | </dialog>


--------------------------------------------------------------------------------
/Instance_setSequenceName.jsfl:
--------------------------------------------------------------------------------
 1 | //=====================================================	
 2 | // Instance : setSequenceName1.0
 3 | // hisayuki takagi | www.wildcard.jp.org
 4 | //=====================================================	
 5 | var cur_doc = fl.getDocumentDOM();
 6 | var ui = cur_doc.xmlPanel(fl.configURI + "Commands/Instance_setSequenceName.xml");
 7 | var sa = new Array();
 8 | 
 9 | for(var i1=0; i1<cur_doc.selection.length; i1++){
10 | 	if(cur_doc.selection[i1].elementType == "instance"){
11 | 		sa.push({obj:cur_doc.selection[i1],pos:cur_doc.selection[i1].top*1000+cur_doc.selection[i1].left});
12 | 	}
13 | }
14 | sa.sort(cmp_pos);
15 | function cmp_pos(a, b) {return a.pos - b.pos;}
16 | 
17 | for(var i1=0; i1<sa.length; i1++){
18 | 	var n1 = ui.prefix+ (i1+1);
19 | 	sa[i1].obj.name = n1;
20 | }
21 | 
22 | 
23 | 


--------------------------------------------------------------------------------
/duplicateInstance.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <dialog id="setSymbolClass" title="Mixmedia Flash Toolset" buttons="accept, cancel">
 3 | <hbox>
 4 | <label value="Instance Name:" control="asIDDisplay"/>
 5 | <textbox id="insName" maxlength="256" multiline="false" value=""/>
 6 | </hbox>
 7 | <hbox>
 8 | <label value="Column:" control="asclass" width="100"/>
 9 | <textbox id="colCount" maxlength="256" multiline="false" value="10"/>
10 | <label value="Row:" control="asclass" width="70"/>
11 | <textbox id="rowCount" maxlength="256" multiline="false" value="10"/>
12 | </hbox>
13 | <hbox>
14 | <label value="Column Width:" control="asclass" width="100"/>
15 | <textbox id="colWidth" maxlength="256" multiline="false" value="30"/>
16 | <label value="Row Height:" control="asclass" width="70"/>
17 | <textbox id="rowHeight" maxlength="256" multiline="false" value="30"/>
18 | </hbox>
19 | </dialog>


--------------------------------------------------------------------------------
/Commands/Library - Link Image.jsfl:
--------------------------------------------------------------------------------
1 | var lib = fl.getDocumentDOM().library;
var select = lib.getSelectedItems();
var total = select.length;

if( total <= 0 ) {
	alert( "Make a library selection" );
} else {
	
	var itemName = "";
	var splitName = [];
	var itemIndex;
	for( var i = 0; i < total; i++ ) {
		itemName = select[i].name;
		
		splitName = itemName.split("/");
		itemName =  splitName[splitName.length-1];
		
		// Remove file type and periods
		splitName = itemName.split(".");
		splitName.pop();
		itemName = splitName.join("");
		
		// Remove spaces
		itemName = findReplace( itemName, " ", "-" );
		
		select[i].linkageExportForAS = true;
		select[i].linkageIdentifier = itemName;
		select[i].linkageBaseClass = "flash.display.BitmapData";
		select[i].linkageExportInFirstFrame = true;
	}
	
}

function findReplace( original, toFind, toReplace ) {
	return original.split( toFind ).join( toReplace );
}



--------------------------------------------------------------------------------
/Embed Video into Selected MovieClip.jsfl:
--------------------------------------------------------------------------------
 1 | var dom = fl.getDocumentDOM();
 2 | var theLibrary = dom.library;
 3 | var selectedItems = theLibrary.getSelectedItems();
 4 | 
 5 | var clip;
 6 | var video;
 7 | 
 8 | for (var itemIndex = 0; itemIndex < selectedItems.length; itemIndex++)
 9 | {
10 | 	var theItem = selectedItems[itemIndex];
11 | 	switch (theItem.itemType)
12 | 	{
13 | 		case "movie clip":
14 | 			clip = theItem;
15 | 			break;
16 | 		case "video":
17 | 			video = theItem;
18 | 			break;
19 | 	}
20 | }
21 | 
22 | theLibrary.editItem(clip.name);
23 | var tl = dom.getTimeline();
24 | tl.currentLayer = 0;
25 | tl.selectAllFrames();
26 | tl.removeFrames();
27 | tl.insertBlankKeyframe(0);
28 | 
29 | dom.addItem({x:video.width / 2, y:video.height / 2}, video);
30 | var element = dom.selection[0];
31 | element.x = 0;
32 | element.y = 0;
33 | element.name = "video";
34 | 
35 | dom.currentTimeline = 0;


--------------------------------------------------------------------------------
/AIR - Application and Installer Settings.jsfl:
--------------------------------------------------------------------------------
 1 | var dom = fl.getDocumentDOM();
 2 | 
 3 | if (dom == null)
 4 | {
 5 | 	alert("Failed to get current document.");
 6 | }
 7 | else
 8 | {
 9 | 	
10 | 	var flaFilePath = dom.path;
11 | 	var fileName = dom.name;
12 | 	if(!flaFilePath || !fileName)
13 | 	{
14 | 		alert("The Flash AIR file must be saved before opening AIR Application and Installer Settings and before creating the AIR file.");
15 | 	}
16 | 	else
17 | 	{
18 | 		
19 | 		var folderName = flaFilePath.substring(0, flaFilePath.indexOf(fileName));
20 | 	
21 | 		if(dom.getPlayerVersion() == 'AdobeAIR1_0')
22 | 		{
23 | 			FLAir.OpenSettingDialog(flaFilePath);
24 | 		}
25 | 		else
26 | 		{
27 | 			//alert("The Publish target is not Adobe AIR 1.0.");
28 | 			var gotOK = FLAir.PackageAlert(flaFilePath);
29 | 			if (gotOK == 1)
30 | 			{
31 | 				dom.setPlayerVersion('AdobeAIR1_0');
32 | 				dom.save();
33 | 				FLAir.OpenSettingDialog(flaFilePath);
34 | 			}
35 | 		}
36 | 	}
37 | }


--------------------------------------------------------------------------------
/Distribute to Keyframes.jsfl:
--------------------------------------------------------------------------------
 1 | /*
 2 | Distribute to Keyframes v1
 3 | Copyright © 2007 GGSHOW.NET
 4 | All Rights Reserved.
 5 | 
 6 | Author: Goh Lee Chuan a.k.a. Mr G.
 7 | Email: gg1980@gmail.com
 8 | Homepage: http://www.ggshow.net
 9 | */
10 | if (fl.getDocumentDOM().selection.length < 1) {
11 | 	alert("Error: No instance selected.");
12 | } else {
13 | 	var count = fl.getDocumentDOM().selection.length;
14 | 	var shape = false;
15 | 	for(var i=0;i<count;i++){
16 | 		if(fl.getDocumentDOM().selection[i].elementType=="shape"){
17 | 			shape = true;
18 | 			break;
19 | 		}
20 | 	}
21 | 	if(shape){
22 | 		alert("Error: You are allowed to distribute only text field or symbol instances.");
23 | 	} else {
24 | 		document.clipCut();
25 | 		for(var i=0;i<count;i++){
26 | 			fl.getDocumentDOM().getTimeline().insertBlankKeyframe();
27 | 			document.clipPaste(true);
28 | 			fl.getDocumentDOM().selection[i].locked=true;
29 | 			document.deleteSelection();
30 | 			document.unlockAllElements();
31 | 		} 
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/AIR - Create AIR File.jsfl:
--------------------------------------------------------------------------------
 1 | //fl.trace("Artemis");
 2 | var dom = fl.getDocumentDOM();
 3 | 
 4 | if (dom == null)
 5 | {
 6 | 	alert("Failed to get current document.");
 7 | }
 8 | else
 9 | {
10 | 	
11 | 	var flaFilePath = dom.path;
12 | 	//fl.trace(flaFilePath);
13 | 	//fl.trace(dom.playerVersion);
14 | 	//fl.trace(dom.asVersion);
15 | 	//fl.trace(dom.getSWFPathFromProfile());
16 | 	
17 | 	if(!flaFilePath)
18 | 	{
19 | 		alert("The Flash AIR file must be saved before opening AIR Application and Installer Settings and before creating the AIR file.");
20 | 	}
21 | 	else
22 | 	{
23 | 		if(dom.getPlayerVersion() == 'AdobeAIR1_0')
24 | 		{
25 | 			FLAir.PackageAIRFile(flaFilePath);
26 | 		}
27 | 		else
28 | 		{
29 | 			//alert("The Publish target is not Adobe AIR 1.0.");
30 | 			var gotOK = FLAir.PackageAlert(flaFilePath);
31 | 			if (gotOK == 1)
32 | 			{
33 | 				dom.setPlayerVersion('AdobeAIR1_0');
34 | 				dom.save();
35 | 				FLAir.OpenSettingDialog(flaFilePath);
36 | 			}
37 | 		}
38 | 	}
39 | }
40 | 
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/Insert Multiple.jsfl:
--------------------------------------------------------------------------------
 1 | /*
 2 | Insert Multiple v1
 3 | Copyright © 2007 GGSHOW.NET
 4 | All Rights Reserved.
 5 | 
 6 | Author: Goh Lee Chuan a.k.a. Mr G.
 7 | Email: gg1980@gmail.com
 8 | Homepage: http://www.ggshow.net
 9 | */
10 | var gg_dialog = fl.getDocumentDOM().xmlPanel(fl.configURI+"Commands/Insert Multiple.xml");
11 | if (gg_dialog.dismiss == "accept") {
12 | 	var q = Number(gg_dialog.quantity);
13 | 	if ((isNaN(q))||(q<=0)) {
14 | 		alert("Error: Invalid parameter.\nThe value for quantity must be a positive integer.");
15 | 	} else {
16 | 		for(var i=1;i<=q;i++){
17 | 			switch(gg_dialog.frameType){
18 | 				case "frame":
19 | 					fl.getDocumentDOM().getTimeline().insertFrames();
20 | 					break;
21 | 				case "keyframe":
22 | 					fl.getDocumentDOM().getTimeline().insertKeyframe();
23 | 					break;
24 | 				case "blankkeyframe":
25 | 					fl.getDocumentDOM().getTimeline().insertBlankKeyframe();
26 | 					break;
27 | 				case "layer":
28 | 					fl.getDocumentDOM().getTimeline().addNewLayer();
29 | 					break;
30 | 			}
31 | 		}
32 | 	}
33 | }


--------------------------------------------------------------------------------
/[ced] Unblur aliased text.jsfl:
--------------------------------------------------------------------------------
 1 | function doCommand()
 2 | {
 3 | 	var tf = fl.getDocumentDOM().selection[0];
 4 | 	var document = fl.getDocumentDOM();
 5 | 	if(tf == null || tf.elementType != "text")
 6 | 	{
 7 | 		return;
 8 | 	}
 9 | 	var w = Math.round(tf.width - 2);
10 | 	var h = Math.round(tf.height - 2);
11 | 	var l = Math.round(tf.left);
12 | 	var t = Math.round(tf.top);
13 | 	
14 | 	document.setTextRectangle({top:t, left:l, right:l+w, bottom:t+h});
15 | 	document.moveSelectionBy({x:l - tf.left, y:t - tf.top});
16 | 	
17 | 	//Now move out of the movieclip until we are at the root
18 | 	var sel;
19 | 	var newSel;
20 | 	while(true)
21 | 	{
22 | 		sel = fl.getDocumentDOM().selection[0];
23 | 		document.exitEditMode();
24 | 		newSel = fl.getDocumentDOM().selection[0];
25 | 		if(newSel == sel)
26 | 		{
27 | 			break;
28 | 		}
29 | 		else
30 | 		{
31 | 			var mat = newSel.matrix;
32 | 			mat.tx = Math.round(mat.tx);
33 | 			mat.ty = Math.round(mat.ty);
34 | 			newSel.matrix = mat;
35 | 			document.setTransformationPoint({x:0, y:0});
36 | 		}
37 | 	}
38 | }
39 | 
40 | doCommand();


--------------------------------------------------------------------------------
/selected items as public vars.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Creates an output of symbol definitions as public vars
 3 |  * and traces to the output panel.
 4 |  */
 5 | var items=fl.getDocumentDOM().selection;
 6 | var finalDeclarations="";
 7 | var li;
 8 | for(var i=0;i<items.length;i++)
 9 | {
10 | 	var item=items[i];
11 | 	if(item.libraryItem)
12 | 	{
13 | 		li=item.libraryItem;
14 | 		if(isComponent(item.libraryItem.name))finalDeclarations+="public var "+item.name+":"+getClassOfComponent(item.libraryItem.name)+";\n";
15 | 		else if(li.linkageBaseClass)finalDeclarations+="public var "+item.name+":"+(li.linkageBaseClass.toString().split(".").pop())+";\n";
16 | 		else if(item.name)finalDeclarations+="public var "+item.name+":MovieClip;\n";
17 | 	}
18 | 	else if(item.elementType=="text"&&item.name)finalDeclarations+="public var "+item.name+":TextField;\n";
19 | }
20 | function isComponent(libItemName){return libItemName.match(/Components\//i);}
21 | function getClassOfComponent(libItemName){return libItemName.match(/Components\/([a-zA-Z0-9_-]*)/i)[1];}
22 | fl.outputPanel.trace(finalDeclarations);


--------------------------------------------------------------------------------
/Resize Text.jsfl:
--------------------------------------------------------------------------------
 1 | /*
 2 | Resize Text v1
 3 | Copyright © 2007 GGSHOW.NET
 4 | All Rights Reserved.
 5 | 
 6 | Author: Goh Lee Chuan a.k.a. Mr G.
 7 | Email: gg1980@gmail.com
 8 | Homepage: http://www.ggshow.net
 9 | */
10 | var gg_dialog = fl.getDocumentDOM().xmlPanel(fl.configURI+"Commands/Resize Text.xml");
11 | if (gg_dialog.dismiss == "accept") {
12 | 	var w = Number(gg_dialog.w);
13 | 	var h = Number(gg_dialog.h);
14 | 	if ((fl.getDocumentDOM().selection.length != 1) || (fl.getDocumentDOM().selection[0].elementType != 'text')) {
15 | 		alert("Error: You must select a text field instance.");
16 | 	} else if (isNaN(w)||isNaN(h)) {
17 | 		alert("Error: Invalid parameters.");
18 | 	} else {
19 | 		var l = Number(fl.getDocumentDOM().getSelectionRect().left);
20 | 		var t = Number(fl.getDocumentDOM().getSelectionRect().top);
21 | 		var r = Number(fl.getDocumentDOM().getSelectionRect().right);
22 | 		var b = Number(fl.getDocumentDOM().getSelectionRect().bottom);
23 | 		var r1 = l+w-2;
24 | 		var b1 = t+h-2;
25 | 		fl.getDocumentDOM().setTextRectangle({left:l, top:t, right:r1, bottom:b1});
26 | 	}
27 | }


--------------------------------------------------------------------------------
/Scale To Stage.jsfl:
--------------------------------------------------------------------------------
 1 | /*
 2 | Scale To Stage v1
 3 | Copyright © 2007 GGSHOW.NET
 4 | All Rights Reserved.
 5 | 
 6 | Author: Goh Lee Chuan a.k.a. Mr G.
 7 | Email: gg1980@gmail.com
 8 | Homepage: http://www.ggshow.net
 9 | */
10 | var gg_dialog = fl.getDocumentDOM().xmlPanel(fl.configURI+"Commands/Scale To Stage.xml");
11 | var w1 = document.width-2*gg_dialog.margin;
12 | var h1 = document.height-2*gg_dialog.margin;
13 | var x1 = w1/document.width;
14 | var y1 = h1/document.height;
15 | if (gg_dialog.dismiss == "accept") {
16 | 	if (fl.getDocumentDOM().selection.length<=0) {
17 | 		alert("Error: No instance was selected.\nPlease select an instance before running this command.");
18 | 	} else if (isNaN(gg_dialog.margin)) {
19 | 		alert("Error: Invalid parameter.\nThe value for margin must be a number.");
20 | 	} else {
21 | 		fl.getDocumentDOM().match(true, false, true);
22 | 		fl.getDocumentDOM().match(false, true, true);
23 | 		fl.getDocumentDOM().scaleSelection(x1, y1);
24 | 		fl.getDocumentDOM().align('horizontal center', true);
25 | 		fl.getDocumentDOM().align('vertical center', true);
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/Commands/Library - New MC.jsfl:
--------------------------------------------------------------------------------
1 | /**
 * Created by Colin Duffy on 04/20/2010
 */
var doc = fl.getDocumentDOM();
var settings = doc.xmlPanel (fl.configURI + "Commands/Library - New MC.xml");
var lib = doc.library;
	
if (settings.dismiss == "accept") {
	var mcName = "New MC";
	if( settings.mcName.length > 1 ) {
		mcName = settings.mcName;
	}
	lib.addNewItem('movie clip', mcName);
	lib.editItem(mcName);
	fl.trace(lib.getSelectedItems()[0].name);
	
	if(settings.mcClass.length > 1 || settings.mcBase.length > 1) {
		lib.setItemProperty ("linkageExportForAS", true);
		
		if( settings.mcClass == "" ) {
			lib.setItemProperty ("linkageIdentifier", mcName);
		} else {
			lib.setItemProperty ("linkageIdentifier", settings.mcClass);
		}
		
		lib.setItemProperty ("linkageBaseClass", settings.mcBase);
		lib.setItemProperty ("linkageExportInFirstFrame", true);
	}
	
	doc.selectNone();
	doc.getTimeline().addNewLayer("Labels", "normal", true);
	doc.getTimeline().addNewLayer("Actions", "normal", true);
	doc.getTimeline().layers[0].locked = true;
	doc.getTimeline().layers[1].locked = true;
	doc.getTimeline().layers[2].name = "Animation";
	doc.getTimeline().setSelectedLayers(2);
	doc.selectNone();
}


--------------------------------------------------------------------------------
/Slice Bitmap Instance.xml:
--------------------------------------------------------------------------------
 1 | <dialog id="gg_dialog" title="Slice Bitmap Instance" buttons="accept, cancel" >
 2 | 	<grid>
 3 | 		<columns>
 4 | 			<column />
 5 | 			<column />
 6 | 		</columns>
 7 | 		<rows>
 8 | 			<row>
 9 | 				<label value="Rows: " />
10 | 				<textbox id="v" value="3" />
11 | 			</row>
12 | 			<row>
13 | 				<label value="Columns: " />
14 | 				<textbox id="h" value="3" />
15 | 			</row>
16 | 			<row>
17 | 				<label value="Spacing: " />
18 | 				<textbox id="s" value="0" />
19 | 			</row>
20 | 			<row>
21 | 				<label value="Option: "/>
22 | 				<menulist id="o">
23 | 					<menupop>
24 | 						<menuitem label="Mask" value="mask" />
25 | 						<menuitem label="Cut" value="cut" />
26 | 					</menupop>
27 | 				</menulist>
28 | 			</row>
29 | 			<row>
30 | 				<label value="Convert to: "/>
31 | 				<menulist id="t">
32 | 					<menupop>
33 | 						<menuitem label="graphic" value="graphic" />
34 | 						<menuitem label="movie clip" value="movie clip" />
35 | 					</menupop>
36 | 				</menulist>
37 | 			</row>
38 | 			<row>
39 | 				<label value="Name prefix: " />
40 | 				<textbox id="p" value="slice_" />
41 | 			</row>
42 | 		<rows>
43 | 	</grid>
44 | </dialog>
45 | 


--------------------------------------------------------------------------------
/Commands/Timeline - Transform Selected.jsfl:
--------------------------------------------------------------------------------
1 | // created by Colin Duffy (inctm.net)
2 | // on june 24, 2009
3 | var doc = fl.getDocumentDOM();
var tl = doc.getTimeline();
var trace = fl.trace;
var dialogBox = "Commands/Timeline - Transform Selected.xml";

var selectedFrames = tl.getSelectedFrames();
var layer = selectedFrames[0];
var startFrame = selectedFrames[1];
var endFrame = selectedFrames[2];


if (selectedFrames.length <= 0) {
	alert ('Please select an object.' );
} else {
	settings = doc.xmlPanel(fl.configURI + dialogBox);
	if (settings.dismiss == 'accept'){
		var layer = 0;
		var startFrame = 1;
		var endFrame = 2;
		for (var i=0; i<(selectedFrames.length/3); i++){
			for (var n=selectedFrames[startFrame]; n<selectedFrames[endFrame]; n++){
				var frame = tl.layers[selectedFrames[layer]].frames[n];
				if (frame.elements.length > 0){
					if (settings._scale == "true") {
						frame.elements[0].scaleX = Number (settings._wid) / 100;
						frame.elements[0].scaleY = Number (settings._hei) / 100;
					} else {
						frame.elements[0].width = Number (settings._wid);
						frame.elements[0].height = Number (settings._hei);
					}
				}
			}
			layer += 3;
			startFrame += 3;
			endFrame += 3;
		}
	}
}


--------------------------------------------------------------------------------
/Convert Bitmap To MovieClip.jsfl:
--------------------------------------------------------------------------------
 1 | /*
 2 | var xui = fl.getDocumentDOM().xmlPanel(fl.configURI + "Commands/symbol_type.xml");
 3 | if(xui){
 4 | 	fl.outputPanel.trace(xui.type.value);
 5 | }
 6 | */
 7 | var SymbolType = "movieclip";
 8 | 
 9 | var theLibrary = fl.getDocumentDOM().library;
10 | var selectedItems = theLibrary.getSelectedItems();
11 | fl.outputPanel.clear();
12 | for(var itemIndex=0; itemIndex < selectedItems.length; itemIndex++){
13 | 	var theItem = selectedItems[itemIndex];
14 | 	var itemName = theItem.name;
15 | 	var itemDirectoryArray = itemName.split("/");
16 | 	var itemNameNoDir = itemDirectoryArray[itemDirectoryArray.length-1];
17 | 	var newItemName = itemName.split(".")[0];
18 | 	var newItemNameNoDir = itemNameNoDir.split(".")[0];
19 | 	var newItem = theLibrary.addNewItem(SymbolType, newItemName);
20 | 	theLibrary.editItem(newItemName);
21 | 	fl.getDocumentDOM().addItem({x:0,y:0}, theItem);
22 | 	var sel = fl.getDocumentDOM().selection[0];
23 | 	sel.x = 0;
24 | 	sel.y = 0;
25 | 	var outputString = "Convert \"" + itemNameNoDir + "\" to \"" + newItemNameNoDir + "\"";
26 | 	fl.outputPanel.trace(outputString);
27 | }
28 | fl.outputPanel.trace("Conversion Complete!");
29 | fl.getDocumentDOM().currentTimeline = 0;


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/TidyCurrentFLA.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * TidyCurrentFLA.jsfl
 3 |  *
 4 |  * Tidies the library of the currently open FLA with the Utils.tidyLibrary method.
 5 |  *
 6 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 7 |  */
 8 | 
 9 | var config =
10 | {
11 | 	jobID : "000", // PHP's job ID, use to match log entries to jobs
12 | 	logToFile : false, // Whether to log to a file
13 | 	logToIDE : true, // Whether to log to the IDE's output panel
14 | 	libDir : "" // Static JSFL library directory
15 | }
16 | 
17 | var startTime = new Date();
18 | var scriptPath = fl.scriptURI;
19 | var scriptPathParts = scriptPath.split("/");
20 | var scriptName = scriptPathParts[scriptPathParts.length-1];
21 | var scriptDir = scriptPath.split(scriptName)[0];
22 | 
23 | config.libDir = scriptDir+"lib/";
24 | 
25 | fl.runScript(config.libDir+"Utils.jsfl");
26 | fl.runScript(config.libDir+"Logger.jsfl");
27 | 
28 | Utils.initLogger(config,scriptName);
29 | 
30 | try
31 | {
32 | 	Utils.tidyLibrary(fl.getDocumentDOM());
33 | 	Utils.tidyLibrary(fl.getDocumentDOM());
34 | }
35 | catch (p_error)
36 | {
37 | 	Logger.log("Error tidying library. "+p_error,Logger.CRITICAL);
38 | }
39 | 
40 | Logger.log("Script exiting ("+((new Date().getTime()-startTime.getTime())/1000)+"s)");


--------------------------------------------------------------------------------
/movieclip to swf.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Recursively exports selected movie clips in the library as swf's.
 3 |  */
 4 | function MovieClipToSWF()
 5 | {
 6 | 	var docPath=document.path.replace(/\\/g,'/').split('/').slice(0,-1).join('/')+"/";
 7 | 	var exportPath=docPath='file:///'+docPath;
 8 | 	var dom=fl.getDocumentDOM();
 9 | 	var si=dom.library.getSelectedItems();
10 | 	var publishProfileSource=docPath+document.name.toString().replace(/\.fla/i,"")+'_publishProfile.xml';
11 | 	dom.exportPublishProfile(publishProfileSource);
12 | 	var publishProfile=FLfile.read(publishProfileSource);
13 | 	var exportval=publishProfile.match(/<flashFileName>(.*)<\/flashFileName>/)[1].replace(/\\/g,"/");
14 | 	exportPath=((docPath.indexOf("/")>-1)?docPath+exportval.split("/").slice(0,-1).join("/")+"/":docPath).replace("file:////","");
15 | 	while(exportPath.match(/\/$/))exportPath=exportPath.replace(/\/$/,"");
16 | 	if(si.length==0)alert('ERROR: No Library items are selected.');
17 | 	else for(var i=0;i<si.length;i++)if(si[i].itemType=='movie clip')(si[i].name.indexOf("/")>-1)?si[i].exportSWF("file:///"+exportPath+"/"+(si[i].name.split("/").slice(-1))+".swf"):si[i].exportSWF("file:///"+exportPath+"/"+si[i].name+".swf");
18 | 	FLfile.remove(publishProfileSource);
19 | }
20 | MovieClipToSWF();


--------------------------------------------------------------------------------
/Commands/Timeline - Layer Settings.jsfl:
--------------------------------------------------------------------------------
1 | /*

made by: colin duffy
created: nov.11.2008

*/

trace = fl.trace;

var select = fl.getDocumentDOM ().getTimeline ().getSelectedLayers ();

settings = fl.getDocumentDOM ().xmlPanel (fl.configURI + "Commands/Timeline - Layer Settings.xml");

if (settings.dismiss == "accept") {
	
	var totalLayers = fl.getDocumentDOM ().getTimeline ().getSelectedLayers ();
	
	var layer = fl.getDocumentDOM ().getTimeline ();
	
	for (i = 0; i < totalLayers.length; i ++) {
		
		// visible		
		(settings._seen == 'true') ? layer.layers[totalLayers[i]].visible = true : layer.layers[totalLayers[i]].visible = false;
		
		// locked		
		(settings._locked == 'true') ? layer.layers[totalLayers[i]].locked = true : layer.layers[totalLayers[i]].locked = false;
		
		// layer type
		
		if (settings._type == '_normal') {
			layer.layers[totalLayers[i]].layerType = 'normal';
		} else if (settings._type == '_guide') {
			layer.layers[totalLayers[i]].layerType = 'guide';
		} else if (settings._type == '_mask') {
			layer.layers[totalLayers[i]].layerType = 'mask';
		} else if (settings._type == '_folder') {
			layer.layers[totalLayers[i]].layerType = 'folder';
		}
		
		if (settings._color.length == 6) {
			layer.layers[totalLayers[i]].color = '#' +  settings._color;
		}
	}
}


--------------------------------------------------------------------------------
/ExportSounds.jsfl:
--------------------------------------------------------------------------------
 1 | var lib;
 2 | if (fl.getDocumentDOM().library.getSelectedItems().length > 0) {
 3 |     lib = fl.getDocumentDOM().library.getSelectedItems(); 
 4 | } else { lib = fl.getDocumentDOM().library.items; } 
 5 | 
 6 | // Get destination directory for files 
 7 | var imageFileURLBase = fl.browseForFolderURL("Select a folder."); 
 8 | var imageFileURL; 
 9 | 
10 | var totalItems = lib.length;
11 | // Iterate through items and save bitmaps and 
12 | // audio files to the selected directory.
13 | for (var i = 0; i < totalItems; i++) 
14 | {
15 |     var libItem = lib[i];
16 |     if (libItem.itemType == "bitmap" || libItem.itemType == "sound") 
17 |     {
18 |         // Check the audio files original Compression Type if "RAW" export only as a .wav file
19 |         // Any other compression type then export as the libItem's name defines.
20 |         if(libItem.itemType == "sound" && libItem.originalCompressionType == "RAW")
21 |         {
22 |             wavName = libItem.name.split('.')[0]+'.wav';
23 |             imageFileURL = imageFileURLBase + "/" + wavName;
24 |         } else {
25 |             imageFileURL = imageFileURLBase + "/" + libItem.name;
26 |         }
27 |         var success = libItem.exportToFile(imageFileURL);
28 |         fl.trace(imageFileURL + ": " + success);
29 |     }
30 | }


--------------------------------------------------------------------------------
/[TEK]-Change Case.jsfl:
--------------------------------------------------------------------------------
 1 | var win=fl.getDocumentDOM().xmlPanel(fl.configURI+"Commands/teknision/windows/changecase.xml");
 2 | if(win.dismiss=="accept"){
 3 | 	
 4 | 	//get text selection
 5 | 	var doc=fl.getDocumentDOM();
 6 | 	var textstr=doc.getTextString();
 7 | 	var state=win.casestate;
 8 | 	if(state=="u"){
 9 | 		//uppercase
10 | 		var fstring=textstr.toUpperCase();
11 | 	}else if(state=="l"){
12 | 		//lowercase
13 | 		var fstring=textstr.toLowerCase();
14 | 	}else if(state=="m"){
15 | 		var strsplit=textstr.split(" ");
16 | 		var fstring="";
17 | 		for(var i=0;i<strsplit.length;i++){
18 | 			var atext=strsplit[i];
19 | 			var ntext=atext.charAt(0).toUpperCase()+(atext.substring(1,atext.length).toLowerCase());
20 | 			fstring+=ntext+" "
21 | 		}
22 | 	}else if(state=="ms"){
23 | 		var strsplit=textstr.split(".");
24 | 		var fstring="";
25 | 		for(var i=0;i<strsplit.length;i++){
26 | 			var atext=strsplit[i];
27 | 			if(atext.charAt(0)==" "){
28 | 				var ntext=" "+atext.charAt(1).toUpperCase()+(atext.substring(2,atext.length).toLowerCase());
29 | 			}else{
30 | 				var ntext=atext.charAt(0).toUpperCase()+(atext.substring(1,atext.length).toLowerCase());
31 | 			}
32 | 			if(i==strsplit.length-1){
33 | 				fstring+=ntext
34 | 			}else{
35 | 				fstring+=ntext+"."
36 | 			}
37 | 		}
38 | 	}
39 | 	doc.setTextString(fstring);
40 | }


--------------------------------------------------------------------------------
/JPEG Compression Settings.jsfl:
--------------------------------------------------------------------------------
 1 | 
 2 | function init()
 3 | {
 4 | 	fl.outputPanel.clear();
 5 | 	
 6 | 	var obj = fl.getDocumentDOM().xmlPanel(fl.configURI+"Commands/JXL/JPEG Compression/jpegsettings.xml");
 7 | 	//var obj = fl.getDocumentDOM().xmlPanel("file:///C:/Documents and Settings/Syle/My Documents/_Projects/JPEG Compression Extension/jpegsettings.xml");
 8 | 	if(obj.dismiss == "cancel")
 9 | 	{
10 | 		return;
11 | 	}
12 | 	var a = obj.jpegcompression;
13 | 	if(a == "")
14 | 	{
15 | 		alert("JPEG Compression cannot be left blank, use the slider to change the value,\n or type in your desired compression number amount into the text field.");
16 | 		return;
17 | 	}
18 | 
19 | 	var compressionValue = parseInt(obj.jpegcompression);
20 | 	if(isNaN(compressionValue))
21 | 	{
22 | 		alert("JPEG Compression value has to be a number.  Use the slider instead of typing into the text field.");
23 | 		return;
24 | 	}
25 | 	var doSmoothing = obj.smoothing;
26 | 	
27 | 	selItems = fl.getDocumentDOM().library.getSelectedItems();
28 | 	var i = selItems.length;
29 | 	var i2 = selItems.length;
30 | 	while(i--)
31 | 	{
32 | 		selItems[i].useImportedJPEGQuality = false;
33 | 		selItems[i].compressionType = "photo";
34 | 		selItems[i].quality = parseInt(compressionValue);
35 | 		// JXL: Bug... not setting this? At least, the dialogue doesn't show it.
36 | 		selItems[i].allowSmoothing = doSmoothing;
37 | 	}
38 | }
39 | 
40 | init();
41 | 


--------------------------------------------------------------------------------
/[TEK]-Find In Library.jsfl:
--------------------------------------------------------------------------------
1 | //Find in Library
var doc=fl.getDocumentDOM();
var query="Symbol";
var results=new Array();

if(!doc) {
	alert("Please open a file before using the Find In Library command");
} else {

	if(doc.selection[0]!=null && doc.selection[0].elementType=="instance"){
		fl.runScript(fl.configURI+"Commands/teknision/utilities/tekLibUtilities.jsfl","setAllFolders",false);
		fl.runScript(fl.configURI+"Commands/teknision/utilities/tekLibUtilities.jsfl","expandAndSelect",doc.selection[0].libraryItem.name,false);
	}else{
		
		var win=doc.xmlPanel(fl.configURI+"Commands/teknision/windows/find_in_Library.xml");
		if(win.dismiss!="cancel"){
			var query=win.query;
			if(win.gotoedit=="true"){
				var editview=true;
			}else{
				var editview=false;
			}
			
			
			var lib=doc.library;
			var items=lib.items;
			
			for(var i=0;i<items.length;i++){
				var item=items[i];
				var pathsplit=item.name.split("/");
				var mainname=pathsplit[pathsplit.length-1];
				
				var inname=mainname.split(query);
				
				if(inname.length>1){
					results.push(item);
				}
				
				
				
				
			}
			results.reverse();
			
			if(results.length>0){
				fl.runScript(fl.configURI+"Commands/teknision/utilities/tekLibUtilities.jsfl","setAllFolders",false);
				fl.runScript(fl.configURI+"Commands/teknision/utilities/tekLibUtilities.jsfl","expandAndSelect",results[0].name,editview);
			}else{
				alert("No Symbol Found");
			}
		}
	}
	
	
}


--------------------------------------------------------------------------------
/[TEK]-Clean Up Library.jsfl:
--------------------------------------------------------------------------------
 1 | if(!fl.getDocumentDOM()) {
 2 | 	alert("Please open a file before using the Clean Up Designer Library command");
 3 | } else {
 4 | 	
 5 | 	///////////////////////////////////////////////////////////////
 6 | 	// DATA HOLDERS
 7 | 	var lib=fl.getDocumentDOM().library;
 8 | 	var items=lib.items;
 9 | 
10 | 	var disalloweditems=new Array();
11 | 	var disallowednames=new Array();
12 | 	
13 | 	var libselitems=lib.getSelectedItems();
14 | 	
15 | 	
16 | 	
17 | 	///////////////////////////////////////////////////////////////
18 | 	//UI PATHS
19 | 	
20 | 	var win=fl.getDocumentDOM().xmlPanel(fl.configURI+"Commands/teknision/windows/Clean_Designer_Library.xml");
21 | 	
22 | 	
23 | 	if(win.dismiss=="accept"){
24 | 		
25 | 		///////////////////////////////////////////////////////////////
26 | 		//RETIREVE PROPS FROM UI
27 | 		
28 | 		if(win.ftitle==null){
29 | 			var sortfolder="OrganizedElements";
30 | 		}else{
31 | 			var sortfolder=win.ftitle;
32 | 		}
33 | 		
34 | 		if(win.utitle==null){
35 | 			var badfolder="UNNAMED";
36 | 		}else{
37 | 			var badfolder=win.utitle;
38 | 		}
39 | 		
40 | 		if(win.allowFolders=="false"){
41 | 			disalloweditems.push("folder");
42 | 		}
43 | 		
44 | 		if(win.unames!=null){
45 | 			var spl=win.unames.split(",");
46 | 			for(var x=0;x<spl.length;x++){
47 | 				disallowednames.push(spl[x]);
48 | 			}
49 | 		}
50 | 
51 | 		fl.runScript(fl.configURI+"Commands/teknision/utilities/tekLibUtilities.jsfl","organizeFolder","",sortfolder,badfolder,disalloweditems,disallowednames);
52 | 	
53 | 	}
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/Round Pixel Coordinates.jsfl:
--------------------------------------------------------------------------------
 1 | function init()
 2 | {
 3 | 	fl.outputPanel.clear();
 4 | 	var timeline = fl.getDocumentDOM().getTimeline();
 5 | 	var currentLayer = timeline.currentLayer;
 6 | 	var currentFrame = timeline.currentFrame;
 7 | 	var elements_array = timeline.layers[currentLayer].frames[currentFrame].elements;
 8 | 	var i = elements_array.length;
 9 | 	while(i--)
10 | 	{
11 | 		var item = elements_array[i];
12 | 		if(item.elementType == "shape")
13 | 		{
14 | 			var theName = "some shape";
15 | 		}
16 | 		else
17 | 		{
18 | 			var theName = item.name;
19 | 			if(theName == "")
20 | 			{
21 | 				theName = "some instance";
22 | 			}
23 | 		}
24 | 		var matX = item.matrix;
25 | 		var x = matX.tx;
26 | 		if(!getIsWholeInt(x))
27 | 		{
28 | 			fl.trace(theName + "'s x was: " + x);
29 | 			matX.tx = round(x);
30 | 			item.matrix = matX;
31 | 			fl.trace(theName + "'s x now is: " + round(x));
32 | 		}
33 | 		
34 | 		var matY = item.matrix;
35 | 		var y = matY.ty;
36 | 		if(!getIsWholeInt(y))
37 | 		{
38 | 			fl.trace(theName + "'s y was: " + y);
39 | 			matY.ty = round(y);
40 | 			item.matrix = matY;
41 | 			fl.trace(theName + "'s y now is: " + item.matrix.ty);
42 | 		}
43 | 	}
44 | 	
45 | }
46 | 
47 | function getIsWholeInt(n)
48 | {
49 | 	var s = String(n);
50 | 	if(s.indexOf(".") != -1)
51 | 	{
52 | 		return false;
53 | 	}
54 | 	else
55 | 	{
56 | 		return true;
57 | 	}
58 | }
59 | 
60 | function round(n)
61 | {
62 | 	var s = String(n);
63 | 	var a = s.split(".");
64 | 	var num = parseInt(a[0]);
65 | 	var dec = parseInt(a[1].substr(0, 1));
66 | 	if(dec >= 5)
67 | 	{
68 | 		num++;
69 | 	}
70 | 	return num;
71 | }
72 | 
73 | // start this mug
74 | init();


--------------------------------------------------------------------------------
/xmui/wrap selected as new symbol.xml:
--------------------------------------------------------------------------------
 1 | <dialog id="ConvertAllToClips" title="Wrap selected items as new symbol" buttons="accept,cancel">
 2 | 	<grid>
 3 | 		<columns>
 4 | 			<column/>
 5 | 			<column/>
 6 | 		</columns>
 7 | 		<row>
 8 | 			<label value="Item type " control="itemType" />
 9 | 			<menulist id="itemType">
10 | 				<menupop>
11 | 					<menuitem label="movie clip" selected="true" />
12 | 					<menuitem label="button" selected="false" />
13 | 					<menuitem label="graphic" selected="false" />
14 | 				</menupop>
15 | 			</menulist>
16 | 		</row>
17 | 		<row>
18 | 			<label value="Registration Point" control="regPoint" />
19 | 			<menulist id="regPoint">
20 | 				<menupop>
21 | 					<menuitem label="top left" selected="true" />
22 | 					<menuitem label="top center" selected="false" />
23 | 					<menuitem label="top right" selected="false" />
24 | 					<menuitem label="center left" selected="false" />
25 | 					<menuitem label="center" selected="false" />
26 | 					<menuitem label="center right" selected="false" />
27 | 					<menuitem label="bottom left" selected="false" />
28 | 					<menuitem label="bottom center" selected="false" />
29 | 					<menuitem label="bottom right" selected="false" />
30 | 				</menupop>
31 | 			</menulist>
32 | 		</row>
33 | 		<row>
34 | 			<label value="Item name prefix " control="itemName" /><textbox id="itemName" value="convertedItem_" maxlength="100" />
35 | 		</row>
36 | 		<row>
37 | 			<label value="Folder name " control="folderName" /><textbox id="folderName" value="_convertedItems" maxlength="100" />
38 | 		</row>
39 | 		<row>
40 | 			<label value="Use leading zeroes " control="leadingZeroes" /><checkbox id="leadingZeroes" />
41 | 		</row>
42 | 	</grid>
43 | </dialog>
44 | 


--------------------------------------------------------------------------------
/[TEK]-Convert Distribute.jsfl:
--------------------------------------------------------------------------------
 1 | 
 2 | //layer delete function////////////
 3 | 
 4 | function deleteTekLayers(){
 5 | 	doc=fl.getDocumentDOM();
 6 | 	tl=doc.getTimeline();
 7 | 	var slayers=tl.findLayerIndex("[tek]-removeLayer");
 8 | 	
 9 | 	for(var i=0;i<slayers.length;i++){
10 | 		tl.deleteLayer(slayers[i]);
11 | 	}
12 | }
13 | //////////////////////////////////
14 | 
15 | 
16 | 
17 | doc=fl.getDocumentDOM();
18 | tl=doc.getTimeline();
19 | 
20 | 
21 | //distribute selection
22 | tl.setLayerProperty("name","[tek]-removeLayer","selected");
23 | doc.distributeToLayers();
24 | 
25 | if(doc.selection.length>0){	
26 | 	//get layer info and lock all layers
27 | 	var selectedLayer=tl.getSelectedLayers();
28 | 	layers=tl.layers;
29 | 	tl.setLayerProperty("locked",true,"all");
30 | 	
31 | 	// isolate and convert each object
32 | 	for(var i=0;i<layers.length;i++){
33 | 		doc.selectNone();
34 | 		tl.setSelectedLayers(i,i);
35 | 		tl.setLayerProperty("locked",false,"selected");
36 | 		doc.selectAll();
37 | 		if(doc.selection.length>0){
38 | 			//convert only if not symbol
39 | 			var seltype=doc.selection[0].instanceType;
40 | 			if(seltype!="symbol"){
41 | 				var iitem=doc.selection[0].libraryItem;
42 | 				if(iitem==null){
43 | 					var iname=doc.selection[0].elementType+"_"+i;
44 | 				}else{
45 | 					var iname=iitem.name;
46 | 				}
47 | 				var isplit=iname.split(".");
48 | 				var uname=isplit[0];
49 | 				tl.setLayerProperty("name",uname,"selected");
50 | 				doc.convertToSymbol("movie clip",uname,"top left");
51 | 				doc.setElementProperty("name",uname+"_mc");
52 | 			}
53 | 		}
54 | 		tl.setLayerProperty("locked",true,"selected");
55 | 	}
56 | 	
57 | 	
58 | 	
59 | 	tl.setLayerProperty("locked",false,"all");
60 | 	deleteTekLayers();
61 | }
62 | 


--------------------------------------------------------------------------------
/[TEK]-Swap Across Layer.jsfl:
--------------------------------------------------------------------------------
1 | var doc=fl.getDocumentDOM();
if(!doc) {
	alert("Please open a file before using the Swap Symbol Accross Layer command");
} else {
	
	var lib=doc.library;
	
	var sellib=lib.getSelectedItems()[0];
	
	if(doc.selection.length!=1 || lib.getSelectedItems().length!=1){
		alert("In order to use Swap Symbol Across Layer, you must select an instance on stage and a library item to swap it with. You may have no more than one stage element and one library item selected. Be sure there are no other items on each frame of the layer other than the instance of the symbol, otherwise, Swap Symbol Across Layer will fail.");
	}else{
		var tl=doc.getTimeline();
		var fselframe=tl.getSelectedFrames();
		var selitem=doc.selection[0].libraryItem.name;
		var sellib=lib.getSelectedItems()[0];
		var lay=tl.layers[tl.currentLayer];
		var frs=lay.frames;
		
		//save layer locks
		var slay=new Array();
		for(var i=0;i<tl.layers.length;i++){
			slay.push(tl.layers[i].locked);
		}
		
		tl.setLayerProperty("locked",true,"others");
		tl.setLayerProperty("locked",false,"selected");
		

		for(var i=0;i<frs.length;i++){
			var fr=frs[i];
			if(fr.elements.length>1){
				alert("There is more than one item on the frame "+(i+1)+". Swap Symbol Across Layer only works with layers containing one instance across frames.");
				break;
			}else{
				if(fr.elements.length>0){
					var el=fr.elements[0];
					var symbolname=el.libraryItem.name;
					doc.selectNone();
					if(selitem==symbolname && fr.startFrame==i){
						tl.setSelectedFrames(i,i+1);
						doc.selectAll();
						doc.swapElement(sellib.name);
					}
				}
			}
		}
		
		for(var i=0;i<slay.length;i++){
			tl.setSelectedLayers(i,i);
			tl.setLayerProperty("locked",slay[i],"selected");
		}
		
		tl.setSelectedFrames(fselframe,fselframe+1);
	
	}
}


--------------------------------------------------------------------------------
/Enable Excludes.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 | 
 3 | 	Enable Excludes JSFL
 4 | 	Martijn de Visser
 5 | 	http://www.martijndevisser.com/
 6 | 
 7 | 	This script enables all *_exclude.xml files in the /excludes/ directory (in same directory as the current
 8 | 	open .fla document) by moving them to the same directory as the folder of the current .fla file.
 9 | */
10 | 
11 | // get current path
12 | var path = fl.getDocumentDOM().path;
13 | 
14 | if (path != undefined) {
15 | 
16 | 	fl.outputPanel.clear();
17 | 
18 | 	// cleanup path
19 | 	path = path.substr(0, path.lastIndexOf("\\") + 1);
20 | 	path = path.replace(/\\/g, "/");
21 | 	path = "file:///" + path;
22 | 
23 | 	// we need a bit of a workaround here, as JSFL appears
24 | 	// not to list files correctly when using wildcards (at least under Win2k).
25 | 	// FLfile.listFolder(path + "_exclude.xml", "files"); should
26 | 	// be sufficient, but files with multiple '_' in them will
27 | 	// then be ignored.
28 | 	var source = FLfile.listFolder(path + "excludes/*.xml", "files");
29 | 	var files = new Array();
30 | 	for (var i=0; i<source.length; ++i) {
31 | 
32 | 		if (source[i].indexOf("_exclude.xml")) {
33 | 
34 | 			files[files.length] = source[i];
35 | 		}
36 | 	}
37 | 
38 | 	fl.trace("Enable Excludes\nMoving '*_exclude.xml' to current folder...");
39 | 
40 | 	// move files
41 | 	var count = 0;
42 | 	for (var i=0; i<files.length; ++i) {
43 | 
44 | 		var name = files[i];
45 | 		var source = path + "excludes/" + name;
46 | 		var target = path + name;
47 | 
48 | 		if (FLfile.copy(source,target)) {
49 | 
50 | 			FLfile.remove(source);
51 | 			fl.trace(" - " + name);
52 | 			count++;
53 | 		}
54 | 
55 | 	}
56 | 
57 | 	fl.trace(count + " files moved.");
58 | 
59 | } else {
60 | 
61 | 	alert("Enable Excludes JSFL:\n\nSave file before applying this command.");
62 | }


--------------------------------------------------------------------------------
/GetProfile.jsfl:
--------------------------------------------------------------------------------
 1 | /****************************************************
 2 |  * Set the desired publish profile properties in    *
 3 |  * the flash IDE. Run this script from the Commands *
 4 |  * Menu and cut and paste the output from into the  *
 5 |  * export script                                    *
 6 |  * Some modification will need to be made to take   *
 7 |  * the width, height and name of each item. See the *
 8 |  * export script for an example                     *
 9 |  *                                                  *
10 |  * Author: C.Wilson - abitofcode                    *
11 |  * Date: 19-11-2011                                 *
12 |  ****************************************************/
13 |  
14 | // clear the output window
15 | fl.outputPanel.clear()
16 | 
17 | // Get a path to save the current profile information into
18 | var saveDir = fl.browseForFolderURL("Save your profile template where:")
19 | var profFile = saveDir + '/pubprofile_template.xml'
20 | 
21 | // Export the current publish profile
22 | fl.getDocumentDOM().exportPublishProfile(profFile);
23 | 
24 | // Read the profile we have exported back into a string
25 | var str = FLfile.read( profFile);
26 | if (str) {
27 |     // Split the profile XML by line break
28 |     var lines = str.split("\n");
29 | 
30 |     // Start building the profile string that we'll use in 
31 |     // the export script.
32 |     var profileString = "\tprofile = ";
33 |     
34 |     // loop through each line formatting for use in the template
35 |     for(line in lines){
36 |         if(lines[line]) {
37 |             profileString += "\t'" + lines[line] + "\\n' + \n";        
38 |         }
39 |     }
40 |   
41 |     // Output the profile string to the output window so we can
42 |     // cut and paste into the export script
43 |     fl.trace(profileString);
44 | }
45 | 
46 | 
47 | 
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/Commands/Library - Quick Duplicate.jsfl:
--------------------------------------------------------------------------------
1 | /**
 *
 * made by: colin duffy
 * created: dec.2.2008
 *
 **/

trace = fl.trace;
var lib = fl.getDocumentDOM().library;
var select = [];
select = lib.getSelectedItems ();

if (select.length <= 0) {
	
	alert ("Please make a selection in the library" );
	
} else {
	settings = fl.getDocumentDOM ().xmlPanel (fl.configURI + "Commands/Library - Quick Duplicate.xml");
	var folder = '';
	if (settings.dismiss == "accept") {
		var _items = select;
		var total = Number (settings._num);
		
		if (total > 0) {
			
			for (var i = 0; i < _items.length; i++) {
				
				// FOLDER NAME TO PLACE DUPLICATES INTO
				if (settings.folderName != '') {
					folder = settings.folderName;
				} else {
					folder = _items[i].name + ' duplicates';
				}
				lib.newFolder (folder);
				
				// LINAGE
				var linkage = lib.getItemProperty ("linkageBaseClass");
				
				n = 0;			
				while (n < total) {
					if (lib.duplicateItem (_items [i].name)) {
						var _selected = lib.getSelectedItems ();
						lib.selectItem (_items [i].name + ' copy');
						var split = _items [i].name.split ('/');
						
						// ITEM NAME
						var itemName = '';
						(n < 9) ? itemName = split[split.length-1] + '[0' + (n + 1) + ']' : itemName =  split[split.length-1] + '[' + (n + 1) + ']';
						lib.setItemProperty ('name', itemName);
						
						// BASE CLASS
						if (settings.copyBaseClass == "true")
						{
							lib.setItemProperty ("linkageExportForAS", true);
							lib.setItemProperty ("linkageIdentifier", itemName);
							lib.setItemProperty ("linkageBaseClass", linkage);
							lib.setItemProperty ("linkageExportInFirstFrame", true);
						}
						
						// MOVE TO FOLDER
						lib.moveToFolder (folder);
						lib.expandFolder (false, true, folder);
						lib.selectItem (_selected);
					} else {
						alert (_items [i].name + '[' + n + '] was not created');
					}
					n++;
				}
			}
		} else {
			alert ("1 or More duplicates required" );
		}
	}
}


--------------------------------------------------------------------------------
/Disable Excludes.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 | 
 3 | 	Disable Excludes JSFL
 4 | 	Martijn de Visser
 5 | 	http://www.martijndevisser.com/
 6 | 
 7 | 	This script disables all *_exclude.xml files in the same directory as the current open .fla document by
 8 | 	moving them to /excludes/ subdirectory. This directory will be created if not present.
 9 | */
10 | 
11 | // get current path
12 | var path = fl.getDocumentDOM().path;
13 | 
14 | if (path != undefined) {
15 | 
16 | 	fl.outputPanel.clear();
17 | 
18 | 	// cleanup path
19 | 	path = path.substr(0, path.lastIndexOf("\\") + 1);
20 | 	path = path.replace(/\\/g, "/");
21 | 	path = "file:///" + path;
22 | 
23 | 	// we need a bit of a workaround here, as JSFL appears
24 | 	// not to list files correctly when using wildcards (at least under Win2k)..
25 | 	// FLfile.listFolder(path + "_exclude.xml", "files"); should
26 | 	// be sufficient, but files with multiple '_' in them will
27 | 	// then be ignored.
28 | 	var source = FLfile.listFolder(path + "*.xml", "files");
29 | 	var files = new Array();
30 | 	for (var i=0; i<source.length; ++i) {
31 | 
32 | 		if (source[i].indexOf("_exclude.xml")) {
33 | 
34 | 			files[files.length] = source[i];
35 | 		}
36 | 	}
37 | 
38 | 	fl.trace("Disable Excludes\nMoving '*_exclude.xml' to './excludes/' ...");
39 | 
40 | 	// is target directory present?
41 | 	if (!FLfile.exists(path + "excludes/")) {
42 | 		fl.trace("folder ./excludes/ not present, creating...");
43 | 		FLfile.createFolder(path + "excludes/");
44 | 	}
45 | 
46 | 	// move files
47 | 	var count = 0;
48 | 	for (var i=0; i<files.length; ++i) {
49 | 
50 | 		var name = files[i];
51 | 		var source = path + name
52 | 		var target = path + "excludes/" + name
53 | 
54 | 		if (FLfile.copy(source, target)) {
55 | 
56 | 			FLfile.remove(source);
57 | 			fl.trace(" - " + name);
58 | 			count++;
59 | 		}
60 | 	}
61 | 
62 | 	fl.trace(count + " files moved.");
63 | 
64 | } else {
65 | 
66 | 	alert("Disable Excludes JSFL:\n\nSave file before applying this command.");
67 | }


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/lib/Logger.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Logger
 3 |  *
 4 |  * Logs debug information to a log file and/or the Flash IDE's output panel.
 5 |  *
 6 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 7 |  */
 8 | 
 9 | var Logger =
10 | {
11 | 	SYSTEM : "[SYST]",
12 | 	WARNING : "[WARN]",
13 | 	CRITICAL : "[CRIT]",
14 | 	
15 | 	logToFile : true,
16 | 	logToIDE : true,
17 | 	logFilePath : "",
18 | 	jobID : "",
19 | 	scriptName : "",
20 | 
21 | 	/**
22 | 	 * Logger needs to be initialised before use.
23 | 	 *
24 | 	 * @param p_logToFile Boolean value, whether to log ouput to a file.
25 | 	 * @param p_logToIDE Boolean valuem whether to log outout to the IDE.
26 | 	 * @param p_logFilePath Full file path to the desired log file location.
27 | 	 * @param p_jobID A reference number to the current job ID, supplied to the main script by PHP.
28 | 	 * @param p_scriptName The filename of the currently running script.
29 | 	 *
30 | 	 * @return Void.
31 | 	 */
32 | 	init : function(p_logToFile,p_logToIDE,p_logFilePath,p_jobID,p_scriptName)
33 | 	{
34 | 		this.logToFile = p_logToFile;
35 | 		this.logToIDE = p_logToIDE;
36 | 		this.logFilePath = p_logFilePath;
37 | 		this.jobID = p_jobID;
38 | 		this.scriptName = p_scriptName;
39 | 
40 | 		if ( this.logToIDE )
41 | 		{
42 | 			fl.outputPanel.clear();
43 | 		}
44 | 	},
45 | 
46 | 	/**
47 | 	 * Log a message.
48 | 	 *
49 | 	 * @param p_logItem String to log.
50 | 	 * @param p_type String specifying the type of message, i.e. SYSTEM, WARNING or CRITICAL.
51 | 	 *
52 | 	 * @return Void.
53 | 	 */
54 | 	log : function(p_logItem,p_type)
55 | 	{
56 | 		var output = this.jobID+" "+this.scriptName+" "+Utils.getTimeStamp();
57 | 
58 | 		if ( !p_type || p_type === "" )
59 | 		{
60 | 			output = this.SYSTEM+" "+output;
61 | 		}
62 | 		else
63 | 		{
64 | 			output = p_type+" "+output;
65 | 		}
66 | 
67 | 		output = output+" > "+p_logItem;
68 | 
69 | 		if ( this.logToIDE )
70 | 		{
71 | 			fl.outputPanel.trace(output);
72 | 		}
73 | 
74 | 		FLfile.write(this.logFilePath,output+"\n","append");
75 | 	}
76 | };


--------------------------------------------------------------------------------
/Convert Symbol to Flex Container.jsfl:
--------------------------------------------------------------------------------
 1 | // This script does the following:
 2 | // 
 3 | // 1. Calls the "Make Flex Component" command
 4 | //
 5 | // 2. Creates a "FlexContent" symbol that uses FlexContentHolder as a base class
 6 | //    
 7 | 
 8 | var doc = null;
 9 | 
10 | function getSymbol(name) {
11 | 	// search library for specified item
12 | 	var items = doc.library.items;
13 | 	for (var i = 0; i < items.length; i++) {
14 | 		var shortName = items[i].name;
15 | 		var slashIndex = shortName.lastIndexOf("/");
16 | 		if (slashIndex >= 0) {
17 | 			shortName = shortName.substr(slashIndex + 1);
18 | 		}
19 | 		if (shortName == name) {
20 | 			return items[i];
21 | 		}
22 | 	}
23 | 
24 | 	return null;
25 | }
26 | 
27 | function createFlexContentSymbol() {
28 | 	var flexContentSymbol = getSymbol("FlexContentHolder");
29 | 
30 | 	// If the symbol already exists, there is nothing more to do...
31 | 	if (flexContentSymbol != null)
32 | 		return true;
33 | 
34 | 	var holderDoc = fl.openDocument(fl.configURI + "Libraries/ContentHolder.fla");
35 | 	var copiedSymbol = false;
36 | 
37 | 	if (holderDoc) {
38 | 		holderDoc.library.addItemToDocument({x:0, y:0}, "FlexContentHolder");
39 | 		holderDoc.clipCopy();
40 | 		holderDoc.close(false);
41 | 		copiedSymbol = true;
42 | 	}
43 | 
44 | 	if (copiedSymbol) {
45 | 		doc.clipPaste();
46 | 		doc.deleteSelection();
47 | 
48 | 		flexContentSymbol = getSymbol("FlexContentHolder");
49 | 
50 | 		if (flexContentSymbol != null)
51 | 		{
52 | 			flexContentSymbol.linkageExportForAS = true;
53 | 			flexContentSymbol.linkageExportInFirstFrame = true;
54 | 			flexContentSymbol.linkageBaseClass = "mx.flash.FlexContentHolder";
55 | 			flexContentSymbol.linkageClassName = "FlexContentHolder";
56 | 
57 | 			return true;
58 | 		}
59 | 	}
60 | 
61 | 	return false;
62 | }
63 | 
64 | // Main execution starts here
65 | doc = fl.getDocumentDOM();
66 | 
67 | if (fl.runScript(fl.configURI + 'Javascript/MakeFlexComponent.jsfl', 'makeFlexComponent', 'mx.flash.ContainerMovieClip',
68 |  		'Add the \'FlexContentHolder\' symbol to define the Flex content area.'))
69 | 	createFlexContentSymbol()
70 | 


--------------------------------------------------------------------------------
/Bitmaps-Quality.jsfl:
--------------------------------------------------------------------------------
 1 | function bitmap_quality(doc){ 
 2 | 	
 3 | 	var path=getFolderURI(doc.path);
 4 | 	var tempFile=path.substr(0,path.lastIndexOf('/'))+'/temp.swf';
 5 | 	
 6 | 	var library=fl.getDocumentDOM().library;
 7 | 	var items=library.items;
 8 | 	var items_length=items.length;
 9 | 	for( var h = 0; h < items_length; h++){
10 | 		var item=items[h];
11 | 		var item_name=item.name.substr(item.name.lastIndexOf('/')+1);		
12 | 		if(item.itemType=='bitmap'){
13 | 			if(!item.useImportedJPEGQuality){
14 | 				
15 | 				item.compressionType='lossless';
16 | 				doc.exportSWF(tempFile,true);
17 | 				var lossless_size=FLfile.getSize(tempFile);
18 | 				
19 | 				item.compressionType='photo';
20 | 				item.quality=100;
21 | 				doc.exportSWF(tempFile,true);
22 | 				var photo_size=FLfile.getSize(tempFile);
23 | 				
24 | 				var advantage=lossless_size-photo_size;
25 | 				
26 | 				if(advantage<500){
27 | 					item.compressionType='lossless';
28 | 				}else{
29 | 					item.compressionType='photo';
30 | 					item.quality=90;
31 | 				}
32 | 				
33 | 				fl.trace(item_name+' compression decided to be '+item.compressionType);
34 | 				FLfile.remove(tempFile);
35 | 				
36 | 			}
37 | 		}
38 | 	}
39 | }
40 | 
41 | function kbytes(bytes) {
42 | 	return (Math.round((bytes/1024)*10)/10)+' kb';
43 | }
44 | 
45 | function getFolderURI(folderURI) {
46 | 	folderURI = replaceStr(folderURI, '\\', '/');
47 | 	folderURI = replaceStr(folderURI, ' ', '%20');
48 | 	folderURI = replaceStr(folderURI, ':', '|');
49 | 	folderURI = 'file:///'+folderURI;
50 | 	return folderURI;
51 | }
52 | 
53 | function replaceStr(origStr, searchStr, replaceStr) {
54 | 	var tempStr = '';
55 | 	var startIndex = 0;
56 | 	if (searchStr == '') {
57 | 		return origStr;
58 | 	}
59 | 	if (origStr.indexOf(searchStr) != -1) {
60 | 		while ((searchIndex=origStr.indexOf(searchStr, startIndex)) != -1) {
61 | 			tempStr += origStr.substring(startIndex, searchIndex);
62 | 			tempStr += replaceStr;
63 | 			startIndex = searchIndex+searchStr.length;
64 | 		}
65 | 		return tempStr+origStr.substring(startIndex);
66 | 	} else {
67 | 		return origStr;
68 | 	}
69 | }
70 | 
71 | bitmap_quality(fl.getDocumentDOM());


--------------------------------------------------------------------------------
/Browse Installed AS Files.jsfl:
--------------------------------------------------------------------------------
 1 | function FLPBuilder(aFolders){
 2 | 	
 3 | 	this.__folders = aFolders;
 4 | }
 5 | 
 6 | 
 7 | FLPBuilder.prototype.getXML = function(){
 8 | 
 9 | 	var i = 0;
10 | 	var len = this.__folders.length;		
11 | 	var s = "";
12 | 	
13 | 	s += ('<flash_project name="Installed AS Files" version="1">');
14 | 	while(i<len){
15 | 		s += this.buildFolders(fl.configURI + this.__folders[i], this.__folders[i], "");
16 | 		i++;
17 | 	}
18 | 	s += ('</flash_project>');
19 | 	
20 | 	return s;
21 | }
22 | 
23 | 
24 | FLPBuilder.prototype.buildFiles = function(sPath, s){
25 | 
26 | 	// loop through files
27 | 	var files = FLfile.listFolder(sPath, "files");
28 | 	var i = 0;
29 | 	var len = files.length;	
30 | 	var path;
31 |  	while (i<len) {
32 | 		if(files[i].indexOf(".as") != -1){
33 | 			path = unescape(sPath + "/" + files[i]);
34 | 			path = path.replace("file:///", "");
35 | 			 s +=('<project_file filetype="as" path="'+ path.replace("|", ":")+'"/>');
36 | 		}
37 | 		i++;
38 | 	}	
39 | 	
40 | 	return s;
41 | }
42 | 
43 | 
44 | FLPBuilder.prototype.buildFolders = function(sPath, sFolder, s){
45 | 	
46 | 	var dirs = FLfile.listFolder(sPath,"directories");
47 | 	var i = 0;
48 | 	var len = dirs.length;
49 | 	// add directory
50 | 	s +=('<project_folder expanded="false" name="'+sFolder+'">');
51 | 	// loop through sub directories
52 | 	while (i<len) {
53 | 		if(dirs[i] != "aso"){
54 | 			s += this.buildFolders(sPath + "/" + dirs[i], dirs[i], "");
55 | 		}
56 | 		i++;
57 | 	}
58 | 	s += this.buildFiles(sPath, "");
59 | 	s +=('</project_folder>');
60 | 	
61 | 	return s; 
62 | }
63 |  
64 | 
65 | 
66 | 
67 | var TEMP_FLP_PATH = fl.configURI + "Commands/TEMP/"; 
68 | var TEMP_FLP_FILE = "Test.flp";
69 | 
70 | // Build .flp xml string
71 | var flp = new FLPBuilder(["Classes", "Include"]);
72 | // Create TEMP directory in commands to place .flp file
73 | if(FLfile.exists(TEMP_FLP_PATH)){
74 |      FLfile.remove(TEMP_FLP_PATH);
75 | }
76 | FLfile.createFolder(TEMP_FLP_PATH);
77 | // Write temp .flp file
78 | FLfile.write(TEMP_FLP_PATH + TEMP_FLP_FILE,  flp.getXML());
79 | // Open temp .flp file
80 | fl.openProject( TEMP_FLP_PATH + TEMP_FLP_FILE);
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/Funciton Remove Comments.jsfl:
--------------------------------------------------------------------------------
 1 | // Funciton Communications | Fernando Flórez
 2 | // © www.funciton.com
 3 | 
 4 | // --- start of class definition
 5 | 
 6 | FuncitonRemoveComments = function(){
 7 | }
 8 | 
 9 | var p = FuncitonRemoveComments.prototype;
10 | 
11 | p.doc = fl.getDocumentDOM();
12 | p.trace = fl.outputPanel.trace;
13 | 
14 | p.init = function(){
15 | 	if(!this.doc){
16 | 		alert ("You need to open a Flash File First");
17 | 	}else{
18 | 		if(this.doc.selection.length){
19 | 			var sel = this.doc.selection;
20 | 			for(var i=0;i<sel.length;i++){
21 | 				if(sel[i].actionScript != null && sel[i].actionScript != "") sel[i].actionScript = this.removeComments(sel[i].actionScript);
22 | 			}
23 | 		}else if(this.doc.getTimeline().getSelectedFrames().length){
24 | 			var selFrames = this.doc.getTimeline().getSelectedFrames();
25 | 			var l = selFrames.length / 3;
26 | 			for(var i=0;i<l;i++){
27 | 				var sel = this.doc.getTimeline().layers[selFrames[(i*3)]].frames[selFrames[(i*3)+1]];
28 | 				if(sel.actionScript != null && sel.actionScript != "") sel.actionScript = this.removeComments(sel.actionScript);
29 | 			}
30 | 		}
31 | 	}
32 | }
33 | 
34 | p.removeComments = function(txt){
35 | 	txt = this.removeMultiLineComments(txt);
36 | 	txt = this.removeOneLineComments(txt);
37 | 	return txt;
38 | }
39 | 
40 | p.removeOneLineComments = function(txt){
41 | 	var actionScriptLines = txt.split("\n");
42 | 	for(var i=0;i<actionScriptLines.length;i++){
43 | 		var temp = actionScriptLines[i].indexOf("//");
44 | 		if(temp != -1 && actionScriptLines[i].charAt(temp-1) != "\"") actionScriptLines[i] = actionScriptLines[i].substring(0, (temp-1));
45 | 	}
46 | 	return actionScriptLines.join("\n");
47 | }
48 | 
49 | p.removeMultiLineComments = function(txt){
50 | 	var sIndex = 0;
51 | 	while(txt.indexOf("/*", sIndex) != -1){
52 | 		if(txt.charAt(txt.indexOf("/*", sIndex)-1) != "\""){
53 | 			var t = "";
54 | 			sIndex = txt.indexOf("/*", sIndex);
55 | 			t = txt.substring(0, sIndex);
56 | 			t += txt.substring(txt.indexOf("*/", sIndex)+2);
57 | 			txt = t;
58 | 		}else{
59 | 			sIndex = txt.indexOf("/*", sIndex);
60 | 		}
61 | 	}
62 | 	return txt;
63 | }
64 | 
65 | // --- end of class definition
66 | 
67 | fl.outputPanel.clear();
68 | 
69 | var t = new FuncitonRemoveComments();
70 | t.init();


--------------------------------------------------------------------------------
/Commands/Library - Folder Structure.jsfl:
--------------------------------------------------------------------------------
1 | /**
 * Created by Colin Duffy
 * http://blog.tomorrowevening.com/
 */

var doc = fl.getDocumentDOM();
if( doc != null ) {
	var lib = doc.library;
	
	var displayFolder	= "Display";
	var globalFolder	= "- Global";
	
	// Fill color for shapes
	var fill = doc.getCustomFill();
	fill.style = "solid";
	fill.color = 0x000000;
	
	// Display
	if( !lib.itemExists( displayFolder ) ) lib.newFolder( displayFolder );
	if( !lib.itemExists( displayFolder + "/Fonts" ) ) lib.newFolder( displayFolder + "/Fonts" );
	if( !lib.itemExists( displayFolder + "/Images" ) ) lib.newFolder( displayFolder + "/Images" );
	if( !lib.itemExists( displayFolder + "/MovieClips" ) ) lib.newFolder( displayFolder + "/MovieClips" );
	if( !lib.itemExists( displayFolder + "/Sprites" ) ) lib.newFolder( displayFolder + "/Sprites" );
	
	// Global
	if( !lib.itemExists( globalFolder ) ) lib.newFolder( globalFolder );
	if( !lib.itemExists( globalFolder + "/empty" ) ) lib.addNewItem( "movie clip", globalFolder + "/empty" );
	
	// Create and draw shape_square
	if( !lib.itemExists( globalFolder + "/shape_square" ) ) {
		doc.setCustomFill( fill );
		lib.addNewItem( "graphic", globalFolder + "/shape_square" );
		lib.editItem( globalFolder + "/shape_square" );
		doc.addNewPrimitiveRectangle( { left: 0, top: 0, right: 100, bottom: 100 }, 0, false, true );
	}
	
	// Create and draw shape_circle
	if( !lib.itemExists( globalFolder + "/shape_circle" ) ) {
		doc.setCustomFill( fill );
		lib.addNewItem( "graphic", globalFolder + "/shape_circle" );
		lib.editItem( globalFolder + "/shape_circle" );
		doc.addNewPrimitiveOval( { left: 0, top: 0, right: 100, bottom: 100 }, 0, false, true );
	}
	
	// Create and draw square_mc
	if( !lib.itemExists( globalFolder + "/mc_square" ) ) {
		doc.setCustomFill( fill );
		lib.addNewItem( "movie clip", globalFolder + "/mc_square" );
		lib.editItem( globalFolder + "/mc_square" );
		lib.addItemToDocument( { x: 50, y: 50 }, globalFolder + "/shape_square" );
	}
	
	// Create and draw mc_circle
	if( !lib.itemExists( globalFolder + "/mc_circle" ) ) {
		doc.setCustomFill( fill );
		lib.addNewItem( "movie clip", globalFolder + "/mc_circle" );
		lib.editItem( globalFolder + "/mc_circle" );
		lib.addItemToDocument( { x: 50, y: 50 }, globalFolder + "/shape_circle" );
	}
	
	doc.exitEditMode();
	lib.selectNone();
}


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/ImportXMLToCurrentFLA.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * ImportXMLToCurrentFLA.jsfl
 3 |  *
 4 |  * Uses the functionality of Importer.jsfl to import translation XML into the currently open FLA.
 5 |  *
 6 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 7 |  */
 8 | 
 9 |  // Init
10 | 
11 | var config =
12 | {
13 | 	jobID : "000", // PHP's job ID, use to match log entries to jobs
14 | 	logToFile : false, // Whether to log to a file
15 | 	logToIDE : true, // Whether to log to the IDE's output panel
16 | 	outputFLAFilePath : "", // FLA file path to write
17 | 	outputSWFFilePath : "", // SWF file path to write
18 | 	xmlFilePath : "", // XML file path to import
19 | 	importFormattedText : true,
20 | 	outputFolder : "",
21 | 	libDir : "", // Static JSFL library directory
22 | 	outputFileName : ""
23 | }
24 | 
25 | var startTime = new Date();
26 | var scriptPath = fl.scriptURI;
27 | var scriptPathParts = scriptPath.split("/");
28 | var scriptName = scriptPathParts[scriptPathParts.length-1];
29 | var scriptDir = scriptPath.split(scriptName)[0];
30 | 
31 | config.libDir = scriptDir+"lib/";
32 | 
33 | // Load modules
34 | 
35 | fl.runScript(config.libDir+"Utils.jsfl");
36 | fl.runScript(config.libDir+"Logger.jsfl");
37 | fl.runScript(config.libDir+"HTMLParser.jsfl");
38 | fl.runScript(config.libDir+"Importer.jsfl");
39 | fl.runScript(fl.configURI+"JavaScript/ObjectFindAndSelect.jsfl");
40 | 
41 | // Get user input:
42 | 
43 | config.importFormattedText = confirm("Parse XML for text formatting information?");
44 | config.xmlFilePath = fl.browseForFileURL("select","Select the XML file");
45 | config.outputFolder = fl.browseForFolderURL("Select the output folder");
46 | config.outputFileName = prompt("Select output filename",fl.getDocumentDOM().name.replace(/\.fla/ig,""));
47 | 
48 | var outputFilePath = config.outputFolder+"/"+config.outputFileName;
49 | 
50 | config.outputFLAFilePath = outputFilePath+".fla";
51 | config.outputSWFFilePath = outputFilePath+".swf";
52 | 
53 | // Start
54 | 
55 | Utils.initLogger(config,scriptName);
56 | 
57 | var success = Importer.go(fl.getDocumentDOM(),config,false);
58 | 
59 | if ( success )
60 | {
61 | 	Logger.log("Processing completed successfully");
62 | }
63 | else
64 | {
65 | 	Logger.log("Errors encountered, operation may have failed",Logger.CRITICAL);
66 | }
67 | 
68 | Logger.log("Script exiting ("+((new Date().getTime()-startTime.getTime())/1000)+"s)");


--------------------------------------------------------------------------------
/Generate Webcast.jsfl:
--------------------------------------------------------------------------------
 1 | //var _timestamps = "00:00:00.00\n00:00:06.50\n00:00:33.50\n00:00:37.50\n00:01:25.00\n00:01:46.50\n00:02:06.00\n00:02:30.00\n00:02:46.00\n00:02:52.00\n00:03:09.00\n00:03:30.00\n00:03:46.00\n00:03:50.00\n00:04:08.00\n00:04:22.50\n00:04:42.00\n00:04:56.50\n00:05:08.00\n00:05:14.00\n00:05:43.00\n00:06:14.50\n00:06:40.50\n00:06:53.50\n00:07:15.00\n00:07:34.50\n00:07:47.00\n00:08:08.00\n00:08:30.00";
 2 | //buildWebcast("Slide#.jpg", "frozen_foods.mp3", "9", "13", _timestamps);
 3 | 
 4 | function buildWebcast(slideNamePattern, soundItemName, mins, seconds, timestamps)
 5 | {
 6 | 	var times = [];
 7 | 	var doc = fl.getDocumentDOM();
 8 | 	var timeline = doc.getTimeline();
 9 | 	
10 | 	// Get timestamps
11 | 	var lines = timestamps.split("|");
12 | 	var lineCount = lines.length;
13 | 	for (var lineIndex = 0; lineIndex < lineCount; lineIndex++)
14 | 	{
15 | 		var line = lines[lineIndex];
16 | 		var timeSplit = line.split(":");
17 | 		var timeSec = parseInt(timeSplit[0] * 60 * 60) + parseInt(timeSplit[1] * 60) + Math.round(parseFloat(timeSplit[2]));
18 | 		times.push(timeSec);
19 | 	}
20 | 	
21 | 	var totalTimeDuration = times[times.length - 1];
22 | 	var totalFrameDuration = totalTimeDuration * doc.frameRate;
23 | 	
24 | 	// Create new slides layer
25 | 	timeline.addNewLayer("Slide_Images", "normal", true);
26 | 	var currFrame = 0;
27 | 	var itemCount = times.length;
28 | 	for (var itemIndex = 0; itemIndex < itemCount; itemIndex++)
29 | 	{
30 | 		var libName = slideNamePattern.split("#").join((itemIndex + 1).toString());
31 | 		var selItem = doc.library.items[doc.library.findItemIndex(libName)];
32 | 		var frameLength = (itemIndex < times.length - 1) ? ((times[itemIndex + 1] - times[itemIndex]) * doc.frameRate) : (1);
33 | 
34 | 		if (itemIndex > 0) timeline.insertBlankKeyframe(currFrame);
35 | 		doc.addItem({x:doc.width / 2, y:doc.height / 2}, selItem);
36 | 		timeline.insertFrames(frameLength);
37 | 		currFrame += frameLength;
38 | 	}
39 | 	
40 | 	// Create new audio layer
41 | 	timeline.addNewLayer("Slide_Audio", "normal", true);
42 | 	
43 | 	// Find MP3 library object and put it on Audio layer
44 | 	var audioItem = doc.library.items[doc.library.findItemIndex(soundItemName)];
45 | 	var soundFrames = doc.frameRate * Math.round(parseInt(mins * 60) + parseFloat(seconds));
46 | 	
47 | 	timeline.layers[timeline.currentLayer].frames[0].soundLibraryItem = audioItem;
48 | 	timeline.insertFrames(soundFrames);
49 | }


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/ProcessCurrentFLA.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * ProcessCurrentFLA.jsfl
 3 |  *
 4 |  * Uses the functionality of Processor.jsfl to prepare the currently open FLA for translation and
 5 |  * generate the translation XML.
 6 |  *
 7 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 8 |  */
 9 | 
10 | var config =
11 | {
12 | 	lang : "en_GB", // Language code to add to XML file
13 | 	jobID : "000", // PHP's job ID, use to match log entries to jobs
14 | 	logToFile : false, // Whether to log to a file
15 | 	logToIDE : true, // Whether to log to the IDE's output panel
16 | 	outputXMLFilePath : "", // XML file path to write
17 | 	outputFLAFilePath : "", // FLA file path to write
18 | 	outputSWFFilePath : "", // SWF file path to write
19 | 	outputFormattedText : true, // Output the text in the XML with formatting or else raw strings.
20 | 	libDir : "", // Static JSFL library directory
21 | 	outputFolder : ""
22 | }
23 | 
24 | var startTime = new Date();
25 | var scriptPath = fl.scriptURI;
26 | var scriptPathParts = scriptPath.split("/");
27 | var scriptName = scriptPathParts[scriptPathParts.length-1];
28 | var scriptDir = scriptPath.split(scriptName)[0];
29 | 
30 | config.libDir = scriptDir+"lib/";
31 | 
32 | // Load modules
33 | 
34 | fl.runScript(config.libDir+"Utils.jsfl");
35 | fl.runScript(config.libDir+"Logger.jsfl");
36 | fl.runScript(config.libDir+"HTMLParser.jsfl");
37 | fl.runScript(config.libDir+"Processor.jsfl");
38 | fl.runScript(fl.configURI+"JavaScript/ObjectFindAndSelect.jsfl");
39 | 
40 | // Get user input for language code and output folder etc.:
41 | 
42 | config.outputFormattedText = confirm("Generate XML with text formatting data?");
43 | config.lang = prompt("Enter the language code",config.lang);
44 | config.outputFolder = fl.browseForFolderURL("Select the output folder");
45 | 
46 | var outputFileName = fl.getDocumentDOM().name+"_"+config.lang;
47 | outputFileName = outputFileName.replace(/\.fla/ig,"")
48 | var outputFilePath = config.outputFolder+"/"+outputFileName;
49 | 
50 | config.outputXMLFilePath = outputFilePath+".xml";
51 | config.outputFLAFilePath = outputFilePath+".fla";
52 | config.outputSWFFilePath = outputFilePath+".swf";
53 | 
54 | // Start
55 | 
56 | Utils.initLogger(config,scriptName);
57 | 
58 | var success = Processor.go(fl.getDocumentDOM(),config,false);
59 | 
60 | if ( success )
61 | {
62 | 	Logger.log("Processing completed successfully");
63 | }
64 | else
65 | {
66 | 	Logger.log("Errors encountered, operation failed",Logger.WARNING);
67 | }
68 | 
69 | Logger.log("Script exiting ("+((new Date().getTime()-startTime.getTime())/1000)+"s)");


--------------------------------------------------------------------------------
/func_autodoc.jsfl:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | // func_autodoc.jsfl
 3 | //    javadoc-style automatic comment generation tool
 4 | // 
 5 | // author: g.wygonik - with thanks to guy watson for the first few lines
 6 | //         taken from his "Insert Stop Frames" code. :-)
 7 | //
 8 | // comments, enhancements, or hate mail: gw@artificialcolors.com
 9 | ////////////////////////////////////////////////////////////////////////////////
10 | 
11 | var dom = fl.getDocumentDOM();
12 | var timeline = dom.getTimeline();
13 | var selections = timeline.getSelectedFrames();
14 | var layer = selections[0];
15 | var frame = selections[1];
16 | var as = timeline.layers[layer].frames[frame].actionScript;
17 | var asArr = as.split("\n");
18 | var asArrL = asArr.length;
19 | var asF = "";
20 | var prevDone = false;
21 | for (s=0; s<asArrL; s++) {
22 | 	var asE = asArr[s].split(" ").join("");
23 | 	var LL = "";
24 | 	var tmpLL = asArr[s].toLowerCase().split("function")[0].split("");
25 | 	for (L=0;L<tmpLL.length;L++) {
26 | 		if ( (tmpLL[L] != " ") && (tmpLL[L] != "\t") ) {
27 | 			break;
28 | 		} else {
29 | 			LL += tmpLL[L];
30 | 		}
31 | 	}
32 | 	if ((asE.indexOf("function")>-1) && (asE.indexOf("=function")<0) && (asE.indexOf("*function")<0) && (asE.indexOf("//function")<0)) {
33 | 		if (s>0) {
34 | 			if (asArr[s-1].indexOf("*/")<0) {
35 | 				prevDone = false;
36 | 			} else {
37 | 				prevDone = true;
38 | 			}
39 | 		}
40 | 		if (!prevDone) {
41 | 			var asTMP = asArr[s];
42 | 			var jd = LL + "/**\n";
43 | 			var fname = asArr[s].split("function")[1].split("(")[0];
44 | 			jd += LL + " * FUNCTION: "+fname+"\n";
45 | 			jd += LL + " *\n";
46 | 			jd += LL + " * function description here\n";
47 | 			if (asE.indexOf("()")<0) {
48 | 				jd += LL + " *\n";
49 | 				var params = asArr[s].split("function")[1].split("(")[1].split(")")[0].split(" ").join("").split(",");
50 | 				if (params.length>0) {
51 | 					for (p=0; p<params.length; p++) {
52 | 						var tmpP = params[p].split(":");
53 | 						if (tmpP[1] == "") {
54 | 							tmpP[1] = "undefined";
55 | 						}
56 | 						if (tmpP[0].indexOf(" ") == 0) {
57 | 							tmpP[0] = tmpP[0].split(" ")[1];
58 | 						}
59 | 						jd += LL + " * @param   "+tmpP[0]+"   "+tmpP[1]+"   ** param description here\n";
60 | 					}
61 | 				}
62 | 			}
63 | 			if (asE.indexOf("):")>0) {
64 | 				jd += LL + " *\n";
65 | 				jd += LL + " * @return  "+asE.split("):")[1].split("{")[0]+"\n";
66 | 			}
67 | 			jd += LL + " *\n";
68 | 			jd += LL + "**/\n";
69 | 			asArr[s] = jd+asTMP;
70 | 		}
71 | 	}
72 | 	asF += asArr[s];
73 | }
74 | timeline.layers[layer].frames[frame].actionScript = asF;
75 | 


--------------------------------------------------------------------------------
/ProjectPanelAPISample.jsfl:
--------------------------------------------------------------------------------
1 | function callMethod(p_panelName, p_function, p_param) {
	//Check for panels first
	l = fl.swfPanels.length;
	if (l == 0) { return 'false'; }
	
	//Find our panel, and call the method.
	for (i=0; i<l; i++) {
		if (fl.swfPanels[i].name == p_panelName) {
			if (p_param == null) {
				return fl.swfPanels[i].call(p_function);
			} else {
				return fl.swfPanels[i].call(p_function, p_param);
			}
		}
	}
	return 'false';
}

//var newName = prompt('Enter a new name for your Project.');
//callMethod('Project', 'setName', newName);

//var projRoot = fl.browseForFolderURL('Find Project Root');
//callMethod('Project', 'createProject', projRoot+';New Project From JSFL;3');

//var projURI = fl.browseForFolderURL('Find Project Root');
//callMethod('Project', 'openProject', projURI);


fl.trace('createQuickProject: ', callMethod('Project', 'createQuickProject'));

//Modify Methods
/*
uri = 'file:///SOME_LOCATION;
callMethod('Project', 'addToCompileList', uri + '/swcFile.swc');
callMethod('Project', 'removeFromCompileList', uri);
callMethod('Project', 'removeLocation', uri);
callMethod('Project', 'addSourcePath', uri+ '/swcFile.swc');
callMethod('Project', 'removeSourcePath', uri);
callMethod('Project', 'addLocation', uri);
callMethod('Project', 'setFlexSDKPath', uri);
callMethod('Project', 'addLibraryPath', uri+ '/swcFile.swc');
callMethod('Project', 'removeLibraryPath', uri);
callMethod('Project', 'addExternalLibraryPath', uri+ '/swcFile.swc');
callMethod('Project', 'removeExternalLibraryPath', uri);
callMethod('Project', 'setURI', uri);
callMethod('Project', 'setClassTemplate', uri);
callMethod('Project', 'setSymbolClassTemplate', uri);
*/
//fl.trace('runCompileList: ' + callMethod('Project', 'runCompileList'));

callMethod('Project', 'setASVersion', 3);

//Get Methods
fl.trace('getName: ' + callMethod('Project', 'getName'));
fl.trace('getURI: ' + callMethod('Project', 'getURI'));
fl.trace('getASVersion: ' + callMethod('Project', 'getASVersion'));
fl.trace('getClassTemplate: ' + callMethod('Project', 'getClassTemplate'));
fl.trace('getSymbolClassTemplate: ' + callMethod('Project', 'getSymbolClassTemplate'));
fl.trace('getCompileList: ' + callMethod('Project', 'getCompileList'));
fl.trace('getLocationNames: ' + callMethod('Project', 'getLocationNames'));
fl.trace('getLocationURIs: ' + callMethod('Project', 'getLocationURIs'));
fl.trace('getFlexSDKPath: ' + callMethod('Project', 'getFlexSDKPath'));
fl.trace('getSourcePaths: ' + callMethod('Project', 'getSourcePaths'));
fl.trace('getLibraryPaths: ' + callMethod('Project', 'getLibraryPaths'));
fl.trace('getExternalLibraryPaths: ' + callMethod('Project', 'getExternalLibraryPaths'));
fl.trace('getRecentProjectList: ' + callMethod('Project', 'getRecentProjectList'));


--------------------------------------------------------------------------------
/organize library.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Organizes all library items - folders get 
 3 |  * created for each item type and items get moved into those folders.
 4 |  */
 5 | 
 6 | //possible item types:
 7 | //undefined,component,movie clip,
 8 | //graphic,button,folder,font,
 9 | //sound,bitmap,compiled clip,screen,video
10 | 
11 | var lib = fl.getDocumentDOM().library;
12 | function makeFolders()
13 | {
14 | 	lib.newFolder("movieclips");
15 | 	lib.newFolder("fonts");
16 | 	lib.newFolder("sounds");
17 | 	lib.newFolder("graphics");
18 | 	lib.newFolder("bitmaps");
19 | 	lib.newFolder("components");
20 | 	lib.newFolder("videos");
21 | 	lib.newFolder("buttons");
22 | }
23 | makeFolders();
24 | function moveMovieClip(item){lib.moveToFolder("movieclips",item.name,false);}
25 | function moveBitmap(item){lib.moveToFolder("bitmaps",item.name,false);}
26 | function moveSound(item){lib.moveToFolder("sounds",item.name,false);}
27 | function moveGraphic(item){lib.moveToFolder("graphics",item.name,false);}
28 | function moveButton(item){lib.moveToFolder("buttons",item.name,false);}
29 | function moveFont(item){lib.moveToFolder("fonts",item.name,false);}
30 | function moveVideo(item){lib.moveToFolder("videos",item.name,false);}
31 | function moveComponent(item){lib.moveToFolder("components",item.name,false);}
32 | var items = fl.getDocumentDOM().library.items;
33 | var i=0;
34 | var l=items.length;
35 | var missed = false;
36 | for(i;i<l;i++)
37 | {
38 | 	var item = items[i];
39 | 	if(item.name.indexOf("Component Assets")>-1) continue;
40 | 	if(item.name.indexOf("FLV Playback Skins")>-1) continue;
41 | 	if(item.name.indexOf("movieclips")>-1) continue;
42 | 	if(item.name.indexOf("bitmaps")>-1) continue;
43 | 	if(item.name.indexOf("buttons")>-1) continue;
44 | 	if(item.name.indexOf("components")>-1) continue;
45 | 	if(item.name.indexOf("fonts")>-1) continue;
46 | 	if(item.name.indexOf("graphics")>-1) continue;
47 | 	if(item.name.indexOf("sounds")>-1) continue;
48 | 	if(item.name.indexOf("videos")>-1) continue;
49 | 	switch(items[i].itemType)
50 | 	{
51 | 		case "undefined":
52 | 			continue;
53 | 		case "movie clip":
54 | 			moveMovieClip(item);
55 | 			break;
56 | 		case "bitmap":
57 | 			moveBitmap(item);
58 | 			break;
59 | 		case "sound":
60 | 			moveSound(item);
61 | 			break;
62 | 		case "graphic":
63 | 			moveGraphic(item);
64 | 			break;	
65 | 		case "button":
66 | 			moveButton(item);
67 | 			break;
68 | 		case "font":
69 | 			moveFont(item);
70 | 			break;
71 | 		case "video":
72 | 			moveVideo(item);
73 | 			break;
74 | 		case "component":
75 | 			moveComponent(item);
76 | 			break;
77 | 		case "folder":
78 | 			continue;
79 | 	}
80 | }
81 | lib.selectNone();
82 | lib.editItem();
83 | if(missed) alert("Some items could not be organized.");


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/lib/ImportXMLTemplate.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * ImportXMLTemplate.jsfl
 3 |  *
 4 |  * Uses the functionality of Importer.jsfl to import the contents of a translation XML file into a
 5 |  * FLA. This script is designed to be used as a template by an external system. The config values
 6 |  * can be dynamically populated before the script is called.
 7 |  *
 8 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 9 |  */
10 | 
11 |  // Init
12 | 
13 | var config =
14 | {
15 | 	jobID : "001", // PHP's job ID, use to match log entries to jobs
16 | 	logToFile : true, // Whether to log to a file
17 | 	logToIDE : true, // Whether to log to the IDE's output panel
18 | 	logFilePath : "", // Log file path
19 | 	lockFilePath : "", // Lock file path
20 | 	flaFilePath : "", // Master FLA file path
21 | 	outputFLAFilePath : "", // FLA file path to write
22 | 	outputSWFFilePath : "", // SWF file path to write
23 | 	xmlFilePath : "", // XML file path to import
24 | 	importFormattedText : true,
25 | 	libDir : "" // Static JSFL library directory
26 | }
27 | 
28 | var startTime = new Date();
29 | var scriptPath = fl.scriptURI;
30 | var scriptPathParts = scriptPath.split("/");
31 | var scriptName = scriptPathParts[scriptPathParts.length-1];
32 | var scriptDir = scriptPath.split(scriptName)[0];
33 | 
34 | // Set defaults if not supplied by PHP:
35 | 
36 | if ( config.logFilePath == "" ) config.logFilePath = scriptDir+"log";
37 | if ( config.lockFilePath == "" ) config.lockFilePath = scriptDir+"lock";
38 | if ( config.libDir == "" ) config.libDir = scriptDir;
39 | if ( config.flaFilePath == "" ) config.flaFilePath = scriptDir+"../test-files/import-test.fla";
40 | if ( config.xmlFilePath == "" ) config.xmlFilePath = scriptDir+"../test-files/import-test.xml";
41 | 
42 | // Lock it
43 | 
44 | FLfile.write(config.lockFilePath,new Date().toString());
45 | 
46 | // Load modules
47 | 
48 | fl.runScript(config.libDir+"Utils.jsfl");
49 | fl.runScript(config.libDir+"Logger.jsfl");
50 | fl.runScript(config.libDir+"HTMLParser.jsfl");
51 | fl.runScript(config.libDir+"Importer.jsfl");
52 | fl.runScript(fl.configURI+"JavaScript/ObjectFindAndSelect.jsfl");
53 | 
54 | // Set more defaults if not supplied by PHP:
55 | 
56 | var guid = Utils.guid();
57 | 
58 | if ( config.outputFLAFilePath === "" ) config.outputFLAFilePath = scriptDir+"output/"+guid+".fla";
59 | if ( config.outputSWFFilePath === "" ) config.outputSWFFilePath = scriptDir+"output/"+guid+".swf";
60 | 
61 | // Start
62 | 
63 | Utils.initLogger(config,scriptName);
64 | 
65 | var success = Importer.go(config.flaFilePath,config,true);
66 | 
67 | if ( success )
68 | {
69 | 	Logger.log("Processing completed successfully");
70 | }
71 | else
72 | {
73 | 	Logger.log("Errors encountered, operation may have failed",Logger.CRITICAL);
74 | }
75 | 
76 | // Unlock and exit
77 | 
78 | Logger.log("Script exiting ("+((new Date().getTime()-startTime.getTime())/1000)+"s)");
79 | FLfile.remove(config.lockFilePath);


--------------------------------------------------------------------------------
/MoveRegpoint.jsfl:
--------------------------------------------------------------------------------
 1 | /////////////////////////////////////////////////////////////////////////
 2 | //
 3 | //	MoveRegpoint.jsfl
 4 | //
 5 | //	version 1.1
 6 | //	23.12.2004
 7 | //
 8 | //	programmed by klaas kielmann
 9 | //	copyright 2004 by kosmokrator.com
10 | 
11 | 
12 | if ( flash.documents.length == 0 ) {
13 | 	alert( "Please open a flash document first." );
14 | 
15 | } else if ( ( flash.getDocumentDOM().selection.length != 1 ) || ( flash.getDocumentDOM().selection[ 0 ].elementType != "instance" ) ) {
16 | 	alert( "Please select a single symbol instance and retry command." );
17 | 
18 | } else {
19 | 	var doc = flash.getDocumentDOM();
20 | 	var tim	= doc.getTimeline();
21 | 	var sel = doc.selection;
22 | 	var obj = sel[ 0 ];
23 | 	var layer = tim.currentLayer;
24 | 	var frame = tim.currentFrame;
25 | 	var name = obj.libraryItem.name;
26 | 	var offset = doc.getTransformationPoint();
27 | 	doc.enterEditMode( "inPlace" );
28 | 	MoveContent( { x: - offset.x, y: - offset.y } );
29 | 	doc.exitEditMode();
30 | 	doc.selectNone();
31 | 	MoveSymbols( name, offset );
32 | 	tim.setSelectedLayers( layer );
33 | 	tim.setSelectedFrames( frame, frame );
34 | 	doc.selectNone();
35 | }
36 | 
37 | function MoveContent( this_point ) {
38 | 	var is_locked = false;
39 | 	var timeline = doc.getTimeline();
40 | 	var layers = timeline.layers;
41 | 	for ( var i = 0; i < layers.length; i++ ) {
42 | 		is_locked = layers[ i ].locked;
43 | 		layers[ i ].locked = false;
44 | 		var frames = layers[ i ].frames;
45 | 		for ( var j = 0; j < frames.length; j++ ) {
46 | 			if ( frames[ j ].startFrame == j ) {
47 | 				timeline.setSelectedLayers( i );
48 | 				timeline.setSelectedFrames( j, j );
49 | 				if ( frames[ j ].elements.length ) {
50 | 					doc.group();
51 | 					if ( doc.selection.length > 0 ) {
52 | 						doc.moveSelectionBy( this_point );
53 | 					}
54 | 					doc.unGroup();
55 | 				}
56 | 				doc.selectNone();
57 | 			}
58 | 		}
59 | 		layers[ i ].locked = true;
60 | 	}
61 | }
62 | 
63 | function MoveSymbols( this_name, this_point ) {
64 | 	var selection = new Array();
65 | 	var timeline = doc.getTimeline();
66 | 	var layers = timeline.layers;
67 | 	for ( var i = 0; i < layers.length; i++ ) {
68 | 		if ( ! layers[ i ].locked ) {
69 | 			var frames = layers[ i ].frames;
70 | 			for ( var j = 0; j < frames.length; j++ ) {
71 | 				if ( frames[ j ].startFrame == j ) {
72 | 					timeline.setSelectedLayers( i );
73 | 					timeline.setSelectedFrames( j, j );
74 | 					var elements = frames[ j ].elements;
75 | 					for ( var c = 0; c < elements.length; c++ ) {
76 | 						var element = elements[ c ];
77 | 						if ( element.elementType == "instance" && element.libraryItem.name == this_name && !element.locked ) {
78 | 							doc.selectNone();
79 | 							doc.selection = [ element ];
80 | 							if ( doc.selection.length == 1 ) {
81 | 								doc.setTransformationPoint( { x: 0, y: 0 } );
82 | 								doc.moveSelectionBy( this_point );
83 | 							}
84 | 						}
85 | 					}
86 | 					doc.selectNone();
87 | 				}
88 | 			}
89 | 		}
90 | 	}
91 | }
92 | 


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/test-files/import-test.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <root lang="en_GB">
 3 |   <items>
 4 |     <item id="tf1"><![CDATA[<textrun face="Georgia" size="24" bold="false" italic="false" colour="#000000">Hello world!</textrun>]]></item>
 5 |     <item id="tf2"><![CDATA[<textrun face="Georgia" size="15" bold="false" italic="false" colour="#000000">What's up? I appear in an incorrectly named<br/>TextField</textrun>]]></item>
 6 |     <item id="tf3"><![CDATA[<textrun face="Georgia" size="24" bold="false" italic="false" colour="#000000">Greetz. I only appear in the Library.</textrun>]]></item>
 7 |     <item id="tf4"><![CDATA[<textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000">ANOTHER TEST.</textrun>]]></item>
 8 |     <item id="tf5"><![CDATA[<textrun face="Georgia" size="24" bold="false" italic="false" colour="#000000">Howdy, I appear in multiple places.</textrun>]]></item>
 9 |     <item id="tf6"><![CDATA[<textrun face="Georgia" size="24" bold="false" italic="false" colour="#000000">Greetz. I also only appear in the Library.</textrun>]]></item>
10 |     <item id="tf7"><![CDATA[<textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000">Hello, I'm static TextField 2 of 2 sat on a MovieClip timeline!</textrun>]]></item>
11 |     <item id="tf8"><![CDATA[<textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000">Hello, I'm static TextField 1 of 2 sat on a MovieClip timeline!</textrun>]]></item>
12 |     <item id="tf9"><![CDATA[<textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000">Hello, I'm a static TextField sat on a Graphic timeline somewhere!</textrun>]]></item>
13 |     <item id="tf10"><![CDATA[<textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000">Hello, I'm a static TextField sat directly<br/>on the main stage!</textrun>]]></item>
14 |     <item id="tf11"><![CDATA[<textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000">Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut </textrun><textrun face="Georgia Bold" size="14" bold="true" italic="false" colour="#000000">labore</textrun><textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000"> et dolore magna aliqua.<br/><br/>Ut enim ad </textrun><textrun face="Georgia Italic" size="14" bold="false" italic="true" colour="#000000">minim veniam,</textrun><textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000"> quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea </textrun><textrun face="Georgia" size="14" bold="false" italic="false" colour="#006699">commodo</textrun><textrun face="Georgia" size="14" bold="false" italic="false" colour="#000000"> consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. <br/><br/></textrun><textrun face="Georgia" size="24" bold="false" italic="false" colour="#000000">Big font.</textrun>]]></item>
15 |   </items>
16 | </root>


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/lib/ProcessFLATemplate.jsfl:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * ProcessFLATemplate.jsfl
 3 |  *
 4 |  * Uses the functionality of Processor.jsfl to prepare an FLA for translation and generate the
 5 |  * translation XML. This script is designed to be used as a template by an external system. The
 6 |  * config values can be dynamically populated before the script is called.
 7 |  *
 8 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 9 |  */
10 | 
11 | // Init
12 | 
13 | var config =
14 | {
15 | 	lang : "en_GB", // Language code to add to XML file
16 | 	jobID : "001", // PHP's job ID, use to match log entries to jobs
17 | 	logToFile : true, // Whether to log to a file
18 | 	logToIDE : true, // Whether to log to the IDE's output panel
19 | 	logFilePath : "", // Log file path
20 | 	lockFilePath : "", // Lock file path
21 | 	flaFilePath : "", // Master FLA file path
22 | 	outputXMLFilePath : "", // XML file path to write
23 | 	outputFLAFilePath : "", // FLA file path to write
24 | 	outputSWFFilePath : "", // SWF file path to write
25 | 	outputFormattedText : true, // Output the text in the XML with formatting or else raw strings.
26 | 	libDir : "" // Static JSFL library directory
27 | }
28 | 
29 | var startTime = new Date();
30 | var scriptPath = fl.scriptURI;
31 | var scriptPathParts = scriptPath.split("/");
32 | var scriptName = scriptPathParts[scriptPathParts.length-1];
33 | var scriptDir = scriptPath.split(scriptName)[0];
34 | 
35 | // Set defaults if not supplied by PHP:
36 | 
37 | if ( config.logFilePath == "" ) config.logFilePath = scriptDir+"log";
38 | if ( config.lockFilePath == "" ) config.lockFilePath = scriptDir+"lock";
39 | if ( config.libDir == "" ) config.libDir = scriptDir;
40 | if ( config.flaFilePath == "" ) config.flaFilePath = scriptDir+"../test-files/process-test.fla";
41 | 
42 | // Lock it
43 | 
44 | FLfile.write(config.lockFilePath,new Date().toString());
45 | 
46 | // Load modules
47 | 
48 | fl.runScript(config.libDir+"Utils.jsfl");
49 | fl.runScript(config.libDir+"Logger.jsfl");
50 | fl.runScript(config.libDir+"HTMLParser.jsfl");
51 | fl.runScript(config.libDir+"Processor.jsfl");
52 | fl.runScript(fl.configURI+"JavaScript/ObjectFindAndSelect.jsfl");
53 | 
54 | // Set more defaults if not supplied by PHP:
55 | 
56 | var guid = Utils.guid();
57 | 
58 | if ( config.outputXMLFilePath === "" ) config.outputXMLFilePath = scriptDir+"output/"+guid+".xml";
59 | if ( config.outputFLAFilePath === "" ) config.outputFLAFilePath = scriptDir+"output/"+guid+".fla";
60 | if ( config.outputSWFFilePath === "" ) config.outputSWFFilePath = scriptDir+"output/"+guid+".swf";
61 | 
62 | // Start
63 | 
64 | Utils.initLogger(config,scriptName);
65 | 
66 | var success = Processor.go(config.flaFilePath,config,true);
67 | 
68 | if ( success )
69 | {
70 | 	Logger.log("Processing completed successfully");
71 | }
72 | else
73 | {
74 | 	Logger.log("Errors encountered, operation failed",Logger.WARNING);
75 | }
76 | 
77 | // Unlock and exit
78 | 
79 | Logger.log("Script exiting ("+((new Date().getTime()-startTime.getTime())/1000)+"s)");
80 | FLfile.remove(config.lockFilePath);


--------------------------------------------------------------------------------
/[ced] Dump library.jsfl:
--------------------------------------------------------------------------------
  1 | function init()
  2 | {
  3 | 	var dom = fl.getDocumentDOM();
  4 | 	var lib = dom.library;
  5 | 	var items=lib.items;
  6 | 	var output = "";
  7 | 	var folders = new Object();
  8 | 	var symbols = new Object();
  9 | 	
 10 | 	for(var i=0;i<items.length;i++)
 11 | 	{
 12 | 		var item=items[i];
 13 | 		var pathsplit=item.name.split("/");
 14 | 		if(item.itemType != "folder")
 15 | 		{
 16 | 			var mainname=pathsplit[pathsplit.length-1];
 17 | 			var where = symbols;
 18 | 			for(var j = 0; j < pathsplit.length - 1; j++)
 19 | 			{
 20 | 				if(where[pathsplit[j]] == null)
 21 | 				{
 22 | 					where[pathsplit[j]] = new Object();
 23 | 				}
 24 | 				where = where[pathsplit[j]];
 25 | 			}
 26 | 			where[mainname] = {__specialVal:1,
 27 | 							   __itemType:item.itemType,
 28 | 							   __linkageIdentifier:item.linkageIdentifier, 
 29 | 							   __linkageUrl:item.linkageUrl, 
 30 | 							   __linkageClassName:item.linkageClassName
 31 | 							   };
 32 | 		}
 33 | 		else
 34 | 		{
 35 | 			var pathsplit=item.name.split("/");
 36 | 			var where = folders;
 37 | 			for(var j = 0; j < pathsplit.length; j++)
 38 | 			{
 39 | 				if(where[pathsplit[j]] == null)
 40 | 				{
 41 | 					where[pathsplit[j]] = new Object();
 42 | 				}
 43 | 				where = where[pathsplit[j]];
 44 | 			}
 45 | 		}
 46 | 	}
 47 | 	
 48 | 	fl.outputPanel.clear();
 49 | 	
 50 | 	fl.trace('------------------------------------------------------------------------');
 51 | 	fl.trace('-----------------------       Library dump      ------------------------');
 52 | 	fl.trace('------------------------------------------------------------------------');
 53 | 	traceFolder(folders, symbols, 0);
 54 | 	fl.trace(folderBuff)
 55 | }
 56 | 
 57 | function traceFolder(what, symbols, level)
 58 | {
 59 | 	var keys = new Array();
 60 | 	
 61 | 	for(var i in what)
 62 | 	{
 63 | 		keys.push(i);
 64 | 	}
 65 | 	keys.sort();
 66 | 
 67 | 	for(var i = 0; i < keys.length; i++)
 68 | 	{
 69 | 		folderBuff += bn[level] + '+++ ' + keys[i] + "\n";
 70 | 		traceFolder(what[keys[i]], symbols[keys[i]], level + 1);
 71 | 	}
 72 | 	
 73 | 	var keys = new Array();
 74 | 	
 75 | 	for(var i in symbols)
 76 | 	{
 77 | 		keys.push(i);
 78 | 	}
 79 | 	keys.sort();
 80 | 	
 81 | 	for(var j = 0; j < keys.length; j++)
 82 | 	{
 83 | 		i = keys[j];
 84 | 		if(symbols[i].__specialVal == 1)
 85 | 		{
 86 | 			folderBuff += bn[level] + '|- ' + i + " (" + symbols[i].__itemType + ")\n";
 87 | 		}
 88 | 		
 89 | 		if(symbols[i].__linkageIdentifier != null)
 90 | 		{
 91 | 			folderBuff += bn[level + 1] + " | Linkage identifier: " + symbols[i].__linkageIdentifier + "\n";
 92 | 		}
 93 | 		
 94 | 		if(symbols[i].__linkageClassName != null && symbols[i].__linkageClassName != "")
 95 | 		{
 96 | 			folderBuff += bn[level + 1] + " | AS2 class: " + symbols[i].__linkageClassName + "\n";
 97 | 		}
 98 | 		
 99 | 		if(symbols[i].__linkageUrl != null && symbols[i].__linkageUrl != "")
100 | 		{
101 | 			folderBuff += bn[level + 1] + " | Linkage URL: " + symbols[i].__linkageUrl + "\n";
102 | 		}
103 | 	}
104 | 	return;
105 | }
106 | 
107 | folderBuff = "";
108 | 
109 | bn = new Array();
110 | bn[0] = "";
111 | bn[1] = "  ";
112 | bn[2] = "    ";
113 | bn[3] = "      ";
114 | bn[4] = "        ";
115 | bn[5] = "          ";
116 | bn[6] = "            ";
117 | bn[7] = "              ";
118 | bn[8] = "                ";
119 | bn[9] = "                  ";
120 | bn[10] = "                    ";
121 | 
122 | init();


--------------------------------------------------------------------------------
/Layer Frame Distributer.jsfl:
--------------------------------------------------------------------------------
  1 | //
  2 | // Layer to Frame, Frame to Layer
  3 | //
  4 | // This command was made by Luar (luar@luar.net, http://www.luar.com.hk/)
  5 | //
  6 | var dom = fl.getDocumentDOM();
  7 | var xui = dom.xmlPanel(fl.configURI+"Commands/Layer Frame Distributer.xml");
  8 | var selectedFrame = dom.getTimeline().getSelectedFrames();
  9 | var sM = xui.switchMethod;
 10 | var isDelete = xui.isDelete;
 11 | 
 12 | if (xui.dismiss == "accept") {
 13 | 	if (selectedFrame == "") {
 14 | 		alert("No Frame is selected");
 15 | 	} else {
 16 | 		//fl.trace(selectedFrame);
 17 | 		parseFrame(selectedFrame);
 18 | 	}
 19 | }
 20 | function parseFrame(sf) {
 21 | 	LayerA = new Array();
 22 | 	startFrame = selectedFrame[1];
 23 | 	endFrame = selectedFrame[2];
 24 | 	for (var i = 0; i<selectedFrame.length; i=i+3) {
 25 | 		LayerA.push(selectedFrame[i]);
 26 | 	}
 27 | 	/*fl.trace("isDelete: "+isDelete);
 28 | 	fl.trace("sM: "+sM);
 29 | 	fl.trace("startFrame: "+startFrame);
 30 | 	fl.trace("endFrame: "+endFrame);
 31 | 	fl.trace("LayerA: "+LayerA);*/
 32 | 	if (sM<2) {
 33 | 		if (LayerA.length<2 || endFrame-startFrame>1) {
 34 | 			alert("Layer to Frame need at least 2 Layers and single frame is selected");
 35 | 		} else {
 36 | 			Layer2Frame();
 37 | 		}
 38 | 	} else if (sM>1) {
 39 | 		if (LayerA.length>1 || endFrame-startFrame == 1) {
 40 | 			alert("Frame to Layer need at least 2 Frames and single Layer is selected");
 41 | 		} else {
 42 | 			Frame2Layer();
 43 | 		}
 44 | 	}
 45 | }
 46 | function Layer2Frame() {
 47 | 	dom.getTimeline().setSelectedLayers(LayerA[0]);
 48 | 	dom.getTimeline().addNewLayer("NewLayer", "normal");
 49 | 	newLayer = LayerA[0];
 50 | 	if (sM == 0) {
 51 | 		var startLayer = LayerA.length-1;
 52 | 		var endLayer = 0;
 53 | 		var dir = -1;
 54 | 	} else {
 55 | 		var startLayer = 0;
 56 | 		var endLayer = LayerA.length-1;
 57 | 		var dir = 1;
 58 | 	}
 59 | 	var count = 0;
 60 | 	var i = startLayer;
 61 | 	while (i != endLayer+dir) {
 62 | 		dom.getTimeline().setSelectedLayers(LayerA[i]+1);
 63 | 		dom.getTimeline().copyFrames(selectedFrame[3*count+1], selectedFrame[3*count+2]);
 64 | 		dom.getTimeline().setSelectedLayers(newLayer);
 65 | 		dom.getTimeline().pasteFrames(selectedFrame[1]+count, selectedFrame[2]+count+1);
 66 | 		count++;
 67 | 		i = i+dir;
 68 | 	}
 69 | 	if (isDelete == "true") {
 70 | 		for (var i = LayerA.length-1; i>=0; i--) {
 71 | 			dom.getTimeline().deleteLayer(LayerA[i]+1);
 72 | 		}
 73 | 	}
 74 | 	dom.getTimeline().setSelectedFrames([]);
 75 | 	dom.selectNone();
 76 | }
 77 | function Frame2Layer() {
 78 | 	frameNo = selectedFrame[2]-selectedFrame[1];
 79 | 	if (sM == 2) {
 80 | 		var count = selectedFrame[1];
 81 | 		var dir = 1;
 82 | 	} else {
 83 | 		var count = selectedFrame[2]-1;
 84 | 		var dir = -1;
 85 | 	}
 86 | 	var i = 0;
 87 | 	var layerFrameno = dom.getTimeline().frameCount;
 88 | 	while (i<frameNo) {
 89 | 		dom.getTimeline().setSelectedLayers(LayerA[0]);
 90 | 		dom.getTimeline().copyFrames(count, count+1);
 91 | 		dom.getTimeline().setSelectedLayers(LayerA[0]+i);
 92 | 		dom.getTimeline().addNewLayer("NewLayer "+i, "normal", 0);
 93 | 		dom.getTimeline().pasteFrames(selectedFrame[1], selectedFrame[1]+1);
 94 | 		dom.getTimeline().removeFrames(selectedFrame[1]+1, layerFrameno);
 95 | 		count = count+dir;
 96 | 		i++;
 97 | 	}
 98 | 	if (isDelete == "true") {
 99 | 		dom.getTimeline().deleteLayer(LayerA[0]);
100 | 	}
101 | 	dom.getTimeline().setSelectedFrames([]);
102 | 	dom.selectNone();
103 | }
104 | 


--------------------------------------------------------------------------------
/ExportSymbols.jsfl:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Export for ActionScript selected library items.
  3 |  * Support exporting MovieClips, Bitmaps, Sounds and Fonts.
  4 |  * Copyright (c) 2014 flaxe. All rights reserved.
  5 |  */
  6 | 
  7 | var spriteClass = 'flash.display.Sprite';
  8 | var movieClipClass = 'flash.display.MovieClip';
  9 | var buttonClass = 'flash.display.SimpleButton';
 10 | var bitmapDataClass = 'flash.display.BitmapData';
 11 | var soundClass = 'flash.media.Sound';
 12 | var fontClass = 'flash.text.Font';
 13 | 
 14 | var doc = fl.getDocumentDOM();
 15 | var exportPackage = "";
 16 | var exportAssets = false;
 17 | 
 18 | if (!doc) {
 19 | 	alert('Please open or create a document.');
 20 | } else {
 21 | 	var selectedItems = fl.getDocumentDOM().library.getSelectedItems();
 22 | 	if (selectedItems.length == 0) {
 23 | 		alert('Please select one or more symbols in library to export.');
 24 | 	} else {
 25 | 		exportItems(selectedItems);
 26 | 	}
 27 | }
 28 | 
 29 | function exportItems(items)
 30 | {
 31 | 	var dialog = createUIDialog();
 32 | 	if (dialog.dismiss == 'accept') {
 33 | 		exportPackage = dialog.package;
 34 | 		exportAssets = dialog.exportAssets == 'true';
 35 | 		for (var i = 0; i < items.length; i++) {
 36 | 			exportItem(items[i]);
 37 | 		}
 38 | 	}
 39 | }
 40 | 
 41 | function exportItem(item)
 42 | {
 43 | 	switch (item.itemType) {
 44 | 		case 'movie clip':
 45 | 			exportSymbol(item, item.timeline.frameCount > 1 ? movieClipClass : spriteClass);
 46 | 			break;
 47 | 		case 'button':
 48 | 			exportSymbol(item, buttonClass);
 49 | 			break;
 50 | 		case 'bitmap':
 51 | 			if (exportAssets) exportSymbol(item, bitmapDataClass);
 52 | 			break;
 53 | 		case 'sound':
 54 | 			if (exportAssets) exportSymbol(item, soundClass);
 55 | 			break;
 56 | 		case 'font':
 57 | 			if (exportAssets) exportSymbol(item, fontClass);
 58 | 			break;
 59 | 	}
 60 | }
 61 | 
 62 | function exportSymbol(item, baseClass)
 63 | {
 64 | 	item.linkageExportForAS = true;
 65 | 	item.linkageExportInFirstFrame = true;
 66 | 	item.linkageBaseClass = baseClass;
 67 | 	item.linkageClassName = (exportPackage ? exportPackage + "." : "") + getItemPackage(item) + getItemName(item);
 68 | }
 69 | 
 70 | function getItemPackage(item)
 71 | {
 72 | 	var id = item.name.lastIndexOf('/');
 73 | 	if (id != -1) {
 74 | 		var pack = item.name.slice(0, id);
 75 | 		return formatPackage(pack).toLowerCase();
 76 | 	} else {
 77 | 		return "";
 78 | 	}
 79 | }
 80 | 
 81 | function formatPackage(pack)
 82 | {
 83 | 	pack = pack.replace(/[\s]/g, '');
 84 | 	pack = pack.replace(/\.\w+/g, '');
 85 | 	pack = pack.replace(/[\/]/g, '.');
 86 | 	return pack + '.';
 87 | }
 88 | 
 89 | function getItemName(item)
 90 | {
 91 | 	var id = item.name.lastIndexOf('/');
 92 | 	var name = (id != -1) ? item.name.slice(id + 1) : item.name;
 93 | 	return formatName(name);
 94 | }
 95 | 
 96 | function formatName(name)
 97 | {
 98 | 	return name.replace(/\s/g, '');
 99 | }
100 | 
101 | function createUIDialog()
102 | {
103 | 	var xml = '<?xml version="1.0"?>'
104 | 	+ '<dialog buttons="accept, cancel"  title="Export Symbols" >'
105 | 	+ '<hbox><label value="Package:" /><textbox id="package" value="" size="32" /></hbox>'
106 | 	+ '<hbox><checkbox id="exportAssets" label="Export Assets" checked="false" /></hbox>'
107 | 	+ '</dialog>';
108 | 	var url = fl.configURI + 'Commands/TempExportDialog' + parseInt(9999 * Math.random()) + '.xml';
109 | 	FLfile.write(url, xml);
110 | 	var output = fl.getDocumentDOM().xmlPanel(url);
111 | 	FLfile.remove(url);
112 | 	return output;
113 | }


--------------------------------------------------------------------------------
/Adjust Timeline to FPS.jsfl:
--------------------------------------------------------------------------------
  1 | fl.outputPanel.clear();
  2 | var doc = fl.getDocumentDOM();
  3 | 
  4 | var lib = doc.library;
  5 | var currFrameRate = doc.frameRate;
  6 | var newFrameRate = prompt("Enter new desired frame rate:", currFrameRate.toString());
  7 | var adjustMode = prompt("Adjust all movieclip timelines? (0=no, 1=yes)", 1);
  8 | 
  9 | if (newFrameRate != null && adjustMode != null)
 10 | {
 11 | 	if (adjustMode == 1) selectMainTimeline();
 12 | 	adjustTimeline();
 13 | 	if (adjustMode == 1)
 14 | 	{
 15 | 		var libItemCount = lib.items.length;
 16 | 		for (var libItemIndex = 0; libItemIndex < libItemCount; libItemIndex++)
 17 | 		{
 18 | 			var libItem = lib.items[libItemIndex];
 19 | 			if (libItem.itemType == "movie clip")
 20 | 			{
 21 | 				lib.editItem(libItem.name);
 22 | 				adjustTimeline();
 23 | 			}
 24 | 		}
 25 | 	}
 26 | 
 27 | 	if (adjustMode == 1) doc.frameRate = parseFloat(newFrameRate);
 28 | 	selectMainTimeline();
 29 | 	fl.trace("Timeline adjustment complete");
 30 | }
 31 | else
 32 | {
 33 | 	fl.trace("Action cancelled");
 34 | }
 35 | 
 36 | function selectMainTimeline()
 37 | {
 38 | 	doc.editScene(0);
 39 | }
 40 | 
 41 | function adjustTimeline()
 42 | {
 43 | 	var tl = doc.getTimeline();
 44 | 	fl.getDocumentDOM().getTimeline().expandFolder(true, true, -1);
 45 | 	var layerArray = tl.layers;
 46 | 	var layerCount = layerArray.length;
 47 | 	
 48 | 	for (var layerIndex = 0; layerIndex < layerCount; layerIndex++)
 49 | 	{
 50 | 		tl.currentLayer = layerIndex;
 51 | 		var currLayer = layerArray[layerIndex];
 52 | 		var frameArray = currLayer.frames;
 53 | 		var frameCount = frameArray.length;
 54 | 		var keyFrameArray = new Array();
 55 | 		var currStartFrame = 0;
 56 | 		keyFrameArray.push(currStartFrame);
 57 | 
 58 | 		for (var frameIndex = 0; frameIndex < frameCount; frameIndex++)
 59 | 		{
 60 | 			var currFrame = frameArray[frameIndex];
 61 | 			
 62 | 			if (currFrame.startFrame != currStartFrame)
 63 | 			{
 64 | 				keyFrameArray.push(currFrame.startFrame);
 65 | 				currStartFrame = currFrame.startFrame;
 66 | 			}
 67 | 		}
 68 | 
 69 | 		var keyFrameCount = keyFrameArray.length;
 70 | 		var endFrame = currLayer.frameCount - 1;
 71 | 		var frameChange = 0;
 72 | 
 73 | 		for (var keyFrameIndex = 0; keyFrameIndex < keyFrameCount; keyFrameIndex++)
 74 | 		{
 75 | 			var frameStart = keyFrameArray[keyFrameIndex];
 76 | 			
 77 | 			if (keyFrameIndex == (keyFrameCount - 1))
 78 | 			{
 79 | 				var frameEnd = endFrame;
 80 | 			}
 81 | 			else
 82 | 			{
 83 | 				var frameEnd = keyFrameArray[keyFrameIndex + 1];
 84 | 			}
 85 | 
 86 | 			var duration = frameEnd - frameStart;
 87 | 			var seconds = duration / currFrameRate;
 88 | 			var destFrameDur = seconds * newFrameRate;
 89 | 			frameChange = Math.round(duration - destFrameDur);
 90 | 
 91 | 			if (frameChange > 0)
 92 | 			{
 93 | 				if (frameChange > 0) tl.removeFrames(frameStart, (frameStart + frameChange));
 94 | 				endFrame -= frameChange;
 95 | 
 96 | 				for (var i = 0; i < keyFrameCount; i++)
 97 | 				{
 98 | 					if (i > keyFrameIndex)
 99 | 					{
100 | 						keyFrameArray[i] -= frameChange;
101 | 					}
102 | 				}
103 | 			}
104 | 			else
105 | 			{
106 | 				frameChange = Math.abs(frameChange);
107 | 
108 | 				if (frameChange > 0) tl.insertFrames(frameChange, false, frameStart);
109 | 
110 | 				endFrame += frameChange;
111 | 
112 | 				for (var i = 0; i < keyFrameCount; i++)
113 | 				{
114 | 					if (i > keyFrameIndex)
115 | 					{
116 | 						keyFrameArray[i] += frameChange;
117 | 					}
118 | 				}
119 | 			}
120 | 		}
121 | 	}
122 | }
123 | 
124 | 
125 | 


--------------------------------------------------------------------------------
/wrap selected as new symbol.jsfl:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Wraps all selected items in the library in a movie
  3 |  * clip, with registration point set to 0,0.
  4 |  */
  5 | ConvertAllToClips = function(){}
  6 | var proto = ConvertAllToClips.prototype;
  7 | proto.doc = fl.getDocumentDOM();
  8 | proto.init = function()
  9 | {
 10 | 	if(xmui.dismiss == "accept")
 11 | 	{
 12 | 		this.lib = this.doc.library;
 13 | 		var cItems = this.lib.getSelectedItems();
 14 | 		var cLength = cItems.length;
 15 | 		
 16 | 		//add a temporary clip to the library in which conversion takes place:
 17 | 		this.lib.addNewItem("movie clip", "_tmpConversionClip");
 18 | 		this.lib.editItem("_tmpConversionClip");
 19 | 		
 20 | 		//put selected library items to stage:
 21 | 		for(var i = 0; i < cLength; i++)
 22 | 		{
 23 | 			//this.lib.selectItem(cItems[i].name);
 24 | 			this.lib.addItemToDocument({x:0, y:0}, cItems[i].name);
 25 | 		}
 26 | 		
 27 | 		//select all items:
 28 | 		this.doc.selectNone();
 29 | 		this.doc.selectAll();
 30 | 		this.doc.distributeToLayers();
 31 | 
 32 | 		//delete the first layer, it's empty now:
 33 | 		this.doc.getTimeline().deleteLayer(0);
 34 | 			
 35 | 		//get all layers again:
 36 | 		var currentLayers = this.doc.getTimeline().layers;
 37 | 		
 38 | 		//first lock all layers:
 39 | 		var i = 0;
 40 | 		for(i in currentLayers)
 41 | 		{
 42 | 			currentLayers[i].locked = true;
 43 | 		}
 44 | 			
 45 | 		//create folder:
 46 | 		this.lib.newFolder(xmui.folderName);
 47 | 			
 48 | 		//then unlock layer by layer, convert, then lock again:
 49 | 		var j = 0;
 50 | 		var cl = currentLayers.length; // use backwards counting value for layers so item order stays correct.
 51 | 		for(j in currentLayers)
 52 | 		{
 53 | 			cl--;
 54 | 			if(!currentLayers[cl])
 55 | 			{
 56 | 				fl.trace("NOT HERE");
 57 | 				break;
 58 | 			}
 59 | 			currentLayers[cl].locked = false;
 60 | 			this.doc.selectNone();
 61 | 			this.doc.selectAll();
 62 | 
 63 | 			//check if leading zeroes should be used:
 64 | 			if (xmui.leadingZeroes == "true")
 65 | 			{
 66 | 				//check how many zeroes are actually needed:
 67 | 				var tmpLength = currentLayers.length;
 68 | 				if(tmpLength < 100)
 69 | 				{
 70 | 					if(j < 10) var lz = "0";
 71 | 					else if(j >= 10) var lz = "";
 72 | 				}
 73 | 				else if(tmpLength >= 100 && tmpLength < 1000)
 74 | 				{
 75 | 					if (j < 10) var lz = "00";
 76 | 					else if (j >= 10 && j < 100) var lz = "0";
 77 | 					else if (j >= 100) var lz = "";
 78 | 				}
 79 | 				else if (tmpLength >= 1000)
 80 | 				{
 81 | 					if (j < 10) var lz = "000";
 82 | 					else if (j >= 10 && j < 100) var lz = "00";
 83 | 					else if (j >= 100 && j < 1000) var lz = "0";
 84 | 					else if (j >= 1000) var lz = "";
 85 | 				}
 86 | 			}
 87 | 			else
 88 | 			{
 89 | 				var lz = "";
 90 | 			}
 91 | 			
 92 | 			//finally convert selected item:
 93 | 			this.doc.convertToSymbol(xmui.itemType, xmui.itemName + lz + j, xmui.regPoint);
 94 | 			this.lib.moveToFolder(xmui.folderName);
 95 | 			this.doc.getTimeline().deleteLayer();
 96 | 		}
 97 | 		
 98 | 		//delete the rest:
 99 | 		this.doc.selectNone();
100 | 		this.doc.selectAll();
101 | 		if(this.doc.selection.length > 0) this.doc.deleteSelection();
102 | 		this.doc.exitEditMode();
103 | 		this.lib.deleteItem("_tmpConversionClip");
104 | 	}
105 | }
106 | var theDoc = fl.getDocumentDOM();
107 | if (!theDoc) alert("You need to open a Flash file first!");
108 | else
109 | {
110 | 	if(theDoc.library.getSelectedItems().length <= 1) alert("Please select at least two items in the library!");
111 | 	else
112 | 	{
113 | 		var xmui = theDoc.xmlPanel(fl.configURI + "Commands/xmui/wrap selected as new symbol.xml");
114 | 		var obj = new ConvertAllToClips();
115 | 		obj.init();
116 | 	}
117 | }


--------------------------------------------------------------------------------
/Combine Textfields.jsfl:
--------------------------------------------------------------------------------
1 | //Combine Textfields
//Justin Putney
//http://putney.ajarproductions.com
//version 1.0.0


var dom = fl.getDocumentDOM();

fl.outputPanel.clear();
var sortProp = "top";
var sel = dom.selection;
var selTextfields = new Array();
var firstField;
var uri = fl.scriptURI;
var uArr = uri.split("/");
uArr.pop();
var uri = uArr.join("/");
//fl.trace(uri);

collectFields();

if(selTextfields.length > 1) {
	var xpanel = dom.xmlPanel(uri + "/Combine Textfields.xml");

	var separator = xpanel["separator"];
	sortProp = xpanel["sortby"];
	//fl.trace("sort by..." + sortProp);
	separator = replace(separator, '\\r', '\r');
	separator = replace(separator, '\\n', '\n');
	
	
	if(xpanel.dismiss == "accept") run();
} else if (selTextfields.length == 1){
		alert('You must select multiple textfields.');
	}
	else {
		alert('No textfields were selected.');
}

function run(){
		dom.selection = selTextfields; //select only textfields
		//flip for sorting
		if(sortProp == "bottom") dom.scaleSelection(1, -1);
		if(sortProp == "right") dom.scaleSelection(-1, 1);
		selTextfields.sort(sortFields);
		//flip back
		if(sortProp == "bottom") dom.scaleSelection(1, -1);
		if(sortProp == "right") dom.scaleSelection(-1, 1);
		combine(selTextfields);
}

//get all TFs //store them
function collectFields(){
	for(var i = 0; i < sel.length; i++){
		var tSelection = sel[i]; 
		if(tSelection == "[object Text]"){
			selTextfields.push(tSelection);
		}
	}
}

function replace(searchStr, findStr, replaceStr){
	//fl.trace('replacing...' + findStr + '...with...' + replaceStr + '...in: ' + searchStr);
	var tArr = searchStr.split(findStr);
	var returnStr = tArr.join(replaceStr);
	return returnStr;
}


//sort them
function sortFields(a,b) {
	var tProp = sortProp;
	if(tProp == "bottom") tProp = "top"; //use flipped values
	if(tProp == "right") tProp = "left"; //use flipped values
	var aN = parseInt(a[tProp]);
	var bN = parseInt(b[tProp]);
	var returnVal = aN - bN;
	if(returnVal == 0) {
		//second level sorting
		if(tProp == "top") tProp = "left";
		if(tProp == "left") tProp = "top";
		if(tProp == "right") tProp = "top";
		if(tProp == "bottom") tProp = "left";
		aN = parseInt(a[tProp]);
		bN = parseInt(b[tProp]);
		returnVal = aN - bN;
	}
	return aN - bN;
}


//for testing only
function traceFields(arr){
	for(var i=0; i<arr.length; i++){
		fl.trace(arr[i].getTextString());
	}
}


function combine(arr){ //take 1st field, add each TF's text runs with attributes
	var targField = arr.shift();
	//fl.trace("combining to targField with content: " + targField.getTextString());
	for(var i =0; i <arr.length; i++){
		targField.setTextString(separator, targField.getTextString().length);
		for(var j=0; j < arr[i].textRuns.length; j++) { //run through textruns for each field
			var tRun = arr[i].textRuns[j];
			var startPos = targField.getTextString().length;
			targField.setTextString(separator, startPos);
			startPos = targField.getTextString().length - separator.length;
			targField.setTextString(tRun.characters, startPos, startPos+separator.length);
			var endPos = targField.getTextString().length;
			var tAttribs = tRun.textAttrs;
			for(var attr in tAttribs){
				var attrName = attr;
				var attrValue = tAttribs[attr];
				//if(attrValue != undefined) fl.trace('setting ' + attrName + ' attribute of ' + tRun.characters + ' to ' + attrValue);
				if(attrValue != undefined && attr!= 'rotation') targField.setTextAttr(attrName, attrValue, startPos, endPos);
			}//end attribute loop
		}//end textrun loop
		
	}
	clearFields(targField, arr); //clean-up
}


function clearFields(newField, oldFields){
	//fl.trace('clearing ' + oldFields.length + ' fields, saving field: ' + newField.getTextString());
	dom.selectNone();
	dom.selection = oldFields;
	dom.deleteSelection();
	dom.selection = [newField];
}



--------------------------------------------------------------------------------
/shape2array.jsfl:
--------------------------------------------------------------------------------
  1 | /**
  2 | *
  3 | * this script only works under certain conditions:
  4 | *		- everything that is selected must be shapes, if not, this doesn't work (select all and ctrl+b (break))
  5 | * 		- every shape has to be in a different layer, otherwise the script see it as one shape
  6 | *
  7 | * The result of this jsfl is not always what you expect...
  8 | * 		sometimes geometric shapes like squares/rectangles/triangles are all f#$%ed-up (it looks like curves are made to opposite corners)
  9 | * 		I have no solution for that in this jsfl (in the code), it seems that Flash 'reads' the shape wrong (or in the wrong order)...
 10 | *		But you could try: 	- I used the straighten tool which worked in one case, but not in the other
 11 | *						- rotated a square 90 degrees
 12 | *						- both solutions
 13 | *
 14 | *
 15 | *
 16 | * based upon 		http://ericlin2.tripod.com/bugwire/bugwiret.html
 17 | * and			http://livedocs.adobe.com/flash/9.0/main/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=00003869.html
 18 | *
 19 | * <pre>
 20 | *  ____                   _      ____
 21 | * |  __| _ __ ___    ___ | | __ |__  |
 22 | * | |   | '_ ` _ \  / __|| |/ /    | |
 23 | * | |   | | | | | || (__ |   <     | |
 24 | * | |__ |_| |_| |_| \___||_|\_\  __| |
 25 | * |____|                        |____|
 26 | *
 27 | * </pre>
 28 | *
 29 | *
 30 | * @author			Matthijs C. Kamstra [mck]
 31 | * @version		1.1
 32 | * @since			10:00 5-5-2008
 33 | *
 34 | * Changelog:
 35 | * 		v1.1 [2008-05-09] - test movie after use of this jsfl
 36 | * 		v1.0 [2008-05-05] - Initial release
 37 | *
 38 | *
 39 | */
 40 | var currentVersion = '1.1';
 41 | 
 42 | fl.trace ('[mck] shape2Array :: version ' + currentVersion);
 43 | 
 44 | // with a shape selected
 45 | var ptArray = [];
 46 | var doneEdge = [];
 47 | var exportString = 'var shapeArrayz:Array = new Array ();\n';
 48 | var selectionNumber = 0;
 49 | 
 50 | // fl.trace("// start ---------------------------");
 51 | function isDrawn(id) {
 52 | 	for (var k = 0; k<doneEdge.length; k++) {
 53 | 		if (doneEdge[k] == id) {
 54 | 			return true;
 55 | 		}
 56 | 	}
 57 | 	return false;
 58 | }
 59 | 
 60 | sel = fl.getDocumentDOM().selection;
 61 | for (var n = 0; n < sel.length; n++) {
 62 | 
 63 | 	exportString += 'shapeArrayz['+n+'] = [';
 64 | 	selectionNumber = sel.length;
 65 | 
 66 | 	var elt = sel[n];
 67 | 	if (elt.elementType != 'shape') {
 68 | 		continue;
 69 | 	}
 70 | 	elt.beginEdit();
 71 | 	for (i=0; i<elt.contours.length; i++) {
 72 | 		var cont = elt.contours[i];
 73 | 		var he = cont.getHalfEdge();
 74 | 		var startId = he.id;
 75 | 		var id = 0;
 76 | 		while (id != startId) {
 77 | 			var ed = he.getEdge();
 78 | 			if (!isDrawn(ed.id)) {
 79 | 				doneEdge.push(ed.id);
 80 | 				for (var j = 0; j<3; j++) {
 81 | 					var pt = ed.getControl(j);
 82 | 					ptArray.push(pt.x, pt.y , j);
 83 | 					exportString += '[' + pt.x + ',' + pt.y + ',' + j + '] , ';
 84 | 				}
 85 | 			}
 86 | 			he = he.getNext();
 87 | 			id = he.id;
 88 | 		}
 89 | 	}
 90 | 	elt.endEdit();
 91 | 	exportString += '];\n';
 92 | }
 93 | // fl.trace(ptArray);
 94 | // fl.trace("// end ---------------------------");
 95 | 
 96 | // I'm a lazy bastard, so paste the code in the as layer
 97 | // create or place code in 'as' layer
 98 | var tl = fl.getDocumentDOM().getTimeline();
 99 | if (tl.findLayerIndex("as") == undefined){
100 | 	tl.addNewLayer('as', 'normal' , true);
101 | } else {
102 | 	tl.currentLayer = tl.findLayerIndex("as")[0];
103 | }
104 | tl.layers[tl.currentLayer].frames[0].actionScript = exportString.split('] , ];').join(']];') + "\n";
105 | 
106 | // The following example tests the movie for the current document:
107 | fl.getDocumentDOM().testMovie(); // if you don't want to export to swf after the jsfl is ready, comment this line
108 | 
109 | // end jsfl
110 | 


--------------------------------------------------------------------------------
/Export ActionScript.jsfl:
--------------------------------------------------------------------------------
  1 | var dom = fl.getDocumentDOM();
  2 | 
  3 | // AScript definition
  4 | function AScript(code, timeline, layer, frame, isScene){
  5 | 	this.code = code;
  6 | 	this.timeline = timeline;
  7 | 	this.layer = layer;
  8 | 	this.frame = frame;
  9 | 	this.isScene = isScene;
 10 | 	
 11 | 	this.id = "script:"+this.timeline+"."+this.layer+"."+this.frame;
 12 | 	this.title = AScript.timelines[this.timeline].name+': '+AScript.timelines[this.timeline].layers[this.layer].name+', frame '+(this.frame + 1);
 13 | }
 14 | AScript.prototype.toString = function(){
 15 | 	return this.code;
 16 | }
 17 | AScript.scripts = new Array();
 18 | AScript.timelines = new Array();
 19 | AScript.addScript = function(code, timeline, layer, frame, isScene){
 20 | 	AScript.scripts.push(new AScript(code, timeline, layer, frame, isScene));
 21 | }
 22 | 
 23 | function parseCode() {
 24 | 	// main timeline timelines
 25 | 	var sceneCount = dom.timelines.length;
 26 | 	AScript.timelines = AScript.timelines.concat(dom.timelines);
 27 | 
 28 | 	// library timelines
 29 | 	var items = dom.library.items;
 30 | 	var n = items.length;
 31 | 	var i = 0;
 32 | 	while (i < n){
 33 | 		if (items[i].itemType == "movie clip") {
 34 | 			AScript.timelines.push(items[i].timeline);
 35 | 		}
 36 | 		i++;
 37 | 	}
 38 | 	
 39 | 	// get code
 40 | 	var li, fi;
 41 | 	var ln, fn;
 42 | 	var as;
 43 | 	var n = AScript.timelines.length;
 44 | 	var i = 0;
 45 | 	while (i < n) {
 46 | 		ln = AScript.timelines[i].layers.length;
 47 | 		li = 0;
 48 | 		while (li < ln) {
 49 | 			fn = AScript.timelines[i].layers[li].frames.length;
 50 | 			fi = 0;
 51 | 			while (fi < fn) {
 52 | 				as = AScript.timelines[i].layers[li].frames[fi].actionScript;
 53 | 				if (as) {
 54 | 					AScript.addScript(as, i, li, fi, (i < sceneCount));
 55 | 				}
 56 | 				fi += AScript.timelines[i].layers[li].frames[fi].duration;
 57 | 			}
 58 | 			li++;
 59 | 		}
 60 | 		i++;
 61 | 	}
 62 | }
 63 | 
 64 | 
 65 | function generateTOC() {
 66 | 	// table of contents
 67 | 	var str = "";
 68 | 	str += '<ul>\n'+
 69 | 	'	<li><h5>Scenes:</h5>\n'+
 70 | 	'		<ul>\n';
 71 | 	var n = AScript.scripts.length;
 72 | 	var i = 0;
 73 | 	while (i < n){
 74 | 		if (AScript.scripts[i].isScene) {
 75 | 			str += '			<li><a href="#'+AScript.scripts[i].id+'">'+AScript.scripts[i].title+'</a></li>\n';
 76 | 		}
 77 | 		i++;
 78 | 	}
 79 | 	str += '		</ul>\n'+
 80 | 	'	</li>\n'+
 81 | 	'	<li><h5>Symbols:</h5>\n'+
 82 | 	'		<ul>\n';
 83 | 	n = AScript.scripts.length;
 84 | 	i = 0;
 85 | 	while (i < n){
 86 | 		if (!AScript.scripts[i].isScene) {
 87 | 			str += '			<li><a href="#'+AScript.scripts[i].id+'">'+AScript.scripts[i].title+'</a></li>\n';
 88 | 		}
 89 | 		i++;
 90 | 	}
 91 | 	str += '		</ul>\n'+
 92 | 	'	</li>\n'+
 93 | 	'</ul>\n'
 94 | 	return str;
 95 | }
 96 | 
 97 | function generateContent() {
 98 | 	// actionscripts
 99 | 	var str = "";
100 | 	var n = AScript.scripts.length;
101 | 	var i = 0;
102 | 	while (i < n){
103 | 		str += formatScript(AScript.scripts[i]);
104 | 		i++;
105 | 	}
106 | 	return str;
107 | }
108 | 
109 | function formatScript(script){
110 | 	// individual scripts
111 | 	return ''+
112 | 	'<div class="script">\n'+
113 | 	'	<h4 class="scriptTitle"><a name="'+script.id+'">'+script.title+'</a></h4>\n'+
114 | 	'	<pre class="code">'+replaceEntities(script.code)+'</pre>\n'+
115 | 	'</div>\n';
116 | }
117 | function replaceEntities(str){
118 | 	return str.replace(/&/g,"&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
119 | }
120 | 
121 | function init(){
122 | 	var saveFile = fl.browseForFileURL("save", "Save File");
123 | 	if (saveFile) {
124 | 		var templateFile = fl.configURI + "Commands/Export ActionScript/template.html";
125 | 		var str = FLfile.read(templateFile);
126 | 		parseCode();
127 | 		str = str.replace(/%%title%%/g, dom.name);
128 | 		str = str.replace(/%%toc%%/g, generateTOC());
129 | 		str = str.replace(/%%content%%/g, generateContent());
130 | 		FLfile.write(saveFile, str);
131 | 	}
132 | }
133 | 
134 | init();


--------------------------------------------------------------------------------
/Slice Bitmap Instance.jsfl:
--------------------------------------------------------------------------------
 1 | /*
 2 | Slice Bitmap Instance v1
 3 | Copyright © 2007 GGSHOW.NET
 4 | All Rights Reserved.
 5 | 
 6 | Author: Goh Lee Chuan a.k.a. Mr G.
 7 | Email: gg1980@gmail.com
 8 | Homepage: http://www.ggshow.net
 9 | */
10 | var gg_dialog = fl.getDocumentDOM().xmlPanel(fl.configURI+"Commands/Slice Bitmap Instance.xml");
11 | if (gg_dialog.dismiss == "accept") {
12 | 	var type = gg_dialog.t;
13 | 	var o = gg_dialog.o;
14 | 	var p = gg_dialog.p;
15 | 	var s = Number(gg_dialog.s);
16 | 	var l = Number(fl.getDocumentDOM().getSelectionRect().left);
17 | 	var t = Number(fl.getDocumentDOM().getSelectionRect().top);
18 | 	var r = Number(fl.getDocumentDOM().getSelectionRect().right);
19 | 	var b = Number(fl.getDocumentDOM().getSelectionRect().bottom);
20 | 	var w = Number(r-l);
21 | 	var h = Number(b-t);
22 | 	var h0 = Number(gg_dialog.h);
23 | 	var v0 = Number(gg_dialog.v);
24 | 	var w1 = Number(w/h0);
25 | 	var h1 = Number(h/v0);
26 | 	if ((fl.getDocumentDOM().selection.length != 1) || (fl.getDocumentDOM().selection[0].instanceType != "bitmap")) {
27 | 		alert("Error: You must select a bitmap instance.");
28 | 	} else if (isNaN(h0)||isNaN(v0)||h0<1||v0<1||h0>100||v0>100||isNaN(s)||s<0) {
29 | 		alert("Error: Invalid parameters.");
30 | 	} else {
31 | 		fl.getDocumentDOM().group();
32 | 		fl.getDocumentDOM().enterEditMode('inPlace');
33 | 		if (o=="mask") {
34 | 			var fill = fl.getDocumentDOM().getCustomFill();
35 | 			fill.color = 0xFF0000;
36 | 			fill.style = "solid";
37 | 			fl.getDocumentDOM().setCustomFill(fill);
38 | 			fl.getDocumentDOM().clipCut();
39 | 			for (var j = 0; j<v0; j++) {
40 | 				for (var i = 0; i<h0; i++) {
41 | 					var n = p+j+"_"+i;
42 | 					var k = 0;
43 | 					var n1 = n;
44 | 					while(fl.getDocumentDOM().library.itemExists(n1)){
45 | 						k++;
46 | 						n1 = n+"_"+k;
47 | 					}
48 | 					n = n1;
49 | 					fl.getDocumentDOM().clipPaste(true);
50 | 					fl.getDocumentDOM().convertToSymbol(type, n, 'top left');
51 | 					fl.getDocumentDOM().setTransformationPoint({x:(0.5+i)*w1, y:(0.5+j)*h1});
52 | 					fl.getDocumentDOM().enterEditMode('inPlace');
53 | 					fl.getDocumentDOM().getTimeline().addNewLayer();
54 | 					fl.getDocumentDOM().addNewRectangle({left:i*w1+l, top:j*h1+t, right:(i+1)*w1+l, bottom:(j+1)*h1+t}, 0, false, true);
55 | 					fl.getDocumentDOM().getTimeline().setLayerProperty('layerType', 'mask');
56 | 					fl.getDocumentDOM().getTimeline().setSelectedLayers(1, true);
57 | 					fl.getDocumentDOM().getTimeline().setLayerProperty('layerType', 'masked');
58 | 					fl.getDocumentDOM().exitEditMode();
59 | 					if (type == 'movie clip') {
60 | 						fl.getDocumentDOM().selection[0].name = n;
61 | 					}
62 | 					flash.getDocumentDOM().moveSelectionBy({x:i*s, y:j*s});
63 | 				}
64 | 			}
65 | 		} else if (o=="cut") {
66 | 			fl.getDocumentDOM().breakApart();
67 | 			for (var j = 0; j<v0; j++) {
68 | 				for (var i = 0; i<h0; i++) {
69 | 					var n = p+j+"_"+i;
70 | 					var k = 0;
71 | 					var n1 = n;
72 | 					while(fl.getDocumentDOM().library.itemExists(n1)){
73 | 						k++;
74 | 						n1 = n+"_"+k;
75 | 					}
76 | 					n = n1;
77 | 					fl.getDocumentDOM().setSelectionRect({left:w1*i+l, top:h1*j+t, right:w1*(i+1)+l, bottom:h1*(j+1)+t}, true, true);
78 | 					fl.getDocumentDOM().convertToSymbol(type, n, 'center');
79 | 					fl.getDocumentDOM().enterEditMode('inPlace');
80 | 					fl.getDocumentDOM().selectNone();
81 | 					fl.getDocumentDOM().getTimeline().setLayerProperty('locked', 'true');
82 | 					fl.getDocumentDOM().exitEditMode();
83 | 					if (type == 'movie clip') {
84 | 						fl.getDocumentDOM().selection[0].name = n;
85 | 					}
86 | 					flash.getDocumentDOM().moveSelectionBy({x:i*s, y:j*s});
87 | 					fl.getDocumentDOM().selection[0].locked = true;
88 | 				}
89 | 			}
90 | 			fl.getDocumentDOM().unlockAllElements();
91 | 		}
92 | 		fl.getDocumentDOM().exitEditMode();
93 | 		fl.getDocumentDOM().unGroup();
94 | 		var total = Number(v0*h0);
95 | 		alert("Slice bitmap instance (" + h0 + " x " + v0 + ") successful.\nTotal " + total + " " + type + " symbols created.");
96 | 	}
97 | }
98 | 


--------------------------------------------------------------------------------
/Replace associated class text.jsfl:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Replaces text in class definitions within a FLA. When run
  3 |  * two prompts will appear to specify search and replace text.
  4 |  * Once entered, all class definitions including the document
  5 |  * class, library item classes, and library base classes will
  6 |  * be searched for the specified text and replaced with the
  7 |  * respective text using a replace regular expression. After
  8 |  * the command has completed, an alert will appear providing
  9 |  * a report of the results.
 10 |  */
 11 | function replaceClassText(){
 12 | 	
 13 | 	// get search and replace text from the user
 14 | 	// if the prompt is canceled, abort command
 15 | 	var userFindText = prompt("Library class text to find", "");
 16 | 	if (!userFindText) {
 17 | 		fl.trace("User canceled command.");
 18 | 		return;
 19 | 	}
 20 | 	var userReplaceText = prompt("Text to replace it", "");
 21 | 	if (!userReplaceText) {
 22 | 		fl.trace("User canceled command.");
 23 | 		return;
 24 | 	}
 25 | 	
 26 | 	// set up the regular expression that will
 27 | 	// replace the specified text (g = globally)
 28 | 	var searchReg = new RegExp(userFindText, "g");
 29 | 	var docClassReplaceCount = 0;	// report for document class replacement
 30 | 	var classReplaceCount = 0;		// report for class replacement
 31 | 	var baseReplaceCount = 0;		// report for base class replacement
 32 | 	var item, classText;
 33 | 	var dom = fl.getDocumentDOM();
 34 | 	var lib = dom.library;
 35 | 	
 36 | 	// Document class
 37 | 	classText = dom.docClass;
 38 | 	if (classText){
 39 | 		dom.docClass = classText.replace(searchReg, userReplaceText);
 40 | 		
 41 | 		// if the class text changed, increment report value
 42 | 		if (classText != dom.docClass){
 43 | 			docClassReplaceCount++;
 44 | 		}
 45 | 	}
 46 | 	
 47 | 	// Library items
 48 | 	var i = lib.items.length;
 49 | 	while (i--){
 50 | 		item = lib.items[i];
 51 | 		
 52 | 		// class name
 53 | 		classText = item.linkageClassName;
 54 | 		if (classText){
 55 | 			item.linkageClassName = classText.replace(searchReg, userReplaceText);
 56 | 			
 57 | 			// if the class text changed, increment report value
 58 | 			if (classText != item.linkageClassName){
 59 | 				classReplaceCount++;
 60 | 			}
 61 | 		}
 62 | 		
 63 | 		// base class
 64 | 		classText = item.linkageBaseClass;
 65 | 		if (!classText){
 66 | 			
 67 | 			// using default base class check the type to
 68 | 			// get the implied base class. this is required
 69 | 			// since the [implied] base class returns "" if
 70 | 			// not specified by the user
 71 | 			switch (item.itemType){
 72 | 				case "button":
 73 | 					classText = "flash.display.SimpleButton";
 74 | 					break;
 75 | 				case "movie clip":
 76 | 					classText = "flash.display.MovieClip";
 77 | 					break;
 78 | 				case "bitmap":
 79 | 					classText = "flash.display.BitmapData";
 80 | 					break;
 81 | 				case "sound":
 82 | 					classText = "flash.media.Sound";
 83 | 					break;
 84 | 				
 85 | 				// no implied base class - a symbol
 86 | 				// that cannot have a base class
 87 | 				default:
 88 | 					classText = null;
 89 | 					break;
 90 | 			}
 91 | 		}
 92 | 		
 93 | 		// check again for class text in case implied
 94 | 		// text was set. also make sure a class name exists
 95 | 		// if you're going to change the base otherwise
 96 | 		// the setting of the base class will fail and the
 97 | 		// the command will be silently aborted by Flash
 98 | 		if (classText && item.linkageClassName){
 99 | 			item.linkageBaseClass = classText.replace(searchReg, userReplaceText);
100 | 			
101 | 			// if the class text changed, increment report value
102 | 			if (classText != item.linkageBaseClass){
103 | 				baseReplaceCount++;
104 | 			}
105 | 		}
106 | 	}
107 | 	
108 | 	// report the results
109 | 	alert(docClassReplaceCount +" document classes replaced\n"
110 | 		  +classReplaceCount +" library item classes replaced\n"
111 | 		  +baseReplaceCount +" library item base classes replaced");
112 | }
113 | 
114 | // call the method. In case there's
115 | // an error, trace it to the output window
116 | try {
117 | 	replaceClassText();
118 | }catch(error){
119 | 	fl.trace(error);
120 | }


--------------------------------------------------------------------------------
/_Change AntiAnim to DeviceFonts.jsfl:
--------------------------------------------------------------------------------
  1 | /*
  2 | 
  3 | Change all textfields with "Anti-alias for animation" back to "Use device fonts".
  4 | 
  5 | Features:
  6 | 
  7 | - Searches within all scenes, and all their contents
  8 | - Searches within all library items, to find clips not used in a scene
  9 | - Searches within all groups (Flash CS4 only)
 10 | - Only changes "Anti-alias for animation" textfields
 11 | - Preserves textfields with Custom or "Anti-alias for readability"
 12 | 
 13 | */
 14 | 
 15 | fl.showIdleMessage(false);
 16 | 
 17 | fl.outputPanel.clear();//clear output panel
 18 | fl.trace("\n****************************************\n");
 19 | 
 20 | var seenMCs = {};
 21 | 
 22 | var date = new Date();
 23 | var ms1 = date.getTime();
 24 | var tfnum = 0;
 25 | var tfmod = 0;
 26 | 
 27 | //currently focussed document
 28 | var d = fl.getDocumentDOM();
 29 | 
 30 | 
 31 | //Iterate through all scenes
 32 | var mtl = d.timelines;
 33 | 
 34 | for (var snum = 0, slen = mtl.length; snum<slen; snum++){
 35 | 	d.currentTimeline = snum; // Set active timeline(scene)
 36 | 	
 37 | 	var tln = mtl[snum];	
 38 | 	var objs = go(null, null, tln);
 39 | }	
 40 | 
 41 | 
 42 | //Iterate through all items in library
 43 | var arr = d.library.items;
 44 | var alen = arr.length;
 45 | for(n = 0; n < alen; n++){
 46 | 	
 47 | 	var ar = arr[n];
 48 | 	if(ar.itemType !== "folder"){
 49 | 
 50 | 		var tl = ar.timeline;
 51 | 		var objs = go(ar ,ar, tl);
 52 | 	}
 53 | }
 54 | 
 55 | date = new Date();
 56 | var ms2 = date.getTime();
 57 | 
 58 | fl.trace("\nSCRIPT TIME: "+ ((ms2-ms1)/1000) + " sec.");
 59 | fl.trace("MODIFIED "+tfmod+" of "+tfnum+" TEXTFIELDS");
 60 | fl.trace("\n****************************************");
 61 | 
 62 | 
 63 | 
 64 | function go(pmc, mc, tl, lvl){
 65 | 
 66 | 	// dont go thru same thing twice
 67 | 	if(pmc != null){
 68 | 		if (seenMCs[pmc.name]==1){
 69 | 			d.library.editItem(pmc.name);
 70 | 			return;
 71 | 		}else{
 72 | 			seenMCs[pmc.name]=1;// done
 73 | 		}
 74 | 	}
 75 | 	
 76 | 	// go in
 77 | 	if(mc != null){
 78 | 		d.library.editItem(mc.name);
 79 | 	}
 80 | 	
 81 | 	if (tl==null){	return; }
 82 | 	
 83 | 	if(!lvl){ lvl = "  "; }
 84 | 	
 85 | 	// layers
 86 | 	for(var t=0,tlen = tl.layers.length; t<tlen; t++){
 87 | 	
 88 | 		// go through all the frames
 89 | 		for(var f=0,lfrm = tl.layers[t].frameCount; f<lfrm; f++){
 90 | 
 91 | 			var el = tl.layers[t].frames[f].elements;
 92 | 			goFrame(mc, el, lvl+"    ", tl.name);
 93 | 		}
 94 | 	}
 95 | 	
 96 | 	// go out
 97 | 	if(pmc != null){
 98 | 		d.library.editItem(pmc.name);
 99 | 	}
100 | }
101 | 
102 | function goFrame(mc, obj, lvl, tln){
103 | 	if(tln==null){tln = "?";}
104 | 
105 | 	if (obj==null){	return; }
106 | 	
107 | 	for (var o=0, oblen=obj.length; o<oblen; o++){
108 | 		
109 | 		var ob = obj[o];
110 | 		var ot = obj[o].elementType; //element type
111 | 								 
112 | 		if(ot == "instance"){
113 | 			
114 | 			var oi = ob.libraryItem.symbolType //SymbolItem Type: "movie clip"  "button"  and "graphic"
115 | 			
116 | 			if(oi == "movie clip"){
117 | 				go(mc, ob, ob.libraryItem.timeline, lvl+"    ")
118 | 				
119 | 				
120 | 			}else if(oi == "button"){		
121 | 				go(mc, ob, ob.libraryItem.timeline, lvl+"    ")				
122 | 				
123 | 			}else if(oi == "graphic"){
124 | 				go(mc, ob, ob.libraryItem.timeline, lvl+"    ")
125 | 			}
126 | 			
127 | 		}else if(ot == "shape" || ot == "shapeObj"){//for Group objects
128 | 			
129 | 			if(ob.isGroup){
130 | 				goFrame(mc, ob.members, lvl+"    ");// find objs in group
131 | 			}
132 | 		}else if(ot == "text"){//text
133 | 			
134 | 			tfnum++; //Total textfields
135 | 			var tft = ob.textType != "static"?ob.name:"Static";
136 | 			
137 | 			if(ob.fontRenderingMode == "standard"){
138 | 				fl.trace(tln+"\t - MODIFIED "+tft+"\t - "+fntRenderType(ob.fontRenderingMode)+" - SET TO - Device Fonts");
139 | 				ob.fontRenderingMode = "device";
140 | 				tfmod++; //Modified textfields
141 | 			}
142 | 		}
143 | 	}	
144 | }
145 | 
146 | function fntRenderType(rdrMode){
147 | 	
148 | 	switch(rdrMode){
149 | 		
150 | 		case "device":		return "Device Fonts";
151 | 		case "bitmap":		return "Bitmap Fonts";
152 | 		case "standard":	return "Anti-Alias for Animation";
153 | 		case "advanced":	return "Anti-Alias for Readability";
154 | 		case "customThicknessSharpness":	return "Custom Anti-Alias";
155 | 
156 | 	}
157 | }
158 | 
159 | 


--------------------------------------------------------------------------------
/Redundant Text - Shape Optimizer.jsfl:
--------------------------------------------------------------------------------
  1 | fl.outputPanel.clear();
  2 | var doc = fl.getDocumentDOM();
  3 | doc.zoomFactor = 8;
  4 | doc.clipCopy();
  5 | doc.getTimeline().addNewLayer("Original", "normal", false);
  6 | doc.clipPaste(true);
  7 | doc.getTimeline().layers[doc.getTimeline().currentLayer].layerType = "guide";
  8 | doc.getTimeline().layers[doc.getTimeline().currentLayer].locked = true;
  9 | doc.getTimeline().layers[doc.getTimeline().currentLayer].visible = false;
 10 | doc.getTimeline().setSelectedLayers(0);
 11 | doc.getTimeline().setSelectedFrames(0, 0);
 12 | 
 13 | doc.breakApart();
 14 | var break1Sel = doc.selection;
 15 | doc.selectNone();
 16 | var count = break1Sel.length;
 17 | var lib = doc.library;
 18 | 
 19 | var RTSOFolderName = "RTSO_Objects";
 20 | lib.newFolder(RTSOFolderName);
 21 | 
 22 | var tempArray = [];
 23 | 
 24 | for (var i = 0; i < count; i++)
 25 | {
 26 | 	doc.selectNone();
 27 | 	var letterSel = break1Sel[i];
 28 | 	doc.selection = [letterSel];
 29 | 
 30 | 	doc.clipCopy();
 31 | 	doc.selectNone();
 32 | 
 33 | 	var theLetter = letterSel.getTextString();
 34 | 	if (theLetter == "/") theLetter = "(slash)";
 35 | 	var cX = letterSel.x;
 36 | 	var cY = letterSel.y;
 37 | 	var cWidth = letterSel.width;
 38 | 	var cHeight = letterSel.height;
 39 | 	var cColor = letterSel.getTextAttr("fillColor");
 40 | 	var cSize = letterSel.getTextAttr("size");
 41 | 	var cFont = letterSel.getTextAttr("face");
 42 | 	var cBold = letterSel.getTextAttr("bold");
 43 | 	var cItalic = letterSel.getTextAttr("italic");
 44 | 	var theCase = (isLowerCase(theLetter) == true) ? ("l") : ("u");
 45 | 	var instanceName = cFont.split(" ").join("") + "_" + theLetter + "(" + theCase + ")" + ((cBold) ? ("_bold") : ("")) + ((cItalic) ? ("_italic") : (""));
 46 | 	//var instanceName = cFont.split(" ").join("") + "_" + theLetter + "(" + theCase + ")_" + cSize + ((cBold) ? ("_bold") : ("")) + ((cItalic) ? ("_italic") : (""));
 47 | 	
 48 | 	doc.getTimeline().addNewLayer(instanceName, "normal", true);
 49 | 	doc.clipPaste();
 50 | 	var newSel = doc.selection;
 51 | 
 52 | 	doc.selectNone();
 53 | 
 54 | 	newSel[0].x = cX;
 55 | 	newSel[0].y = cY;
 56 | 	doc.selection = newSel;
 57 | 	doc.breakApart();
 58 | 	
 59 | 	doc.getTimeline().setSelectedLayers(doc.getTimeline().currentLayer);
 60 | 	doc.getTimeline().setSelectedFrames(0, 0);
 61 | 	
 62 | 	var myRect = doc.getSelectionRect();
 63 | 	
 64 | 	tempArray.push([myRect.left, myRect.top, doc.selection[0].width, doc.selection[0].height, cColor.split("#").join("")]);
 65 | }
 66 | 
 67 | for (var i = 0; i < count; i++)
 68 | {
 69 | 	var lay = doc.getTimeline().layers[i];
 70 | 	doc.getTimeline().setSelectedLayers(i);
 71 | 	doc.getTimeline().setSelectedFrames(0, 0);
 72 | 	
 73 | 	if (lib.itemExists(RTSOFolderName + "/" + lay.name) == false)
 74 | 	{
 75 | 		doc.convertToSymbol("graphic", lay.name, "top left");
 76 | 		lib.moveToFolder(RTSOFolderName, lay.name, true);
 77 | 	}
 78 | 	else
 79 | 	{
 80 | 		doc.deleteSelection();
 81 | 		lib.addItemToDocument({x:tempArray[i][0] + (tempArray[i][2]/2), y:tempArray[i][1] + (tempArray[i][3]/2)}, RTSOFolderName + "/" + lay.name);
 82 | 		var sel = doc.selection[0];
 83 | 		sel.width = tempArray[i][2];
 84 | 		sel.height = tempArray[i][3];
 85 | 		var r = parseInt(tempArray[i][4].substr(0, 2), 16);
 86 | 		var g = parseInt(tempArray[i][4].substr(2, 2), 16);
 87 | 		var b = parseInt(tempArray[i][4].substr(4, 2), 16);
 88 | 		sel.colorMode = "tint";
 89 | 		sel.colorRedPercent = 0;
 90 | 		sel.colorGreenPercent = 0;
 91 | 		sel.colorBluePercent = 0;
 92 | 		sel.colorRedAmount = r;
 93 | 		sel.colorGreenAmount = g;
 94 | 		sel.colorBlueAmount = b;
 95 | 	}
 96 | }
 97 | 
 98 | doc.getTimeline().deleteLayer(doc.getTimeline().layers.length - 2);
 99 | doc.selectAll();
100 | doc.clipCut();
101 | doc.getTimeline().currentLayer = doc.getTimeline().layers.length - 2;
102 | doc.getTimeline().currentFrame = 0;
103 | doc.clipPaste(true);
104 | doc.getTimeline().layers[doc.getTimeline().layers.length - 2].name = "Working layer";
105 | 
106 | var count = doc.getTimeline().layers.length;
107 | fl.trace(count);
108 | doc.selectNone();
109 | for (var i = 0; i < count - 2; i++)
110 | {
111 | 	doc.getTimeline().deleteLayer(0);
112 | }
113 | 
114 | doc.zoomFactor = 1;
115 | alert("Done");
116 | 
117 | function isLowerCase(aLetter)
118 | {
119 | 	if (aLetter == aLetter.toLowerCase()) return true;
120 | }
121 | 


--------------------------------------------------------------------------------
/ASExpander.jsfl:
--------------------------------------------------------------------------------
1 | /**
 * ASExpander.jsfl
 * version 1.1.3
 * 
 * Copyright (c) 2008 Keith Peters
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 *
 * Changes: 
 * 1.1   Started using actionsPanel.getText, setText. And setSelection for cursor position.
 * 1.1.1 Fixed a typo in enterFrame
 * 1.1.2 Not correctly finding end of file if no cursor specified. So specified cursor at end of each snippet. Added some snippets.
 * 1.1.3 Added help function. Type &help and run command and it traces out a list of commands.
 */

map = new Object();
map["&help"] = "";
map["&meta"] = "[SWF(width=800, height=800, backgroundColor=0xffffff, frameRate=31)]&cursor";
map["&stage"] = "stage.align = StageAlign.TOP_LEFT;\nstage.scaleMode = StageScaleMode.NO_SCALE;&cursor";
map["&resize"] = "stage.addEventListener(Event.RESIZE, stageResizeHandler);\nfunction stageResizeHandler(event:Event)\n{\n\t&cursor\n}";
map["&bitmap"] = "var bmpd:BitmapData = new BitmapData(800, 800, false, 0xffffff);\nvar bmp:Bitmap = addChild(new Bitmap(bmpd)) as Bitmap;&cursor";
map["&enterFrame"] = "addEventListener(Event.ENTER_FRAME, enterFrameHandler);\nfunction enterFrameHandler(event:Event):void\n{\n\t&cursor\n}";
map["&mouseDown"] = "stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);\nfunction mouseDownHandler(event:MouseEvent):void\n{\n\t&cursor\n}";
map["&mouseUp"] = "stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);\nfunction mouseUpHandler(event:MouseEvent):void\n{\n\t&cursor\n}";
map["&mouseMove"] = "stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);\nfunction mouseMoveHandler(event:MouseEvent):void\n{\n\t&cursor\n}";
map["&keyDown"] = "stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);\nfunction keyDownHandler(event:KeyboardEvent):void\n{\n\t&cursor\n}";
map["&keyUp"] = "stage.addEventListener(KeyboardEvent.KEY_UP, keyUpHandler);\nfunction keyUpHandler(event:KeyboardEvent):void\n{\n\t&cursor\n}";
map["&loop"] = "for(var i:int = 0; i < 10; i++)\n{\n\t&cursor\n}";
map["&2loop"] = "for(var i:int = 0; i < 10; i++)\n{\n\tfor(var j:int = 0; j < 10; j++)\n\t{\n\t\t&cursor\n\t}\n}";
map["&embed"] = "[Embed(source=\"sourcefile\")]\nvar theClass:Class;&cursor";
map["&click"] = "btn.addEventListener(MouseEvent.CLICK, onClick);\nfunction onClick(event:MouseEvent):void\n{\n\t&cursor\n}";
map["&sprite"] = "var s:Sprite = addChild(new Sprite()) as Sprite;&cursor";
map["&mc"] = "var mc:MovieClip = addChild(new MovieClip()) as MovieClip;&cursor";
map["&tf2"] = "var tf:TextField = addChild(new TextField()) as TextField;\ntf.autoSize = TextFieldAutoSize.LEFT;\ntf.selectable = false;\ntf.multiline = true;\ntf.wordWrap = true;\ntf.defaultTextFormat = new TextFormat(\"Arial\", 12, 0);\ntf.text = \"hello\";&cursor";
map["&tf"] = "var tf:TextField = addChild(new TextField()) as TextField;&cursor";


script = fl.actionsPanel.getText();

if(script.indexOf("&help") != -1)
{
	fl.trace("ASExpander keys:");
	for(key in map)
	{
		fl.trace(key);
	}
}

for(key in map)
{
	script = script.split(key).join(map[key]);
}

// set text, along with cursor location info
fl.actionsPanel.setText(script);
// search for &curso. does not find &cursor if followed by \n
index = fl.actionsPanel.getText().indexOf("&curso");
// if no cursor info, index = end of file
if(index == -1) index = fl.actionsPanel.getText().length;
// set text again, without cursor info
fl.actionsPanel.setText(script.split("&cursor").join(""));
// set selection to where cursor was, or end of file.
fl.actionsPanel.setSelection(index, 0);


--------------------------------------------------------------------------------
/Package for Delivery.jsfl:
--------------------------------------------------------------------------------
  1 | var doc = fl.getDocumentDOM();
  2 | var lib = doc.library;
  3 | var docPath = doc.path;
  4 | var rootPath = docPath.substr(0, docPath.lastIndexOf("\\") + 1);
  5 | var rootUri = convertFilePathToUri(rootPath);
  6 | var deliveryUri = rootUri + "_ForDelivery";
  7 | var classPaths = [];
  8 | var uriList = [];
  9 | 
 10 | //FLfile.createFolder(deliveryUri);
 11 | //FLfile.copy(convertFilePathToUri(docPath), deliveryUri + "/" + doc.name);
 12 | 
 13 | if (document.docClass.length > 0)
 14 | {
 15 | 	findClassPathsWithin(document.docClass);
 16 | 	addLibLinkageClasses();
 17 | 	addClassFilesForDelivery();
 18 | }
 19 | else
 20 | {
 21 | 	fl.trace("Error: Must contain a Document Class");
 22 | }
 23 | 
 24 | function addClassFilesForDelivery()
 25 | {
 26 | 	var classCount = classPaths.length;
 27 | 	for (var classIndex = 0; classIndex < classCount; classIndex++)
 28 | 	{
 29 | 		var fileObj = classPaths[classIndex];
 30 | 		var classPath = fileObj[0];
 31 | 		var filePath = fileObj[1];
 32 | 		fl.trace(classPath);
 33 | 	}
 34 | }
 35 | 
 36 | function addLibLinkageClasses()
 37 | {
 38 | 	var itemCount = lib.items.length;
 39 | 	for (var i = 0; i < itemCount; i++)
 40 | 	{
 41 | 		var item = lib.items[i];
 42 | 		var baseClass = item.linkageBaseClass;
 43 | 		var linkageClass = item.linkageClassName;
 44 | 		
 45 | 		if (item.linkageExportForAS == true)
 46 | 		{
 47 | 			findClassPathsWithin(baseClass);
 48 | 			findClassPathsWithin(linkageClass);
 49 | 		}
 50 | 	}
 51 | }
 52 | 
 53 | function findClassPathsWithin(classPath)
 54 | {
 55 | 	var fileObj = getFileForClassPath(classPath);
 56 | 
 57 | 	if (!arrayContains(uriList, fileObj[1]) && classPath.substr(0, 5) != "flash")
 58 | 	{
 59 | 		uriList.push(fileObj[1]);
 60 | 		classPaths.push(fileObj);
 61 | 		var importedClasses = getImportedClasses(fileObj[1], fileObj);
 62 | 		var importCount = importedClasses.length;
 63 | 		for (var importIndex = 0; importIndex < importCount; importIndex++)
 64 | 		{
 65 | 			findClassPathsWithin(importedClasses[importIndex]);
 66 | 		}
 67 | 	}
 68 | }
 69 | 
 70 | function getImportedClasses(classUri, classPathArrayItem)
 71 | {
 72 | 	var code = FLfile.read(classUri);
 73 | 	var packageName = "";
 74 | 	var className = classUri.substr(classUri.lastIndexOf("/") + 1).split(".as").join("");
 75 | 	importedClasses = [];
 76 | 	lineArray = code.split("\n");
 77 | 	var lineCount = lineArray.length;
 78 | 
 79 | 	for (var lineIndex = 0; lineIndex < lineCount; lineIndex++)
 80 | 	{
 81 | 		var line = LTrim(lineArray[lineIndex]);
 82 | 		if (line.substr(0, 7) == "import ")
 83 | 		{
 84 | 			line = line.split("import ").join("").split(";")[0];
 85 | 			importedClasses.push(line);
 86 | 		}
 87 | 		if (line.substr(0, 8) == "package ")
 88 | 		{
 89 | 			packageName = LTrim(line.split("package ").join(""));
 90 | 			packageName = packageName.split("{").join("").split(" ").join("").split("\n").join("");
 91 | 		}
 92 | 	}
 93 | 	
 94 | 	classPathArrayItem[0] = packageName + "." + className;
 95 | 	return importedClasses;
 96 | }
 97 | 
 98 | function getFileForClassPath(classPath)
 99 | {
100 | 	var classPathArrayItem = [];
101 | 	classPathArrayItem.push(classPath);
102 | 	var newPath = classPath.split(".").join("\\");
103 | 	relativeClassPath = rootPath + newPath + ".as";
104 | 	relativeClassUri = convertFilePathToUri(relativeClassPath);
105 | 	
106 | 	if (FLfile.exists(relativeClassUri) == true)
107 | 	{
108 | 		classPathArrayItem.push(relativeClassUri);
109 | 	}
110 | 	else
111 | 	{
112 | 		var absoluteClassUri = "";
113 | 		var globalClassPaths = fl.as3PackagePaths.split(";");
114 | 		var gcpCount = globalClassPaths.length;
115 | 		for (var gcpIndex = 0; gcpIndex < gcpCount; gcpIndex++)
116 | 		{
117 | 			var path = globalClassPaths[gcpIndex];
118 | 			if (path != "." && path.indexOf("$(AppConfig)") == -1)
119 | 			{
120 | 				var absoluteClassPath = path + "\\" + newPath + ".as";
121 | 				var absoluteClassUri = convertFilePathToUri(absoluteClassPath);
122 | 				if (FLfile.exists(absoluteClassUri) == true) break;
123 | 			}
124 | 		}
125 | 		
126 | 		classPathArrayItem.push(absoluteClassUri);
127 | 	}
128 | 
129 | 	return classPathArrayItem;
130 | }
131 | 
132 | function convertFilePathToUri(filePath)
133 | {
134 | 	filePath = filePath.split(":\\").join("|/").split("\\").join("/");
135 | 	filePath = "file:///" + filePath;
136 | 	
137 | 	return filePath;
138 | }
139 | 
140 | function arrayContains(theArray, arrayItem)
141 | {
142 | 	var itemCount = theArray.length;
143 | 	for (var i = 0; i < itemCount; i++)
144 | 	{
145 | 		if (theArray[i] == arrayItem) return true;
146 | 	}
147 | 	return false;
148 | }
149 | 
150 | function LTrim(theString)
151 | {
152 | 	theString = theString.split("\t").join("").split("\n").join("");
153 | 	stringLength = theString.length;
154 | 	for (var j = 0; j < stringLength; j++)
155 | 	{
156 | 		if (theString.substr(j, 1) != " ")
157 | 		{
158 | 			theString = theString.substr(j);
159 | 			break;
160 | 		}
161 | 	}
162 | 	return theString;
163 | }


--------------------------------------------------------------------------------
/[tkd] timeline_to_class.jsfl:
--------------------------------------------------------------------------------
  1 | // JSFL
  2 | // 
  3 | // generates class vars to match elements on stage
  4 | // 
  5 | //
  6 | // by David Knape
  7 | // http://bumpslide.com/
  8 | 
  9 | // Author name to display in code
 10 | var author = "David Knape";
 11 | 
 12 | 
 13 | 
 14 | 
 15 | //-----------------------------
 16 | // GLOBALS
 17 | //-----------------------------
 18 | 
 19 | // The current Timeline
 20 | var timeline = fl.getDocumentDOM().getTimeline();
 21 | 
 22 | // output buffer
 23 | var output = ""; 
 24 | 
 25 | // classes to import
 26 | var imports = [];
 27 | 
 28 | // clips we've processed (in case they are on more than one frame)
 29 | var processedElements = [];
 30 | 
 31 | // shortcut to trace
 32 | trace = fl.outputPanel.trace;
 33 | 
 34 | 
 35 | 
 36 | //-----------------------------
 37 | // FUNCTIONS
 38 | //-----------------------------
 39 | 
 40 | 
 41 | // trace to output buffer
 42 | function dtrace( s ) {
 43 | 	output+="\n"+s;
 44 | }
 45 | 
 46 | // add class name to imports list if it isn't already there
 47 | function addToImports( className ) {
 48 |     for (var i=0; i<imports.length; i++) if(imports[i] == className) return;
 49 |     imports.push( className );
 50 | }
 51 | 
 52 | // get classname for current timeline by looking for it in the library
 53 | // (not foolproof, looking for suggestions here)
 54 | function getTimelineClass() {
 55 |     var items = fl.getDocumentDOM().library.items;
 56 |     for (var n=0; n<items.length; n++) { 
 57 |         if(items[n].name.split('/').pop()==timeline.name) return items[n].linkageClassName;
 58 |     }
 59 |     return timeline.name;    
 60 | }
 61 | 
 62 | // Returns a "var" entry for a given timeline element
 63 | // example: "var instance_name : ClassName;"
 64 | function getVarForElement(el) {
 65 | 
 66 |     // check if we have already processed this element
 67 |     for(var i in processedElements) if(processedElements[i] == el.name) return "";
 68 | 	processedElements.push( el.name );
 69 |     
 70 | 	// local vars
 71 | 	var propType=null;
 72 | 	var classname = '';
 73 | 	var output = "";
 74 | 	
 75 |     switch( el.elementType ) 
 76 |     {
 77 |         case "instance": 
 78 | 			// If class attached, import it and use the
 79 | 			// base name, otherwise use the MovieClip class
 80 |             var classname = el.libraryItem.linkageClassName;
 81 |             if(classname!=null) {
 82 |                 addToImports( classname );
 83 |                 propType = ":" + classname.split('.').pop();
 84 |             } else {
 85 |                 propType = ":MovieClip";
 86 |             }
 87 |             break;
 88 | 			
 89 | 		// TextFields are easy
 90 |         case "text": 
 91 | 			propType = ":TextField"; 
 92 | 			break;
 93 | 			
 94 | 		// Shapes don't apply, but grouped elements show up as shapes.
 95 | 		// So, we should put out a warning when groups are found
 96 |         case "shape":
 97 |             if(el.isGroup) {
 98 |                 // found a group of items, not supported
 99 |                 return "\t// Warning: Grouped items found \n\t// (clips must be ungrouped to be identified this JSFL script)";
100 |             }
101 |             break;
102 |     }
103 |     if(propType) {
104 | 		var varname = el.name=="" ? "NO_INSTANCE_NAME" : el.name;
105 | 		return "\n\tpublic var "+varname + propType+";";                
106 | 	}
107 | 	return "";
108 | }
109 | 
110 | 
111 | 
112 | 
113 | // main subroutine
114 | function main() {
115 | 
116 | 	
117 | 	var l,f,e;        // iterators
118 | 	var elements;
119 | 
120 |     fl.outputPanel.clear();
121 | 
122 | 	
123 | 	// print class header
124 |     dtrace( "\n/**");
125 |     dtrace( " * This class is a movie clip");
126 |     dtrace( " * ");
127 |     dtrace( " * This code was generated by a JSFL file.");
128 |     dtrace( " * http://bumpslide.com/");
129 |     dtrace( " * ");
130 |     dtrace( " * @author "+author);
131 |     dtrace( " */");
132 |     dtrace( "\nclass "+getTimelineClass()+" extends MovieClip \n{");
133 |     
134 |     // print vars
135 |     dtrace("\t// timeline clips\n\t//--------------------");
136 | 	
137 |     // process all layers
138 |     for(l=0; l<timeline.layers.length; l++) 
139 |     {     
140 |         // print layer name as comment to pretty up our vars
141 |                        
142 |         var varlines = "";
143 |         // process all frames
144 |         for(f=0; f<timeline.layers[l].frames.length; f++) 
145 |         {        
146 |             elements=timeline.layers[l].frames[f].elements;
147 |             for(e=0; e<elements.length; e++) {
148 | 				varlines+=getVarForElement( elements[e] );
149 |             }
150 |         }
151 | 		
152 | 		// if layer had elements, output the var text with a
153 | 		// comment matching the layer name
154 | 		if(varlines!="") {
155 | 			dtrace( "\n\t// "+ timeline.layers[l].name + varlines );
156 | 		}
157 |     }
158 | 	
159 |     // end class
160 |     dtrace( "}" );
161 |     
162 | 	
163 | 	
164 | 	// OUTPUT...
165 |     
166 |     // print imports using regular trace
167 |     for(var n=0; n<imports.length; n++) trace( "import "+imports[n] + ";");
168 |     
169 | 	// trace buffered output
170 |     trace( output );    
171 | }
172 | 
173 | 
174 | 
175 | 
176 | // run...
177 | main();
178 | 


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/lib/HTMLParser.jsfl:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * HTMLParser
  3 |  *
  4 |  * SAX-style HTML parser. Sequentually traverse through simple (X)HTML calling callbacks when
  5 |  * tags are encountered. Based on original code by Erik Arvidsson and John Resig offered under
  6 |  * the Mozilla Public License.
  7 |  *
  8 |  * http://ejohn.org/files/htmlparser.js
  9 |  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
 10 |  *
 11 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 12 |  */
 13 | 
 14 | (function(){
 15 | 
 16 | 	// Regular Expressions for parsing tags and attributes
 17 | 	var startTag = /^<([-A-Za-z0-9_]+)((?:\s+\w+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
 18 | 		endTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/,
 19 | 		attr = /([-A-Za-z0-9_]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g;
 20 | 		
 21 | 	// Empty Elements - HTML 4.01
 22 | 	var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed");
 23 | 
 24 | 	// Block Elements - HTML 4.01
 25 | 	var block = makeMap("address,applet,blockquote,button,center,dd,del,dir,div,dl,dt,fieldset,form,frameset,hr,iframe,ins,isindex,li,map,menu,noframes,noscript,object,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul");
 26 | 
 27 | 	// Inline Elements - HTML 4.01
 28 | 	var inline = makeMap("a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var,textrun");
 29 | 
 30 | 	// Elements that you can, intentionally, leave open
 31 | 	// (and which close themselves)
 32 | 	var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
 33 | 
 34 | 	// Attributes that have their values filled in disabled="disabled"
 35 | 	var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
 36 | 
 37 | 	// Special Elements (can contain anything)
 38 | 	var special = makeMap("script,style");
 39 | 
 40 | 	var HTMLParser = this.HTMLParser = function( html, handler ) {
 41 | 		var index, chars, match, stack = [], last = html;
 42 | 		stack.last = function(){
 43 | 			return this[ this.length - 1 ];
 44 | 		};
 45 | 
 46 | 		while ( html ) {
 47 | 			chars = true;
 48 | 
 49 | 			// Make sure we're not in a script or style element
 50 | 			if ( !stack.last() || !special[ stack.last() ] ) {
 51 | 
 52 | 				// Comment
 53 | 				if ( html.indexOf("<!--") == 0 ) {
 54 | 					index = html.indexOf("-->");
 55 | 	
 56 | 					if ( index >= 0 ) {
 57 | 						if ( handler.comment )
 58 | 							handler.comment( html.substring( 4, index ) );
 59 | 						html = html.substring( index + 3 );
 60 | 						chars = false;
 61 | 					}
 62 | 	
 63 | 				// end tag
 64 | 				} else if ( html.indexOf("</") == 0 ) {
 65 | 					match = html.match( endTag );
 66 | 	
 67 | 					if ( match ) {
 68 | 						html = html.substring( match[0].length );
 69 | 						match[0].replace( endTag, parseEndTag );
 70 | 						chars = false;
 71 | 					}
 72 | 	
 73 | 				// start tag
 74 | 				} else if ( html.indexOf("<") == 0 ) {
 75 | 					match = html.match( startTag );
 76 | 	
 77 | 					if ( match ) {
 78 | 						html = html.substring( match[0].length );
 79 | 						match[0].replace( startTag, parseStartTag );
 80 | 						chars = false;
 81 | 					}
 82 | 				}
 83 | 
 84 | 				if ( chars ) {
 85 | 					index = html.indexOf("<");
 86 | 					
 87 | 					var text = index < 0 ? html : html.substring( 0, index );
 88 | 					html = index < 0 ? "" : html.substring( index );
 89 | 					
 90 | 					if ( handler.chars )
 91 | 						handler.chars( text );
 92 | 				}
 93 | 
 94 | 			} else {
 95 | 				html = html.replace(new RegExp("(.*)<\/" + stack.last() + "[^>]*>"), function(all, text){
 96 | 					text = text.replace(/<!--(.*?)-->/g, "$1")
 97 | 						.replace(/<!\[CDATA\[(.*?)]]>/g, "$1");
 98 | 
 99 | 					if ( handler.chars )
100 | 						handler.chars( text );
101 | 
102 | 					return "";
103 | 				});
104 | 
105 | 				parseEndTag( "", stack.last() );
106 | 			}
107 | 
108 | 			if ( html == last )
109 | 				throw "Parse Error: " + html;
110 | 			last = html;
111 | 		}
112 | 		
113 | 		// Clean up any remaining tags
114 | 		parseEndTag();
115 | 
116 | 		function parseStartTag( tag, tagName, rest, unary ) {
117 | 			tagName = tagName.toLowerCase();
118 | 
119 | 			if ( block[ tagName ] ) {
120 | 				while ( stack.last() && inline[ stack.last() ] ) {
121 | 					parseEndTag( "", stack.last() );
122 | 				}
123 | 			}
124 | 
125 | 			if ( closeSelf[ tagName ] && stack.last() == tagName ) {
126 | 				parseEndTag( "", tagName );
127 | 			}
128 | 
129 | 			unary = empty[ tagName ] || !!unary;
130 | 
131 | 			if ( !unary )
132 | 				stack.push( tagName );
133 | 			
134 | 			if ( handler.start ) {
135 | 				var attrs = [];
136 | 	
137 | 				rest.replace(attr, function(match, name) {
138 | 					var value = arguments[2] ? arguments[2] :
139 | 						arguments[3] ? arguments[3] :
140 | 						arguments[4] ? arguments[4] :
141 | 						fillAttrs[name] ? name : "";
142 | 					
143 | 					attrs.push({
144 | 						name: name,
145 | 						value: value,
146 | 						escaped: value.replace(/(^|[^\\])"/g, '$1\\\"') //"
147 | 					});
148 | 				});
149 | 	
150 | 				if ( handler.start )
151 | 					handler.start( tagName, attrs, unary );
152 | 			}
153 | 		}
154 | 
155 | 		function parseEndTag( tag, tagName ) {
156 | 			// If no tag name is provided, clean shop
157 | 			if ( !tagName )
158 | 				var pos = 0;
159 | 				
160 | 			// Find the closest opened tag of the same type
161 | 			else
162 | 				for ( var pos = stack.length - 1; pos >= 0; pos-- )
163 | 					if ( stack[ pos ] == tagName )
164 | 						break;
165 | 			
166 | 			if ( pos >= 0 ) {
167 | 				// Close all the open elements, up the stack
168 | 				for ( var i = stack.length - 1; i >= pos; i-- )
169 | 					if ( handler.end )
170 | 						handler.end( stack[ i ] );
171 | 				
172 | 				// Remove the open elements from the stack
173 | 				stack.length = pos;
174 | 			}
175 | 		}
176 | 	};
177 | 
178 | 	function makeMap(str){
179 | 		var obj = {}, items = str.split(",");
180 | 		for ( var i = 0; i < items.length; i++ )
181 | 			obj[ items[i] ] = true;
182 | 		return obj;
183 | 	}
184 | })();


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/lib/Importer.jsfl:
--------------------------------------------------------------------------------
  1 | Importer =
  2 | {
  3 | 	config : {},
  4 | 
  5 | 	/**
  6 | 	 * Initiate import.
  7 | 	 * 
  8 | 	 * @param p_doc A reference to a document to process or else a string specifying its filepath.
  9 | 	 * @param p_config A reference to the config object.
 10 | 	 * @param p_closeAll Boolean specifying whether to close all documents when the script exits.
 11 | 	 * 
 12 | 	 * @return Boolean indicating success or failure.
 13 | 	 */
 14 | 	go : function(p_doc,p_config,p_closeAll)
 15 | 	{
 16 | 		this.config = p_config;
 17 | 
 18 | 		var textFields;
 19 | 		var xml;
 20 | 		var translationData;
 21 | 		var doc;
 22 | 		var library;
 23 | 
 24 | 		var flaSaved = false;
 25 | 		var writeError = false;
 26 | 		var applySuccess = false;
 27 | 
 28 | 		if ( typeof(p_doc) == "string" )
 29 | 		{	
 30 | 			doc = Utils.loadFLA(p_doc);
 31 | 		}
 32 | 		else
 33 | 		{
 34 | 			doc = p_doc;
 35 | 		}
 36 | 
 37 | 		if ( !doc )
 38 | 		{
 39 | 			Logger.log("Error opening document",Logger.CRITICAL);
 40 | 
 41 | 			return false;
 42 | 		}
 43 | 
 44 | 		library = doc.library;
 45 | 
 46 | 		// Temporarily add unused/exported MovieClips to the stage:
 47 | 
 48 | 		var tempLayerIndex = Utils.addUnusedSymbolsToStage(doc);
 49 | 
 50 | 		// Gather translatable TextFields from the FLA:
 51 | 
 52 | 		try
 53 | 		{
 54 | 			textFields = Utils.getAllTranslatableTextFields(doc);
 55 | 		}
 56 | 		catch (p_error)
 57 | 		{
 58 | 			Logger.log("Error gathering translatable TextFields from FLA. "+p_error,Logger.CRITICAL);
 59 | 
 60 | 			return false;
 61 | 		}
 62 | 
 63 | 		Logger.log("Found "+textFields.length+" translatable TextFields in the FLA");
 64 | 
 65 | 		if ( textFields.length == 0 )
 66 | 		{
 67 | 			Logger.log("No translatable TextFields found in the FLA",Logger.CRITICAL);
 68 | 
 69 | 			return false;
 70 | 		}
 71 | 
 72 | 		// Load and parse the XML:
 73 | 
 74 | 		xml = Utils.loadXML(this.config.xmlFilePath);
 75 | 
 76 | 		if ( !xml )
 77 | 		{
 78 | 			Logger.log("Error laoding the XML",Logger.CRITICAL);
 79 | 
 80 | 			return false;
 81 | 		}
 82 | 
 83 | 		try
 84 | 		{
 85 | 			translationData = this.parseXML(xml);
 86 | 		}
 87 | 		catch (p_error)
 88 | 		{
 89 | 			Logger.log("Error parsing the XML. "+p_error);
 90 | 		}
 91 | 
 92 | 		if ( translationData.items.length == 0 )
 93 | 		{
 94 | 			Logger.log("No translation data found in the XML",Logger.CRITICAL);
 95 | 
 96 | 			return false;
 97 | 		}
 98 | 
 99 | 		// Attempt to apply the parsed translation data to the static TextFields found in the FLA:
100 | 
101 | 		try
102 | 		{
103 | 			applySuccess = this.applyTranslations(textFields,translationData);
104 | 		}
105 | 		catch (p_error)
106 | 		{
107 | 			Logger.log("Error applying translation data to FLA. "+p_error,Logger.WARNING);
108 | 
109 | 			return false;
110 | 		}
111 | 
112 | 		if ( !applySuccess )
113 | 		{
114 | 			Logger.log("Error applying translation data to FLA.",Logger.WARNING);
115 | 
116 | 			return false;
117 | 		}
118 | 
119 | 		// Clean up the stage:
120 | 
121 | 		library.editItem(doc);
122 | 		doc.getTimeline().deleteLayer(tempLayerIndex);
123 | 
124 | 		// Create the TextField sprite sheet:
125 | 
126 | 		try
127 | 		{
128 | 			Utils.createTextSheet(doc);
129 | 		}
130 | 		catch (p_error)
131 | 		{
132 | 			Logger.log("Warning, error creating the TextField sprite sheet. "+p_error,Logger.WARNING);
133 | 		}
134 | 
135 | 		// Write the FLA and SWF to disk:
136 | 
137 | 		flaSaved = fl.saveDocument(doc,this.config.outputFLAFilePath);
138 | 
139 | 		if ( flaSaved )
140 | 		{
141 | 			Logger.log("FLA written to disk");
142 | 		}
143 | 		else
144 | 		{
145 | 			Logger.log("Error, can't save FLA",Logger.WARNING);
146 | 
147 | 			writeError = true;
148 | 		}
149 | 
150 | 		var swfSaved = Utils.exportSWF(this.config.outputSWFFilePath,doc);
151 | 
152 | 		if ( swfSaved )
153 | 		{
154 | 			Logger.log("SWF written to disk");
155 | 		}
156 | 		else
157 | 		{
158 | 			Logger.log("Error, can't save SWF",Logger.WARNING);
159 | 
160 | 			writeError = true;
161 | 		}
162 | 
163 | 		// Close all open files:
164 | 
165 | 		if ( p_closeAll ) fl.closeAll(false);
166 | 
167 | 		if ( writeError )
168 | 		{
169 | 			return false;
170 | 		}
171 | 		else
172 | 		{
173 | 			return true;
174 | 		}
175 | 	},
176 | 
177 | 	/**
178 | 	 * Applies the translations found in the XML to the static TextFields found in the FLA.
179 | 	 *
180 | 	 * @param p_textFields Array of valid translatable TextField generic objects.
181 | 	 * @param p_translationData Object containing all the translation data.
182 | 	 *
183 | 	 * @return Boolean value indicating success or failure.
184 | 	 */
185 | 	applyTranslations : function(p_textFields,p_translationData)
186 | 	{
187 | 		var success = true;
188 | 
189 | 		if ( p_textFields.length == 0 || p_translationData.items.length == 0 )
190 | 		{
191 | 			success = false;
192 | 		}
193 | 
194 | 		if ( p_textFields.length != p_translationData.items.length )
195 | 		{
196 | 			Logger.log("Warning, mismatch between number of translatable TextFields in the FLA and in the XML.");
197 | 
198 | 			success = false;
199 | 		}
200 | 
201 | 		for ( var i=0; i<p_translationData.items.length; i++ )
202 | 		{
203 | 			var translationObj = p_translationData.items[i];
204 | 			var tfObj;
205 | 			var foundTF = false;
206 | 
207 | 			for ( var j=0; j<p_textFields.length; j++ )
208 | 			{
209 | 				if ( p_textFields[j].id == translationObj.id )
210 | 				{
211 | 					foundTF = true;
212 | 					tfObj = p_textFields[j];
213 | 
214 | 					break;
215 | 				}
216 | 			}
217 | 
218 | 			if ( foundTF )
219 | 			{
220 | 				this.applyTranslationToTextField(translationObj,tfObj);
221 | 			}
222 | 			else
223 | 			{
224 | 				Logger.log("Warning, no TextField found for XML id \""+translationObj.id+"\"");
225 | 
226 | 				success = false;
227 | 			}
228 | 		}
229 | 
230 | 		Logger.log("Applied "+p_translationData.items.length+" translations onto "+p_textFields.length+" TextFields");
231 | 
232 | 		return success;
233 | 	},
234 | 
235 | 	/**
236 | 	 * Applies translation data to a TextField.
237 | 	 *
238 | 	 * @param p_translationObj Generic object containing XML derived translation data for a single item.
239 | 	 * @param p_tfObj Generic TextField object of the type returned by fl.getObjectsByType.
240 | 	 *
241 | 	 * @return Void.
242 | 	 */
243 | 	applyTranslationToTextField : function(p_translationObj,p_tfObj)
244 | 	{
245 | 		var text = p_translationObj.text;
246 | 
247 | 		if ( this.config.importFormattedText )
248 | 		{
249 | 			Utils.xmlToTF(text,p_tfObj.obj);
250 | 		}
251 | 		else
252 | 		{
253 | 			p_tfObj.obj.setTextString(text);
254 | 		}
255 | 	},
256 | 
257 | 	/**
258 | 	 * Parse the E4X XML object into generic JavaScript objects.
259 | 	 *
260 | 	 * @param XML object to parse.
261 | 	 *
262 | 	 * @return Object.
263 | 	 */
264 | 	parseXML : function(p_xml)
265 | 	{
266 | 		var o = {};
267 | 
268 | 		o.lang = p_xml.@lang;
269 | 
270 | 		Logger.log("XML has country code "+o.lang);
271 | 
272 | 		o.items = [];
273 | 
274 | 		var items = p_xml.items..item;
275 | 
276 | 		Logger.log("Found "+items.length()+" translation items in the XML");
277 | 
278 | 		for ( var i=0; i<items.length(); i++ )
279 | 		{
280 | 			var item = items[i];
281 | 
282 | 			o.items.push
283 | 			(
284 | 				{
285 | 					id : item.@id,
286 | 					font : item.@font,
287 | 					size : item.@size,
288 | 					bold : item.@bold,
289 | 					italic : item.@italic,
290 | 					text : item.toString()
291 | 				}
292 | 			);
293 | 		}
294 | 
295 | 		return o;
296 | 	}
297 | }


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/README.md:
--------------------------------------------------------------------------------
 1 | # FLA Text Processor JSFL
 2 | 
 3 | JSFL scripts for extracting and importing text into FLAs via XML. Designed to be of use during the localisation of static Flash assets and movies, for example advertising banners.
 4 | 
 5 | ## Outline
 6 | 
 7 | The JSFL scripts run within the Flash IDE environment and operate on FLAs. They are capable of parsing and outputting XML and publishing SWFs.
 8 | 
 9 | In the first step an FLA is taken as input, tidied up, prepared and scanned for translatable text which is outputted as XML. The XML can then be translated by a 3rd party and finally imported back into the FLA.
10 | 
11 | This repo contains the commands `ProcessCurrentFLA` and `ImportXMLToCurrentFLA` which can be run within the IDE.
12 | 
13 | ## Installation
14 | 
15 | To install into Flash CS5.5 on OSX run the following commands in Terminal replacing {username} with the correct value for your user account:
16 | 
17 | `cd /Users/{username}/Library/Application\ Support/Adobe/Flash\ CS5.5/en_US/Configuration/Commands`
18 | `git clone git://github.com/jedrichards/HogarthAutomationJSFL.git`
19 | 
20 | The scripts should now be available from Flash's Commands menu. Keep updated by executing `git pull` in the installation directory.
21 | 
22 | ## Considerations
23 | 
24 | ### Environment
25 | 
26 | - Developed using Flash CS5.5 11.5.1.349 and AS2 FLAs.
27 | - The scripts are untested on AS3 content but should work fine.
28 | - Keep the IDE up to date with the latest updates from Adobe to minimise bugs.
29 | - JSFL scripts can be executed from the command line in OSX via `open myscript.jsfl`. This will open Flash if it isn't already and run the script.
30 | - There is no way to pass parameters from the command line into the JSFL script, so an external tool will need to modify the JSFL script directly before it is run if dynamic values need to be passed in.
31 | - On OSX JSFL scripts understand file paths in the format `file:///absolute/path/to/myfile`.
32 | - On OSX Flash will expose in its Commands menu any JSFL scripts it finds in the following location `/Users/{username}/Library/Application\ Support/Adobe/Flash\ CS5.5/en_US/Configuration/Commands`.
33 | 
34 | ### FLA structure
35 | 
36 | - Only static TextFields are supported, not dynamic or input. There is no way to predict the text content of a dynamic or input TextField since it can be modified by ActionScript and additionally font embedding is more complex and prone to bloating the SWF file size.
37 | - Since there is no way to uniquely identify a static TextField in an FLA (they aren't library symbols and don't have instance names) all static TextFields should be wrapped in a matching MovieClip which are named via an id which is carried through into the XML. The script uses an id format tf*n* where *n* is an incrementing integer. These MovieClip wrappers are called *translatable MovieClips* in the terminology of these scripts.
38 | - To be properly formatted a translatable MovieClip should follow the naming convention tf*n* and contain a single layer, a single key frame and a single static TextField. Any static TextFields in the FLA not wrapped in such a MovieClip will be automatically wrapped and fixed by the script. To achieve as robust and tidy FLA as possible the master file should be prepared in advance with properly formatted translatable MovieClips before processing.
39 | - If multiple unwrapped static TextFields appear *with the same text content* at different points on the timeline the script will generate multiple translateable MovieClips and multiple translation items in the XML with the same content, which is undesirable. To avoid this follow good Flash design practice and convert TextFields with the same formatting and content into one MovieClip symbol for re-use throughout the FLA.
40 | - TextFields that appear either on the maintime or nested in a symbol an ancestor of which also appears on the maintime are all picked up by the script. The script will also find and process TextFields that appear in MovieClips that are exported for ActionScript. Any MovieClips (and any TextFields contained therein) which do not appear on the timeline, have a zero use count and are not exported for ActionScript are discarded by the script.
41 | 
42 | ### Text formatting
43 | 
44 | - The script is capable of analysing in-line styles found in the static TextFields and converting these to simple HTML tags which are included in the XML as CDATA. This formatting information can be carried forward through the translation process and then re-applied to the static TextFields when re-importing the translated XML.
45 | - Currently supported are line-breaks, font type, font size, colour, bold and italic. The scripts are not capable of parsing arbitrary HTML, only formatting HTML of the type and sctructure generated by the scripts should be imported.
46 | - Care should be taken to format text within the static TextFields *sensibly* and *simply*.
47 | - Do not mix too many inline styles/formatting inside the same TextField, it'll make the translation XML overly complicated.
48 | - Do not include a lot of whitespace in a TextField- if you need to move text down a few lines don't add multiple line breaks move the whole Textfield instead.
49 | - Do not change the alignment of text inline in the same TextField, instead consider breaking out text that has different alignments into seperate TextFields.
50 | - The scripts are also capable of outputting simple raw text strings with no HTML formatting, in which case line breaks and whitespace are stripped.
51 | - Text will wrap at the width of the static TextField, so care should be taken to ensure TextFields are set to the correct width while considering the fact that translated text content may be much longer.
52 | 
53 | ### FLA tidying
54 | 
55 | - The FLA is "tidied" during processing.
56 | - Symbols with a zero use count that aren't exported for ActionScript are deleted.
57 | - Library items are moved into descriptive folders ("movieclips", "bitmaps", "graphics" etc.).
58 | - Empty library folders are deleted.
59 | - All translatable MovieClips are added to a sprite sheet MovieClip called "TranslatableTextMC" for easy access.
60 | 
61 | ### Logging and locking
62 | 
63 | - The scripts will create a lockfile on the filesystem while they run, and delete it once the script has exited and Flash has finished processing.
64 | - If the script crashes midway through the lockfile will remain and serves as an indicator that something went wrong.
65 | - The script can log progress messages, warnings and critical errors to a log file.
66 | - It's possible that the script encountered critical problems that didn't cause it to crash but should be reported so always check the log.
67 | 
68 | ### Fonts, class files, components and extensions
69 | 
70 | - The system executing the JSFLs will need to have the correct fonts installed to properly publish the SWFs.
71 | - If the FLAs make use of any external class files these will have to be uploaded alongside the FLA to the correct folder position relative to the FLA.
72 | - If the FLAs make use of any extensions (for example ad serving platform extensions) these may also have to be installed onto the IDE.
73 | - If the FLAs need to be exported via a specialist Flash IDE extension (for example Eyeblaster Workshop) this may have to be completed in a manual step.
74 | 
75 | ### Caveats
76 | 
77 | - RTL text is not supported. RTL text is only achievable in AS3 FLAs using Text Layout Framework (TLF) TextFields. TLF TextFields are not currently accessible via the JSFL API. Any conversion to RTL will have to be completed in a manual step after importing.
78 | - TextFields that have been grouped together with other symbols on the stage may be skipped by the script - consider breaking apart any groups containing TextFields in the master file.
79 | - Only static TextFields are considered translatable, dynamic and input TextFields are skipped.


--------------------------------------------------------------------------------
/describeShape.jsfl:
--------------------------------------------------------------------------------
  1 | 	
  2 | function getInstances() {
  3 | 	// Clear 
  4 | 	
  5 | 	var animationData=true;
  6 | 	
  7 | 	fl.outputPanel.clear();
  8 | 	var timeline = fl.getDocumentDOM().getTimeline();
  9 | 	//var tframes=timeline.getSelectedFrames();
 10 | 	// Check every layer
 11 | 	var currentframe=timeline.currentFrame;
 12 | 	var totalLayers=timeline.layerCount;
 13 | 	//fl.getDocumentDOM().getTimeline().layers[0].frames[0].elements[0].name = "clip_
 14 | 	
 15 | 	//tElements=timeline.getFrameProperty("elements",currentframe);
 16 | 	var tString="";
 17 | 	var tElementList="";
 18 | 	var unnamedElements=0;
 19 | 	var currentShape=0;
 20 | 	// String to create the clip
 21 | 	//fl.trace("this.createEmptyMovieClip(\"drawClip\",1);");
 22 | 	//fl.trace("drawClip.lineStyle(1,0xFFFFFF,100);");
 23 | 	fl.trace("import wilberforce.util.drawing.drawingagent.drawingAgentSystem;");
 24 | 	fl.trace("var allEdgesArray:Array=new Array()");
 25 | 	for (var i=0;i<totalLayers;i++) {
 26 | 		//tString+="LAYER "+i+"\n";
 27 | 
 28 | 		var tElements=timeline.layers[i].frames[currentframe].elements;
 29 | 		for (var j=0;j<tElements.length;j++) {			
 30 | 			var tElement=tElements[j];
 31 | 			if (tElement.elementType=="shape") {
 32 | 				// Get position etc
 33 | 				var tMatrix=tElement.matrix;
 34 | 				var tEdges=tElement.edges;
 35 | 				var tVertices=tElement.vertices;
 36 | 				var tContours=tElement.contours;
 37 | 				fl.trace("//Edges : "+tEdges.length+" - Vertices "+tVertices.length+" - Contours "+tContours.length);
 38 | 				// Vertices : x,y
 39 | 				// Edge : 
 40 | 				var drawnEdgeArray=[];
 41 | 				// Process each CONTOUR!
 42 | 				for (var i=0;i<tContours.length;i++) {
 43 | 					var tContour=tContours[i];
 44 | 					// Does it enclose an area?
 45 | 					var tEnclosed=false;
 46 | 					if (tContour.interior) tEnclosed=true;
 47 | 					// Select the contour to get its stroke data
 48 | 					fl.getDocumentDOM().selection = [tElement];
 49 | 					var stroke = fl.getDocumentDOM().getCustomStroke("selection");
 50 | 					//fl.trace("Stroke colour is "+stroke.color);
 51 | //					tHexColor="0x"+stroke.color.substring(2,8);
 52 | 					
 53 | 					fl.trace("// ---- Beginning shape : Fill-"+tEnclosed+" --------")
 54 | 					if (animationData) fl.trace("var edgeData"+currentShape+"=[]");
 55 | //					if (animationData) fl.trace("edgeData"+currentShape+".push({type:drawingAgentSystem.LINESTYLE,color:"+tHexColor+",thickness:"+stroke.thickness+"})");
 56 | 
 57 | 					// Start at the beginning, and use getEdge to continue to process the contour
 58 | 					var tHalfEdge=tContour.getHalfEdge();
 59 | 					var tStartId=tHalfEdge.id;
 60 | 					//var id = 0;
 61 | 					//fl.trace("ID is "+id);
 62 | 					// Make sure its not been visited
 63 | 					var visitedArray=[];
 64 | 					//visitedArray.push(tStartId);
 65 | 					var id=tStartId;
 66 | 					var lastHalfEdge=null;
 67 | 					tComplete=false;
 68 | 					//while (id != tStartId){					
 69 | 					//while (!checkExists(visitedArray,id)) {
 70 | 					// Whatever happens, the first point is a Moveto
 71 | 					var vrt = tHalfEdge.getVertex();
 72 | 					//fl.trace("MOVE : "+vrt.x+","+vrt.y);
 73 | 					
 74 | 					if (animationData) fl.trace("edgeData"+currentShape+".push({type:drawingAgentSystem.MOVE,x:"+vrt.x+",y:"+vrt.y+"});");
 75 | 					else fl.trace("drawClip.moveTo("+vrt.x+","+vrt.y+");");
 76 | 					// DONT add to the array any more to allow them to be closed
 77 | 					//visitedArray.push(vrt);
 78 | 					// Get the first vertex to describe the line its moving to					
 79 | 					lastHalfEdge=tHalfEdge;
 80 | 					tHalfEdge = tHalfEdge.getNext();
 81 | 					
 82 | 					while (!tComplete) {
 83 | 						// get the next vertex
 84 | 						//visitedArray.push(id);						
 85 | 						//fl.trace("ID is "+id);
 86 | 						var vrt = tHalfEdge.getVertex();
 87 | 						var tEdge=tHalfEdge.getEdge()
 88 | 						var tCurrentEdgeId=tEdge.id;
 89 | 						// Check to see if this edge has been drawn
 90 | 						var drawEdge=true;
 91 | 						if (checkExists(drawnEdgeArray,tCurrentEdgeId)) {
 92 | 							//fl.trace("EDGE ALREADY DRAWN "+tCurrentEdgeId);
 93 | 							drawEdge=false;
 94 | 						}
 95 | 						drawnEdgeArray.push(tCurrentEdgeId);
 96 | 						
 97 | 						var x = vrt.x;
 98 | 						var y = vrt.y;
 99 | 						
100 | 						
101 | 						//if (checkExists(visitedArray,vrt)) {
102 | 						if (checkDuplicateVertex(visitedArray,vrt)) {
103 | 							tComplete=true;
104 | 							
105 | 							// Attach the animation system
106 | 							if (animationData) {
107 | 								//fl.trace("var tData"+currentShape+"={edgeData:edgeData"+currentShape+"}");
108 | 								//fl.trace("var contourClip"+currentShape+"=this.attachMovie(\"contourDrawSystem\",\"contour"+currentShape+"\","+(100+currentShape)+",tData"+currentShape+");");
109 | 								fl.trace("allEdgesArray.push(edgeData"+currentShape+");");
110 | 							}
111 | 							fl.trace("// --- End of shape -----");
112 | 							currentShape++;
113 | 						}
114 | 						else {
115 | 							// Get the corresponding edge
116 | 							
117 | 							if (tEdge.isLine) {
118 | 								//fl.trace("LINE: - " + x + ", " + y);
119 | 								if (drawEdge) {
120 | 									if (animationData) fl.trace("edgeData"+currentShape+".push({type:drawingAgentSystem.LINE,x:"+x+",y:"+y+"});");
121 | 									else fl.trace("drawClip.lineTo("+x+","+y+");");
122 | 								}
123 | 							}
124 | 							else {
125 | 								// Get the control point
126 | 								var tControlPoint=tEdge.getControl(1);
127 | 								if (drawEdge) {
128 | 									if (animationData) fl.trace("edgeData"+currentShape+".push({type:drawingAgentSystem.CURVE,cx:"+tControlPoint.x+",cy:"+tControlPoint.y+",ax:"+vrt.x+",ay:"+vrt.y+"});");
129 | 									else fl.trace("drawClip.curveTo("+tControlPoint.x+","+tControlPoint.y+","+x+","+y+");");							
130 | 								}
131 | 							}
132 | 							visitedArray.push(vrt);
133 | 							lastHalfEdge=tHalfEdge;
134 | 							tHalfEdge = tHalfEdge.getNext();
135 | 							//id = tHalfEdge.id;		
136 | 						}										
137 | 					}
138 | 					
139 | 				}
140 | 				
141 | 				
142 | 				
143 | 				// Process each edge?
144 | 				/*
145 | 				for (var i=0;i<tEdges.length;i++) {
146 | 					var tEdge=tEdges[i];
147 | 					var p1=tEdge.getControl(0);
148 | 					var p3=tEdge.getControl(2);
149 | 					if (tEdge.isLine) {
150 | 						// Straight line
151 | 					}
152 | 					else {
153 | 						// Curved line
154 | 						
155 | 						var tControlPoint=tEdge.getControl(1);
156 | 					}
157 | 				}
158 | 				*/
159 | 				// WHats a half edge
160 | 			}
161 | 			/*
162 | 			if (tElement.name.length>0) {
163 | 				tString+="Found  : "+tElements[j].name+"\n";
164 | 				tElementList+=tElements[j].name+"~";
165 | 			}
166 | 			else {
167 | 				unnamedElements++;
168 | 			}
169 | 			*/
170 | 			
171 | 		}
172 | 	}
173 | 	
174 | 	// Put out the name of all the contourDrawSystem
175 | 	var contourString="var contourArray=["
176 | 	for (var i=0;i<currentShape;i++) {
177 | 		if (i>0) contourString+=",";
178 | 		contourString+="contourClip"+i;
179 | 		
180 | 	}
181 | 	contourString+="];";
182 | 	//tString+="Unnamed elements :"+unnamedElements;
183 | 	//fl.trace("// All contour array here");
184 | 	//fl.trace(contourString);
185 | 	//alert(tElementList);
186 | 	//alert(tString);
187 | 	//fl.trace("ELEMENTS :"+tElementList+"\n");
188 | 	return tElementList;
189 | 	//fl.trace("Current frames "+tframes);
190 | }
191 | 
192 | function checkExists(tArray,tValue) {
193 | 	for (var i=0;i<tArray.length;i++) {
194 | 		var tTestValue=tArray[i];
195 | 		if (tTestValue==tValue) {
196 | 			//fl.trace("FOUND! "+tTestValue+" : "+tValue)
197 | 			return true
198 | 		}
199 | 	}
200 | //	fl.trace("not found");
201 | 	return false;
202 | }
203 | function checkDuplicateVertex(tArray,tVertex) {
204 | 	for (var i=0;i<tArray.length;i++) {
205 | 		var tTestVertex=tArray[i];
206 | 		if (tTestVertex.x==tVertex.x && tTestVertex.y==tVertex.y) {
207 | 			return true
208 | 		}
209 | 	}
210 | 	return false;
211 | }
212 | 
213 | getInstances();


--------------------------------------------------------------------------------
/publish with excludes.jsfl:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Publish the current document. Excluding any classes 
  3 |  * found in a {fla_name}_exclude.xml file.
  4 |  */
  5 | function publishWithExcludes(traces,throwOnFail)
  6 | {
  7 | 	var docName = document.name.toString().replace(/\.fla/i,"");
  8 | 	var dom = fl.getDocumentDOM();
  9 | 	var modifiedLibraryItems=[];
 10 | 	var renamedClasses=[];
 11 | 	var tmp,tmp2,i,j,res,os,items,item,publish;
 12 | 	var as3PackagePaths,publishProfileSource,libPublishProfileSource;
 13 | 	var failErrorMessage,traceMessage;
 14 | 	var docPath=getDocumentPath();
 15 | 	var isSaved=(document.path)?true:false;
 16 | 	var cu=unescape(fl.configURI).toLowerCase();
 17 | 	if(cu.indexOf("macintosh hd")>-1)os="mac";
 18 | 	else if(cu.indexOf("c|")>-1)os="win";
 19 | 	items = dom.library.items;
 20 | 	publish = true;//publish flag,set to false to debug (runs the script without any publishing).
 21 | 	if(!publish) fl.trace("OS: "+os);
 22 | 	
 23 | 	//get document path, for win/mac
 24 | 	function getDocumentPath()
 25 | 	{
 26 | 		var path = document.path.replace(/\\/g, '/').split('/').slice(0,-1).join('/');
 27 | 		path = path.replace(/\\/g, '/');
 28 | 		if((path.indexOf(':/') != -1) || (path.charAt(0) == '/')) while(path.charAt(0) == '/') path = path.substr(1);
 29 | 		if(path.indexOf('file:///') != 0) path = 'file:///' + path;
 30 | 		path += '/';
 31 | 		return path;
 32 | 	}
 33 | 
 34 | 	//cleans up all the temp files
 35 | 	function cleanup()
 36 | 	{
 37 | 		if(publishProfileSource) dom.importPublishProfile(publishProfileSource);
 38 | 		FLfile.remove(libPublishProfileSource);
 39 | 		FLfile.remove(publishProfileSource);
 40 | 		FLfile.remove(docPath + docName + '_lib____.swf');
 41 | 		FLfile.remove(docPath + docName + '_lib____.swc');
 42 | 		for(i=0;i<renamedClasses.length;i++) //un-rename renamed classes.
 43 | 		{
 44 | 			if(FLfile.copy(renamedClasses[i]+'.bkup',renamedClasses[i]))
 45 | 			{
 46 | 				if(!FLfile.remove(renamedClasses[i]+'.bkup')) fl.trace('Warning: unable to delete temporary file ' + renamedClasses[i] + '.bkup');
 47 | 			}
 48 | 			else fl.trace('Warning: unable to restore file ' + renamedClasses[i]);
 49 | 		}
 50 | 		for(i=0;i<modifiedLibraryItems.length;i++) modifiedLibraryItems[i].linkageExportInFirstFrame=true; //un-modify modified library items.
 51 | 	}
 52 | 	
 53 | 	if(isSaved) //must be saved.
 54 | 	{
 55 | 		var xcontents,xfile,filepath;
 56 | 		var contents = FLfile.read(getDocumentPath() + docName + '_exclude.xml'); //reads exclude xml
 57 | 		var xpattern = /name="([^"]+)"/g;
 58 | 		if(contents)
 59 | 		{
 60 | 			contents = contents.replace(/\n/g, ' ').replace(/<!--.*?-->/g, ''); //comments
 61 | 			var pattern = /name="([^"]+)"/g;
 62 | 			var excludedClasses = [];
 63 | 			while(tmp = pattern.exec(contents)) excludedClasses.push(tmp[1]);
 64 | 			pattern = /file="([^"]+)"/g;
 65 | 			while(tmp=pattern.exec(contents))
 66 | 			{
 67 | 				xfile = tmp[1];
 68 | 				if(os=="mac")
 69 | 				{
 70 | 					if(xfile.substr(0,1)=="/") filepath = "Macintosh HD/"+xfile.substr(1,xfile.length); //file="/Users/aaronsmith"
 71 | 					else if(xfile.toLowerCase().indexOf("macintosh hd")>-1) filepath = xfile; // file="Macintosh HD/xxxx"
 72 | 					else filepath = getDocumentPath() + xfile; //file="./xxx" ||  file="../../xxx" || file="someexcludes.xml"
 73 | 				}
 74 | 				else if(os=="win")
 75 | 				{
 76 | 					xfile = xfile.replace(/\//,"/");
 77 | 					if(xfile.substr(0,2).match(/^[a-z]\:/i)) filepath = xfile;//file="c:/xxx"
 78 | 					else filepath = getDocumentPath() + xfile;
 79 | 				}
 80 | 				filepath = filepath.replace(/file\:\/\/\//,"");
 81 | 				filepath = filepath.replace(/\/{2,}/g,"/");
 82 | 				filepath = "file:///"+filepath;
 83 | 				xcontents = FLfile.read(filepath);
 84 | 				xcontents = xcontents.replace(/\n/g, ' ').replace(/<!--.*?-->/g, ''); //comments
 85 | 				while(xtmp=xpattern.exec(xcontents)) excludedClasses.push(xtmp[1]);
 86 | 			}
 87 | 			if(excludedClasses.length)
 88 | 			{
 89 | 				publishProfileSource = getDocumentPath() + docName + '_publishProfile.xml'; //the file name to write the current publish profile to.
 90 | 				dom.exportPublishProfile(publishProfileSource);
 91 | 				var publishProfile = FLfile.read(publishProfileSource);
 92 | 				as3PackagePaths = (/<AS3PackagePaths>(.*?)<\/AS3PackagePaths>/.exec(publishProfile)[1] + ';' + fl.as3PackagePaths).replace(/\$\(AppConfig\)/g, fl.configURI).split(';');
 93 | 				//create a new publish profile for creating the library swc.
 94 | 				var libPublishFormatProperties='<PublishFormatProperties enabled="true">\n<defaultNames>0</defaultNames>\n<flash>1</flash>\n<generator>0</generator>\n<projectorWin>0</projectorWin>\n<projectorMac>0</projectorMac>\n<html>0</html>\n<gif>0</gif>\n<jpeg>0</jpeg>\n<png>0</png>\n<qt>0</qt>\n<rnwk>0</rnwk>\n<flashDefaultName>0</flashDefaultName>\n<generatorDefaultName>0</generatorDefaultName>\n<projectorWinDefaultName>0</projectorWinDefaultName>\n<projectorMacDefaultName>0</projectorMacDefaultName>\n<htmlDefaultName>0</htmlDefaultName>\n<gifDefaultName>0</gifDefaultName>\n<jpegDefaultName>0</jpegDefaultName>\n<pngDefaultName>0</pngDefaultName>\n<qtDefaultName>0</qtDefaultName>\n<rnwkDefaultName>0</rnwkDefaultName>\n<flashFileName>%FILE_NAME%.swf</flashFileName>\n<generatorFileName>%FILE_NAME%.swt</generatorFileName>\n<projectorWinFileName>%FILE_NAME%.exe</projectorWinFileName>\n<projectorMacFileName>%FILE_NAME%.app</projectorMacFileName>\n<htmlFileName>%FILE_NAME%.html</htmlFileName>\n<gifFileName>%FILE_NAME%.gif</gifFileName>\n<jpegFileName>%FILE_NAME%.jpg</jpegFileName>\n <pngFileName>%FILE_NAME%.png</pngFileName>\n<qtFileName>%FILE_NAME%.mov</qtFileName>\n<rnwkFileName>%FILE_NAME%.smil</rnwkFileName>\n</PublishFormatProperties>';
 95 | 				libPublishFormatProperties = libPublishFormatProperties.replace(/%FILE_NAME%/g, docName + '_lib____');
 96 | 				var libPublishProfile = publishProfile.replace(/\n/g, '%NEWLINE%').replace(/<PublishFormatProperties.*?\/PublishFormatProperties>/, libPublishFormatProperties).replace(/%NEWLINE%/g, '\n').replace(/<ExportSwc.*?\/ExportSwc>/, '<ExportSwc>1</ExportSwc>');
 97 | 				libPublishProfileSource = getDocumentPath() + docName + '_lib____' + '_publishProfile.xml';
 98 | 				if(!FLfile.write(libPublishProfileSource,libPublishProfile))
 99 | 			  {
100 | 					cleanup();
101 | 					failErrorMessage = "The library publish profile could not be saved";
102 | 					if(throwOnFail) throw failErrorMessage;
103 | 					res = false;
104 | 			  }
105 | 				for(i=excludedClasses.length-1;i>0;i--) if(excludedClasses.indexOf(excludedClasses[i])!=i) excludedClasses.splice(i,1); //eliminate redundancies in excludes.
106 | 		    dom.importPublishProfile(libPublishProfileSource); //set the new library publish profile
107 | 				if(publish) dom.publish(); //publish the library fla to produce the swc file
108 | 				for(i=0;i<excludedClasses.length;i++) //rename/move excluded classes so that they aren't compiled into the swf
109 | 				{
110 | 					var classSource;
111 | 					var searchDir;
112 | 					var className = excludedClasses[i].replace(/\./g,"/") + ".as";
113 | 					for(var j=0;j<as3PackagePaths.length;j++) //find the location(s) of the class.
114 | 					{
115 | 						if(!as3PackagePaths[j]) continue;
116 | 						searchDir = as3PackagePaths[j];
117 | 						searchDir = unescape(searchDir.replace(/file\:\/\/\//,""));
118 | 						searchDir = searchDir.replace(/c|/i,"");
119 | 						searchDir = searchDir.replace(/\/\|\//,"/");
120 | 						searchDir = searchDir.replace(/\\/g, '/');
121 | 						searchDir = searchDir.replace(/\:/g,"/");
122 | 						searchDir = searchDir.replace(/\/{2,}/g,"/");
123 | 						if(searchDir.substr(0,1)==".")searchDir=getDocumentPath()+searchDir;
124 | 						searchDir = searchDir.replace(/file\:\/\/\//,"");
125 | 						if(os == "mac")
126 | 						{
127 | 							if(!publish) fl.trace("IN MAC");
128 | 							if(searchDir.toLowerCase().indexOf("macintosh hd")<0)searchDir="Macintosh HD/"+searchDir;
129 | 						}
130 | 						else if(os == "win")
131 | 						{
132 | 							if(!publish) fl.trace("IN WIN");
133 | 							if(searchDir.toLowerCase().indexOf("c:")<0)searchDir="C:/"+searchDir;
134 | 						}
135 | 						if(searchDir.lastIndexOf("/")<searchDir.length-1) searchDir += "/";
136 | 						searchDir = searchDir.replace(/\/{2,}/g,"/");
137 | 						classSource = "file:///"+searchDir+className;
138 | 						if(!publish) fl.trace("CLASS SOURCE");
139 | 						if(!publish) fl.trace(classSource);
140 | 						if(FLfile.exists(classSource))
141 | 						{
142 | 							if(!publish) fl.trace("FOUND FILE " + classSource);
143 | 							renamedClasses.push(classSource);
144 | 							if(!FLfile.copy(classSource,classSource+'.bkup')||!FLfile.remove(classSource)) //tmp rename class
145 | 							{
146 | 								cleanup();
147 | 								res = false;
148 | 								failErrorMessage = "Unable to rename file "+classSource;
149 | 								if(throwOnFail) throw failErrorMessage;
150 | 							}
151 | 							break;
152 | 						}
153 | 					}
154 | 				}
155 | 				for(i=0;i<items.length;i++) //alter library items that have exclude classes in first frame
156 | 				{
157 | 					item = items[i];
158 | 					if((excludedClasses.indexOf(item.linkageClassName)!=-1)||(excludedClasses.indexOf(item.linkageBaseClass)!=-1))
159 | 					{
160 | 						if(item.linkageExportInFirstFrame)
161 | 						{
162 | 								modifiedLibraryItems.push(item);
163 | 								item.linkageExportInFirstFrame = false;
164 | 						}
165 | 					}
166 | 				}
167 | 				res = true;
168 | 				dom.importPublishProfile(publishProfileSource);
169 | 				if(publish) dom.testMovie();
170 | 				cleanup();
171 | 			}
172 | 			else
173 | 			{
174 | 				res = true;
175 | 				traceMessage = "Nothing was excluded.";
176 | 				if(publish) dom.testMovie(); //no excludes
177 | 			}
178 | 		}
179 | 		else
180 | 		{
181 | 			res = true;
182 | 			traceMessage = "Exclude classes must be declared in " + docName + "_exclude.xml";
183 | 			if(publish) dom.testMovie(); //no _exclude.xml file
184 | 		}
185 | 	}
186 | 	else fl.alert("In order to publish with excludes, the fla must be saved.");
187 | 	if(traces && traceMessage) fl.trace(traceMessage);
188 | 	return res;
189 | }
190 | //a result of true means ok
191 | //a result of false means errors.
192 | result = publishWithExcludes(true,true);


--------------------------------------------------------------------------------
/fla-text-processor-jsfl-master/lib/Processor.jsfl:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Processor.jsfl
  3 |  *
  4 |  * Not for direct use, these methods are called by other scripts.
  5 |  *
  6 |  * Takes an FLA as input and generates an XML file containing the text content ready for
  7 |  * translation. Static TextFields in a properly prepared FLA should each be wrapped in a MovieClip
  8 |  * named "tf1", "tf2" ... "tfn" in the library. The "tfn" library name becomes the text content's ID
  9 |  * in the XML file.
 10 |  * 
 11 |  * If any static TextFields are found in the FLA placed directly on the root timeline or on a
 12 |  * keyframe in a arbitrary MovieClip then this script will dynamically wrap such TextFields in an
 13 |  * appropriately named MovieClip before generating the XML. Dynamic and input TextFields are not
 14 |  * supported.
 15 |  *
 16 |  * If the outputFormattedText value is set to true the script will attempt to parse the style
 17 |  * information into XML tags for inclusion in the XML in CDATA sections, or if set to false the text
 18 |  * content is outputted as raw strings.
 19 |  *
 20 |  * The processed FLA and XML are then saved to the file paths specified.
 21 |  *
 22 |  * @author JedR, Seisaku Ltd <jed@seisaku.co.uk>
 23 |  */
 24 | 
 25 | Processor =
 26 | {
 27 | 	config : {},
 28 | 
 29 | 	/**
 30 | 	 * Initiate FLA processing.
 31 | 	 * 
 32 | 	 * @param p_doc A reference to a document to process or else a string specifying its filepath.
 33 | 	 * @param p_config A reference to the config object.
 34 | 	 * @param p_closeAll Boolean specifying whether to close all documents when the script exits.
 35 | 	 * 
 36 | 	 * @return Boolean indicating success or failure.
 37 | 	 */
 38 | 	go : function(p_doc,p_config,p_closeAll)
 39 | 	{
 40 | 		this.config = p_config;
 41 | 
 42 | 		var xml;
 43 | 		var data;
 44 | 		var doc;
 45 | 
 46 | 		if ( typeof(p_doc) == "string" )
 47 | 		{
 48 | 			doc = Utils.loadFLA(p_doc);
 49 | 		}
 50 | 		else
 51 | 		{
 52 | 			doc = p_doc;
 53 | 		}
 54 | 
 55 | 		if ( !doc )
 56 | 		{
 57 | 			Logger.log("Error opening document",Logger.CRITICAL);
 58 | 
 59 | 			return false;
 60 | 		}
 61 | 
 62 | 		try
 63 | 		{
 64 | 			data = this.doProcessAndExport(doc);
 65 | 		}
 66 | 		catch (p_error)
 67 | 		{
 68 | 			Logger.log("Error processing FLA. "+p_error,Logger.CRITICAL);
 69 | 
 70 | 			return false;
 71 | 		}
 72 | 
 73 | 		Logger.log("Generated "+data.length+" items for translation, converting to XML ...");
 74 | 
 75 | 		try
 76 | 		{
 77 | 			Utils.tidyLibrary(doc);
 78 | 		}
 79 | 		catch (p_error)
 80 | 		{
 81 | 			Logger.log("Warning, error trying to tidy the library. "+p_error,Logger.WARNING);
 82 | 		}
 83 | 
 84 | 		try
 85 | 		{
 86 | 			Utils.createTextSheet(doc);	
 87 | 		}
 88 | 		catch (p_error)
 89 | 		{
 90 | 			Logger.log("Warning, error trying to create the text sheet MovieClip. "+p_error,Logger.WARNING);
 91 | 		}
 92 | 
 93 | 		try
 94 | 		{
 95 | 			xml = this.createXML(data);
 96 | 		}
 97 | 		catch (p_error)
 98 | 		{
 99 | 			Logger.log("Error generating XML. "+p_error,Logger.CRITICAL);
100 | 
101 | 			return false;
102 | 		}
103 | 
104 | 		var writeError = false;
105 | 
106 | 		var xmlSaved = Utils.saveXML(this.config.outputXMLFilePath,xml.toXMLString(),true,true);
107 | 
108 | 		if ( xmlSaved )
109 | 		{
110 | 			Logger.log("XML written to disk");
111 | 		}
112 | 		else
113 | 		{
114 | 			Logger.log("Error, can't save XML",Logger.WARNING);
115 | 
116 | 			writeError = true;
117 | 		}
118 | 
119 | 		var flaSaved = fl.saveDocument(doc,this.config.outputFLAFilePath);
120 | 
121 | 		if ( flaSaved )
122 | 		{
123 | 			Logger.log("FLA written to disk");
124 | 		}
125 | 		else
126 | 		{
127 | 			Logger.log("Error, can't save FLA",Logger.WARNING);
128 | 
129 | 			writeError = true;
130 | 		}
131 | 
132 | 		var swfSaved = Utils.exportSWF(this.config.outputSWFFilePath,doc);
133 | 
134 | 		if ( swfSaved )
135 | 		{
136 | 			Logger.log("SWF written to disk");
137 | 		}
138 | 		else
139 | 		{
140 | 			Logger.log("Error, can't save SWF",Logger.WARNING);
141 | 
142 | 			writeError = true;
143 | 		}
144 | 
145 | 		if ( p_closeAll )
146 | 		{
147 | 			fl.closeAll(false);
148 | 		}
149 | 
150 | 		if ( writeError )
151 | 		{
152 | 			return false;
153 | 		}
154 | 		else
155 | 		{
156 | 			return true;
157 | 		}
158 | 	},
159 | 
160 | 	/**
161 | 	 * Process an FLA for translation. This involves parsing the contents of FLA for translatable
162 | 	 * static TextFields, wrapping them in a MovieClip if required and returning the data collection
163 | 	 * as an Array suitable for converting to XML.
164 | 	 *
165 | 	 * @return Array.
166 | 	 */
167 | 	doProcessAndExport : function (p_doc)
168 | 	{
169 | 		var data = [];
170 | 		var library = p_doc.library;
171 | 		var i;
172 | 		var tfObj;
173 | 
174 | 		// Add to the root timeline any unused symbols that are exported for ActionScript to make sure
175 | 		// we include them in our processing. We'll delete this temporary layer later:
176 | 
177 | 		var tempLayerIndex = Utils.addUnusedSymbolsToStage(p_doc);
178 | 
179 | 		// Find all static TextFields. Analyse them to see if they're in the correct translatable format
180 | 		// and if required fix them (wrap them in a MovieClip):
181 | 
182 | 		var staticTextFields = Utils.getAllStaticTextFields(p_doc);
183 | 		var validCount = 0;
184 | 		var invalidCount = 0;
185 | 
186 | 		Logger.log("Found "+staticTextFields.length+" static TextFields in the FLA");
187 | 
188 | 		for ( i=0; i<staticTextFields.length; i++ )
189 | 		{
190 | 			tfObj = staticTextFields[i];
191 | 
192 | 			if ( tfObj.parent === undefined )
193 | 			{
194 | 				invalidCount++;
195 | 
196 | 				this.fixInvalidTextFieldObject(tfObj,p_doc,this.getNextTFID(library));
197 | 			}
198 | 			else
199 | 			{
200 | 				if ( !Utils.isTranslatableMovieClip(tfObj.parent.obj.libraryItem,library) )
201 | 				{
202 | 					invalidCount++;
203 | 
204 | 					this.fixInvalidTextFieldObject(tfObj,p_doc,this.getNextTFID(library));
205 | 				}
206 | 				else
207 | 				{
208 | 					validCount++;
209 | 				}
210 | 			}
211 | 		}
212 | 
213 | 		Logger.log(validCount+" static TextFields were properly formatted");
214 | 		Logger.log(invalidCount+" static TextFields were improperly formatted and fixed");
215 | 
216 | 		// Gather all translatable TextFields and generate the translation data:
217 | 
218 | 		var translatableTextFields = Utils.getAllTranslatableTextFields(p_doc);
219 | 
220 | 		Logger.log("Gathered "+translatableTextFields.length+" translatable TextFields");
221 | 
222 | 		for ( i=0; i<translatableTextFields.length; i++ )
223 | 		{
224 | 			tfObj = translatableTextFields[i];
225 | 
226 | 			var tfElement = tfObj.obj;
227 | 			var translationObj = {id:tfObj.id};
228 | 
229 | 			if ( this.config.outputFormattedText )
230 | 			{
231 | 				translationObj.text = "<![CDATA["+Utils.tfToXML(tfElement)+"]]>";
232 | 			}
233 | 			else
234 | 			{
235 | 				// If we're not outputting HTML we want a clean unformatted string. Strip out any
236 | 				// carriage returns, newlines and replace any sequence of whitespaces with a single
237 | 				// space character:
238 | 
239 | 				translationObj.text = tfElement.getTextString();
240 | 				translationObj.text = translationObj.text.replace(/\n/g," ");
241 | 				translationObj.text = translationObj.text.replace(/\r/g," ");
242 | 				translationObj.text = translationObj.text.replace(/\s{2,}/g," ");
243 | 			}
244 | 
245 | 			data.push(translationObj);
246 | 		}
247 | 
248 | 		// Sort the array:
249 | 
250 | 		function sortOnID(p_a,p_b)
251 | 		{
252 | 			var aNum = parseInt(p_a.id.split("tf")[1]);
253 | 			var bNum = parseInt(p_b.id.split("tf")[1]);
254 | 
255 | 			if ( aNum > bNum )
256 | 			{
257 | 				return 1;
258 | 			}
259 | 			else if ( aNum < bNum )
260 | 			{
261 | 				return -1;
262 | 			}
263 | 			else
264 | 			{
265 | 				return 0;
266 | 			}
267 | 		}
268 | 
269 | 		data.sort(sortOnID);
270 | 
271 | 		// Clean up the stage and return the data:
272 | 
273 | 		library.editItem(p_doc);
274 | 		p_doc.getTimeline().deleteLayer(tempLayerIndex);
275 | 
276 | 		return data;
277 | 	},
278 | 
279 | 	/**
280 | 	 * Compute the next available TextField ID.
281 | 	 *
282 | 	 * @param p_library Library object to analyse.
283 | 	 *
284 | 	 * @return String.
285 | 	 */
286 | 	getNextTFID : function (p_library)
287 | 	{
288 | 		var num = 1;
289 | 
290 | 		while ( Utils.isItemInLib("tf"+num,p_library) )
291 | 		{
292 | 			num++;
293 | 		}
294 | 
295 | 		return "tf"+num;
296 | 	},
297 | 
298 | 	/**
299 | 	 * Where a static TextField is found on a timeline and not wrapped in a translatable MovieClip
300 | 	 * this method will attempt to dyncamically create a MovieClip and reparent the TextField into it.
301 | 	 *
302 | 	 * @param p_tfObj Generic TextField object as generated by fl.findObjectsByType.
303 | 	 * @param p_doc Reference to the current FLA document being worked on.
304 | 	 * @param p_id The desired ID of the new translatable MovieClip in the format "tfn".
305 | 	 *
306 | 	 * @return Void.
307 | 	 */
308 | 	fixInvalidTextFieldObject : function (p_tfObj,p_doc,p_id)
309 | 	{
310 | 		var library = p_doc.library;
311 | 		var element  = p_tfObj.obj;
312 | 		var parent = p_tfObj.parent;
313 | 
314 | 		if ( parent === undefined )
315 | 		{
316 | 			library.editItem(p_doc);
317 | 		}
318 | 		else
319 | 		{
320 | 			library.editItem(parent.obj.libraryItem.name);
321 | 		}
322 | 		
323 | 		p_doc.selectNone();
324 | 		p_doc.getTimeline().currentFrame = p_tfObj.keyframe.startFrame;
325 | 		element.selected = true;
326 | 
327 | 		var newMC = p_doc.convertToSymbol("movie clip",p_id,"top left");
328 | 
329 | 		p_tfObj.parent = newMC;
330 | 	},
331 | 
332 | 	/**
333 | 	 * Generate an E4X XML object from a data array in the format returned from the
334 | 	 * doProcessAndExport method.
335 | 	 *
336 | 	 * @param Data array from doProcessAndExport.
337 | 	 *
338 | 	 * @return XML object.
339 | 	 */
340 | 	createXML : function (p_data)
341 | 	{
342 | 		var xml = <root></root>;
343 | 
344 | 		for ( var j in xml )
345 | 		{
346 | 			Logger.log(j);
347 | 		}
348 | 
349 | 		xml.@lang = this.config.lang;
350 | 		xml.appendChild(<items></items>);
351 | 
352 | 		var items = xml.items;
353 | 
354 | 		for ( var i=0; i<p_data.length; i++ )
355 | 		{
356 | 			var item = <item></item>;
357 | 
358 | 			item.appendChild(p_data[i].text);
359 | 			item.@id = p_data[i].id;
360 | 
361 | 			items.appendChild(item);
362 | 		}
363 | 
364 | 		return xml;
365 | 	}
366 | };


--------------------------------------------------------------------------------