Menu Retrátil com CSS e jQuery

menuretratilcssjquery

Navegação para design responsivo sem complicações em quatro sabores diferentes.

Neste artigo vamos criar passo-a-passo um menu retrátil super versátil que, com apenas algumas linhas de modificação, poderá ser utilizado na horizontal, vertical, sobrepondo ou empurrando o conteúdo de um site. Veja ainda como evitar os malditos bugs problemas mais comuns deste tipo de navegação.

MINI BIBLIOTECAS

Uma das principais vantagens de escrever um HTML semântico e bem organizado é a versatilidade. Com um mesmo código é possível criar diversas variações de estilo utilizando apenas CSS. Na verdade muitas estruturas acabam se repetindo, embora visualmente diferentes. Isto acontece geralmente com formulários, rodapés e navegação. É o motivo pelo qual os frameworks estão tão populares ultimamente. Mas, muitas vezes, não precisamos de algo tão massivo e complexo quanto uma framework para tarefas simples. É algo como tentar acertar uma formiga com uma bazuca! É muito mais prático e funcional construir uma pequena biblioteca pessoal de snippets – pequenos trechos de código. O formato não importa muito. Pode ser que você salve comentários no seu software de edição favorito, escreva em pequenos blocos de notas no seu computador, envie e-mails para si mesmo ou até mesmo utilize alguma ferramenta como Snippets.me  ouSnippi. Seja como for ter algumas cartas na manga é útil na hora de entregar aquele projeto para ontem e recuperar horas de sono. Este menu é uma das minhas.

HTML

O HTML do menu é bem simples. Vamos usar uma div com a classe “drop”. Esta div será necessária para as versões do menu em que ele irá sobrepor o site. Ela irá funcionar como uma sustentação para a navegação. Nas demais versões, ela pode ser deletada.

Dentro da div “drop” criamos uma nav e, como um menu é sempre uma lista de links, vamos usar as tags ul eli.

No exemplo, o meu menu ocupa 100% da tela mas eu gostaria que os links ficassem dentro de um container centralizado. Para isso, adicionei uma div com a classe wrap e margin automática.

No final, o HTML ficou assim:

  1. <div class=”drop”>
  2. <nav class=”nav nav-aberta”>
  3. <div class=”wrap”>
  4. <ul class=”listaNav”>
  5. <li><a href=”#”>Item 1</a></li>
  6. <li><a href=”#”>Item 2</a></li>
  7. <li><a href=”#”>Item 3</a></li>
  8. <li><a href=”#”>Item 4</a></li>
  9. <li><a href=”#”>Item 5</a></li>
  10. <li><a href=”#”>Item 6</a></li>
  11. <li><a href=”#”>Item 7</a></li>
  12. <li><a href=”#”>Item 8</a></li>
  13. <li><a href=”#”>Item 9</a></li>
  14. </ul>
  15. </div>
  16. </nav>
  17. </div>

Para ter um elemento servindo de exemplo visual e ser sobreposto ou empurrado pelo meu menu, coloquei apenas uma imagem. Mas, pense nela como todo o conteúdo do site, okay?

  1. <img alt=”" src=”http://placehold.it/1920×800/&text=Conteúdo” />

Hoje vamos criar quatro menus utilizando este mesmo html como um coringa.

O CSS

Aqui já começamos a ter diferenças de um menu para o outro. Trabalharemos com media-queries que reordenarão os elementos de acordo com o tamanho do viewport do usuário, ou seja, da janela do browser. Para o exemplo, criei um media-querie com a max-width de 800px. É a partir desta largura que o menu se colapsa em apenas uma âncora. Altere este valor de acordo com o seu projeto, é claro.

MENUS HORIZONTAIS

Hoje vamos desenvolver dois tipos de menus horizontais diferentes. Um empurrará todo o site para baixo ao abrir (demo).

nav-1

E o outro, se abrirá sobre o site (demo).

nav-2

Note que entre os dois htmls existe apenas uma classe diferente: a div “drop”. Esta divisão extra está apenas no segundo exemplo no menu que passa por cima do conteúdo do site. Ela terá uma altura fixa, que será a altura do meu menu quando fechado. Quando ele se abrir, a div que sustenta nosso menu continuará do mesmo tamanho, fazendo com que os demais elementos sobreponham o resto do site.

