Posts tagged ‘ActionScript’

Beginners OOP ActionScript Tutorial – part 3

For users who prefer to learn Flash visually we have a range of Adobe Flash CS3 video tutorials, this method of training greatly enhances learning and allows beginners to master even the most complex aspects of Adobe Flash with ease.
View the Beginners Flash CS3 Video Tutorial.

.

Instance Variables

Instance Variables are variables that are contained in each ‘instance’ of the Class; so every instance of the TextHandler Class will have it’s own TextFormat variable. Instance Variables should be initialised (given an initial value) in the constructor function, which is called whenever an Object of the Class is created. It is important, however, to refer to the instance variables outside the constructor, as in the above example, so that they are ‘visible’ to the entire Class.

Constructor Function

When you use the keyword ‘new’ to create an Object of a Class, what actually happens is that the ActionScript code within the constructor function for the Class is executed, returning an Object of the Class. The constructor function does not have to have the return type specified, as it is identified by having the same name as the Class itself.

To illustrate, imagine you wanted to create several of the TextHandler Objects, each with different formatting (i.e. different colour, font etc); you could alter the Class declaration so that the constructor function takes parameters indicating e.g. the colour, and these properties of the TextFormat object could be set within the constructor code. This way your main application code could create several different Objects of the TextHandler Class, each handling the textfields that you want to format in the same way (make the changes to your Class declaration and Flash document code):

//class code constructor
public function TextHandler(col:Number)
{
tf=new TextFormat();
tf.color=col;
}

//main code creating object
var myHandler:TextHandler = new TextHandler(0xFF0000);

To test this, place another dynamic textfield on your stage and name it other_txt, again with arbitrary text in it. Now add the following to your Flash document code:

var otherHandler:TextHandler = new TextHandler(0x0000FF);
otherHandler.formatText(other_txt);
//When you test the movie, other_txt should appear blue.

This trivial example may appear odd at first, but once you have gotten into the habit of thinking in terms of Objects, you’ll soon see how the techniques can save you a lot of stress. Experiment within your applications by creating Classes and Objects, with the following additional guidance:

  • Functions can have as many parameters (of any datatypes) as you need, but can only have one return type; you must declare this when you devise the method (as in the stripChars function above where the return type is specified as String).
  • The functions within a Class that are declared with the keyword ‘public’ are those that can be called on any Object of that type, wherever it has been created, as with the formatText method above.
  • Additionally, Classes may feature private functions that are for use within the Class only; these are referred to as ‘helper’ functions and are used in much the same way as the stripChars function was in our original example. You will use such functions within your Classes where processing is repetitive or where the code contained within a function becomes overly long or complicated.

Class Overview

Look again at the (amended) version of your TextHandler Class declaration. In terms of the interface, the Class contains a constructor function (which takes one parameter of the type Number, representing the colour) and a single function for formatting text, which takes one parameter of the type textfield, and returns nothing.

Try adding more functions to the Class – e.g. add the stripChars function, using the keyword ‘public’ in front of it, then try calling it from your movie, passing it a String as in the original example.

In theory, the TextHandler Class could have been created by someone else and you could still use it as long as you know: what the Class is for, what the functions are called (and what their purpose is), what parameters they take, and what data they return, if any. If you think about it, this is all you know about the built-in Classes that you use regularly.

The ‘interface’ can also be made more explanatory through the use of documentation and comments, as is the case with the built-in Classes. You can see an example of this with the official Adobe documentation for the TextFormat Class in ActionScript 3.0 here: http://livedocs.adobe.com/flash/9.0/ActionScriptLangRefV3/flash/text/TextFormat.html

- this gives you limited insight into the TextFormat Class declaration.

As with the stripChars helper function example above, if at any stage during your development process, you decide to change any of the implementation details within your Classes’ functions, you should be able to do so without upsetting any other code, as long as your interface remains the same. e.g. If you decided to change the for loop in the stripChars function to a while loop (for whatever reason) it wouldn’t affect the rest of the code, as long as it performs the same function.

Summary

