1) O documento apresenta o framework JavaScript ExtJS, demonstrando seus principais componentes e funções por meio de uma aplicação simples utilizando PHP e PostgreSQL.
2) As seções abordam JavaScript, ExtJS, AJAX, PHP e PostgreSQL, culminando em uma aplicação funcional com cadastros.
3) O objetivo é auxiliar na compreensão dos conceitos por meio de exemplos práticos interligando a interface, servidor e banco de dados.
Este documento apresenta o framework JavaScript ExtJS, demonstrando seus principais componentes e funções. Apresenta também PHP, PostgreSQL e AJAX como auxiliares para construir uma aplicação web simples usando ExtJS para a interface, PHP para a comunicação com o servidor e PostgreSQL como banco de dados.
Este documento apresenta o framework JavaScript ExtJS. Ele introduz o JavaScript, ExtJS e AJAX, e explica como usar ExtJS, PHP e PostgreSQL para criar interfaces web dinâmicas. A documentação está dividida em seções sobre cada tecnologia e inclui exemplos práticos de como integrá-las.
Este documento apresenta o ExtJS, uma biblioteca JavaScript, e mostra como criar interfaces web dinâmicas usando ExtJS, PHP e PostgreSQL. A primeira parte introduz conceitos básicos de JavaScript e o Firebug. A segunda parte explica o ExtJS, como instalá-lo e criar uma interface simples. As partes subsequentes abordam AJAX, PHP e PostgreSQL para tornar a interface funcional e interativa com bancos de dados.
Este documento apresenta o framework JavaScript ExtJS. Ele introduz o JavaScript, ExtJS e AJAX, e explica como usar ExtJS, PHP e PostgreSQL para criar interfaces web dinâmicas. A documentação está dividida em seções sobre cada tecnologia e inclui exemplos práticos de como integrá-las.
O documento discute strings, I/O e a classe Console em Java. Aborda tópicos como: características e métodos importantes de strings; memória e strings; StringBuffer e StringBuilder; leitura e escrita de arquivos; e uso da classe Console para entrada e saída no terminal.
1) O curso aborda tópicos de programação Java como introdução à linguagem, uso de formulários, manipulação de arquivos e banco de dados.
2) Apresenta conceitos de programação orientada a objetos em Java incluindo classes, atributos, métodos, encapsulamento e herança.
3) Demonstra o uso de variáveis, vetores, condições, laços e métodos em programação Java.
O documento apresenta o perfil profissional de Wemerson Silva, que atua como desenvolvedor front-end na empresa UaiTI. Ele tem experiência anterior como desenvolvedor em outras empresas e formação acadêmica em Tecnologia da Informação e Engenharia de Software Ágil.
Este documento resume um módulo sobre a ferramenta XDoclet, que permite gerar automaticamente artefatos Java como EJBs a partir de código-fonte e comentários Javadoc. O documento explica como configurar o XDoclet no Ant, criar templates, e usar a tarefa EJBDocletTask para gerar interfaces, deployment descriptors e outros arquivos para EJBs.
Este documento apresenta o framework JavaScript ExtJS, demonstrando seus principais componentes e funções. Apresenta também PHP, PostgreSQL e AJAX como auxiliares para construir uma aplicação web simples usando ExtJS para a interface, PHP para a comunicação com o servidor e PostgreSQL como banco de dados.
Este documento apresenta o framework JavaScript ExtJS. Ele introduz o JavaScript, ExtJS e AJAX, e explica como usar ExtJS, PHP e PostgreSQL para criar interfaces web dinâmicas. A documentação está dividida em seções sobre cada tecnologia e inclui exemplos práticos de como integrá-las.
Este documento apresenta o ExtJS, uma biblioteca JavaScript, e mostra como criar interfaces web dinâmicas usando ExtJS, PHP e PostgreSQL. A primeira parte introduz conceitos básicos de JavaScript e o Firebug. A segunda parte explica o ExtJS, como instalá-lo e criar uma interface simples. As partes subsequentes abordam AJAX, PHP e PostgreSQL para tornar a interface funcional e interativa com bancos de dados.
Este documento apresenta o framework JavaScript ExtJS. Ele introduz o JavaScript, ExtJS e AJAX, e explica como usar ExtJS, PHP e PostgreSQL para criar interfaces web dinâmicas. A documentação está dividida em seções sobre cada tecnologia e inclui exemplos práticos de como integrá-las.
O documento discute strings, I/O e a classe Console em Java. Aborda tópicos como: características e métodos importantes de strings; memória e strings; StringBuffer e StringBuilder; leitura e escrita de arquivos; e uso da classe Console para entrada e saída no terminal.
1) O curso aborda tópicos de programação Java como introdução à linguagem, uso de formulários, manipulação de arquivos e banco de dados.
2) Apresenta conceitos de programação orientada a objetos em Java incluindo classes, atributos, métodos, encapsulamento e herança.
3) Demonstra o uso de variáveis, vetores, condições, laços e métodos em programação Java.
O documento apresenta o perfil profissional de Wemerson Silva, que atua como desenvolvedor front-end na empresa UaiTI. Ele tem experiência anterior como desenvolvedor em outras empresas e formação acadêmica em Tecnologia da Informação e Engenharia de Software Ágil.
Este documento resume um módulo sobre a ferramenta XDoclet, que permite gerar automaticamente artefatos Java como EJBs a partir de código-fonte e comentários Javadoc. O documento explica como configurar o XDoclet no Ant, criar templates, e usar a tarefa EJBDocletTask para gerar interfaces, deployment descriptors e outros arquivos para EJBs.
O documento discute vários componentes de interface do usuário em Android, incluindo TextView, CheckBox, RadioButton, ProgressBar, EditText, ImageView e ImageButton. Fornece exemplos de código XML para declarar esses componentes em layouts e explica brevemente como cada um funciona.
Palestra sobre persistência de dados no SQLite com Room API apresentada no TDC São Paulo 2017 (19/07/2017). O Room é um dos Architectural Components apresentados pelo Google no Google I/O 2017.
Este artigo descreve as alterações necessárias para utilizar o método POST ao invés de GET na transmissão de dados do objeto XMLHttpRequest em exemplos AJAX. As alterações incluem definir a variável de dados a serem enviados, definir cabeçalhos HTTP apropriados e usar o método send para transmitir os dados.
JavaScript é uma linguagem de script que é interpretada pelo navegador para dar interatividade às páginas HTML. jQuery é um framework JavaScript que simplifica a manipulação do DOM HTML, tratamento de eventos e efeitos visuais. O documento apresenta os conceitos básicos de JavaScript e jQuery, incluindo seletores, manipulação do DOM, eventos e efeitos.
1. O documento descreve como acessar e manipular bancos de dados MySQL usando Python.
2. Ele explica como instalar o módulo MySQLdb, conectar-se ao banco de dados, criar tabelas, inserir, ler, atualizar e excluir dados.
3. Também aborda operações como commits, rollbacks e tratamento de erros para garantir a consistência dos dados.
O documento resume os principais conceitos e comandos do MongoDB, incluindo como selecionar e visualizar bancos de dados e coleções, inserir, consultar, atualizar e remover documentos, criar índices, realizar relacionamentos entre coleções e utilizar recursos como sharding, replica e aggregation framework.
1) O documento discute SQL e NoSQL, tipos de bancos de dados relacionais e não relacionais.
2) MongoDB é apresentado como um banco de dados não relacional do tipo document store, no qual os dados são armazenados em formato JSON.
3) Relacionamentos um-para-muitos podem ser representados de forma normalizada ou embedded no MongoDB.
Este documento fornece uma introdução a bancos de dados NoSQL e ao MongoDB. Ele discute as limitações dos bancos de dados relacionais SQL, as características e tipos de bancos de dados NoSQL, e fornece detalhes sobre como instalar e usar o MongoDB, incluindo como criar bancos de dados, coleções e documentos, e executar consultas e operações.
O documento apresenta uma introdução ao jQuery, abordando os seguintes tópicos: fundamentos do JavaScript e do DOM, preparação do ambiente jQuery, seletores, manipulação de CSS e conteúdo, eventos e funções. O documento fornece uma visão geral dos principais conceitos e funcionalidades do jQuery.
O documento apresenta os conceitos fundamentais sobre uso de streams de arquivos em Java, incluindo classes para abertura de conexões, leitura e gravação de objetos e caracteres. Exemplos mostram como serializar e desserializar objetos em arquivos e como ler e gravar texto usando streams. O leitor é incentivado a testar os exemplos e esclarecer dúvidas com o professor.
Javascript para CSharpers - Append B - jQueryWesley Lemos
Este documento fornece uma introdução à biblioteca JavaScript jQuery:
1) É uma biblioteca cross-browser para manipulação de DOM, eventos e efeitos visuais.
2) Fornece funcionalidades como seleção de elementos, manipulação do DOM, vinculação de eventos e requisições Ajax.
3) É altamente utilizado pela comunidade web devido à sua simplicidade e extensibilidade.
O documento resume as principais características do MongoDB, um banco de dados NoSQL orientado a documentos e esquema-livre. Ele explica que o MongoDB é escalável, de alto desempenho e open source, armazena dados em formato de documentos JSON ou BSON, permite esquemas flexíveis e não requer migrations. Além disso, ressalta que as propriedades ACID ficam a cargo do programador e apresenta alguns comandos básicos para usar o MongoDB via terminal.
O documento apresenta uma introdução ao jQuery, biblioteca JavaScript que simplifica manipulação de elementos HTML, eventos e animações. Explica que jQuery aumenta produtividade, funciona em diversos navegadores e é utilizado por muitos sites. Detalha seleção e manipulação de elementos DOM e apresenta exemplos básicos de uso do jQuery.
Estrutura de Dados e Algoritmos com Java #02-12: Vetores e ArraysLoiane Groner
Curso de Estrutura de Dados e Algoritmos com Java Completo com Certificado e Fórum para dúvidas: http://loiane.training
Site: http://loiane.training
Blog: http://loiane.com
Facebook: https://www.facebook.com/loianegroner
Github: https://github.com/loiane
Twitter: https://twitter.com/loiane
O documento apresenta três classes básicas da API do Java para manipulação de datas e strings: Calendar, que encapsula um momento no tempo; Date, que representa uma data específica; e StringBuffer, que permite manipulação mutável de strings.
O documento apresenta uma introdução à biblioteca jQuery, descrevendo suas principais funcionalidades como simplificar a manipulação de elementos HTML, tratamento de eventos e interações assíncronas. Explica também como jQuery permite interpretar documentos como objetos e coleções de objetos, facilitando a seleção, filtragem e manipulação de elementos. Por fim, resume os principais métodos de jQuery para seleção, iteração, manipulação do DOM e tratamento de eventos.
O documento resume o framework jQuery, que simplifica o desenvolvimento JavaScript ao permitir selecionar elementos, manipular o DOM e realizar animações de forma concisa. O jQuery é leve, rápido, simples, extensível e compatível com os principais navegadores. Ele permite escrever menos código para realizar tarefas comuns no desenvolvimento web.
Este documento apresenta os principais comandos CRUD (Create, Read, Update, Delete) no banco de dados MongoDB. Ele explica como inserir, buscar, atualizar e remover documentos no MongoDB usando os métodos db.collection.insert(), db.collection.find(), db.collection.update() e db.collection.remove(). O documento também demonstra como usar filtros, arrays e operadores como $set para executar as operações CRUD.
1) O documento apresenta uma introdução sobre MongoDB com PHP, incluindo links relevantes e casos de uso de empresas que utilizam MongoDB em produção.
2) É descrito os principais tipos de bancos de dados NoSQL (key-value stores, wide column stores, document stores, graph stores e column oriented stores), com exemplos de cada um.
3) São apresentados comandos e conceitos básicos para trabalhar com MongoDB via PHP, como conexão, inserção, consulta, alteração e exclusão de dados.
Este documento fornece uma introdução básica sobre JavaScript, incluindo o que é JavaScript, onde atua, exemplos de uso, variáveis e tipos de dados, operadores e comentários. Ele também apresenta dois exercícios para praticar conceitos básicos de JavaScript.
O documento discute vários componentes de interface do usuário em Android, incluindo TextView, CheckBox, RadioButton, ProgressBar, EditText, ImageView e ImageButton. Fornece exemplos de código XML para declarar esses componentes em layouts e explica brevemente como cada um funciona.
Palestra sobre persistência de dados no SQLite com Room API apresentada no TDC São Paulo 2017 (19/07/2017). O Room é um dos Architectural Components apresentados pelo Google no Google I/O 2017.
Este artigo descreve as alterações necessárias para utilizar o método POST ao invés de GET na transmissão de dados do objeto XMLHttpRequest em exemplos AJAX. As alterações incluem definir a variável de dados a serem enviados, definir cabeçalhos HTTP apropriados e usar o método send para transmitir os dados.
JavaScript é uma linguagem de script que é interpretada pelo navegador para dar interatividade às páginas HTML. jQuery é um framework JavaScript que simplifica a manipulação do DOM HTML, tratamento de eventos e efeitos visuais. O documento apresenta os conceitos básicos de JavaScript e jQuery, incluindo seletores, manipulação do DOM, eventos e efeitos.
1. O documento descreve como acessar e manipular bancos de dados MySQL usando Python.
2. Ele explica como instalar o módulo MySQLdb, conectar-se ao banco de dados, criar tabelas, inserir, ler, atualizar e excluir dados.
3. Também aborda operações como commits, rollbacks e tratamento de erros para garantir a consistência dos dados.
O documento resume os principais conceitos e comandos do MongoDB, incluindo como selecionar e visualizar bancos de dados e coleções, inserir, consultar, atualizar e remover documentos, criar índices, realizar relacionamentos entre coleções e utilizar recursos como sharding, replica e aggregation framework.
1) O documento discute SQL e NoSQL, tipos de bancos de dados relacionais e não relacionais.
2) MongoDB é apresentado como um banco de dados não relacional do tipo document store, no qual os dados são armazenados em formato JSON.
3) Relacionamentos um-para-muitos podem ser representados de forma normalizada ou embedded no MongoDB.
Este documento fornece uma introdução a bancos de dados NoSQL e ao MongoDB. Ele discute as limitações dos bancos de dados relacionais SQL, as características e tipos de bancos de dados NoSQL, e fornece detalhes sobre como instalar e usar o MongoDB, incluindo como criar bancos de dados, coleções e documentos, e executar consultas e operações.
O documento apresenta uma introdução ao jQuery, abordando os seguintes tópicos: fundamentos do JavaScript e do DOM, preparação do ambiente jQuery, seletores, manipulação de CSS e conteúdo, eventos e funções. O documento fornece uma visão geral dos principais conceitos e funcionalidades do jQuery.
O documento apresenta os conceitos fundamentais sobre uso de streams de arquivos em Java, incluindo classes para abertura de conexões, leitura e gravação de objetos e caracteres. Exemplos mostram como serializar e desserializar objetos em arquivos e como ler e gravar texto usando streams. O leitor é incentivado a testar os exemplos e esclarecer dúvidas com o professor.
Javascript para CSharpers - Append B - jQueryWesley Lemos
Este documento fornece uma introdução à biblioteca JavaScript jQuery:
1) É uma biblioteca cross-browser para manipulação de DOM, eventos e efeitos visuais.
2) Fornece funcionalidades como seleção de elementos, manipulação do DOM, vinculação de eventos e requisições Ajax.
3) É altamente utilizado pela comunidade web devido à sua simplicidade e extensibilidade.
O documento resume as principais características do MongoDB, um banco de dados NoSQL orientado a documentos e esquema-livre. Ele explica que o MongoDB é escalável, de alto desempenho e open source, armazena dados em formato de documentos JSON ou BSON, permite esquemas flexíveis e não requer migrations. Além disso, ressalta que as propriedades ACID ficam a cargo do programador e apresenta alguns comandos básicos para usar o MongoDB via terminal.
O documento apresenta uma introdução ao jQuery, biblioteca JavaScript que simplifica manipulação de elementos HTML, eventos e animações. Explica que jQuery aumenta produtividade, funciona em diversos navegadores e é utilizado por muitos sites. Detalha seleção e manipulação de elementos DOM e apresenta exemplos básicos de uso do jQuery.
Estrutura de Dados e Algoritmos com Java #02-12: Vetores e ArraysLoiane Groner
Curso de Estrutura de Dados e Algoritmos com Java Completo com Certificado e Fórum para dúvidas: http://loiane.training
Site: http://loiane.training
Blog: http://loiane.com
Facebook: https://www.facebook.com/loianegroner
Github: https://github.com/loiane
Twitter: https://twitter.com/loiane
O documento apresenta três classes básicas da API do Java para manipulação de datas e strings: Calendar, que encapsula um momento no tempo; Date, que representa uma data específica; e StringBuffer, que permite manipulação mutável de strings.
O documento apresenta uma introdução à biblioteca jQuery, descrevendo suas principais funcionalidades como simplificar a manipulação de elementos HTML, tratamento de eventos e interações assíncronas. Explica também como jQuery permite interpretar documentos como objetos e coleções de objetos, facilitando a seleção, filtragem e manipulação de elementos. Por fim, resume os principais métodos de jQuery para seleção, iteração, manipulação do DOM e tratamento de eventos.
O documento resume o framework jQuery, que simplifica o desenvolvimento JavaScript ao permitir selecionar elementos, manipular o DOM e realizar animações de forma concisa. O jQuery é leve, rápido, simples, extensível e compatível com os principais navegadores. Ele permite escrever menos código para realizar tarefas comuns no desenvolvimento web.
Este documento apresenta os principais comandos CRUD (Create, Read, Update, Delete) no banco de dados MongoDB. Ele explica como inserir, buscar, atualizar e remover documentos no MongoDB usando os métodos db.collection.insert(), db.collection.find(), db.collection.update() e db.collection.remove(). O documento também demonstra como usar filtros, arrays e operadores como $set para executar as operações CRUD.
1) O documento apresenta uma introdução sobre MongoDB com PHP, incluindo links relevantes e casos de uso de empresas que utilizam MongoDB em produção.
2) É descrito os principais tipos de bancos de dados NoSQL (key-value stores, wide column stores, document stores, graph stores e column oriented stores), com exemplos de cada um.
3) São apresentados comandos e conceitos básicos para trabalhar com MongoDB via PHP, como conexão, inserção, consulta, alteração e exclusão de dados.
Este documento fornece uma introdução básica sobre JavaScript, incluindo o que é JavaScript, onde atua, exemplos de uso, variáveis e tipos de dados, operadores e comentários. Ele também apresenta dois exercícios para praticar conceitos básicos de JavaScript.
Palestra ministrada no 1º PHPDF RoadShow em maio/07. A palestra apresenta o conceito de AJAX e mostra dois caminhos para seu aprendizado, com ou sem frameworks e bibliotecas.
O documento discute estruturas de dados, incluindo vetores, matrizes e registros. Vetores são sequências homogêneas de dados acessados por índice. Matrizes são estruturas bidimensionais de dados homogêneos. Registros permitem estruturar dados heterogêneos. Essas estruturas permitem organizar e acessar dados de forma estruturada em programas.
Melhorando a Experiência do Usuário com JavaScript e jQueryHarlley Oliveira
O documento resume as principais informações sobre JavaScript e jQuery para melhorar a experiência do usuário. Apresenta o que é JavaScript, suas aplicações além de páginas HTML, motiva o uso de efeitos e interações, e introduz conceitos básicos como variáveis, vetores, operadores, estruturas de controle e manipulação do DOM. Em seguida, explica o que é jQuery, como simplifica o JavaScript, e demonstra exemplos de seletores, manipulação e eventos.
O documento discute o desenvolvimento de aplicações ricas para internet (RIA) usando Javascript. Apresenta Javascript como uma opção viável para RIA, ao contrário do que sugere o senso comum. Explica como usar Orientação a Objetos, organização de código, documentação e testes para superar as limitações percebidas da linguagem. Defende o padrão MVVM e as bibliotecas jQuery e Knockout para separar as responsabilidades e facilitar a manutenção do código.
Este documento fornece uma introdução ao AJAX e como ele pode ser usado em aplicações Java. Ele discute o que é AJAX, como fazer requisições ao servidor usando AJAX e frameworks JavaScript que facilitam o desenvolvimento de aplicações AJAX. Além disso, apresenta como AJAX pode ser usado com Java usando DWR.
1) O documento apresenta um curso sobre PHP, MySQL e MVC, abordando conceitos como linguagem, framework, banco de dados e arquitetura MVC. 2) É apresentado um exemplo simples de implementação de MVC em PHP sem frameworks. 3) O documento também discute conceitos da linguagem PHP como variáveis, tipos, controle de fluxo e orientação a objetos.
Criando e consumindo webservice REST com PHP e JSONAmbiente Livre
O documento apresenta uma palestra sobre criação e consumo de web services RESTful utilizando PHP e JSON. Aborda conceitos como protocolo HTTP, métodos GET e POST, arquitetura REST, URIs, JSON versus XML e como disponibilizar e consumir dados em formato JSON através de PHP.
O documento apresenta uma palestra sobre criação e consumo de web services RESTful utilizando PHP e JSON. Explica conceitos como protocolo HTTP, métodos GET e POST, arquitetura REST, URIs e JSON, e demonstra como disponibilizar e consumir dados em formato JSON através de PHP.
O documento apresenta uma introdução ao jQuery, cobrindo os seguintes tópicos: 1) Apresenta os objetivos do curso de introdução ao jQuery, como nivelar conhecimentos sobre JavaScript e mostrar como o jQuery funciona; 2) Discutem conceitos básicos de JavaScript como escopo, tipos, orientação a objetos e eventos; 3) Explica as vantagens do jQuery, como simplificar o trabalho com JavaScript, e como ele funciona; 4) Mostra exemplos básicos de como utilizar seletores e métodos jQuery.
O documento discute o que são WebServices e WebServices RESTful, demonstrando como criar um WebService RESTful em Java usando a biblioteca Jersey. Ele explica o que são WebServices, principais características de WebServices RESTful, como implementar recursos e entidades, e testar o WebService usando ferramentas como cURL.
Javaone Brazil 2012: Integrando Ext JS 4 com Java EELoiane Groner
O documento discute a integração do framework Ext JS com Java EE, incluindo prós e contras dos diferentes frameworks e cuidados necessários. Ele também apresenta exemplos de arquitetura para projetos que utilizam Ext JS e Java, além de opções para comunicação entre as tecnologias.
O documento apresenta conceitos sobre PHP e AJAX. Resume os principais pontos sobre: 1) como o AJAX permite enviar e receber dados de um servidor sem recarregar a página usando tecnologias como Javascript, XML e HTTP; 2) o objeto XMLHttpRequest que permite fazer requisições assíncronas; 3) um exemplo prático de um mural de recados interativo usando PHP no servidor e AJAX no cliente.
Este documento discute conceitos de programação orientada a objetos em Javascript para desenvolvedores acostumados com C#. Ele explica como Javascript lida com objetos dinâmicos, "classes", herança e outros conceitos usando o objeto prototype. O documento também mostra como simular classes abstratas e métodos de extensão usando prototype.
Java utiliza uma máquina virtual que traduz as aplicações para as chamadas do sistema operacional, permitindo que as aplicações rodem independentemente do sistema operacional. A máquina virtual Java (JVM) executa as aplicações Java e permite o desenvolvimento usando ferramentas como o compilador Javac e o kit de desenvolvimento JDK. O documento descreve também conceitos básicos de programação em Java como tipos primitivos, classes, métodos, fluxos de controle e orientação a objetos.
O documento discute os conceitos fundamentais de orientação a objetos em Java, incluindo: 1) Definições de classes, objetos, encapsulamento e herança; 2) Como criar objetos a partir de classes e compartilhar dados entre objetos; 3) Como definir métodos e construtores em classes.
1) O documento introduz a linguagem R, abordando sua história, instalação, editores de texto, manipulação de objetos, entrada e saída de dados, e distribuições de probabilidade.
2) São apresentados conceitos sobre modos e atributos de objetos no R, como vetores, matrizes, listas e data frames.
3) O documento também explica a importação e exportação de dados, e como gerar gráficos e saídas em diferentes formatos a partir do R.
Este documento fornece um resumo de 3 frases sobre tecnologias para desenvolvimento de software:
1) Apresenta um curso sobre diversas tecnologias Java como Servlets, JSP, JSF, EJB e Spring. 2) Fornece detalhes sobre o instrutor Rafael Benevides e sua experiência com Java. 3) A agenda inclui discussões sobre Servlets, JSP, Hibernate e outros temas ao longo de 9 dias.
Este documento fornece um resumo sobre a linguagem de programação C. Ele discute tópicos como estrutura básica de programas em C, variáveis, operadores, entrada e saída, estruturas de decisão e repetição, funções, classes de armazenamento, diretivas, vetores e matrizes, strings, estruturas e ponteiros.
Administração mercadolgica aula 01 - história e conceitoLuciano Marwell
O documento descreve a história do marketing, desde suas origens na Roma antiga até se tornar uma disciplina importante no século 20. Também define marketing de acordo com Kotler e discute as três eras do marketing: produção, vendas e marketing. Por fim, aborda o papel da mídia na criação de valores e o escopo de atuação do profissional de marketing moderno.
Administração mercadolgica aula 02 - legislação e estudo de casoLuciano Marwell
O documento discute os aspectos legais inerentes à publicidade no Brasil. Ele explica a defesa do consumidor e o direito do consumidor, destacando os princípios e leis que regem a publicidade e protegem os consumidores contra práticas enganosas. Também apresenta os principais artigos do Código de Defesa do Consumidor relacionados à publicidade.
O documento resume as principais características da linguagem PHP. Discute como surgiu o PHP, o que pode ser feito com ele e suas principais vantagens como ser de código aberto, gratuito e multiplataforma. Também faz uma comparação entre PHP e ASP, concluindo que o PHP é mais flexível, rápido e adequado para projetos que precisam de múltiplas plataformas.
1. O documento apresenta uma introdução ao PHP, incluindo sua história e o que pode ser feito com a linguagem.
2. É descrita a sintaxe básica do PHP, como delimitar código, nomes de variáveis e comentários.
3. São explicados os principais tipos de dados suportados como inteiros, strings e arrays, assim como conversões entre tipos.
Este documento fornece uma introdução básica ao jQuery em português. Resume os principais tópicos ensinados no documento, incluindo como começar com jQuery, escrever scripts básicos, modificar estilos CSS, alterar partes específicas de uma página e esconder/mostrar elementos. O documento contém vários exercícios para ajudar o leitor a praticar os conceitos aprendidos.
Este certificado confirma que Gabriel de Mattos Faustino concluiu com sucesso um curso de 42 horas de Gestão Estratégica de TI - ITIL na Escola Virtual entre 19 de fevereiro de 2014 a 20 de fevereiro de 2014.
PRODUÇÃO E CONSUMO DE ENERGIA DA PRÉ-HISTÓRIA À ERA CONTEMPORÂNEA E SUA EVOLU...Faga1939
Este artigo tem por objetivo apresentar como ocorreu a evolução do consumo e da produção de energia desde a pré-história até os tempos atuais, bem como propor o futuro da energia requerido para o mundo. Da pré-história até o século XVIII predominou o uso de fontes renováveis de energia como a madeira, o vento e a energia hidráulica. Do século XVIII até a era contemporânea, os combustíveis fósseis predominaram com o carvão e o petróleo, mas seu uso chegará ao fim provavelmente a partir do século XXI para evitar a mudança climática catastrófica global resultante de sua utilização ao emitir gases do efeito estufa responsáveis pelo aquecimento global. Com o fim da era dos combustíveis fósseis virá a era das fontes renováveis de energia quando prevalecerá a utilização da energia hidrelétrica, energia solar, energia eólica, energia das marés, energia das ondas, energia geotérmica, energia da biomassa e energia do hidrogênio. Não existem dúvidas de que as atividades humanas sobre a Terra provocam alterações no meio ambiente em que vivemos. Muitos destes impactos ambientais são provenientes da geração, manuseio e uso da energia com o uso de combustíveis fósseis. A principal razão para a existência desses impactos ambientais reside no fato de que o consumo mundial de energia primária proveniente de fontes não renováveis (petróleo, carvão, gás natural e nuclear) corresponde a aproximadamente 88% do total, cabendo apenas 12% às fontes renováveis. Independentemente das várias soluções que venham a ser adotadas para eliminar ou mitigar as causas do efeito estufa, a mais importante ação é, sem dúvidas, a adoção de medidas que contribuam para a eliminação ou redução do consumo de combustíveis fósseis na produção de energia, bem como para seu uso mais eficiente nos transportes, na indústria, na agropecuária e nas cidades (residências e comércio), haja vista que o uso e a produção de energia são responsáveis por 57% dos gases de estufa emitidos pela atividade humana. Neste sentido, é imprescindível a implantação de um sistema de energia sustentável no mundo. Em um sistema de energia sustentável, a matriz energética mundial só deveria contar com fontes de energia limpa e renováveis (hidroelétrica, solar, eólica, hidrogênio, geotérmica, das marés, das ondas e biomassa), não devendo contar, portanto, com o uso dos combustíveis fósseis (petróleo, carvão e gás natural).
As classes de modelagem podem ser comparadas a moldes ou
formas que definem as características e os comportamentos dos
objetos criados a partir delas. Vale traçar um paralelo com o projeto de
um automóvel. Os engenheiros definem as medidas, a quantidade de
portas, a potência do motor, a localização do estepe, dentre outras
descrições necessárias para a fabricação de um veículo
Em um mundo cada vez mais digital, a segurança da informação tornou-se essencial para proteger dados pessoais e empresariais contra ameaças cibernéticas. Nesta apresentação, abordaremos os principais conceitos e práticas de segurança digital, incluindo o reconhecimento de ameaças comuns, como malware e phishing, e a implementação de medidas de proteção e mitigação para vazamento de senhas.
1. Apostila de ExtJS com PHP e PostgreSQL
Criando interfaces web 2.0
Rodrigo K. Nascimento
rodrigoknascimento@gmail.com
FACCAT
Atualizado em 26 de Novembro de 2009
2. Esta apostila tem por objetivo demonstrar os principais componentes e funções da biblioteca
JavaScript ExtJS. Como auxílio para a demonstração de uma aplicação simples porém funcional,
será usada a linguagem de programação PHP para a comunicação da interface (ExtJS) com o
servidor e o banco de dados PostgreSQL. Para melhor compreensão esta apostila está dividida da
seguinte forma:
Sumário
JavaScript ........................................................................................................................................3
Introdução ao JavaScript.............................................................................................................3
Conhecendo e instalando o Firebug............................................................................................3
Formato de dados, funções e estrutura........................................................................................3
ExtJS................................................................................................................................................6
Conhecendo o ExtJS...................................................................................................................6
Instalando o ExtJS e testando......................................................................................................8
Parte Prática 1: Montando uma interface simples.....................................................................12
AJAX.............................................................................................................................................13
O que é, para que serve e quando usar......................................................................................13
Como o ExtJS se comunica com o servidor..............................................................................13
Instalando o servidor Apache....................................................................................................14
Testando o AJAX do ExtJS.......................................................................................................14
Parte Prática 2: Interagindo nossa interface com o servidor.....................................................15
PHP................................................................................................................................................16
Conhecendo o PHP...................................................................................................................16
Instalando o PHP.......................................................................................................................16
Parte Prática 3: Interagindo nossa interface com o servidor.....................................................17
PostgreSQL....................................................................................................................................18
Conhecendo o PostgreSQL.......................................................................................................18
Instalando o PostgreSQL e o PgAdmin.....................................................................................18
Criando nosso Banco de Dados................................................................................................19
Parte Prática 4: Tornando nossa aplicação funcional................................................................19
Extend e Override..........................................................................................................................22
Adaptando o ExtJS as nossas necessidades..............................................................................22
Praticando um pouco mais.............................................................................................................23
Criando mais cadastros em nossa aplicação..............................................................................23
Fim.................................................................................................................................................24
Agradecimentos........................................................................................................................24
3. JavaScript
Introdução ao JavaScript
JavaScript é uma linguagem de programação que permite a manipulação de objetos de uma
página web diretamente no browser, bem como o acesso a algumas informações importantes como
qual o sistema operacional, qual o browser que está abrindo a página, qual a engine de renderização
do navegador, etc. Permite também o acesso e manipulação de datas, pegar a data e hora do sistema
operacional, formatar ou criar novos objetos de data e hora.
Por ser uma linguagem de programação interpretada pelo browser em tempo de execução o
JavaScript está sujeito a particularidades de cada navegador, um bom exemplo é a diferença que
existe entre a forma de se criar uma requisição AJAX no Internet Explorer e no Firefox.
Internet Explorer
req = new ActiveXObject(“Microsoft.XMLHTTP”);
Firefox
req = new XMLHttpRequest();
Conhecendo e instalando o Firebug
Firebug é um complemento para o navegador Firefox, ele permite que o desenvolvedor
possa analisar o JavaScript, css, html e carregamentos da página, também permite a manipulação do
JavaScript, html e css em tempo de execução permitindo testes mais rápidos e diretamente na
página. Analisando por outro lado, essa facilidade que o Firebug disponibiliza é um ponto fraco
para a segurança dos sites.
Instalando: Com o Firefox instalado vá em Ferramentas>Complementos>Adicionar e
pesquise por Firebug, localize o Firebug, instale-o e reinicie o Firefox.
Formato de dados, funções e estrutura
Por ter tido uma colaboração considerável da SUN em sua criação o JavaScript tem a sintaxe
muito semelhante a do Java porém muito diferente em seu conceito e seu uso.
De acordo com seu sistema de tipos JavaScript é:
• Fraca - sua tipagem é mutável;
• Dinâmica - uma variável pode assumir vários tipos diferentes durante a execução;
• Implícita - as variáveis são declaradas sem tipo.
Existem três formas de declaração de variáveis:
• Escopo Global: variavel1 = 'a';
• Escopo Local: var variavel1 = 'a';
• Escopo do Objeto: this.variavel1 = 'a';
Existem duas formas de declaração de funções:
• function funcao1(){};
• var funcao1 = function(){};
4. Atribuição e tipos de objetos:
• String: var variavel1 = 'string';
• Integer: var variavel1 = 123;
• Float: var variavel1 = 123.5;
• Objeto: var variavel1 = {};
• Array: var variavel1 = [];
• Boolean: var variavel1 = true;
• Data: var variavel1 = new Date();
• Função: var variavel1 = function(){};
Operadores aritméticos:
• + x + y Soma ou concatena y a x;
• - x – y Subtrai y de x;
• * x * y Multiplica x por y;
• % x % y Retorna o resto da divisão de x por y;
• / x / y Divide x por y;
• ++ x++ Adiciona 1 a x;
• -- x-- Subtrai 1 de y;
Operadores lógicos e relacionais
• ! !bool Inverte o resultado booleano da variável ou expressão;
• && x && y True se x e y forem verdadeiros;
• || x || y True se x ou y ou ambos forem verdadeiros;
• == x == y True se x for igual a y, não considera o tipo dos dados;
• != x != y True se x for diferente de y, não considera o tipo dos dados;
• === x === y True se x for igual a y e do mesmo tipo de dados;
• !== x !== y True se x for diferente de y considerando o tipo dos dados;
• < x < y True se x for menor que y;
• <= x <= y True se x for menor ou igual a y;
• > x > y True se x for maior que y;
• >= x >= y True se x for maior ou igual a y;
Um objeto vazio é representado por {} e um array vazio é representado por [], sendo que
esses podem ser atribuídos com inicialização de um objeto do respectivo tipo. Um array ou um
objeto podem conter dados de um ou mais tipos.
Exemplo de array com dados:
var variavel1 = ['valor1','valor2','valor3'];
var variavel1 = [0,1,2];
var variavel1 = ['valor1', 0, true];
Exemplo de acesso a um array:
var variavel2 = variavel1[1];
Exemplo de objeto com dados:
var variavel1 = {nome:'João', idade:13};
5. Exemplo de acesso a um objeto:
var variavel2 = variavel1.nome;
Um objeto pode conter um array ou outros tipos assim como um array pode conter objetos
ou outros tipos, exemplo:
var variavel1 = [{nome:'João'}, {nome:'Jorge'}];
var variavel1 = {nome:['João','Jorge']};
Exemplo de objeto complexo:
var variavel1 = {
pessoas: ['João', 'Jorge'],
addPessoa: function(pessoa){
this.pessoas.push(pessoa);
}
}
variavel1.addPessoa('Rodrigo');
Uma classe em JavaScript é uma função que contém variáveis e funções referenciadas a si,
ou seja, declaradas com thi, exemplo:
var classe1 = function(){
this.pessoas = [];
this.addPessoa = function(pessoa){
this.pessoas.push(pessoa);
}
}
var obj1 = new classe1;
var obj2 = new classe1;
obj1.addPessoa('João');
obj2.addPessoa('Jorge');
Javascript possui um recurso chamado prototype, que permite modificar uma classe depois
que ela foi criada. Permite inclusive alterar classes internas da linguagem. Após as alterações no
prototype da classe todos os objetos criados a partir desta serão afetados além dos objetos criados
posteriormente. Tomando como base a classe já criada no exemplo acima, podemos exemplificar
adicionando uma função de contagem de pessoas:
classe1.prototype.quantidadePessoas=function(){
return this.pessoas.length
}
obj1.quantidadePessoas(); //Deve retornar 1;
var obj3 = new classe1;
obj3.quantidadePessoas(); //Deve retornar 0, pois não foram adicionado dados;
Mas qual a real utilidade do prototype? Se você deseja alterar uma classe que você mesmo
criou porque não alterar diretamente no código da classe, certo? Bom, existem casos onde temos a
necessidade de alterar classes que não criamos, classe de bibliotecas ou até mesmo classes do
próprio JavaScript, um exemplo seria criar a funcionalidade de adicionar uma sequencia de
caracteres a uma string para preenche-la até determinado tamanho, comumente chamado de Pad, no
exemplo abaixo iremos implementar um LeftPad a classe String do Javascript:
String.prototype.LeftPad = function (L, C) {
return new Array(L - this.length + 1).join(C || '0') + this;
6. }
var teste = '12345'.LeftPad(10);
teste; //Deve nos retornar '0000012345;
ExtJS
Conhecendo o ExtJS
Citação de [HTML STAFF] ExtJS: Um excelente framework de Javascript
O ExtJS é um framework Javascript criado originalmente como uma extensão do YUI
(Yahoo! User Interface). Na época de sua criação, chamava-se yui-ext, funcionando junto
ao YUI, que era a base. Por ser uma extensão do YUI, o yui-ext não funcionava sem ele.
O ExtJS é um software de código livre criado por Jack Slocum, disponibilizado sob a
licença LGPL, porém pode ser comprado para vir com uma outra licença não-livre, caso
seja preciso, e também há como adquirir apenas o suporte pago do ExtJS o que dá direito,
além do suporte via fórum, e-mail, telefone e onsite (dependendo do nível de associação), o
acesso ao SVN do ExtJS onde estão as versões de desenvolvimento do ExtJS e as correções
ainda não liberadas publicamente.
Com o desenvolvimento do yui-ext, foram sendo incorporados diversos adapters
(adaptadores), que funcionavam de ponte entre o yui-ext e outros Frameworks de
Javascript: o Prototype e jQuery.
Com o crescente e rápido reconhecimento entre os desenvolvedores como uma extensão rica
em funcionalidades e componentes de interface acrescentando valor aos mais conhecidos
Frameworks de Javascript (YUI, Prototype e jQuery), o seu desenvolvimento foi ganhando
em colaboradores e velocidade. Assim, sucederam-se várias versões 0.x do yui-ext, antes de
ser lançada a versão 1.0 final onde seu nome foi alterado para EXT JS, demonstrando que
ele já não era apenas uma extensão para o YUI.
A próxima release lançada foi o ExtJS 1.1, sendo que, a partir dessa versão houve um salto
tornando-o um verdadeiro Framework de Javascript ou AJAX Framework e não mais
limitado a ser apenas uma extensão para outros Frameworks, apesar de ainda poder ser
usado assim.
A partir da versão 1.1.1 o ExtJS passou a ser oficialmente suportado pelos navegadores
Microsoft Internet Explorer 6+, Mozilla Firefox 1.5+, Apple Safari 2+ e Opera 9+ e extra-
oficialmente com o Konqueror, Galeon, Ice Weasel, Mozilla, Netscape e provavelmente
outros.
Após a série 1.1, começou a ser desenvolvido o ExtJS 2.0, trazendo várias funções e
componentes básicos completamente remodelados para trabalhar com mais eficiência e
códigos menores.
Características
O ExtJS, por ser uma biblioteca Javascript cross-browser, provê o desenvolvedor de
ferramentas para criar interfaces para páginas e sistemas web-based com alta
performance, customização e uma aparência elegante.
7. Atualmente o ExtJS é suportado oficialmente pelos navegadores Internet Explorer 6+,
FireFox 1.5+ (PC, Mac), Safari 3+ e Opera 9+ (PC, Mac).
Pode ser utilizado sob a GPL ou pode-se adquirir uma licença comercial, além de ser
possível a compra de suporte técnico.
O ExtJS suporta os frameworks Yahoo! User Interface, Prototype e jQuery, através de
adapters (adaptadores). Além disso, trabalha integrado com o Adobe AIR e com Google
Web Toolkit (GWT).
A sua utilização é bastante simples, uma vez que os arquivos necessários à sua utilização
são incluídos na página HTML (ou PHP etc) através das tags <SCRIPT>, tal como a
inclusão que qualquer arquivo *.js.
A documentação também é farta, existindo uma ativa comunidade de utilizadores no Brasil,
além da comunidade Norte-Americana.
A própria documentação do ExtJS (inglês) é fácil de entender e bastante dinâmica, bem
como apresenta diversos exemplos de suas funcionalidades. Veja uma imagem da API de
documentação:
Existem ainda algumas ferramentas para criação visual de componentes, tais como
formulários, todas disponíveis gratuitamente, além de plugins para algumas IDEs (Aptana,
por exemplo).
Conclusão
Como se pode ver nas seções anteriores, o ExtJS facilita e muito o desenvolvimento web,
seja porque provê ao desenvolvedor de ferramentas poderosas para criação de interfaces
elegantes, funcionais e eficientes; seja porque retira do desenvolvedor a preocupação com a
elaboração visual, que às vezes não é tão importante quanto a camada de tratamento dos
dados.
Resumindo em uma frase popular, o ExtJS é "bom, bonito e barato".
Para aqueles que desejam saber mais sobre esta biblioteca, aconselho a visita aos seguintes
endereços eletrônicos:
• Site oficial do ExtJS;
• Site da comunidade de utilizadores brasileiros do ExtJS;
• http://www.extjs.com/deploy/dev/examples/samples.html
• http://www.extjs.com/deploy/dev/docs/
No momento em que escrevo esta apostila a versão atual da biblioteca do ExtJS é 3.0.0.
8. Instalando o ExtJS e testando
Instalando:
1. Entre na área de download do site do ExtJS e faça a download da versão 3.0.0 da biblioteca,
ela virá compactada;
2. Dentro do pacote ZIP existe uma pasta chamada ext-3.0.0, extraia-a para uma pasta em seu
computador, se você tiver um servidor web instalado aproveite para coloca-la dentro da
pasta do seu servidor;
Testando:
1. Crie um arquivo chamado index.html na mesma pasta que contém a pasta ext-3.0.0;
2. Crie um arquivo chamado index.js;
3. Abra o arquivo index.html e escreva o seguinte código:
<html>
<head>
<title>Testando o ExtJS</title>
<link rel="stylesheet" type="text/css" href="ext-
3.0.0/resources/css/ext-all.css" />
<script src="ext-3.0.0/adapter/ext/ext-base.js"></script>
<script src="ext-3.0.0/ext-all.js"></script>
<script src="index.js"></script>
</head>
<body>
</body>
<button id="btClose">Fechar Janela</button>
</html>
4. Abra o arquivo index.js e escreva o seguinte código:
Ext.onReady(function(){
var win = new Ext.Window({
height:200,
width:300,
title:'Teste',
html:'<b>Minha primeira janela em ExtJS</b>'
})
win.show();
Ext.get('btClose').on('click', function(){
win.close();
})
})
5. Abra o arquivo index.html em algum navegador, devemos ver uma janela azul em ExtJS
com título “Teste” e conteúdo “Minha primeira janela em ExtJS”, caso isso não ocorra
revise seus códigos.
Explicações:
1. Carregamos 3 arquivos do ExtJS:
1. ext-all.css - contém os estilos que fazem a ligação do html gerado pelo ExtJS com a
“Skin”, a qual contém inúmeras linhas de estilos e ligações com imagens;
2. ext-all.js – contém o código de todos os componentes visuais e não visuais da biblioteca;
9. 3. ext-base.js – o ExtJS pode funcionar ligado a essa biblioteca ou a outras como JQuery
através de adaptadores que são outros arquivos .js.
2. Carregamos o arquivo index,js onde colocaremos nosso código JavaScript, essa divisão de
arquivos torna o código mais organizado.
3. Dentro do index.js:
1. “Ext.onReady” recebe uma função por parâmetro, quando passamos uma função por
parâmetro chamamos de callback porque ela será executada por outro pedaço de código
que não possui conhecimento desta função, essa função será executada logo após o
carregamento de todos os elementos de nossa página, evitando problemas. Sendo assim,
dentro desta função “anonima” começamos a escrever o código que queremos que seja
executado ao abrir a página;
2. Criamos para uma variável chamada “win” um compoente chamado Window (janela)
com largura de 300px, altura de 200px, titulo e um pequeno texto;
3. A partir do objeto criado para a variável “win” chamamos o método “show” o qual faz a
nossa janela ser renderizada na tela para o usuário, como não passamos posição ela será
renderizada exatamente no centro da tela;
4. “Ext.get()”. Lembra do “document.getElementById()”? Pois é, podemos compara-lo a
ele, com uma pequena diferença, Ext.get nos traz um elemento pelo id que ele contém na
sua tab html mas como um objeto do ExtJS, você pode notar que com o Ext.get o objeto
retornado contém todas as propriedades e métodos do objeto Ext.Element, olhe na
documentação, e a propriedade “Ext.get('idElemento').dom” nos retorna o que o
“document.getElementById()” nos retornaria. Sendo assim com o Ext.get podemos usar
de eventos facilmente, como neste caso associando um evento ao botão de id “btClose”.
Em um Ext.Element, que é o que o Ext.get nos retorna, podemos usar do método “on”
que recebe três paramentos, o nome do evento a se associar, a função de callback que
queremos executar quando esse evento ocorrer e o escopo, o escopo é um paramentro
opcional e trataremos dele mais tarde. Em resumo, associamos uma função ao evento
click do botão que pega a variável onde temos a janela e executa o método de fechar
(close).
Obs: É muito importante manter um código bem identado, isso facilita a vida de quem fez o código,
de quem vai ler e do professor deste curso :) se possível use um editor de texto que lhe ajude a
programar, principalmente um que contenha syntax highlight. Se não tiver um favorito tente o
Notepad++.
Ótimo, agora que sabemos como iniciar a utilização do ExtJS vamos começar com os exercícios:
1. Vamos praticar um pouco mais de “Ext.get”, temos em nosso código acima um exemplo de
como fechar a janela no click de um botão. Crie mais um botão, não esqueça de colocar um
id único para ele, e faça com que nossa janela abra somente quando este botão for clicado.
Obs: coloque todo o código de criação da janela dentro do evento do botão e declare a
variável fora dos eventos.
2. Vamos praticar um pouco de lógica. Os mais curiosos provavelmente perceberam que a cada
vez que se clica no botão de criar a janela é criada uma nova janela, isso acontece porque a
cada clique executamos nosso código de criação sem antes verificar se a janela já existe,
sendo assim criamos uma nova janela para a mesma variável e a antiga continua lá, assim
perdemos a referencia das janelas anteriores pela variável “win”, note que ao clicar no botão
de fechar a janela somente a última janela se fecha. Faça uma estrutura básica de condição,
10. um IF antes da criação da janela e verifique se a mesma ainda não foi criada para poder dar
continuidade ao código. Exemplo de if onde o alert será mostrado somente se a quantidade
for igual a zero:
var qtd = 0;
if(qtd === 0){
alert('quantidade zerada');
}
3. Você deve ter notado que ao fechar a janela não conseguimos mais abri-la, isso se deve ao
fato de fecharmos a janela e não liberarmos a variável, adicione após o close() da janela o
código win = null; para que ela passe em nosso teste de criação;
4. Altere as configurações da janela para que ela não possua o botão de fechar, que ela não
possa ser redimensionada e que ela contenha um barra de status na parte inferior com um
botão alinhado a direita escrito “Fechar” e que ao ser clicado feche a janela.
Xtype
O Xtype é uma forma abreviada de se criar um componente dentro de outro no ExtJS, os
dois exemplos abaixo tem o mesmo efeito:
var win = new Ext.Window({
height: 200,
width: 300,
items:[new Ext.Panel({
title: 'Titulo',
html: 'texto'
})]
})
win.show();
var win = new Ext.Window({
height: 200,
width: 300,
items:[{
xtype: 'panel',
title: 'Titulo',
html: 'texto'
}]
})
win.show();
Exemplo de janela com formulário e 3 campos, onde o campo nome não pode ser nulo:
var win = new Ext.Window({
height: 200,
width: 300,
layout: 'fit',
items:[{
xtype: 'form',
items: [{
xtype: 'textfield',
fieldLabel: 'Nome',
allowBlank: false
},{
xtype: 'textfield',
fieldLabel: 'Sobrenome',
width: 160
},{
xtype: 'datefield',
fieldLabel: 'Data Nascimento'
11. }]
}]
})
win.show();
Exercícios
5. Pegando o exemplo de formulário acima, faça com que o campo Sobrenome não permita
nulo e adicione os seguintes campos:
1. Endereço (campo texto);
2. Data Cadastro (campo data, não pode ser nulo);
3. Profissão (Campo texto).
Exemplo de grid com dados:
var win = new Ext.Window({
height: 200,
width: 300,
layout: 'fit',
items:[{
xtype:'grid',
store: new Ext.data.ArrayStore({
fields:[
{name:'nome'},
{name:'profissao'},
{name:'idade', type:'int'}
],
data: [
['Rodrigo','Programador','21'],
['Hullen','Programador','23'],
['Gabriel','Programador','26']
]
}),
columns:[
{
id: 'nome',
header: 'Nome',
width: 100,
sortable: true,
dataIndex: 'nome'
},{
id: 'profissao',
header: 'Profissão',
width: 100,
sortable: true,
dataIndex: 'profissao'
},{
id: 'idade',
header: 'Idade',
width: 50,
sortable: true,
dataIndex: 'idade'
}
]
}]
})
win.show();
Exercícios
6. Pegando o exemplo de grid acima, adicione o campo Sobrenome no store, coloque dados
12. para esse campo, faça com que ele apareça no grid e faça com que este campo não possa ser
ordenado.
Parte Prática 1: Montando uma interface simples
Criar uma interface simples:
1. Criar um Viewport de layout border, contendo as regiões north, east, center e south;
2. Criar uma toolbar na região norte contendo os botões:
1. Cadastro (com submenu)
• Pessoas (Deve abrir a Aba de Cadastro Pessoas)
• Cidades (Sem funcionalidade por enquanto)
2. Teste (um botão toggle sem funcionalidade)
3. Um texto de boas vindas ao usuário
4. Sair (um botão sem funcionalidade alinhado a direita)
3. A região east deve ter o título “Propagandas”, largura de 100px e poder ser minimizada
(collapse);
4. A região south de ter altura de 100px, o título “Noticias”, poder ser minimizada, vir
minimizada por padrão, ser redimensionavel e ter o modo de collapsed como “mini”;
5. A região center deve ser um tabPanel;
6. Criar uma tab na região central com título “Olá Mundo” e que fique ativa por padrão
7. Ao clicar no botão “Cadastro > Pessoas” criar uma nova tab na região central contendo um
grid conforme a figura abaixo.
8. O grid deve conter as colunas Nome, Idade e Profissão;
9. Para maiores detalhes comparem a figura abaixo com a sua tela.
13. AJAX
O que é, para que serve e quando usar.
Citação de Wikipédia: AJAX (programação):
AJAX (acrônimo em língua inglesa de Asynchronous Javascript And XML) é o uso
metodológico de tecnologias como Javascript e XML, providas por navegadores, para
tornar páginas Web mais interativas com o usuário, utilizando-se de solicitações
assíncronas de informações. AJAX não é somente um novo modelo, é também uma iniciativa
na construção de aplicações Web mais dinâmicas e criativas. AJAX não é uma tecnologia —
são realmente várias tecnologias conhecidas trabalhando juntas, cada uma fazendo sua
parte, oferecendo novas funcionalidades.
AJAX é resumidamente uma forma de se comunicar com o lado servidor sem a necessidade
de recarregar a página WEB, tornando assim possível a separação perfeita de uma aplicação em
camadas (MVC). Ele permite que sejam enviados dados do lado cliente para o lado servidor por
POST ou GET e receber dados do servidor como um texto.
A utilização do AJAX é recomendada nos casos onde há a necessidade de enviar dados para
o servidor e/ou trazer dados para a tela de forma minimalista evitando o recarregamento de todos os
elementos de uma página, evitando assim também o tempo de espera no carregamento de uma
página. A sua utilização não é recomendada para tráfego de informações importantes, como dados
de login.
Importante, AJAX é uma requisição assíncrona, ou seja, o código continua a ser executado
enquanto a requisição está em andamento, o código não espera pela resposta do servidor, por isso
trabalhamos com funções de callback, uma função anonima passada para a requisição, esta função
será chamada ao termino da requisição e receberá por parâmetro os dados da requisição e o retorno
da mesma, sendo assim temos que trabalhar com os dados dentro deste callback.
Como o ExtJS se comunica com o servidor
O ExtJS prove um componente não visual chamado Ext.Ajax a qual nos permite criar
requisições AJAX de forma fácil e clara, vários componentes do ExtJS se utilizam deste
componente para realizar transações AJAX de maneira mais abstrata ao programador como os
Stores, a propriedade autoLoad e o método load do componente Ext.Panel e seus derivados.
A comunicação em AJAX ocorre basicamente da seguinte forma:
1. É enviada uma requisição ao servidor, igualmente ao ato de abrir uma página, onde
podem ser passados dados por POST ou GET, igual ao envio de um formulário da
maneira tradicional;
2. Ocorre o processamento dos dados do lado servidor caso seja chamada uma página
que contenha programação do lado servidor;
3. É retornado todo o código que seria impresso na tela para o usuário caso abríssemos
a página diretamente pelo navegador.
Ou seja, se requisitarmos um arquivo texto, teremos o retorno exato do conteúdo deste
arquivo, se requisitarmos um arquivo PHP teremos o retorno deste arquivo processado como se
abríssemos este arquivo pelo navegador. Sendo assim, nosso retorno é um texto puro, podendo ele
conter HTML ou não.
14. No ExtJS podemos dizer que a forma de trabalharmos com AJAX é um pouco diferente,
podemos criar uma requisição AJAX na mão e trabalharmos com o retorno dela de forma normal,
porém quando usamos de componentes que fazem este acesso por nós ficamos sujeitos a algumas
convenções. Em geral ao criarmos uma requisição Ext.Ajax.request temos em mente trabalhar
diretamente com os dados retornados, quando usamos um Store por exemplo o componente se
encarrega de trabalhar com os dados, para isso precisamos retornar-los em formato JSON, XML ou
ARRAY.
Instalando o servidor Apache
A instalação do servidor Apache é simples e se resume no seguinte:
1. Baixar a ultima versão do arquivo binário Win32 sem OpenSSL (MSI Installer) no
site do Apache;
2. Executar o instalador;
3. Na primeira tela basta clicar no botão Next;
4. Nesta tela temos que aceitar os termos da licença, para isso certifique de que está
marcado o campo I accept the terms in the license agreement e clique em Next;
5. Nesta tela clique em Next;
6. Nesta tela temos de colocar algumas configurações do nosso servidor, para questão
de teste coloque dados ficticíos como os exmplos acima de cada campo, deixe
marcado o campo For All Users, on Port 80... e clique em Next;
7. Nesta tela selecione a opção Typical para fazer a instalação padrão e clique em Next;
8. Nesta tela selecione a pasta de instalação, recomendo deixar a pasta padrão e clique
em Next;
9. Nesta tela clique em Install e aguarde a instalação.
10. Irá abrir uma tela de instalação completa, Installation Wizard Completed, clique em
Finish.
11. Pronto, Apache instalado.
12. Abra seu navegador e digite http://localhost/, se aparecer bem grande escrito It
Works!, parabéns você é o mais novo proprietário do seu próprio servidor WEB.
A pasta padrão do servidor Apache onde devem ficar os arquivos do seu site é uma pasta
chamada htdocs, esta pasta fica dentro da pasta de instalação do servidor apache. Caso você queira
trocar esta pasta para um caminho mais amigável ou para outra unidade de disco basta editar o
arquivo httpd.conf que se encontra dentro da pasta conf que está dentro da pasta de instalação do
apache e trocar as duas ocorrências do caminho padrão pelo caminho desejado e reiniciar o apache.
Dica, use o comando de procurar e procure por htdocs.
Testando o AJAX do ExtJS
Vale lembrar que AJAX é uma comunicação de dados entre cliente e servidor, por isso só
podemos utiliza-lo em arquivos que estejam rodando através de servidores como o Apache que
instalamos anteriormente. Abrir um arquivo diretamente pelo navegador dando 2 cliques no mesmo
carrega o arquivo de fora do servidor, para garantir que o arquivo esteja sendo carregado através do
servidor verifique se o inicio da URL em seu navegador consiste em http://localhost/.
15. Exemplo 1: AJAX e manipulação do retorno dos dados:
1. Crie os arquivos html e js como de costume;
2. Dentro do Ext.onReady do arquivo js coloque o seguinte código:
Ext.Ajax.request({
url:'noticia.txt',
success:function(r){
alert(r.responseText)
}
})
3. Crie um arquivo chamado noticia.txt e coloque o seguinte conteúdo:
Notícia carregada por AJAX. Forma interessante de se trabalhar.
Exemplo 2: AJAX e carregamento de conteúdo de forma simplificada:
1. Crie os arquivos html e js como de costume;
2. Dentro do Ext.onReady do arquivo js coloque o seguinte código:
var win = new Ext.Window({
height:200,
width:300,
title:'Ajax em uma Window',
autoLoad:'noticia2.txt'
})
win.show();
3. Crie um arquivo chamado noticia2.txt e coloque o seguinte conteúdo:
Notícia carregada por AJAX.<br/>Forma interessante de se trabalhar.
Exercícios
7. Pegando o exercício 6 onde temos um grid ligado a um store, troque o store por um que
aceite JSON, retire os dados escritos diretamente no store e coloque-os em um arquivo, por
exemplo grid.txt, defina a url de leitura dos dados e formate em JSON os dados do arquivo
txt. Note que os dados não serão carregados, temos que dizer ao store para carrega-los e para
isso há duas formas, colocar autoLoad:true como configuração do store, ou depois de cria-lo
pegar sua referencia e executar o método laod (meuStore.load()). Como não temos
referencia do store e nem um id para o mesmo temos de usar a opção autoLoad:true que faz
com que os dados sejam carregados assim que o store for criado.
Parte Prática 2: Interagindo nossa interface com o servidor
Altere nosso pequeno sistema para que os dados passem a ser carregados por AJAX de
arquivos .txt no lado servidor. Faça com que possam ser inseridos dados nos grids através de
formulários, analise, estude a escolha um dos métodos usados no arquivo pratica1.1.js. Crie novos
cadastros para praticar um pouco mais. E faça com que ao se clicar no menu para abrir um cadastro
já aberto este cadastro ganhe foco, ou seja, a tab deste cadastro fique ativa.
16. PHP
Conhecendo o PHP
Citação de Wikipédia: PHP:
PHP (um acrónimo recursivo para "PHP: Hypertext Preprocessor") é uma
linguagem de programação de computadores interpretada, livre e muito utilizada para
gerar conteúdo dinâmico na World Wide Web, como por exemplo a Wikipédia.
A linguagem PHP é uma linguagem de programação de domínio específico, ou seja,
seu escopo se estende a um campo de atuação que é o desenvolvimento web, embora tenha
variantes como o PHP-GTK. Seu propósito principal é de implementar soluções web
velozes, simples e eficientes.
Características:
• Velocidade e robustez
• Estruturado e orientação a objeto
• Portabilidade - independência de plataforma - escreva uma vez, rode em qualquer
lugar;
• Tipagem fraca
• Sintaxe similar a Linguagem C/C++ e o PERL
O PHP tem a sintaxe muito similar a sintaxe do JavaScript, usamos de chaves {} para definir
inicio e fim de blocos de código como o conteúdo de um IF por exemplo, temos variáveis com
tipagem entre outras coisas. O PHP nos permite manipular os dados no lado servidor de nossa
aplicação e o mais importante é lembrar que temos que imprimir esses dados na tela, para isso
usamos o comando echo que veremos muito no resto da apostila. Em resumo, o que será impresso
na tela pelo PHP é o que o usuário verá se acessar a pagina .php ou o que receberemos por AJAX se
requisitarmos esta página .php.
Instalando o PHP
A instalação do PHP é ainda mais fácil que a instalação do Apache:
1. Baixe o arquivo do instalador do PHP para windows aqui, selecione o arquivo VC6
x86 Thread Safe tipo Installer, esse é o instalador pra quem tem Apache instalado;
2. Execute o instalador;
3. Na primeira tela, “Well Come ...”, do instalador clique em Next;
4. Na segunda tela, “End-User License Agreement”, marque o campo “I accept the
terms in...” para aceitar os termos do contrato de licença e clique em Next;
5. Na terceira tela, “Destination Folder”, selecione o caminho de instalação ou deixe o
padrão e clique em Next;
6. Na quarta tela, “Web Server Setup”, selecione a opção “Apache 2.2.x Module” para
que o PHP configure o Apache para nós e clique em Next;
7. Na quinta tela, “Apache Configuration Directory”, selecione a pasta de configuração
do Apache que é a pasta conf dentro da pasta de instalação do apache e clique em
Next;
17. 8. Na sexta tela, “Choose Items to Install”, há uma arvore, abra o nó PHP e dentro dele
abra o nó Extencions para selecionarmos as extensões que queremos instalar junto
ao PHP, verifique se a extensão PostgreSQL está selecionada, se não estiver
selecione-a clicando no icone ao lado do nome e clicando na primeira opção da lista.
Caso deseje usar outro banco como o MySQL faça a ativação da extensão para o
banco desejado e clique em Next;
9. Na sétima tela, “Ready to install PHP ...”, clique em Install e aguarde o término do
processo de instalação;
10. Na oitava tela, “Completed the PHP … Setup Wizard”, clique em Finish;
11. Reinicie o Apache;
12. Crie um arquivo teste.php no pasta do servidor Apache e escreva dentro o seguinte:
<?php
phpinfo();
?>
13. Abra o arquivo no navegador através do localhost e veja se apareceu o relatório das
configurações do PHP.
Parte Prática 3: Interagindo nossa interface com o servidor
Troque nossos arquivos .txt que contém nossos dados em formato JSON por arquivos .php e
crie neles a estrutura de dados como exemplificado abaixo.
Exemplo de impressão dos dados em JSON de 2 campos:
<?php
$campos = array(); //Cria um array vazio
$linhas = array();
$campos['estado'] = 'Rio Grande do Sul';
$campos['uf'] = 'RS';
$linhas[] = $campos; //Adiciona os campos ao primeiro item
$campos['estado'] = 'Santa Catarina';
$campos['uf'] = 'SC';
$linhas[] = $campos;
echo json_encode($linhas); //Imprime os campos em JSON
?>
18. PostgreSQL
Conhecendo o PostgreSQL
Citação de Wikipédia: PostgreSQL:
Hoje, o PostgreSQL é um dos SGBDs (Sistema Gerenciador de Bancos de Dados) de código
aberto mais avançados, contando com recursos como:
• consultas complexas
• chaves estrangeiras
• integridade transacional
• controle de concorrência multi-versão
• suporte ao modelo híbrido objeto-relacional
• gatilhos
• visões
• Linguagem Procedural em várias linguagens (PL/pgSQL, PL/Python, PL/Java,
PL/Perl) para procedimentos armazenagem
• Indexação por texto
• Estrutura para guardar dados Georeferenciados PostGIS
Instalando o PostgreSQL e o PgAdmin
Vamos instalar o PostgreSQL:
1. Baixe a última versão do instalador do PostgreSQL para windows aqui, baixe o “the
one click installer”;
2. Execute o instalador e aguarde o início da tela de configurações;
3. Na primeira tela, “Setup – PostgreSQL”, clique em Next;
4. Na segunda tela, “Installation Directory”, selecione um diretório de instalação ou
deixe o padrão e cliqe em Next;
5. Na terceira tela, “Data Directory”, selecione o diretório que conterá os arquivos dos
bancos de dados do PostgreSQL ou deixe o padrão e clique em Next;
6. Na quarta tela, “Password”, informe uma senha para o super-usuário (postgres) do
banco, será criado um usuário no windows chamado postgres que terá esta mesma
senha. Repita a senha no segundo campo e clique em Next;
7. Na quinta tela, “Port”, informe a porta que deseja rodar o serviço de banco de dados
do PostgreSQL ou deixe a porta padrão e clique em Next;
8. Na sexta tela, “Advanced Options”, informe a localidade desejada no primeiro
campo como por exemplo “Portugues, Brazil”, marque o item “Install pl/pgsql in
template1 database” e clique em Next;
9. Na sétima tela, “Ready to Install”, clique em Next e aguarde a instalação terminar;
10. Na oitava tela, “Completing the PostgreSQL Setup Wizard”, desmarque a opção
“Launch Stack Builder at Exit” e clique em Finish;
11. Procure no menu iniciar pelo diretório do PostgreSQL e abra o PgAdmin contido
nele;
12. De 2 cliques no servidor PostgreSQL localhost contido na lista a esquerda e informe
a senha do usuário postgres;
13. Estamos prontos para começar a criar nosso banco de dados.
19. Criando nosso Banco de Dados
1. Abra o PgAdmin;
2. Crie um novo banco de dados de nome “extjs”, dono “postgres” e codificação “UTF8”;
3. Conecte no banco “extjs” recém criado;
4. Dentro do esquema “public” crie as seguintes tabelas:
1. Tabela de nome “pessoas”, dono “postgres” e as seguintes colunas:
• id, integer, PK;
• nome, character variyng (60);
• profissao, character variyng (30);
• idade, integer;
2. Tabela de nome “cidades”, dono “postgres” e as seguintes colunas:
• id, integer, PK;
• cidade, character variyng (20);
• uf, character variyng (2);
Parte Prática 4: Tornando nossa aplicação funcional
1. SELECT: Altere nossos arquivos .php para que ele busque as informações do banco de
dados, para isso basta conectar ao banco, executar uma pesquisa e imprimir o resultado em
JSON, exemplo:
<?php
$h = 'localhost'; //Local do banco
$p = 5432; //Porta do banco
$db = 'extjs'; //Banco a se conectar
$u = 'postgres'; //Usuário
$pw = 'postgres'; //Senha
//Tenta conectar e passar a referencia para $db, se não for possível
//ele termina a execução com erro e imprime o erro do banco
if(!$db = pg_connect("host=$h port=$p dbname=$db user=$u password=$pw"))
die ("Erro ao conectar ao banco<br/>".pg_last_error($db));
//Executa um SQL no banco e guarda o retorno em $result
$result = pg_query($db, "SELECT id, nome, profissao, idade FROM pessoas");
//Se $result está definido a query teve sucesso
if($result){
//Pega todos os dados da consulta em um array bidimencional
//e os codifica para JSON
echo json_encode(pg_fetch_all($result));
}else{
echo "Erro na consulta.";
}
?>
20. 2. INSERT: Agora devemos alterar os arquivos PHP e JS, no arquivo PHP precisamos de uma
estrutura condicional que verifique que ação estamos requisitando, agora teremos duas ações
(SELECT e INSERT) e no arquivo JS precisamos enviar as informações do formulário para
o PHP e também precisamos enviar qual a ação que queremos realizar.
• JS: O FormPanel possui um método interno pra enviar os dados por ajax para o
servidor, é o método submit do formulário interno que também possui o método isValid
que verifica se todos os campos estão corretos de acordo com suas validações.
Observação importante, cada campo do formulário deve ter a propriedade name
identificando um nome para cada campo, este é o nome que usaremos no lado servidor
para pegar os valores enviados. Exemplo:
//isValid retorna true se todos os campos estiverem corretos
if(Ext.getCmp('idDoFormPanel').getForm().isValid()){
Ext.getCmp('idDoFormPanel').getForm().submit({
url:'arquivo.php', //url do arquivo a receber os dados
params:{ //parametros adicionais
acao:'insert'
},
success:function(){
//Código a ser executado ao termino do AJAX
//Como recarregar um grid por exemplo;
}
})
}else{
alert('campos inválidos');
}
• PHP: Antes tínhamos apenas uma ação para o arquivo PHP em questão que era retornar
os dados do banco, agora temos 2 (SELECT e INSERT) e no futuro termos mais 2
(UPDATE e DELETE), por esse motivo precisamos saber no lado PHP que ação o lado
cliente está requisitando, para isso passamos um parâmetro por POST ao arquivo
informando qual a ação a ser executada e dentro do código PHP podemos fazer um IF e
separa os blocos de ação. O código abaixo não substitui o código já criado no arquivo
PHP, é apenas um exemplo de como implementar a condição da ação a ser requisitada.
Cada campo é pego por $_POST['nomeDoCampo']. Exemplo:
if($_POST['acao']=='insert'){
$id = '(SELECT COALESCE(MAX(id), 0)+1 FROM pessoas)';
$nome = $_POST['nome'];
$profissao = $_POST['profissao'];
$idade = $_POST['idade'];
$result = pg_query($db, "INSERT INTO pessoas(id, nome,
profissao, idade) VALUES($id, '$nome', '$profissao', $idade)");
}else{
//Bloco de código a ser executado case não seja ação 'insert'
//Como o select por exemplo;
}
21. 3. DELETE: Para implementarmos a deleção precisamos alterar os dois lados da aplicação.
• JS: Precisamos adicionar o campo ID no nosso store para que possamos envia-lo ao PHP
para identificar qual registro queremos excluir, esta alteração não exemplificarei aqui
pois é simples, e precisamos adicionar um botão em nossa tela, na TBAR por exemplo, e
definir em seu HANDLER um requisição ajax enviando a ação quer queremos realizar e
o ID do registro a ser excluído. Exemplo:
var grid = Ext.getCmp('gridPessoas');
if(grid.getSelectionModel().getSelected()){
Ext.Ajax.request({
url:'arquivo.php',
params:{
acao:'delete',
id:grid.getSelectionModel().getSelected().data.id
},
success:function(){
grid.getStore().reload();
}
})
}
• PHP: Precisamos criar mais um IF para esta ação:
if($_POST['acao']=='insert'){
//Código da ação de insert
}if($_POST['acao']=='delete'){
$id = $_POST['id'];
$result = pg_query($db, "DELETE FROM pessoas WHERE id = $id");
}else{
//Código da ação de select
}
4. UPDATE: Essa é uma ação complicada, ela se resume em pegar a linha selecionada no grid,
carregar estes dados para um formulário de forma que o usuário possa editar as informações
e envia-las por submit com a ação de update.
• JS: Crie um botão para a alteração, copie o handler do botão de adicionar, coloque um
IF em torno deste código verificando se existe uma linha selecionada no grid, adicione
um campo a mais no formulário para conter o ID do registro, exemplificarei abaixo,
adicione um listeners na window e dentro adicione o evento show, dentro deste evento
carregue os dados para o formulário (os campos devem ter os mesmos nomes dos
campos do store) e no handler do botão de salvar altere a ação para update:
//código a ser adicionado a window
//listeners é uma propriedade da window assim como height, width,
etc
listeners:{
show: function(){
var form = Ext.getCmp('formPessoas').getForm();
form.loadRecord(grid.getSelectionModel().getSelected());
}
}
• PHP: Temos de adicionar mas um bloco de código:
if($_POST['acao']=='update'){
$id = $_POST['id'];
$nome = $_POST['nome'];
$profissao = $_POST['profissao'];
$idade = $_POST['idade'];
$result = pg_query($db, "UPDATE pessoas SET nome = '$nome',
profissao = '$profissao', idade = $idade WHERE id = $id");
}
22. Extend e Override
Adaptando o ExtJS as nossas necessidades
Ext.extend e Ext.override são formas de modificar e adicionar classes da biblioteca ExtJS,
ambos são funções internas da biblioteca.
1. Extend: Esta função nos permite estender uma classe já existente adicionando novas
propriedades, métodos, eventos e valores padrão. Um bom e simples exemplo seria estender
a classe Window para uma classe chamada MyWindow e adicionar a ela altura e largura
padrão:
Ext.onReady(function(){
Ext.namespace('Ext.ux');
Ext.ux.MyWindow = Ext.extend(Ext.Window, {
height:200,
width:300
})
var win = new Ext.ux.MyWindow({
title:'Teste',
html:'<b>Minha primeira janela em ExtJS</b>'
})
win.show();
})
2. Override: Esta função nos permite adicionar funcionalidades a uma classe já existente sem
que seja necessária a criação de uma nova classe. Um bom exemplo seria adicionar um
método a classe Ext.data.Store que nos permita adicionar registros mais facilmente como
demonstrado no código abaixo, um exemplo mais complexo e de grande utilidade é um
override que nos permite adicionar colunas em um formulário de forma fácil que pode ser
encontrado aqui:
Ext.override(Ext.data.Store, {
insertRecord: function(record,index){
index = index || 0;
record = record || {};
this.insert(index, new this.recordType(record,null,true))
}
})
//Antes do override tinhamos de proceder assim:
//store.insert(0, new store.recordType(form.getForm().getValues()));
//Após o override podemos proceder assim:
//store.insertRecord(form.getForm().getValues());
23. Praticando um pouco mais
Criando mais cadastros em nossa aplicação
Esta parte está destinada a última aula deste curso e consiste em criar novos cadastros para
praticarmos um pouco mais, esta criação de novos cadastros envolve criação de tabelas no banco de
dados, criação dos arquivos PHP necessários e adição dos códigos JavaScript necessários.
Aconselho quem estiver com alguma dificuldade criar mais cadastros de campos corridos,
como um cadastro de empresas por exemplo, e quem estiver mais seguro aconselho a criação de um
cadastro de estados fazendo as alterações na tabela e tela do cadastro de cidades para efetuar a
ligação entre ambos e que o usuário possa selecionar em um combobox o estado da cidade.
E por fim aconselho a todos soltar a imaginação, estudar os exemplos e a documentação e
claro, pedir ajuda a alguem mais experiente em ExtJS, no caso deste curso presencial, o professor.
24. Fim
Agradecimentos
Obrigado a todos que estiveram presentes neste pequeno curso, aos laboratoristas e claro aos
professores da FACCAT em especial ao coordenador do curso de Sistemas de Informação Marcelo
Azambuja.
Abraços a todos.