Primeiro, vamos ao CSS dele fechado. Como é só uma lista, eu apenas usei o parâmetro “inline-block” para que todos os itens se alinhem um ao lado do outro. Os demais parâmetros, são apenas estilização do menu. Não coloquei muitas coisas em termos visuais. Não é para ser bonito. A idéia é ter uma carcaça pronta para receber o SEU design. Eu coloquei na minha nav uma “position: fixed” para que o menu fique sempre à vista do usuário, e de fácil acesso. Mas, você não terá problemas se quiser trabalhar com uma posição relativa ou absoluta. Isso irá variar de acordo com o seu projeto.

Outra coisa importante é o parâmetro “nav-toggle”. Ele será o gatilho para abrir e fechar o meu menu, tanto em sua versão vertical quanto na horizontal. Ele é inserido no meu HTML dinamicamente via JavaScript. No entanto, eu não quero que ele apareça quando estiver em resoluções maiores que 800px, por isso coloquei nele um “display: none” e, dentro do media-querie que irá atender viewports menores que 800px ele tem o “display: block”.

Veja como ficou o CSS do menu na horizontal que empurrará o site para baixo:

  1. .wrap {
  2. max-width: 1200px;
  3. margin: 0 auto;
  4. }
  5. .nav {
  6. background: #FFF;
  7. z-index: 200;
  8. position: fixed;
  9. width: 100%;
  10. font-size: 1em;
  11. overflow: auto;
  12. }
  13. .nav ul {
  14. padding: 1em;
  15. }
  16. li {
  17. display: inline-block;
  18. margin-right: 2em;
  19. }
  20. a {
  21. text-decoration: none;
  22. color: #444;
  23. }
  24. a:hover {
  25. color: red;
  26. }
  27. .nav-toggle {
  28. display: none;
  29. }
  30. .foto {
  31. width: 100%;
  32. }
  33. /*Media Queries*/
  34. @media only screen and (max-width: 800px) {
  35. .wrap {
  36. max-width: 100%;
  37. margin: 0;
  38. }
  39. .nav.nav-aberta {
  40. position: relative;
  41. padding: 0 0 0.5em 0;
  42. height: 0;
  43. }
  44. .nav ul {
  45. padding: .5em;
  46. margin: 0;
  47. background: #444;
  48. }
  49. li {
  50. margin: 0;
  51. padding: 0;
  52. display: block;
  53. border-bottom: 1px solid #FFF;
  54. }
  55. li a {
  56. padding: 0.5em 0 0.5em 0;
  57. display: block;
  58. color: #FFF;
  59. }
  60. li:last-child {
  61. border-bottom:none;
  62. }
  63. .nav-toggle {
  64. display: block;
  65. padding: .4em;
  66. margin: .5em 0;
  67. }
  68. }

As principais mudanças para telas menores são o .nav-toggle que agora é visível nas versões menores que 800px, a lista que deixa de ser “inline-block” para ser apenas “block” e a .nav, que antes tinha a posição fixa e agora é relativa.

Na versão em que o menu irá passar por cima do site, defina uma altura para a classe .drop no media querie equivalente ao menu fechado, posição relativa e o z-index maior que os outros elementos para que ele possa se sobrepor. Veja o código:

  1. .drop {
  2. height: 48px;
  3. position: relative;
  4. z-index: 1000;
  5. }

Uma maneira interessante de testar o menu funcionando antes de aplicar o JavaScript é modificar a altura da .nav para “auto” ou a altura que você quer que o seu menu tenha quando estiver aberto. Isso fará com que, ao redimensionar o seu browser, o menu apareça como se estivesse aberto. No entanto, para o nosso exemplo, vamos usar a altura 0.

MENUS VERTICAIS

 

menu-lateral

São dois os modelos de menu vertical:
Um abrirá a partir da esquerda empurrando todo o site para a direita ao abrir (demo).

nav-3

E o outro, se abrirá sobre o conteúdo (demo).

nav-4

Primeiro, vamos ao CSS do menu quando o viewport for maior que 800px. Neste exemplo, deixei o menu em um background escuro e ocupando 20% do viewport. Assim, o conteúdo, ocupará os 80% restantes. Como os itens da minha lista não ficarão mais uns aos lados dos outros, neste caso eu a mantive o display “block” desde o CSS desktop. E, também deixei o gatilho com “display:none” e a minha imagem com 80% de largura.

Quanto ao CSS para telas menores o primeiro ponto é que, neste exemplo, trabalharemos com uma largura fixa para o menu. Deixei o padrão de 175px de largura. Usei esta medida pela segurança de não ficar muito grande em smartphones, já que o tamanho mais comum é de 320px de largura com ele em pé, 175px é uma medida segura para trabalharmos.

