I like to have this same ability when I'm writing ActionScript to resize objects proportionately too.
Here I use the functions to set the sizes so when I set width, height is changed accordingly.
The same for setting height, the width is changed accordingly.

*Note: I set the inputs to limit the width and height to 500.

Here are two functions for performing proportional resizing by both width and height...

 
/*---------------------------------------------
Resize proportionately by width.
Returns an Object with new proportionate "width" and "height" properties.
After passing the current width, current height and  a new width.
-----------------------------------------------*/
function constrainSizeToWidth(oldW:Number,oldH:Number,newW:Number):Object
{
	return {width:newW,height:newW / oldW * oldH};
}
 
/*---------------------------------------------
Resize proportionately by height.
Returns an Object with new proportionate "width" and "height" properties.
After passing the current width, current height and  a new height.
-----------------------------------------------*/
function constrainSizeToHeight(oldW:Number,oldH:Number,newH:Number):Object
{
	return {width:newH / oldH * oldW,height:newH};
}
 

This uses the "lineIntersectLine" function of the earlier post.

 
/*---------------------------------------------------------------------------
Returns an Object with the following properties:
intersects        -Boolean indicating if an intersection exists.
start_inside      -Boolean indicating if Point A is inside of the polygon.
end_inside       -Boolean indicating if Point B is inside of the polygon.
intersections    -Array of intersection Points along the polygon.
centroid          -A Point indicating "center of mass" of the polygon.
 
"pa" is an Array of Points.
----------------------------------------------------------------------------*/
function lineIntersectPoly(A : Point, B : Point, pa:Array):Object {
	var An:int=1;
	var Bn:int=1;
	var C:Point;
	var D:Point;
	var i:Point;
	var cx:Number=0;
	var cy:Number=0;
	var result:Object = new Object();
	pa.push(pa[0]);
	result.intersects = false;
	result.intersections=[];
	result.start_inside=false;
	result.end_inside=false;
	var n:int=pa.length-1;
	while(n > -1){
		C=Point(pa[n]);
		if(n > 0){
			cx+=C.x;
			cy+=C.y;
			D=Point(pa[n-1])||Point(pa[0]);
			i=lineIntersectLine(A,B,C,D);
			if(i != null){
				result.intersections.push(i);
			}
			if(lineIntersectLine(A,new Point(C.x+D.x,A.y),C,D) != null){
				An++;
			}
			if(lineIntersectLine(B,new Point(C.x+D.x,B.y),C,D) != null){
				Bn++;
			}
		}
		n--;
	}
	if(An % 2 == 0){
		result.start_inside=true;
	}
	if(Bn % 2 == 0){
		result.end_inside=true;
	}
	result.centroid=new Point(cx/(pa.length-1),cy/(pa.length-1));
	result.intersects = result.intersections.length > 0;
	return result;
}
 

 
/*---------------------------------------------------------------------------
Returns an Object with the following properties:
	enter			-Intersection Point entering the circle.
	exit			-Intersection Point exiting the circle.
	inside			-Boolean indicating if the points of the line are inside the circle.
	tangent		-Boolean indicating if line intersect at one point of the circle.
	intersects		-Boolean indicating if there is an intersection of the points and the circle.
 
If both "enter" and "exit" are null, or "intersects" == false, it indicates there is no intersection.
 
This is a customization of the intersectCircleLine Javascript function found here:
http://www.kevlindev.com/gui/index.htm
----------------------------------------------------------------------------*/
function lineIntersectCircle(A : Point, B : Point, C : Point, r : Number = 1):Object {
	var result : Object = new Object ();
	result.inside = false;
	result.tangent = false;
	result.intersects = false;
	result.enter=null;
	result.exit=null;
	var a : Number = (B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y);
	var b : Number = 2 * ((B.x - A.x) * (A.x - C.x) +(B.y - A.y) * (A.y - C.y));
	var cc : Number = C.x * C.x + C.y * C.y + A.x * A.x + A.y * A.y - 2 * (C.x * A.x + C.y * A.y) - r * r;
	var deter : Number = b * b - 4 * a * cc;
	if (deter <= 0 ) {
		result.inside = false;
	} else {
		var e : Number = Math.sqrt (deter);
		var u1 : Number = ( - b + e ) / (2 * a );
		var u2 : Number = ( - b - e ) / (2 * a );
		if ((u1 < 0 || u1 > 1) && (u2 < 0 || u2 > 1)) {
			if ((u1 < 0 && u2 < 0) || (u1 > 1 && u2 > 1)) {
				result.inside = false;
			} else {
				result.inside = true;
			}
		} else {
			if (0 <= u2 && u2 <= 1) {
				result.enter=Point.interpolate (A, B, 1 - u2);
			}
			if (0 <= u1 && u1 <= 1) {
				result.exit=Point.interpolate (A, B, 1 - u1);
			}
			result.intersects = true;
			if (result.exit != null && result.enter != null && result.exit.equals (result.enter)) {
				result.tangent = true;
			}
		}
	}
	return result;
}
 

