Convert svg to as3

Based on µSprite, i did a converter svg->as3

Here

Un livre gratuit sur flash 9

Un tres bon livre gratuit, qui explique vraiment bien les subtilité d'actionscript 3 :

Ici

ET c'est gratuit !

(A french book about as3, free)

For my project, I need to localize my english website in many different langage.
I don't want to use resource buddle for one simple reason : i don't want compile 10 version of my website each time I do a small fix !!!!
So i find on the net a solution :
1) download a resources xml :
[Bindable]
private var $:XML

public function init():void
{
loadResources("trans_fr.xml")
}

private function loadResources(xmlURL : String) : void
{
var myXMLURL:URLRequest = new URLRequest(xmlURL);
var myLoader:URLLoader = new URLLoader(myXMLURL);
myLoader.addEventListener("complete", xmlLoaded);
}

private function xmlLoaded(e:Event) : void
{
$ = XML( URLLoader(e.target).data);
}

So $ is your resources now !
2) How use it :
mx:TitleWindow layout="absolute" title="{$.Tool}" width="194" height="212" ...

The title is localize now !

3) how look the resources files :
<resources locale="fr">
<tool>Outils</tool>
<new>Tout effacer</new>
</resources>

Save it as trans_fr.xml in the same directory than your application, and all is ok !
The only problem for now, it is we didn't choose the langage.Let's do it in a second part !

www.My-Office-Paint.com

I am proud to announce the beta version of www.My-office-Paint.com , my first program in flash.
The goal of this program is to do office/home map. With it, u can stop to ask your coworker about "where is Mister Smith", or "What is the email of this pretty girl", just go on consultation page,and find who are people,and what they do in your company...
U can try some change in office place...And use it for your personnal home.

Hope you enjoy, as i enjoy programming it.

www.My-Office-Paint.com

A nice tileset editor

It is not a famous one, but it is pretty good !

http://saqscrap.com/saq2d.aspx

The author give you source, in c#, and that's really important, as it is near impossible to find a universal tileset format.
In the same way, that's save the data in XML format, more easy to be processing after by your program, independantly of your langage.

Really a great job.

Some draw,Icon

I always need soem gfx as i can't draw well, so, that's a little compilation of some free ressource i find on net:

(I try my best for find free one, but check by yourself)

Icon:
http://www.ceptive.it/icone/index.php?page=1

http://www.icone-gif.com/icone/png/apps/2.php

http://art.gnome.org/themes/icon/

http://jimmac.musichall.cz/i.php

http://www.webappers.com/2008/02/12/webappers-released-free-web-application-icons-set/

http://www.smashingmagazine.com/2008/03/06/35-really-incredible-free-icon-sets/

http://www.iconsfree.org/free-icons/language/eng/c/categoriesRating/icons-categories-rating.html

http://www.iconbulk.com/icons_new.asp?strt=10

http://mintywhite.com/tech/xp/high-quality-free-icon-sets/

http://dryicons.com/free-icons/preview/ruby-extended/

http://www.smashingmagazine.com/2008/03/06/35-really-incredible-free-icon-sets/

http://www.icone-gif.com/icone/isometrique/32x32/

Some Game gfx:

http://lostgarden.com/2006/07/more-free-game-graphics.html (very beautifull)

http://lostgarden.com/2005/03/game-post-mortem-hard-vacuum.html ( a full RTS !!!)

[Flash] Show the mxml secret

If, as me, you don't like secret, if, like me, u don't like when compiler do some magic without explain....I find the magic option !
"-keep"

This option show you what as3 compiler generate from mxml files.

My Assert in Flash

That's bit silly, i know, but i was SO missing my assert in Flash...After many years of using it in c++ and c#, i can't live without it !
So, just create a file "assert.as" in flexbuilder :
// ActionScript file
package
{
function assert(expr:Boolean=false,msg:string=""):void
{
if (expr)
return;
throw new Error(msg);
}
}

That's all ! All exception not catched make the debuguer launch if u program with flexbuilder3 as me !

Un nouveau operateur en C++!

J'ai l'honneur de vous annoncer la naissance de <-,un opérateur tout nouveau en C++.

Un nouvel opérateur en C++!!!

