since vBox has just been added, it has not been fully created and added to display list and hence Label also is not created yet. Infact if we try to access label, we will get null!

So, what's the solution?
One solution is that I define an inline (anonymous function) and attach it as event handler for 'creationComplete'. And in that functon I set the 'str' to Label. something like:

function someMethod() {
// somewhere deep down:
var str : String = "some value";
var vBox : MyVBox = new MyVBox();
tabNavigaor.addChild(vBox);
// this vBox contains a Label, whose text I want to set to 'str'.
vBox.addEventListener('creationComplete' function(e : Event) : void {
e.target['myLabel'].text = str;
}
}

This will solve the problem. But I have always been a bit finicky about 'inlined' functions. I mean what if the value of 'str' changes before the creationComplete has been fired?

Java solves this problem (in case of anonymous inner classes) by forcing that variable to be final so that it cannot be changed, but I dont see such a thing happening for flex.

Therefore, to ensure that this does not happen, we can use the following solution:
1. Define a normal function which has the same code as the anonymous function.
2. Write a AsyncFunction class which 'queues' the exection of a function and its params for later.
3. The AsyncFunction listens for some trigger (in this case 'creationComplete' and then dequeues the queued method and its params and executes them.

Following is the code for AsyncFunction :

package modules.model {
import flash.utils.Dictionary;
import mx.core.UIComponent;
import mx.utils.UIDUtil;
import flash.events.Event;

public class AsyncFunction {

private static const dict : Dictionary = new Dictionary();

public static function callLater(method : Function, triggerEventName : String, 
triggerComponent : UIComponent, ... args) : void {
triggerComponent.addEventListener(triggerEventName,asyncHandler);
var uid : String = UIDUtil.createUID();
triggerComponent.setStyle("___$uid",uid);
dict[uid] = {f : method, params : args};
}

private static function asyncHandler(triggerEvent : Event) : void {
var uid : String = triggerEvent.target.getStyle('___$uid');
if(dict.hasOwnProperty(uid)) {
var method : Function = dict[uid].f as Function;
method.apply(triggerEvent.target,dict[uid].params); 
// rollback:
triggerEvent.target.removeEventListener(triggerEvent.type,asyncHandler);
triggerEvent.target.setStyle('___$uid',null);
delete dict[uid];
}
}

}
}

Then, in our current situation just do this:
function someMethod() {
// somewhere deep down:
var str : String = "some value";
var vBox : MyVBox = new MyVBox();
tabNavigaor.addChild(vBox);
// this vBox contains a Label, whose text I want to set to 'str'.
AsyncFunction.callLater(setUpLabel, 'creationComplete', vBox, vBox, str);
}

private function setUpLabel(vBox : MyVBox, str : String) : void {
vBox['myLabel'].text = str;
}

That's it! Just one line of code : AsyncFunction.callLater(setUpLabel, 'creationComplete', vBox, vBox, str);
and you are guaranteed that your code will execute fine.

I have taken the liberty of taking one of my old posts and adding to the Adobe Flex cookbook.

Check it out..
http://www.adobe.com/cfusion/communityengine/index.cfm?event=showdetails&postid=11083&loc=en_US&productid=2

This is the first time I've looked at this particular Flex book and I have to say, I'm impressed.  It's highly illustrated (in vivid color) and seems very well organized.

I just ordered mine! :)

You can download chapters 13 and 14 from here.  The chapter on Styling was what made me order it.  Very useful.

The Oreilly link to buy the book is here

The Amazon.com link is here

He has done it again by releasing a framework for visual object-based editor applications, called "moccasin".

Hopefully I will get a chance to take it for a spin soon...

Check it out…
http://code.google.com/p/moccasin/

• Episode 1 - Setting Up a Flex Project
• Episode 2 - Using the Flex Debugger
• Episode 3 - Understanding Data Binding
• Episode 4 - Creating Component Properties
• Episode 5 - Using XML with Flex
• Episode 6 - Drag and Drop Lists
• Episode 7 - Understanding Events

The pace is good - Jeffry waste very little time jumping right into the good stuff.  If you are looking for a  place to get some Flex 101, this is a good starting point.

GameBoard.mxml
This piece is the real workhorse of the game.  It houses not only the board where the pieces are laid out, but also the game logic itself.

Was that the best decision?

Probably not.  If I wanted to swap out the game rules but keep the same pieces, I couldn't do that.  It's not so common with Tic-Tac-Toe, but think of a card game.  One deck of 52 cards can play an almost infinite number of games.  Would it make much sense to put the Solitaire logic right inside the CardDeck class file?  Nope, it surely wouldn't.  I was in a hurry though so I did.

Let's start off with the states.  You'll notice there's only 2 states:

1. The Base State - Here I have the the lines of the board drawn out.  You'll see that I went the cheap route regarding the grid of the game board.  No fancy drawing APIs and no background image.  Just four rules (2 vertical and 2 horizontal) make up the grid.  You can see that I also manually lay out the 9 instances of the GamePiece class, giving them descriptive id values such as "TopRight", "BottomLeft", etc.  I'll explain why later.
2. "BlankSlate" - For this state, I pretty much remove the game pieces and the grid that "houses" them.  In their place, I put a label up that gives the title of the game and a button that resets the board back to the base state.

Why is the BlankSlate not blank?

It was initially, hence the name.  Then I thought, "Well, I need to tell the user what the name of the game is and let them start it."  So I added those items to the blankSlate state.  I should have either renamed the state or created a new state based on blankSlate.

<mx:Canvas ...other code... currentState="blankSlate">

By default, I set the currentState of the GameBoard class to blankSlate in the root Canvas tag.

<mx:Button x="134.5" y="216" label="Start Game" click="reset()"/>

If we take a look at the button we add in the blankState, we see that I call the reset function when clicked.  Let's take a look at that function.

public function reset():void
{
     resetPieces();
     lastPiece = "O";
     winnerFound = false;
     currentState = "";
}

It calls a function nameed resetPieces().  That function just calls reset() on the individual pieces to make sure they're ready to be played.  It preps the board by setting the properties back to values that we'll see used later.  It also sets the currentState back to default, so that we get the board and pieces back on the stage.

<ns1:GamePiece x="4" y="4" id="TopLeft" click="pieceChosen(TopLeft)">
</ns1:GamePiece>

If you look at the pieces, you'll see that there's a click event handler.  It calls the pieceChosen function.  Let's take a look at that function.

public function pieceChosen(piece:GamePiece):void

In the declaration, we see that it expects a GamePiece to be passed into it.  Therefore, each piece passes in a reference to itself.

NOTE: We can't use the this keyword to pass in a reference to the GamePiece instance.  This is because in the MXML, the this refers to the containing class (in this case, GameBoard) and not the tag that has the handler code.  Confusing? Try this.  Look at the click handler.  You give it a function and that function is not in the GamePiece class, but rather the parent class.  Same thing with the this keyord.

Let's get back to the pieceChosen function.

var message:String = new String();

We setup a message variable to hold a message for the end.  This will be used to tell the players who won or if there was a tie.

if (!piece.used && !winnerFound)

Our first statement checks to make sure the piece is playable and that no one has won the game yet.

if (lastPiece == "O")
{
     piece.currentState = "X";
     lastPiece = "X";
} else
{
     piece.currentState = "O";
     lastPiece = "O";
}
piece.used = true;

It sets the piece to the appropriate state based on the last piece played and resets the lastPiece value.  After that, it marks the piece as being used.

if (checkForWinner())

Next, it checks for a winner.  This function is probably the ugliest of the code base for two reasons:

1. It's horribly hardcoded.  You must know every possible winning combination and hard code it.
2. It's terribly inefficient.  It checks every possible combination in the same order each time, even if pieces that aren't part of the winning combination weren't played this turn.

Let's take a look at a little snippet from the checkForWinner function.

if (TopLeft.currentState == lastPiece && MiddleLeft.currentState == lastPiece && BottomLeft.currentState == lastPiece)

As you can see, whether any of the -Left piece got played just now doesn't really matter.  It's gonna check if those 3 pieces magically got turned on and won the game.

The logic inside the if statements isn't so bad except the first line.

TopLeft.currentState = MiddleLeft.currentState = BottomLeft.currentState = lastPiece  + "Winner";

Surely, there's a function (let's call it checkCombination) that I can extract from that logic.  Because if I change the name of the winning state, I'll have to go through and modify it in 8 places.  Regardless, this works for changing the winning pieces to their proper winning state.

