Cadastro básico com grid e formulário

Yesterday I was asked about a demo that demonstrated a basic registration screen with the list of records in one side and the form registration on the other. As said, it’s a simple interface for entries, where you view the records written in a list, and clicking on any record their data is loaded in the form. Once changed, the data are submit, and the grid is reloaded. The Ex has this example, but what differs is that my uses object oriented code and has the option to save the data.

Base Class

Will be neither a form that will contain a grid or a grid containing a form. It will be a panel with two items inside. This panel arrange the layout and also will conduct the business rule that exists between the grid and form.

GridForm = Ext.extend(Ext.Panel,{
	
	//Config Options {
	
		 title			: 'Usuários'
		,iconCls		: 'silk-user'
		,layout			: 'hbox'
		,layoutConfig	: {align: 'stretch'}
		
	//}
	
	//Inits {
	
		,initComponent: function()
		{
			//..aqui será criado o grid e o form 
			
			GridForm.superclass.initComponent.call(this);
		}
		
		,initEvents: function()
		{
			GridForm.superclass.initEvents.call(this);
			
			//aqui definiremos alguns eventos
		}
		
	//}
	
	//Listeners {
	//}
	
});

Ext.reg('bt-gridform',GridForm);

Grid

Not many secrets here. Just set the datastore, columns, and some optional settings. Interestingly, the datastore declares three fields – id, name and login – and grid declares only two columns – name and login. The ID field will be hidden but available even though I have no column for it.

this._grid = new Ext.grid.GridPanel({
	 flex		: 1
	,bodyStyle	: 'border-width:0 1px 0 0;'
	,viewConfig	: {forceFit:true}
	,store		: new Ext.data.JsonStore({
		 autoLoad	: true
		,autoDestroy: true
		,proxy		: new Ext.data.HttpProxy({url: 'usuarios.json', method: 'GET'})
		,fields		: [
			 {name:'id'		, type:'int'	}
			,{name:'nome'	, type:'string'	}
			,{name:'login'	, type:'string'	}
		]
	})
	,columns: [{
		 header		: 'Nome'
		,dataIndex	: 'nome'
	},{
		 header		: 'Login'
		,dataIndex	: 'login'
	}]
});

Form

Also not many secrets here. For the id to be passed to the server on submit I chose to create a hidden field. Also important to note the existence of the password field. Is not it interesting to show the password in the grid, but at submission time this is a important information for my user registration.

this._form = new Ext.form.FormPanel({
	 defaultType: 'textfield'
	,labelAlign	: 'top'
	,padding	: '10'
	,width		: 300
	,border		: false
	,defaults	: {anchor: '-10'}
	,items		: [{
		 xtype	: 'hidden'
		,name	: 'id'
	},{
		 fieldLabel	: 'Nome'
		,name		: 'nome'
		,allowBlank	: false
	},{
		 fieldLabel	: 'Login'
		,name		: 'login' 
		,allowBlank	: false 
	},{
		 fieldLabel	: 'Senha'
		,inputType	: 'password'
		,name		: 'senha'
	}]
	,buttons:[{
		 text	: 'Salvar'
		,scope	: this
		,handler: this._onBtnSalvarClick					 
	},{
		 text	: 'Alterar'
		,hidden	: true
		,scope	: this
		,handler: this._onBtnSalvarClick
	},{
		 text	: 'Limpar'
		,scope	: this
		,handler: this._onBtnLimparClick
	}]
});

Loading grid on row click

First we attach a listener to the event “click on a line” on the grid. Then we used the method loadRecord of Ext.form.BasicForm (all Ext.form.FormPanel has a BasicForm in it) to load the data

,initEvents: function()
{
	GridForm.superclass.initEvents.call(this);
	
	this._grid.getSelectionModel().on('rowselect',this._onGridRowSelect,this);
}

//...

,_onGridRowSelect: function(selectionModel, rowIndex, record ) 
{
	var form = this._form.getForm(); 
	
	form.loadRecord(record);
	form.findField('nome').focus(false,true);
	
	this._form.buttons[0].hide(); //salvar
	this._form.buttons[1].show(); //alterar
}

