Tutorial sobre a ferramenta de construção de Websites …paf/proj/Set2001/frontier-final.pdf · HTML até a parte de scripts na qual pode-se automatizar a construção dos sites

Tutorial sobre a ferramenta de construção de Websites Frontier

Projecto do Curso de Engenharia Informática do Ramo de Computadores e Sistemas

sob a orientação do Eng.º Paulo Ferreira

Luís Gonçalves de Andrade

Setembro de 2001


Página III

Índice

1 – Introdução.....................................................................................................1 2 - História..........................................................................................................5 3 - Arquitectura ..................................................................................................7 4 - Tutorial........................................................................................................10

4.1. Considerações Gerais ..........................................................................11 4.2. Construção de Sites através do Framework.......................................12

Novo Website ............................................................................................13 Publicar uma Página..................................................................................15 Editar uma página......................................................................................16 Nova Página ..............................................................................................17 Modificar directivas ..................................................................................19 Publicar um site .........................................................................................21 Publicar para um servidor .........................................................................22 Imagens .....................................................................................................24 Modelos .....................................................................................................26 Múltiplos modelos.....................................................................................28 Ligações entre páginas: Glossário.............................................................31 Includes .....................................................................................................34 Hiperligações do tipo anterior e próximo .................................................35 Outlines .....................................................................................................36 Outline Renderers .....................................................................................38 Javascript ...................................................................................................40 Cascading Style Sheets..............................................................................42

4.3. Scripting ................................................................................................44 Scripts Simples ..........................................................................................45 Operadores.................................................................................................46 Tipos de dados...........................................................................................48 Variáveis....................................................................................................49 Criar macros: 1º Caso - Apontadores........................................................51 Criar macros: 2º Caso – Ciclos, âmbito e strings......................................54 Criar macros: 3º Caso – Ficheiros.............................................................57 Criar macros: 4º Caso – Tabela da Página ................................................59 Filtros.........................................................................................................61 Outline Renderers .....................................................................................63 XML ..........................................................................................................65

4.4. Construção de sites através da Web ...................................................68 Sites ...........................................................................................................71 Settings ......................................................................................................72 Readouts ....................................................................................................74 Help ...........................................................................................................75


Página IV

Criar vários sites e domínios a servir ........................................................76 Apagar um site ..........................................................................................78 Mover um site............................................................................................79 Apagar domínios .......................................................................................80 Conversão de trabalho entre Framework Frontier/Manila........................81 Exemplo 1: Criar um grupo de discussão .................................................82 Exemplo 2: Criar histórias.........................................................................85 Exemplo 3: Criar notícias..........................................................................86 Exemplo 4: Edição do site.........................................................................87

4.5. Tópicos Avançados ..............................................................................88 XML-RPC .................................................................................................89

O que é? .................................................................................................89 Como funciona? .....................................................................................89 Como implementar?...............................................................................89

SOAP para Frontier ...................................................................................93 O que é? .................................................................................................93 Como funciona? .....................................................................................93 Como implementar?...............................................................................93

5 - Conclusão....................................................................................................98 Bibliografia.....................................................................................................101 Apêndice.........................................................................................................104


Página 1

1 – Introdução


Página 2

Neste tutorial, será abordada a ferramenta de construção de Websites, UserLand Frontier. O Frontier é um CMS(Content Management System), uma base de dados, contém uma linguagem de scripting (UserTalk), outliner(para escrita de HTML estruturado, XML e modelos), ferramentas, servidor HTTP, protocolos da computação distribuída como XML-RPC e SOAP, e funciona em Windows e Macintosh. Pertence à empresa UserLand e também inclui um sistema de CMS baseado na Web, chamado Manila.

O Frontier é também um servidor de grupo de trabalho desenhado para suportar membros de um grupo de trabalho em um site, com uma ligação ao Website Framework, uma interface para grupos de discussão, preferências e gestão de membros.

Possui então as seguintes características:

• Servidor Web – suporta gestão de membros, preferências, área de trabalho, grupos de discussão, domínios virtuais, subscrições, calendários, cookies, registo de acessos, sites de notícias, uploads de ficheiros.

• Content Management System – É um sistema que providencia soluções rápidas na criação de sites, extremamente centrado no conteúdo, para que quem edite o site, preocupe-se mais com a informação do que com escrita de código HTML ou XML, por exemplo. Permite também que haja vários tipos de escritores do site, publicação de notícias, aparência de páginas muda conforme modelos, entre outras funcionalidades.

• Website Framework – está ligado directamente ao servidor HTTP, e contém um conjunto de ferramentas para criar e gerir os Websites.

• Grupo de discussão – permite que um grupo de trabalho troque mensagens. Estes grupos de discussão podem ser obtidos a partir de diferentes modelos existentes.

• Indexação de páginas – O site é todo indexado, o que permite que se pesquise algo no site.

• Extensão cliente-servidor – permite que um grupo de pessoas trabalhe em um Website ou num projecto de scripting.

• Área de trabalho – o grupo de trabalho pode ter uma área de trabalho partilhada, individual ou pública.

• Preferências – estão guardadas no servidor e podem ser vistas através de um interface Web.

• Programável - tanto o servidor como a estação de trabalho, têm uma linguagem de scripting integrada, uma base de dados, HTTP integrado, suporte XML, ferramentas de edição e de scripting.


Página 3

• Calendários – permitem facilmente ver o que aconteceu numa determinada data. A página central de um site Manila tem ligações para os eventos diários colocados por um editor ou uma equipa de edição.

• Ligação XML-RPC – facilita a edição de texto num browser, pois integra editor de texto, outliner e editor de script.

• Escalonável- pode servir muitos de utilizadores que acedem a uma enorme quantidade de páginas por dia. Em muitas situações o Frontier também pode ser o servidor primário dos utilizadores do site. Pode-se gerar páginas estáticas para serem servidas por outros servidores estáticos ou dinâmicos, mesmo que possuam outros sistemas operativos.

• Cria sites estáticos/dinâmicos- o site estático usa o rendering estático, que gera ficheiros HTML e guarda-os no disco. O dinâmico, como a própria palavra diz, permite que o site, esteja em permanente mutação através de notícias publicadas, mensagens de grupos de discussão, etc.

O que será visto ao longo deste tutorial propriamente dito, será como

construir um Website com o Framework numa primeira fase, após o qual segue-se uma fase de trabalho com a linguagem de scripting, UserTalk, e por fim, analisa-se a ferramenta Manila como ferramenta de apoio ao Frontier, assim como os protocolos XML-RPC e SOAP.

São usadas ainda, as seguintes referências ao longo do tutorial:

As marcas Frontier, Manila, Radio, XML-RPC devem ser entendidas com sufixo e pertencem à UserLand Software, Inc.

UserTalk pertence à UserLand Software, Inc.

As marcas Java, Javascript devem ser entendidas sufixo e pertence à Sun Microsystems, Inc.

A marca Perl deve ser entendida com sufixo e pertence à O'Reilly & Associates, Inc.

A marca DevelopMentor deve ser entendida com sufixo e pertence à DevelopMentor, Inc.

A marca Windows deve ser entendida com sufixo ® e pertence à Microsoft Corporation.

A marca WebStar deve ser entendida com sufixo ® e pertence à StarNine Technologies, Inc.


Página 4

As marcas AppleScript, Macintosh, Mac devem ser entendidas com sufixo ® e pertencem à Apple, Inc.

HTTP, HTML e XML pertencem à W3C® World Wide Web Consortium.

Apache, IIS, PHP, SOAP, Python, C e C++ não requerem referências específicas.


Página 5

2 - História


Página 6

O desenvolvimento da ferramenta Frontier inicia-se em 1988 como uma ferramenta de programação de scripts para ambiente Macintosh.

A Userland, empresa que produz o Frontier actualmente, entre outras ferramentas, inicia o lançamento então da versão 1.0, em 1992, com possibilidade de guardar dados em formato de base de dados, comunicação inter-aplicações e principalmente com programação de scripts, fazendo uso dos eventos Apple que surgem então.

Em Novembro de 1992, é lançada a versão 2.0, que recebeu um prémio como melhor ferramenta de desenvolvimento em 1992, atribuído pela MacUser’s(Website de utilizadores Mac desactivado).

Em 1993 é então, lançada a versão 3.0. Após esta fase, surge então o Applescript, que inicialmente não esteve

logo disponível, e apesar de ser barato, poucos aderiram à ideia. Contudo a Apple responde e junta ao software de sistema o Applescript. A UserLand decide contra atacar, e distribui o Frontier livremente, cujo nome de código era “Aretha”. É também o momento em que o Frontier volta-se para a Web, como construtor de sites e CGIs. Surgem então as versões 4.0 em Maio de 1996, que foi a primeira a incluir o Website Framework , 4.1 em Outubro de 1996 e 4.2 em Janeiro de 1997.

Em Janeiro de 1998 surge a versão 5.0, que é a primeira a funcionar em ambiente Windows e Macintosh. É actualizado para 5.1 em 24 de Junho do mesmo ano.

A versão 6.0 surge em 26 de Março de 1999. E finalmente a verão 7.0.1 aparece em Junho de 2001, com a novidade

de estar presente também na plataforma Mac OS X.


Página 7

3 - Arquitectura


Página 8

O Frontier além de ser um poderoso sistema de gestão de conteúdos (Content Management System - CMS) é também um servidor HTTP, que permite que o conteúdo seja gerado através de modelos e macros. Por outras palavras, todos os benefícios de gestão de conteúdos podem ser aplicados a sites dinâmicos com apresentação personalizada. O Frontier também pode ser executado atrás de um servidor estático, como Microsoft IIS ou WebSTAR, mas nessa caso desperdiça-se a facilidade do Frontier integrar servidor de HTTP e CMS num único software. Portanto, a arquitectura do servidor Frontier assenta em responders. Um responder é uma colecção de scripts(programas) e dados que escutam pedidos HTTP.

Desde a versão 6.0, que existe responder chamado mainResponder, que corresponde a uma arquitectura de alto nível que providencia gestão de membros, preferências, área de trabalho, grupos de discussão, domínios virtuais, subscrições, indexação de páginas, calendários, cookies, registo de acessos, sites de notícias e uploads de ficheiros. Este aparece como mainResponder.root, porque a extensão “root” é de base de dados do Frontier.

Portanto, em termos de arquitectura, o Frontier possui:

• MainResponder.root – responder principal; • Guest Databases Folder(GDB) – é a shell para a presença na Web. Está

no topo do directório do Frontier e contém três subdirectórios: o www – Onde ficam os ficheiros, subdirectórios e base de dados

que são colocados neste directório acessível através da Web. Possuem normalmente estes dois ficheiros: ManilaWebsites.root – contém informação acerca dos

Websites Manila; Prefs.root – contém as preferências dos Websites Manila;

o ops – Contém logs, backups, informação de membros, e outros

ficheiros que são úteis para o site mas não são visíveis via HTTP e os dois ficheiros mais importantes são:

Members.root – A informação sobre cada membro é

guardada aqui; Discuss.root – Onde estão todas as mensagens do grupo de

discussão;


Página 9

o apps – Contém software e um ficheiro de configuração chamado config.root, que aparece quando o mainresponder é executado a primeira vez. Config.root – tem configurações gerais do MainResponder

e do Manila; Manila.root – é a aplicação Manila;

• Frontier.root – é uma base de dados que contém as funções internas do

Frontier; • User.databases – controla que base de dados são automaticamente

abertas quando o Frontier arranca; • Frontierstartupcommands.txt – ficheiro de texto que contém um script

que é executado quando o Frontier arranca.


Página 10

4 - Tutorial


Página 11

4.1. Considerações Gerais

Este tutorial pretende demonstrar uma forma diferente de criar páginas Web, através do conjunto de ferramentas do Frontier (Framework), e num nível intermédio-avançado, começando pela parte de construção de sites com HTML até a parte de scripts na qual pode-se automatizar a construção dos sites. Na última parte ver-se-á a ferramenta Manila como ferramenta de apoio ao Frontier e com tópicos directos ao assunto, como também os protocolos XML-RPC e SOAP.

Parte-se do princípio de que quem utilizar o tutorial tenha conhecimentos básicos prévios de HTML, XML e de noções gerais de informática. Mesmo assim, está escrito de forma a que uma pessoa com poucos conhecimentos informáticos possa rapidamente aprender a trabalhar com este software.

Além disso, o tutorial segue uma ordem lógica, de forma a iniciar a construção de uma página que inicialmente é simples, mas a medida que se avança, as páginas tornam-se mais complexas. A metodologia utilizada é ainda, baseada em exemplos práticos. Durante o tutorial, considera-se que o Frontier está instalado e a correr num servidor, embora sempre que necessário, são feitas diferenciações quando o Frontier está instalado num cliente.

O tutorial incide sobre a versão 7.0.1 mas é retrocompatível no global com versões anteriores, pelo menos até à versão 5, de acordo com afirmações da UserLand.


Página 12

4.2. Construção de Sites através do Framework

Para iniciar o Framework execute o “Frontier.exe” que está no

directório onde o Frontier foi instalado, após o qual ver-se-á a Figura 1:

Figura 1 – Visão Geral do Framework


Página 13

Novo Website

Para construir o Website(colecção de documentos Web – HTML, figuras, etc.), primeiro é necessário criar uma nova base de dados. O porque da base de dados reside no facto de termos um tipo de estrutura que contém um conjunto de informação em que são organizadas as páginas. Um site é constituído por uma base de dados, que contém tabelas, e estas por sua vez contêm vários tipos de dados, e scripts semelhante às base de dados clássicas.

Para criar então o primeiro site, é necessário ir ao menu File, submenu New e opção Database. Pode-se dar um nome qualquer, chamemos “exemplo.root” e guardamos no directório “www”, que é um subdirectório do Frontier Guest Databases. A extensão das bases de dados do Frontier são “root”, e guarda-se em “www”, pois desta forma temos um ponto de acesso, por defeito no Frontier.

A base de dados terá, então, o seguinte aspecto (parece uma tabela):

Figura 2 – Item da base de dados

Para criar o Website, usa-se a opção New Website... do menu Web, o

que irá permitir dar um nome ao site, por exemplo, “tutorial” (Figura 3):

O próprio Frontier é uma base de dados armazenada em “frontier.root”,que contém as funções internas e é o ponto de onde partem as restantesbases de dados criadas pelo utilizador. A Guest Database é o local onde sãoguardadas as bases de dados criadas pelo utilizador para seremautomaticamente publicadas.