winnerFound = true;
return true;

The two lines above our nice, but again we can detect the winnerFound value in the checkCombination function I propose above. We can then have that new function return our true/false value for us.  (I'll do that in the next iteration.)

If the checkForWinner function comes back true, than we're done.

message = "Player " + lastPiece + " won. ";

We set the message to the proper winner in preparation for the announcement.

What if no winner was found though, should we just let the next player go?

At first, that's what I did.  Then it dawned on me, "What if that's the last playable piece?  It's a cats game and I gotta let the players know."  Therefore, I created the checkForTie() function.  It checks for one thing only: Are all the pieces used?

if (TopLeft.used == true && MiddleLeft.used == true && BottomLeft.used == true && TopMiddle.used == true && MiddleMiddle.used == true && BottomMiddle.used == true && TopRight.used == true && MiddleRight.used == true && BottomRight.used == true)

Once again, not efficient and surely not pretty, but it gets the job done.  I need to rewrite that so that it's a nice iterative loop that inspects each piece programmatically vs via a hardcoded list.  It then returns true or false depending on if all the pieces are used or not.

Back in the pieceChosen function, we either continue playing the game or set the message to tie.

Alert.show( message + "Would you like to play again?", "Game Over", 3, this, playAgainHandler);

Lastly, if we haven't moved on to the next turn, we pop up an alert. Here we display the message and ask if they want to play again.  The playAgainHandler takes care of their choice.

reset();
if (event.detail==Alert.NO)
{
     currentState = "blankSlate";
}

We reset the board in either case.  Then if they don't want to play anymore, we return the board to the blankSlate state.

That's it!  There's the entire code for version 1 of my Tic-Tac-Toe game.  It's time to create Version 2!  Stay tuned!  It'll mainly be optimizations to the code base vs a new look and feel.  The latter won't likely come until version 3.

Thanks,

Shaleen Jan

Before I get to that, it makes sense to discuss a little bit about namespaces. Namespaces are essentially used to limit the scope of methods, classes, variables or constants. One could say that they are used to avoid potential naming conflicts that may arise with other components having the same names. Namespaces are associated with a Uniform Resource Identifier that identifies the namespace. You can find more information on namespaces here.

Now, mx_internal is one such namespace that the Flex SDK uses to handle internal data. Just like all other namespaces, mx_internal contains a lot of variables which we can use in our code. To know which variables belong to mx_internal, dig into the Flex SDK code and you can find them. An example of the use of mx_internal can be found in the TextInput.as class of the Flex SDK. Some commonly used mx_internal variables/methods of this class are:

/**
* The internal subcontrol that draws the border and background.
*/
mx_internal var border:IFlexDisplayObject;

————————————————————————————–

mx_internal function get selectable():Boolean
{
return _selectable;
}

To you the mx_internal namespace, just import it and let Actionscript know you are using it.

import mx.core.mx_internal;

use namespace mx_internal;

You are then ready to use the variables of mx_internal.

Of course there are some issues with using this namespace. First there is no code hinting in Flex Builder when using this namespace. That means you have to dig yourself to know which variables are present in the namespace. Second, Adobe has mentioned this warning with using the namespace.

“This namespace is used for undocumented APIs — usually implementation details — which can’t be private because they need to visible to other classes. APIs in this namespace are completely unsupported and are likely to change in future versions of Flex.”

That means that the next time Flex updates happen and your code doesn’t work as it is supposed to, don’t blame Adobe.

Thanks,
Shaleen Jain

Com ADOBE FLEX disponibilizaremos ao mercado brasileiro aplicativos virtuais ricos para internet com alto impacto visual, prático e rápido.

Acesse o link a seguir e conheça agora mesmo:
http://www.cerebrum.com.br/revenda_construtor_flex
email: contato@cerebrum.com.br
senha: 123456

IMAGEM ILUSTRATIVA DO PAINEL DO REVENDEDOR DE LOJAS VIRTUAIS:

IMAGEM ILUSTRATIVA DO SISTEMA:
- Indicador gráfico de clientes pessoa física por sexo;
- Indicador gráfico de quantidade de clientes por estado;
- Indicador gráfico de como conheceu o nosso site;
- Indicador gráfico de faturamento mensal por cliente;

IMAGEM ILUSTRATIVA DA GRADE DE DADOS DE CLIENTES CADASTRADOS:

IMAGEM ILUSTRATIVA DA GRADE DE DADOS DE LOJISTAS ATIVOS:

Ficou supreendido?

Este é o começo de uma nova era, bem vindo ao mundo novo.

Em breve mais novidades - Aguarde!!!

There are  3 files that make up the complete game (right click to view/download the source) :

1. Main.mxml - This has the Application tag
2. GamePiece.mxml - This is the X/O game piece
3. GameBoard.mxml - This is the tic-tac-toe gameboard

I'll go over the 3 files, explaining logic on why/what from both the Flex and gaming perspective.

Main.mxml

The Flex logic is pretty simple.  It contains the Application tag, so my app can be built.  It also houses the GameBoard class.

Why not make GameBoard the Application Class?

There are two reasons why I didn't do this.

1. I wanted to be able to swap out the gameboards.  What if I get to the point where I have 10 different types of the Tic-Tac-Toe boards?  If I built it this way, I can just remove the GameBoard.mxml child from the Main.mxml and add some new, fandangled game board class in its stead.
2. I also wanted to be able to swap out the main tag.  I haven't done much AIR programming, but I remember it using WindowedApplication as it's root tag.  Again, I'd have to transport any business/game logic to this second root application class if I didn't do this separation up front.

GamePiece.mxml

The brains behind this part of the game app is actually states.  I wanted to use states for a few reasons:

1. I was using Flex and states are an integral part or Flex.  Why not take advantage of this powerful, built-in mechanism?
2. I didn't want to code much.  States can be whipped up very quickly inside of Flex Builder using the design view. It took a few clicks and little typing to create the 4 states (5 if you count the blank one).
3. I was forward thinking to when I was gonna style my class.  One of the things I think is very underused is the Flex Component Kit for Flash.  Therefore, when I go to skin the game piece, I'm going to use Flash to hopefully create some wild game pieces.  If I code my Components in Flash correctly, I won't need to change any logic.  They'll just work auto-magically in my game.

Let's take a look at the states.  They're incredibly simple, but worth going over.

<mx:State name="X">
     <mx:AddChild position="lastChild">
          <mx:Label x="10" y="10" text="X" fontWeight="bold"
            fontSize="72" width="98" id="label1" height="98"
            textAlign="center" />
     </mx:AddChild>
</mx:State>


In the first state above, we see that I add a Label to the component.  This is the same label that I'll use for each of the other states.  I give it some styling options and a default value of "X".

<mx:State name="O" basedOn="X">
     <mx:SetProperty target="{label1}" name="text" value="O"/>
</mx:State>

Next, I base the "O" state on the previous one.  The only thing I do is change the text propety of the label to "O" instead of "X".  Otherwise, a game of all Xs would be pretty boring!  :)