Submit the form and reload the grid

When you click Save / Update I submit the form, displaying a message while the process is not finished. When finalized (the server returns success: true) we can clear the form and reload the grid.

,_onBtnSalvarClick: function()
{
	var form = this._form.getForm(); 
	
	if(!form.isValid()){
		return false;
	}
	
	form.submit({
		 url		: 'usuariosubmit.json' //do nothing
		,waitTitle	: 'Aguarde'
		,waitMsg	: "Enviando dados..."
		,scope		: this
		,success	: function()
		{
			this._onBtnLimparClick();
			this._grid.store.reload();
		}	
	});
}

Resume

And our basic registration is ready. You just have to do all the coding for server data to be persisted. Here are the links to the full code and online demo. Ps: I didn’t code the persistent stuff so if you change any registry or create a new, nothing will happen.

Until next time!

server-side.zip

Full code

Demo Online

Online demo

LinkedInDeliciousPinterestTumblrEmailShare

Como abrir páginas de um menu no centro de sua aplicação

Sorry, this entry is only available in Português.

Muitas aplicações se baseiam em um layout com links na esquerda e com um tabPanel ao centro. Depois de responder alguns posts no fórum brasileiro sobre como abrir itens de um menu em um tabPanel central, estou escrevendo sobre o assunto aqui no blog através de tutorial.

Primeiramente vamos criar uma subpasta abrirPaginaCentro dentro da pasta examples do Ext. Depois disso criar um arquivo index.html com o código abaixo e um arquivo abrirPaginaCentro.js, por enquanto em branco.

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
        <title>Abrindo páginas de menu no centro da aplicação - www.extdesenv.com.br</title>

		<!--css-->
        <link rel="stylesheet" type="text/css" href="../../resources/css/ext-all.css"/>
        <link rel="stylesheet" type="text/css" href="../shared/examples.css" />
        <link rel="stylesheet" type="text/css" href="../shared/icons/silk.css" />
        <style type="text/css">
            .no-icon {
                display: none;
            }
        </style>

        <!--js-->
        <script type="text/javascript" src="../../adapter/ext/ext-base.js"></script>
        <script type="text/javascript" src="../../ext-all.js"></script>
        <script type="text/javascript" src="abrirPaginaCentro.js"></script>
    </meta></head>
    <body>
    </body>
</html>

Sua configuração deve estar assim:

  • examples
    • abrirPaginaCentro
      • abrirPaginaCentro.js
      • index.html

Então agora no arquivo JS vou criar definir uma nova classe AbrirPaginaCentro:

var AbrirPaginaCentro = Ext.extend(Ext.util.Observable,{

	constructor: function(){
		//..aqui vai toda definição dos componentes...

		//super
		AbrirPaginaCentro.superclass.constructor.apply(this,arguments);
	}
});

Ext.onReady(function()
{
	new AbrirPaginaCentro();
});

