Esta app tem uitas classes e interfaces, por isso não fica prático mostrar o código aqui, por isso dê uma olha a no código, ok?

Se você tiver sugestões (não dúvidas), comente.

View source here.

Aqui você vai para o post original da DClick.

Mas eu estão tããããão entediada hoje, que resolvi me dar uma folga. Então aí está. Aproveite :0)

No zip você vai encontar os fontes do Flex e o fla com os dois MC, como mostra na imagem abaixo.

As imagens mostram a biblioteca do fla

E este é o script do frame 1 da timeline do fla. Não tem documetn class, mas poderia ter…

O código no Flex também é super simples…

Baixe os fontes aqui

PS. Esta solução não usa o método addFrameScript. Se você quer tentar usá-lo, veja http://blog.tygate.com/?p=194

So, I´m posting a Flex version of this app. It´s based on Matrix operations, quick and dirty. Maybe someday I will use a tree structure to represent the relations between continents, contries, states and cities but it wont be now.

The app has view source, as it always does. There´s a flash version here.

Well, earning money was never my strong point :0P

This is a print screen for the first

And for the second

No, I couldnt figure out how to make wordpress allow me to show swf on this page :0P

/*****************************/

[code lang="actionscript"] package com.util{
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;

public class ObjectOrdering{

public static function bringToFront(object:DisplayObject):void{
var father:DisplayObjectContainer=DisplayObjectContainer(object.parent);
var brothers:int=father.numChildren;
father.setChildIndex(object,brothers-1);
}

public static function sendToBack(object:DisplayObject):void{
var father:DisplayObjectContainer=DisplayObjectContainer(object.parent);
father.setChildIndex(object, 0);
}
}
} [/code]

This version is more complicated than the previous, which is pretty good in my opinion. The good about it is that it implements the Observer pattern and some interfaces that tie more elegantly the triad.

This is an AS3 version of Moock’s MVC Clock.

See the app here (view source enabled).

The flash app is coming soon (I mean, two or three days).

/***********************************************/

Essa é a segunda parte de uma série de três posts que eu pretendo escrever.

Esta versão é um pouco mais complicada que a primeira, que é bem boa, na minha opinião. O bom desta é que ela implementa Observer e algums interfaces, de forma que a tríade fica mais elegantemente composta.

Esta é uma versão AS3 do MVCClock do Moock.

Veja o app aqui (view source habilitado).

O app em flash já vai ficar pronto (dois ou três dias).

The 3rd part will have Commands also.

Veja o arquivo do flash

Download the flash files here.

See the flex app here (view source enabled).

/******************************************/

Certo, essa é a primeira parte de um post que deve 3 três partes. O primeiro exemplo mostra uma visào muito simples de uma implementação MVC, com falsh e flex. O único padrão implementado é Singleton, usado para disparar eventos. Eu me inspirei no exemplo do Eric Feminella, que pode ser visto aqui: http://www.ericfeminella.com/blog/2006/10/08/as3-model-view-controller-implementation/ 

A segunda parte também vai ter um Observer, como a implementação super elegante do livro ES2 do Moock (o melhor livro de AS de todos os tempos, na minha modesta opinião).

A terceira parte também vai ter um Command

Veja o arquivo do flash

Baixe os arquivos do flash aqui.

Veja o app em flex aqui (view source habilitado).

Estava eu trabalhando no Flex, construindo uma interface super bacana para um programa que estou fazendo. A idéia é ótima, olha só:

Daí? Bala, né?

Pois então, imagina que esse mapa aí atrás tem um navegador, zoom e pan,  e que os balõezinhos acompanham o mapa à medida que tu interage com ele – cara! – e não aumentam de tamanho! Pois eu espremi o meu cérebro do tamanho de uma cereja e me saí com um super-método de transformação de coordenadas que não é uma gambiarra! Eu tava aqui me sentindo o máximo – tô aqui cheia de Matrix e Points e etc…

Bem, depois que eu finalmente consegui colocar essa coisa toda pra funcionar (tava pensando: acho que vou no cinema hoje de tarde), coloquei mais uns personagens no meu XML e…

Cinema?