<mx:State name="OWinner" basedOn="O">
     <mx:SetStyle name="backgroundColor" value="#42E303"/>
</mx:State>

Next, I needed a way to alert the players that a winner had been found.  The quickest way to do this I figured was by modifying the background color.  I figured green was a good color because it's the color of money ( "You won!" ) and of envy ( "Sorry, loser. Aren't you envious of my skills?" ).  I made a winning state for the "O" piece.

<mx:State name="XWinner" basedOn="X">
     <mx:SetStyle name="backgroundColor" value="#42E303"/>
</mx:State>

And for the "X" as well.

The Script tag for the game piece is pretty small.  I was suprised by how little AS code I needed to add.

public var used:Boolean = false;

I created the used property, because I would need to know its value during 2 scenarios:

1. Has someone already played this piece?  If so, then ignore when someone picks it again.  If not, then let the game engine work its magic.
2. Have all the pieces been played?  Is it a "cat's game" ?  If so, then let the game engine know.

Someone has already commented to me that instead of a used property, I could have just checked the currentState.  If it was it was not the base state, then it was available.  While that might be true, I wanted to leave the possibility of toggling through various states before the user chooses.  Something that would have been tougher without the used flag.

public function reset():void
{
     used = false;
     currentState = "";
}

The reset function is the only method I added.  Upon further review, I probably didn't even need it as the used property could have been reset in the state.

