Changing default map redux

This is definitely an actionscript syntax issue, and one forum post is not the best place for me to teach it. I can recommend working through a good actionscript 3 book - the O'Reilly one by Colin Moock is pretty great. That said, I will try to explain here and at least I should give you plenty of things to Google :)

The signature of your makeButton function says that action needs to be a Function variable.

This can be confusing, because generally you call functions to perform an action, which is what's happening where you're using map.setProvider(...) with parentheses. Unfortunately this breaks because setProvider returns returns void (nothing) and void is not a Function.

Luckily though, functions in actionscript can be referred to as variables (that's the reason you sometimes see it with a capital F, Function), and this works so long as you don't use parentheses. If you put the parentheses on the end you';; call the function instead of referring to it, as you did.

However, you're probably wondering how you pass arguments into a function if you can't use brackets when referring to it as a variable. This will take a bit of explaining, which I'll try to do with some examples...

Say you have a class called DemoThing with a function called doSomething:


package com.example.demo {
public class DemoThing
{
public function doSomething() {
trace('doSomething function in DemoThing class got called');
}
}
}


You make an instance of your class like this:


var myDemoThing:DemoThing = new DemoThing();


Then you could put the doSomething function into a variable and pass it to your makeButton function like so:


var action:Function = myDemoThing.doSomething; // note no parentheses at the end
makeButton(viewButton, 'beltline', 'beltline', action)


Or you could have passed it directly, like so:


makeButton(viewButton, 'beltline', 'beltline', myDemoThing.doSomething)
// again note the lack of parentheses


If you say doSomething() it will perform the action (in this case tracing some stuff) but if you say doSomething it refers to a Function instance instead.

However in order for such a Function object to work as an event listener in actionscript 3 without causing an error, it needs to take an event as an argument. So we would modify doSomething as follows:


public function doSomething(event:Event) {
trace('doSomething function in DemoThing class got called with event:', event);
}


Finally if you actually want doSomething to, uh, do something, you need to make DemoThing know about the pieces required. Let's say DemoThing is actually called ProviderHelper and doSomething is actually called applyProvider, the final class would need to know about map and provider, so it might look like this:


package com.example.demo {

import com.modestmaps.Map;
import com.modestmaps.mapproviders.IMapProvider

public class ProviderHelper
{
public var map:Map;
public var provider:IMapProvider;

public function ProviderHelper(map:Map, provider:IMapProvider) {
this.map = map;
this.provider = provider;
}

public function applyProvider(event:Event) {
map.setProvider(provider);
}
}
}


And then you would do:


var helper:ProviderHelper = new ProviderHelper(map, new BeltlineMapProvider());
makeButton(viewButton, 'beltline', 'beltline', helper.applyProvider);


Note that you're not calling applyProvider, you're passing it into the function as a variable where (I assume) it will be used as an event listener and it will get called only when the event occurs.

I hope the method I've outlined above is clear. I'll follow-up with an alternative approach which uses an actionscript feature called closures to do away with the need for the ProviderHelper class.