Nós fomos escolhidos pelo W3C do Brasil para ministrar um treinamento sobre HTML5 para os seus membros e alguns convidados. Para tanto, construímos uma apostila com todo o conteúdo abordado neste nosso curso. Essa apostila está sendo agora publicada sob Creative Commons aqui no Tableless. Esperamos que ajude a comunidade de desenvolvimento web brasileira.
64 |
65 |
66 | Essa apostila ficará em processo de constante atualização já que muitos pontos do HTML5 não foram ainda definidos e também porque diversas outras características estão sendo planejadas e rascunhadas ainda. Se você tiver qualquer sugestão, por favor, nos contacte.
A API de Drag and Drop é relativamente simples. Basicamente, inserir o atributo draggable="true" num elemento o torna arrastável. E há uma série de eventos que você pode tratar. Os eventos do objeto sendo arrastado são:
12 |
13 |
14 |
dragstart
15 |
O objeto começou a ser arrastado. O evento que a função recebe tem um atributo target, que contém o objeto sendo arrastado.
16 |
drag
17 |
O objeto está sendo arrastado
18 |
dragend
19 |
A ação de arrastar terminou
20 |
21 |
22 |
O objeto sobre o qual outro é arrastado sofre os seguintes eventos:
23 |
24 |
25 |
dragenter
26 |
O objeto sendo arrastado entrou no objeto target
27 |
dragleave
28 |
O objeto sendo arrastado deixou o objeto target
29 |
dragover
30 |
O objeto sendo arrastado se move sobre o objeto target
31 |
drop
32 |
O objeto sendo arrastado foi solto sobre o objeto target
33 |
34 |
35 |
Detalhes importantes:
36 |
37 |
A ação padrão do evento dragover é cancelar a ação de dragging atual. Assim, nos objetos que devem receber drop, é preciso setar uma ação de dragover com, no mínimo, return false.
38 |
39 |
Seleções de texto são automaticamente arrastáveis, não precisam do atributo draggable. E se você quiser criar uma área para onde seleções de texto possam ser arrastadas, basta tratar esses mesmos eventos.
40 |
41 |
Por fim, todas funções de tratamento de evento de drag recebem um objeto de evento que contém uma propriedade dataTransfer, um dataset comum a todos os eventos durante essa operação de drag.
Os agentes de usuário podem oferecer recursos de revisão ortográfica e gramatical, dependendo do que houver disponível em cada plataforma. Os desenvolvedores podem controlar o comportamento dessa ferramenta através do atributo spellcheck. Inserir spellcheck="true" num elemento faz com que a revisão esteja habilitada para ele. Você também pode desabilitar a revisão para determinado elemento, inserindo spellcheck="false".
52 |
53 |
8 |
9 |
Áudio
10 |
11 |
Para inserir áudio em uma página web, basta usar o elemento audio:
O valor de controls define se um controle de áudio, com botões de play, pause, volume, barra de progresso, contador de tempo, etc. será exibido na tela. Se for setado como "false", será preciso controlar o player via javascript, com métodos como play() e pause(). O valor de autoplay define se o áudio vai começar a tocar assim que a página carregar.
16 |
17 |
Origens alternativas de áudio
18 |
19 |
Todo agente de usuário deveria suportar o codec livre OggVorbis, mas, infelizmente, pode acontecer de seu arquivo oga não tocar no computador ou celular de alguém. Quem sabe do seu chefe ou seu cliente. Então é preciso saber como oferecer um formato alternativo de áudio. Fazemos assim:
Claro, o agente de usuário pode ainda não saber tocar nenhum desses formatos, ou sequer ter suporte a áudio. Para esses casos, ofereça um conteúdo alternativo:
É muito importante que você inclua, nos seus elementos source de áudio e vídeo, informação a respeito do container e codecs utilizados. Isso vai evitar que o navegador tenha que baixar, pelo menos parcialmente, o arquivo de mídia para, depois, descobrir que não consegue tocá-lo. É importante lembrar que a extensão do arquivo não é informação relevante para isso, pelo contrário, não significa nada. Uma URL pode não ter extensão de arquivo e pode levar a um redirecionamento.
59 |
60 |
Para indicar ao navegador o container e codecs de determinado arquivo, usa-se o atributo type, no formato:
61 |
62 | type='MIME-type do container; codecs="codec de vídeo, codec de áudio"'
63 |
64 |
Por exemplo, um vídeo em Ogg, usando os codecs Theora e Vorbis, terá seu source assim:
Você pode inserir em seu HTML um elemento de acesso à webcam do usuário, assim:
17 |
18 |
<device type="media">
19 |
20 |
Isso vai exibir uma interface solicitando ao usuário acesso a sua webcam. Se ele tiver mais de uma, também será permitido que ele escolha que webcam usar. O atributo media também pode conter o valor "fs", que vai abrir uma caixa de seleção no sistema de arquivos, permitindo ao usuário escolher um arquivo para fazer stream.
21 |
22 |
O passo seguinte é conectar o stream desse seu elemento device a alguma coisa. Veja, por exemplo, como conectá-lo a um elemento video na própria página, fazendo com que o usuário possa ver a imagem de sua própria webcam:
23 |
24 |
25 |
26 |
Streams
27 |
28 |
Você deve ter notado, no script acima, que a função de update recebe um parâmetro stream. Trata-se de um objeto da classe Stream, que possui uma propriedade url, que já usamos acima, e um método record. O método record inicia a gravação do stream e retorna um objeto StreamRecorder. Esse último possui um método stop, que retorna o arquivo que foi gravado.
29 |
30 |
Peer-to-peer
31 |
32 |
Cuidado! O W3C ainda está trabalhando nessa especificação, e tudo aqui pode mudar. Por isso, não se preocupe em entender as minúcias. Saiba apenas que HTML5 prevê que os agentes de usuário tenham uma interface de comuicação P2P, que permite a troca de texto, imagem, vídeo e arquivos. Por enquanto, a especificação deste item esté sendo escrita junto da do elemento device, mas isso deve ganhar uma página própria em breve. Fique de olho.
33 |
34 |
8 |
9 |
MathML
10 |
11 |
O HTML5 incorpora o padrão MathML. Trata-se de uma linguagem de marcação, baseada em XML, para representação de fórmulas matemáticas. Você pode ler mais sobre MathML em http://www.w3.org/Math/. Para incorporar código MathML em seu documento HTML5, não preciso fazer declarações especiais. Basta escrever normalmente o código, iniciando com um elemento math. Veja este exemplo:
12 |
13 |
14 |
15 |
Veja como esse exemplo é renderizado no navegador:
16 |
17 |
18 |
19 |
Mesmo que você nunca tenha visto MathML, e este código pareça um pouco assustador, dê uma olhada com calma no código, comparando com a imagem do resultado, e você vai perceber que é muito simples. Talvez algo que possa deixá-lo confuso é a entidade ⁢, que aparece algumas vezes no código. Ela está lá para separar os fatores 4ac, por exemplo. Esses valores são multiplicados, é o que a fórmula representa, mas não queremos colocar um operador de multiplicação entre eles, porque por convenção se simplesmente escrevemos 4ac qualquer leitor saberá que isso é uma multiplicação.
20 |
21 |
Por que então se preocupar em inserir ⁢? Você vai notar que se remover a entidade e a tag mo correspondente o resultado visual será o mesmo. Colocamos ⁢ porque MathML não é só visual, é semântica. Um outro agente de usuário pode ter recursos de importar essa fórmula para uma ferramenta de cálculo, por exemplo.
22 |
23 |
SVG
24 |
25 |
Assim como MathML, SVG é uma outra linguagem XML que pode ser incorporada com facilidade em HTML5. Você pode ler mais sobre SVG em http://www.w3.org/Graphics/SVG/. SVG é uma linguagem para marcação de gráficos vetoriais. Vejamos um exemplo bem simples:
26 |
27 |
28 |
29 |
E veja como isso é renderizado no navegador:
30 |
31 |
32 |
33 |
É possível fazer muito mais com SVG. A maioria dos editores de gráficos vetoriais hoje exporta e importa automaticamente SVG, permitindo a um designer construir um gráfico em seu editor vetorial predileto e exportá-lo diretamente. Em seguida, um programador pode construir javascript que manipula esse SVG, usando os métodos do DOM. Com isso você pode ter gráficos dinâmicos, com animação, escaláveis e com excelente qualidade visual, programáveis em Javascript, sem tecnologias proprietárias e plugins.
34 |
35 |
8 |
9 |
O elemento canvas
10 |
11 |
A Canvas API permite a você desenhar na tela do navegador via Javascript. O único elemento HTML existente para isso é o elemento canvas, o resto todo é feito via Javascript. Veja como inserir o elemento canvas numa página:
12 |
13 |
<canvas id="x" width="300" height="300"></canvas>
14 |
15 |
Isso vai exibir um retângulo vazio. Para desenhar nele, primeiro obtemos o contexto de desenho, com Javascript:
Agora que temos um contexto, podemos desenhar nele. Vamos começar com um simples retângulo:
25 |
26 |
context.fillRect(10, 10, 50, 150)
27 |
28 |
Simples, não? Que tal tentarmos algo um pouco mais complexo? Dê uma olhada no exemplo:
29 |
30 |
31 |
32 |
E veja o que acontece quando se clica no botão:
33 |
34 |
35 |
36 |
Há muito mais para você estudar se quiser se aprofundar na Canvas API. Apenas para que você tenha uma idéia, é possível desenhar texto, sombras, gradientes, incluir imagens no canvas, manipular os pixels, rotacionar e transformar os objetos.
37 |
38 |
Canvas e SVG
39 |
40 |
Uma dúvida muito comum é quando usar Canvas, quando usar SVG. Para saber escolher, é preciso entender as diferenças entre um e outro. SVG é vetorial, e baseado em XML, logo, acessível via DOM. Canvas é desenhado pixel a pixel, via Javascript.
41 |
42 |
Assim, as vantagens do SVG são:
43 |
44 |
45 |
O conteúdo é acessível a leitores de tela
46 |
O gráfico é escalável, não perde resolução ou serrilha ao redimensionar
47 |
O conteúdo é acessível via DOM
48 |
49 |
50 |
E as vantagens do Canvas:
51 |
52 |
53 |
A performance é muito superior ao SVG na maioria dos casos
54 |
É fácil desenhar via Javascript. Em SVG, é preciso fazer seu script escrever XML para você. Com Canvas você só manda desenhar, e pronto.
55 |
56 |
57 |
8 |
9 |
EventSource
10 |
11 |
A Server-Sent Events API é uma maneira de inverter o fluxo das aplicações Ajax, fazendo com que o servidor possa disparar o envio de dados ao agente de usuário. Para isso, cria-se, no agente de usuário, um objeto EventSource:
12 |
13 |
es=new EventSource('comm.php')
14 |
15 |
Isso vai abrir uma conexão HTTP para "comm.php" e mantê-la escutando. Cada vez que o servidor enviar eventos para esse cliente, será disparado o evneto message do objeto EventSource. Veja um exemplo:
Isso pode ser usado, por exemplo, para implementar uma interface de chat ou um monitor de status de alguma operação demorada ocorrendo no servidor.
22 |
23 |
O protocolo de comunicação
24 |
25 |
Em nosso exemplo acima, a página comm.php envia eventos para o agente de usuário. Você não precisa se preocupar em saber como isso funciona do lado do cliente, uma vez que o agente de usuário faz todo o trabalho. Mas é importante que saiba como isso deve funcionar do lado do servidor. A URL de comunicação deve devolver ao cliente um header Content-type: text/event-stream. Em seguida, envia as mensagens, que são blocos de texto separados um do outro por uma linha em branco:
26 |
27 |
data: mensagem 1
28 |
29 | data: a mensagem 2 tem
30 | data: mais de uma linha
31 |
32 | data: mensagem 3
33 |
34 |
O prefixo data: indica que o que segue são os dados da mensagem. Você também pode usar o prefixo id:
35 |
36 |
data: mensagem 1
37 | id: 1
38 |
39 | data: a mensagem 2 tem
40 | data: mais de uma linha
41 | id: 2
42 |
43 | data: mensagem 3
44 | id: 3
45 |
46 |
Se você enviar prefixos id em suas mensagens e o agente de usuário perder a conexão, ao tentar reconectar ele vai enviar o valor do último id no header HTTP Last-Event-ID. Com isso você pode, por exemplo, enviar as mensagens do chat do ponto em que parou.
47 |
48 |
8 |
9 |
Uma palavra sobre eventos
10 |
11 |
O suporte ao tratamento de eventos disparados pelo usuário é parte essencial do DOM. HTML5 oferece a você um extenso conjunto de novos eventos. Vamos dar uma olhada nos mais interessantes:
12 |
13 |
Elementos multimídia:
14 |
15 |
16 |
oncanplay
O elemento audio ou video já tem dados suficientes no buffer para começar a tocar.
17 |
oncanplaythrough
O elemento audio ou video já tem dados suficientes no buffer para começar a tocar e, se a tranferência de dados continuar no ritmo em que está ocorrendo, estima-se que tocará até o final sem interrupções.
18 |
ondurationchange
O elemento audio ou video teve seu atributo duration modificado. Isso acontece, por exemplo, ao alterar a origem da mídia.
19 |
onemptied
O elemento audio ou video teve um erro de retorno vazio de dados da rede. O retorno vazio acontece quando, por exemplo, você tenta invocar o método play de um elemento que ainda não tem uma origem de mídia definida.
20 |
onended
O vídeo ou áudio chegou ao fim.
21 |
onloadeddata
Os dados começaram a ser carregados e a posição atual de playback já pode ser renderizada.
22 |
onloadedmetadata
Os metadados foram carregados. Já sabemos as dimensões, formato e duração do vídeo.
23 |
onloadstart
Os dados começaram a ser carregados.
24 |
onpause
O usuário clicou em pause.
25 |
onplay
O usuário clicou em play ou o playback começou por causa do atributo autoplay
26 |
onplaying
O vídeo ou áudio está tocando.
27 |
onprogress
O agente de usuário está buscando dados do vídeo ou áudio.
28 |
29 |
30 |
Eventos em campos de formulário:
31 |
32 |
oninput
O usuário entrou com dados no campo
33 |
oninvalid
O campo não passou pela validação
34 |
35 |
36 |
Eventos gerais:
37 |
38 |
oncontextmenu
O usuário disparou um menu de contexto sobre o objeto. Na maioria dos sistemas Desktop, isso significa clicar com o botão direito do mouse ou segurando uma tecla especial.
39 |
onmousewheel
A rodinha do mouse foi acionada.
40 |
onbeforeprint
Disparado antes da impressão da página. Você pode usá-lo para modificar, esconder ou exibir elementos, preparando a página para impressão.
41 |
onafterprint
Disparado após a impressão da página. Você pode usá-lo para reverter o status anterior à impressão.
42 |
onhashchange
A última porção da URL, após o hash (#), foi modificada.
A especificação do HTML5 padronizou um formato de atribuição de eventos que já era amplamente utilizado. Você pode atribuir eventos através de atributos HTML com o nome do evento. Por exemplo:
65 |
66 |
<input onblur="return verifica(this)" />
67 |
68 |
É claro que você pode continuar usando o método do DOM addEventListener, com a vantagem de poder atribuir vários listeners ao mesmo evento.
69 |
70 |
8 |
O elemento menu
9 |
10 |
O elemento menu é usado para definir menus e barras de ferramenta. Dentro do menu, você pode inserir submenus ou comandos. Para inserir submenus, basta inserir outros elementos menu. Para definir comandos, você pode inserir:
11 |
12 |
13 |
Um link, um elemento a com atributo href;
14 |
Um botão, um elemento button;
15 |
Um botão, um elemento input com o atributo type contendo button, submit, reset ou image;
16 |
Um radiobutton, um elemento input com o atributo type contendo radio;
17 |
Um checkbox, um elemento input com o atributo type contendo checkbox;
18 |
Um elemento select, contendo um ou mais options, define um grupo de comandos
19 |
Um elemento qualquer com o atributo accesskey
20 |
Um elemento command
21 |
22 |
23 |
Tipos de comando
24 |
25 |
Há três tipos de comando:
26 |
27 |
28 |
command
29 |
Uma ação comum;
30 |
checkbox
31 |
Uma ação que pode estar no status de ligada ou desligada, e alterna entre esses dois stauts quando clicada;
32 |
radio
33 |
Uma ação que pode estar no status de ligada ou desligada, e quando clicada vai para o status de ligada, deligando todas as ações com o mesmo valor no atributo radiogroup;
34 |
35 |
36 |
Da lista de elementos possíveis para definir comandos, os três primeiros, link, button e input button, definem comandos do tipo command. O quarto elemento, radiobutton, define um comando do tipo radio. O quinto, checkbox, define um comando do tipo checkbox.
37 |
38 |
O sexto elemento, o select, vai definir um grupo de comandos. Se o select tiver o atributo multiple, definirá uma lista de comandos do tipo checkbox. Caso contrário, os comandos serão do tipo radio, tendo o mesmo radiogroup.
39 |
40 |
No sétimo caso, um elemento qualquer com tecla de acesso, o tipo de comando vai depender do tipo de elemento que recebeu accesskey.
41 |
42 |
O elemento command
43 |
44 |
Por fim, temos o oitavo método, o elemento command. Neste caso o tipo de comando dependerá do valor do atributo type. Veja um exemplo de como usá-lo:
Por que a especificação permite que se use o novo elemento command para definir comandos, e ao mesmo tempo permite que se use os velhos elementos como input, button e select para isso? Para possibilitar ao desenvolvedor oferecer alguma compatibilidade com navegadores antigos. Veja este exemplo:
51 |
52 |
53 |
54 |
O agente de usuário deveria renderizar algo como:
55 |
56 |
57 |
58 |
Um agente de usuário que não conhece o novo elemento menu vai entender esse código como listas aninhadas com botões e links. E vai renderizar isso assim:
59 |
60 |
61 |
62 |
Não está bonito, mas é perfeitamente acessível. E o visual pode ser bem trabalhado com CSS. A mesma coisa poderia ser escrita com o elemento command:
63 |
64 |
65 |
66 |
Mas um agente de usuário que não conhece os elementos menu e command não vai mostrar absolutamente nada.
67 |
68 |
8 |
9 |
Links
10 |
11 |
A possibilidade de linkar documentos é o que torna a Web o que ela é. Existem duas maneiras principais de linkar documentos, os elementos a e link. O elemento a cria um link no conteúdo da página. Você conhece sua sintaxe:
12 |
13 |
<a href="http://visie.com.br">Visie</a>
14 |
15 |
O elemento link, por sua vez, cria um metadado, um link que não é mostrado no conteúdo, mas o agente de usuário usa de outras maneiras. O uso mais comum é vincular um documento a uma folha de estilos:
16 |
17 |
<link rel="stylesheet" href="estilo.css" />
18 |
19 |
Note o atributo rel="stylesheet". O atributo rel pode estar presente nos elementos a e link, e ter uma série de valores:
20 |
21 |
Metadados de navegação
22 |
23 |
24 |
archives
25 |
os arquivos do site
26 |
author
27 |
a página do autor do documento atual
28 |
bookmark
29 |
o permalink da seção a que este documento pertence
30 |
first
31 |
o primeiro documento da série a qual este pertence
32 |
help
33 |
ajuda para esta página
34 |
index
35 |
o índice ou sumário que inclui o link para esta página
36 |
last
37 |
o último documento da série a qual este pertence
38 |
license
39 |
a licensa que cobre este documento
40 |
next
41 |
o próximo documento da série a qual este pertence
42 |
prefetch
43 |
o agente de usuário deve fazer cache desse link em segundo plano tão logo o documento atual tenha sido carregado. O autor do documento indica que este link é o provável próximo destino do usuário.
44 |
prev
45 |
o documento anterior da série a qual este pertence
46 |
search
47 |
a busca deste site
48 |
up
49 |
O documento um nível acima deste
50 |
51 |
52 |
O Opera nos dá um interessante exemplo de como um agente de usuário pode exibir estes links:
53 |
54 |
55 |
56 |
Metadados da página
57 |
58 |
59 |
alternate
60 |
um formato alternativo para o conteúdo atual. Precisa estar acompanhado do atributo type, contendo o tipo MIME do formato. Por exemplo, para indicar o RSS da página atual usamos:
61 |
a URL de pingback desta página. Através desse endereço um sistema de blogging ou gerenciador de conteúdo pode avisar automaticamente quando um link para esta página for inserido.
67 |
stylesheet
68 |
a folha de estilo linkada deve ser vinculada a este documento para exibição
69 |
70 |
71 |
Comportamento dos links na página
72 |
73 |
74 |
external
75 |
indica um link externo ao domínio do documento atual
76 |
nofollow
77 |
indica que o autor do documento atual não endossa o conteúdo desse link. Os robôs de indexação para motores de busca podem, por exemplo, não seguir este link ou levar em conta o nofollow em seu algoritmo de ranking.
78 |
noreferrer
79 |
o agente de usuário não deve enviar o header HTTP Referer se o usuário acessar esse link
80 |
sidebar
81 |
o link deve ser aberto numa sidebar do navegador, se este recurso estiver disponível
82 |
83 |
84 |
85 |
86 |
8 |
9 |
Semântica adicional
10 |
11 |
Dê um olhada no seguinte código:
12 |
13 |
14 |
15 |
A Microdata API nos permite tornar esta estrutura semântica um pouco mais específica, definindo o que é o conteúdo de cada elemento. Veja este outro exemplo:
16 |
17 |
18 |
19 |
Adicionamos atributos especias, itemscope e itemprop. Cada elemento itemscope define um item de dados. Cada itemprop define o nome de uma propriedade. O valor da propriedade é o conteúdo da tag HTML. A Microdata API nos fornece acesso especial a esses dados. Veja como acessar esses dados:
No exemplo acima, temos uma listagem de pessoas. Agora imagine que você precise ter, no mesmo documento, uma listagem de pessoas e carros. Poderia escrever assim:
30 |
31 |
32 |
33 |
Note que pessoas e carros tem propriedades em comum, nome e total. Quando você executar document.getItems() vai obter uma lista de todos os elementos com itemscope. Como obter uma lista apenas de pessoas ou de carros? Você pode adicionar a cada item um atributo itemtype, que diz de que tipo de entidade são aqueles dados:
34 |
35 |
36 |
37 |
Agora você pode executar: document.getItems('carro') para obter só os carros, por exemplo.
38 |
39 |
Falando um idioma comum
40 |
41 |
Você deve ter notado que pode definir seus próprios padrões de metadados com microdata. Recomendo que, antes de criar seu próprio formato, verifique se o mesmo problema não já foi resolvido por alguém. O site www.data-vocabulary.org contém alguns desses formatos padronizados. Por exemplo, para descrever os dados de sua empresa ou organização, não invente seu próprio formato, use o formato definido em http://www.data-vocabulary.org/Organization. O valor de itemtype deve ser a própria URL que documenta o formato. Veja como fica:
42 |
43 |
44 |
45 |
Claro que a vantagem de usar o formato padronizado ao invés de inventar o seu não é apenas não ter o trabalho de pensar os nomes das propriedades. Os sistemas de busca, e outros sistemas que acessem seu site, podem entender e tratar esses dados. O Google já faz isso, veja neste endereço:
HTML5 provê uma maneira de se indicar ao navegador que elementos são necessários e devem ser postos em cache para que uma aplicação funcione offline. O exemplo da documentação oficial é bastante esclarecedor. Dê uma olhada na seguinte página:
12 |
13 |
14 |
15 |
Trata-se de um widget de relógio. Para funcionar, este HTML depende dos arquivos "clock.js" e "clock.css". Para permitir que o usuário acesse esta página offile, precisamos escrever um arquivo de manifesto, indicando que URLs devem ser postas em cache. Vamos preparar uma nova versão do widget, contendo o manifesto, que é um arquivo com a extensão .manifest e que deve ser servido com o tipo MIME text/cache-manifest. Em nosso caso, o arquivo vai se chamar clock.manifest e terá o seguinte conteúdo:
Agora veja o HTML com o arquivo de manifesto linkado:
23 |
24 |
25 |
26 |
Note que é recomendado que você insira o próprio HTML principal na lista de URLs do arquivo de manifesto, embora não seja necessário. Ao encontrar uma página com um arquivo de manifesto vinculado, o navegador fará cache das URLs listadas no manifesto e da própria página.
27 |
28 |
Note também que não é necessário que todas as URLs para cache estejam importadas no documnto atual. O arquivo de manifesto pode contar todas as páginas de sua aplicação que forem necessárias para permitir o funcionamento offline, inclusive a navegação entre páginas.
29 |
30 |
O objeto ApplicationCache
31 |
32 |
O objeto ApplicationCache controla o status e operações de caching da página. Ele pode ser acessado via javascript, assim:
33 |
34 |
window.applicationCache
35 |
36 |
Seu método mais interessante é o update(), que faz com que o agente de usuário recarregue o cache da aplicação. Além disso, ele possui a propriedade status, cujo valor numérico pode ser um dos seguintes:
37 |
38 |
39 |
0 - UNCACHED
40 |
Não há um arquivo de manifesto nesta página ou apontando para ela
41 |
1 - IDLE
42 |
O objeto ApplicationCache está ocioso. O cache está atualizado.
43 |
2 CHECKING
44 |
O arquivo de manifesto está sendo baixado e conferido.
45 |
3 - DOWNLOADING
46 |
As URLs vinculadas no manifesto estão sendo baixadas.
47 |
4 - UPDATEREADY
48 |
O cache é antigo, mas ainda não foi marcado como obsoleto.
49 |
5 - OBSOLETE
50 |
O cache foi marcado como obsoleto e precisa ser atualizado assim que possível.
51 |
52 |
53 |
O objeto ApplicationCache também possui os seguintes eventos, relacionados a sua mudança de status:
54 |
55 |
56 |
onchecking
57 |
onerror
58 |
onnoupdate
59 |
ondownloading
60 |
onprogress
61 |
onupdateready
62 |
oncached
63 |
onobsolete
64 |
65 |
66 |
Como você pode ver, além de onerror, temos um evento para cada um dos status da lista acima.
67 |
68 |
Controle de status da aplicação
69 |
70 |
No exemplo do relógio acima não há formulários ou submissões Ajax. O agente de usuários não troca dados com o servidor. Assim é muito fácil fazer sua aplicação rodar offline, mas essa não é a realidade da maioria das aplicações. Vimos no capítulo anterior como fazer armazenamento local de dados. Com isso, você pode armazenar os dados que o navegador deveria enviar para o servidor enquanto a aplicação estiver offline e, tão logo ela esteja online, enviar tudo.
71 |
72 |
Para saber se a aplicação está online, basta acessar a propriedade onLine do objeto window.navigator:
E para disparar o envio quando a aplicação estiver online e avisar o usuário quando ela estiver offline, usamos os eventos ononline e onoffline do objeto window:
O valor default é true. Se você passar false, a rolagem vai deixar o objeto visível na base do viewport.
20 |
21 |
hidden
22 |
23 |
Ocultar e exibir elementos é uma das tarefas mais comuns em Javascript. Em HTML5 existe um atributo específico para isso, o atributo hidden. Ao inserí-lo em um elemento assim:
24 |
25 |
<div hidden>Xi, se esconde!</div>
26 |
27 |
Ou assim:
28 |
29 |
<div hidden="true">Xi, se esconde!</div>
30 |
31 |
O elemento estará oculto.
32 |
33 |
hidden e Javascript
34 |
35 |
Acessar o atributo hidden em Javascript é muito conveniente:
function switchElement(elm){
47 | elm.hidden=!elm.hidden
48 | }
49 |
50 |
Sugiro que você sempre use o atributo hidden. Descobrir se o elemento está oculto lendo as propriedades display e visibility do CSS, além de dar mais trabalho, pode gerar confusão.
51 |
52 |
8 |
9 |
O objeto UndoManager
10 |
11 |
O agente de usuário deve armazenar um histórico de alterações para cada documento carregado. Esse histórico é controlado pelo objeto UndoManager, acessível através de window.undoManager. O histórico guarda dois tipos de alterações:
12 |
13 |
14 |
Alterações DOM
15 |
O próprio histórico de alterações do navegador, as alterações DOM são inseridas automaticamente no histórico quando o usuário usa um campo de edição.
16 |
Objetos undo
17 |
Os objetos undo são inseridos no histórico e controlados pelos seus scripts. Por exemplo, uma aplicação de e-mail pode guardar um objeto undo representando o fato de que o usuário moveu um e-mail de uma pasta para outra.
18 |
19 |
20 |
O objeto UndoManager possui os seguintes métodos e propriedades:
21 |
22 |
23 |
length
24 |
o número de entradas no histórico
25 |
position
26 |
o número da entrada atual no histórico
27 |
add(data,title)
28 |
adiciona uma entrada específica no histório. data pode ser um objeto literal com dados arbitrários. title é como essa entrada vai aparecer descrita na lista do histórico
29 |
remove(index)
30 |
remove uma entrada específica do histórico
31 |
clearUndo()
32 |
remove todas as entradas antes da atual no histórico
33 |
clearRedo()
34 |
remove todas as entradas após a atual no histórico
35 |
36 |
37 |
Além disso, os itens no histórico podem ser acessados com window.undoManager[index].
38 |
39 |
Respondendo às ações de undo e redo
40 |
41 |
Cada vez que o usuário disparar uma ação de undo ou redo, e o item do histórico for um objeto undo, será disparado o evento correspondente, window.onundo ou window.onredo. As funções associadas a estes eventos receberão como parâmetro um objeto event, contendo uma propriedade data, cujo valor é o objeto undo que você inseriu no histórico.
42 |
43 |
Veja o exemplo:
44 |
45 |
window.onundo=function(e){
46 | alert('Refazer a alteração: '+e.data)
47 | }
48 |
49 |
Disparando as ações de undo e redo
50 |
51 |
Se você quiser oferecer em sua aplicação botões para undo e redo, basta que eles executem:
52 |
53 |
document.execCommand('undo')
54 |
55 |
Ou:
56 |
57 |
document.execCommand('redo')
58 |
59 |
8 |
9 |
A estrutura básica do HTML5 continua sendo a mesma das versões anteriores da linguagem, há apenas uma excessão na escrita do Doctype. Segue abaixo como a estrutura básica pode ser seguida:
10 |
11 |
12 |
13 |
O Doctype
14 |
O Doctype deve ser a primeira linha de código do documento antes da tag HTML.
15 |
16 |
<!DOCTYPE html>
17 |
18 |
O Doctype indica para o navegador e para outros meios qual a especificação de código utilizar. Em versões anteriores, era necessário referenciar o DTD diretamente no código do Doctype. Com o HTML5, a referência por qual DTD utilizar é responsabilidade do Browser.
19 |
20 |
21 | O Doctype não é uma tag do HTML, mas uma instrução para que o browser tenha informações sobre qual versão de código a marcação foi escrita.
22 |
23 |
24 |
O elemento HTML
25 |
O código HTML é uma série de elementos em árvore onde alguns elementos são filhos de outros e assim por diante. O elemento principal dessa grande árvore é sempre a tag HTML.
26 |
27 |
<html lang="pt-br">
28 |
29 |
O atributo LANG é necessário para que os user-agents saibam qual a linguagem principal do documento.
30 | Lembre-se que o atributo LANG não é restrito ao elemento HTML, ele pode ser utilizado em qualquer outro elemento para indicar o idioma do texto representado.
A Tag HEAD é onde fica toda a parte inteligente da página. No HEAD ficam os metadados. Metadados são informações sobre a página e o conteúdo ali publicado.
36 |
37 |
Metatag Charset
38 |
No nosso exemplo há uma metatag responsável por chavear qual tabela de caractéres a página está utilizando.
39 |
40 |
<meta charset="utf-8">
41 |
42 |
Nas versões anteriores ao HTML5, essa tag era escrita da forma abaixo:
Essa forma antiga será também suportada no HTML5. Contudo, é melhor que você utilize a nova forma.
47 |
48 |
A Web é acessada por pessoas do mundo inteiro. Ter um sistema ou um site que limite o acesso e pessoas de outros países é algo que vai contra a tradição e os ideais da internet. Por isso, foi criado uma tabela que suprisse essas necessidades, essa tabela se chama Unicode. A tabela Unicode suporta algo em torno de um milhão de caracteres. Ao invés de cada região ter sua tabela de caracteres, é muito mais sensato haver uma tabela padrão com o maior número de caracteres possível. Atualmente a maioria dos sistemas e browsers utilizados por usuários suportam plenamente Unicode. Por isso, fazendo seu sistema Unicode você garante que ele será bem visualizado aqui, na China ou em qualquer outro lugar do mundo.
49 |
O que o Unicode faz é fornecer um único número para cada caractere, não importa a plataforma, nem o programa, nem a língua.
50 |
51 |
Tag LINK
52 |
Há dois tipos de links no HTML: a tag A, que são links que levam o usuário para outros documentos e a tag LINK, que são links para fontes externas que serão usadas no documento.
53 |
54 |
No nosso exemplo há uma tag LINK que importa o CSS para nossa página:
Neste caso, indicamos aos user-agents que o conteúdo do site poder ser encontrado em um caminho alternativo via Atom FEED.
65 |
66 |
No HTML5 há outros links relativos que você pode inserir como o rel="archives" que indica uma referência a uma coleção de material histórico da página. Por exemplo, a página de histórico de um blog pode ser referenciada nesta tag.
67 |
68 |
8 |
9 |
Existiam no HTML alguns elementos que traziam apenas características visuais e não semânticas para o conteúdo da página. Esses elementos anteriormente foram descontinuados porque atrapalhavam o código e também porque sua função era facilmente suprida pelo CSS. Contudo, alguns destes elementos voltaram à tona com novos significados semânticos. Outros elementos que não descontinuados, mas seus significados foram modificados.
10 |
11 |
Elementos modificados
12 |
13 |
O elemento B passa a ter o mesmo nível semântico que um SPAN, mas ainda mantém o estilo de negrito no texto. Contudo, ele não dá nenhuma importância para o text marcado com ele.
14 |
15 |
O elemento I também passa a ser um SPAN. O texto continua sendo itálico e para usuários de leitores de tela, a voz utilizada é modificada para indicar ênfase. Isso pode ser útil para marcar frases em outros idiomas, termos técnicos e etc.
16 |
17 |
18 |
O interessante é que nestes dois casos houve apenas uma mudança semântica. Provavelmente você não precisará modificar códigos onde estes dois elementos são utilizados.
19 |
20 |
21 |
O elemento a sem o atributo href agora representa um placeholder no exato lugar que este link se encontra.
22 |
O elemento address agora é tratado como uma seção no documento.
23 |
O elemento hr agora tem o mesmo nível que um parágrafo, mas é utilizado para quebrar linhas e fazer separações.
24 |
25 |
O elemento strong ganhou mais importância.
26 |
O elemento head não aceita mais elementos child como seu filho.
27 |
28 |
29 |
Elementos ou atributos descontinuados
30 |
Os elementos abaixo foram descontinuados por que seus efeitos são apenas visuais:
31 |
32 |
basefont
33 |
big
34 |
center
35 |
font
36 |
s
37 |
strike
38 |
tt
39 |
u
40 |
41 |
42 |
Os elementos abaixo foram descontinuados por que ferem os princípios de acessibilide e usabilidade:
43 |
44 |
45 |
frame
46 |
frameset
47 |
noframes
48 |
49 |
50 |
Os elementos abaixo não foram incluídos na especificação porque não tiveram uso entre os desenvolvedores ou porque sua função foi substituída por outro elemento:
51 |
52 |
53 |
acronym não foi incluído porque criou um bocado de confusão entre os desenvolvedores que preferiram utilizar a tag abbr.
54 |
applet ficou obsoleto em favor da tag object.
55 |
isindex foi substituído pelo uso de form controls.
56 |
dir ficou obsoleto em favor da tag ul.
57 |
58 |
59 |
8 |
9 |
Novos valores para o atributo type
10 |
11 |
15 |
16 |
O elemento input aceita os seguintes novos valores para o atributo type:
17 |
18 |
tel
19 |
20 |
Telefone. Não há máscara de formatação ou validação, propositalmente, visto não haver no mundo um padrão bem definido para números de telefones. É claro que você pode usar a nova API de validação de formulários (descrita no capítulo 8) para isso. Os agentes de usuário podem permitir a integração com sua agenda de contatos, o que é particularmente útil em telefones celulares.
21 |
22 |
search
23 |
24 |
Um campo de busca. A aparência e comportamento do campo pode mudar ligeiramente dependendo do agente de usuário, para parecer com os demais campos de busca do sistema.
25 |
26 |
email
27 |
28 |
E-mail, com formatação e validação. O agente de usuário pode inclusive promover a integração com sua agenda de contatos.
29 |
30 |
url
31 |
32 |
Um endereço web, também com formatação e validação.
33 |
34 |
Datas e horas
35 |
36 |
40 |
41 |
O campo de formulário pode conter qualquer um desses valores no atributo type:
42 |
43 |
datetime
44 |
date
45 |
month
46 |
week
47 |
time
48 |
datetime-local
49 |
50 |
51 |
Todos devem ser validados e formatados pelo agente de usuário, que pode inclusive mostrar um calendário, um seletor de horário ou outro auxílio ao preenchimento que estiver disponível no sistema do usuário.
52 |
53 |
O atributo adicional step define, para os validadores e auxílios ao preenchimento, a diferença mínima entre dois horários. O valor de step é em segundos, e o valor padrão é 60. Assim, se você usar step="300" o usuário poderá fornecer como horários 7:00, 7:05 e 7:10, mas não 7:02 ou 7:08.
54 |
55 |
number
56 |
57 |
Veja um exemplo do tipo number com seus atributos opcionais:
58 |
59 |
60 |
61 |
O Opera 10 nos dá uma excelente visualização do que um agente de usuário pode fazer nesse caso:
62 |
63 |
64 |
65 |
range
66 |
67 |
Vamos modificar, no exemplo acima, apenas o valor de type, mudando de "number" para "range":
68 |
69 |
70 |
71 |
Novamente, Opera 10:
72 |
73 |
74 |
75 |
color
76 |
77 |
O campo com type="color" é um seletor de cor. O agente de usuário pode mostrar um controle de seleção de cor ou outro auxílio que estiver disponível. O valor será uma cor no formato #ff6600.
78 |
79 |
8 |
9 |
Formulários vitaminados
10 |
11 |
Conforme você deve ter percebido no último capítulo, o HTML5 avançou bastante nos recursos de formulários, facilitando muito a vida de quem precisa desenvolver aplicações web baseadas em formulários. Neste capítulo vamos avançar um pouco mais nesse assunto e, você vai ver, a coisa vai ficar ainda melhor.
12 |
13 |
autofocus
14 |
15 |
Ao incluir em um campo de formulário o atributo autofocus, assim:
16 |
17 |
<input name="login" autofocus >
18 |
19 |
O foco será colocado neste campo automaticamente ao carregar a página. Diferente das soluções em Javascript, o foco estará no campo tão logo ele seja criado, e não apenas ao final do carregamento da página. Isso evita o problema, muito comum quando você muda o foco com Javascript, de o usuário já estar em outro campo, digitando, quando o foco é mudado.
20 |
21 |
Placeholder text
22 |
23 |
Você já deve ter visto um "placeholder". Tradicionalmente, vínhamos fazendo isso:
24 |
25 |
26 |
27 |
HTML5 nos permite fazer isso de maneira muito mais elegante:
28 |
29 |
30 |
31 |
required
32 |
33 |
Para tornar um campo de formulário obrigatório (seu valor precisa ser preenchido) basta, em HTML5, incluir o atributo required:
34 |
35 |
<input name="login" required>
36 |
37 |
maxlength
38 |
39 |
Você já conhecia o atributo maxlength, que limita a quantidade de caracteres em um campo de formulário. Uma grande lacuna dos formulário HTML foi corrigida. Em HTML5, o elemento textarea também pode ter maxlength!
40 |
41 |
Validação de formulários
42 |
43 |
Uma das tarefas mais enfadonhas de se fazer em Javascript é validar formulários. Infelizmente, é também uma das mais comuns. HTML5 facilita muito nossa vida ao validar formulários, tornando automática boa parte do processo. Em muitos casos, todo ele. Você já viu que pode tornar seus campos "espertos" com os novos valores para o atributo type, que já incluem validação para datas, emails, URLs e números. Vamos um pouco além.
44 |
45 |
pattern
46 |
47 |
O atributo pattern nos permite definir expressões regulares de validação, sem Javascript. Veja um exemplo de como validar CEP:
48 |
49 |
50 |
51 |
novalidate e formnovalidate
52 |
53 |
Podem haver situações em que você precisa que um formulário não seja validado. Nestes casos, basta incluir no elemento form o atributo novalidate.
54 |
55 |
Outra situação comum é querer que o formulário não seja validade dependendo da ação de submit. Nesse caso, você pode usar no botão de submit o atributo formnovalidate. Veja um exemplo:
56 |
57 |
58 |
59 |
Custom validators
60 |
61 |
É claro que as validações padrão, embora atendam a maioria dos casos, não são suficientes para todas as situações. Muitas vezes você vai querer escrever sua própria função de validação Javascript. Há alguns detalhes na especificação do HTML5 que vão ajudá-lo com isso:
62 |
63 |
64 |
O novo evento oninput é disparado quando algo é modificado no valor de um campo de formulário. Diferente de onchange, que é disparado ao final da edição, oninput é disparado ao editar. É diferente também de onkeyup e onkeypress, porque vai capturar qualquer modificação no valor do campo, feita com mouse, teclado ou outra interface qualquer.
65 |
O método setCustomValidity pode ser invocado por você. Ele recebe uma string. Se a string for vazia, o campo será marcado como válido. Caso contrário, será marcado como inválido.
66 |
67 |
68 |
Com isso, você pode inserir suas validações no campo de formulário e deixar o navegador fazer o resto. Não é mais preciso capturar o evento submit e tratá-lo. Veja, por exemplo, este formulário com validação de CPF:
69 |
70 |
71 |
72 |
8 |
9 |
Ainda mais formulários
10 |
11 |
Vejamos mais duas coisas que você certamente já fez mais de uma vez e foram simplificadas pelo HTML5.
12 |
13 |
Detalhes e sumário
14 |
15 |
Veja um exemplo de uso dos novos elementos details e summary:
Você pode ler e manipular os elementos editáveis normalmente usando os métodos do DOM. Isso permite, com facilidade, construir uma área de edição de HTML.
48 |
49 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/css/fonts/HelveticaNeueLTStd-Lt.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tableless/guia-html5/249f1234a3757815d4332d3a57e1474dd8be4019/css/fonts/HelveticaNeueLTStd-Lt.otf
--------------------------------------------------------------------------------
/css/fonts/HelveticaNeueLTStd-UltLt.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tableless/guia-html5/249f1234a3757815d4332d3a57e1474dd8be4019/css/fonts/HelveticaNeueLTStd-UltLt.otf
--------------------------------------------------------------------------------
/css/print.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tableless/guia-html5/249f1234a3757815d4332d3a57e1474dd8be4019/css/print.png
--------------------------------------------------------------------------------
/esboco.txt:
--------------------------------------------------------------------------------
1 | Parte 1: Markup
2 |
3 | 1. Visão geral do HTML5. [Diego]
4 | 2. Análise do suporte atual pelos navegadores e estratégias de uso [Diego]
5 | 3. Estrutura básica, DOCTYPE e charsets [Diego]
6 | - não esquecer de falar de:
7 | - text/html-sandboxed
8 | - iframe com sandbox, seamless e srcdoc
9 | 4. Modelos de conteúdo [Diego]
10 | 5. Novos elementos e atributos [Diego]
11 | 6. Elementos modificados e ausentes [Diego]
12 |
13 | Parte 2: Formulários e Multimídia
14 |
15 | 7. Novos tipos de campos
16 | 8. Tipos de dados e validadores
17 | 9. Detalhes, conteúdo editável.
18 | 10. Drag-n-drop e correção ortográfica
19 | 11. Elementos audio e video, e codecs [Diego]
20 | 12. Elemento device e Stream API
21 | - elemento device
22 | - device.onchange
23 | - Stream e StreamRecorder
24 | - Futuro: Peer-to-peer
25 |
26 | Parte 3: A nova geração de aplicações web I
27 |
28 | 13. MathML e SVG
29 | - entendendo mathml e svg
30 | - inserindo mathml e svg no html5
31 | - exemplo de mathml
32 | - exemplo de svg
33 | - onde aprender
34 | 14. Canvas API
35 | - o elemento canvas
36 | - context
37 | - fillRect, strokeRect e clearRect
38 | - beginPath, moveTo, lineTo, closePath
39 | - fill e stroke
40 | - arc
41 | - bezierCurveTo e quadraticCurveTo
42 | - rect
43 | - fillStyle e strokeStyle
44 | - transparência, CSS3 colors e globalAlpha
45 | - lineWidth, lineCap, lineJoin, miterLimit
46 | - Image e drawImage
47 | - Gradientes
48 | - rotate
49 | - Para estudar: patterns, shadows, save e restore, translate, scale, transform, clip
50 | 15. Server-sent events e WebSockets
51 | - o elemento eventsource
52 | - eventos: open, message, error
53 | - WebSockets: send e close
54 | - eventos: open, message, close
55 | - o protocolo
56 | 16. DOM e HTML5
57 | 17. Novos eventos DOM
58 | - contextmenu
59 | - drag, dragend, dragenter, dragleave, dragover, dragstart, drop
60 | - media: loadstart, progress, suspend, abort, error, emptied, stalled, play, pause, loadedmetadata, loadeddata, waiting, playing, canplay, canplaythrough, seeking, seeked, timeupdate, ended, ratechange, durationchange, volumechange
61 | - invalid
62 | - beforeprint, afterprint
63 | - hashchanged, pagehide, pageshow, popstate
64 | - online, offline
65 | - undo, redo
66 | 18. XPath e document.evaluate()
67 | - Por que usar XPath, e não querySelector?
68 | - document.evaluate
69 | - Default namespace: "http://www.w3.org/1999/xhtml"
70 | 19. Menus e toolbars
71 | - menu e command
72 | - menus popup
73 | 20. Tipos de links
74 | - alternate
75 | - archives
76 | - author
77 | - bookmark
78 | - external
79 | - help
80 | - icon
81 | - license
82 | - nofollow
83 | - noreferrer
84 | - pingback
85 | - prefetch
86 | - search
87 | - stylesheet
88 | - sidebar
89 | - tag
90 | - index
91 | - up
92 | - first
93 | - last
94 | - next
95 | - prev
96 | Parte 4: A nova geração de aplicações web II
97 | 21. Microdata
98 | - itemscope e itemprop
99 | - imagens
100 | - itemref
101 | - itemtype
102 | - itemid
103 | - microdata API (document.getItems e cat.properties[key].values)
104 | 22. Histórico de sessão e API Storage
105 | - Já escrito
106 | 23. Aplicações offline
107 | - client-side database
108 | - controle de cache com manifest
109 | - atributo onLine em navigator e eventos online e offline
110 | 24. Modal dialogs
111 | - showModalDialogs
112 | - passando argumentos para a modal
113 | - recebendo um valor de retorno
114 | - registerContentHandler
115 | 25. Scroll in to view
116 | 26. Drag and Drop API
117 | 27. Interfaces de edição e UndoManager
118 | 28. Comunicação entre documentos
119 |
120 |
--------------------------------------------------------------------------------
/exemplos/10/drag.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | HTML5 Drag and drop demonstration
6 |
19 |
40 |
41 |
42 |
43 |