The Object Oriented design method is a good way to achieve well-organised applications, but the success of the technique does depend strongly on Classes being defined in a clear manner. If you’re struggling at all to grasp the technical notions, have a try at using Classes anyway; as long as you stick to the principles outlined above, you should be able to define and create useful Objects.

It can be challenging to understand these notions when you’re starting out as a programmer and have built only relatively small applications. However, even where you are developing applications single-handed, Object Oriented design can make for efficient programs that are easily manageable.

If you’re interested in exploring Object Oriented development further, advanced areas to study include: Packages; Inheritance; Polymorphism; Interfaces; Abstract Classes.

November 7, 2008 at 12:15 pm 1 comment

Beginners ActionScript Object Oriented Programming part1

For users who prefer to learn Flash visually we have a range of Adobe Flash CS3 video tutorials, this method of training greatly enhances learning and allows beginners to master even the most complex aspects of Adobe Flash with ease.
View the Adobe Flash CS3 Tutorial.

.

Object Oriented Programming with ActionScript – part 1

As your Flash applications grow more complex, relying on substantial amounts of ActionScript code, efficiency will become more of an issue. Applications that use well-organised code are more reliable, and lend themselves better to future extension. One approach to developing such systems is Object Oriented design, which we will explore in this tutorial. Even if you’re new to the concept of Object Oriented design, you may find that you have already adopted some of the techniques on which it is based.

The Concept of OOP with ActionScript

You will likely already have used Objects in your ActionScript code whether you’re aware of it or not. For example, your code may have used the TextFormat class:

var tf:TextFormat = new TextFormat();

In this example, we create a new Object of the Class TextFormat. This means that the Object has the properties and behaviour that are defined in the TextFormat Class declaration. This Class is part of ActionScript itself, and you can therefore create and use TextFormat Objects just by inserting the single line above. With Object Oriented design, you will be designing your own Objects, by creating Class declarations for them in ActionScript, then importing them into your Flash for use there.

The concept of Object should be familiar to you if you have used Library items and Symbols in Flash. When you create a MovieClip, for example, and define what happens within it, the MovieClip symbol in your library is like a blueprint or prototype for that kind of Symbol. When you then use instances of the MovieClip Symbol within your Flash movie itself, each of these instances has the properties and behaviour that you defined when you created the MovieClip originally. This process is analogous to what you’ll do with your ActionScript Classes. The Class declaration is where you define the properties (in ActionScript) that any instances of the Class will have when you create them, as with the TextFormat object above.

Well-organised code

The reason for adopting any design methodology is to produce applications that are reliable, efficient and easy to perform future amendments or extensions upon. This is similarly the case with Object Oriented development. To begin, we will look at some of the simple efficiency measures that you can take during your regular programming routine, and demonstrate how these form the basis for the Object Oriented approach.

There are many techniques to achieving well-organised code when creating Flash applications. The simple act of including plenty of comments and whitespace in your code makes for a component that is easier to debug and extend. Similarly, organising your code into sensible chunks of related processing is helpful. When doing this, creating what are referred to as ‘helper’ functions (something that you may have already done), illustrates the basic principle behind Object Oriented design.

Let’s look at a simple example. When you are writing ActionScript code, you will often find that you are carrying out similar processes repetitively. When this is the case, you should consider creating functions to carry out those processes, effectively allowing you to cut down on the amount of code you need to achieve the same functionality. Imagine you have a Flash movie that contains several text Strings whose content varies, maybe the text is being imported from some external file which has unpredictable content. You have decided that you don’t want to display any content that isn’t alphanumeric, i.e. you only want letters and numbers. For this reason you will have to perform text processing on each of the Strings before you display them. Your code might look like this (feel free to paste this into a Flash document to try it out – don’t worry too much about the String processing code if it’s unfamiliar to you, the details are unimportant, but pay attention to the overall structure of the code):

//strings - nonsense
var first_str:String="kdfHGKj kkv e$ deagf% /.;fghlkjsf'h'";
var second_str:String="bcn'l;gH;'(fghsf ";
var third_str:String="bcnf..,\\gj[] *dFG";

