Armando Leopoldo Keller

MonsterDebugger.trace(this, o_que_é_para_ir_no_trace)

var _debugger:MonsterDebugger;
_debugger = new MonsterDebugger(this);

package
{
    import com.adobe.serialization.json.JSON;
    import flash.net.Socket;
   /**
     * Classe para conexao com python utilizando socket
     * @author    Armando Leopoldo Keller - (http://alkeller.wordpress.com) - alkeller@live.de
     */
    public class Python extends Socket
    {
        // TODO: Implementar um metodo de retorno, verificando o tipo do retorno, e passando como parametro na funcao associada
        /**
         * Cria um novo Socket
         * @param host    Host onde esta o socket
         * @param port    Porta que esta o socket
         * @see flash.net.Socket
         * @usage    var p:Python = new Python("10.1.1.23",2727);
         */
        public function Python(host:String=null, port:uint=0)        {
            super(host, port);
            host = null;
            port = 0;
        }
        /**
         * Chama uma funcao do python se o socket estiver conectado 
         * @param func    Nome da funcao a ser chamada no python
         * @param args    Argumentos a serem chamados no python
         * @usage p.call("teste",{um:1,dois:2,tres:3});
         * @usage p.call("teste");
         */
        public function call(func:String,args:Object=null):void
        {
            if(this.connected)
            {
                this.flush();
                var obj:Object = new Object();
                obj["funcao"] = func;
                for(var i:* in args)
                {
                    if(args[i] is String) args[i] = "'"+args[i]+"'";
                    obj[i]=args[i];
                }
                this.writeUTFBytes(JSON.encode(obj));
                obj = null;
            }
            else
                throw new Error("Voce deve estar conectado ao socket.")
            this.flush();
        }
    }
}

import json;
def executar(objeto):
    __arr__ = [];
    __str__ = "";
    obj = json.loads(objeto);
    __str__ = str(obj["funcao"])+"(";
    obj.pop("funcao");
    if len(obj.keys()) >;= 1:
        for k in obj:
            __arr__.append(str(k)+"="+str(obj[k]));
        for x in xrange(len(__arr__)-1):
            __str__ = __str__+__arr__[x]+",";
        __str__ = __str__ +__arr__[len(__arr__)-1]+")";
    else:
        __str__ = __str__+")";
    return __str__;

import socket
import threading
import json
from JMF import executar
class ClientThread ( threading.Thread ):
    def __init__ ( self, channel, details ):
        self.channel = channel
        self.details = details
        threading.Thread.__init__ ( self );
    def run ( self ):
        print 'Conexao recebida: ', self.details [ 0 ]
        self.channel.send ( "resposta vinda do python" )
        for x in xrange ( 10 ):
            string = self.channel.recv ( 1024 )
            self.interpretaComando(string)
        self.channel.close();
        print 'Conexao fechada: ', self.details [ 0 ]
    def interpretaComando(self,string):
        eval("self."+executar(str(string)));
    def testar(self,arg1,arg2):
        print "Chamou testar: "+str(arg1)+","+str(arg2);
        self.channel.send("Chamou testar: "+str(arg1)+","+str(arg2));
    def pegaVariaveis(self):
        print "chamou pegaVariaveis"
        self.channel.send("chamou pegaVariaveis");
    def pegarArray(self):
        print "Chamou pegar Array";
        arr = ['a','b','c',1,2,3];
        txt = json.dumps(arr);
        self.channel.send(txt);
    def pegarObj(self):
        print "Chamou pegar Objeto";
        teste = {}
        teste["item1"]   =   "Primeiro item";
        teste["item2"]   =   "Segundo item";
        teste["numero"]  =   2;
        self.channel.send(json.dumps(teste));
# Inicia o servidor
server = socket.socket ( socket.AF_INET, socket.SOCK_STREAM )
server.bind ( ( socket.gethostbyname(socket.gethostname()), 2727 ) )
server.listen ( 5 )
print "Iniciando servidor..."
while True:
    channel, details = server.accept()
    ClientThread ( channel, details).start()