Bon je dois avouer que je suis vraiment pas pour la redéfinition des opérateurs en c++... Quelques cas sont très utile,mais cela masque souvent le temps machine utilisé,produit des programmes plus lourd,c'est aussi une source d'erreur assez grande. Même les cas très "évident" comme les matrices, produisent au final un code assez mauvais,et caché derrière quelques signes,le programmeur le vois pas...

exemple typique:

matrice res,a,b,c;
res=a*b+c;

Cela produit un très très mauvais code (beaucoup trop de parcours de matrices)... Si ce cas arrive souvent,il serait mieux de faire une fonction special.

Donc bon,ce qui suit est plutôt un jeu de l'esprit,...

Le nouveau opérateur du C++ est:
<-
exemple d'utilisation:

stack pile;
int value;
pile<-value; // ajoute value dans la pile

A priori d'autre opérateur sont faisable si vous comprenez la bidouille, je pense a <++, <--, par exemple.

En fait la technique est très simple quand on connait le fonctionnement d'un compilateur, a<-b est en fait,une fois traduit en terme plus clair:
a.superieur(b.moinsUnaire());

donc pour avoir l'opérateur <- il suffit que - unaire renvoit une copie (ou référence,je vous laisse optimiser :) ) de b... cela donne (exemple très très simple):

class test
{
public:
int a;
const test& operator-() {return *this;};
void operator<(const test& arg) // l'operateur <- est en fait l'affectation,pour simplifier.
{
a=arg.a;
}
};

int main(int argc, _TCHAR* argv)

{
test a,b;
a.a=0;
b.a=25;
a<-b;
cout< return 0;
}

Et voila! un opérateur "<-" !

Et la: "c'est bien beau,mais je peux pu utiliser l'opérateur < normal! Cela reste possible car on peut utiliser plusieurs opérateurs <, par exemple un opérateur qui prends un "int" ou un "test". Il suffit donc de bidouiller un peu...Par contre le - unaire est perdu (si quelqu'un a la solution...) Donc on va faire un opérateur - qui prends un "test" en argument et renvoi un "testAux". il y aura donc deux opérateurs <, un qui prends un "test" et qui fait une comparaison "supérieur" normal, et une autre qui prends un "testAux" et fait l'opérateur "<-"!

(c++) BOOST

BOOST

Par fabi, mardi 18 janvier 2005 à 01:19 :: Prog :: #3 :: rss

Un petit test de la librairie BOOST.

La librairie BOOST commence a être très connu par les amis du C++. J'ai donc voulu faire un petit test de ces qualités et ces défauts.

BOOST est entrain de devenir, comme la STL en son temps,un prochain standard, il est donc inintéressant de l'étudier pour prévoir le futur du c++, et de plus,cette librairie utilise souvent des techniques, voir des bidouilles toujours intéressant à connaitre.

Déjà, passons sur cette légende répandu, la partie qui doit être standardisé bientôt dans BOOST est vraiment minime, malheureusement: voir ici cela concerne les librairies les moins intéressantes je pense.

Donc, BOOST c'est quoi en gros ? une collection de lib, complètement hétéroclite, on y trouve des nouvelles fonctions "random", de la "metaprogrammation par le préprocesseur" (une horreur sans nom). Bref en piquant au hasard dans les diverses librairies, on pense que c'est un délire de geek en manque de pizza. Les auteurs se présentent comme proche du comité de standardisation, les gens qui adorent les templates. Dans les fait,il y a énormément de template dans BOOST (je suis pas fan de template...) . La qualité a par contre l'air d'être bien respecté, test de régression, norme de codage, espace de nom, norme de doc...les auteurs ont l'air très pointilleux sur ce point,plutôt encourageant.

Je n'ai utilisé que des librairies simples,donc pour l'instant je peux pas trop parler du reste (a part si je fais une section humour dans ce texte...)