Página 14

Figura 3 – Visão da estrutura de um Website

Ao fechar esta janela, pode-se voltar à inicial, e pode-se apagar o “item

#1”, pois não é necessário para a estrutura. Para fazê-lo, deverá seleccionar (triângulo à esquerda) o referido item e pressionar a tecla delete ou através de Clear do menu Edit. Pode-se averiguar ao expandir os itens da base de dados, o conteúdo e subconteúdo dos mesmos. Caso necessite de ver somente a janela referente a um item, basta fazer o mesmo, mas sobre o item na coluna Value.

Nesta altura pode-se então gravar a base de dados(CRLT+S ou opção Save Database do menu File).

Na Figura 3, temos várias tabelas ou outro tipo de estrutura (coluna Name),número de elementos em estrutura (Value) e tipo de dados(Kind). Alémdisso, os itens que começam com #, significam que não são páginas Web,mas são recursos que serão utilizados na altura que o Frontier fizer orendering ou apresentação final da página. Há um único item que é umapágina html – index.

Algumas formas de acesso rápido nas tabelas: Ver em detalhes – Duplo clique no triângulo ou em Value ou CTRL +Enter do teclado numérico Expandir ramos da hierarquia – tecla + ou Duplo clique no triângulo emitens que contenham subitens. Encolher ramos da hierarquia - tecla - ou Duplo clique no triângulo emitens que contenham subitens. Nota: Em Macintosh deve-se entender o CTRL como command key e oEnter do Windows deve-se entendido como Return.


Página 15

Publicar uma Página

Para publicar a página gerada pelo Frontier, também é simples, visto que o Frontier facilita essa tarefa através do item #ftpsite que indica a localização da página no disco local, como por exemplo, “C:\Frontier\Websites\Tutorial”. Em termos de estrutura, isto deve-se ao facto de os Websites ficarem dentro do subdirectório “Websites”.

Portanto, na prática, selecciona-se a página index da tabela “tutorial” e escolhe-se Publish Page do Web menu (CTRL+’). O Frontier vai invocar o browser por defeito do sistema e mostrará a página “index.html” gerada, para já sem conteúdo. Se for visto o código HTML da página, verifica-se que o Frontier gerou essa página. Para isso, contribuíram os itens definidos na tabela “tutorial”, que permitem gerar o título Home, as cores de fundo, etc.

Figura 4 – Página gerada pelo Frontier

O Frontier gera páginas automaticamente de acordo com os itensdefinidos na base de dados, tais como conteúdos, directivas, etc. eencaminha-as para um modelo(template) que se encarrega de construiruma página Web, a isto chama-se rendering ou construção automáticafinal da página. Uma página diz-se rendered quando sofre rendering. As páginas não necessitam de ter extensão nas tabelas, visto que oFrontier adiciona “.html” às páginas. As páginas utilizadas por defeito,são o “index” ou “default”.


Página 16

Editar uma página Para alterar o conteúdo de uma página, simplesmente selecciona-se a página pretendida index, como já referido anteriormente em “ver em detalhes”. As páginas são do tipo wp-text, ou seja, mais um tipo de estrutura no Frontier. Wp-text, significa Word Processing, ou melhor é um processador de texto simples, que facilita a edição de páginas. Ao abrir a página vê-se então apenas o título da mesma, através da directiva #title, que é algo que afecta o conteúdo da página de acordo com uma função específica. Começa pelo sinal #, e possui uma hierarquia, que começa pelo raiz da estrutura em #prefs da tabela “tutorial”. Neste caso particular a directiva title define o título a colocar na página, ou seja, converte para as etiquetas HTML “<title>” e “</title>”, simplificando a elaboração da página.

Pode-se então modificar o conteúdo da página, e o seu título de forma a ficar de acordo com a Figura 5, por exemplo. Depois basta publicá-la de forma a ver o aspecto gerado, e o código HTML criado.

Figura 5 – Página Frontier com directiva

Nesta página foi introduzida mais uma directiva que define a cor de

fundo da página e algumas etiquetas HTML que podem ser introduzidas manualmente, ou através do menu HTML do Frontier.

A hierarquia das directivas obedece às seguintes regras: • Uma directiva definida em #prefs é aplicada a toda a página gerada; • Uma directiva numa tabela é aplicada a qualquer página através da

entrada nessa tabela ou subtabelas dessa tabela; • Uma directiva numa página aplica-se somente a essa página; • É válida a mais restritiva, no caso de haver mais do que uma

directiva, ou seja, a mais próxima da página Web; • Se a directiva está em #prefs não é necessário começar por #.


Página 17

Nova Página Para criar outras páginas, selecciona-se qualquer item da tabela “tutorial”, seguido de New Page do menu Web. Desta forma é pedido logo um título para a página, e fica em modo de edição da página. O nome dado à página é o mesmo do título definido, e pode ser alterado, seleccionando o item e rescrevendo o novo nome(ou tecla Enter do teclado numérico). Um exemplo pode ser o da Figura 6.

Figura 6 – Outra página Frontier com directivas

Depois de publicada terá a seguinte aparência:

Figura 7 – Visão da página rendered com directivas

Ou seja, ao analisar o código da Figura 6 definiu-se uma directiva para o título, outra para fundo branco e outra para texto apresentado a negro. Pode-se pretender criar uma página dentro de uma estrutura hierárquica. Ou seja, o Frontier estabelece uma correspondência directa entre tabelas e


Página 18

subtabelas e directórios e subdirectórios no disco. Se for visualizada a estrutura do directório “C:\Frontier\Websites\tutorial”, e for criada uma nova tabela chamada “exemplo”, e dentro desta um objecto wp-text(página HTML), surgirá no disco na altura na publicação um subdirectório de “tutorial” com o mesmo nome da subtabela, “exemplo”. Para criar esse exemplo, usa-se a tecla Enter depois de seleccionado um item qualquer do Website “tutorial”, o que criará o “new item #1”. Depois, ao efectuar um duplo clique sobre o triângulo à esquerda do novo item, aparecerá uma caixa de diálogo, que permite introduzir o nome da tabela, que será “exemplo”, e permite também escolher o tipo de dados a colocar, que neste caso é table(tabela - Figura 8). Por fim, faz-se Zoom e uma nova janela surge para mostrar somente o interior de “exemplo”.

Figura 8 – Criação de entradas na base de dados

Aparece também um “new item #1”, que deve ser substituído por um

nome de uma página, por exemplo, “tres” e deve ser do tipo wp-text. Aproveita-se o mesmo código da página “dois”, altera-se o título e inclui-se mais algum texto no fim só para diferenciar das páginas anteriores. Depois, publica-se a página e pode-se ver no browser que a página “tres” aparece dentro de “tutorial/exemplo”.

Figura 9 – Página incluída numa subtabela


Página 19

Modificar directivas Para modificar a cor de fundo, do texto, das hiperligações em todas as páginas no site, o ideal é ajustar as directivas definidas em #prefs, cujo principal objectivo é reunir as directivas do site num único local. Ao expandir a tabela #prefs, verificam-se uma série de directivas, conforme se pode verificar na Figura 10.

Figura 10 – Tabela #prefs

Para modificar uma directiva, por exemplo, a cor de fundo (bgcolor), em Value, deve-se modificar para azul, introduz-se blue nessa coluna e ao pressionar Enter ou F2, o Frontier encarrega-se de traduzir a cor azul para valor hexadecimal “0000FF”, ou então se for conhecido o valor hexadecimal pode-se introduzir directamente, mas entre aspas, para que o Frontier não concatene os zeros num só. O mesmo pode ser feito para a cor do texto(text), cor da hiperligação activa(alink), cor da hiperligação já visitada(vlink), e cor normal da hiperligação(link). Depois das modificações basta publicar a página através da selecção da página que se pretende ver as alterações, ou pedir uma previsão da página através do Preview Page do menu Web. Caso se pretenda páginas com cores diferentes, deve-se ter em conta as regras das directivas, em que se define na própria página uma cor diferente e esta é que será válida para a página a ser construída automaticamente, não importando o que está definido em #prefs. Para saber todas as directivas existentes deve-se consultar http://frontier.userland.com/stories/storyReader$238. Contudo, há algumas directivas que são bastante utilizadas, além das já explicadas acima, que são boleanas: activeURLs, addLineFeeds, autoParagraphs, e clayCompatibility. A primeira directiva significa que


Página 20

quando se introduz um URL, o Frontier automaticamente converterá, o URL ou endereço de correio electrónico numa hiperligação, por exemplo, ao introduzir: http://frontier.userland.com o Frontier traduz para http://frontier.userland.com.

A directiva addLineFeeds, define se deve ou não um carriage return ser convertido para um par carriage return/line feed(true ou false). AutoParagraphs quando verdadeira significa que cada vez que se deixa uma linha em branco, são convertidos numa etiqueta “<p>”. E a última, clayCompatibility, se verdadeira torna activa a compatibilidade com um antigo programa da UserLand designado Clay Basket. Tem então duas características: se uma linha começa com três asteriscos, o restante da linha é convertido para negrito; se uma linha começa por três hífens então uma etiqueta “<hr>” será gerada. Para adicionar novas directivas na tabela #prefs, primeiro deve-se seleccionar um item qualquer dessa tabela, e de seguida pressionar a tecla Enter principal. Aparecerá um novo item designado, “item #1”, que deve ser editado para colocar a directiva desejada, por exemplo, maxFileNameLength, que define o tamanho máximo de ficheiros criados pelo Frontier. Além disso, deve ter em Value por exemplo 20, ser do tipo String[2], que pode ser seleccionado no botão Kind.

Modos de trabalho em tabelas: Modo de selecção – tecla Enter principal, não o Enter do teclado numérico.Pode-se:

• Criar novos itens – Com Enter Principal num item • Apagar itens – Com a tecla delete sobre o item • Mover itens – ao clicar no triângulo à esquerda do item, e sem largar,

posicionar-se no novo local e libertar o botão do rato. Modo de edição – tecla Enter do teclado numérico ou F2, e no qual podemodificar o nome e o valor do item.


Página 21

Publicar um site Para publicação de um site na totalidade, usa-se o comando Publish Table do menu Web. Para isso, é necessário seleccionar previamente uma página qualquer da base de dados desse site, e depois de usar o comando anterior, confirmar com Ok, que se pretende ‘Publish all web objects in “tutorial”?’. No caso exemplificado, a página “index”, a “dois” e a “tres” sofrerão rendering para o disco, e o browser mostrará a página principal. Se houver subtabelas, estas podem ser publicadas separadamente através da selecção de página qualquer da subtabela e seleccionar Publish Table do menu Web. Ou seja, sempre que se selecciona uma página qualquer no nível principal, todas as subtabelas serão publicadas, caso contrário, serão somente publicadas as subtabelas respeitantes à página seleccionada.


Página 22

Publicar para um servidor Este tópico refere-se quando o Frontier não está no servidor, mas sim num cliente, ou quando o Frontier não é um servidor primário. Como foi dito até aqui, para publicar uma página ou um site no próprio servidor que está instalado o Frontier basta utilizar a opção Publish Page ou Publish Table. Para que se possa efectuar a publicação através de um cliente tem de se ter atenção à tabela #ftpSite, pois é nesta tabela que se encontra informação sobre para onde vão os ficheiros gerados e como obtê-los. Esta tabela deve conter no mínimo o campo method, que indica o método de publicação: via sistema de ficheiros(file), FTP ou base de dados(odb). Os dois primeiros são os mais usados, embora o odb também tenha interesse. Veja-se então os três métodos:

• Via sistema de ficheiros – é o método mais tradicional, pois permite publicação através de um servidor mapeado como um volume existente na rede. Neste método, a tabela #ftpSite necessita de conter os seguintes itens:

o folder: é o caminho para o directório onde serão colocadas as páginas do Website. Por exemplo: “F:\inetpub\wwwroot\” ou no Macintosh “HD:WebSTAR”;

o isLocal: deve ser verdadeiro(true). Este item existe para manter compatibilidade com versões anteriores do Frontier;

o method: neste caso deve ser preenchido com file; o url: este é o URL do directório onde está o site, por exemplo,

http://www.exemplo.com .

• Via FTP – Utiliza o protocolo FTP para publicação e precisa de conter os seguintes itens:

o account: o nome de utilizador para o servidor FTP; o password: a senha de utilizador para o servidor FTP; o directory: o directório do servidor de FTP para onde vão ser

colocadas as páginas; o domain: o nome ou endereço IP do servidor de FTP; o folder: onde as páginas vão ser guardadas no disco antes do

Frontier enviar para o servidor FTP; o isLocal: tem o mesmo significado que no método anterior; o method: neste caso deve ser preenchido com ftp; o url: tem o mesmo significado que no método anterior.

• Via base de dados – Publica directamente para a base de dados especificada e tem três itens:

o method: neste caso deve ser preenchido com odb;


Página 23

o odbAddress: deve ser o endereço que aponta(representado pelo símbolo @) para onde o site será publicado no Frontier.root ou numa Guest Database. Exemplo: @workspace.sites;

o url: tem o mesmo significado que nos métodos anteriores.

Se o local onde está o Frontier é o próprio servidor pode-se também utilizar o método por sistema de ficheiros, para publicar directamente num URL, e nesse caso, modifica-se o item url da tabela #ftpSite para o URL que se pretende ao invés do que está previamente definido que é file:///C:/Frontier/Websites/tutorial.


Página 24

Imagens Para usar imagens no Website, existe uma tabela especial denominada #images, que inicialmente está vazia. Para introduzir então uma imagem, por exemplo, um GIF ou JPEG, primeiro selecciona-se a tabela #images, usa-se a opção Load Image File..., e na caixa de diálogo que aparece de seguida, escolhe-se então a imagem a colocar, através do directório onde se encontra, e pressiona-se o botão Open. A imagem é então, armazenada no Frontier na tabela #images, como tipo binário e cujo nome é o mesmo do ficheiro GIF ou JPEG, mas sem extensão. Como ilustração do uso de imagens numa página, ao editar a página “dois.html”, criada anteriormente, e supondo que a imagem introduzida na tabela tenha o nome “figura1”, ao acrescentar o seguinte código no fim do código existente: <p>{imageRef (“figura1”)}

