Icon in Panel Title Bar

Hi John

First of all, it is a mistake to implement property commitment logic in the createChildren() method. The createChidren() method is meant to initialize your component's subcomponents and add them to the display list but nothing more. Property commitment should be implemented in the protected commitProperties() function. Hence, code such as:
myText.text = this.linkName ;
returnedArray = linkUrlFunction.returnLink(identify,screenID);
myImage.source = String(returnedArray.getItemAt(1));

should reside in commitProperties().

After having that sorted, you need a way to know when your component's properties change so that you can commit those changes. For that reason, you need get/set functions for your properties. In your code, all bindable variables should be rewritten as properties. An added improvement would be to add explicit events to your bindable properties. That way, you are making binding much more explicit, efficient and solid. Here is an example for the first one:

private var _linkName:String = new String();

[Bindable(event="linkNameChanged")]
public function get linkName():String {
  return _linkName;
}

public function set linkName(value:String):void {
  _linkName = value;

  // calling this method will cause commitProperties() to be called in the next update
  invalidateProperties();

  // note that the event you dispatch has the same name as the one given in the Bindable metatag
  dispatch(new Event("linkNameChanged"));

}

Ok so now you know that when someone sets the linkName property, your component's properties will be invalidated, bindings on linkName will execute and eventually commitProperties() will be called. But when it comes down to writing your commitProperties() function, how do you know which property changed? Do you just update all of them? Sometimes when the performance hit is trivial, you simply update all of them for the sake of simplicity. But in some cases where updating the whole lot is expensive performance-wise, you need to implement additional "dirty checking" logic. In that slightly more complex scenario, the example above would become:

private var _linkName:String = new String();
private var _linkNameDirty:Boolean = true;

[Bindable(event="linkNameChanged")]
public function get linkName():String {
  return _linkName;
}

public function set linkName(value:String):void {
  if (_linkName != value) {
    _linkName = value;
    _linkNameDirty = true;
    // calling this method will cause commitProperties() to be called in the next update
    invalidateProperties();
    // note that the event you dispatch has the same name as the one given in the Bindable metatag
    dispatch(new Event("linkNameChanged"));
  }
}

override protected function commitProperties():void {
  ...
  if (_linkNameDirty) {
    // property updating code goes here
    _linkNameDirty = false; // reset the flag
  }
}

Please note that just like you can invalidate properties, you can invalidate the component's size (invalidateSize() which will end up calling measure()) or the display list (invalidateDisplayList() which will end up calling updateDisplayList()). However, for this specific component of yours, the given approach is the most appropriate, since you are more or less updating subcomponent's properties.

I know this may look a tad confusing at first but if you get used to the above routine, you will end up creating rock solid components with minimal effort.