//strip out non alphanueric from first
var firstStripped_str:String="";
for(var i:Number=0; i="0" && ch<="9") || (ch>="a" && ch<="z"))
firstStripped_str+=first_str.charAt(i);
}
trace(firstStripped_str);

//strip out from second
var secondStripped_str:String="";
for(var j:Number=0; j="0" && ch<="9") || (ch>="a" && ch<="z"))
secondStripped_str+=second_str.charAt(j);
}
trace(secondStripped_str);

//strip third
var thirdStripped_str:String="";
for(var k:Number=0; k="0" && ch<="9") || (ch>="a" && ch<="z"))
thirdStripped_str+=third_str.charAt(k);
}
trace(thirdStripped_str);

This can be easily improved by making a ‘parameterised’ function, meaning a function that will carry out the same processing but which takes the Strings as parameter, making it adapt to each different circumstance:

//strings - nonsense
var first_str:String="kdfHGKj kkv e$ deagf% /.;fghlkjsf'h'";
var second_str:String="bcn'l;gH;'(fghsf ";
var third_str:String="bcnf..,\\gj[] *dFG";

function stripChars(my_str:String):String
{
var stripped_str:String="";
for(var c:Number=0; c="0" && ch<="9") || (ch>="a" && ch<="z"))
stripped_str+=my_str.charAt(c);
}

return stripped_str;
}

trace(stripChars(first_str));
trace(stripChars(second_str));
trace(stripChars(third_str));

Notice how much more concise the code is – test the movie to check that both versions of the code have the same effect. What you have done is to give the function ‘responsibility’ for the text processing. One of the advantages to doing this is that, if you decide to change the process in any way, you only have to do it in one place (within the function) – this is a single ‘point of change’. Eventually, when you have gotten into the habit of thinking this way when writing your code, you will start to anticipate the practice, rather than carrying it out retrospectively, and will save yourself a lot of time and effort in doing so.

While the above technique does make the code more efficient, it is still ‘procedural’ rather than Object Oriented in structure. Procedural programs are basically a series of instructions being executed in turn. When the movie is run, the code listed on the main timeline is executed in a linear fashion, i.e. each line is processed one after the other until the machine is instructed otherwise. To adopt Object Oriented design, we need to extend the notion of creating ‘helper’ functions, and to develop ‘helper’ Objects to carry out the processing within a movie. In the same way that we allocated the text-processing responsibility to a function, we can assign responsibility for the individual parts of an application to Objects – we can ‘delegate’.

ActionScript Object Oriented Programming Tutorial Part 2

November 7, 2008 at 12:08 pm Leave a comment

Flash Tutorial – Drawing Lines and Shapes with ActionScript

For users who prefer to learn Flash visually we have a range of Adobe Flash CS3 video tutorials, this method of training greatly enhances learning and allows beginners to master even the most complex aspects of Adobe Flash with ease.
View the Flash CS3 Tutorial Videos .

.

Flash Tutorial – Drawing Lines and Curves using Actionscript 3.0

We all know you can create shapes and lines in Flash using the many drawing tools, but did you know you can unleash the power of ActionScript to create shapes on the fly.

In this Flash tutorial we’ll be looking at how to draw lines and curves using Actionscript 3.0. In the examples below we’ll use methods from graphics class to draw out the lines and curves. The benefit of drawing in Actionscript rather than using tools from the Flash interface is that it makes for a much smaller file size. Below we’ll go through the code line by line and draw out the line and curve in shown in the example .swf file.

Download the SWF File

Drawing Lines
First thing we’ll look at is how to draw a simple line. We’ll first create a new Sprite object called “container”, this will hold all our graphical information for the line. A Sprite is just a Movie-Clip without a Timeline.

Open up Flash and launch the Actions Panel.

var container:Sprite = new Sprite();

To display the new Sprite object or add it to the stage we use the addChild() method. This makes it visible when you preview or publish the file.

addChild(container);

Next we want to draw the line itself, our first task is to choose the style of the line. To do this we use the lineStyle() method, the lineStyle() method has 3 parameters available to it thickness, colour and alpha scale. Thickness is measured in pixels, colour is in decimal format and finally alpha scale, which is an optional parameter measured in percent (1 = 100%, .5 = 50%). We assign this method to the graphics property and then assign that graphics property to the Sprite object, so that everything is added to the Sprite object.