e depois de publicar a página, ver-se-á a imagem aparecer na página dois. Neste pedaço de código vê-se pela primeira vez o uso de uma macro. Estas aparecem entre chavetas, são definidas como um script Frontier que gera HTML. Isto é, no caso do código acima, a macro chamada imageRef vai buscar a “figura1”, que é um parâmetro, e constrói uma etiqueta <img src=...>. Além disso, guarda a imagem na estrutura de directórios do Website, calcula a largura e altura da imagem automaticamente, e a localização gerada na etiqueta é relativa e não absoluta, o que traz vantagens em termos de portabilidade do site. Estas abordagens podem ser vistas quando se vê o código HTML gerado da página dois. Para melhorar a apresentação da imagem pode-se incluir mais parâmetros tais como: {imageRef (“figura1”,”Exemplo de Imagens”)}

– esta linha acrescenta o atributo alt à etiqueta img src, o que permite adicionar uma descrição à imagem. {imageRef (“figura1”, hspace:3, border:3, width:100)}

– esta linha define que a imagem tem de espaço horizontal 3, borda também 3 e largura 100.

Pode-se ainda, acrescentar uma hiperligação à macro, por exemplo:

<a href=http://www.userland.com>{imageRef (“figura1”)}</a>

E ao clicar sobre a imagem no browser irá directamente para o endereço introduzido.


Página 25

Caso se trate de imagens de fundo, procede-se à introdução da imagem na tabela de #images, da mesma maneira que já foi explicado. A única diferença é que deve-se introduzir na tabela #prefs, uma entrada chamada background, em que no nome deve ser colocado o nome da imagem de fundo sem extensão, no caso que se pretender ver todo o site com a mesma imagem de fundo. Quando se pretende que só uma página deve ter determinada imagem de fundo, então deve-se adicionar uma directiva no topo da própria página, que é a #background “nome da imagem”. Por exemplo: #background “figura2”

Se essa imagem não está na tabela de imagens do Frontier então deve-se indicar o caminho completo para chegar à imagem, como por exemplo, se essa imagem está num servidor: #background http://frontier.userland.com/images/bg1.gif


Página 26

Modelos Este é um dos grandes benefícios do Frontier, pois modelos ou templates, são formas de apresentação da página, independentes do conteúdo. O que permite que se altere a aparência, sem mexer no conteúdo, o que na prática, se faz através da edição do modelo e publicação do site. O Frontier tem um item específico para esta característica, que é o item #template. Mas ao olhar com atenção verifica-se que este é do tipo outline. Este é um tipo de estrutura similar a um objecto da base de dados: expandem-se, retraem-se, podem ser movidos, alternados entre modo de edição e selecção, mas mais adiante ver-se-á este tipo de estrutura em detalhes. Voltando ao modelo e supondo que no item está o seguinte código: {pageheader(title)}<blockquote>{bodytext}</blockquote>{pagefooter()}

Verifica-se que um modelo nada mais é do que HTML e macros do Frontier. Em pormenor, na primeira linha há uso de uma macro, que constrói a estrutura principal de uma página HTML, ou seja, gera as etiquetas “<html>”, “<head>”, “<title>” e “<body>”. Coloca o título(title) da página definido nas directivas #title da página, entre as etiquetas “<title>” e “</title>”. A parte do corpo, constrói de acordo com as directivas bgcolor, background, text e as de hiperligação(alink,etc.). A segunda linha contém código HTML, para dar um espaço entre linhas que é terminado na quarta linha, e na terceira linha há uma segunda macro, permite colocar na página o conteúdo da mesma. Por fim, a macro final inclui as etiquetas “</body>” e “</html>”.

Outlines Os modelos podem ser escritos como wp-text ou outlines. É uma questão depreferência de escrita, pois os outlines são indicadores de organização,através de indentação dos elementos. Portanto, é mais fácil olhar para umoutline, do que para um wp-text. Nota: Para indentar elementos num outline usa-se a tecla Tab. Para fazer oinverso, usa-se Shift-Tab.


Página 27

Depois deste código ser introduzido, publicam-se as páginas. Pode-se ver um código mais completo de um modelo como mais um exemplo. Neste caso, há mais código HTML e uma nova macro que fornece a hora actual do sistema no momento da publicação da página( {clock.now()} ).

Figura 11 – Item #template com exemplo de um modelo

Macros – sintaxe Para todas as macros não importa se está escrita em letras maiúsculas,minúsculas ou mistas, pois o resultado é sempre o mesmo. Nota: Excepto no caso da macro bodytext, que é obrigatoriamente escritaem letras minúsculas.


Página 28

Múltiplos modelos Há casos em que interessa ter modelos diferentes, para serem usados em páginas diferentes. Existem dois métodos para fazê-lo:

1. Por herança 2. Por nomes de modelos

O primeiro método, é vantajoso, quando há uma tabela inteira que requer

um modelo específico, e neste caso, vai-se introduzir um novo #template dentro dessa tabela, o que permite sobrepor a #template da raiz do tutorial, no exemplo que se tem seguido. Veja-se o caso da Figura 12.

Figura 12 – Website com mais do que um modelo através da sobreposição

Nessa tabela exemplo, que contém a página “tres.html” já criada

anteriormente, coloca-se o #template e dentro dele o que se pretende fazer, por exemplo, o segundo modelo definido anteriormente. Este irá prevalecer na página “tres”, sobre o modelo geral que está na raiz de “tutorial”. No segundo método, é necessário criar uma nova tabela na raiz chamada #templates, e que deve conter os modelos que se pretende criar e atribuir-lhes nomes diferentes. E através da chamadas destes modelos nas próprias páginas, pode-se usá-los em conformidade com as páginas. Através de um exemplo mais completo, do Website “tutorial”, em que é criada uma nova tabela chamada “modelos”, e dentro desta última, duas páginas “um” e “dois”, e na raiz do “tutorial”, cria-se uma tabela #templates


Página 29

com dois modelos, chamados “modelo1” e “modelo2” do tipo “outline”, em que é adicionado código aos modelos, de modo a ficar como a Figura 13, e ao supor que o “modelo1”, por exemplo será usado para a página “um”, e o “modelo2” será usado para a página “dois”, pode-se então ver o uso deste segundo método.

Figura 13 – Website com vários modelos independentes

Mas, para o exemplo ficar completo é necessário no código da página “um”, adicionar uma directiva #template que refere o “modelo1”, e na página “dois” fazer o mesmo para o “modelo2”. Veja-se o código da página um na Figura 14.

Figura 14 – Página Frontier com uso de modelo


Página 30

Portanto, pode-se ter também os dois métodos em simultâneo, de acordo com aquilo que se necessita, no mesmo Website. Se o que se pretende é afectar uma tabela ou secção do Website, o melhor método é o da herança. Se apenas pretende-se usar para páginas métodos diferentes, localizadas na mesma tabela ou secção, então o melhor é o método da chamada por nome.


Página 31

Ligações entre páginas: Glossário O Frontier permite a ligação entre páginas através de referências ou ligações relativas entre estas. Ou seja, esta característica do Frontier que faz a gestão das ligações, funciona da seguinte forma: Guarda o título e a localização de cada página numa tabela chamada #glossary, por isso esta característica do Frontier chama-se glossário. Esta tabela é actualizada cada vez que se publica uma página.

Figura 15 – Tabela glossário

Por exemplo, na página “dois” do “tutorial”, quando se acrescenta a seguinte linha no fim da página: <p>Volte à “Tutorial Home”</p>

e depois de publicar a página, surgirá uma hiperligação à pagina principal do Website. Convém que se faça não só uma publicação do site, mas uma publicação completa para que não haja erros de correspondência na tabela. Para isso bastou apenas indicar o título da página entre aspas.


Página 32

Figura 16 – Visão da página com uso do glossário

Ao olhar para o código HTML, verifica-se que foi criada uma ligação relativa, pois permite portabilidade, ou seja, aparecerá o código: ...<a href=”index.html”>Tutorial Home</a>...

Isto está definido da tabela #glossary(Figura 15), com uma entrada de nome “Tutorial Home” que indica qual é a página. Pode-se assim referenciar qualquer página do Website independentemente do local onde esteja(Figura 17).

Figura 17 – Entrada do glossário

Outra forma de referenciar uma hiperligação é através da macro glossSub. Esta, permite que a página seja chamada no browser na hiperligação, não pelo título mas por um nome alternativo. Por exemplo, se no código da página "dois" for substituído a linha que indica a ligação à página "index" por: Volte à {glossSub ("Tutorial Home", "Página Principal")}

então, no browser apareceria "Volte à Página Principal".


Página 33

Há situações em que o site inteiro é movido de local, ou a organização das páginas está em constante alteração, ou não se quer publicar o site todo, o que implica que a tabela #glossary não fica sincronizada em condições. Mas existe uma forma de obrigar a manter esta tabela actualizada, que é através do comando Build Glossary... do menu Web, que exige confirmação, e depois de ter seleccionado previamente a tabela #glossary. Também se pode adicionar entradas a essa tabela, por exemplo, para sites que estejam fora do Website. Para colocar uma entrada externa para o site do Frontier no Website, é necessário:

1. Expandir a tabela #glossary; 2. Criar uma nova entrada com o nome “Frontier”; 3. Definir o tipo como outline; 4. No outline colocar: <a href=http://frontier.userland.com/>Frontier</a>

Para chamar esta entrada, numa página qualquer do “tutorial”, coloca-se o código, e Frontier entre aspas para invocar a hiperligação.

As entradas externas são representadas de maneira diferente dasinternas(do próprio Website). Entradas externas não são afectadas pelo Build Glossary... do menuWeb.


Página 34

Includes São objectos que podem ser incluídos em algumas páginas, reaproveitando

informação já guardada. É do tipo wp-text ou outline, e é colocado como um novo item da tabela #tools.

Por exemplo, se for criado um novo item na tabela #tools chamado contacto, e for incluída informação em HTML sobre a pessoa a contactar, pode-se reutilizar esta informação em diversas páginas, da seguinte forma:

1. Abrir a página a editar 2. Adicionar {contacto}

Quando a página for publicada, {contacto} será substituído pelo conteúdo

do objecto contacto. Se esse objecto possuir macros incluídas, estas não serão processadas. Para

que estas sejam processadas, é necessário invocar uma macro do Frontier da seguinte maneira:

{html.processMacros (string (contacto)) }


Página 35

Hiperligações do tipo anterior e próximo O Frontier permite gerar ligações para a página anterior e próxima, como

é usual em algumas páginas. Para criar hiperligações destes tipos deve-se:

1. Seleccionar um item qualquer da base de dados 2. Escolher Build NextPrev List... do menu Web 3. Na caixa de diálogo acerca do nome do site preenche-se com

“tutorial” Nesse momento, o Frontier terá construído uma nova tabela chamada

#nextPrevs na raiz do “tutorial”. Ao ver esta tabela, verifica-se que o Frontier adiciona o endereço completo das páginas, e deve-se verificar também se há entradas a mais, pois o Frontier adiciona algumas entradas por defeito, de uma subtabela mesmo que não tenha nada. Neste caso, deve-se apagar as entradas a mais. Além disso, a ordem pode não estar correcta, pois a ordem a criar deve ser da principal para a final. Ou seja, primeiro a página “index”, depois a “dois” e assim sucessivamente, pois o Frontier não adivinha qual a ordem correcta.

Figura 18 – Tabela #nextPrevs

Para usar estas hiperligações nas páginas, é necessário usar as macros

linkPrev e linkNext, que possuem apenas um parâmetro que é o texto a apresentar na página do browser. Mas antes, é melhor actualizar o glossário, ou publicar todo o site.

Se for pretendido usar hiperligações em imagem ao contrário das anteriores em modo texto, e assumindo que existe um “anterior.gif” e um “proximo.gif” na tabela de #images, a sintaxe na página deverá ser: {linkPrev (imageRef(“anterior”)) } | {linkNext (imageRef(“proximo”)) }


Página 36

Outlines Embora já tenha sido usado ao longo do tutorial, foi só muito superficialmente. E por ser uma característica omnipresente no Frontier, e de grande utilidade será descrita em maior pormenor. Um outline significa um esboço de uma página, contém uma hierarquia, são fáceis de organizar, e são uma forma fácil de separar o conteúdo da aparência. Quando se escreve um outline, pode-se usar um outline renderer para gerar o código HTML que quiser, sem mexer no conteúdo. Também pode ser apresentado como um conjunto ordenado de listas, texto simples ou tabela HTML. Um exemplo é o da Figura 19.

Figura 19 – Exemplo de um outline

Para criar um outline como este acima, primeiro deve-se criar um novo item, atribuir-lhe o nome “meuoutline” e depois introduzir o texto.


Página 37

Comandos básicos úteis nos outlines: Criar uma nova linha – tecla Enter principal Comutar entre modo selecção e edição – tecla Enter numérico ou F2 Expandir linhas na hierarquia – tecla + ou duplo clique no triânguloem linhas que contenham sublinhas, ou menu Outliner opção Expand,para uma linha, Expand All Subheads para as sublinhas da linha actuale Expand Everything para todas as linhas. Encolher linhas na hierarquia - tecla - ou duplo clique no triângulo emlinhas que contenham sublinhas, ou menu Outliner opção Collapse,para uma linha, Expand to Parent para as sublinhas da linha actual eCollapse Everything para todas as linhas. Comentário - menu Outliner opção Toggle Comment, ou CTRL+\. Mover linha para cima– CTRL+U, ou arrastar com o rato o triângulo,ou , ou menu Outliner opção Move Up. Mover linha para baixo– CTRL+D, ou arrastar com o rato o triângulo ,ou menu Outliner opção Move Down. Mover linha para a direita – tecla Tab, ou CTRL+R, ou arrastar com orato o triângulo, ou menu Outliner opção Move Right. Mover linha para a esquerda – tecla Shift+Tab, ou CTRL+L, ouarrastar com o rato o triângulo, ou menu Outliner opção Move Left. Ordenar alfabeticamente - menu Outliner opção Sort. Apagar linha – Selecciona-se a linha e usa-se a tecla delete ou a opçãoClear do menu Edit. Apagar todas as sublinhas da linha actual - menu Outliner opçãoDelete All Subheads. Não permite voltar à trás.


Página 38

Outline Renderers Geradores de código HTML a partir de um outline, permitem modificar a apresentação da página conforme o renderer, que vai criar as páginas sem modificar o conteúdo(outline). Para que o Frontier use um renderer num outline, é preciso adicionar uma directiva #renderOutlineWith, e tal como qualquer directiva pode ser colocada na tabela #prefs, na página ou em ambas. Para exemplificar, após criação de um outline como o da Figura 19 com o código adicional que se segue a ser colocado no topo do outline: #title “Meu Outline”#renderoutlinewith “fatHeadlines”...