Moral da história para programadores: UML? Não! Desenhe cada tela antes de começar. Faça cenários. Desenhe os cenários. Depois, só depois, UML. Esse erro vai me custar horas de planejamento do sistema. Só que eu não tenho tempo pra isso.

Moral dois (ainda para programadores): Quando vocês tiverem uma idéia bala e diferente para interfaces, mesmo que achem que saibam como implementar, dupliquem o prazo do projeto.

Moral três (é, ainda): Provavelmente os padrões vão salvar o meu dia (e com esperança o meu cinema, que talvez role um pouco mais tarde).
Moral da história para designers: não odeiem os programadores. Eles (a gente?) não consegue prever tudo.

I can’t figure out a good way of doing it on a timeline base.

So Im writting this short tute: it is an excellent example of the power of object orientation.

Figure 1 depicts the gallery we want to build.

Figure 2 shows the basic preloading code.

Suppose youre showing images from a XML file. It’s a very common setting. This means you dont know how many images youre going to show.

So, whats the big deal?

Check out the code of Figure 2. See that we instantiated MyBar, which is a simple bar MovieClip. We add it to stage when the preloading starts, change its scaleX as the loading progresses and remove it from stage when the loading finishes. So far so good, hun?

So, you dont know how may pictures you have… What are you going to do about the loading bars? Are you going to instantiate and add them to stage as you read your XML? Great! Excellent idea! But, hey, youre probably inside a function, dont you? So your variables are all “locals”… How are you going to remove the loading bars?

Well, before someone thinks of something like “hey, what if I make an Array of loading bars”, let’s check the OO approach

First, a warning for the experienced programmer: this is a novice tute. I am pretty aware of DP an it all… Im not gonna cover these issues here…

So, as I was saying… Imagine that, instead of having all of our code on the timeline, we are going to have objects that represent each of the images we are loading. Each one of them is responsible for its own loading, so it takes care of its bars and warnings…

We will only instantiate them and put them on stage.

This is the idea. Now you download the code and read the as files. And if you figure out an elegant way of doing this on the timeline Ill writte a  tribute in your name in my MSN (hehe).

/*****************************************************/
E se nós quiséssemos carregar todas nossas imagens ao mesmo tempo?

E se quiséssemos mostrar informação enquanto elas carregam?

Eu não consigo pensar num jeito bcana de fazer isso via timeline.

Por isso estou escrevendo esse pequeno tutorial: é um excelente exemplo do poder da orientação a objetos.

Figura 1 mostra a geleria que queremos construir.

Figura 2 mostra um código básico de preloading.

Suponha que você vai mostrar as imagens de um arquivo XML. É uma coisa muito comum. Isso significa que você não sabe quantas imagens você vai mostrar.

E daí, qual o problema?

Olhe o código da figura 2. Veja que instaciamos MyBar, que é um MovieClip simples, com uma barra. Nós colocamos ele no palco quando o carregamento começa, mudamos sua scaleX durante o progresso e removemos ele do palco quando o carregamento terminia. Até tudo bem, certo?

Então…  você não sabe quantas imagens vai ter… Como você vai fazer com as barras de carregamento? Você vai instaciá-las e colocá-las no aplco enquanto lê seu XML? Ótimo! Excelente idéia! mas, olha só, você provavelmente está dentro de uma função, não? Então suas variáveis são todas “locais”… Como você vai remover as barras de carregamento?

Bem, antes que alguém pense em algo do tipo “e se eu criasse um Array de barras de carregamento”, vamos ver a abordagem OO

Primeiro, um aviso aos programadores experientes: este é um tutorial para iniciantes. Eu estou bem ciente dos padrões de projeto e tals… E não vou cobrir estes assuntos aqui…

Então, como eu estava dizendo… Imagine que, ao invés de ter todo seu código na timeline, nós vamos ter objetos que representam cada uma das imagens que nós vamos carregar. Cada uma delas é reponsável por seu próprio carregamento, por isso cuida de suas barras e avisos…

Nós só vamos instaciar os objetos e colocá-los no palco.

Essa é a idéia. Agora você baixa o código e lê os arquivos. E se você achar um jeito elegante de fazer isso na timeline eu escrevo uma homenagem a você no meu MSN (hehe).