container.graphics.lineStyle(3,0×333333);

Now that we have the style properties of the line it’s time to decide on our starting point. The starting point will indicate where we are drawing from, to declare the starting point we use the moveTo() method. This method requires 2 parameters, X and Y position. The X and Y values will indicate the starting position of where we want to draw from.

container.graphics.moveTo(20,20);

We have the starting points and are now ready to draw the line. The starting point needs an ending point or somewhere to draw to. Using the lineTo() method we declare the point we’re drawing to. The lineTo() method uses the same parameters as the moveTo() method, the only difference is with the lineTo() method we’re declaring where we are drawing to instead of where we are drawing from.

container.graphics.lineTo(450, 20);

It is possible to draw shapes by continuing to use the lineTo() method, as Actionscript executes in linear fashion we can also change the style of the line at any given point. Adding the code below to the code we’ve already written draws a small rectangle, we draw out the rectangle but change the style of the line by inserting a new lineStyle() method. This means the last two lines will be drawn in red.

container.graphics.lineTo(450,50);
container.graphics.lineStyle(3,0xff0000);
container.graphics.lineTo(20, 50);
container.graphics.lineTo(20,20);

Drawing Curves
Drawing curves is also pretty straight forward but instead of using the lineTo() method we use the curveTo() method. The curveTo() method also works with the moveTo() method to determine our starting point. The curveTo() method however requires 4 parameters, x and y positions of the curve and X and Y positions of the ending point. Using this code below will give us a nice red curve.

var curve:Sprite = new Sprite();
addChild(curve);
curve.graphics.lineStyle(3,0xff0000);
curve.graphics.moveTo(50,150);
curve.graphics.curveTo(225, 0, 450, 150);

For a more clear explanation look at the diagram below, you can see the moveTo() starting points indicated by the arrow. The curveTo() parameters are also highlighted in green, the first 2 parameters show the X and Y points of the curve. The final 2 parameters also highlighted in green show the X and Y points of where the ending point of the curve is.

In the next Flash Tutorial we will move on to creating Shapes with ActionScript

November 3, 2008 at 6:48 pm 1 comment

Flash CS3 Tutorial – Create a Custom Scrollbar with ActionScript

For users who prefer to learn Flash visually we have a range of Adobe Flash CS3 video tutorials, this method of training greatly enhances learning and allows beginners to master even the most complex aspects of Adobe Flash with ease.
View the Flash CS3 Tutorial Videos .

.

Would you like to be able to create your own cool, custom Flash Scroll Bar. This Flash Tutorial shows you how, with a little bit of ActionScript 3 you’ll be on your way.

Flash CS3 Tutorial – Create a Custom Scrollbar with ActionScript

In this tutorial we’ll look at how to create a custom scrollbar using Flash and Actionscript 3.0. In the download file (To download right click and save target as ) we have 3 main graphics, two arrows and a rectangle. The two arrows will act as our scrollbar navigation allowing us to scroll up or down. The rectangle will act as the slider and will work in the same way as the scrollbar in your browser window. We’ll create a TextField and connect it to the movie clips using actionscript allowing the text to scroll with the scrollbar.

Downloads for this Flash Tutorial
Example SWF File
Download FLA File
(To download right click and save target as )

Lesson 1 – Setting Up The Movie-Clips

First we need to convert the arrow and rectangle graphics into Flash Movie-Clips, and give them each unique instance names.

Select the rectangle, press F8, choose Movie-Clip from the type options and click Ok.

Click the new Movie-Clip to make sure it’s selected and go down to the properties inspector and type “slider” inside the text box. This will give the Movie-Clip the instance name “slider” and allow us to control the Movie-Clip with Flash Actionscript.

Repeat this step for the up and down arrow graphics but give them the instance names upArrow and downArrow respectively.
Step 2 Setting Up The Text Field

