1) Aggregation

If objects A and B has same function, why not put that function on a separate object C and let both other objects call it from there.

2) Composition ie. inheritance

Put your redundant code to a class C and let your objects A and B inherit those methods from there.

3) Last but not least: include -statement

Sometimes good old include -statement is best way to go. Just put your code on separate file and include it where ever it’s needed. Quick, dirty and powerfull!

Included code doesn’t even have to be full class or  function, but any usefull bit of code will do.

function doSquareThing(x,y,width,height,fillcolor,bordercolor,callback){
      //Do something with the parameters

}

doSquareThing(10,20,15,15,#cccccc,#000000,squareReady);

Everytime you call the function you have to remember what order the parameters should be. If somebody else is reading the code he/she can’t know what the parameters are without seeing documentation or function definition.

Better way to do the same thing is to use a object as a function parameter. This way you will get much more human readable code. something like this:

function doSquareThing(settings){
      // do something with the parameters: settings.x settings.callback etc.
}
doSquareThing({
   x:10,
   y:20,
   width:15,
   height:15,
   fillcolor:#cccccc,
   bordercolor:#000000,
   callback:squareReady
});

it takes a few more lines, but instantly you know what parameters function call is passing and they can also be in any order.

mc_to_be_masked.mask = masking_mc;

But this will usually ignore any alpha gradients you might have in your masking movie clip.

To make the masking work  properly, you have to set everything to be caches as bitmaps. Both mask and movieclip that is going to be masked.

mc_to_be_masked.cacheAsBitmap = true;
masking_mc.cacheAsBitmap = true;
mc_to_be_masked.mask = masking_mc;

Tadaa, masks alpha properties should work as expected.

So for smaller line-height between lines of textfield you have to set leading on a css -style to negative values and vice versa for bigger line-height.

Something like this for decreased line-height:

.mystyle{
leading:-2px;
}

forename.surename@gmail.com
forenamesurename@gmail.com
f.o.r.e.n.a.m.e.surename@gmail.com
f.o.r.e.n.a.m.e.s.u.r.e.n.a.m.e@gmail.com

Next time you will need a new email address, for example to register to same service twice, look no further than your gmail account.

1) Make a new class with a public static variable (..or just download example files here)

package org.randomaccess.utility{
    public class Gb
    {
          public static var vars:Object = new Object();
    }
}

2) Import globals class to your own classes

import org.randomaccess.utility.Gb;

3) Use global variables like this:

Gb.vars.message_1 = "This is a global message";
Gb.vars.another_variable = "This is another global variable";

DOWNLOAD EXAMPLE FILES

Calling timeline from main class

On main class you can access timeline straight from the code.  Write stop(); to your main class and it will stop the playback of timeline.

package org.randomaccess{
	import flash.display.MovieClip;
	public class MyApplication extends MovieClip{

		 function MyApplication(){
                           /*
                          On main class you can access timeline straight from the code.
                          stop(); refers to the maintimeline and stops it.
                          */
                          stop();
		 }
	 }
}

Calling main classes methods from the timeline

Visa versa you can also refer straight to the main classes methods from the timeline. Add to your main class new method aka function:

  function myGotoAndStop(frame){
			 // This method is called on main timeline.
			// As this is the main class, you can call the main timeline directly.
			gotoAndStop(frame);

		 }

On first frame of your main timeline put command:

myGotoAndStop(10);

• Now the main class first stops the timeline on the first frame.
• On the first frame timeline calls the main classes function myGotoAndStop()
• myGotoAndStop() makes the timeline to go to the frame 10

Calling main classes methods from timeline is quite straightforward.

However, usually there shouldn’t be any reason to put any code to the timeline. It’s always better to write your code on methods and classes to keep them in nice, reusable order.

Download files

However, there is a better way to organise your code, that’s called packages ( That’s a fancy object oriented  name for subfolders)

Naming the packages

Common method for naming packages ie. folders is to use your companys or your own domain name. It’s convenient method as it provides unique paths for your code. Unique paths prevents your file names clashing with other peoples / companies code when you use their code or they use your classes.

Make folders for your packages

1. On the same folder where you have your flash (.fla) file create a  subfolder. Name  it according to your top-level domain ie. com, net, org etc.
2. On that folder make a subfolder named with your domain name. For us the folders would be org\randomaccess\
3. Move all your class files to that folder

Declare the new location in your .as class files

On .as files you define the package with dot syntax. For example: ” package org.randomaccess” simply means that “This file is located to a folder org\randomaccess\”

package org.randomaccess{

   import flash.display.MovieClip;

   public class MyApplication extends MovieClip{

      public function MyApplication(){
         trace("hello world")
      }
   }
}

Modify your main .fla to use your class in the new location ie. package

On your flash (.fla) documents properties -> publish -> class write the new location of  your main class, with dot syntax.

For example: “org.randomaccess.MyApplication”

Download example files

Setup a main class to have a starting point for your as3 code

1. ) Create a new actionscript file (as3) and add some code to it:

/*
This class is located to the same folder as main .fla file
so there is no package ie. subfolder defined.
*/

package{

	/*
	You have to import all the other classes that this class uses.
	Also flashes own classes like MovieClip
	*/
	import flash.display.MovieClip;

	/*
	Class has to be public to be used by other classes.
	Applications main class has to always extend flashes own MovieClip class
	*/
	public class MyApplication extends MovieClip{

		  /*
		  Main function is called when class is initiated.
		  It's name has to be the same as the classes name
		  */
          function MyApplication(){
             trace("Hello world!")
         }

    }

}

2.) Save the actionscript file with name “MyApplication.as”

3.) Make a new flash document

4.) On documents properties -> publish -> class write the name for your main class, for example: “MyApplication”

5.) Save the flash document to the same folder as your MyApplication.as file

6.) Test the flash movie!

On the Output panel you will see the “Hello world!” -message

Download files