private function checkText(evt:Event):void {
if (_stage.myInput.text == "test text") {
_stage.addChild(customText);
dispatchEvent( new Event(correctText) );
}
}

you would quickly learn that the AS3 compiler can get really annoying. Obviously this should work, right? I mean, its an explicit reference to the stage! Well, true, it is an explicit reference to the stage, but that isn’t what you need. What you need is an explicit reference to “root”. Now here is where I am going to vague because I don’t fully understand what the difference is, nor why its necessary, but I can tell you from exploring the children of ’stage’ that “root” seems to be a display object one level below “stage” where the real children (the ones we care about at least) reside.

That said, we will be passing “root” to the class in the same way we passed “stage” except that I don’t actually know what data type “root” is (called “MainTimeline” by Flash’s trace() function). My quick fix is to use *. Here is the updated code for the class:

package com.kylebrekke {
import flash.display.Sprite;

// Our class extends the Sprite base class
public class testClass extends Sprite {

// Imported files for the compiler
import fl.controls.TextInput;
import flash.text.TextField;
import flash.events.Event;
import flash.display.Stage;

// Public Event Constants
public static const correctText:String = "correctText";

// Private variables
private var stageTextfield:TextInput; //check using event change
private var customText:TextField = new TextField();
private var _stage:Stage;
private var _root:*;

// The 'getters' and the 'setters'
public function get customizedText():String {
return customText.text;
}
public function set customizedText(s:String):void {
customText.text = s;
}

// This is the constructor, the first function to fire during instantiation
public function testClass(alreadyOnStage:TextInput, s:Stage, r:*):void {

// We are passing a reference of the Input Text into a class variable
// so that we can access it from anywhere inside our class
stageTextfield = alreadyOnStage;
stageTextfield.addEventListener(Event.CHANGE, checkText);

_stage = s;
_root = r;

// This custom text can be overriden by the getters/setters
customText.text = "Correct Text!";
customText.x = 250;
customText.y = 35;
}

// This function processes the input text if its value ever changes
private function checkText(evt:Event):void {
if (_root.myInput.text == "test text") {
_stage.addChild(customText);
dispatchEvent( new Event(correctText) );
}
}

}
}

and here is the one line you need to change in the .fla:

var test:testClass = new testClass(myInput, stage, root);

I hope that clarifies everything. Please post any comments, especially if you happen to know a bunch about how the stage works in AS3.

Also, for another guide on this, try this link.

ShareThis

Hopefully you’ve had a chance to read my other postings on AMFPHP and the classes and wrappers I’ve written for it. This post will be an example on how to query a mysql database from php and pass it into flash, then parse it into a multi-dimensional associative array (a big array that gives you the ability to loop through its records by number, and access its columns by name – similar to PHP’s mysql_fetch_assoc() ). First, if you are unfamiliar with my other postings, you can view them below:

• AMFPHP Class and Wrapper
• Updated version of the base class

Setting the Stage

This project requires 4 files: the php service, the two as3 classes (amfphp.as and amfWrapper.as), and the FLA. You can download them below:

• AMFPHP + MYSQL Connection Project

Understanding the PHP Service

The service itself is fairly straight forward. First, note the important require_once line that includes the connection info to the MySQL database. This file should be basic and doesn’t necessarily have to be an external one. I keep mine external for convenience sake. Here’s the code:

$dbhost = "127.0.0.1";
$dbname = "my_database";
$dblogin = "mylogin";
$dbpass = "mypassword";

$failure = "MySQL problem. Connection to ".$dbhost." failed.";