La librairie "format". Je dois précise que j'adore cette librairie,simple mais si utile...elle manquait vraiment au C++! Cette librairie ce résume a une seul classe, Format. Son but est d'allié la facilité de "printf" (facilité relative,j'ai jamais aimé printf) avec le C++ Actuellement, vous avez deux façons de formaté du texte: Le vieux printf...sa syntaxe est souvent

printf("l'age de %s est %i ans.",truc,age);

Ce bon vieux printf et ces amis scanf,sprintf... sont responsable de la plupart des attaques par "buffer overflow".Des librairies sur linux et windows permettent de les éliminer du code, les outils de qualité les détestent, bref c'est une mauvaise habitude à éradiquer.On peut voir aussi que si on ne donne pas le bon type d'argument ou le bon nombre,un plantage est à craindre (ceci est détecter par pas mal de compilo actuel,dans les cas les plus simple).Le fait d'avoir à apprendre X flags, qui sont parfois plus subtile qu'on le pense me freine un peu aussi.

De l'autre le nouveau cout, de syntaxe

cout<<"l'age de"<<<"est"<<<".";

C'est une syntaxe plus sure a cause du typage du C++...mais le problème est la esthétique, le formatage ressemble pas a ce qu'on attends; Par exemple, par mégarde,j'ai oublié les espaces devant et après "truc" et "age".

Format réconcilie les deux,prenant le meilleur, on est pas loin de la facilité du php, et même,peut être mieux! avec format,on écrira:

cout<

On combine donc les avantages du printf (on voit bien ce qu'on aura en sortie) avec ceux du c++ (les %1% ne parlent pas de type,juste de ou mettre l'argument)

La librairie est facilement configurable pour lancer une exception ou non si le nombre d'argument est correct. Et autre intérêt, on peut répéter l'argument!

Imaginons que je veux générer automatiquement une classe:

class NOMDECLASSE
{
NOMDECLASSE() {};
~NOMDECLASSE(){};
}

Avec printf,on aura:

char patron=\
"class %s\n"\
"{\n"\
"%s() {};\n"\
"~%s(){};\n"\
"}"

printf(patron,nom,nom,nom);

Avec cout: cout<<"class "<<<\n"<<"{\n"<<<"() {};\n~"<<<(){};\n}"; (je rappel au passage que endl et \n sont très différent) (et que ce code est fait de tête,désolé pour les erreurs ;) )

Avec format: string patron=

"class %1%\n"\
"{\n"\
"%1%() {};\n"\
"~%1%(){};\n"\
"}"

cout<

Plus lisible quand même :) Dommage que ce langage ne permettent pas de prendre de chaine sans les analyser,d'où les \n et \ seul en fin de chaque ligne,c'est dommage. Ça prouve qu'avec quelques librairies le C++ devient un langage "web" tout a fait acceptable.