//---------------------------------------------------------------
//Checks for intersection of Segment if as_seg is true.
//Checks for intersection of Line if as_seg is false.
//Return intersection of Segment "AB" and Segment "EF" as a Point
//Return null if there is no intersection
//---------------------------------------------------------------
function lineIntersectLine(A:Point,B:Point,E:Point,F:Point,as_seg:Boolean=true):Point
{
	var ip:Point;
	var a1:Number;
	var a2:Number;
	var b1:Number;
	var b2:Number;
	var c1:Number;
	var c2:Number;
 
	a1= B.y-A.y;
	b1= A.x-B.x;
	c1= B.x*A.y - A.x*B.y;
	a2= F.y-E.y;
	b2= E.x-F.x;
	c2= F.x*E.y - E.x*F.y;
 
	var denom:Number=a1*b2 - a2*b1;
	if(denom == 0){
		return null;
	}
	ip=new Point();
	ip.x=(b1*c2 - b2*c1)/denom;
	ip.y=(a2*c1 - a1*c2)/denom;
 
	//---------------------------------------------------
	//Do checks to see if intersection to endpoints
	//distance is longer than actual Segments.
	//Return null if it is with any.
	//---------------------------------------------------
	if(as_seg){
		if(Point.distance(ip,B) > Point.distance(A,B)){
			return null;
		}
		if(Point.distance(ip,A) > Point.distance(A,B)){
			return null;
		}	
 
		if(Point.distance(ip,F) > Point.distance(E,F)){
			return null;
		}
		if(Point.distance(ip,E) > Point.distance(E,F)){
			return null;
		}
	}
	return ip;
}

Today I accidentally left this same model in my pants and washed it on that same cycle...plus dried it it for 40 minutes on HOT in a  dryer machine...and it still works like new.

That's so awesome!

Knobs and dials just look cool...I don't know anything about audio editing but I like the site of a sound studio. This is the "Reason" I decided to make a knob component.

Here is a modification of the "findObjects" I posted earlier. This is handy if you are the type of person that names your symbol items with names you intend to use as their instance name as well.

Maybe you will find this useful or know improvements, either way let me know your thoughts.

 
/*========================================================================
selfNameAllInstances(true)
 
Renames all symbol instance names on the stage of in FLA document with
the symbol's library Name.
 
Instances that already have a name will be skipped...
If the argument "force_rename" is true, the element will be renamed
regardless if it already had a instance name or not.
 
The renaming process is recursive to each
for each MovieClip's timeline as well.
 
(Unfortunately symbols that are grouped are ignored.)
=========================================================================*/
 
