Question

I figured out how to create a static method that is available everywhere, for example:

UtilLib.as:

package
{   
     public final class UtilLib
     {  
          public static function getTimeStamp():uint
          {
               var now:Date = new Date();
               return now.getTime();
          }
     }
}

I can access this everywhere by doing UtilLib.getTimeStamp() – Now, I want to create a new staic method called log(msg:String). This should log a message to a multi-line inputfield.

The problem however is that this inputfield must be created somewhere and must be accessible and visible all the time, and I don’t want to pass it through the function parameters all the time as this would cause a lot of trouble (I’d have to pass it through objects aswell..).

So, how do I make a “public textfield” so my static log method can write to it?

UPDATE:
I now tried the following class, with a static constructor (I think). However, the textfield object is not showing. When I do an addChild(debugField) after creating it, it gives me error 1180.

Logger.as

package
{
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.text.TextFieldType;

    public class Logger extends Sprite
    {
        public static var debugField:TextField;

        /* static block */
        {
            trace("Logger initializing.");
            debugField = new TextField();
            debugField.width = 500;
            debugField.height = 100;
            debugField.x = 100;
            debugField.y = 400;
            debugField.background = true;
            debugField.backgroundColor = 0xFFFFFF;
            debugField.defaultTextFormat = new CustomTextFormat();
            debugField.mouseWheelEnabled = true;
            debugField.multiline = true;
            debugField.type = TextFieldType.DYNAMIC;
        }

        public static function log(msg:String):void
        {
            if (debugField) debugField.appendText(msg);
        }

    }
}

I initialize it like this:

var test:Logger = new Logger();
addChild(test);

And I log a new message like this:

Logger.log("test");

Unfortunately, the textField is not showing.

Answer 1

Essentially you need:

• somewhere to log a message which is globally accessible
• the ability to update a text field whenever the log message changes

A simple solution using objects could look like this:

Example

package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.events.Event;

    public class Example extends Sprite {
        private var messageLog:TextField;

        public function Example() {
            createTextField();
            MessageLogger.getInstance().addEventListener( MessageLogger.LOG, handleMessageLoggerUpdate );
            MessageLogger.getInstance().log( "Message!" );
        }

        private function handleMessageLoggerUpdate( event:Event ):void {
            messageLog.text = MessageLogger.getInstance().getLog();
        }

        private function createTextField():void {
            messageLog = new TextField();
            addChild( messageLog );
        }
    }
}

MessageLogger

package {
    import flash.events.EventDispatcher;
    import flash.events.Event;

    public class MessageLogger extends EventDispatcher {
        private static var instance:MessageLogger;
        public static function getInstance():MessageLogger {
            if ( !instance ) {
                instance = new MessageLogger( new InstanceKey() );
            }
            return instance;
        }

        public static var LOG:String = "MessageLoader#log";

        private var messageLog:String;

        public function MessageLogger(key:InstanceKey) {
            messageLog = "";
        }

        public function log( message:String ):void {
            messageLog += message;
            notify();
        }

        public function getLog():String {
            return messageLog;
        }

        private function notify():void {
            dispatchEvent( new Event( LOG ) );
        }
    }
}
class InstanceKey {}

The important thing here is that a message can be logged from anywhere using

MessageLogger.getInstance().log( "Your Message Here" );

and anything can be notified of when a message has been logged using

MessageLogger.getInstance().addEventListener( MessageLogger.LOG, listenerFunction );

at any point the current message log can be obtained using

MessageLogger.getInstance().getLog();