pode-se experimentar publicá-lo ou pedir uma previsão(Preview Page do menu Web).

Figura 20 – Visão de uma página com renderer fatHeadlines


Página 39

Ao observar a página verifica-se que o renderer fatHeadlines, converte as linhas da raiz da hierarquia para negrito, insere parágrafos entre linhas principais, e indenta linhas que tem mais do que dois níveis de profundidade.

O melhor a fazer no caso dos renderers de outlines é experimentar e ver se corresponde ao esperado. Para se ter uma ideia de alguns dos diversos renderers proceder-se-á a uma breve descrição dos mais importantes:

• prettyoutline – este converte cada caracter da linha principal para

maiúsculas; • twoleveloutline – é parecido com o fatHeadlines, mas as linhas

principais são do tipo “<h4>” e não há indentação entre linhas principais em qualquer nível;

• cadillac – fica muito semelhante ao próprio outline;

• justText – gera somente o texto do outline, sem qualquer rendering em

especial;

• default renderer – parece também o próprio outline, mas a página fica formatada como um conjunto de listas não ordenadas.


Página 40

Javascript Há duas formas de incorporar Javascript no Frontier: na secção “<head>” ou no corpo da página. Da primeira forma, pode-se usar a directiva ou o include #javaScript. Se é pretendido que qualquer página tenha o mesmo Javascript, cria-se então essa directiva como wp-text ou outline no topo do Website. Dentro deste item coloca-se o código em Javascript.

Se o modelo usar a macro pageHeader, então o Javascript é adicionado automaticamente na construção da página. Se pelo contrário for definido pelo utilizador uma directiva #pageHeader, então é necessário adicionar uma linha com: {javascript}

à directiva #pageHeader. Outra hipótese, também com uso da directiva #pageHeader, é colocar o código Javascript directamente no objecto #pageHeader, conforme a figura abaixo.

Figura 21 – Javascript no objecto #pageHeader


Página 41

Se este método for usado, é necessário colocar backslashes antes da chaveta de abrir e dos comentários em Javascript para prevenir que o Frontier interprete-os como macros. Pela segunda forma, através do corpo da página, é semelhante ao que já foi dito. Pode-se criar um objecto include na raiz do Website, chamado por exemplo, #bodyscript(não é obrigatório este nome, mas é obrigatório o #), e então adiciona-se ao objecto o código Javascript, que pode ser chamado em qualquer página da seguinte forma : {bodyscript}

Por exemplo, nesse objecto pode-se incluir então um código semelhante a este: <script lang="JavaScript">document.write ("<font color=maroon>");document.write ("Este JavaScript vem do objecto #bodyScript!");document.write ("</font>");</script>

E no caso, de chamar este objecto na página dois, aparecerá:

Figura 22 – Visão da página com uso de Javascript


Página 42

Cascading Style Sheets

Cascading style sheets permitem especificar o estilo de apresentação das páginas Web. Tem como grande vantagem a separação entre o conteúdo e a apresentação, ou seja, se for modificado um style sheet(estilo de apresentação) pode-se modificar todo o site sem ter que rescrevê-lo.

No Frontier para criar um novo estilo de apresentação, primeiro deve-se criar uma tabela #stylesheets no Website, depois cria-se uma entrada chamada default do tipo outline, embora o Frontier suporte múltiplos estilos. Para exemplificar será analisado para um caso, pois o resto é idêntico.

Quando se definiu o item como outline, indirectamente foi especificado

que irá usar um cascading style sheet, porque o outliner do Frontier nada mais é do que um editor de style sheet. Um style sheet é então como um outline. E esta característica pode ser vista na figura seguinte:

Figura 23 – Exemplo de um Cascading Style Sheet

E neste caso, definiu-se um estilo que é modificado o cabeçalho do tipo 2(h2), para tamanho 18 e o tipo de letra indicado. Para usar estes style sheets numa página há duas formas de o fazer:

• A primeira é ligar a um ficheiro de cascading style sheets externo(mesmo que exista no Website), que tem como vantagem modificar somente o ficheiro externo para modificar a apresentação do site. Para isso é necessário usar a macro {linkstylesheet()} na directiva #pageheader. Se nenhum parâmetro for passado, irá usar o default, caso contrário é passado o nome do style sheet criado entre aspas. Por exemplo:

Style sheets no Frontier podem ser criados através de outlines, wp-text ouscripts. Embora preferencialmente devam ser do tipo outline por facilidadena organização e semelhança.


Página 43

Figura 24 –Cascading Style Sheet no pageHeader

Esta macro faz três coisas: Gera o style sheet, adiciona-o ao Website publicado(ficheiro “default.css” na estrutura do Website) e cria uma ligação na página Web que fica deste modo se for visualizado o código fonte da página:

<link rel=stylesheet href="default.css" type="text/css">

Como no Website só há um style sheet, é criada essa ligação, embora o ficheiro “.css” possa ser modificado fora do Frontier com um simples editor de texto, o que justifica a vantagem referida. Se houvesse outro style sheet criado, para invocá-lo usar-se-ia:

{linkstylesheet(“smallfonts”)}

• A segunda forma é embutir o style sheet na secção “<head>” de

cada página HTML. Ou seja, o código do style sheet fica na própria página Web. Funciona de maneira semelhante ao método anterior, mas usa-se a macro {embedstylesheet()} na directiva #pageheader. Por isso, a macro faz o mesmo que a {linkstylesheet()} com a diferença que não cria um ficheiro a parte, nem cria nenhuma ligação, apenas gera o style sheet.

Se houvesse outro style sheet criado, para invocá-lo usar-se-ia:

{embedstylesheet(“smallfonts”)}


Página 44

4.3. Scripting

O Frontier tem também um sistema de scripts, ou seja, tem uma

linguagem própria chamada UserTalk. Esta linguagem é semelhante ao Javascript, Java e C, e um pouco parecida com Applescript e Visual Basic. Um script é um conjunto de instruções, que quando executado devolve resultados, que podem ser números, strings, listas, ou outro tipo de dados. Embora não seja obrigatório aprender a programar para construir sites com o Frontier, é bastante útil para sites com maior complexidade. Este capítulo tem intenção de explicar como programar com o UserTalk, para que no final a ideia de programar no Frontier seja algo que se faça com algum à vontade. Neste ponto, é suposto que se saiba trabalhar com o Frontier na construção de sites, e tenha alguns conhecimentos mínimos de programação. Portanto, haverá exemplos com escrita de macros, outline renderers, e outros scripts que são usados em Websites.


Página 45

Scripts Simples Um script muito elementar que não faz nada de útil, a não ser retornar uma string é o script seguinte: return (“Script muito simples”)

Portanto, há uso do comando return, que simplesmente retorna o valor

que está entre parêntesis. Para executar este script, pode-se usar a opção Quick Script do menu

Main ou através de “CTRL+,”. Quando a janela estiver aberta basta introduzir o código acima e pressionar o botão Run. O resultado aparece numa pequena barra abaixo da caixa de texto.

Mas há scripts mais úteis e que já vem com o Frontier, e que são usados na construção de outros mais complexos. Por exemplo, para saber o número de caracteres numa determinada string pode-se fazer isso com: String.length(“Quantos caracteres isto tem”)

Este último irá retornar 27, ou seja, foi chamado um script interno que conta o número de caracteres numa string. Outro exemplo para se ver mais parâmetros pode ser o que extrai uma secção de uma string, entre o primeiro caracter até o oitavo caracter: string.mid("Userland Frontier",1,8)

O que dará como resultado “Userland”. Para criar um script que fique armazenado como ficheiro pode-se criar através do menu File, submenu New e opção Script. Depois de introduzido o código deve-se gravá-lo com um nome, ao qual é adicionada a extensão “.ftsc”

O Frontier tem muitos scripts que já vem incluídos e que facilitam otrabalho. A estes scripts incorporados no Frontier dá-se o nome de Verbs. Os Verbs que existem estão no DocServer em http://docserver.userland.com


Página 46

Operadores Segue-se uma tabela que explica as funções dos operadores do UserTalk. Operador Função

= atribuição

+ Soma valores numéricos ou concatena strings e caracteres

- Subtrai valores numéricos ou remove a primeira ocorrência de uma string em outra string.

* Multiplicação

/ Divisão (inteira ou real, dependente dos tipos de dados)

% Resto da divisão inteira

== equals

Testa a igualdade

!= notEquals

Testa a desigualdade

< lessThan

Menor que ...

<= Menor ou igual que ...

> greaterThan

Maior que ...

>= Maior ou igual que ...

beginsWith Compara uma string com o início de outra

contains Verdade se uma string contém outra

endsWith Compara uma string com o fim de outra

|| or

OU lógico


Página 47

&& and

E lógico

! Não lógico

++ Incremento

-- Decremento

@ Endereço de

^ Conteúdo apontado por

Tabela 1 – Operadores UserTalk


Página 48

Tipos de dados A tabela que se segue mostra os diferentes tipos de dados existentes na linguagem UserTalk.

Tipo Âmbito

addressType Qualquer objecto da base de dados existente ou não de uma tabela

booleanType True ou False

charType Qualquer caracter, entre plicas.

dateType Qualquer valor tipo data do sistema

directionType up, down, left, right, flatup, flatdown, nodirection

intType -32768 até 32767

longType -2147483648 até 2147483647

menubarType Qualquer objecto Frontier da menubar

outlineType Qualquer objecto Frontier do tipo outline

scriptType Qualquer script Frontier

stringType Um ou mais caracteres, entre aspas

string4Type Exactamente quatro caracteres, entre aspas

tableType Qualquer objecto Frontier que seja tabela

wptextType Qualquer objecto Frontier que seja word processing text

Tabela 2 – Tipo de dados Frontier


Página 49

Variáveis

Uma variável pode conter qualquer tipo de dados que o Frontier comporta, entre elas, strings, caracteres, listas, números, etc.

Um exemplo de um script que usa variáveis é o seguinte: local (s=”Isto e conteudo da variavel”)dialog.notify(s)s=”Este e o segundo conteudo”dialog.notify(s)return(s)

Neste script verifica-se o uso da variável s que inicialmente contém ”Isto e conteudo da variavel” e depois passa a ter ”Este e o segundo conteudo”, o qual é retornado como resultado final. Entretanto, surge o Verb, dialog.notify que é utilizado para mostrar caixas de diálogo, que neste caso leva um parâmetro, que é a variável s.

As variáveis também podem mudar de tipos, embora não seja boa prática de programação. Por exemplo: local(s)s=”string”s=7s=s+10return(s)

O UserTalk não é uma linguagem fortemente tipada como C++ e Java, por exemplo. Por isso, deve-se manter uma variável com o mesmo tipo até terminar o seu uso, embora o UserTalk permita essa mudança.

Local define uma variável local, que só pode ser reconhecida por essescript. Pode ser declarado como: local(s) ou local(s=”string”) s=”string” E local(s=”um”,i,h= ”<html>”), por exemplo para declarar várias variáveis,que neste caso são s, i e h. As variáveis globais são guardadas como objectos da base de dados. As variáveis não são case-sensitive. Uma variável cujo nome éindexCounter é o mesmo que por exemplo, indexcounter.


Página 50

Há no Frontier uma convenção básica de nomes de variáveis, que é: podem ter números e caracteres, mas sem espaços. Além disso, há boas práticas de atribuições de nomes às variáveis que normalmente aparecem em documentações do Frontier que são apresentadas em seguida: Nome da variável Função adrPageTable, adrParamTable, pta Contém o endereço da página actual.

Actualmente aparece mais como pta: é mais curto, mais fácil.

adrXxx Endereços normalmente começam com um prefixo "adr", com em adrPageTable, adrItem, adrPage, ou adrObject.

f Normalmente é associado ao caminho para um ficheiro.

flXxx Os boleanos usualmente começam um prefixo "fl", que representa uma flag. Um exemplo pode ser flSupportsIndexing ou flFound.

htmlText htmlText é o nome de uma string que uma macro do Website, um outline renderer, ou CGI script devem retornar. Esta string contém texto HTML.

i, j, k Para contadores de ciclos, usa-se muito o i. Para ciclos encadeados, o j é usual. Num nível mais interno do ciclo, usa-se k, e assim por diante.

objType Tipo de um objecto, é representado como objType = typeOf (adrObject^).

s Variáveis do tipo string. Tabela 3 – Variáveis comuns no Frontier


Página 51

Criar macros: 1º Caso - Apontadores Anteriormente já foi visto como se usavam macros, através dos {}. Agora e para se conhecer a potencialidade o UserTalk, será visto por exemplos como criar macros com vários objectivos, ou seja, uma outra definição de macro, que é um script chamado por uma macro embutida no código fonte de uma página Web. Para começar, deve-se ir à tabela #tools, expandi-la e dentro dela criar um novo script chamado “meunome”, através do New Script do menu Table.

Quando isto é feito, surge logo na primeira linha, um código que é: on meunome()

Isto significa que o script não tem parâmetros, e que a palavra “on” inicia um handler. Um handler inicia comandos que são executados quando é chamado o script cujo nome está declarado na linha “on”. Se houvesse parâmetros, assemelhariam-se a:

on meunome(s), ou on meunome(s,n), etc.

Visto isto, pode-se criar então código, e como exemplo, será adicionada uma linha que devolve o nome da pessoa que está registado na base de dados: return(user.prefs.name)

Tabela #tools É a tabela que contém macros, texto e outline renderers que são usados naconstrução de Websites. Nota: Caso não se saiba ainda com certeza se o script é para ficar guardado numdeterminado Website, pode-se usar outra forma de criar scripts, que éatravés do Workspace do menu Main, e depois no menu Table seleccionarNew Script. Isto significa que fica em área de trabalho partilhada. Sepretender guardá-lo de forma definitiva num determinado Website deve-sefazer uma cópia (CTRL+C) do script e colagem na tabela #tools(CTRL+V). A grande vantagem do Workspace é realmente a partilha deobjectos entre Websites.


Página 52

Figura 25 – Script que retorna um nome

Depois, para experimentar deve-se compilar através do botão Compile, e se algum erro aparecer, então surge uma janela de Error Info, deve-se então, pressionar o botão Go To e o cursor será posicionado na ponto em que o erro ocorreu. Agora basta editar uma página qualquer do Website e adicionar uma linha como esta: Esta página foi elaborada por {meunome ()}

E depois é só publicar. O resultado será o seguinte:

Figura 26 – Visão da página com uso de macro