I'll explain the GameBoard code in other post as this one is getting pretty long. Most of the game logic takes place there, so it'll take a bit to explain.

Feel free to comment or ask any questions if I didn't make certain parts/decisions clear.

If you are a software developer living in the Tampa area interested in Adobe Flash, Flex and AIR, please consider joining me at the inaugural Tampa Flash, Flex and AIR Developers Group meeting on Tuesday, October 7th at 7pm.  The meeting will be held at the Art Institute of Tampa at 4401 N. Himes Ave Tampa, FL.  We already have nearly 50 people signed up so this will be a great opportunity to network with other local developers.  There is no cost to attend.

I am preparing a presentation titled, "Adobe Flash, Flex and AIR - What, Where and Why", an overview of Adobe Flash, Flex and AIR from the ground up.  I'll be showing a lot of demos and giving out some Adobe goodies...so be there!

For more information and to RSVP, please go to http://www.tffadg.com

Adobe Flex Builder 3.0 is an Eclipse-based IDE for developing RIAs on Adobe's Flash platform and the open source Flex SDK. Although you could use any text editor to cobble Action Script and MXML into a Flex app, Flex Builder 3.0 delivers a streamlined experience for RIA development and Flex project code management.

Flex Builder provides easy graphical tools for laying out rich GUI's that creates an MXML code. It excels for making real-time dashboards and the credit goes to graphing and charting widgets.

