I'm really banging my head on this one.
For some reason I can't see how to do what I want. I have a custom Event Class

package {
	
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.EventPhase;
	
	public class RemotingEvent extends Event {
		// constants for the different event types
		public static const LOGIN_RESULT:String = "login_result";
		public static const IMAGE_UPLOAD:String = "image_upload";
		public static const USER_SIGNUP:String = "user_signup";
		
		public var dataObj:Object;
		public function RemotingEvent(type:String, data:Object, bubbles:Boolean=true, cancelable:Boolean=false) {
			
			// Pass constructor values to superClass constructor
			super(type, bubbles, cancelable);
			
			dataObj = data;
			
		}
		
		// override clone()
		public override function clone():Event {
			return new RemotingEvent(type, dataObj, bubbles, cancelable);
		}
		
		// override toString()
		public override function toString():String {
			return formatToString("RemotingEvent", "type", "dataObj", "bubbles", "cancelable", "eventPhase");
		}
		
	}
}

When I try to dispatch an event I get the error

1180: Call to a possibly undefined method dispatchEvent.

Here's the code for handling the dispatching of events. This is just one of the methods
from a large remoting class I have written. I have made sure all of my classes are imported.

Here's a list of classes:
import flash.net.NetConnection;
import flash.net.Responder;
import flash.events.*;
import RemotingEvent;

There are others but these are the relevant ones.

private static function handleLogin_Result(isValid:Array):void {
	// param @ isValid:Array -- Contains 2 items. [0]=="success or error", [1]=="The error string" 
			
	var responseObj:Object = {isAllowed:false, errMsg:""}; 			
	var errStr:String = isValid[0].toLowerCase();
			
	var evt:RemotingEvent;
			
	// check to see if the user has passed in a proper username and password
	if (errStr == "error") {
		// Error has occurred. 
		// Username / Password is incorrect.
		evt = new RemotingEvent(RemotingEvent.LOGIN_RESULT, {err:errStr});
				
				
	} else if (errStr == "success") {
		// Allow the user to login.
		evt = new RemotingEvent(RemotingEvent.LOGIN_RESULT, {err:errStr});
	}
	dispatchEvent(evt);
}

Can someone point out what exactly I'm doing wrong?
I just don't see it. Any help would be greatly appreciated.

Thanks.

[senocular]

whatever class you're defining handleLogin_Result in needs to be an event dispatcher, either through extending EventDispatcher (or a subclass, like Sprite) or by implementing IEventDispatcher and using the EventDispatcher class to dispatch events for your instance in the implemented methods

[neilm]

I had tried that but it still didn't seem to work.
Originally this was a static class. I changed it all over to not be static and now it all seems to work.
I can't see that being the only cause tho. Static classes should be able to dispatch events, shouldn't they?
Here's the constructor of the class as it was in the non-working state.

package {
	import flash.net.NetConnection;
	import flash.net.Responder;
	import flash.events.*;
	import flash.display.*;
	import RemotingEvent;


	public class Remoting extends Sprite {
		private static const SERVICE_URL:String = "http://www.theurl.com/path/to/gateway.php";
		
		private static var service:NetConnection;
		
		//  Constructor
		public function Remoting() {}

		// Sends the users login information to the server for validation.
		public static function login(u:String, p:String):void {
			// This method sends the login data to the server
			var responder = new Responder(handleLogin_Result, onFault);
			service.call("gateway.login", responder, u, p);
		}

		private static function handleLogin_Result(isValid:Array):void {
			// param @ isValid:Array -- Contains 2 items. [0]=="success or error", [1]=="The error string" 
			
			var responseObj:Object = {isAllowed:false, errMsg:""}; 			
			var errStr:String = isValid[0].toLowerCase();
			
			var evt:RemotingEvent;
			
			// check to see if the user has passed in a proper username and password
			if (errStr == "error") {
				// Error has occurred. 
				// Username / Password is incorrect.
				evt = new RemotingEvent(RemotingEvent.LOGIN_RESULT, {err:errStr});
				
				
			} else if (errStr == "success") {
				// Allow the user to login.
				evt = new RemotingEvent(RemotingEvent.LOGIN_RESULT, {err:errStr});
			}
			dispatchEvent(evt);
		}
	}
}

That's the code that wasn't/isn't working.
The way I ended up going just takes out all of the static types which forced me to create a Remoting Object
instead of just calling it directly.

// Old
Remoting.login(u, p);

// New
var remObj:Remoting = new Remoting();
remoObj.login(u, p);

I know it should work as a static class but I'm obviously missing something in there.

If you see what I've messed up I'd be interested to know what it was/is.
Or if I'm completely out to lunch in my thinking and there is a better way I'd like to hear that as well.
Thanks Senocular.

[senocular]

static methods can't dispatch because the "instance" is the class itself, and that is an instance of Class which does not inherit from EventDispatcher.

[Nutrox]

It should work with a singleton though.

[neilm]

I think I'm going to end up going the singleton route as this particular class is going to be used in so many places within the app. I don't want to have multiple login's of the same user etc. so it's probably the best way to go for now. This was why I was trying to keep the static class. Thanks guys.

[Nutrox]

Yeah, a singleton would be better IMO. They pretty much behave the same way as all-static classes do. I think the only time all-static classes are really needed is for utility classes and classes that simply contain parameter values (i.e. StageAlign and StageScaleMode etc).

It sounds like you are already familiar with singletons but I thought I would post the following code anyway. This is how I do things:

package
{
    /**
     */
    public class MySingleton extends EventDispatcher
    {
        //----------------------------------------------------------------------
        //
        // Private Properties
        //
        //----------------------------------------------------------------------
        
        /**
         */
        private static var singletonInstance:MySingleton = null;
        
        /**
         */
        private static var constructorLocked:Boolean = false;
        
        //----------------------------------------------------------------------
        //
        // Constructor
        //
        //----------------------------------------------------------------------
        
        /**
         */
        public function MySingleton()
        {
            if( constructorLocked )
            {
                throw new Error( "MySingleton is a singleton" );
            }
        }
 
        //----------------------------------------------------------------------
        //
        // Public Methods
        //
        //----------------------------------------------------------------------
 
        /**
         */
        public function login( username:String, password:String ):void
        {}
        
        //----------------------------------------------------------------------
        //
        // Getters/Setters
        //
        //----------------------------------------------------------------------
        
        /**
         */
        public static function get instance():MySingleton // read-only
        {
            if( singletonInstance == null )
            {
                constructorLocked = false;
                singletonInstance = new MySingleton();
                constructorLocked = true;
            }
            
            return singletonInstance;
        }
 
    }
} 

The unwritten rules of OOP say the class instance should be accessed via a getInstance() method but I find using a getter makes the code a lot cleaner:

MySingleton.instance.login( ... ); 

Anyway, there you have it.

[sentinels]

not really an unwritten rule of OOP that says to use 'getInstance'... it's more because not all languages support implicit getter/setter methods, therefore the 'standard' way for singletons is via getInstance() but you can call it kickMe() if you wanted to, it wouldn't really matter.