Minha sidebar terá também a posição absoluta no exemplo. Isso serve para que ela possa “passar por cima” do conteúdo do site sem problemas. Na versão em que o site irá caminhar para o lado, faremos isso pelo JS.

E, não podemos esquecer, do gatilho que irá ativar o nosso menu. Assim como no exemplo anterior, usei um item de classe .nav-toggle que será adicionado dinamicamente pelo Javascript. Deixei ele com o display:none fora do media-query e ele irá ter a posição absoluta quando o viewport for menor que 800px. Deixei o topo dele em 0 e ele será alinhado à partir da borda direita dele. Usei, neste caso, um valo negativo. Assim, ele ficará visível quando o meu menu estiver fechado, para ser clicado e, ao abrir, caminhará junto com o meu menu para ser clicado novamente e fecha-lo.

  1. .wrap {
  2. max-width: 1200px;
  3. margin: 0 auto;
  4. }
  5. .nav {
  6. background: #FFF;
  7. z-index: 200;
  8. position: relative;
  9. width: 20%;
  10. font-size: 1em;
  11. float: left;
  12. background: #444;
  13. }
  14. .nav ul {
  15. padding: 1em;
  16. }
  17. li {
  18. display: block;
  19. width: 100%;
  20. margin: 1em 2em 1em 0;
  21. }
  22. a {
  23. text-decoration: none;
  24. color: #FFF;
  25. }
  26. a:hover {
  27. color: red;
  28. }
  29. .nav-toggle {
  30. display: none;
  31. }
  32. .foto {
  33. width: 80%;
  34. float: right;
  35. }
  36. /*Media Queries*/
  37. @media only screen and (max-width: 800px) {
  38. .wrap {
  39. max-width: 100%;
  40. margin: 0;
  41. }
  42. .nav {
  43. width: 175px;
  44. position: absolute;
  45. top: 0;
  46. left: 0;
  47. }
  48. .nav ul {
  49. padding: .5em;
  50. margin: 0;
  51. background: #444;
  52. }
  53. li {
  54. margin: 0;
  55. padding: 0;
  56. display: block;
  57. }
  58. li a {
  59. padding: 0.5em 0 0.5em 0;
  60. display: block;
  61. color: #FFF;
  62. }
  63. .nav-toggle {
  64. position: absolute;
  65. top: 0;
  66. right: -56px;
  67. color: #FFF;
  68. cursor: pointer;
  69. width: 44px;
  70. height: 24px;
  71. z-index: 1000;
  72. display: block;
  73. background: #444;
  74. padding: 12px 6px 6px 6px;
  75. }
  76. .foto {
  77. width: 100%;
  78. position: relative;
  79. float: none;
  80. }
  81. }

JAVASCRIPT

Como o nosso código utiliza jQuery a primeira coisa a fazer é chamar a biblioteca.

  1. <script src=”//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js”></script>
  2. <script>window.jQuery || document.write(‘<script src=”js/vendor/jquery-1.9.1.min.js”><\/script>’)</script>

Menus na Horizontal

Para os dois casos do menu na horizontal, tanto o que empurra quanto o que sobrepõe o site, usei exatamente o mesmo JS. O que irá garantir que ele irá sobrepor o site é a classe .drop . Quando ela estiver com uma altura definida, ela será como um suporte para o menu e fará com que tudo passe por cima dos outros objetos do site. Quando ela não existir, ou não estiver com uma altura definida ela irá aumentar de tamanho, empurrando os demais elementos para baixo.

A primeira coisa a fazer é utilizar addClass para colocar a classe “fechada” no menu. Esta classe será retirada quando o menu for aberto e irá aparecer quando ele fechar novamente. Servirá como um elemento para indicar ao meu JS o que irá fazer.

Em seguida, utilize o comando de jQuery after para adicionar o gatilho para o menu. Caso queira que ele fique antes do menu, você pode substituir o “after” por “before”.

A animação acontece através dos eventos “click” e “animate”.

O JavaScript fica assim:

  1. $(“.nav”).addClass(“fechada”);
  2. $(“.nav”).after(“<a class=\”nav-toggle\”>Menu</a>”);
  3. $(“.nav-toggle”).click(function() {
  4. var altura = $(“.nav ul”).height();
  5. if($(“.nav”).hasClass(“fechada”)) {
  6. $(“.nav”).animate({height:altura},{queue:false, duration:200}).removeClass(“fechada”);
  7. }
  8. else {
  9. $(“.nav”).animate({height:”0px”},{queue:false, duration:200}).addClass(“fechada”);
  10. }
  11. });