What draws attention is better visual layout tools and more control over CSS, new wizards for WSDL introspection and back-end data connectivity, and plug-ins that augment workflow between developers and design teams running Adobe Creative Suite 3 applications (such as Flash, Photoshop, Illustrator, and Fireworks). The WSDL introspection wizard makes it easy to pull together Action Script and Web services inside Flex, while the CS3 plug-ins provide MXML-savvy templates that allow CS3 users to create Flex controls with familiar tools, versus learning to design directly in Flex.

Flex 3.0 in building RIA goes a long way towards getting higher-quality applications into production faster. Other improvements, such as real-time charting and advanced data grids, help give your Web applications a better extent and extra shine.

The Flex Builder 3.0 IDE builds the typical package, including code and graphical views, a controls palette, project hierarchy and debug views, and a properties panel. Anyone familiar with Eclipse will feel right at home. Visual Studio developers may miss such features as the ability to split code windows or to simultaneously display code and layout windows as in Dreamweaver, but these are minor issues. One can easily jump over to UI creation, dragging components for layout, navigation, and data access from the pallet to the work canvas.

QBit systems is gearing up the Flex projects for the Web (Flash player) or the desktop (running on AIR) for building RIA. QBit Creates AIR projects for revealing additional pallet components for working with native file systems (tree, list, history) and for embedding an HTML browser into the application which is seemingly useful for quick import and redeployment of existing Web site assets to the desktop.

Courtesy: QBit Systems

If you have been developing web based applications which require login, I am pretty sure you would have come across this question - How do you safe-logout the user if the user just closes the window/tab when there is unsaved information on the user’s screen?

My current Flex project requires the user to login and logout. And most of the time, the users never use the logout button. They just close the browser and walk away! So, I needed a mechanism which will warn the user that there is unsaved information before closing the window. The way, I got this working was by using the FABridge.

In the application, I had an isAppDirty boolean.

public var isAppDirty:Boolean = false;

This variable is set to true whenever there is unsaved information in the application from any view. Now, add a few lines of javascript to your html wrapper. You can do this to the html file in the html-template folder.

————————————————————————————-

window.onbeforeunload = confirmExit;

function confirmExit(){
var flexApp = FABridge.flash.root();
var appDirty = flexApp.isAppDirty();

// note that the isAppDirty var is called like a function. This is done deliberately. Thats the way FABridge works

if(appDirty == true){
return “The configuration changes performed in this session have not been saved. If you wish to save the config, please click CANCEL.”;
}
}

————————————————————————————-

Do not forget to include the FABridge libraries in the html - 

This also means that I have a more difficult path ahead of me, with my Flex Builder trial license already expired.

Fortunately, it's not that hard to setup basic mxml auto complete functionality with a plain Eclipse installation with XML support.

First we need to define the .mxml file association in Eclipse (Preferences > General > Editors > File Associations).

Then map this file association to the XML editor (see screenshot below).

Add the Flex 3 schema (flex3.xsd) to Eclipse's XML catalog.

Try creating a test mxml file and open it from Eclipse.

Test.mxml

[sourcecode language="xml"]



[/sourcecode]

You will most likely receive an Unsupported Type error.

Complete the process by adding the content type definition (shown below).

Close the mxml file and re-open. You should now be able to see the auto-complete functionality in action.

Hope this helps and let me know if you encounter any problems.

If you're a student or a full time Flex developer, you shouldn't even bother trying out the outlined steps.

Flex is free for students. But, if you make a living out of developing Flex apps, you might want to consider buying a license.

Related posts:

• Setting Up Eclipse For Flex 2

…one such situation recently happened to me when I had to deploy an Adobe Flex solution using undigested Runtime Shared Libraries, Flex Modules and Data Visualization in one cool cocktail… after having been unable to rid myself and the solution for the annoying Flex watermark declaring that the chart was shown with a graph compiled with non-registered version of the Adobe Flex SDK, I consulted good ol' Uncle Google for an answer…

If you don't know what I am talking about… this is the watermark I am talking about… displayed in grayed out letters displaying "Flex Data Visualization Trial"…

Quickly I came to the JIRA entry for the problem stating that it was not a bug if you remembered to load the Framework RSL prior to loading the Visualization RSL…
http://bugs.adobe.com/jira/browse/FLEXDMV-1756

However, this didn't change a thing as I was already loading the framework prior to data visualization – I did however try, and yes, it wasn't the solution…