(.NET / C# ) L'Assembleur IL

Il peut sembler désuet, à l’époque d’ASP.NET et de C#, de s’intéresser à un langage d’aussi bas niveau que l’Assembleur (asm pour les intimes). Il y a 15 ans, on m’en enseignait les rudiments avec, déjà, un certain recul, comme pour une science un peu dépassée mais dont les principes devraient faire partie de la culture générale de tout bon développeur... Et pourtant l’Assembleur permet justement de nous rappeler que tout est, en fin de compte, de l’électronique, une fois toutes les couches d’abstraction décompilées. Cela m’a d’ailleurs servi à comprendre ce que faisait concrètement un compilateur, et pourquoi certaines instructions étaient plus lentes à l’exécution que d’autres.

Pour trouver audience dans cette démonstration de l’intérêt de connaître l’asm, j’en appelle donc à tous ceux qui, comme moi, s’intéressent à ce qui se passe « sous le capot » ; le but n’étant pas de tout programmer en asm (quoique...) mais plutôt de s’en servir pour comprendre ce que fait le compilateur C# / VB.NET pour optimiser et comparer le code produit.

IL est l’assembleur de DotNet dont les instructions sont générées aussi bien à partir d’un source C# que VB.NET, du « managed » C++, du Python, du Forth... Il offre de ce fait une palette de possibilités bien plus large qu’en offrirait, par exemple, le C# à lui seul.

Le second intérêt, et de loin le plus pratique, de connaître l’asm est la possibilité offerte par le C# de générer lors du runtime du code assembleur, et cela s’avère dans certains cas très puissant (voir [1] par exemple).

Mais il semble aller de soi que, pour générer un tel code de cette façon, il faut au préalable connaître l’asm... et je n’ai jamais jusqu’à présent trouvé d’article en français sur le sujet.

« Mais où sont mes registres ? »

L’assembleur de DotNet est très différent des assembleurs standard. Premier choc : il n’y a pas de registre... Tout se passe dans la pile, à la façon des calculatrices HP. Il s’agit donc de « notation polonaise » : pour une simple addition de A et B, par exemple, on empile A, on empile B, puis l’opération d’addition est appelée, qui dépile B et A et en empile la somme.

Autre différence majeure, l’assembleur IL est orienté ... objet ! hé oui, même si cela peut sembler étrange aux puristes de l’assembleur, chaque routine appelée peut être dans une classe, elle-même dans une assembly, et l’instruction new fait partie des instructions de cette assembleur...

Voici un exemple de « Hello world » en asm IL :

1:.assembly extern mscorlib {} // dépendance (writeline)

2:.assembly test {}

3:.method public hidebysig static void Main(string[] args) cil managed

4:{

5: .entrypoint

6: .maxstack 1

7: ldstr "Hello World!" // mettre la chaine sur la pile

8: call void [mscorlib]System.Console::WriteLine(string) // l’afficher

9: ret // quitter le programme

10:}

Une fois tout cela écrit, comment compiler ?

Rien de plus simple : tapez en ligne de commande :

ilasm mon_fichier.asm

... et vous devriez voir apparaître mon_fichier.exe.

Mais commentons un peu le code ci-dessus.

Première constatation, très pratique : les commentaires sont « comme en C ».

Toujours dans la même veine, plutôt à la mode C# cette fois, la définition des méthodes est préfixée par une série de mot-clés « public » « static »...Ces mots clé sont définis dans le document « PARTITION II METADATA.DOC » [2]

Plus original, chaque méthode doit définir le maximum de pile qu’elle va utiliser (.maxstack 1), ceci probablement afin d’éviter tout risque d’attaque par « buffer overflow » de la part de potentiels hackers. Une maxstack trop petit ? c’est le plantage. Alors pourquoi a-t-il été placé à 1 dans le cas présent ?

Que doit-on mettre dans la pile ? une chaîne de caractères... ou plus exactement (pour ceux qui n’ont pas assez fait de C dans leur jeunesse) un « pointeur » sur une chaîne de caractères. Or, l’unité de base de .NET est « l’entier naturel », soit un pointeur. On précise donc à .NET que cette méthode empilera qu’une donnée.

Ligne 8, l’instruction call appelle une méthode, qu’elle soit normale, ou préfixée de static ou virtual.

Une caractéristique fondamentale à comprendre, c’est que contrairement au C# où c’est obligatoire, ici, aucun objet n’est créé : tout est « procédural ».

Un exemple plus utile

Voici maintenant comment la non moins classique méthode add, qui prend en paramètres 2 entiers et renvoie leur somme :

1:.method private hidebysig static int32 Add(int32 x, int32 y) cil managed

2:{

3: .maxstack 8

4: ldarg.0

5: ldarg.1

6: add

7: ret

8:}

10:.method public hidebysig static void Main(string[] args) cil managed

11:{

12: .entrypoint

13: .maxstack 8

14: ldc.i4.3

15: ldc.i4.4

16: call int32 Add(int32, int32)

17: call void [mscorlib]System.Console::WriteLine(int32)

18: ret

19:}

Lignes 14 et 15, nous mettons sur la pile les valeurs constantes 3 et 4 (ldc), puis nous appelons notre méthode ADD. Celle-ci charge les deux arguments de la pile, les ajoute, et revient à l’appelant. Enfin, WriteLine pour afficher le résultat.

Mais regardons de plus près l’instruction lcd.i4.3. Ce mnémonique charge directement l’entier trois sur la pile. C’est une version spécialement « optimisée » pour 3 de l’instruction de base lcd.i4 qui charge 4 octets (soit un Int32) sur la pile.

L’un des buts avoués de l’asm MSIL était de fournir en sortie des binaires très compacts. Après un certain nombre d’analyses statistiques sur les codes sources, Microsoft a conclu à la propondérance des constantes entières de 0 à 8. On a donc réservé un traitement spécial à ces nombres : une instruction lcd.i4.x (x étant compris entre et 0 et 8) qui ne prend qu’1 octet. Il existe bien entendu une version générique de cet empilement d’entier : lcd.i4 3 (remarquer l’absence du point). Mais l’utilisation de ce dernier réserve par défaut un espace (ici inutile) de 4 octets entiers sur la pile...

Ceci est aussi vrai pour « ldarg.0 » qui est une version spéciale de ldarg, optimisée pour charger les 8 premiers arguments (il faut avouer que c’est souvent assez !). S’il y a davantage d’arguments, il faut utiliser « ldarg NumArg ».

Ligne 16, nous avons dans la pile les valeurs 3 et 4, que la méthode Add va extraire, additionner, et renvoyer sur la pile, remarquons qu’il n’y a aucun typage, autre caractéristique de MSIL ! Rendez-vous a [3] pour voir les règles de conversion implicites.

Utilisation de variable locale, création d’objet

Passons à un exemple beaucoup plus concret : nous allons créer notre objet, en passant par l’instruction « newobj » qui prends ses arguments sur la pile, alloue la mémoire nécessaire, appel un constructeur, et renvoie le « this » sur la pile.

// On déclare notre class.

.class public auto ansi beforefieldinit Counter

extends [mscorlib]System.Object

{

// Un champ float, en c#: public float Total

.field public float32 Total

// Le construteur, "ctor" en langage ASM

.method public hidebysig specialname rtspecialname instance void .ctor() cil managed

{

.maxstack 8

ldarg.0 // l'argument zero est toujours "this" dans un objet

call instance void object::.ctor()

ret

}

// Une methode qui incremente notre compteur

.method public hidebysig instance void AddToCounter(float32 f) cil managed

{

.maxstack 8

ldarg.0 // L'argument zero est toujours "this" dans un objet

dup // On le duplique

ldfld float32 Counter::Total // Charger la valeur du champ

ldarg.1 // Charger le flottant f

add // Faire la somme

stfld float32 Counter::Total // Stocke le resultat dans le champ Total

ret

}

.method private hidebysig static void Main(string[] args) cil managed

{

.entrypoint

.maxstack 2

newobj instance void Counter::.ctor() // allocation de la memoire+appel au constructeur, mise du resultat en pile

ldc.r4 5 // stocke la valeur "real" 5.0f

callvirt instance void Counter::AddToCounter(float32) // appel la methode de l'objet

ret

}

Quelques points à noter :

· Le constructeur s’appelle « .ctor », c’est une convention de MSIL.

· Quand on appelle une fonction d’un objet, l’argument 0 est toujours le this de l’objet.

· De même, quand on appelle une fonction de l’objet, on doit toujours commencer à pusher le this (sauf dans le cas d’une fonction statique bien sûr).

· Quand on définit une classe, il FAUT déclarer une assembly, alors que les programmes « non objet » ne le nécessitent pas.

Mise en application

L’un des intérêt s majeurs de connaître l’assembleur MSIL est de comprendre le fonctionnement interne…à quelques rares cas, programmer directement en MSIL n’est pas nécessaire, mais regarder le fonctionnement interne d’un programme est déjà plus intéressant. Pour cela il existe le programme ILDASM (Intermediate langage Deassembleur) qui prends en entrée un EXE ou DLL, et vous fournit le source, il est livré en standard avec C#. Cependant, je lui préfère un outil beaucoup plus agréable : Reflector , un outil vraiment obligatoire pour tout programmeur .NET qui se respecte. Vous le trouverez ici : http://www.aisto.com/roeder/dotnet/.

Une fois pris en main cette utilitaire, amusons nous a quelques tests :

FOR est-il plus rapide que FOREACH ?

Cette question est revenue plusieurs fois dans les forums, nous allons essayer de lui donner un début de réponse, en comparant le parcours d’une liste d’entier. Le programme C# correspondant est :

static int FOREACH(int[] tab)

{

int res=0;

foreach(int valeur in tab)

res+=valeur;

return res;

}

static int FOR(int[] tab)

{

int res=0;

for(int i=0;i

i+=tab[i];

return res;

}

Regardons maintenant dans Reflector le code généré :

.method private hidebysig static int32 FOR(int32[] tab) cil managed

      .maxstack 3

      .locals init (

            [0] int32 num1,

            [1] int32 num2,

            [2] int32 num3,

            [3] bool flag1)

      L_0000: nop

      L_0001: ldc.i4.0

      L_0002: stloc.0

      L_0003: ldc.i4.0

      L_0004: stloc.1

      L_0005: br.s L_0011

      L_0007: ldloc.1

      L_0008: ldarg.0

      L_0009: ldloc.1

      L_000a: ldelem.i4

      L_000b: add

      L_000c: stloc.1

      L_000d: ldloc.1

      L_000e: ldc.i4.1

      L_000f: add

      L_0010: stloc.1

      L_0011: ldloc.1

      L_0012: ldarg.0

      L_0013: ldlen

      L_0014: conv.i4

      L_0015: clt

      L_0017: stloc.3

      L_0018: ldloc.3

      L_0019: brtrue.s L_0007

      L_001b: ldloc.0

      L_001c: stloc.2

      L_001d: br.s L_001f

      L_001f: ldloc.2

      L_0020: ret

}

Cela semble énorme, et ça l’est ! En y regardant de plus près, on trouve des instructions bizarres, comme « nop », ou le br.s L_001F qui ne servent à rien. Pourquoi C# génère-t-il de telles horreurs ? Car nous avons oublié de compiler en Release, tout simplement. Pourquoi ce Nop, et ce saut inutile ? C’est une supposition de ma part mais je pense qu’il s’agit pour l’environnement d’une marque pour permettre de mettre des points d’arrêt sur les accolades en C#.

En effet, comment marchent les breakpoint ? Tout simplement en remplaçant une instruction par une instruction spéciale, « break », qui donne la main a l’Edi, qui garde en mémoire l’ancienne valeur, et l’exécute après. Faire du « pas a pas » signifie, en fait, mettre un opcode « break », exécuter l’instruction qui était sous le break, et déplacer d’un pas le break.

Revenons à notre comparatif :

.method private hidebysig static int32 FOR(int32[] tab) cil managed

      .maxstack 3

      .locals init (

            [0] int32 num1,

            [1] int32 num2)

      L_0000: ldc.i4.0

      L_0001: stloc.0

      L_0002: ldc.i4.0

      L_0003: stloc.1

      L_0004: br.s L_0010

      L_0006: ldloc.1  //DEBUT DE BOUCLE

      L_0007: ldarg.0

      L_0008: ldloc.1

      L_0009: ldelem.i4

      L_000a: add

      L_000b: stloc.1

      L_000c: ldloc.1

      L_000d: ldc.i4.1

      L_000e: add

      L_000f: stloc.1

      L_0010: ldloc.1

      L_0011: ldarg.0

      L_0012: ldlen

      L_0013: conv.i4

      L_0014: blt.s L_0006 // FIN DE BOUCLE

      L_0016: ldloc.0

      L_0017: ret

}

Nous n’avons plus de flag de test de fin de tableau, moins de variables locales, le code semble beaucoup plus correct. Si nous cherchons la boucle, nous voyons qu’elle fait 15 instructions…Je vous fait grâce du source de foreach, qu’il lui fait 17 instructions.

Il semblerait donc que sur un tableau d’entier, for soit mieux que foreach….attention cependant de garder en tête que l’ASM IL est au final traduit en ASM natif, donc…Qui sait ?

[1] http://www.codeproject.com/csharp/dynmatrixmath.asp

[2] Vous pouvez trouver ce document dans le repertoire Microsoft.NET\ FrameworkSDK \Tool Developers Guide

[3] http://msdn.microsoft.com/library/fre/default.asp?url=/library/FRE/cpref/html/frlrfsystemreflectionemitopcodesclassaddtopic.asp

buzzword: Ajax VS Flash

Ajax est bien, ajax roxx, ajax est geniallllllll. Flash est pourri, c'est nul, oulala,c'est honteux.

Enfin c'est ce que j'entends partout, et si tout le monde le dit, ça doit être vrai... Je suis actuellement sur un projet asp.net/ajax.net (le truc Microsoft qui fait de l'ajax) Le client avait le choix entre une interface ajax, ou une interface flash. Flash? mais mon dieu, on est des Coders! pas des bidouilleurs flashiens. Bref on a bien sur choisis ajax... Et là, on déchante: Ajax veut pas dire grand chose au final, oué, il y a bien l'objet xmlrequest, mais après? Quand on a reçus une information,on en fait quoi ? on le manipule en ....Javascript? est ce mieux que flash?

Moi, l'html, l'ajax, le DHTML, flash, je dois avouer, j'y connaissais rien il y a encore 6 mois... Donc je remet les choses un peu au point:

Doc:

Ajax est super,il y a des centaines de framework. C'est aussi le problème. C'est nouveau, quasiment aucune doc! Pour savoir si un framework est bon ou pas, il faut l'essayer. J'ai dut en tester 10 avant de prendre YUI. Ajax.net s'est révélé bordélique à souhait, incompréhensible à mon niveau. Je suis passé aussi par Dojo (l'archétype du projet libre qui promet beaucoup,mais reste en version 0.0.0.0.1 bêta). Bref, beaucoup de temps perdu. En flash, un coup de Google permet de voir des centaines de tutoriels.

Langage:

Ajax, pour résumer, c'est du coté serveur,le langage qu'on veut, et coté client javascript. Et du coté de flash? c'est de l'ECMAscript....mais, attendez un peu...c'est pas l'autre nom de javascript? Et oui,les deux se programment dans le même langage !!! Avec un net avantage pour Flash qui utilise les dernières spec du langage (donc on peut,si on veut, faire des class, typé les variables etc)

Vitesse: il suffit d'aller voir un site AJAX pour se rendre compte que....le CPU est bouffé a 100%

Et oui, et la, FF et IE sont aussi bete, une page javascript peut vous paralyser votre machine... Ouvrez donc 3 pages ajax, et hop,timeout de partout. C'est donc çà Ajax? un truc qui sur une machine a 2ghz, 1 giga de ram, me prends tout mon cpu car ...je déplace une image? Ajax,le futur? heuuuuu... De ce coté, flash, même en étant énormément plus lent qu'un langage compilé genre c++, vous laisse respirer, déplace des objets sur X courbes de bezier tout en changeant leur alpha. Quand même un peu plus raisonnable !

Compatibilité !

LE POINT! Et oui, flash, il n'y en pas partout, c'est nul, c'est pourri, ton site, personne pourra le voir ! Je pensais un peu ça aussi....avant de réaliser que les "blockbuster" des derniers mois, niveau site web,étaient tous...en flash. Dailymotion, deezer et youtube utilisent le "flv", qui est le format video de flash. Ces sites sont regardés en permanence par des millions de gens, les journaux intègres leurs videos en permanence et...j'ai jamais vu personne se plaindre! Et du coté d'ajax? oui c'est super sauf que...FF et IE continu de se bouder, alors prévoyez des aspirines, rien que manipulez l'alpha d'une image nécessite deux codes différents! Des extensions de FF bloque tout les scripts... Et n'oublions pas, vous devrez tester votre code sous SAFARI, Konqueror, et autres browser quasi inconnu... Comme vous êtes un peu fainéant, vous testerez que sous IE et FF...mais ie5?ie6? FF1.5? FF2.0? Au final, ça ne marchera donc pas partout...

Référencement: Sur ce point, les deux sont nul, puisque le robot ne peut pas connaitre le contenu du site...il faudrait que google, yahoo et co, commence à s'en occuper, au passage... Un petit avantage pour ajax, dont les parties statiques sont référençable, c'est déjà ça !

Voila, je pense avoir fait un tour d'un peu tout...au final,si je refaisais le projet, j'insisterais pour utilisé flash: c'est pas que j'aime bien,mais c'est plus adapté a bouger deux malheureux sprites sur un écran

(flash) Clipping, Ajout de sprite flash dans du mxml, matrice de transformation

Un peu bizarre ça !

J'ai peiné à trouver comment clipper une zone en flash, donc, pour ceux qui cherche comme moi:
this.scrollRect=new Rectangle(x,y,width,height);
...drole de choix de nom. Sinon il y a masque, mais qui m'a l'air plus couteux....à tester!
Pour ajouter un bête sprite dans un composant MXML il faut ruser! Normalement, le addChild prends un objet sprite....mais MXML le caste en UIComponent, et verifit (avec "as") que le resultat est correcte dans les bases qui en derive. C'est pas du tout naturel,mais donc,le 1er composant MXML est le seul qui accepte des Sprite Flash,et donc :

uIComponent = new UIComponent();

monSprite=new monSprite();

uIComponent.addChild(monSprite);
addChild(uIComponent);

Maintenant c'est addElement(uICOmponent);

Apres, monSprite est utlisable "comme en flash" !

Chose curieuse par contre : tué le UIComponent, et le sprite sera toujours visible!
et oui monSprite est pas mort :-) donc,soit vous faire un monSprite.graphics.clear();
ou soit vous faite une liste de Sprites qu'il faut detruire a chaque resize :s