Feito esse esqueleto de classe vamos em 3 passos fazer tudo funcionar:

  1. Crio os componentes: o tabPanel, o viewport para conter os itens, e o menu lateral formado de um painel accordion com treePanels. O seu menu lateral pode ser o que quiser, treePanels, labels, buttons…Não importa o componente, o que importa é que quando clicado dispare um evento.

    //tabPanel
    this.tabPanelCentral = new Ext.TabPanel({
        region		: 'center',
        activeTab	: 0,
        defaults	: {closable: true},
        items		: [{
            title		: 'Portal',
            closable	: false
        }]
    });
    
    //criar layout
    new Ext.Viewport({
    	 layout	: 'border'
    	,items	: [{
    	//menu lateral
    		 region			: 'west'
    		,layout			: 'accordion'
    		,defaultType	: 'treepanel'
    		,width			: 300
    		,split			: true
    		,layoutConfig	: {fill: false, animate:true}
    		,defaults		: {
    			 border		: false
    			,rootVisible: false
    			,listeners:{
    				 scope: this
    				,click: this.onNodeClick
    			}
    		}
    		,items			: [{
    			 title	: 'Cadastros'
    			,iconCls: 'silk-add'
    			,root	: {
    				children: [
    					 {text:'Atendentes'		, leaf:true, iconCls:'no-icon'}
    					,{text:'Solicitantes'	, leaf:true, iconCls:'no-icon'}
    					,{text:'Clientes'		, leaf:true, iconCls:'no-icon'}
    					,{text:'Representantes'	, leaf:true, iconCls:'no-icon'}
    					,{text:'Produtos'		, leaf:true, iconCls:'no-icon'}
    					,{text:'Distribuidores'	, leaf:true, iconCls:'no-icon'}
    					,{text:'Compromissos'	, leaf:true, iconCls:'no-icon'}
    				]
    			}
    		},{
    			 title	: 'Configurações'
    			,iconCls: 'silk-cog'
    			,root	: {
    				children: [
    					 {text:'Feriados'		  ,leaf:true,iconCls:'no-icon'}
    					,{text:'Permissões'		  ,leaf:true,iconCls:'no-icon'}
    					,{text:'Horários'		  ,leaf:true,iconCls:'no-icon'}
    					,{text:'Cargas'			  ,leaf:true,iconCls:'no-icon'}
    					,{text:'Acesso ao sistema',leaf:true,iconCls:'no-icon'}
    				]
    			}
    		},{
    			 title	: 'Relatórios'
    			,iconCls: 'silk-grid'
    			,root	: {
    				children: [
    					 {text:'Tempo Trabalhado por Atendente',leaf:true,iconCls:'no-icon'}
    					,{text:'Vendas por Cliente'			   ,leaf:true,iconCls:'no-icon'}
    					,{text:'Rotas de Distribuição'		   ,leaf:true,iconCls:'no-icon'}
    					,{text:'Performance dos Representantes',leaf:true,iconCls:'no-icon'}
    				]
    			}
    		}]
    	},
    	//tabpanel central
    	this.tabPanelCentral]
    });
  2. Perceba que pouco antes de definir os TreePanels eu associei uma função (listener) ao evento click a cada um deles. Essa função deve ser definida em nossa classe. A documentação do Ext nos diz quais os parâmetros receber nesse listener:

    //...
    ,listeners:{
    	 scope: this
    	,click: this.onNodeClick
    }
    
    //...
    ,onNodeClick: function( node )
    {
    	//aqui vai nossa rotina para criar as abas
    }
    
  3. Por fim, nessa função vou implementar uma regra de negócio. Nela vou tentar procurar uma aba com a mesma descrição do item de menu que foi clicado. Se não existir, eu crio com o método add, se existir eu somente ativo. Isso evita a criação de abas duplicadas.

    ,onNodeClick: function( node )
    {
    	var titulo = node.text;
    	var novaAba = this.tabPanelCentral.items.find(function( aba ){ return aba.title === titulo; });
    
    	if(!novaAba)
    	{
    		novaAba = this.tabPanelCentral.add({
    			  title	: titulo
    			 ,html	: 'nova aba:' +  titulo
    		});
    	}
    
    	this.tabPanelCentral.activate(novaAba);
    }

E pronto! Temos aí links em um menu lateral abrindo novas abas no tabPanel central sem duplicar as abas. Não irei abordar como carregar conteúdo nas abas, mas no código fonte fiz algumas observações que podem guiá-lo nessa tarefa. Além disso temos exemplos mais completos no blog que podem também lhe ajudar, como por exemplo o Crud Avançado e Carregar códig Ext sob demanda

Forte abraço e até a próxima!

server-side.zip

Código Completo

Demo Online

Demo Online

LinkedInDeliciousPinterestTumblrEmailShare

Estudo sobre layout fit: encaixando componentes em 100% de largura e altura

