doc = flash.getDocumentDOM();
timelines = doc.timelines;

//fl.outputPanel.clear();

/////////////////////////////////////////////////////////////////////////
// transform_in_timeline = function(timeline, lib_item, trans)
//
// Transform all instances of lib_item in a timeline
/////////////////////////////////////////////////////////////////////////

transform_in_timeline = function(lib_item, new_transform)
{
var frame_index;
var layer;
var n = 0, m = 0;
timeline = doc.getTimeline();

//fl.trace("Visiting " + timeline.name);

for(n = 0; n < timeline.layers.length; n++)
{
//fl.trace("\tlayer " + n);
layer = timeline.layers[n];
frame_index = 0;
while(layer.frames[frame_index] != undefined)
{
elements = layer.frames[frame_index].elements;
//fl.trace("\t\tframe " + frame_index);
for(m = 0; m < elements.length; m++)
{
if(elements[m].elementType == "instance")
if(elements[m].libraryItem == lib_item)
{
//fl.trace("found " + lib_item.name + " on " + layer.name + ", frame " + (frame_index + 1) );
//fl.trace("old: " + elements[m].skewX + ", " + elements[m].skewY);
old_matrix = elements[m].matrix;
old_tx = old_matrix.tx;
old_ty = old_matrix.ty;
old_matrix.tx = old_matrix.ty = 0;
new_matrix = fl.Math.concatMatrix(fl.Math.invertMatrix(new_transform), old_matrix);
new_matrix.tx = old_tx;
new_matrix.ty = old_ty;
elements[m].matrix = new_matrix;
//fl.trace("new: " + elements[m].skewX + ", " + elements[m].skewY);
}
}
//fl.trace("duration: " + layer.frames[frame_index].duration);
frame_index += layer.frames[frame_index].duration;
}
}

}

/////////////////////////////////////////////////////////////////////////
// transform_global = function(lib_item, new_transform)
//
// Transform all instances of lib_item in the whole document
/////////////////////////////////////////////////////////////////////////

transform_global = function(lib_item, new_transform)
{
var n = 0;

// First do it in all the timelines in the document

for(n = 0; n < timelines.length; n++)
{
doc.editScene(n)
transform_in_timeline(lib_item, new_transform);
}

// Now do it in the timelines of all the library symbols

//fl.trace("Now sybols");

var items = doc.library.items;
for(n = 0; n < items.length; n++)
{
if(items[n] != lib_item)
{
// If it has a timeline, transform all instances of lib_item in that timeline

if(items[n].itemType == "movie clip" || items[n].itemType == "graphic" || items[n].itemType == "button")
{
doc.library.editItem(items[n].name);
transform_in_timeline(lib_item, new_transform);
}
}
}
}

/////////////////////////////////////////////////////////////////////////
// transformTimeline(trans_matrix)
//
// Transforms all elements on the current timeline
/////////////////////////////////////////////////////////////////////////

transformTimeline = function(trans_matrix)
{
var layer_locked = new Array();
var layer_visible = new Array();
var layernum, framenum;
var layers;
var frame_index;
var next_keyframe, this_next_key;

layers = doc.getTimeline().layers;

// Unlock and unhide all layers
for(layernum = 0; layernum < layers.length; layernum++)
{
layer_locked[layernum] = layers[layernum].locked;
layer_visible[layernum] = layers[layernum].visible;
layers[layernum].visible = true;
layers[layernum].locked = false;
}

frame_index = 0;
while(frame_index < doc.getTimeline().frameCount)
{
doc.getTimeline().currentFrame = frame_index;

for(layernum = 0; layernum < layers.length; layernum++)
{
// Check all the layers. If this is a keyframe, unlock the layer.
// If not, lock it.
if(layers[layernum].frames[frame_index].startFrame == frame_index)
layers[layernum].locked = false;
else layers[layernum].locked = true;

//fl.trace("layers[" + layernum + "].locked is " + layers[layernum].locked);
}

doc.selectAll();

// If anything is selected (i.e. these keyframes aren't empty), do the transformation
if(doc.selection.length)
{
//First group everything so we can set a pivot point without affecting a symbol instance's pivot point
doc.group();

// Transform everything from (0,0)
doc.setTransformationPoint({x:0, y:0});
doc.transformSelection(trans_matrix.a, trans_matrix.b, trans_matrix.c, trans_matrix.d);
doc.unGroup();

}

// Set next_keyframe to a big number
next_keyframe = 0x7fff;

for(layernum = 0; layernum < layers.length; layernum++)
{
// If this layer's next keyframe is closer than next_keyframe, replace
// next_keyframe with the frame number of this layers's next key.

if(layers[layernum].frames[frame_index] != undefined)
{
this_next_key = layers[layernum].frames[frame_index].startFrame + layers[layernum].frames[frame_index].duration;
if(this_next_key < next_keyframe)
next_keyframe = this_next_key;
}
}
frame_index = next_keyframe;
}

// return all the layers to their lock & hide states
for(layernum = 0; layernum 1)
{
edit_stack_entry = edit_stack.pop();
doc.getTimeline().currentFrame = edit_stack_entry.frame;
doc.selection = [edit_stack_entry.object];
//fl.trace("re-editing " + doc.selection[0].libraryItem.name + " on frame " + edit_stack_entry.frame);
doc.enterEditMode("inPlace");
}

edit_stack_entry = edit_stack.pop();
doc.getTimeline().currentFrame = edit_stack_entry.frame;
//fl.trace("final frame: " + edit_stack_entry.frame);
doc.selection = [];

}

/////////////////////////////////////////////////////////////////////////
// MAIN
/////////////////////////////////////////////////////////////////////////

//fl.trace("Current timeline is " + doc.getTimeline().name);

zero_transform = function(x_scale, y_scale)
{
// If parameter weren't passed, load in the default values
if(x_scale == undefined)
x_scale = y_scale = 1.0;
else if(y_scale == undefined)
y_scale = x_scale;

var original_selection = doc.selection;
var original_timeline = doc.currentTimeline;

for(var i = 0; i < original_selection.length; i++)
{
obj = original_selection[i];
doc.selectNone();
doc.selection = [obj];

// First make sure the selection is a symbol instance
if(obj.elementType == "instance" && obj.instanceType == "symbol")
{
original_transform_matrix = obj.matrix;

// First transform the contents of the symbol's timeline

//fl.trace("Transforming the contents of " + obj.libraryItem.name);
doc.enterEditMode("inPlace");
new_transform = {a:1/x_scale, b:0, c:0, d:1/y_scale, tx:0, ty:0};
new_transform = fl.Math.concatMatrix(original_transform_matrix, new_transform);
transformTimeline(new_transform);
doc.exitEditMode();
var edit_stack = save_edit_place();

// Now correct the transform on all the instances of the symbol in the whole FLA

//fl.trace("Corrrecting the transformation of all instnaces of " + obj.libraryItem.name);
new_transform.tx = new_transform.ty = 0;
transform_global(obj.libraryItem, new_transform);

if(fl.getDocumentDOM() != null)
{

// This script relies on "Zero Transform.include", my library for the
// "Zero Transform" commands
fl.runScript( fl.configURI + "Commands/Zero Transform.include" );