Página 53

Ao analisar o novo código “return(user.prefs.name)” verifica-se então

que vai ser visto qual o valor de “name” na tabela “user.prefs”. Para tornar as macros mais complexas podem ser usados endereços. Endereços ou addresses são caminhos do Frontier, e um tipo particular de dados. Endereços são como na vida real, um endereço pode ser “rua livre 100” que aponta para uma casa. O endereço não é a casa, simplesmente ele aponta para ela. Este conceito de apontador também é utilizado em outras linguagens de programação. No Frontier, user.prefs.name é o valor dessa tabela. Mas, endereços começam pelo símbolo @, como foi visto na tabela de operadores. Ou seja, @user.prefs.name não é o conteúdo da tabela, mas aponta para user.prefs.name, isto é, um endereço. Se for reformulada a macro anterior ter-se-ía: on meunome()local([email protected])return (adr^)

A variável adr guarda o endereço que aponta para user.prefs.name. O adr^ retorna o conteúdo do endereço apontado por adr, pois o símbolo ^ retorna “o contéudo de”. O script também poderia ter sido escrito como: on meunome()local((@user.prefs.name)^)

É evidente nesta fase, que a melhor maneira de escrever ainda seria:

“return(user.prefs.name)”, mas foi útil para demonstrar o uso de apontadores. E ainda era possível realizar o mesmo objectivo somente com uso da macro: “{user.prefs.nome}” directamente na página.

Objectos da Base de Dados Para referenciar um objecto de uma base de dados, indica-se como umcaminho, separado por pontos. Por exemplo: user.prefs.name, que é ovalor do item name que está dentro da tabela prefs, e que por sua vez estádentro da tabela user. Para ver o valor de um objecto da base de dados – CTRL+duplo clique ouCTRL+J ou Jump do menu Main, e depois deve-se introduzir a referênciaao objecto. Por exemplo para saber os Verbs que existem basta fazerreferência à “system.verbs.builtins”.


Página 54

Criar macros: 2º Caso – Ciclos, âmbito e strings Agora a macro que será criada tem por objectivo ir buscar somente o primeiro nome que está em user.prefs.name. on meuprimnome ()local (s, i) //declara duas variáveis locais s e ilocal (adr = @user.prefs.name) //o endereçofor i = 1 to sizeOf (adr^) //ciclo até acabar os caracteres do nomelocal (ch = adr^ [i]) //vai buscar o i ésimo caracter do nomeif ch == ' ' //se é um espaçobreak //sai for a deste ciclo

s = s + ch //concatena o caracter a sreturn (s) //devolve o primeiro nome a quem chamou

O uso de “//” significa comentários, que nada mais é do que texto que não é utilizado para compilação. Em termos de novidades neste código, além do que já foi referido, há o uso dos ciclos for e if. O ciclo for indica que tudo o que está dentro do ciclo(indentado à direita), é repetido até chegar ao valor de fim de ciclo que neste exemplo é indicado pelo sizeof(adr^), que fornece o tamanho da string adr. Ou seja, na primeira vez “i” é igual a 1 e executa a linha “local...” , “if...” e “s=...”, e depois “i” passa a 2 e executa outra vez, e assim por diante. Quando é encontrado um espaço (ciclo if), então sai do ciclo for e devolve o conteúdo de “s”, ou seja, até encontrar o primeiro espaço. No if é feita uma comparação através de “==” com espaço e se for verdadeiro, então entra na indentação a direita, que executa o break e depois return(s). Este exemplo serve de demonstração do processamento de strings, embora também poderia ter sido resolvido através de uma maneira mais fácil:

Muito Importante: O âmbito ou scope de um ciclo é definido pela indentação do mesmo. Ouseja, a seguir a um ciclo if, deve-se indentar à direita para que o bloco decódigo que se segue esteja dentro do if. Quando se quer sair volta-se aonível do ciclo if ou mais acima. As indentações definem assim o ciclo de “vida” de uma variável ou código. Exemplos baseados no código acima: A variável ch é local, mas só é reconhecida no ciclo for. A variável s é local, e é reconhecida em todo o script, pois está no topo dahierarquia. User.prefs.name é global, pois está na base de dados


Página 55

on meuprimnome()return(string.nthfield(user.prefs.name,' ',1))

Ou seja, mais uma vez através de um Verb, que retorna o campo pretendido de uma string, através de três parâmetros: a string a processar, o delimitador de campo, e o número de campos a obter. Outro exemplo de ciclo for seria, o script que se segue que mostra os números de 10 a 1 por ordem decrescente: on conta(limiteinf=1, limitesup=10)

if limiteinf > limitesupfor n=limiteinf downto limitesup

msg(n)clock.waitseconds(1)

elsefor n=limiteinf to limitesup

msg(n)clock.waitseconds(1)

conta()

O ciclo for anda ao contrário devido ao downto, pois vai do maior para o menor valor. Neste exemplo, são verificados os limites e conforme a situação varia o ciclo for. É introduzido aqui a msg(n), que apresenta o resultado na janela About do Frontier. Além disso, há o Verb, clock.waitseconds, que espera um segundo. Foi colocado um else que é opcional, visto que, se o segundo código for ficar no mesmo nível do if, é como se lá estivesse o else. Note-se também a última linha é como um return, pois tem o nome do próprio handler, e nada é devolvido como resultado final. Seguem-se pequenos pedaços de código com outros ciclos existentes nesta linguagem: Estrutura case: executa o bloco de código que corresponde ao valor da expressão. O else é opcional. case true //de acordo com a temperatura diz se está frio, quente ou não.

temperature < minimodialog.alert ("Muito frio.")

temperature > maximumdialog.alert ("Muito quente.")

elsedialog.notify ("óptima.")

case letra"a""e"

msg ("Vogal")"b"

msg ("Consoante")else


Página 56

msg ("Não se enquadra no exemplo.")

Estrutura while: repete enquanto uma condição for verdadeira. // enquanto não for fim de ficheiro, lê linha a linha e mostra no ecrã.while not file.endOfFile (f)

msg (file.readLine (f))

Estrutura fileloop: repete para cada ficheiro e atribui a uma variável.

fileloop (f in path)// vai ver todos os ficheiros de um caminho eapresenta-os no ecrã.

msg (file.fileFromPath (f))

Estrutura loop: repete para sempre até encontrar um break.

loop //vai incrementar “i” até chegar a 5.msg (i)i = i + 1if i > 5

break

Estrutura try: para diagnóstico de erros, ou seja, se encontrar um erro salta essa instrução e através de tryError notifica o erro ocorrido. try // se não existir ficheiro para apagar, mostra o erro.

file.delete (f)else

dialog.alert (tryError)

Estrutura bundle: para criar um agrupamento de linhas num bloco simples. As opções Bundle-ize ou De-Bundle do menu Script, permitem respectivamente criar ou retirar esse agrupamento. bundle //cria um ficheiro de texto simples

file.new (path)file.setType (path, "TEXT")file.setCreator (path, "ttxt")


Página 57

Criar macros: 3º Caso – Ficheiros Esta macro irá incluir o conteúdo de um ficheiro de texto numa página Web. Para isso, deve-se criar primeiro um ficheiro de texto, com um editor de texto como Notepad, ou outro, e o ideal para experimentar este caso, é incluir também código HTML. O código que se segue deve ser inserido como um novo script, na tabela #tools chamado “inserefich”, que terá o seguinte código: on inserefich (f, flProcessMacros)local (s) // define a variável local ss = string (file.readWholeFile (f)) //lê o ficheiro como stringif flProcessMacros //devem as macros ser processadas?s = html.processMacros (s) //se true, processa macros

return (s) //retorna a string

Depois, deve-se inserir uma nova linha numa página do Website, que invoque este script, por exemplo, e partindo do princípio que está na localização indicada: {inserefich(“C:\\Documentos\\Texto.txt”,false)}

E finalmente basta publicar para ver o conteúdo do “Texto.txt” aparecer no browser. Este handler, espera dois parâmetros: f que é o caminho para o ficheiro, e flProcessMacros que é true ou false(boleano). Depois cria uma variável local s, que vai guardar todo o conteúdo do ficheiro, que é fornecido por um Verb, readwholefile(f), que necessita de um parâmetro que é o caminho para o ficheiro. Este Verb, não retorna nenhum tipo em particular, por isso obrigou-se a que fosse string, através da conversão string (file.readWholeFile (f)). Posteriormente, no if, também poderia estar: if flProcessMacros==true

O significado seria o mesmo, pois se for verdadeiro, vai processar as macros que o ficheiro contenha, através do Verb html.processMacros(s). E por fim, retorna o conteúdo de “s”, que tem todo o ficheiro. Outro exemplo é o que se segue, no qual, é pedido ao utilizador um directório, para mostrar o caminho no disco para ele. O código é simples, define uma variável local “pasta”, depois utiliza o Verb, file.getfolderdialog, que pede ao utilizador que escolha um directório do disco, e se não escolher não mostra nada, e termina o script, caso contrário apresenta a pasta escolhida na janela About do Frontier.


Página 58