Left with no official solution and a deadline I didn't want to break for no one, I quickly had to become innovative and ingenious… I therefore dived down into the source code of the Adobe Flex SDK and eventually found my way to the sources for the data visualization components… once I had created an Adobe Flex Class library for the sources, compiling a SWC and referencing it from my application was easy.

To my great satisfaction, the homebrewed SWC proved to have no watermark when loaded as undigested RSL from a Flex module !

This solution not only solves the problem with the watermark, but it also allows me full control of which classes to include in the library allowing me to effectively cut the size of the visualization library in half based on the classes necessary for this particular application.

I have read the EULA from Adobe, and I don't think I am in conflict when doing this… however, if anyone at Adobe reads this, please advice otherwise in case.

Please don't hesitate to write me if you problems getting this solution to work for you…

PS… off course I have a licensed edition of Adobe Flex Builder, so this is not the issue here.

But let us first know what is a statically linked application and a dynamically linked application

Statically linked application - Flex framework code and the application code will make the SWF file increasing the size of the SWF file

Dynamically linked application - Flex framework code will be added dynamically to the SWF code thus reducing its size
If you want to check the result of the above mentioned feature live the follow the steps

1. Create any flex application with some code

2. Get the true size of the application - Follow the steps
1. By default, Flex Builder adds debugging information to SWF files, so in order to see the true size of the application,
turn off the debugging information
2. To do this, add -debug=false to the Additional Compiler Arguments section of the Flex Compiler Properties dialog box

3. Check the size of the application by viewing the properties of the application’s SWF file created in the bin directory
Note down the size

4. Now go to Project Properties (right click on Flex project and select properties), then choose the Flex Build Path properties
and click the Library Path tab

5. In the Framework Linkage pop-up menu, change the link type from “Merged into code” to “Runtime shared library (RSL).”
Click OK to save the changes.

6. Build the project

7. Now check the file size of the SWF file. You will definitely be surprised!!!!

266268  bytes - BEFORE
- 125020  bytes - AFTER
——
141248  bytes - DIFFERENCE IN SIZE

Important things

When you choose the option to use RSLs, all of the debug information is removed.
So you can easily switch between a statically linked application and a dynamically linked application just by toggling the option in the Framework Linkage pop-up menu from “Merged into code” to “Runtime shared library (RSL).”

The framework RSL is the only RSL that is configured by default in the flex-config.xml file because every Flex application uses over 100K of framework classes. If you do add RSLs, the compiler will always load any RSLs you specify whether or not they are used by your application.

For more information on this check the following link
http://www.adobe.com/devnet/flex/articles/flash_player_cache_print.html

Tym razem nowa wersja wprowadza duże zmiany w całym workspace. Do dyspozycji jest nowy Timeline, którego działanie przypomina linię z prawdziwych programów do animacji, narzędzie do tworzenia kości obiektów pozwalające na łatwe tworzenie postaci i nie tylko. Naszym obiektóm możemy nadać pseudotrójwymiarową behawioralność, oraz działać na tweenie jak na obiekcie, tj. przesuwać, zmniejszać, zwiększać, obracać, co do tej pory było bardzo trudne i uciążliwe. Workspace, podobnie jak np. w Eclipse, można przełączać pomiędzy kilkoma trybami, a każdy z nich ma domyślne ułożenie narzędzi, odpowiednia dla animatorów i developerów. Panel properties nie znajduje się już u dołu ekranu, teraz jest ułożony w pionie co ułatwia edycję właściwości i przypomina on trochę ten z FlexBuildera. To tylko część nowości, które przedstawił Lee, zresztą to trzeba zobaczyć w akcji.

Flash CS4 staje się nowym narzędziem, które wnosi sporo nowych innowacyjnych rozwiązań w stosunku do poprzednich wersji. Mam nadzieję, że praca z ActionScript będzie równie przyjemna co animacja.

For as long as I can remember, I've gamed (specifically the video kind).  Before I got married, I spent almost every birthday I can remember at Chuck E. Cheese's (even my 21st!)  To me, birthday equated to gaming.  In addition to those special days, I have a lot of memories in life associated with gaming:

• When I was 6 or 7,  I remember me and my dad going to our frequent hangout, an arcade down the street.  It was actually a miniature golf course, but we never did anything but game.  We'd play Vanguard together.  As you can see by this image, it had this unique setup.  It was one of the first games I can remember that had multiple buttons.  My dad would drive (use the control stick) while I sat shotgun (took control of the 4 direction shoot buttons).  Oddly, I think this contributed to my sense of it being okay to take the back seat for the greater good.  As long as the team wins, it doesn't matter which position you play.
  
  
• A few years later, I got my first video game system: a ColecoVision.
  
  
  
  
  It was friggin' sweet.  My friends and cousins had the other consoles, but this one was mine.  My parents rationed my usage, using it as a reward for good behavior.  We only had one TV, so it was a simple way to ensure the TV wasn't hogged up by me and Donkey Kong.  I remember my mom teaching me a life lesson with that system.  I didn't want to clean up once, so she put the Coleco away.  About an hour later, I went to her and said, "Mom, I'm sorry. I'll clean up.  Is it too late for me to still play though?"  She said, "No, if you clean up like you're supposed to, you can play games."  Ever since, I've known that if I screw up, a sincere apology and demonstrable steps of action will usually rectify the situation.
  
  
• When I was 12 or so, my brother (10 years younger than me) realized that the controller he was holding was not actually the one making Mario move.  He cried until I gave him my controller.  He still hasn't let go of that proverbial controller 2 decades later, as he's an avid video gamer.  (For a groomsman gift at my wedding, I got him a framed copy of Super Mario Bros. with a NES controller)
  
  
• When Myst came out, I didn't sleep or leave the house until I finished it.  It was an amazing game that completely blew away any previous gaming experience.  Then the sequel Riven came along and I was just amazed that I could literally be transported to another world.  Unfortunately, it also ruined games for me for a long time.  Those games were an experience like no other.
  
  
  The controls were simple: Point mouse. Click.
  
  
  The story was unique: It was a narrative, yet still up to the player to unravel in the order he chose.
  
  
  The imagery was lifelike: No game had graphics of that high quality.
  
  
• I've waited 24 hours in line for both the PlayStation 2 and PlayStation 3.  The PS2 line I waited in just to hang with my best friend, Miguel.  He was the diehard; I wound up selling mine to my uncle.  I was in the Bay Area for the PS3 launch and knew the Metreon would be a blast to wait at (and it was).  Plus, I wanted to fork over my cash to support Sony's choice to go with the Cell processor.  That choice was a risk that I wanted to make sure got my vote of confidence via my hard earned cash. It's now the primary gaming vehicle for me and my son.
  
  

I've often thought that gaming is where I'll make my big mark in business. This is because, as you can see above, it was such an integral part of my life.  I have never been a hardcore gamer, but it was definitely a favorite past time of mine. All the interests I have ever had in life (programming, CGI, story telling, film making, competing, mental puzzles, etc.) point to game making.  It's the only medium that pulls from all of those skill sets.  It's a unique industry in that, while over 30 years old, it's still pretty much in its infancy.  Most games are cookie cutter and go after the same demographic.  As processing power increases and the number of cores per chip goes up, it'll be very interesting to see what affect that has on this medium.

So, what took me so long to get into game making then?

To be honest, it was my wife.  She never said I couldn't get into game making and she never forbade me from playing them, but she expressed disdain for the industry.  I can't say I blame her.  Most games out there are crap.  They're cookie-cutter clones or sequels to the same tired First Person Shooter and/or Massively Multiplayer Online Game.  Games like Braid exist, but sadly are not the norm.  Out of respect for her views on the industry, I refrained from playing games, much less making them.

Has the industry changed then?

No, sadly it has not.  However, I've cut my chops in business.  I've shown myself and my wife that it's possible for a two man shop to help change an industry (i.e. with John as my partner in 360Conferences we're helping change the conference space) .  With the right resource utilization, I feel I can have an effect on this industry and help it expand beyond it's vicious duplication cycle. Unlike 360Conferences, which serves a niche market, I could have a more "mainstream" product in the gaming business.

Does this mean I'm quitting my day job and dropping 360Conferences?

Ha, ha.  No, not quite.  While I have many traits that I think will help make me a successful game maker, I've yet to actually make any games.  I don't know much about gaming theory, etc.  It will take a few years before I can even think of entering the business as a serious player of any kind.

No, instead I'll take my first baby steps into this medium.  I'll start by using the programming language that I'm most familiar with: Adobe Flex.  I've seen what people like PlayCrafter can do with Flex in the gaming realm. Therefore, I'm confident that it will suffice for my learning needs for quite some time to come.

Stay tuned to this blog as I'll be sharing not only my experiences, but also my code.  This way you too can learn to make games, but let me do all the legwork!

Bom, sábado dia 20/09 participei de um treinamento em Flex, pela empresa que trabalho. O palestrante foi um consultor da adobe Fabrício Manzi.