Estou de volta (eeeee)!  Depois de umas férias pude descansar um montão e estou retomando minhas atividades no trabalho, comunidade Ext, ExtDesenv e etc… 2009 foi um ano muito bacana pro ExtDesenv. Foi o ano de criação do blog e também pude tirar umas experiências boas para fazer melhor no ano de 2010. Em particular notei que os posts e assuntos aqui abordados estavam num nível técnico um pouco complicado. Por isso estou iniciando uma série de artigos mais “relax”. Alguns estudos, exemplos e explicações sobre coisas casuais do cotidiano Ext (: É o caso do post de hoje, vamos lá!

“Eu quero que esse componente ocupe toda a largura e altura disponível”
“Tentei de tudo mas esse cara não redimensiona ocupando 100% da área”
“Coloquei autoWidth e autoHeight mas a largura e altura não ficam automaticamente do tamanho total disponível”

Essas são apenas alguns questionamentos facilmente solucionáveis com o uso do layout fit! Mas antes de começar a codificar vamos deixar claro alguns conceitos:

Um componente que pode conter outros componentes é chamado “Container”. Um painel (Ext.Panel), um viewport (Ext.Viewport), ou uma janela (Ext.Window) são bons exemplos de containers.

Os programadores por trás do Ext desenvolveram um método muito eficiente para organizar os componentes dentro de um container. Eles definiram uma série de layouts pré-definidos que reagem de forma diferente a ações como redimensionamento, tornar visível ou não, expandir ou contrair, etc… Esses layouts estão reunídos no pacote Ext.layout e bem exemplificados no exemplo Layout Browser (navegue um pouco nesse exemplo e veja as diferentes características de cada layout). Para fazer uso de um layout basta declará-lo no container dessa forma.

Ext.onReady(function()<br />
{<br />
	new Ext.Viewport({<br />
		 layout	: &quot;fit&quot;<br />
		,items	: {<br />
			 xtype	: &quot;panel&quot;<br />
			,title	: &quot;Painel 100%&quot;<br />
			,html	: &quot;&lt;p&gt;Eu ocupo 100% da área do viewport!&quot;<br />
		}<br />
	});<br />
});

Você deve ficar atento para as premissas de cada layout. O border layout exige um componente na região central, o layout fit só pode gerenciar um único componente filho do container, etc…

A função do layout fit é “fazer um componente ocupar 100% da área de seu container, independente de redimensionamento”. Como eu disse, esse layout serve para gerenciar um único filho do container (pode colocar outro, eles serão jogados para fora da tela).

Ext.onReady(function()<br />
{<br />
	//uma simples declaração de um grid<br />
	var grid = new Ext.grid.GridPanel({<br />
	     title		: &quot;Grid&quot;<br />
		,autoScroll	: true<br />
	    ,columns	: [{<br />
			 header		: &quot;Coluna 1&quot;<br />
			,dataIndex	: &quot;col1&quot;<br />
		},{<br />
			 header		: &quot;Coluna 2&quot;<br />
			,dataIndex	: &quot;col2&quot;<br />
		}]<br />
		,store:  new Ext.data.SimpleStore({<br />
		    fields: [&quot;col1&quot;,&quot;col2&quot;]<br />
			,data: [<br />
				 ['1x1','1x2'],['2x1','2x2'],['3x1','3x2'],['4x1','4x2']<br />
			]<br />
		})<br />
	})</p>
<p>	//uma simples declaração de janela com layout fit e o grid dentro<br />
	var janela = new Ext.Window({<br />
	     title	: &quot;Me redimensione!&quot;<br />
		,layout	: &quot;fit&quot;<br />
	    ,width	: 500<br />
	    ,height	: 400<br />
	    ,items	: grid<br />
	});</p>
<p>	janela.show();<br />
});

O trecho acima cria uma janela, e dentro dela um grid. Não importa de que maneira a janela seja redimensionada o grid vai sempre ocupar 100% do espaço disponível no corpo da janela. Como o grid tem autoScroll:true, se o seu conteúdo extrapolar os seus limites o scroll vai ser criado.

Ok, você partiu de uma janela para deixar o grid redimensionável com a opção de scroll ou não, mas se eu quiser que ele ocupe TODA A TELA, toda a área disponível pelo browser? Temos um componente especial para isso chamado viewport. O Viewport é ponto de partida de grande parte dos sistemas Ext. Você não precisa declarar height, nem width, muito menos colocar autoHeight true ou autoWidth:true. O simples fato de instanciar o viewport já possibilita fazer uso de todo espaço visível do browser. Então partindo de um viewport é possível criar um grid que ocupe todo espaço visível da tela.

new Ext.Viewport({<br />
	 layout	: &quot;fit&quot;<br />
	,items	: grid<br />
});

Resolução de problemas

“Eu declarei layout fit, mas ainda assim não ocupa 100% da área!”

Consigo pensar em 2 possíveis problemas:

  1. você tem algum autoHeight ou autoWidth gerando problemas para o Ext ler as dimensões dos componentes. Para fazer com que um componente tenha 100% da área o Ext precisa de dimensões exatas para trabalhar.
  2. O problema não está no componente com layout fit, mas sim no seu pai ou em algum lugar acima na hierarquia. Quer encontrar problemas de layout e resolvê-los de uma maneira mais eficiente? “Comece por cima e vá descendo”. Verifique se o layout do Viewport está ok, se o layout do painel dentro do viewport está ok, e assim por diante…

Concluindo

Abordamos de maneira bem simplista o conceito de container, comentei sobre o uso de layouts do Ext e aprofundei o assunto um pouco mais no layout fit. Este layout faz com que um componente ocupe 100% da área de seu container, e para usá-lo basta declarar layout:fit no container. Problemas decorrentes do uso de layout fit podem ser culpa do uso de autoHeight e autoWidth ou então algum problema no container ou algum outro componente acima na hierarquia.

Dúvidas, problemas e afins comentem (: Forte abraço e até a próxima!

LinkedInDeliciousPinterestTumblrEmailShare

Material de Estudo Ext JS 3.0: slides da Conferência 2009

A primeira conferência anual da comunidade Ext JS ocorreu em abril deste ano. Ela não foi oficialmente gravada (algum participante gravou?) mas teve uma bela cobertura no twitter, por participantes que ficaram minuto a minuto mantendo informados aqueles como eu que não puderam ir até Orlando, EUA. Parte desse material foi utilizado aqui no ExtDesenv inclusive: Cobertura parcial da Ext Conference

Acontece que essa semana estava eu navegando pelo fórum americano e encontrei um post do Abe Elias (Ext JS management team) disponibilizando links dos materiais e slides apresentados na conferência. Me desculpem a ignorância caso alguém já tivesse reparado, mas se vocês entrarem na agenda da conferência, notem um pequeno ícone em determinadas palestras.

ext-conference-link

Esse pequeno ícone é na verdade um link para o material da palestra (péssima divulgação por sinal). Estão disponíveis:

  • O que há de novo e como usá-lo – Ext JS 3.0

    Visão geral de tudo que foi feito de novo, e tudo o que foi melhorado na versão 3.0.

  • Ext JS e Adobe Air

    Perfeito para quem já ouviu falar que Ext tem suporte a Adobe Air, já teve vontade de fazer algum aplicativo para essa plataforma, mas não entende nada do assunto.

  • Introdução ao Ext Core

    O que é esse novo produto do Ext? Aborda características, exemplos e breve tutorial das principais funções

  • Refatoração

    Ótimas dicas de como refatorar sua aplicação, deixando o código mais limpo e com melhor arquitetura. Reforça a idéia divulgada aqui no ExtDesenv de que cada interface deve extender de um componente Ext, beneficiando-se do seu ciclo de vida.

  • Optimizando Performance

    Esse sem dúvida é o melhor de todos para mim. Os 10 mandamentos para fazer sua aplicação Ext muito mais rápida.

Eu ainda não tive tempo de ver todos, mas adianto que os slides são um ótimo material de estudo. Vale muito a pena dedicar um tempo diário para estudá-los. Forte abraço e até a próxima

LinkedInDeliciousPinterestTumblrEmailShare

Tudo sobre licenças ExtJS

Percebi essa semana uma grande quantidade de dúvidas quanto as licenças do Ext. Confesso que eu mesmo tenho muitas dúvidas, mas tirei um tempo, e após ler vários artigos não encontrei uma resposta definitiva, afinal, quando se trata de licenciamento temos que estar seguros de que o que estamos fazendo não é ilegal. Enfim encontrei solução através de respostas da equipe comercial do Ext, espalhadas pelo fórum oficial. Reuni todas e estou publicando-as formatadas a seguir

Atenção! Eu não sou advogado e nem tenho conhecimento profundo das leis envolvidas no licenciamento de software. Este artigo têm como objetivo concentrar informações sobre licenciamento Ext, e o conteúdo publicado pode conter erros meus de interpretação. Sinta-se a vontade a reportar qualquer irregularidade via comentários.

Como funciona o modelo comercial das licenças?

Se baseia num sistema de duas licenças para dois distintos propósitos: desenvolvimento comercial, e desenvolvimento open source. Fundamentado no termo “Quid Pro Quo”, o que traduzido do latim para português seria “algo por algo”.

Em troca dos avanços que você cria usando um produto Ext para criar sua aplicação, nós requirimos que você:

  • Contribua para a continuidade do produto comprando uma licença comercial do Ext. Essa opção lhe assegura o direito de distribuir sua aplicação sobre qualquer termo de licença da sua escolha.
  • Contribua para a comunidade Open Source submetendo sua aplicação sobre uma licença Open Source (ex GPLv3). Essa opção assegura todos os usuários o direito de obter o código fonte completo da aplicação, modificá-lo e redistribuí-lo.
Então o que eu posso e o que não posso?

Comercial

Se você está pagando, você faz o que bem entender. Criando uma aplicação Ext sob licença comercial você pode distribuir sua aplicação ao mundo todo sem disponibilizar nada do seu trabalho. Valores podem ser vistos na seção de vendas de licenças do site oficial.

  • 1 licença por desenvolvedor. Uma pessoa que diretamente ou indiretamente cria aplicações ou interfaces com componentes Ext é considerado um desenvolvedor Ext.
  • São perpétuas, e são válidas também para as revisões de versões. Ex: licença do Ext 3.0 vale pro 3.1, 3.2, etc…mas não pro 2.0.
  • royalty-free: nada de pagar royaltes à equipe Ext por sua aplicação.

Open Source

Não quer pagar, então você tem que disponibilizar o código para download. Salvo a exceção de que você pode não publicar o sistema, ou seja, ao desenvolver um sistema para uso interno da sua empresa ou para sua própria necessidade. Mas se você quiser publicar o sistema, vai ter de publicar o código. Isso é base da licença GPL, você adquiriu o programa de forma grátis, você desenvolve com esse programa, e repassa a comunidade de forma grátis. É uma cadeia de evolução de software.

E a licença para o suporte Ext?

Não confunda as licenças: uma coisa é a licença para desenvolver com Ext e outra é licença de acesso ao suporte do Ext. Ambas são independentes e por isso podem ser adquiridas separadamente, porém em conjunto possuem descontos. A licença de suporte lhe dá direito:

  • Acesso ao SVN
  • Builds mensais com correções
  • Hot-Fix builds emergenciais*
  • Suporte premium no fórum
  • Suporte direto via email
  • Suporte telefônico*

* (menos licença silver)

Para ver a tabela completa do que cada licença de suporte lhe permite visite o site oficial.

Um detalhe, a licença de suporte não é perpétua. Todas as licenças de suporte têm validade de 1 ano.

Perguntas Freqüentes

Para desenvolver um site com Ext, eu tenho que comprar licença comercial?

Um site não difere de uma aplicação Ext, por isso entra nos mesmos termos: vai publicar o site na internet? Tem de pagar licença. Vai usar o site em intranet só para sua empresa, excluindo terceiros? Pode usar licença GPLv3, não pagar nada e não distribuir o código.

Eu quero adquirir uma licença single, no caso, ao comprá-la ela é válida para sempre?

A licença é perpétua para a versão do Ext que estais desenvolvendo. Ao comprar a licença do Ext 2.0 pode usar pra sempre. Se quiser utilizar uma versão nova do Ext, terá de realizar um upgrade na licença, geralmente com descontos.

Além do custo da licença comercial, tem algo mais que tenho que pagar?

Não.

Eles mandam algum tutorial ou manual de ajuda para a utilização dos componentes?

Não. Todos os tutorias e manuais são disponibilizados totalmente grátis no site do Ext.

Tem que ter cartão internacional para comprar a licença?

Sim. O ext utilza pagamento via PayPal ou Google checkout, ambos requerem cartão internacional para operarem.

Eu tenho acesso à todo código fonte e exemplos?

Isso já é feito você tendo licença ou não. Tudo é disponibilizado no site do Ext. Os códigos completos, documentação e exemplos.

Comprando apenas a licença individual, eu tenho acesso ao SVN?

Não. Você tem permissão para desenvolver com o Ext segundo os termos da licença. Acesso ao SVN faz parte da licença de suporte.

Licença do Ext 3.0 vale pro 2.0

Não. Licença do 3.0 vale pro 3.1, 3.2, 3.3, mas não pra versões diferentes.

E é isso aí pessoal, espero ter sanado muitas dúvidas, e poder contar com a participação de vocês para agregar mais informações. Forte abraço e até o próximo post

LinkedInDeliciousPinterestTumblrEmailShare

Introducao Ext JS

Ext JS é uma biblioteca Javascript cross-browser para construção de aplicações RIA. Inclui:

  • Componentes com alta performance e customização
  • Modelo de componentes bem estruturado e extensível
  • Uma API fácil e intuitiva de uso

Esqueça tudo que sabe sobre desenvolvimento de aplicativos web. Criar interfaces a partir de manipulação de tags HTML, e adicionar um pouquinho de dinamismo com Ajax é coisa antiga. Seja mais um desenvolvedor Ext JS e descubra o porque desse framework ser o melhor framework para desenvolvimento de interfaces web.

O Ext JS foi criado a partir do conceito de componentes. Um menu não é uma div flutuante, é um componente menu da classe Ext.menu.Menu. Toda sua interface, antes construída com HTML puro, agora vai virar linhas e linhas de javascript. Tendo em mente isso, sugiro que aprofunde seus estudos na linguagem Javascript e tenha bem consolidado o conceito de Javascript Orientado à Objetos antes de prosseguir.

function onMouseClick( e ){   var menu new Ext.menu.Menu({      text:"botão"      ,handler:function(){ alert(1); }   });

   menu.showAt( e.getXY() );}

Não se assuste com a sintaxe que for utilizada. Inicie primeiramente baixando o framework. O pacote completo incluí documentação e exemplos. Uma vez criado um site local para testes, comece a brincar com os exemplos, mexer no código, no título dos componentes, na aparência.

Depois de familiarizado, procure entender mais sobre os gerenciadores de layout. Neste ponto você já estará bem por dentro do assunto. Qualquer dúvida existe o fórum oficial extremamente completo. Caso inglês não seja seu forte não se preocupe, o fórum oficial brasileiro está disponível e é igualmente extenso. A comunidade de desenvolvedores é enorme e você não terá dificuldade em resolver problemas. Participo de ambos os fóruns e caso deseje pode me encontrar através do nick “bt_bruno”

Segue alguns links de auxílio:

Finalizo aqui o primeiro post da introdução ao Ext JS. Em breve estarei de vez iniciando à programação Ext JS demonstrando os principais componentes do framework e dicas de como otimizar o seu uso.

Forte abraço, e até em breve!

P.S. aos veteranos: Não tenho como objetivo abordar sempre de forma superficial o Ext JS. Ainda falaremos de drag ‘n drop, performance, padrões de desenvolvimento, etc. Aguardem ;)

LinkedInDeliciousPinterestTumblrEmailShare