In this step we’ll create the text that will be controlled by the scrollbar, instead of using the basic text tool to create the text we’re going to dynamically create it using actionscript. We’ll use the TextField and TextFormat classes to create, format and position the text on the stage. Below we’ll break the code down line by line to see what it all does.

If you haven’t already done so select the first keyframe on the timeline and press F9 to open up the actions panel.

First we create a new TextField object called theText. This creates a new instance of the TextField class giving us access to all the properties, methods and events inside that class.

var theText:TextField = new TextField();
Next we create a TextFormat object called theFormat, again giving us access to all the properties, methods and events available to that class. The TextFormat class will allow us to change the size and font properties.

var theFormat:TextFormat = new TextFormat();

At the moment our TextField is empty so we fill it with some text using the text property.

theText.text = “This is a custom made scrollbar. At quod soleat voluptua pri, congue copiosae vulputate ea vel, sit solum facer dicta ne. Sit vide singulis voluptatum cu, est et porro nominati iudicabit, ius et dicit perfecto volutpat. Altera iriure incorrupte est eu, et usu graece fuisset, pri libris epicurei neglegentur an. Usu nibh velit accusata cu, pro ad graecis phaedrum indoctum. Facilis nusquam id ius, ut sonet legimus has. Veniam eruditi graecis sed ei, est id alterum dolorum omittantur. Libris semper quo cu, ius rationibus delicatissimi signiferumque ut, in enim elit corpora sit. Et ius aliquam bonorum ancillae, vix ei quis atqui. Debet dicunt senserit ne sed, solum ponderum persecuti eos et, ullum antiopam expetenda usu eu. Eu nec doming everti nominavi, eu mea falli utroque facilis. An quot quas sonet sit, id vim laudem dolorum, ne vel veritus denique constituto.”;

Sets the text size to 15px.

theFormat.size = 15;

Using the setTextFormat()method sets the font property to the theText object’s theFormat property. In simple terms it combines the TextFormat properties to the TextField.

theText.setTextFormat(theFormat);

Setting the wordWrap value to true will word wrap the text inside the TextField.

theText.wordWrap = true;

Currently all of the text sits on a single line, setting the multiline value of the TextField to true will ensure that the text will appear on multiple lines.

theText.multiline = true;

We want to position the TextField alongside the scrollbar, so we change the X and Y positions of the TextField to 100px respectively.

theText.x = 100;
theText.y = 100;

At the moment our TextField size is really small, we resize it by changing the width and height values to 300px and 160px respectively.

theText.width = 300;
theText.height = 160;

The addChild method adds the TextField to the stage, making it visible when you preview the file.

addChild(theText);

Step 2 – Setting Up The Scroll Arrows

In this step we’ll give the up and down arrows some MouseEvents and functions, enabling us to manipulate the position of the text inside the TextField.
When you hover over a link on the Internet the cursor state changes from an arrow to a hand pointing, to create the same effect with Actionscript we set the buttonMode value to true. Setting the buttonMode value of the up and down arrows to true gives us the hover state effect.

upArrow.buttonMode = true;
downArrow.buttonMode = true;

The arrows on the stage need to listen for mouse clicks, we use the addEventListener()method to achieve this. The addEventListener()methods below each have three parameters class type, property and unique name. The main parameters in our code are MouseEvent and CLICK, selecting MouseEvent gives us access to the MouseEvent class and inside that class we choose the CLICK property. Finally we name them scrollUP and scrollDown respectively.
upArrow.addEventListener(MouseEvent.CLICK, scrollUP);
downArrow.addEventListener(MouseEvent.CLICK, scrollDown);
At the moment nothing happens when we click the up and down arrows, we need to create some functions for the scrollUP and scrollDown event listeners. We want the text in the TextField to scroll up or down depending on which arrow is clicked, with the use of the scrollV property and a little math this can be accomplished. The scrollV property allows us to manipulate the vertical position of the text inside the TextField; it’s measured in lines making it easy to change the text’s position inside the TextField. Inside the scrollUP function we subtract the scrollV value by one each time the function fires, essentially subtracting one line of text each time the up arrow is clicked. For the scrollDown function the opposite is required and we add one each time.
function scrollUP(event:MouseEvent):void {

theText.scrollV -=1;

}
function scrollDown(event:MouseEvent):void {

theText.scrollV += 1;
}
Step 3 – Controlling The Slider
The final and most difficult step of this Flash tutorial is controlling the slider. We’ll create boundaries to control where the slider can and cant scroll too. We’ll then create some eventListener()methods and functions to attach the TextField to the slider.
First we create a new Rectangle object called area to create some boundaries for the slider. The arguments for the Rectangle object are x position, y, position, width and height. In our case we want the boundaries to start at the same position as the slider position, we do this by declaring the x and y positions as slider.x and slider.y. For the width and height of the Rectangle argument we specify 0 and 90 respectively, 0 because we don’t want to be able to move the slider horizontally and 90 because the height of our slider background on the stage is 90px.

