<weblogic-application>
<prefer-application-packages>
<package-name>org.hibernate.*</package-name>
<package-name>org.apache.*</package-name>
<package-name>antlr.*</package-name>
    </prefer-application-packages>
</weblogic-application>

<persistence version="1.0"
	xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<persistence-unit name="datasource">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
<property name="hibernate.connection.datasource" value="jdbc/appName"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.Oracle9iDialect" />
<property name="hibernate.default_schema" value="DB_OWNER"/>
<property name="hibernate.query.factory_class" value="org.hibernate.hql.classic.ClassicQueryTranslatorFactory"/>
<property name="hibernate.transaction.manager_lookup_class" value="org.hibernate.transaction.WeblogicTransactionManagerLookup"/>
		</properties>
	</persistence-unit>
</persistence>

package br.com.gvt.cdi.dao.hibernate.base;
 
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
 
public abstract class DaoBase {
	//--------------------------------------------------------------------------
	private static final String PERSISTENCE_UNIT = "datasource";
	//--------------------------------------------------------------------------
	/**
	 * Método que retorna um gerenciador de entidade instânciado
	 *
	 * @return EntityManager
	 */
	protected EntityManager getEntityManager() {
		/*
		 *  criando um factory, pegando as configurações de acesso
		 *  a base de dados da aplicação
		 */
		EntityManagerFactory entityManagerFactory = Persistence
		.createEntityManagerFactory(PERSISTENCE_UNIT);
 
		// retorna a instância do gerenciador de entidades
		return entityManagerFactory.createEntityManager();
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
 
    <display-name>HelloWorld</display-name>
    <description>BlazeDS Application</description>
 
    <!-- Http Flex Session attribute and binding listener support -->
<listener>
<listener-class>flex.messaging.HttpFlexSession</listener-class>
    </listener>
 
    <!-- MessageBroker Servlet -->
    <servlet>
        <servlet-name>MessageBrokerServlet</servlet-name>
        <display-name>MessageBrokerServlet</display-name>
        <servlet-class>flex.messaging.MessageBrokerServlet</servlet-class>
        <init-param>
<param-name>services.configuration.file</param-name>
<param-value>/WEB-INF/flex/services-config.xml</param-value>
       </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
	<!-- é importante que esteja descomentado -->
    <servlet>
        <servlet-name>RDSDispatchServlet</servlet-name>
		<display-name>RDSDispatchServlet</display-name>
        <servlet-class>flex.rds.server.servlet.FrontEndServlet</servlet-class>
		<init-param>
<param-name>useAppserverSecurity</param-name>
			 <!-- como não iremos utilizar autenticação -->
<param-value>false</param-value>
		</init-param>
        <load-on-startup>10</load-on-startup>
    </servlet>
 
    <servlet-mapping id="RDS_DISPATCH_MAPPING">
        <servlet-name>RDSDispatchServlet</servlet-name>
        <url-pattern>/CFIDE/main/ide.cfm</url-pattern>
    </servlet-mapping>
 
    <servlet-mapping>
        <servlet-name>MessageBrokerServlet</servlet-name>
        <url-pattern>/messagebroker/*</url-pattern>
    </servlet-mapping>
 
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
    </welcome-file-list>
 
</web-app>

package com.erkobridee.helloworld.flex.service;
 
/**
 * @author Erko
 * @description Classe de serviço
 *
 */
public class HelloWorld {
 
	public String sayHello() {
		return "Hello Flex 4 o/";
	}
 
	public String sayHelloTo(String name) {
		String message = "Hello, " + name;
		System.out.println(message);
		return message;
	}
 
}

<destination id="helloWorldService">
<properties>
		<source>com.erkobridee.helloworld.flex.service.HelloWorld</source>
	</properties>
</destination>

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600">
 
	<!-- ___________________________________________________________________ -->
 
	<fx:Script>
		<![CDATA[
			import mx.controls.Alert;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
 
			//------------------------------------------------------------------
			// Handlers Remote Object formato antigo
 
			protected function roService_faultHandler(event:FaultEvent):void
			{
				Alert.show( event.fault.message );
			}
 
			private function roService_sayHello_ResultHandler(event:ResultEvent):void {
				Alert.show( event.result as String );
			}
 
			private function roService_sayHelloTo_ResultHandler(event:ResultEvent):void {
				Alert.show( event.result as String );
			}			
 
			//------------------------------------------------------------------
			// evento de click nos botões : Remote Object formato antigo
 
			protected function sayHelloBtnRO_clickHandler(event:MouseEvent):void
			{
				this.roService.sayHello();
			}
 
			protected function sayHelloToNameBtnRO_clickHandler(event:MouseEvent):void
			{
				this.roService.sayHelloTo(nameFieldRO.text);
			}
 
			//------------------------------------------------------------------
 
		]]>
	</fx:Script>
 
	<!-- ___________________________________________________________________ -->
 
	<fx:Declarations>
		<!-- Place non-visual elements (e.g., services, value objects) here -->
 
		<s:RemoteObject
			id="roService"
			destination="helloWorldService"
			fault="roService_faultHandler(event)">
			<!-- esse formato é útil quando se tem um tipo de resultado para cada método -->
			<s:method name="sayHello" result="roService_sayHello_ResultHandler(event)"/>
			<s:method name="sayHelloTo" result="roService_sayHelloTo_ResultHandler(event)"/>
		</s:RemoteObject>
 
	</fx:Declarations>
 
	<!-- ___________________________________________________________________ -->
 
	<s:Panel x="10" y="10" width="250" title="<mx:RemoteObject>">
		<s:VGroup x="0" y="0" width="100%" height="100%">
			<mx:Form width="100%">
				<mx:FormItem label="Name">
					<s:TextInput id="nameFieldRO" text="Remote Object"/>
				</mx:FormItem>
			</mx:Form>
			<s:HGroup width="100%" horizontalAlign="center">
				<s:Button label="sayHello" id="sayHelloBtnRO" click="sayHelloBtnRO_clickHandler(event)"/>
				<s:Button label="sayHelloToName" id="sayHelloToNameBtnRO" click="sayHelloToNameBtnRO_clickHandler(event)"/>
			</s:HGroup>
		</s:VGroup>
	</s:Panel>
 
	<!-- Por enquanto não foi implementado os códigos dessa parte
	<s:Panel x="268" y="10" width="250" title="Data Wizard">
		<s:VGroup x="0" y="0" width="100%" height="100%">
			<mx:Form width="100%">
				<mx:FormItem label="Name">
					<s:TextInput id="nameFieldDW" text="Data Wizard"/>
				</mx:FormItem>
			</mx:Form>
			<s:HGroup width="100%" horizontalAlign="center">
				<s:Button label="sayHello" id="sayHelloBtnDW"/>
				<s:Button label="sayHelloToName" id="sayHelloToNameBtnDW"/>
			</s:HGroup>
		</s:VGroup>
	</s:Panel>
	-->
 
</s:Application>

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600" xmlns:service="service.*">
 
	<!-- ___________________________________________________________________ -->
 
	<fx:Script>
		<![CDATA[
			import mx.controls.Alert;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
 
			//------------------------------------------------------------------
			// Handlers Remote Object formato antigo
 
			protected function roService_faultHandler(event:FaultEvent):void
			{
				Alert.show(event.fault.faultString + '\n' + event.fault.faultDetail);
			}
 
			private function roService_sayHello_ResultHandler(event:ResultEvent):void {
				Alert.show( event.result as String );
			}
 
			private function roService_sayHelloTo_ResultHandler(event:ResultEvent):void {
				Alert.show( event.result as String );
			}			
 
			//------------------------------------------------------------------
			// evento de click nos botões : Remote Object formato antigo
 
			protected function sayHelloBtnRO_clickHandler(event:MouseEvent):void
			{
				this.roService.sayHello();
			}
 
			protected function sayHelloToNameBtnRO_clickHandler(event:MouseEvent):void
			{
				this.roService.sayHelloTo(nameFieldRO.text);
			}
 
//============================================================================================
 
			//------------------------------------------------------------------
			// Handlers Data Wizard formato novo
 
			protected function helloWorldService_faultHandler(event:FaultEvent):void
			{
				Alert.show(event.fault.faultString + '\n' + event.fault.faultDetail);
			}			
 
			protected function sayHelloResult_resultHandler(event:ResultEvent):void
			{
				Alert.show( event.result as String );
			}			
 
			protected function sayHelloToResult_resultHandler(event:ResultEvent):void
			{
				Alert.show( event.result as String );
			}			
 
			//------------------------------------------------------------------
			// evento de click nos botões : Data Wizard formato novo
 
			protected function sayHelloBtnDW_clickHandler(event:MouseEvent):void
			{
				sayHelloResult.token = helloWorldService.sayHello();
			}		
 
			protected function sayHelloToNameBtnDW_clickHandler(event:MouseEvent):void
			{
				sayHelloToResult.token = helloWorldService.sayHelloTo(nameFieldDW.text);
			}
 
		]]>
	</fx:Script>
 
	<!-- ___________________________________________________________________ -->
 
	<fx:Declarations>
		<!-- Place non-visual elements (e.g., services, value objects) here -->
 
		<s:RemoteObject
			id="roService"
			destination="helloWorldService"
			fault="roService_faultHandler(event)">
			<!-- esse formato é útil quando se tem um tipo de resultado para cada método -->
			<s:method name="sayHello" result="roService_sayHello_ResultHandler(event)"/>
			<s:method name="sayHelloTo" result="roService_sayHelloTo_ResultHandler(event)"/>
		</s:RemoteObject>
 
		<!-- __________________________________ -->
 
		<!-- equivalente ao s:method sayHello -->
		<s:CallResponder id="sayHelloResult" result="sayHelloResult_resultHandler(event)"/>
 
		<!-- equivalente ao s:method sayHelloTo -->
		<s:CallResponder id="sayHelloToResult" result="sayHelloToResult_resultHandler(event)"/>
 
		<!-- equivalente ao s:RemoteObject roService -->
		<service:HelloWorldService
			id="helloWorldService"
			fault="helloWorldService_faultHandler(event)"
			showBusyCursor="true"/>
 
	</fx:Declarations>
 
	<!-- ___________________________________________________________________ -->
 
	<s:Panel x="10" y="10" width="250" title="<mx:RemoteObject>">
		<s:VGroup x="0" y="0" width="100%" height="100%">
			<mx:Form width="100%">
				<mx:FormItem label="Name">
					<s:TextInput id="nameFieldRO" text="Remote Object"/>
				</mx:FormItem>
			</mx:Form>
			<s:HGroup width="100%" horizontalAlign="center">
				<s:Button label="sayHello" id="sayHelloBtnRO" click="sayHelloBtnRO_clickHandler(event)"/>
				<s:Button label="sayHelloToName" id="sayHelloToNameBtnRO" click="sayHelloToNameBtnRO_clickHandler(event)"/>
			</s:HGroup>
		</s:VGroup>
	</s:Panel>
 
	<s:Panel x="268" y="10" width="250" title="Data Wizard">
		<s:VGroup x="0" y="0" width="100%" height="100%">
			<mx:Form width="100%">
				<mx:FormItem label="Name">
					<s:TextInput id="nameFieldDW" text="Data Wizard"/>
				</mx:FormItem>
			</mx:Form>
			<s:HGroup width="100%" horizontalAlign="center">
				<s:Button label="sayHello" id="sayHelloBtnDW" click="sayHelloBtnDW_clickHandler(event)"/>
				<s:Button label="sayHelloToName" id="sayHelloToNameBtnDW" click="sayHelloToNameBtnDW_clickHandler(event)"/>
			</s:HGroup>
		</s:VGroup>
	</s:Panel>
 
</s:Application>

package com.erkobridee.blazeds.util;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;
 
import flex.messaging.FlexContext;
 
/**
 * @author Erko Bridee
 * @description Classe de gerenciamento de arquivos
 *
 */
public class FileUtils {
 
	private String dirPath = "files_dir";
 
	/**
	 * Método para receber um arquivo
	 *
	 * @param bytes byte[]
	 * @param fileName String
	 * @return String
	 * @throws Exception
	 */
	public String  doUpload(
			byte[] bytes, // bytes do arquivo
			String fileName // nome do arquivo
	) throws Exception {
		fileName = FlexContext.getServletContext().getRealPath(dirPath + "/" + fileName);
 
		System.out.println("doUpload: " + fileName);
 
		File f = new File(fileName);
		FileOutputStream fos = new FileOutputStream(f);
		fos.write(bytes);
		fos.close();
		return "success";
	}
 
	/**
	 * Retorna a listagem dos arquivos disponíveis
	 *
	 * @return List<FileInfo>
	 */
	public List<FileInfo> getDownloadList() throws Exception {
 
		System.out.println(FlexContext.getServletContext().getRealPath(dirPath));
 
		File dir = new File(FlexContext.getServletContext().getRealPath(dirPath));
 
		File[] files = dir.listFiles();
		List<FileInfo> dirList = new ArrayList<FileInfo>();
 
		if (files == null) {
			// caso o diretório não exista ou o caminho seja um diretório
		} else {
			for (int i=0; i<files.length; i++) {
				FileInfo info = new FileInfo();
 
				info.setName( files[i].getName() );
				info.setLength( files[i].length() );
 
				dirList.add( info );
			}
		}
		return dirList;
	}
 
	/**
	 * Método que recupera um arquivo e retorna seus bytes
	 *
	 * @param fileName
	 * @return byte[]
	 */
	public byte[] doDownload(String fileName) {
 
		System.out.println("doDownload: " + fileName);
 
		FileInputStream fis;
		byte[] data =null;
		FileChannel fc; 
 
		try {
			fileName = FlexContext.getServletContext().getRealPath(dirPath + "/" + fileName);
 
			fis = new FileInputStream(fileName);
			fc = fis.getChannel();
			data = new byte[(int)(fc.size())];
			ByteBuffer bb = ByteBuffer.wrap(data);
			fc.read(bb);
		} catch (FileNotFoundException e) {
			// TODO
		} catch (IOException e) {
			// TODO
		}
		return data;
	}	
 
	/**
	 * Método para apagar um determinado arquivo
	 *
	 * @param filename String
	 * @return String
	 */
	public String doDelete(String fileName) {
		String message = "fail";
 
		fileName = FlexContext.getServletContext().getRealPath(dirPath + "/" + fileName);
 
		System.out.println("doDelete: " + fileName);
 
		File file = new File(fileName);
		if( file.exists() ) {
			if( file.delete() ) {
				message = "success";
			}
		} 
 
		return message;
	}
 
}

<destination id="fileUtilService">
<properties>
		<source>com.erkobridee.blazeds.util.FileUtils</source>
	</properties>
</destination>

<mx:Panel
	xmlns:mx="http://www.adobe.com/2006/mxml"
	layout="vertical"
	width="100%"  height="100%"
	title="Upload : Arquivos">
 
	<mx:Script>
		<![CDATA[
			import vo.FileInfo;
			import mx.controls.Alert;
			import mx.rpc.AsyncToken;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
 
			private var refUploadFile:FileReference;
 
			private var UploadFiles:Array = new Array();
 
			/*
				Chamado para adicionar os arquivos para upload
			*/
			private function addFiles():void {
				var FILE_FILTER_ALL_FILES_TYPE:Array = [new FileFilter("All files", "*.*")];
 
				refUploadFile = new  FileReference();
	  			refUploadFile.browse(FILE_FILTER_ALL_FILES_TYPE);
	  			refUploadFile.addEventListener(Event.SELECT,onFileSelect);
	  			refUploadFile.addEventListener(Event.COMPLETE,onFileComplete);
 
	  			refUploadFile.addEventListener(IOErrorEvent.IO_ERROR, frIOError);
    			refUploadFile.addEventListener(SecurityErrorEvent.SECURITY_ERROR, frSecError);
 
			}
 
			/*
				Chamado quando os arquivos são selecionado
			*/
			private function onFileSelect(event:Event):void {
 
				UploadFiles.push({
					name:refUploadFile.name,
					size:FileInfo.formatFileSize(refUploadFile.size),
					status:"inicial"
				});
 
				listFiles.dataProvider  = UploadFiles;
				listFiles.selectedIndex = UploadFiles.length - 1;
 
				try {
					refUploadFile.load();
				} catch( err:IOErrorEvent ) {
					Alert.show("erro");
				}
 
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == refUploadFile ) {
						UploadFiles[i].status = "carregado";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
			}
 
			/*
				Chamado quando for formatar a representação do tamanho do arquivo
			*/
			private function formatFileSize(numSize:Number):String {
				var strReturn:String;
				numSize = Number(numSize / 1000);
				strReturn = String(numSize.toFixed(1) + " KB");
				if (numSize > 1000) {
					numSize = numSize / 1000;
					strReturn = String(numSize.toFixed(1) + " MB");
					if (numSize > 1000) {
						numSize = numSize / 1000;
						strReturn = String(numSize.toFixed(1) + " GB");
					}
				}
				return strReturn;
			}
 
			private function onFileComplete(event:Event):void {
 
				refUploadFile = event.currentTarget as FileReference;
				var data:ByteArray = refUploadFile.data;  
 
				var token:AsyncToken = AsyncToken(
					remoteUpload.doUpload(data, refUploadFile.name)
				);
 
				token.kind = refUploadFile.name;
 
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == refUploadFile ) {
						UploadFiles[i].status = "enviando";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
			}
 
	  		private function uploadResultHandler(event:ResultEvent):void {
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == event.token.kind ) {
						UploadFiles[i].status = "OK";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
	  		}
 
	  		private function faultResultHandler(event:FaultEvent):void {
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == event.token.kind ) {
						UploadFiles[i].status = "erro";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
	  		}
 
			private function frIOError(evt:IOErrorEvent):void{
			    Alert.show(evt.toString());
			}
 
			private function frSecError(evt:SecurityErrorEvent):void{
			    Alert.show(evt.toString());
			}
 
			private function clearUploadList():void {
				UploadFiles = null;
				UploadFiles = new Array();
				listFiles.dataProvider = UploadFiles;
			}
 
		]]>
	</mx:Script>
 
	<mx:RemoteObject
		id="remoteUpload"
		destination="fileUtilService"
		result="uploadResultHandler(event)"
		fault="faultResultHandler(event)"/>
 
	<mx:Canvas width="100%" height="100%">
		<mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
			allowMultipleSelection="true" verticalScrollPolicy="on"
			draggableColumns="false" resizableColumns="false" sortableColumns="false">
			<mx:columns>
				<mx:DataGridColumn headerText="Arquivo" width="150" dataField="name" wordWrap="true"/>
				<mx:DataGridColumn headerText="Tamanho" width="50" dataField="size" textAlign="right"/>
				<mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
			</mx:columns>
		</mx:DataGrid>
	</mx:Canvas>
	<mx:ControlBar horizontalAlign="center" verticalAlign="middle">
		<mx:Button
			id="btnAdd"
			toolTip="Adicionar arquivo(s)"
			click="addFiles()"
			label="Upload : Arquivo(s)"
			width="150"/>
		<mx:Button
			label="Limpar lista"
			click="{clearUploadList()}"/>
	</mx:ControlBar>
 
</mx:Panel>

<mx:Panel
	xmlns:mx="http://www.adobe.com/2006/mxml"
	layout="vertical"
	width="100%" height="100%"
	title="Download : Arquivos">
 
	<mx:Script>
		<![CDATA[
 
			import mx.controls.Alert;
			import mx.collections.ArrayCollection;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
			import mx.rpc.AsyncToken;
 
			private var downloadFiles:ArrayCollection = new ArrayCollection();
			private var downloadFilesColl:ArrayCollection = new ArrayCollection();
			private var fileData:ByteArray = new ByteArray();
			private var fileName:String;
 
			private function downloadResultHandler(event:ResultEvent):void {
				if ( event.token.kind == "remoteFileList") {
					downloadFiles.removeAll();
					downloadFilesColl = event.result as ArrayCollection;
					for ( var i:int = 0 ; i <  downloadFilesColl.length ; i++ ) {
						downloadFiles.addItem({
							name:downloadFilesColl[i].name,
							size:downloadFilesColl[i].size,
							status:"Inicial"
						});
					}
					listFiles.dataProvider = downloadFiles;
				} else if(event.token.kind == "remoteDeleteFile") {
					Alert.show( event.result as String );
					getRemoteFiles();
				} else  {
					fileData = event.result as ByteArray;
					fileName = event.token.kind;
 
					Alert.show(fileName);
 
					for ( var b:int = 0 ; b <  downloadFiles.length ; b++ ) {
						if( downloadFiles[b].name == event.token.kind ) {
							downloadFiles[b].status = "Pronto";
							listFiles.dataProvider  = downloadFiles;
							break;
						}
					}
				}
			}
 
			private function faultResultHandler(event:FaultEvent):void {}
 
			private function saveFile():void {
				var fileReference:FileReference = new FileReference();
				fileReference.save(fileData,fileName);
			}
 
			private function getRemoteFiles():void {
				var token:AsyncToken = AsyncToken(remoteDownload.getDownloadList());
				token.kind = "remoteFileList";
			}
 
			private function getDownload():void {
				var token:AsyncToken = AsyncToken(remoteDownload.doDownload(listFiles.selectedItem.name));
				token.kind = listFiles.selectedItem.name;
			}
 
			private function doDelete():void {
				var token:AsyncToken = AsyncToken(remoteDownload.doDelete(listFiles.selectedItem.name));
				token.kind = "remoteDeleteFile";
			}
		]]>
	</mx:Script>
 
	<mx:RemoteObject
		id="remoteDownload"
		destination="fileUtilService"
		result="downloadResultHandler(event)"
		fault="faultResultHandler(event)"
		showBusyCursor="true"/>
 
	<mx:Canvas width="100%" height="100%">
		<mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
			verticalScrollPolicy="on"
			draggableColumns="false" resizableColumns="false" sortableColumns="false">
			<mx:columns>
				<mx:DataGridColumn headerText="Arquivo" width="150" dataField="name" wordWrap="true"/>
				<mx:DataGridColumn headerText="Tamanho" width="50" dataField="size" textAlign="right"/>
				<mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
			</mx:columns>
 
		</mx:DataGrid>
	</mx:Canvas>
	<mx:ControlBar horizontalAlign="center" verticalAlign="middle">
		<mx:Button id="btnList" toolTip="Listar arquivos remotos"
			label="Listar arquivos"
			click="getRemoteFiles()"/>
		<mx:Button id="btnRetrieve" toolTip="Pegar arquivo"
			 click="getDownload()" label="Pegar arquivo"/>
		<mx:Button id="btnSave" toolTip="Salvar arquivo"
			 click="saveFile()" label="Salvar arquivo"/>
		<mx:Button label="Apagar arquivo" click="doDelete()"/>
	</mx:ControlBar>
 
</mx:Panel>