A mágica é a seguinte: quando o usuário clica no gatilho do menu (no caso, o .nav-toggle), ele pega a altura da minha lista de links. Depois, ele faz uma verificação na minha .nav . Se ela possuir a classe “fechada”, ela irá animar aumentando a altura dela e mostrando o menu. Caso esta classe não exista, ele diminui a altura escondendo o menu. Tudo isso na velocidade de 200 milisegundos.

Escolhi este método por uma questão de praticidade. Existem outras maneiras de realizar o mesmo processo. Ao invés de adicionar uma classe, é possível, por exemplo, verificar a altura da .nav. Se for maior que 0px, significa que ela estava aberta e, ao clicar, será fechada. Se for igual a 0, é porque ela está fechada e precisará ser aberta.

E UMA DICA!

Para finalizar, vamos nos livrar de um bug chato que normalmente acontece: ao aumentar a tela para os valores maiores que o nosso media querie (no caso, 800px), o menu poderá ficar com a altura que ele estava quando aberto, e isso obviamente desalinha todo o layout.

Resolver isso é bem fácil. Podemos fazer com que o nosso JS verifique, ao redimensionar a janela, qual é o tamanho do viewport. Se for maior que 800, ele volta a altura que deveria ter originalmente. Se for menor, ele simplesmente se fecha ou mantém a altura que estava quando aberta. No exemplo, eu fiz com que ele se fechasse. Veja como ficou o JS inteiro:

  1. $(“.nav”).addClass(“fechada”);
  2. $(“.nav”).after(“<a class=\”nav-toggle\”>Menu</a>”);
  3. $(“.nav-toggle”).click(function() {
  4. var altura = $(“.nav ul”).height();
  5. if($(“.nav”).hasClass(“fechada”)) {
  6. $(“.nav”).animate({height:altura},{queue:false, duration:200}).removeClass(“fechada”);
  7. }
  8. else {
  9. $(“.nav”).animate({height:”0px”},{queue:false, duration:200}).addClass(“fechada”);
  10. }
  11. });
  12. $(window).resize(function() {
  13. var tamanhoViewport = $(window).width();
  14. if (tamanhoViewport > 800) {
  15. $(“.nav”).css(“height”,”auto”).addClass(“fechada”);
  16. } else {
  17. $(“.nav”).css(“height”,”0px”).addClass(“fechada”);
  18. }
  19. });

Menu Vertical

Neste caso, a verificação da largura do viewport acontece em dois momentos. Uma quando o usuário redimensionar o browser e outra no momento que o documento é aberto. Em ambos, a condição é a mesma: se o tamanho da janela for menor que 800px, ele adiciona a classe “side-fechado”, o gatilho “nav-toggle” que irá animar o menu e colocar a posição dele como -175px à esquerda, o que garante que o menu ficará fechado logo após o usuário redimensionar o browser. Se for maior que 800px a posição à esquerda fica 0.

(Lembrando que estas medidas de largura são subjetivas e devem ser alteradas a cada projeto.)

O JS ficou assim:

  1. //Menu Sidebar
  2. $(window).resize(function() {
  3. var tamanhoJanela = $(window).width();
  4. $(“.nav-toggle”).remove();
  5. if (tamanhoJanela < 800) {
  6. $(‘.nav’).css(‘left’, ‘-175px’).addClass(‘side-fechado’);
  7. $(‘.nav’).append( “<div class=’nav-toggle’>Menu</div>” );
  8. $(‘.foto’).css(“left”, 0);
  9. } else {
  10. $(‘.nav’).css(‘left’, ’0px’).addClass(‘side-fechado’);
  11. }
  12. });
  13. $(document).ready(function() {
  14. var tamanhoJanela = $(window).width();
  15. $(“.nav-toggle”).remove();
  16. if (tamanhoJanela < 800) {
  17. $(‘.nav’).css(‘left’, ‘-175px’).addClass(‘side-fechado’);;
  18. $(‘.nav’).append( “<div class=’nav-toggle’>Menu</div>” );
  19. } else {
  20. $(‘.nav’).css(‘left’, ’0px’).addClass(‘side-fechado’);
  21. }
  22. });

Para animar o menu, vamos criar uma função de nome “menu”. Nesta função, ao clicar no gatilho “.nav-toggle”, acontecem duas coisas: verificação da existência da classe “side-fechado” e animação do menu. Se possuir, o JavaScript anima a navegação para 0px da borda esquerda do menu. Caso não possua (o que indica para nós que o menu está aberto) a navegação volta para os -175px negativos.