var area:Rectangle = new Rectangle(slider.x, slider.y,0,90);

The next step is to create some mouse events for the slider so that we’re able to drag the slider. We’ll use MOUSE_UP and MOUSE_DOWN events from the MouseEvent class that’ll allow us to drag and drop the slider. One noticeable difference between the 2 methods is that the sliderOut event listener is attached to the stage and not the slider, if we attached it to the slider the scrollbar would continue to scroll even when we click away from the slider. Attaching it to the stage gets around this problem.

slider.addEventListener(MouseEvent.MOUSE_DOWN, sliderDrag);
stage.addEventListener(MouseEvent.MOUSE_UP, sliderOut);

As stated before we want to be able to drag and drop the slider, creating functions with the methods startDrag() and stopDrag makes this simple. startDrag() you’ll notice has 2 parameters false and area, the first parameter is a Boolean value called lockCentre. The lockCenter value is set to false, locking to the point where you first click. The second parameter bounds is a Rectangle value that allows us to specify a rectangle boundary area, we’ve already created the boundary inside the area Rectangle object so we call that by typing “area” for the second parameter. The stopDrag() method doesn’t require any parameters as it just cancels the drag.

function sliderDrag(event:MouseEvent):void {
slider.startDrag(false,area);
}

function sliderOut(event:MouseEvent):void{
slider.stopDrag();

}

Next we have to create some EventListeners() to listen for a SCROLL event and an ENTER_FRAME event. The SCROLL event will listen for when the text inside theText TextField is being scrolled. The ENTER_FRAME fires constantly at the same rate as the frame rate. We’ll name these EventListeners() textScrolled and theSlider respectively. In the next step we’ll create some functions for these EventListeners.

theText.addEventListener(Event.SCROLL, textScrolled);
theText.addEventListener(Event.ENTER_FRAME, theSlider);
At the moment the slider drags up and down within the boundaries specified earlier but it doesn’t actually scroll the text. To scroll the text with the slider we create a function with a small calculation that attaches the text position to the slider position.  First we set the vertical position of theText TextField equal to Math.round making sure the calculation gives us a whole number, remember we want to scroll down line by line otherwise we’d end up having some lines getting cut off. Inside the brackets we create the calculation, we’re looking for how far the slider has scrolled so we subtract the sliders y position by the area’s y position and multiply that by the maximum scroll value of the TextField, then finally divide that value by the height of our area (90).

function theSlider(event:Event):void
{
theText.scrollV = Math.round ((slider.y – area.y)* theText.maxScrollV/90)
}

When we click either the up or down arrows the slider doesn’t move position. To make this scrollbar complete we want the slider to move in conjunction with the text when we scroll with the arrow buttons. Inside the function we’ll create a small calculation so that the slider follows the text position. First we set the slider.y position to the y position of our area rectangle. We add that to the calculation inside the brackets. The calculation adds the vertical position of our text (theText.ScrollV), multiplied by the height of the of our boundary area (90) and divides it by theText Textfields maximum ScrollV position.
function textScrolled(event:Event):void
{
slider.y = area.y + (theText.scrollV * 90/theText.maxScrollV);
}

October 27, 2008 at 10:55 pm Leave a comment


Follow us on Twitter


Follow

Get every new post delivered to your Inbox.