on listafich ()local (pasta)if not file.getfolderdialog("Escolha uma pasta para

mostrar",@pasta)return

msg(pasta)listafich()

O mesmo exemplo, mas agora modificado para listar os ficheiros que existem nessa pasta seleccionada seria: on listafich ()

local (pasta)if not file.getfolderdialog("Escolha uma pasta para

mostrar",@pasta)return

local(fich)fileloop(fich in pasta,1)

msg(fich)clock.waitseconds(1)

listafich()

A diferença reside na estrutura fileloop, que significa todos os ficheiros de um directório. Tem dois argumentos, o primeiro é o que indica o ficheiro de que pasta, e o segundo quantos de cada vez são mostrados. Por esse motivo, tem-se msg... e clock..... dentro desse ciclo, para que mostre na janela About um por cada segundo que passa.


Página 59

Criar macros: 4º Caso – Tabela da Página Quando uma página sofre o rendering, é colocada informação e directivas sobre a página, numa tabela, chamada tabela da página ou page table. As macros tem acesso à tabela da página, ou seja, quando é pedido o título da página já publicada, a macro vai buscar à essa tabela. Para ver isto na prática, basta expandir a tabela #data da tabela Websites, do “Frontier.root”, através da opção Websites do menu Main. Esta é a tabela da última página que foi publicada. Por esse motivo esta tabela nem sempre contém os mesmos elementos. A macro que será criada para exemplificar o uso da tabela da página, deve ser criada na tabela #tools, e com o nome “inserirpordirectiva”. Esta macro irá também inserir um ficheiro, como no 3º Caso, mas em vez de ter dois parâmetros, faz uso de directivas próprias previamente definidas que fornecem à macro que ficheiro ir buscar e quando deve ou não processar macros. Segue-se então o código: on inserirpordirectiva ()local (pta = html.getPageTableAddress ()) //vai buscar o endereço da

page tablelocal (f, s = "", flProcessMacros = false) //variáveis locaisif defined (pta^.fileToInsert) //existe a directiva #fileToInsert?f = pta^.fileToInsert //f fica com o caminho para o ficheiroif defined (pta^.processMacrosInInsertedFiles) // existe a directiva?flProcessMacros = pta^.processMacrosInInsertedFiles //atribuição de

flProcessMacross = string (file.readWholeFile (f)) //lê o ficheiro como stringif flProcesssMacros //processa macros?s = html.processMacros (s) //se true, processa macros

return (s) //devolve a string

Após a criação do script, torna-se necessário editar ou criar uma página Web, e adicionar as duas directivas para que a macro funcione, para além de invocá-la, por exemplo, pode ser semelhante a este: #title "Minha Página"#fileToInsert "C:\\Documentos\\Texto.txt"#processMacrosInInsertFiles trueEsta é a minha página. Aqui vai o conteúdo do ficheiro.{ inserirpordirectiva ()}

Em termos de novidades nesta macro, é que não há parâmetros, pois usa as directivas definidas pelo utilizador na página Web. Além disso, usa um Verb, htlm.getpagetableaddress() que é a melhor maneira de ir buscar o endereço da página actual na tabela da página. Depois declara novamente variáveis locais, e no primeiro if, vai verificar se existe aquela directiva, se não existir vai executar o return(s), caso contrário entra no ciclo e guarda o


Página 60

caminho definido por essa directiva na variável f. Depois verifica da mesma forma se existe a segunda directiva, e o restante código é igual ao do caso anterior.


Página 61

Filtros São scripts que actuam uma ou mais vezes sobre as páginas durante o rendering. Podem ser usados para situações do tipo substituir diversas ocorrências de uma palavra por outra, ou enviar uma mensagem de correio electrónico cada vez que a página é publicada, etc. Existe então uma tabela específica para isso que é a tabela #filters, no topo do Website. E ao expandir essa tabela podem ser vistos três scripts, que tem um único parâmetro adrPageTable:

• firstFilter Este script é executado depois da tabela da página começar a ser construída, mas antes das directivas na página terem sido adicionadas à page table. A página ainda não foi rendered.

• pageFilter

Este script é executado depois das directivas serem recolhidas da página e adicionadas à tabela da página. Ainda não foi aplicado nenhum template à página, e nenhum processamento de macros aconteceu. Por defeito, este filtro chama html.addPageToGlossary para adicionar a página actual ao glossário para este site. Para aceder ao texto da página antes de sofrer rendering, acede-se através de adrPageTable^.bodyText.

• finalFilter Este Filtro é chamado ao fim, depois da página ter sido completamente rendered. O texto rendered está na tabela da página: acede-se através de: adrPageTable^.renderedText.

Para escrever um filtro deve-se tirar partido destes scripts, e como exemplo, o filtro que se segue substitui toda a ocorrência da palavra “Frontier” por “UserLand Frontier”. Para isso, deve-se editar o filtro finalfilter e colocar o código: on finalFilter (adrPageTable)local (s = adrPageTable^.renderedText) //busca o texto rendered e

guarda em ss = string.replaceAll (s, "Frontier", "UserLand Frontier") //substitui

todas as ocorrências de Frontier por UserLand FrontieradrPageTable^.renderedText = s //substitui o texto rendered por s


Página 62

return (true) //filtros retornam sempre true

O código em causa, é simples, visto que faz uso de uma variável local s que tem o texto rendered, mais uma vez faz uso de um Verb, string.replaceall, que substitui todas as ocorrências de uma palavra por outra. E depois coloca o novo texto já com substituições novamente na adrPageTable^.renderedText. Desta forma, sempre que for publicada uma página ou feita a sua previsão, será verificada se existe a palavra “Frontier” e será substituída por “UserLand Frontier”.

A primeira linha de um filtro não deve ser alterada, assim como a última,pois os filtros têm sempre o parâmetro adrPageTable e devolvem sempretrue.


Página 63

Outline Renderers Já foi visto o que são outline renderers, anteriormente, e agora é hora de ver como se faz um. Antes disso, para melhor compreensão pode-se visualizar os outline renderers do Frontier em user.html.renderers. Para criar um outline renderer próprio deve-se criá-lo na tabela #tools, como um script que neste caso terá o nome “meurenderer”. Depois é só introduzir o seguinte código: on meurenderer (adrOutline)local (level = 0) //o nível máximo é 0 - topolocal (htmlText) //este é a variável de texto que irá ser retornadaon add (s) //subrotina para colocar texto em htmlTexthtmlText = htmlText + s //add s to htmlText

op.firstSummit () //vai para o topo do outlineop.fullExpand () // expande completamente o outlineon visit ()looplocal (s = op.getLineText ()) //fica com a linha actual do textoif level == 0 //se este é um item de nível máximo?s = "<hr><h3>" + s + "</h3>" //adiciona as etiquetas hr e h3

elses = s + "<br>" //senão adiciona uma etiqueta br

add (s) //adiciona a linha do outline ao htmlTextif op.go (right, 1) //se há linhas indentadas abaixo destalevel++ //incremementa o nívelvisit () //ciclo para os outros itens deste nívellevel-- //decrementa o nívelop.go (left, 1) //volta para a linha antes do visit ter sido

chamadoif not op.go (down, 1) //se não é possível descer uma linha?break //então faz break

visit ()return (htmlText)

O objectivo deste renderer, é colocar um “<hr>” antes de cada nível máximo do outline, e envolve cada linha de nível máximo com “<h3>” e “</h3>”. Todos os outline renderers tem um parâmetro que é o endereço do outline para rendering. Este endereço não aponta para o outline original, mas para uma cópia que não possui directivas. Ao analisar o script acima, pode-se dizer que, é definida uma variável local level que indica o nível no outline, começando em zero e assim por diante. É definida também uma variável que irá conter o texto HTML, htmltext, e uma subrotina que permite acrescentar texto à variável anterior. Uma subrotina é um script dentro do script. Depois o cursor é posicionado no início do outline(op.firstSummit ()), e expandido(op.fullExpand()). Estes são Verbs, para operações com outline processor(op). E finalmente, entra na parte do trabalho propriamente dito, na visit(), que vai ler linha a linha, verificar o nível em que está, se é zero adiciona


Página 64

etiquetas “<hr>” e “<h3>” senão faz “<br>”. Posteriormente tenta descer na ramificação do outline, e caso tenha indentações incrementa o nível e volta a chamar visit(), ou seja, há recursividade. Quando terminar recursividade, e não houver mais linhas para processar para dentro, decrementa-se o nível, e verifica se não há mais linhas abaixo, o que faz terminar o programa, que devolve o novo texto, senão continua a processar até não haver mais linhas a processar. Para ver o que faz este renderer, pode-se editar a página “meuoutline” de modo a incluir uma linha com o código: #renderOutlineWith “meurenderer”

E depois é só publicar para ver o resultado conforme a Figura 27.

Figura 27 – Visão de uma página produzida por outline renderer definido pelo utilizador


Página 65

XML Neste tópico segue-se um exemplo de script que lê um ficheiro em XML(Extensible Markup Language), compila-o para um objecto da base de dados e abre-o numa nova janela: on xmlbd()local (f = "C:\\xml\\pc.xml")local (adrtable = @tutorial.pc)xml.compile (file.readWholeFile (f), adrtable)edit (adrtable)xmlbd()

O script, lê o ficheiro XML que está guardado no disco e que tem, por exemplo o seguinte conteúdo: <?XML VERSION="1.0"?><myComputer>

<brand>Dell</brand><model>Latitude CPi</model><ram>64MB</ram><os>Windows 2000</os></myComputer>

Depois, vai criar uma variável local que aponta para uma tabela “pc” que pertence ao Website tutorial. No terceiro passo, compila o ficheiro para a tabela e fica em modo edição nessa tabela. A tabela criada tem então o aspecto da Figura 28.

Figura 28 – Tabela criada pela importação de XML

Outro exemplo é o que se segue, no qual são lidos os valores da tabela criada pelo script anterior. local (adrtable = @tutorial.pc)local (adrcomputer = xml.getAddress (adrtable, "pc"))local (brand = xml.getValue (adrcomputer, "brand"))


Página 66

local (model = xml.getValue (adrcomputer, "model"))local (ram = xml.getValue (adrcomputer, "ram"))local (os = xml.getValue (adrcomputer, "os"))dialog.alert (“Tem um" + brand + " " + model + " com " + ram + " a correrem " + os + ".")

Utiliza basicamente dois Verbs: xml.getAddress que lê o endereço da tabela XML cujo nome é definido pelo segundo parâmetro e xml.getValue que permite ler um valor colocado através do XML em uma tabela.

O resultado deste script é a leitura de todos os campos da tabela e consequente amostragem numa caixa de diálogo, conforme a Figura 29 .

Figura 29 – Execução de leitura de XML colocado na base de dados


Página 67

Na versão 7 do Frontier para converter outlines para XML, ou vice-versausa-se os Verbs:

• op.outlineToXML(adrOutline, ownerName, ownerEmail) o adrOutline é o endereço do objecto outline o ownerName é opcional e contém o nome do escritor do

outline. Se nada for dito é usado o que está emuser.prefs.name;

o ownerEmail também é opcional e contém o endereço decorreio electrónico do escritor do outline. Se nada for dito éusado o que está em user.prefs.mailAddress.

• op.xmlToOutline(xmlText, adrOutline, flNewOutline)

o xmlText é o texto em formato XML; o adrOutline é o endereço do objecto outline; o flNewOutline é um boleano que se for true, significa que o

outline mesmo que não exista é criado, caso contrário, éadicionado a um existente.

Exemplo(leitura de um outline para XML e vice-versa): local (xmltext = op.outlineToXml (@tutorial.novooutline))wp.newtextobject (xmltext, @tutorial.novooutline)edit (@tutorial.novooutline)op.xmlToOutline (xmltext, @tutorial.pc)edit (@tutorial.pc)


Página 68

4.4. Construção de sites através da Web Esta segunda forma de construir um site é através de edição directamente na Internet, consequentemente acessível a partir de qualquer local. Este segundo modo, não é parte integrante directa do Frontier, mas é mais uma ferramenta da empresa Userland, que apoia o Frontier e nesse sentido será descrita de modo sucinto como criar e manter páginas através da ferramenta Manila. Esta ferramenta entra em acção em conjunto com o Frontier logo na altura de instalação do programa no qual permite definir a localização da página principal, a porta, o endereço de correio electrónico para comunicações, etc. Após o fim da instalação esta ferramenta fica automaticamente disponível na localização http://<dominio ou endereço IP>/controlpanel, ou seja, é neste ponto que se inicia o segundo modo de elaboração/edição de páginas, chamado de Painel de Controlo. Também pode ser acedido através do Frontier no menu Server, na opção Open Control Panel. Aqui é pedido a identificação da conta(a que foi criada na altura da instalação do Frontier, e está armazenada em user.prefs.mailAddress) e palavra passe para aceder ao site. Neste tutorial será considerado o uso da conta de administrador, que foi criada na instalação.

Figura 30 – Identificação do utilizador

Após o preenchimento da identificação válida apresentar-se-á, a página Web, conforme a Figura 31, que permite gerir então o site em causa. Este modo é muito simples e rápido no desenvolvimento de grandes sites.


Página 69

Figura 31 – Painel de Controlo

O Manila Possui as seguintes características: • Inclui editor WYSING para facilitar o trabalho de novos utilizadores

que pretendem construir páginas; • Acesso através de identificação; • Suporte de membros do site; • Suporta vários modelos pré-definidos de sites; • Criação rápida de grupos de discussão; • Publicação fácil de notícias; • Cópias de segurança do site automatizadas.


Página 70

Esta parte do tutorial que se segue explicará cada um dos tópicos do menu à esquerda existente no Painel de Controlo, antes de passar a uma nova fase na qual ver-se-á mais facilmente como produzir um site via Web, ou apagar, e alguns exemplos práticos desta ferramenta.


Página 71

Sites

A criação de sites e listagem pode ser obtida através do menu Sites, e opções New Site e List Sites, respectivamente.

Após pedido de criação de um novo site, será pedido algum tipo de informação conforme a Figura 32. Neste figura pode se observar que é pretendido criar um site “tutorial” a partir do domínio definido na altura da instalação. Devem-se introduzir os dados do editor do site, e respectiva palavra passe, assim como o modelo(Theme), que o Manila tem por defeito. Estes modelos é que permitem uma série de tipos de página, como páginas de notícias, de grupos de discussão, entre outros. Após escolha do modelo deve-se efectuar o pedido(submit) e confirmar o pedido para criar o novo site.

Como é muito simples o ideal é experimentar qual o que vem de encontro ao pretendido e editá-lo, ou consultar nas páginas dos modelos Manila(http://www.weblogger.com).

Figura 32 – Criação de um novo site

Caso seja necessário ver quais os sites existentes usa-se então a opção List Sites.


Página 72

Settings Este tópico define as preferências mais importantes do servidor, através de várias hiperligações. Seguem-se as opções de configurações possíveis:

- Hosting - Pode-se especificar quem pode criar sites, onde são criados e se o site é um site de raiz ou um sub-site.

- Mail - Esta parte é onde se define o endereço de correio electrónico, por defeito, do servidor. Aqui também se inclui a identificação do administrador correspondente ao correio electrónico e a Organização. Em Mail Host, preenche-se com o nome do servidor SMTP do domínio ou endereço IP que o Frontier usará quando envia correio electrónico.

- Backups – O Frontier define dois tipos de cópias de segurança: a das Guest Databases em que define-se a localização onde ficarão as cópias de segurança e a das mensagens dos grupos de discussão, que são armazenadas em formato XML.

- Logging – Nesta opção define-se o que se pretende manter registado em termos de acessos via HTTP, XML-RPC, actualizações de root, escalonamento ou memória disponível. Indica-se o directório onde ficam os registos, e para além disso, pode-se incluir estatísticas acumuladas de cada domínio que o Frontier suportar e para cada grupo de discussão, que podem ser geradas em XML.

- Security – Em termos de segurança, pode-se definir se tem ou não acessos aos directórios, aos scripts para leitura ou execução, pode-se bloquear o acesso HTTP ou XML-RPC só para um determinado conjunto de endereços IP. Esta segurança aplica-se a nível global do Website, caso se pretenda só para um site em particular, deve-se usar a administração do site em causa, que determina a nível mais restritivo as permissões válidas para o site. Além disso pode definir acesso encriptado com cookies, para criação de novos membros do site.

- Updates – O Frontier pode fazer actualizações automáticas do Frontier.root, mainResponder.root, manila.root, e prefs.root directamente à UserLand. Este processo não tem caixas de diálogo e é seguro.

- General – Aqui encontram-se algumas opções avançadas de configuração do Frontier tais como: gravação automática das bases de dados abertas a cada minuto, ao pedir visualização de páginas enviá-las para segundo plano, implementação de servidor de pesquisa de páginas, activação de depuração de erros e profiling, ou seja, o Frontier permite que se procure o script ou o Verb que foi executado e quanto tempo demorou a sua execução.

- Manila – Esta opção permite configurar tudo o que diz respeito à ferramenta Manila. Pode-se activar/desactivar os interfaces XML-RPC ou SOAP, o que permite que outras aplicações escrevam scripts


Página 73

remotamente no interface Manila. Pode-se também activar o envio de notícias acerca de actualizações do site para a UserLand, definir o caminho ou URL para rendering estático de imagens, de páginas ou de gems(característica que permite fazer uploads de ficheiros de qualquer tipo para Websites Manila, por defeito é de 1MB por site), definir o caminho pelo qual os editores das páginas fazem o download do site como base de dados para ser servida estaticamente, e pode-se definir também se os membros do Website pretendem receber as mensagens dos grupos de discussão via correio electrónico.

- WebEdit – É um cliente-servidor que permite um determinado grupo de utilizadores trabalhe “sobre” o Website ou scripts. Por defeito, não está activo. Este é o ponto onde também se faz a gestão de utilizadores para o Website, no qual pode-se adicionar novos membros, modificar os dados de um determinado membro, garantir acesso à funcionalidade de WebEdit a determinados utilizadores ou simplesmente a quem impedir o acesso.

Figura 33 – Definição de Hosting


Página 74

Readouts Este item mostra os vários relatórios ou acontecimentos no servidor, em termos de pedidos HTTP, XML-RPC, quais as bases de dados que estão em uso, entre outros. Seguem-se as opções de visualização possíveis:

- HTTP – Este item mostra os pedidos HTTP mais recentes, que inclui entre outras informações o nome da máquina, número de bytes e local acedido.

- XML-RPC – O mesmo que o anterior, mas para pedidos XML-RPC e

que inclui o nome do procedimento invocado. - Databases – Este item contém informação sobre as bases de dados

abertas, tamanho, a data da última modificação e o directório onde estão.

- Domains – Mostra informação sobre domínios servidos pelo Frontier,

número de acessos, bytes servidos e directório ou endereço onde estão situados.

- Updates – Apresenta informação sobre bases de dados actualizadas, e

somente para aquelas que foram seleccionadas na opção Updates dos Settings.

- Objects – Mostra os objectos que estão a ser utilizados via WebEdit. - Searchs – Caso seja um servidor de pesquisa, este item apresenta as

mais recentes pesquisas efectuadas e as páginas mais recentemente indexadas.


Página 75

Help

Ajuda o utilizador registado, via o site de suporte de problemas da UserLand (http://support.userland.com/). Neste endereço pode-se encontrar muitos recursos de ajuda que podem ser importantes para solucionar problemas.


Página 76

Criar vários sites e domínios a servir

Por defeito, conforme foi visto no início deste capítulo, para criar um site, basta ir ao Painel de Controlo e New Site. Sendo que, este novo site será criado a partir do domínio definido, e por qualquer pessoa o que nem sempre é o que se pretende. Temos então algumas hipóteses de acordo com o que se pretende, e explicadas do modo mais simples de chegar aos objectivos pretendidos:

- Se o que se pretende é construir diversos sub-sites agregados a um

único domínio, então o Frontier fá-lo-á por defeito. - Se é pretendido criar diferentes domínios então, deve-se ir a Hosting,

mudar o Base domain for new sites, e introduzir o novo domínio pretendido, e os sub-sites são criados neste novo domínio.

- Quando o objectivo é criar vários sites só de nível de domínio, então o

melhor é em Hosting, e em Create top-level sites or sub-sites? seleccionar Top-level sites.

- Para modificar quem cria os sites ou sub-sites, também em Hosting e

em Who can create sites pode-se modificar para editores(editors only).


Página 77

Grupos de trabalho em um Website Manila típico(definidos no própriosite no menu Prefs e depois no menu Editorial):

1. Managing Editor – é um Webmaster, Web designer ou editor epodem:

a. Mudar a página principal; b. Criar e editar histórias; c. Mudar preferências; d. Manter o site com as funcionalidades de administração; e. Enviar boletins(método simples de envio de email aos

membros via texto ou HTML); f. Editar imagens ou mensagens;

2. Contributing Editor – é um escritor ou um artista gráfico e podem: a. Editar histórias; b. Editar imagens ou mensagens de grupos de discussão;

3. Membros(Members) – visitantes de um Website identificados, oque permite mais algumas visualizações do que um normalvisitante e podem:

a. Participar das histórias e grupos de discussão; 4. Visitantes(Visitors) – visitantes não identificados.

a. Ler histórias.


Página 78

Apagar um site Para proceder à eliminação de um site, deve-se ir ao Frontier, abrir a base de dados pretendida(menu File opção Open), no caso de um site Manila esse ficheiro é o manilaWebsites.root, no qual ver-se-á diversas tabelas que correspondem aos sites definidos, selecciona-se o site a ser apagado e no menu Server, procede-se ao Uninstall Site.

Figura 34 – Tabela de Websites Manila

Embora não se veja a tabela desaparecer da base de dados, na realidade o site já não existe, pois o que este comando faz é retirar a informação referente ao site em termos de disponibilização via Web. Por esse motivo, deve-se apagar a tabela (tecla delete) para retirar completamente o site do disco.


Página 79

Mover um site

Para proceder à mudança de um site de uma localização para outra, deve-se ir ao Frontier, abrir a base de dados pretendida, no caso de um site Manila esse ficheiro é o manilaWebsites.root, no qual ver-se-á diversas tabelas que correspondem aos sites definidos, selecciona-se o site a ser movido e no menu Server, procede-se ao Uninstall Site. Até ao momento, só foi retirada a informação que diz respeito à disponibilização do site. Depois deve-se copiar o site que será movido, através de Copy do menu Edit ou CRTL+C, para uma nova tabela ou para um local vazio. Na novo local então, deve-se colar a tabela, através de Paste do menu Edit ou CRTL+V, e pode-se alterar neste passo o nome do Website. O último passo é reinstalar o Website, através da opção Install Site do menu Server, depois de previamente ter seleccionado a nova tabela do site. Ao efectuar este passo será mostrada caixa de diálogo que pede o novo URL para o site. Como se pretende mover o site, deve-se introduzir a nova localização. Se não for pretendido mudar o URL, basta pressionar o botão Ok.

Figura 35 – Caixa de introdução de novo URL


Página 80

Apagar domínios A maneira mais simples de apagar um domínio que deixou de existir

para servir um Website, é através da tabela config.mainResponder.domains. É nesta tabela que se colocam os domínios a servir e onde se retiram. No que diz respeito a adição de domínios já foi visto como fazê-lo anteriormente através do Painel de Controlo.

No caso de eliminação de um domínio, é muito simples, deve-se apagar previamente todos os sites que estejam dentro desse domínio. Depois, deve-se ir à tabela config.mainResponder.domains e seleccionar o domínio a retirar e usar a opção delete do menu Edit ou tecla delete.

Este importante esta noção de apagar domínios, visto que cada vez que se criam novos domínios a servir, estes vão se acumulando nesta tabela e nunca são apagados pelo Frontier.


Página 81

Conversão de trabalho entre Framework Frontier/Manila Existem três formas de converter ou aproveitar trabalho feito no Framework Frontier ou Manila, e vice-versa: 1. Para publicar um site construído no Framework Frontier, num site servido

pelo Manila, deve-se: 1.1. No Manila criar um novo site; 1.2. Depois no Frontier copiar o site que se pretende publicar, através de

Copy do menu Edit ou CRTL+C (tutorial, por exemplo); 1.3. Na base de dados Manilawebsites.root deve-se apagar a tabela do site

criado; 1.4. Colar a tabela do Frontier, através de Paste do menu Edit ou CRTL+V

no Manilawebsites.root num espaço vazio; 1.5. Renomear a tabela copiada para o nome do site criado no primeiro

passo.

2. Para utilizar um site criado pelo Manila e utilizá-lo no Framework Frontier , deve-se: 2.1. Abrir a base de dados Manilawebsites.root; 2.2. Seleccionar a tabela do site que se pretende modificar e explorá-lo.

3. Para utilizar páginas HTML criadas com outra ferramenta, deve-se: 3.1. Criar ou abrir o Website que vai acolher as páginas do outro site, no

Framework Frontier; 3.2. Depois, deve-se importar página a página HTML para um ou vários

outlines ou wp-text, através da opção Import From File do menu HTML;

3.3. Se o que se pretende é importar todo o Website, existe a opção Import Website do menu Web.

3.4. Depois é só escolher se o site será trabalhado no Framework Frontier ou no Manila.


Página 82

Exemplo 1: Criar um grupo de discussão É muito simples criar um grupo de discussão visto que o Manila fornece no Painel de Controlo em List Sites, um site que possui o nome createASite, que permite criar um site de discussão em http://localhost/discuss (Figura 36).

Figura 36 – Criação de sites de grupos de discussão

Depois, surge uma nova página que pede o endereço de correio electrónico

e a password, para verificar se é um editor, ou seja, uma pessoa com direitos de administração do site. Após a introdução dos dados do editor, surge uma nova página já com o grupo de discussão criado(Figura 37).

Este grupo de discussão já tem uma mensagem colocada, que é como se cria um novo site. E pode desde logo ser respondido com um pequeno editor de texto incorporado na página.

Em qualquer Website Manila existe na parte superior da página, somentepara editores um menu muito importante que tem as opções:

• Stories – Colocar/Ver histórias; • Pictures – Adicionar imagens; • Shortcuts – Criar atalhos para partes do Website; • Discuss – Adicionar/Ver mensagens ao grupo de discussão; • Prefs – Contém várias acções para editar o site; • Admin – Parte de administração de contas; • Bulletins – Onde se enviam boletins; • Logoff – Abandonar o site, com encerramento de sessão; • Help – Ajuda on-line.


Página 83

Figura 37 – Grupo de discussão

Caso, se pretenda adicionar novos tópicos de discussão basta seleccionar

Create a new topic, sempre que houver necessidade de criar novos tópicos(Figura 38) e inserir o título na caixa de texto Title, e o corpo em Text, que disponibiliza de algumas funções básicas de edição.

O Frontier disponibiliza automaticamente um calendário visual que gere o arquivo das mensagens criadas diariamente, o que permite rápido acesso a mensagens colocadas numa determinada data, através de um clique sobre o dia/mês que se pretende visualizar.

Para criar novos membros deste grupo deve-se utilizar as opções de menu existentes no topo da página, e neste caso, deve-se utilizar a opção Admin, que no grupo Membership, permite:

• Criar novos membros • Apagar • Bloquear membro • Desbloquear membro


Página 84

Figura 38 - Mensagem

Todas as informações sobre membros do grupo de discussão estão na base de dados members.root, e todas as mensagens ficam guardadas em discuss.root.

Nos Websites Manila a edição de páginas é feita internamente com recursoao XML-RPC, que irá ser abordado mais adiante.


Página 85

Exemplo 2: Criar histórias Uma forma simples de criar rapidamente um site com histórias, aquando da criação do site, deve-se escolher um modelos dos vários existentes, por exemplo, o modelo “Newspaper 1.1”, este assemelha-se a um jornal. Uma história difere de um grupo de discussão no que diz respeito a ser tornado público ou não. No caso da história, é pública, isto é quando se pretende que todos tenham acesso a uma mensagem. Após a criação deste jornal, deve-se fazer o login, e o local onde as histórias são colocadas são em stories, no menu do topo da página, da mesma forma que no exemplo anterior dos grupos de discussão.

Figura 39 – Aspecto um site com história

Para adicionar novas histórias de um determinado assunto existe a opção Create a New Story, que permite também adicionar um título e corpo à história. Cada vez que se cria uma história tem-se a hipótese de integrar com o grupo de discussão, pois existe sempre uma opção que é Comment on this Page, para responder e lançar questões relacionadas com a história.


Página 86

Exemplo 3: Criar notícias Para criar notícias num site, pode-se criar um novo site, ou aproveitar um existente. Como exemplo, o site criado anteriormente, pode ter notícias, e para isso deve-se fazer o login, e no topo da página entrar em prefs. Aqui surge um menu à esquerda com muitas opções, mas para criar notícias existe o News Items. Depois de entrar nessa opção, deve-se activar a primeira opção que é Do you want the News Items feature enabled? Surge, então no browser, mais uma opção que são as notícias(news), que são colocadas da mesma forma que já foi descrito para os exemplos anteriores.

Figura 40 – Aspecto de um site com item de notícias


Página 87

Exemplo 4: Edição do site Para alterar o conteúdo do site, e desde que tenha permissões para tal, existe em qualquer página do Manila Website, um botão Edit This Page. Ao carregar neste botão é visto o conteúdo da página, em texto. Pode-se introduzir texto, código HTML, XML, Javascript, etc. Depois da introdução do que se pretende surge outro botão Post Changes, para confirmar o que foi colocado. Por esse motivo, a ferramenta Manila, é baseada na edição através de um Web browser, pois permite esta grande facilidade de manipulação de sites, independente do local.

Figura 41 – Edição de um Website


Página 88

4.5. Tópicos Avançados Esta parte trata de dois itens muito importantes como complemento directo ao Frontier. São avançados porque o seu uso pode ser muito mais complexo do que o apresentado. Mais uma vez o objectivo é mostrar como se faz e incutir vontade de tentar tirar proveito dos conceitos introduzidos.


Página 89

XML-RPC O que é? O Extensible Markup Language – Remote Procedure Call é uma especificação e um conjunto de implementações que permitem que o software, possa elaborar chamadas de procedimentos remotos sobre o protocolo HTTP. Pode ser criado em Perl, Java, Python, C, C++, PHP, entre outras linguagens, e em ambientes Windows, Unix e Macintosh. Como funciona? Quando um cliente efectua uma chamada de procedimento remoto, é enviada uma mensagem XML-RPC através de um pedido HTTP-POST, no qual o corpo da mensagem está em XML. Quando o servidor recebe o pedido é executado o procedimento e devolvida a resposta também em formato XML. A referência ao procedimento remoto pode ser feita pelo nome de uma célula da base de dados, ou pelo nome de um ficheiro que contém um script que aceita pedidos, ou ainda pelo caminho para um ficheiro que faz parte de uma estrutura de directórios e ficheiros. Como implementar? Pode-se criar um programa cliente em diversas linguagens já referidas, mas para elucidar o seu uso segue-se um exemplo em Perl: use Frontier::Client;$server = Frontier::Client->new(url => 'http://rpc.userland.com/RPC2');$name = $server->call('examples.getStateName', 4);print "$name\n";

Neste exemplo, quando executado o programa vai pedir ao servidor Frontier situado naquele endereço, o nome do Estado correspondente ao 4.º da lista, e imprime-o. Para isso é necessário ter no cliente um módulo para chamadas XML-RPC, existente em http://www.cpan.org e no servidor é necessário ter o script “examples.getStateName” (Figura 42) em user.betty.rpcHandlers e módulo servidor a correr em “RPC2”, por defeito o Frontier tem esta localização em “user.webserver.responders.rpc2”. Betty é o nome do mecanismo cliente/servidor RPC do Frontier.


Página 90

Figura 42 – Código exemplo de XML-RPC

O script “examples.getStateName” invoca outro que é o

”states.nthState”(Figura 43). Este devolve o que está na tabela “suites.states.table” na linha “n”.

Figura 43 – Código exemplo chamado pelo script anterior

Em termos de comunicação o que acontece, é que é gerado o seguinte código, quando é executado o programa cliente: Cabeçalho:(Usa o método POST e indica que o Conteúdo é XML) POST /RPC2 HTTP/1.0User-Agent: Frontier/5.1.2 (WinNT)Host: rpc.userland.comContent-Type: text/xmlContent-length: 181

Corpo: (O método é o nome do procedimento remoto) <?xml version="1.0"?><methodCall>

<methodName>examples.getStateName</methodName><params>

<param><value><i4>4</i4></value></param>

</params></methodCall>


Página 91

Em resposta é enviado o seguinte conteúdo: Cabeçalho: (200 significa que houve sucesso no retorno de uma resposta) HTTP/1.1 200 OKConnection: closeContent-Length: 158Content-Type: text/xmlDate: Fri, 17 Jul 2001 19:55:08 GMTServer: UserLand Frontier/5.1.2-WinNT

Corpo: (Retorna o nome do Estado pedido, ou uma estrutura do tipo “<fault>” no qual é indicada a falha) <?xml version="1.0"?><methodResponse>

<params><param>

<value><string>Arkansas </string></value></param>

</params></methodResponse>

Outro exemplo, é o que se segue que demonstra o escrita de um handler XML-RPC, para que um servidor receba chamadas XML-RPC e como chamar de uma máquina cliente também com o Frontier. Para começar deve-se criar um script no servidor em “user.betty.rcpHandlers”, chamado, por exemplo, “olamundo” com o seguinte conteúdo: On olamundo(username)

Return(“Ola “ + username + “.”)

Para invocar este script num cliente Frontier é necessário invocar o Verb, betty.rpc.client que neste caso, possui 4 parâmetros(endereço IP, porto, nome do script, parâmetros a enviar para o script). O script a ser criado será na tabela Workspace(CTRL+T ou menu Main, opção Workspace), com o nome “ligacaorpc” conforme a Figura 44.


Página 92

Figura 44 - Código exemplo de ligação XML-RPC

O resultado será este:

Figura 45 – Execução do código exemplo de ligação XML-RPC


Página 93

SOAP para Frontier O que é? O Simple Object Access Protocol é semelhante ao XML-RPC, e foi inicialmente implementado pela UserLand, DevelopMentor and Microsoft como o XML-RPC com umas pequenas diferenças. Posteriormente foi devidamente especificado pelo W3C, que já inclui XML Schemas, enumerações, tipos definidos e matrizes, e actualmente está na especificação cuja versão é a 1.1. Segue-se uma parte da definição existente no W3C: "SOAP is a lightweight protocol for exchange of information in a decentralized, distributed environment. It is an XML based protocol that consists of three parts: an envelope that defines a framework for describing what is in a message and how to process it, a set of encoding rules for expressing instances of application-defined datatypes, and a convention for representing remote procedure calls and responses. SOAP can potentially be used in combination with a variety of other protocols; however, the only bindings defined in this document describe how to use SOAP in combination with HTTP and HTTP Extension Framework." Como funciona? Quando um cliente efectua uma chamada de procedimento remoto, é enviada uma mensagem XML através de um pedido HTTP-POST, no qual é enviada uma acção que identifica o objecto a chamar no servidor, o corpo da mensagem está em XML, e inclui um envelope SOAP, um conjunto de regras e uma estrutura que representa os RPC’s. Quando o servidor recebe o pedido é executado o procedimento e devolvida a resposta também em formato XML com as especificidades SOAP referidas. A referência ao procedimento remoto pode ser feita pelo nome de uma célula da base de dados, ou pelo nome de um ficheiro que contém um script que aceita pedidos, ou ainda pelo caminho para um ficheiro que faz parte de uma estrutura de directórios e ficheiros. Como implementar? A maneira de implementar é semelhante ao XML-RPC, por isso é natural encontrar muitas semelhanças. Desde a versão 6.2 do Frontier já é suportado o SOAP.


Página 94

Um exemplo, de um cliente que faça chamadas SOAP-RPC através do Frontier, deve usar o Verb, soap.rpc.client. Os parâmetros mais importantes são:

• actionURI – é utilizado na linha de pedido HTTP e no cabeçalho SOAPAction. Identifica o objecto a ser invocado no servidor.

• methodName – é o nome do método público do objecto que é identificado pelo parâmetro actionURI.

• adrparams – é o endereço da lista ou dos registos que contém os parâmetros a serem passados ao servidor.

O script a ser criado será na tabela Workspace(CTRL+T ou menu Main,

opção Workspace), com o nome “ligacaosoap” conforme a Figura 46.

Figura 46 – Código de ligação SOAP

O resultado deste script é a lista do primeiro, segundo e terceiro estado dos Estados Unidos.

Figura 47 – Execução do código de ligação SOAP

Neste script, é declarado o parâmetro “{“numlist”:{1,2,3}}” que é o

nome do parâmetro do handler getStatesList (Figura 48) que é pedido na ligação SOAP-RPC. Além disso, é pedida a acção “examples” que é um objecto que está definido em user.soap.rpcHandlers e que aponta para a tabela onde está o handler:

system.verbs.builtins.soap.examplerpchandlers


Página 95

Figura 48 – Código de exemplo de SOAP

Depois, no script da Figura 46, é mostrado o conteúdo do pedido(Figura 49) e da resposta(Figura 50) XML gerada pelo SOAP-RPC.

Figura 49 – Pedido SOAP


Página 96

Figura 50 – Resposta SOAP

Conforme no XML-RPC, a escrita de um handler é muito parecida com o SOAP-RPC. Por isso, para visualizar melhor as diferenças entre os dois, segue-se o mesmo exemplo já visto no XML-RPC, mas para o caso SOAP-RPC. Em user.soap.rpcHandlers cria-se uma tabela, por exemplo, com o nome “teste”. Dentro dessa tabela o script “olamundo”. Tem um parâmetro que é o nome da pessoa. On olamundo(name)

Return(“Ola “ + name + “.”)

Para invocar este handler, cria-se um novo script, por exemplo na tabela Workspace, chamado “chamarpcsoap” de acordo com a Figura 51.


Página 97

Figura 51 - Código exemplo de ligação SOAP

Ao executar o script o resultado será:

Figura 52 – Execução do código exemplo de ligação SOAP


Página 98

5 - Conclusão


Página 99

O tutorial descreveu de uma maneira prática como construir sites de forma a que o utilizador consiga dominar todos os conceitos existentes no Frontier. Neste ponto o utilizador encontra-se preparado a construir Websites mais complexos, e pronto a aprofundar conhecimentos mais específicos directa ou indirectamente relacionados com a ferramenta. Procurou-se mostrar alguns exemplos para que fosse logo possível demonstrar as capacidades da ferramenta estudada, não de uma forma exaustiva, mas de maneira que se ficasse com a ideia para resolver problemas que podem não estar logo à vista, mas que podem derivar dos conhecimentos adquiridos ao longo do tutorial.

Em termos de software, verificou-se que o Frontier é bastante completo, pois inclui base de dados, CMS, scripting e servidor HTTP num só pacote. Isto permite que a ferramenta seja poderosa, pois não é necessário comprar separadamente software. O preço a pagar no momento da escrita deste tutorial, não é muito caro, $899 para empresas e $299 para licenças académicas, por cópia e por ano, com direito a upgrades. Há também uma versão gratuita, que é a 5.0.1 que pode perfeitamente servir a determinados propósitos.

Em termos de recursos humanos, o Frontier permite que os programadores rapidamente desenvolvam aplicações que possam ser integradas na construção de sites. Embora tenha o UserTalk embutido, também é permitido o uso de outras linguagens como Python, C e Java, ou outra que seja compatível com SOAP. O facto de suportar XML, XML-RPC, SOAP, permite vantagens como a interoperabilidade, a independência, integração, etc. Ou seja, a integração de conteúdo externo através de XML-RPC ou SOAP, permite funcionalidades recente tais como, a integração dos Web Services da nova plataforma .NET, entre outras. Se a programação convencional de XML-RPC ou SOAP vista no tutorial necessitar de mais apoio, e embora não estudado neste tutorial, a UserLand possui outra ferramenta, a Radio que é uma aplicação cliente que permite construir rapidamente aplicações Web que invocam funcionalidades através de ligações SOAP ao sistema final.

Além disso, verificou-se que o Frontier permite aos utilizadores publicar o conteúdo das páginas na Web, de maneira fácil, com uso de modelos, separação de conteúdo da aparência e com uso do Manila que no fundo é o CMS, e que permite:

• Conteúdo dinâmico; • Edição WYSIWYG através do browser; • Gestão do site através do browser; • Grupos de discussão; • Gestão de listas de correio electrónico;


Página 100

• Gestão de membros; • Configurações de editorial(só para editores, etc.)

Pode-se salientar ainda, que é uma ferramenta bastante estável, com

actualizações sempre que haja alterações realmente significativas, com preocupações ao nível compatibilidade de versões, integração com outras linguagens, e suporta sites dinâmicos, ou estáticos, para casos em que se necessite de execução conjunta com o IIS ou Apache.

Aconselha-se então, de uma maneira geral, a sua escolha no caso de querer produzir sites dinâmicos, de notícias, de grupos de discussão, que tenha gestão de membros e na produção de Websites em que os modelos e os filtros são importantes.

Pelos motivos referidos, e para quem procura a automação na criação de Websites aliado ao poder de alteração dos mesmos, o Frontier é uma ferramenta muito útil. Para mais informações sobre outros CMS existentes relativamente ao Frontier consultar http://www.camworld.com/cms/ ou no apêndice deste tutorial.


Página 101

Bibliografia


Página 102

UserLand Software URL: http://www.userland.com/ Frontier da UserLand URL: http://frontier.userland.com/ Documentação URL: http://docserver.userland.com Manila da UserLand URL: http://frontier.userland.com/ Modelos de Websites Manila URL:http://www.weblogger.com Notícias de Scripts da UserLand URL: http://www.scripting.com/ Arquivo de Outliners URL: http://www.outliners.com/ Script Meridian – Tutoriais mais antigos URL: http://www.scriptmeridian.org/tutorials/index.html Inligo URL: http://www.inligo.com/frontier/ Artigo sobre Frontier da TidBits URL: http://db.tidbits.com/getbits.acgi?tbart=05351 Artigo sobre Frontier da revista Domino Power, de Russ Lipton – Novembro 2000 URL: http://www.dominopower.com/issues/issue200011/frontier001.html Tutorial “Website and Scripting Tutorial” URL: http://frontier.userland.com/tutorial/ Tutorial “Up and Running with Frontier Web Site Management” de Matt Neuburg URL: http://www.ojai.net/matt/webtutorial/index.html Tutorial “Serious First Steps In UserTalk Scripting” URL: http://www.ojai.net/matt/scriptingTutorial/


Página 103

Documentação variada e em parte desactualizada URL: http://drmatt.userland.com/ Dave Winer URL: http://davenet.userland.com/ XML-RPC URL: http://www.xmlrpc.com/ SOAP URL: http://www.soapware.org/ Perl URL: http://www.cpan.org


Página 104

Apêndice


Página 105

CAMWORLD: http://www.camworld.com/cms/ (Diário digital - tecnologias): Content Management Systems (in alphabetical order)

Name Web Server (Articles) Platforms

Code Base and/or Scripting Language

Web Interface db Support Cost

Allaire Spectra IIS/NT, Apache/Solaris

? CFML (proprietary)

Yes Any ODBC-compliant on NT/Solaris, Sybase, Oracle

$7,495 per server

AOLServer; (1)

AOLServer (fast, multi-threaded)

Solaris, IRIX, Linux, MacOS X, WinNT, Win98

Tcl, PHP4, or Python

Arsdigita Community System

Oracle, Sybase, Postgres, Solid, Informix, DB2, or ODBC (under WinNT)

Free (open source)

Broadvision [opinion]

IIS, Netscape Enterprise Server, or as a CGI

? Javascript, C++, CORBA (Embedded: Roguewave Tools.h++, money.h++, DBTools.h++)

? Oracle, Informix, Microsoft SQL, Sybase

?

Communique 2

Apache, Netscape Enterprise 3.5.1, IIS 4.0

Windows9x, WinNT, IRIX 6.4/6.5. Solaris 2.7, AIX 4.1, Linux for Intel, Linux for StrongArm

QHTML, ECMAScript

Yes mySQL, Oracle, Informix, Sybase, MSSQL, any ODBC-compliant

?

EditTag Run as a CGI Any Perl Yes No Free (or $50 for supported version)

Enhydra Apache, or built-in

? Java No JDBC Free

FileMaker Pro Built-in MacOS 7.6.1 or higher, Win95/98/NT

CDML (proprietary)

Build your own, or Claris Home Page

proprietary, ODBC-compliant with Oracle 8, Oracle 7, and SQL Server 7

$149 to $999, depending on what you need, how many licences, etc.

FutureTense Netscape Application Server 3.6, IIS 4.0

? FutureTense IPS

Yes (IPS Xcelerate)

Oracle 7.3.4. Oracle 8.0.4, Sybase 11.0, Informix 7.22, SQL Server 6.5 (NT Only) using ODBC

Less than Vignette


Página 106

InfoOffice RedDot

Any (renders flat pages)

WinNT 4.0 w/SP5 Only

RedDot (proprietary), Win95/98 Only

File System or ODBC-compliant

?

Intervoven Teamsite

Apache, IIS 4.0, Netscape Enterprise Server, OpenDeploy (built-in)

Win95, Win98, WinNT, Solaris 2.5.1, MacOS

Perl, XML LaunchPad 3.1 (proprietary)

SQL-compatible

35K+

MasonHQ Apache Linux, FreeBSD, Solaris, IRIX (or anything that supports Apache and mod_perl)

Perl Yes MySQL, any DBI-compliant db, flat-file

Free

Mediasurface Built-in ? ? ? SQL ? MidGard Apache with

PHP ? PHP

(modified) Yes MySQL,

ODBC-compliant (coming soon)

Free

NewsPro Run as a CGI Any Perl ? Flat-file Free phpMyAdmin (MySQL admin)

Any supported by PHP

? PHP Yes MySQL Free

Provue SiteWarrior

Any MacOS, (Windows port coming)

Provue Panorama

No Panorama (proprietary), flat-file, or text-delimited

$300

Revize Any Web-based RevizeScript (proprietary)

Yes (Java-based)

Proprietary or ODBC, JDBC

$295

Roosh Newspublisher

Run as a CGI ? Perl Yes Flat-file Free

SiteEditor ? ? ? Yes proprietary $50/month to ?

slashdot.pl Apache, ? ? Perl ? MySQL Free SOHOnet Runtime Site Builder

IIS WinNT Cold Fusion ? MSSQL7 $30,000 per server

SquishDot Plug-in for Zope Application Server

? Python, Zope's DTML

Yes MySQL Free

Userland Frontier

Built-in, or render flat pages; IIS, WebSTAR

Win95, Win98, WinNT, MacOS

UserTalk (proprietary), Applescript, Tcl/Tk (via Active Scripting)

Manila and Pike

proprietary, ODBC-compliant

$0 to $899 per client per year

Vignette Storyserver

Any webserver that supports NSAPI, ?

? Tcl with proprietary extensions

have to build your own, not inlcuded

Oracle, any ODBC-compliant db

$25,000 to several $mil


Página 107

WebObjects any HTTP server with a CGI, ISAPI, NSAPI, or WAI interface

MacOS X, WinNT, Solaris, HPUX

Java, Objective-C, WebScript (3rd party: Perl, Python, Tcl)

Yes (3rd party)

Oracle, Sybase, Informix, OpenBase, ODBC

$99 to $50,000

WebSite Director

Apache, Domino, Netscape, NCSA, IIS, O'Reilly

BSDI, FreeBSD, HP-UX, Linux, SGI, Solaris, SunOS, WinNT

Yes (HTML-based)

mSQL 1.x, mSQL 2.x, mSQL, or any ODBC-compliant db (with WinNT version)

Varies with each client

Zope Zserver (built-in) based on Medusa HTTPD, or as a CGI using IIS or Apache

Linux, WinNT, Solaris,

Python with some C, DTML (proprietary)

Yes Zope Object DB (proprietary), Oracle, MySQL, PostreSQL, MS_SQL, Gadfly, etc.

Free, or commercial support. Zope is also an open source project.

“This list is owned and moderated by Cameron Barrett and Phil Suh.”

Documents

Tutorial sobre a ferramenta de construção de Websites …paf/proj/Set2001/frontier-final.pdf · HTML até a parte de scripts na qual pode-se automatizar a construção dos sites