Sobre a palestra irei escrever depois, sobre o CS4 ele falou que vai ser lançado amanha a versão final do Creative Suíte CS4. Toda a interface e disposição das opções do novo CS4 está diferente. Uma coisa muito legal que agora está no Flash CS4 é a possibilidade de você trabalhar com 3D, com certeza essa é uma nova ferramenta muito útil e interessante.

A Adobe apresentará o novo Creative Suite CS4 no dia 23 de setembro, através de uma transmissão de vídeo ao vivo pela internet.

Essa nova versão deve vir com um visual totalmente refeito, e a empresa espera torná-la a mais revolucionária desenvolvida até hoje.

Segue link para broadcast de lançamento da suíte Adobe CS4, próxima 3ª feira, 23/09.

http://adobe.istreamplanet.com/?trackingid=DRIAC

Após colocar os dados pessoais, selecione:

• North America - 9:00 a.m. Pacific para ver o evento às 13h (horário de Brasília)

ou

• North America - 9:00 a.m. Eastern para ver o evento às 8h da manhã (horário de Brasília).

Abraço a todos e até o próximo artigo.

Flex has always provided rich functionality for customizing the appearance of its built-in components. You can start with the default appearance of the components and extensively tweak their properties through CSS styles, or you can completely replace the default appearance by drawing custom vector or bitmap skins using visual design tools, such as the tools in Adobe Creative Suite.

In today post, i will show you some tutorials where you can find information, tips and techniques to get your Flex application look better. You might want also to check my previous Flex Skinning Post with more Tutorials.

1 - Flex Quick Starts: Building an advanced user interface

A quick how to tips article pointing you several examples of skinning in Flex.

2 - Skinning in Flex: Beauty is Only Skin Deep

In this Yahoo Flash Developer article, will be demonstrate how to create a simple skin element in Flash for use in Flex Builder. With this skin, you will style the Button element with our own simple color design.

3 - 10 Ways to Skin an App

Awesome article from the very known flex skins site scalenine, pointing 10 techniques for skinning.

4 - Degrafa component skinning (Video Tutorial)

A screencast walking through the process of creating custom skins using Degrafa, Showing you how to get set up with the Degrafa SWC and how easy it is to start creating via Degrafa MXML.

5 - Flex Skinning: Introduction w/ Buttons

2 parts extensive tutorial, explaining you how to skin a button component.

6 - Using FlexBuilder 3 and Flash CS3 to Build Your Skin in Flex–KingnareStyle

A step by step tutorial teaching you how to build your beautiful skin.

7 - Jumping Into Skinning with Flex 4 , Gumbo (Flex 4) Skin with Transitions

Again two great articles from the king of Flex Skins (scalenine.com), this time on the next coming release of Flex 4;

8 - Designing Flex 3 skins and styles using Creative Suite 3 and Flex Builder 3

Great Adobe Dev Tutorial, by Narciso Jaramillo that provides you an overview of the CS3 extensions and Flex Builder 3 features that automate the skinning and styling workflow.

SlideRocket is a Flex-based site for designing and presenting slide presentations both online and offline (using Adobe AIR of course!).   This is one of the best examples of what RIAs are all about.  It doesn't get much more rich than this!  Note - many of the incredible 3D effects are utilizing PaperVision3D.

From their website - "SlideRocket is a rich Internet application that provides everything you need to design professional quality presentations, manage and share libraries of slides and assets, and to deliver presentations in person or remotely over the web."

A few months ago, David Tucker had the opportunity to interview Mitch Grasso, CEO and co-founder of SlideRocket.  In the interview, David got some great insight into the making of SlideRocket.  The interview can be found here.

Below is an embed of their demo presentation.  Click on a few slides to see some of the cool effects, embedded video, animation, etc.

[vodpod id=Groupvideo.1574681&w=500&h=411&fv=id%3D7b681d5e-aada-4444-9aa5-6a5bb1e5aa67]

We've partnered with several online software as a service companies to deliver the Workplace experience in such a way that these 3rd party developers can sell their apps and we will provide them a place where end-users looking for QuickBooks connected web apps can buy them and will allow them to share data that is housed on their backoffice machine.  We've created a shopping mall for web products that help people share info...

This has been one of those "soul of a new machine" or "dreaming in code" years for me.  It's really awesome to be a part of the current conversation...solving the socialization of business data issue while the conversation is still in debate.    As Quicken, Turbotax and QuickBooks have shaped a generation of people on how to use their computers to manage their finacial lives and businesses, I think Intuit, QuickBase and Workplace are once again shaping how people share and interact with data.

Can you tell I'm excited?