Autre chose bizare: this.transform.matrix.ty=10 ne fait rien !!! (par contre this.scaleX=10 marche tres bien). Pour modifier la matrice,on doit faire:
var m:Matrix=this.transform.matrix;
m.ty=10;

this.transform.matrix=m;

(silverlight) Un ptit helper, ou le pourquoi des SetValue

Quand on fait beaucoup de Silverlight, on se retrouve sans arrêt à taper des superbes lignes comme:
Sprite.SetValue(Canvas.TopProperty,25);

C'est assez surprenant pour un environnement vectoriel, les objets n'ont pas de propriétés x et y directement accessibles!

Alors, vous me direz, quelle idée bizarre !
Mais bon, les gens de microsoft ont une bonne raison à cela. En fait le "pattern" utilisé est le même que sur les événements pour les winform pour gérer les événements. Ca permet d'optimiser beaucoup de place sur les vtables, l'occupation mémoire, et d'optimiser certaine propriétés, j'y reviendrai plus longuement un jour...

Donc, pour vous simplifier la vie, j'ai créé quelques méthodes, grâce aux méthodes d'extension de 3.0:

public static class Helper
{

public static void SetTop(this FrameworkElement c, double v)
{
c.SetValue(Canvas.TopProperty, v);
}

public static double GetTop(this FrameworkElement c)
{
return (double)c.GetValue(Canvas.TopProperty);
}

public static void SetLeft(this FrameworkElement c, double v)
{
c.SetValue(Canvas.LeftProperty, v);
}

public static double GetLeft(this FrameworkElement c)
{
return (double)c.GetValue(Canvas.LeftProperty);
}

public static double GetBottom(this FrameworkElement c)
{
return (double)c.GetValue(Canvas.TopProperty) + c.Height;
}

public static double GetRight(this FrameworkElement c)
{
return (double)c.GetValue(Canvas.LeftProperty) + c.Width;
}

public static bool NotNull(this string c)
{
return !string.IsNullOrEmpty(c);
}

public static void SetName(this FrameworkElement c, string name)
{
c.SetValue(Canvas.NameProperty, name);
}

public static string GetName(this FrameworkElement c)
{
return c.GetValue(Canvas.NameProperty) as string;
}

public static double GetAlpha(this FrameworkElement c)
{
return (double)c.GetValue(Canvas.OpacityProperty);
}

public static void SetAlpha(this FrameworkElement c, double alpha)
{
c.SetValue(Canvas.OpacityProperty, alpha);
}
}