O JS fica assim:

  1. function menu() {
  2. $(‘.nav-toggle’).click(function() {
  3. if($(“.nav”).hasClass(“side-fechado”)) {
  4. $(‘.nav’).animate({
  5. left: “0px”,
  6. }, 100, function() {
  7. $(“.nav”).removeClass(“side-fechado”);
  8. });
  9. }
  10. else {
  11. $(‘.nav’).animate({
  12. left: “-175px”,
  13. }, 100, function() {
  14. $(“.nav”).addClass(“side-fechado”);
  15. });
  16. }
  17. });
  18. }

Neste exemplo, ele está sobrepondo o conteúdo do site. Mas, eu posso fazer com que ele empurre o site para a direita quando surgir e para a esquerda quando fechar. Para isso, eu coloco um animate no conteúdo do site também (no exemplo, o meu objeto de classe “.foto”). O JS fica assim:

  1. function menu() {
  2. $(‘.nav-toggle’).click(function() {
  3. if($(“.nav”).hasClass(“side-fechado”)) {
  4. $(‘.nav’).animate({
  5. left: “0px”,
  6. }, 100, function() {
  7. $(“.nav”).removeClass(“side-fechado”);
  8. });
  9. $(‘.foto’).animate({
  10. left: “175px”,
  11. }, 100);
  12. }
  13. else {
  14. $(‘.nav’).animate({
  15. left: “-175px”,
  16. }, 100, function() {
  17. $(“.nav”).addClass(“side-fechado”);
  18. });
  19. $(‘.foto’).animate({
  20. left: “0px”,
  21. }, 100);
  22. }
  23. });
  24. }

Agora, é só chamar a função “menu” depois das verificações de tamanho da janela. O JS completo fica assim:

  1. function menu() {
  2. $(‘.nav-toggle’).click(function() {
  3. if($(“.nav”).hasClass(“side-fechado”)) {
  4. $(‘.nav’).animate({
  5. left: “0px”,
  6. }, 100, function() {
  7. $(“.nav”).removeClass(“side-fechado”);
  8. });
  9. $(‘.foto’).animate({
  10. left: “175px”,
  11. }, 100);
  12. }
  13. else {
  14. $(‘.nav’).animate({
  15. left: “-175px”,
  16. }, 100, function() {
  17. $(“.nav”).addClass(“side-fechado”);
  18. });
  19. $(‘.foto’).animate({
  20. left: “0px”,
  21. }, 100);
  22. }
  23. });
  24. }
  25. //Menu Sidebar
  26. $(window).resize(function() {
  27. var tamanhoJanela = $(window).width();
  28. $(“.nav-toggle”).remove();
  29. if (tamanhoJanela < 800) {
  30. $(‘.nav’).css(‘left’, ‘-175px’).addClass(‘side-fechado’);
  31. $(‘.nav’).append( “<div class=’nav-toggle’>Menu</div>” );
  32. $(‘.foto’).css(“left”, 0);
  33. } else {
  34. $(‘.nav’).css(‘left’, ’0px’).addClass(‘side-fechado’);
  35. }
  36. menu();
  37. });
  38. $(document).ready(function() {
  39. var tamanhoJanela = $(window).width();
  40. $(“.nav-toggle”).remove();
  41. if (tamanhoJanela < 800) {
  42. $(‘.nav’).css(‘left’, ‘-175px’).addClass(‘side-fechado’);;
  43. $(‘.nav’).append( “<div class=’nav-toggle’>Menu</div>” );
  44. } else {
  45. $(‘.nav’).css(‘left’, ’0px’).addClass(‘side-fechado’);
  46. }
  47. menu();
  48. });

DEMOS

Você pode fazer aqui o download dos arquivos com os exemplos criados ou brincar com as demos online no Codepen.

Navegação 1 – Menu horizontal empurrando o conteúdo para baixo.
Navegação 2 – Menu horizontal passando sobre o conteúdo.
Navegação 3 – Menu lateral empurrando o conteúdo para o lado.
Navegação 4 – Menu lateral passando sobre o conteúdo.

CONCLUSÃO

A navegação é sempre uma parte fundamental de qualquer layout. Cuidar para que ela apareça da maneira mais otimizada possível, não apenas em aparelhos mobile, mais em dispositivos com o viewport reduzido não é mais um luxo, mas uma necessidade. Existem algumas outras abordagens até mesmo utilizando apenas CSS3. É importante conhecer diversas soluções para adequar as necessidades de cada projeto. Reaproveitando trechos de código como este podemos garantir que o processo de desenvolvimento seja ágil e preciso, sem sacrificar qualidade, semântica e a experiência do usuário.

Fonte: Tableless

Postagens Relacionadas