<?xml version="1.0" encoding="utf-8"?>;
<mx:WindowedApplication applicationComplete="iniciar()" xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
    <mx:Script>
        <![CDATA[
            import com.adobe.serialization.json.JSON;
            private var py:Python
            [Bindable]
            public var texto:String = ""
            public function iniciar():void
            {
                py = new Python();
                py.addEventListener(ProgressEvent.SOCKET_DATA,onRecebe);
                py.addEventListener(Event.CONNECT,onConecta);
                py.addEventListener(IOErrorEvent.IO_ERROR,onErroIO);
                py.connect("10.1.1.3",2727);
            }
            public function onRecebe(e:ProgressEvent):void
            {
                var str:String = py.readUTFBytes(py.bytesAvailable);
                texto = str;
                py.flush();
            }
            public function onConecta(e:Event):void
            {
                trace("Conectou")
            }
            private function chamarTeste():void
            {
                if(py.connected)
                    py.call("testar",{arg1:"Argumento 1",arg2:"Argumento 2"})
                else
                    texto = "O socket esta desconectado";
            }
            private function chamarPegaVariaveis():void
            {
                if(py.connected)
                    py.call("pegaVariaveis")
                else
                    texto = "O socket esta desconectado"
            }
            private function pegarArray():void
            {
                if(py.connected)
                    py.call("pegarArray");
                else
                    texto = "O socket esta desconectado";
            }
            private function pegarObj():void
            {
                if(py.connected)
                    py.call("pegarObj");
                else
                    texto = "O socket esta desconectado";
            }
            private function matarServer():void
            {
                py.close();
                texto = "Desconectado"
            }
            public function onErroIO(e:IOErrorEvent):void
            {
                trace("Erro ao conectar com o socket");
            }
        ]]>
    </mx:Script>
    <mx:VBox>
        <mx:HBox>
            <mx:Button label = "Testar"         click = "chamarTeste()"         />
            <mx:Button label = "PegaVar"        click = "chamarPegaVariaveis()" />
            <mx:Button label = "pegarArray"     click = "pegarArray()"          />
            <mx:Button label = "pegarObj"       click = "pegarObj()"            />
            <mx:Button label = "Kill Server"    click = "matarServer()"         />
        </mx:HBox>
        <mx:Text text="{texto}" width="100%" height="115"/>
    </mx:VBox>
</mx:WindowedApplication>

/*
* JSFL para converter imagens para swf
* Importa a imagem em um fla novo, e exporta o swf com a imagem. (redução de até 92% no "peso do arquivo")
* @author Armando Leopoldo Keller (alkeller@live.de)  http://alkeller.wordpress.com
*
* Quem utilizar esta classe, favor enviar um email para ALKELLER@LIVE.DE com o "peso" das imagens antes e depois de serem exportadas.
*
*/
 
var fotosURI = fl.browseForFolderURL("Armando Leopoldo Keller(alkeller@live.de)\n \nSelecione a pasta das imagens.\n ");
var swfsURI = fl.browseForFolderURL("Armando Leopoldo Keller(alkeller@live.de)\n \nSelecione a pasta dos swfs.\n ");
var flasURI = fl.browseForFolderURL("Armando Leopoldo Keller(alkeller@live.de)\n \nSelecione a pasta dos flas.\n ");
 
var fileMask1 = "*.png";
var fileMask2 = "*.jpg";
 
var list1 = FLfile.listFolder(fotosURI + "/" + fileMask1, "files");
var list2 = FLfile.listFolder(fotosURI + "/" + fileMask2, "files");
 