if(!$connect = @mysql_connect($dbhost, $dblogin, $dbpass))
die($failure);
} else {
if(!@mysql_select_db($dbname,$connect)) {
die($failure);
}

Here is the class code:

require_once("connect.php");

class example {

/**
@desc - empty
*/
function example ( ){
}

/*
@desc loads the data from the mysql db, sends it to flash, which parses it
*/
function loadMysqlData($user_id) {

NetDebug::trace("Executing loadMysqlData");
NetDebug::trace("Argument user_id: ".$user_id);

$sql = sprintf("SELECT * FROM mytable WHERE id=".$user_id);
$result = mysql_query($sql);

return $result
}

}

As for the rest of the service, you have the class declaration, the constructor, and then class method called loadMysqlData, which is really the meat of the project. The NetDebug::trace() function is a debugging tool that outputs information to the AMFPHP Browser. Not really necessary, but I include it anyway out of habit. After that you have the MySQL Query statement, then the actual query when I pass that statement to the mysql_query() function that, if successful, outputs a valid resource id. Lucky for us, we can just return that resource id (as you can see from the code), and doing so passes all of the mysql info we request straight to flash (very quickly I might add; figures show amfphp is as fast as XML for most data sizes and quite a bit fast than JSON).

Inside Flash – How to handle this SQL Data

Luckily, if you are using my amfphp.as class then the function to parse out the MySQL data table is already done for you. The function is static (meaning you don’t need an instantiated class to access it) and it takes one parameter which is the object that AMFPHP gives to you – the result. The actual code for making use of this function is below:

dbData = amfphp.assocMySQL(remoteConn.serverResponse);

dbData is the final array (you must declare it as an array beforehand). For a full example of this code, simply look at the attached amfWrapper.as class. The amfWrapper class is an example implementation of the amfphp class. Thus, in the final project (fla) you only need to instantiate the wrapper in order to access the mysql information. It keeps things clean and organized.

The project files can be downloaded below:

• AMFPHP + MYSQL Connection Project

As always, feel free to post any comments or questions. I’m always willing to help.

ShareThis

ShareThis

If your ambitions in Flash AS3 extend beyond that of basic animation you will NEED to care about Event Listeners because the flow of your entire project will depend on them. They are the ignition to your movies. They allow you to respond to input from users (whether it be the mouse or the keyboard or any other form) and take action with that input. In short, Event Listeners are part of the life-blood of Flash programming.

What is an Event Listener?

Very simply, an event listener is a way to execute a function when a designated event takes place. Most importantly, an event listener is a way for Flash trigger certain actions (or alert the programmer) when a certain event has happened and then pass key information to that function.

Think about it like this. If a person clicks on a button, there are a couple of ways to logistically determine if the button was clicked. One option would be to run a timer that fired every millisecond to check if the mouse button was down. Technically this would work, but it would become very cumbersome for the programmer to keep track of so many timers. Many of the other options are equally as cumbersome and unhelpful. The preferred solution is to use an Event Listener.

Understanding the AS3 Event Listener Model

The event model is crucial to the flow of complex Flash applications. While you may not have a need for it if you only designing animations (in which case gotoAndPlay() and stop() will be your AS3 favorites) in any other application you will want to harness the power of events. They are crucial for doing things like determining when a user has clicked a button, or figuring out when a remote image has completed loading.

The model itself is part of AS3’s implementation of an Object Oriented Programming (OOP) style. Don’t be overwhelmed by its name, however, its really just a way of thinking about the world and modeling it inside your code. Think of it like this: everything in the world is an object. Some things are a combination of multiple objects that work together to create an even more complex object. And yet, each object by itself is a combination of THREE essentially things: its properties (states of being, characteristics, features, etc), its methods (the actions and functions it can perform), and its events (the things that happen to it, its circumstances). Events, then, are really only one third of the picture, but a very important third.

Continuing with this OOP idea, the event is only going to fire when something happens to it. However, in flash it is a two part system. Part One is telling Flash what event it should be on the look-out for. How should Flash know it needs to send an alert when a button is clicked if you never tell it? This is achieved using the addEventListener function. The Second Part is the actual firing function. This is the code that gets executed when the event happens. These functions are just like any other, except they take as their first parameter an object that contains VERY helpful information. More on that later.

Understanding Part One of the AS3 Event Listener Implementation

If you are joining us from Flash 8’s AS2 model then the newer AS3 Event Listener based language may give you some difficulty. I hope that you are familiar with the idea of an event listener, but it is actually implementation in AS3 will be slightly different. In the old model, we assigned the actual function, code and all, like in the example below:

var focusListener:Object  = new Object();
focusListener.onSetFocus = function(oldFocus:TextField, newFocus:TextField) {
oldFocus.border = false;
newFocus.border = true;
}

In AS3, rather than assigned the entire function, we simply reference the function name within the addEventListener function, like below:

var focusListener:MovieClip  = new MovieClip();
focusListener.addEventListener(MouseEvent.MOUSE_CLICK, handleClick);

Here we have create a new movie clip and assigned an event listener to it that will fire in the case of it being clicked on by the mouse. (Note: contrary to the example above, the Object class in AS3 does not have event dispatching capability. Instead, use the Sprite class or a derivative of the Sprite class, such as the MovieClip class).

In every case of assigning an event listener, you will want to start with the instance name. You can remember this because this is the name of the object to which you want the event to happen. For instance, it is the name of the button that you are assuming the user will click.

This is followed every time by the dot operator (“.”) and then the function name addEventListener. This tells Flash exactly what the name implies, that it should add an event listener to the object you have specified. Of course, the next question is “what kind of listener?” and of course, “what should I do once the event has occurred?”

The answer to the first question will depend on your project. The two most frequent types of events are the general Events and the MouseEvents. To access these types, you simply type the name of the event class, for instance MouseEvent, followed by the dot operator (“.”), and then the specific type of event you’d like to listen for. Don’t worry, a mini-pop-up will appear to help you select your event type. Some MouseEvent types include: MOUSE_UP, MOUSE_DOWN, MOUSE_CLICK, MOUSE_OVER, etc. Just chose your type, hit enter, and then on to the next question.

Now we must tell Flash what to do when the event has occurred. The only real answer is for Flash to execute a function, so the next item we tell Flash is the name of the function we want it to execute. (Note: you do not need to type any quotation marks to signify a string, just simply type the function name and Flash will understand). Once you have done this, part one of the event listener model is completed.

Understanding Part Two of the AS3 Event Listener Implementation

The second part of the Event Listener model is the actual function that the Event Listener will execute. This function is THE EXACT SAME as any other function you will make in flash with only one major exception – the first parameter of the function is an Event Object. This object is the home of many important pieces of information, most notably target and currentTarget. First, let me give you some example code:

function handleClick(evt:MouseEvent):void {
trace("You clicked the "+evt.currentTarget+" button");
}

Notice how the syntax is the same. The one object that has been passed to the function I’ve called “evt” and is a MouseEvent.This object contains different properties that we’d like access to. The one I’ve used in this example is called currentTarget and it is a literal reference to the object that has been clicked, that is, our MovieClip. Thus, anything you do to currentTarget is the same as if you had done it to our MovieClip called “focusListener”. This is very powerful because now you can write just one function and instead of referring to the “focusListener” you can reference currentTarget and it can be ANY MovieClip you’ve passed. You’ve now made reusable code. And reusable code is the best code.

Other properties passed via the MouseEvent include localX, localY, shiftKey, stageX, stagey, etc. As the names imply, these are the coordinates of the mouse upon clicking (both local within the “focusListener” MovieClip and global to the stage). Each property is explained in detail in Adobe’s LiveDocs.

The trick to implementing event listeners successfully is to learn to use the currentTarget property really well so that you can program powerful functions that leverage the reusability offered by this event model. Do not expect to be a master of this all in one sitting. It takes some practice to get use to the idea of events. With effort and some help from the community you will be a pro in no time.

If you’d like to see an example of these event listeners in action you can read the article Write your first class ever… with event dispatching. Please do not hesitate to leave any comments or questions you might have on the feedback below.

ShareThis

I’m sure this isn’t first nor will it be the last time you hear about the frustrations of dealing with Adobe’s pre-coded and pre-packaged components. Some complain about their design, their style, their customization, their size, and even (my personal experience) their functionality when embedded into pages with Facebook’s <fb:swf> tag. The simple solution to all of these problems is to simply code your own. However, scrollbars can be a nightmare and take hours to code, debug and customize. So, I’ve tried to save you all that hassle by building a fairly customizable scrollbar class.

Download the example files (includes the classes): AS3 Scrollbar Class and Example

In zip format: AS3 Scrollbar Class and Example

Quick Start Guide for the AS3 Scrollbar

For out of the box installation there are only a few lines of code you need once you place the files into the correct class path (default: com.kylebrekke.scrollbar – place “com” in the same root folder as your .fla). On whatever frame it is you’d like, place the following code:

import com.kylebrekke.scrollbar.scrollbar;
var viewableWidth:Number = 200;
var viewableHeight:Number = 100;

var hScroll:scrollbar = new scrollbar(stage, targetMC, scrollbar.HORIZONTAL, viewableWidth, viewableHeight);
hScroll.x = 40;
hScroll.y = 235;

var vScroll:scrollbar = new scrollbar(stage, targetMC, scrollbar.VERTICAL, viewableWidth, viewableHeight);
vScroll.x = 15;
vScroll.y = 20;

I’ll give you a quick break down of this code. First, you must import the proper classes. Make sure that the path follows wherever you decide to place the class file (default shown above). The next two variables are the viewable width and height of the target you want to scroll. So, you may have a movie clip that is 700×700, but you only have a place in your flash file to show a 300×400 square. Then, to use the scroll bars within this area simply set the viewable width and height to 300 and 400 respectively.

Next, you will notice that the vertical and horizontal instantiation code is practically the same, with the exception of “scrollbar.<direction>”. That is where you set which direction you’d like that instance to scroll. The “stage” is the default stage you’d like to add the scrollbars to. This should be the same stage that “targetMC” is on; “targetMC” is the movie clip you’d like to scroll. Finally, if you’d like, you can set different positions for the instances of the scrollbar. You’ll most likely have to do use the set and check method – make a guess and compile the movie quickly to see if they show up properly.

Advanced Customization of the AS3 Scrollbar

To customize or skin the scrollbar assets (the movie clips that make up the scrollbar) you can simply edit them from the library of the .fla. However, a couple of things to note (1) be sure to center both vertically and horizontally the graphics within the movieclip and (2) most of the assets have two frames so that their “buttonmode” can be set to true which gives them a rollover effect. Currently, the style is a poor attempt to copy Vista-style buttons. I’m sure many designers out there could do a better job, but since this is only an example, I expect most people to do some modifications.

The other points that can be edited include the speeds at which the content scrolls from an arrow click or a mouse wheel move. These numbers represent the amount of pixel movement on each mouse input and can be changed using the set and check method. The other constant is the transition speed which essentially determines if there is any lag between the time the user scrolls and content moves. I’ve chosen to use TweenLite because the size is much smaller than Caurina Tweener, though you can feel free to swap those out as well, it’s quite simple.

Feedback about the Scrollbar

I realize now, after the fact, that much of this scrollbar structure could be improved. I’ll attempt it again probably in the weeks to come, but if anyone would like to expand or alter this code and send me the updates it’d be much appreciated. As always, I’m only looking to provide the flash community with high quality with premade classes to save time and headaches. One requirement, however, is that the code is clean, concise and reusable. I feel that this code may not live up to the high expectations, but never fear, another version is on its way.

ShareThis

The new file is available for download: AS3 AMFPHP Class and Wrapper

Older articles can be accessed:

AMFPHP AS3 Class – Communication between Flash and AMFPHP made easy

AMFPHP AS3 Class and Wrapper – Communication between Flash and AMFPHP made even easier

AMFPHP AS3 Class and Wrapper – MySQL Query Example

Let me know what you think of the updates, and the additions from Joshua.

ShareThis

Anyhow, here is the class for those who’d just like to download and tinker: AS3 AMFPHP Class and Wrapper

This latest version was possible thanks to help from Joshua Logsdon (credit can be seen here).

And here is an important reference to my previous amfphp connection class (though its a bit out of date you can still download the older version): AMFPHP MADE EASY

Now, for the explanation. The original class works much like I describe in the previous article. During instantiation you supply the gateway url, the call function, and any extra parameters you’d like including a callback function for responses. Simple and clean. However, I do recognize that for complex projects you may need something a bit more robust, and thus I have extended the class with a wrapper class. Now, since wrapper classes should be customized to each project, what I’ve really done is given you an example of how to implement my amfphp communication class. It creates a class with a few custom methods and public variables for easy access to important info. It also shows you how you can dispatch events based on responses from the original amfphp class.

Note, I’ve made some changes suggested to me by Joshua Logsdon, though I didn’t have a chance to get it from him directly (thus, this is still my original code) he did give me the inspiration. These include making the assocMySQL and walkResponse classes static, and making object encoding and debugging constants (like preferences) at the top of the class. I also fixed a bug in the way I was checking for undefined values in extra parameters. All in all this is a much more solid version of the class. I hope you enjoy it.

Download the example and class files: AS3 AMFPHP Class and Wrapper

Download amfphp from it’s website: AMFPHP HOMEPAGE

View the older explanation on using the AS3 AMFPHP class: AMFPHP MADE EASY

ShareThis

Before we get started, here is the example code you can use to follow along.

Step number one consists in creating the actual “*.as” file and placing it in the correct place in relation to your “*.fla” file. (classpath) Generally speaking, people tend to place their class in subfolders that use the “*.fla” as its base folder. For instance, if you .fla is in “C:\wamp\MyProject” then that would be the base folder. The first subfolder tends to be called “com” and the ones after that either the person’s online alias or simply a descriptor name. For instance, using the same base class as above, I would put my classes into a folder with the path of “C:\wamp\MyProject\com\kylebrekke”. This keeps things very simple and clean, and its easy to post your classes online later. All people have to do is drop the “com” folder into their base folder and everything is ready to go. So, assuming you’ve setup your files in this way (and we will use my example for the rest of this article) lets dig a little deeper into the code.

Next you will need a basic frame of code for your class. Each class resides inside what Adobe calls a “package”. This really is just a set of related classes. Note, however, that only ONE class per package is allowed to be public, that is, only one class can talk to the rest of flash, the rest of the classes in the package can only talk to other classes inside the package. Here is the basic look of the starter package:

package com.kylebrekke {
}

Notice how after the keyword package you have a reference to the classpath using dot syntax. This is the same in windows language as “\com\kylebrekke” except we replace slashes with periods. After this we have to give the package a class to work with. We will call ours “testClass” to make it easy.

package com.kylebrekke {
public class testClass extends Sprite {
}
}

We make this class public, so its accessible to our timeline, we call it testClass, and it extends Sprite. Sprite is the preferred base class of Flash CS3 because it comes with everything you could need such as event listeneing and stage capability, but it is not bulky like some other extended classes. Unless you know for a fact you want to extend with something else, I recommend always using the Sprite class.

Next, we have to give our class a constructor function. This is the function that ALWAYS gets called first when someone instantiates your class. You are not required to put anything inside it, but it’s a great place to gather info that you know the class will need, or need set.

Now I haven’t previously mentioned what we will use this class for. I think it will be helpful for demonstration purposes if our class, once instantiated, takes a textfield already on the stage and checks its value, and if it’s a certain value then displays a new textfield. That being said, the constructor is a great place to take the reference to the already created textfield. I’m going to take a big leap in the code and place a bunch of things we need access to within the package.

public function testClass(alreadyOnStage:TextInput, s:Stage):void { // We are passing a reference of the Input Text into a class variable
// so that we can access it from anywhere inside our class
stageTextfield = alreadyOnStage;
stageTextfield.addEventListener(Event.CHANGE, checkText);

_stage = s;

// This custom text can be overriden by the getters/setters
customText.text = "Correct Text!";
customText.x = 250;
customText.y = 35;
}

Notice that the constructor has the same name as our class. Its also declared as public. These two things are vital and they will never change no matter the class. Next, notice the two parameters that are getting passed. One is a reference to the text field that we want to check, and the second is to the stage. This allows us to access things from the timeline that we normally wouldn’t.

Inside the constructor, we assign the parameters to their class variables so that we can access them throughout the class. This is a very typical method especially when you have a reference that you need access to outside the constructor function. In addition, we have added an event listener to the text input so that as a person types we are constantly verifying it against our predetermined text.

I almost forgot to mention how important it is to include to correct imports when working with a class like this. Without them the compiler will throw all types of errors at you that often come in the form of: 1046: Type was not found or was not a compile-time constant: Stage. If you get that error its because you forgot to import all of the necessary files for the compiler.

Here is the next piece of code:

private function checkText(evt:Event):void {
if (stageTextfield.text == "test text") {
_stage.addChild(customText);
dispatchEvent( new Event(correctText) );
}
}

The event listener calls a function that I named checkText. This takes the Event as a parameter, and this event is an object that has access to the target that called it. We could easily use that if we had more than one object calling this function, but since we don’t we will specifically check the text of the Input Text against our “test text” and if they are the same, we will add a new text field to the stage. Notice how I have referenced the addChild() of the stage and not of the class. If I were to forget the “stage” before addChild nothing would show up because the textfield would be added to the stage of our class, not the timeline. Thus, it is a very important piece of code.

The next piece is dispatching an event. You’ll notice that within the conditional statement of checkText, if we find a match then our class dispatches an event. This would be a great way to, for instance, make a “next” button appear on the stage from the timeline. I will show you that code a little further down the page. The important part of the dispatch function is that you should be dispatching an event. You have many possibilities including custom events, in this case we are just dispatching the even by name, but we could also pass on the Event.CHANGE event if we wanted the timeline to access to that as well.

Finally, I’d like to talk about the getters and setters. These are public functions that can make private variables accessible outside the class. The main reason you employ these as opposed to public variables is that you can control whether or not the variable has both capabilities, that is, to be read and written to. In addition, you can make alterations to the variable before passing it out of the class, which can be great leverage. Here is the code for the getter and setter of the customText variable:

public function get customizedText():String {
return customText.text;
}
public function set customizedText(s:String):void {
customText.text = s;
}

In this case, I have not opened up the entire textfield to editing from the user, only the text portion of it. This can protect your code from getting sloppy and unmanageable in the future and it is an important piece of structure to build into all of your classes. Now, my class has a property that can be set very easily simply by doing code that looks like “instance.customText = “new text”;” and instead of “Correct Text” our textfield will show something different.

Ok, finally we can move on to our instantiation code that will be inside of our “*.fla” file. I’ll post all the code since it is not very much and discuss it point by point.

// Import the proper files for the compile
import com.kylebrekke.testClass;// Instantiate the new clas
var test:testClass = new testClass(myInput, stage);

// Add the event listene
test.addEventListener(testClass.correctText, nextQuestion);

// Use a setter to set custom tex
test.customizedText = "Bravo, correct answer!";

// This function is called by the event listener when the
// text is correct
function nextQuestion(evt:Event):void {
// You could place code to move to a next question here
}

stop();

First, we have again imported our code using the correct dot syntax. Right after that we provide the instantiation code. This code takes two parameters, the input text and the stage. The input text MUST be already dragged onto the stage and been given an instance name, in this case I called it “myInput”. The stage variable “stage” will always be the same if you are passing from the timeline to the class.

After that I added an event listener that listens for the custom event of correct text. Notice that the event listener is placed onto “test” which is an instance, but that in order to access the constant’s name that we are dispatching I use the class. This is because the constant that I defined in the class is “static” and does not need to be instantiated. You must make sure that if you follow the same sort of coding that I am practicing here, must use the instance name and the class name in the proper places or the compiler will throw an error. This can be confusing at first, but you’ll get the hang of it in no time.

Just below that I am using a setter to reset the text that will display when user types in the correct text into the Text Input. You’ll see once you execute the code, it should be self-explanatory.

Finally we have the function called by the text. Now I didn’t actually write and code for the next question, but I did let you know that this function would be where you could execute the code for displaying a button for instance that you only want to display once the person has typed in the proper input.

Anyway, that is an explanation of the code piece by piece. I hope you found this useful. Please post any question or comments you may have.

Another great tutorial if you need some help is Senocular’s Beginners Guide.

Here is the example file for download so you can follow step by step and compile it yourself to see how it work. Enjoy!

(Quick update on using root vs. stage)

ShareThis

Well I looked really closely at the pattern of these characters and realized that they pretty much represented either apostrophes, quotation marks or hyphens. There as an entirely different problem with the one essay I’ve posted in French – I just reposted it. I wasn’t about to sit down and hash out all the different foreign characters I used that text. However, I had enough other posts that I didn’t want to find all my old Word documents and repost each one – what a hassle!

I did some research and found lots of people who wanted to teach me how to re-export my MySQL databases or some other headache filled process that, in my opinion, was not actually going to do the trick. Instead, I used a very simple approach – search and replace. We’ve all done it folks, sometimes just inside a Word document when you realized that you’ve misspelled the name of the main character in your latest Shakespeare paper, but this time I needed to use some sql code to achieve the same thing, no CTRL + F GUI.

The way you want to go about doing this is to open up a mysql manager (usually written in php) like phpMyAdmin. Click on the database you want to make the changes to (usually includes the name wordpress in it somewhere) and then click on the “SQL” tab. This page gives you the chance to execute SQL statements on the database. One important note: BE SURE TO BACKUP YOUR DATABASE BEFORE EXECUTING ANY QUERIES OR TRYING TO ALTER IT IN ANYWAY. From this page, insert the following code and execute it:

UPDATE `wp_posts` SET `post_content` = REPLACE( `post_content` , "’", "'" );
UPDATE `wp_posts` SET `post_content` = REPLACE( `post_content` , "…", "..." );
UPDATE `wp_posts` SET `post_content` = REPLACE( `post_content` , "–", "-" );
UPDATE `wp_posts` SET `post_content` = REPLACE( `post_content` , "“", "\"" );
UPDATE `wp_posts` SET `post_content` = REPLACE( `post_content` , "â€", "\"" );

Let me quickly explain the syntax. UPDATE just means that the query isn’t going to add or delete any data, only modify or update it. The next word inbetween the odd quote set is the table name. This is the table typically used by wordpress to hold the post content. SET is another sql keyword which is followed by the field within the table that you’d like to perform the replace function on. Next, REPLACE is the name of the function we are using (remember, we are performing a search and replace). Its parameters are the field name (yes again), the set of letters we are looking for in the field, and finally the set of letters we’d like to actually do the replacing (that is, be inserted into the field).

So, just simply execute those lines of code (you can place them all in the SQL text area at one time as long as you remember the semi-colons as separation) and presto, your content should be good as new.

ShareThis

First things first you need a URLLoader object to load Google Calendar’s xml. This looks like:

var xmlReq:URLRequest = new URLRequest(xmlURL);
var xmlLoader:URLLoader = new URLLoader(xmlReq);

xmlLoader.addEventListener(IOErrorEvent.IO_ERROR, onIOError);
xmlLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
xmlLoader.addEventListener(Event.COMPLETE, xmlGCALLoaded);

To pass the XML’s URL to the URLLoader you need to use the URLRequest class, but its really simple because the constructor takes your URL as an argument so its only one line of code. In fact, if you want it even shorter you could do this:

var xmlLoader:URLLoader = new URLLoader(new URLRequest(xmlURL));

Either way is fine, obviously. Its important to note here that I am using the “full” version of the code that Google Calendar passes to you. If you use the basic you will find it much more difficult to work with the event startTime and endTime. After that be sure to add the proper Event Listeners. The IOError will be thrown if the URL doesn’t return any data (and perhaps for some other reasons too that I don’t know about). The Security Error is thrown when you violate your sandbox (which is a complicated idea, you should look it up if you’d like more info). And of course, the Event.COMPLETE is what is triggered when the data is finished loading, which takes us to the next block of code:

private function xmlGCALLoaded(evt:Event):void {
var xmlData:XML = XML(evt.target.data);
   var ns:Namespace = xmlData.namespace();
}

In this function we take the supplied data (our XML) which is noted as “evt.target.data” and put it into the xmlData variable. Using the method supplied by the XML class we can access the first namespace available to us and place it into the “ns” variable. A namespace in XML is denoted by a tag attribute “xmlns” for instance in google’s opening tag:

This will be useful when we try to access different parts of the XML google has given us. From this first namespace we call any of the properties about the calendar it’s self such as the author or id:

var author:String = xmlData.ns::author;

However, I imagine the primary reason you want this XML data is to access the “entry”, better known as the calendar events. To do this you’ll want to make another namespace (there is a deeper namespace level for accessing events and event properties). In AS3 we find out how many “entry” tags there are, loop through them, and pull the info that we want from it and place them into array or objects or whatever we’d like:

var numEntries:int = xmlData.ns::entry.length();
var xmlObj:Object;

for (var j:int=0; j<numEntries; j++) {
   var gdns:Namespace = xmlData.ns::entry[j].namespace("gd");
   xmlObj = new Object();
   xmlObj.eventTitle = xmlData.ns::entry[j].children().(name().localName == "title");
   xmlObj.startDate = createXMLDate( xmlData.ns::entry[j].gdns::when.@startTime );
   xmlObj.endDate = createXMLDate( xmlData.ns::entry[j].gdns::when.@endTime );
   xmlObj.eventWhere = xmlData.ns::entry[j].gdns::where.@valueString;
   entries.push(xmlObj);
}

We get the number of entries from the first namespace’s entry.length() which is a function provided by the XML Class. Then we loop those entries and for each one find the new namespace (also, this namespace was provided for us in the first tag, I just chose to do it this way instead). With this new namespace we are able to access the inner node of the given entry. The use of the “@” symbol lets us access the attributes of the tags, which is where the data we are seeking is. Anyway, once you have looped all the entries they are available to you in an easy to use array format.

If you’d like to see the full working AS3 Class for the Google XML Parser, you can download it from this link: googleCalendarXML Class

The rar’d version (includes the .fla for compilation) can be found from this link:gCalXML Project

To see a full project that implements this Google Calendar XML Parser, click here.

ShareThis