function selfNameAllInstances (force_rename)
{
	fl.outputPanel.clear();
	var instanceName;
	var inInstance;
	var instances = [];
	var cnt=0;
	var findObjectInTimeline = function (instance, name)
	{
		var timeline;
		if (instance.toString () == "[object SymbolInstance]" || instance.toString () == "[object Frame]")
		{
			timeline = instance.timeline;
		}
		if (instance.toString () == "[object Document]")
		{
			timeline = instance;
		}
		if (instance.toString () == "[object Timeline]")
		{
			timeline = instance;
		}
		if (instance == fl.getDocumentDOM ())
		{
			timeline = instance.getTimeline ();
		}
		if (timeline == undefined)
		{
			return null;
		}
		var checked = new Object ();
		var currentLayers = timeline.layers;
		var layObj;
		var frm;
		var found;
		var i = 0;
 
		while (i < currentLayers.length)
		{
			var layObj = currentLayers [i];
			var frms = layObj.frames;
			var k = 0;
			while (k < frms.length)
			{
				var selArry = frms [k].elements;
				var n = 0;
				while (n < selArry.length)
				{
					var obj = selArry [n];
//=================================================================================
//IF THE OBJECT HAS A "name" PROPERTY, ASSIGN IT TO "found" VARIABLE.
//"found" VARIABLE will be returned from this recusive function.
//---------------------------------------------------------------------------------
					if (obj.name != "undefined")
					{
						found = obj;
						instances.push (obj);
					}
					if (obj.libraryItem != undefined)
					{
						if (obj.libraryItem.name != undefined)
						{
							if (checked [obj.libraryItem.name])
							{
								n ++;
								continue;
							}else
							{
								checked [obj.libraryItem.name] = true;
							}
//=================================================================================
//RENAME INSTANCE ON STAGE WITH IT'S LIBRARY NAME
//...also take of "slashes" in path.
//---------------------------------------------------------------------------------
var CHANGE_NAME=obj.libraryItem.name;
if(obj.name=="" || force_rename){
	CHANGE_NAME=CHANGE_NAME.substr(CHANGE_NAME.lastIndexOf("/")+1,CHANGE_NAME.length);
	obj.name=CHANGE_NAME;
	cnt++;
}
//=================================================================================
						}
						obj = findObjectInTimeline (obj.libraryItem, name);
						if (obj != null)
						{
							found = obj
						}
						obj = selArry [n];
						if (obj.libraryItem.timeline != undefined)
						{
							obj = findObjectInTimeline (obj.libraryItem.timeline, name);
							if (obj != null)
							{
								found = obj
							}
						}
					}
					n ++;
				}
				k ++;
			}
			i ++;
		}
		return found;
	}
	if (inInstance == null)
	{
		inInstance = fl.getDocumentDOM ();
	}
	findObjectInTimeline (inInstance, instanceName);
	alert("Renamed "+cnt+" symbols.");
}
 

Note: Unfortunately, this method will not find elements that are grouped.
Let me know if this is helpful or if there is a better way to do this.

Example:

 
fl.outputPanel.clear();
var items=findObjects("mybox");
var n=0;
while(n < items.length){
	items[n].rotation=45;
	n++;
}
alert("Found "+items.length+" items.");
 

 
/*-------------------------------------------------------------------
findObjects
 
Returns an Array of elements in FLA document that match instanceName.
If nothing matches instanceName, an Array with a length of 0 is returned.
--------------------------------------------------------------------*/
function findObjects (instanceName, inInstance)
{
	var instances = [];
	var groups = [];
	var findObjectInTimeline = function (instance, name)
	{
		var timeline;
		if (instance.toString () == "[object SymbolInstance]" || instance.toString () == "[object Frame]")
		{
			timeline = instance.timeline;
		}
		if (instance.toString () == "[object Document]")
		{
			timeline = instance;
		}
		if (instance.toString () == "[object Timeline]")
		{
			timeline = instance;
		}
		if (instance == fl.getDocumentDOM ())
		{
			timeline = instance.getTimeline ();
		}
		if (timeline == undefined)
		{
			return null;
		}
		var checked = new Object ();
		var currentLayers = timeline.layers;
		var layObj;
		var frm;
		var found;
		var i = 0;
 
		while (i < currentLayers.length)
		{
			var layObj = currentLayers [i];
			var frms = layObj.frames;
			var k = 0;
			while (k < frms.length)
			{
				var selArry = frms [k].elements;
				var n = 0;
				while (n < selArry.length)
				{
					var obj = selArry [n];
					if (obj.name == name)
					{
						found = obj;
						instances.push (obj);
					}
					if (obj.libraryItem != undefined)
					{
						if (obj.libraryItem.name != undefined)
						{
							if (checked [obj.libraryItem.name])
							{
								n ++;
								continue;
							}else
							{
								checked [obj.libraryItem.name] = true;
							}
						}
						obj = findObjectInTimeline (obj.libraryItem, name);
						if (obj != null)
						{
							found = obj
						}
						obj = selArry [n];
						if (obj.libraryItem.timeline != undefined)
						{
							obj = findObjectInTimeline (obj.libraryItem.timeline, name);
							if (obj != null)
							{
								found = obj
							}
						}
					}
					n ++;
				}
				k ++;
			}
			i ++;
		}
		return found;
	}
	if (inInstance == null)
	{
		inInstance = fl.getDocumentDOM ();
	}
	findObjectInTimeline (inInstance, instanceName);
	return instances;
}