J'aurais préféré des propriétés bien sur, mais ce n'est pas faisable en C# 3.0 :(

Donc maintenant, pour déplacer votre control de 15 pixels :
sprite.SetTop(sprite.GetTop()+15);

A la place de :

sprite.SetValue(Canvas.TopProperty,(double)sprite.GetValue(Canvas.TopProperty)+15);

C'est quand même plus lisible !

(Silverlight) Obtenir la taille du controle Silverligth

On a beau dire à silverlight qu'on veut du 640*400, monsieur est très capricieux!

Pour les besoins de mon prog, qui zoom grâce à la roulette, j'avais besoin de savoir où celle-ci etait déclenchée (voir le billet d'hier sur la mousewheel: on obtient des coordonnées du browser, à vous de vous débrouiller pour transformer ça en coordonnées silverligth, en tenant compte du scale etc).

Donc, après beaucoup de recherche, j'ai trouvé l'objet qu'il nous faut :
BrowserHost.ActualHeight
et BrowserHost.ActualWidth

A partir de là, vous pouvez déjà plus facilement calculer la position réel du curseur souris!

(oubliez pas d'inclure System.Windows.Interop !!)

(Silverlight) MouseWheel

Pour pouvoir utiliser la mousewheel (la roulette de la souris quoi !), en silverlight 1.1 :

http://vectorform.wordpress.com/2007/09/26/silverlight-scrollbar-component-updated-with-mousewheel-support/

Ou

http://www.RTLogicSystems.com

Les deux sont gratuits et basés sur le même système: on récupère (par un mécanisme multibrowser) la position de la roulette dans la page html, en javascript, puis on appelle une routine silverligth. Cela peut donc aussi servir d'exemple pour pouvoir communiquer entre html<->silverligth.
A noté, dans mes tests, la routine de RTL a un problème si la page dépasse la taille du browser, le comportement "par défaut" de la roulette s'active...Cela se corrige en renvoyant "1" si l'événement est pris en compte, 0 sinon.
Une autre remarque, sous windows, les valeurs renvoyées sont multiples de 160, et j'ai jamais vu une valeur autre que -160,160, donc vérifier le sens, plutôt que prendre la valeur, semble plus prudent.

A Fabi world