function converte(list)
{
	for(var i in list)
	{
		var doc = fl.createDocument();
		doc.importFile(fotosURI+"/"+list[i],true);
		var it = doc.library.items[0];
		it.quality = 80;
		it.allowSmoothing = true;
		doc.addItem({x:0,y:0},it);
		var selecionado = doc.getTimeline().layers[0].frames[0].elements[0];
		selecionado.x = 0;
		selecionado.y = 0;
		doc.width = parseInt(selecionado.width);
		doc.height = parseInt(selecionado.height);
		doc.frameRate = 1;
		if(flasURI)
		{
			fl.saveDocument(doc,(flasURI+'/')+list[i].split(".png").join("").split(".jpg").join("")+'.fla',false);
		}
		doc.exportSWF(swfsURI+'/'+list[i].split(".png").join("").split(".jpg").join("")+'.swf',true);
		doc.close(false);
	}
}
 
if(fotosURI && swfsURI)
{
	if(list1.length > 0)converte(list1); // png
	if(list2.length > 0)converte(list2); // jpg
}
else
{
	alert("Você deve selecionar todas as pastas.(a de .flas é opcional)")
}

// Pixel Snapping [alk].jsfl
 
/*
Script criado por Armando Leopoldo Keller(http://alkeller.wordpress.com)
para instalar: só colar este arquivo em C:\Users\nome_do_usuario\AppData\Local\Adobe\Flash CS3\en\Configuration\Commands
obs: este é o caminho no windows vista
*/
for( var i = 0; i < fl.getDocumentDOM().getTimeline().layers.length; i++)
{
var layerAtual = fl.getDocumentDOM().getTimeline().layers[i];
for(var j = 0 ; j < layerAtual.frames.length ; j++)
{
var frameAtual = layerAtual.frames[j];
for(var k = 0 ; k < frameAtual.elements.length ; k++)
{
var elementoAtual = frameAtual.elements[k];
elementoAtual.x = parseInt(elementoAtual.x);
elementoAtual.y = parseInt(elementoAtual.y);
}
}
}

/*
################################################
#                                              #
#   Classe  : DB (com.alkeller.air.DB)         #
#   Autor   : Armando Leopoldo Keller          #
#   Versão  : 1.0                              #
#   Contato : alksk8@hotmail.com               #
#   Blog    : http://alkeller.wordpress.com    #
#   Documentaçao em breve no blog              #
#                                              #
################################################
------- Deixe os creditos na classe ----------
*/
package com.alkeller.air
{
	// Imports
	import flash.data.SQLResult;
	import flash.filesystem.File;
	import flash.data.SQLStatement;
	import flash.data.SQLConnection;
	import flash.events.SQLEvent;
	import flash.events.SQLErrorEvent;
	import flash.errors.SQLError;
 
	// Classe;
	public class DB
	{
		// Variaveis utilizadas;
		private static var conectado:Boolean = false;
		private static var dbFile:File
		private static var conn:SQLConnection
		private static var _sqlStatement:SQLStatement;
		private static var resultado:SQLResult;
		private static var retornoString:String;
		private static var retornoObjeto:Object;
 
		// Funçao Inicia :utilizada para conectar com o banco de dados;
		public static function Inicia(_nome:String):String
		{
			conn = new SQLConnection();
			dbFile = File.applicationStorageDirectory.resolvePath(String(_nome+".db"));
			try
			{
				conn.open(dbFile);
				conectado = true;
				trace("Conectado com "+_nome+".db");
				retornoString = "Conectado com "+_nome+".db";
			}
			catch (error:SQLError) 
			{
				conectado = false;
				retornoString = "Falha ao conectar: "+error.message+"\nDetalhes: "+error.details;
			}
			return retornoString;
		}
		// Funçao executeQuery: Utilizada para executar um comando SQL(verificar quais são aceitos pelo AIR);
		// Retorno: SQLResult --> http://livedocs.adobe.com/flash/9.0/ActionScriptLangRefV3/flash/data/SQLResult.html
		// ou  String de erro;
		public static function executeQuery(_sql:String):Object
		{
			if(conectado == true)
			{
				_sqlStatement = new SQLStatement();
				_sqlStatement.sqlConnection = conn;
				_sqlStatement.text = _sql;
				try
				{
					_sqlStatement.execute();
					resultado = _sqlStatement.getResult();
					retornoObjeto = resultado;
				}
				catch (error:SQLError)
				{
					retornoString = "Falha ao executar("+_sql+"): "+error.message+"\nDetalhes: "+error.details;
				}
				return retornoObjeto?retornoObjeto:retornoString;
			}
			else
			{
				return "Não conectado!";
			}
		}
	}
}

// OBS: Aqui é bom verificar se a classe esta no local certo com/alkeller/air/
import com.alkeller.air.*;
// ou
import com.alkeller.air.DB;

DB.Inicia("teste"); // sendo que teste é o nome do banco

DB.executeQuery("CREATE TABLE IF NOT EXISTS testando (id INTEGER PRIMARY KEY AUTOINCREMENT,nome TEXT,sobrenome TEXT)");

DB.executeQuery("INSERT INTO testando (id,nome,sobrenome) VALUES (null,'ARMANDO LEOPOLDO','KELLER')");

var obj:Object = DB.executeQuery("SELECT * FROM testando").data;
for(var i:uint=0; i < obj.length; i++)
{
	trace("linha: "+i);
	for(var j:Object in obj[i])
	{
		trace(j+": "+obj[i][j])
	}
}

/*
Primeiro crie um arquivo novo(air)
crie um campo de texto com o tamanho que desejar
instancie o campo de texto como "texto" (sem as aspas)
cole o codigo a seguir no primeiro frame
*/
 
// importa	as classes necessarias
import flash.display.NativeMenu;
import flash.display.NativeMenuItem;
import flash.display.NativeWindow;
import flash.desktop.NativeApplication;
 
//declara os 2 items do menu
var Menu01:NativeMenuItem;
var Menu02:NativeMenuItem;
 
if (NativeWindow.supportsMenu)// Se o sistema operacional for windows
{
	stage.nativeWindow.menu = new NativeMenu(); //cria o menu
	stage.nativeWindow.menu.addEventListener(Event.SELECT, selecionouUmItem);//adiciona um evento de seleção no menu
	Menu01 = stage.nativeWindow.menu.addItem(new NativeMenuItem("Primeiro item"));//adiciona o primeiro item no menu
	Menu01.submenu = criaSubMenu(); // adiciona o submenu(que vai ser criado logo abaixo) ao primeiro item
	Menu02 = stage.nativeWindow.menu.addItem(new NativeMenuItem("Segundo item"));//adiciona o segundo item no menu
}
 
if (NativeApplication.supportsMenu)// se o sistema operacionall for mac
{
	Menu01 = NativeApplication.nativeApplication.menu.addItem(new NativeMenuItem("Primeiro item"));//adiciona o primeiro item no menu
	NativeApplication.nativeApplication.menu.addEventListener(Event.SELECT, selecionouUmItem);//adiciona um evento de seleção no menu
	Menu01.submenu = criaSubMenu(); // adiciona o submenu(que vai ser criado logo abaixo) ao primeiro item
	Menu02 = NativeApplication.nativeApplication.menu.addItem(new NativeMenuItem("Segundo item"));//adiciona o segundo item no menu
}
 
function criaSubMenu():NativeMenu
{
	var tmpMenu:NativeMenu = new NativeMenu(); // cria o submenu do primeiro item
	var MenuNovo:NativeMenuItem = tmpMenu.addItem(new NativeMenuItem("Novo"));//adiciona o item "Novo" ao submenu
	var MenuSalva:NativeMenuItem = tmpMenu.addItem(new NativeMenuItem("Salva"));//adiciona o item "Salva" ao submenu
	var MenuSair:NativeMenuItem = tmpMenu.addItem(new NativeMenuItem("Sair"));//adiciona o item "Sair" ao submenu
	return tmpMenu;
}
 
function selecionouUmItem(e:Event)
{
	texto.text = e.target.label // escreve o nome do item selecionado no campo de texto
}