O que é o X ?
O X window é um conjunto de protocolos e funções de comunicação utilizados para construir as primitivas gráficas, em sistema de janelas; como pontos, linhas e retângulos, e interface com hardware gráfico e entrada de dados (mouse, teclado). Praticamente tudo que você vê em um ambiente gráfico do GNU/Linux, FreeBSD, OpenBSD, NetBSD, Solaris e outros - Irei generalizar tudo como Linux - partiu de uma solicitação de uma aplicação ou biblioteca para o X.
O X foi criado desde sua base para suportar gráficos em rede. Os programas ou aplicações são conhecidos como clientes. Os clientes não desenham ou manipulam os gráficos direto em seu exibidor, mas se comunicam com seu servidor X para que esses manipulem o seu exibidor.
A confusão se dá basicamente por dois motivos:
* Normalmente os usuários caseiros executam o servidor e o cliente X na mesma máquina, passando a falsa sensação de que o exibidor é controlado pela aplicação que está sendo executada. Porém é possível executar vários servidores X em um único computador e os clientes de computadores remotos. Isso significa que ele pode ser acessado por vários tipos de rede ou através de uma linha dial-up.
* Outro motivo é que a idéia de quem é o cliente e quem é o servidor aparenta estar invertida neste caso. Se interajo com uma aplicação rodando remotamente, vou supor que sou o cliente e a outra máquina o servidor. Mas no caso do X, minha máquina será o servidor para a aplicação remota, pois esta enviará os pedidos (desenhe uma janela, um ícone, etc) para o servidor X rodando na minha máquina, que por sua vez exibirá na minha tela as solicitações da aplicação cliente X, e enviará para mesma a movimentação do mouse e entradas do teclado relevantes.
Você não deve se referir ao X Window como X Windows, os termos apropriados são X, X11, X versão 11 ou sistema X Window versão 11.
O X Foi desenvolvido de início no Instituto de Tecnologia de Massachussets no início dos anos 80. O primeiro lançamento oficial foi o X 10 no meado da década de 80 com lançamento do X11R1 em 1987. Com o fim de sua associação criadora o X passou a ser de propriedade da organização não-comercial X.org, cujos membros executivos incluem a Compaq, HP, IBM, Sun, SGI etc - que mantiveram o modelo original inalterado.
A evolução do X
Um sistema X Window muito utilizado nas distribuições Linux é a coleção de programas do Projeto XFree86 que é baseado na X11R6.4 ou X11, revisão 6.4.
O XFree86 é resultado do trabalho de vários programadores do Open Source e desenvolvedores ao redor do mundo. Uma das vantagens do XFree86 é que a maioria, senão todo o código fonte para os servidores, clientes, módulos, bibliotecas está disponível. Todavia o XFree86 não é distribuído sob a licença GLP, ele é protegido por um tipo de licença BSD de direito autoral, nem todo o código fonte tem que ser fornecido e os vendedores podem fazer melhorias porém distribuir apenas versões em binário.
O XFree86 funciona em uma quantidade bastante vasta de chips de vídeo, placas gráficas e sistemas para notebook, incluindo hardware não Intel. Porém, se você tiver uma necessidade especial ou o XFree86 não funcionar adequadamente, você pode usar fontes alternativas.
Posteriormente, a versão XFree86 da X.Org, baseado no X11R6.4 incluíram algumas melhorias como exibidores multi-head (XINERMA), recursos de configuração mais simples, Display Power Management Signal (DPMS) para economizar energia dos monitores, exigência de memória reduzida, APIs, novas placas gráficas suporte DRI para gráficos 3D etc.
As novas distribuições vem disponibilizando como X Window o XOrg e não mais o XFree86. O XOrg é um fork no projeto Xfree a partir da versão 4.4 Rc2. Essa mudança originou-se por causa da licença do Xfree4.4 final que impunha cláusulas de propaganda.
Basicamente, como o xfree é open source, ex-programadores do xfree, insatisfeitos com o desenvolvimento do mesmo, resolveram fazer um novo projeto baseado no xfree. Como o xfree mudou a sua licença, onde cada distro que a utilizasse ficaria obrigada a mencionar o uso do xfree em sua licença principal, algumas distros resolveram mudar para a XOrg, que utiliza a licença GNU/GPL tradicional.
Entendendo o X
Antes de continuarmos vamos analisar a estrutura típica do Linux.
Cada camada recebe solicitações da camada superior e faz suas solicitações as camadas inferiores. Contudo as camadas não são obrigadas a fazer solicitações as camadas imediatamente inferiores, as solicitações podem pular camadas e fazer solicitações a camadas ainda mais abaixas. As camadas inferiores, assim, não tem consciência de quem está acima. Acima de tudo está o usuário que ao interagir com as aplicações não precisam saber se estão manipulando o Kernel, ferramentas, ambiente gráfico ou seja lá o que venham a inventar.
Esse tipo de estrutura é bem flexível, pois, podemos trocar qualquer componente de uma camada por outro compatível que continua tudo a funcionar normalmente. Lembrando que o padrão seguido pelos Linux POSIX, que estabelece compatibilidade em nível de código fonte, e recompilações seriam necessárias, possivelmente em outras camadas além da que estivesse sendo substituída. Isso é exatamente o que chamamos de arquitetura modular.
A vantagem desse tipo de arquitetura é exemplificado com o caso do servidor XFree86, que devido à uma mudança no licenciamento e outros problemas, já citados, fizeram com que a maioria dos desenvolvedores saíssem do projeto com o código anterior a mudança da licença e criassem o X.Org, gerido pela X.Org. Hoje em dia X.Org avança muito mais rápido que o XFree86 e é o padrão da maioria das distribuições, enquanto isso o XFree86 agoniza lentamente. A substituição não foi tecnicamente problemática pois os clientes continuavam fazendo suas solicitações via o protocolo X11.
O funcionamento do X
Como já mencionado, no X o servidor e cliente se comunicam via protocolo X11. O servidor desenha as informações no exibidor e repassam as informações recolhidas, como clique do mouse, ao cliente. Este por sua vez processa as informações recebidas e requisita ao servidor para que o resultado seja mostrado no exibidor. Veja a estrutura:
Com isso podemos:
Executar o X11 via SSH:
$ ssh login@servidor -X
Usando o parâmetro X no ssh habilitamos o modo X11 porém por uma solicitação criptografada.
Multihead:
O Incrível Computador de Duas Cabeças.
Com dois ou mais monitores e placas de vídeo, na quantidade certa, podemos ter o resultado de uma aplicação executada em um cliente X mostrada de forma "configurável" em todos os monitores. Esse recurso é conhecido como Xinerama.
Múltiplos Servidores X:
Podemos rodar mais de um servidor X na mesma máquina. Essa forma é facilmente observada nas distribuições mais novas quando fazemos uso da opção "Logar como outro usuário". Neste caso, um novo servidor X é executado e sem deslogar o anterior ficando possível alternar entre os servidores.
Podemos ainda ter servidores X dentro de outro servidor X, é o que se chama servidor aninhado.
Controladores de janelas x Ambiente desktop
Até o momento, estivemos tratando o ambiente gráfico do Linux como se fosse apenas o servidor X, mas na realidade o ambiente gráfico como conhecemos se divide em mais duas camadas, o Controlador de Janelas e o Ambiente Desktop.
Atualmente, estamos acostumados com um padrão gráfico, ou melhor, um paradigma gráfico, que foi desenvolvido pela Xerox e que obteve muito sucesso, sendo copiado pela maioria, senão por todos os ambientes Desktops encontrados, o WIMP - Window, Icon, Menu, Pointing device (Janela, Ícone, Menu, Dispositivo de apontador).
No Linux:
* o Servidor X cuida apenas do Dispositivo de apontador, do WIMP ( além do vídeo, teclado e mouse).
* o Gerenciador de Janelas cuida de toda a lógica referente a janela, como: arrastar, redimensionar, minimizar, não deixar redimensionar bordas fixas etc.
* o Ambiente Desktop, por sua vez abstrai, através de ícones e Menus.
Para ilustrarmos o funcionamento das três camadas, vamos imaginar a execução de um programa através de dois cliques dado no ícone.
O Servidor X captura os cliques e passa adiante, para quem for responsável, isso não o importa para ele. Neste caso o responsável foi o Ambiente Desktop que abstraiu a execução da aplicação em um ícone, ele então, entende o clique realiza a execução da aplicação, porém a solicitação de execução da aplicação poderia ser feita por uma linha de comando no shell. Ao criar a janela, o gerenciador de janelas passa a gerenciá-la. Nem a aplicação, nem o Servidor X querem saber quem vai tratar o gerenciamento da janela, nem se alguém vai tratar. A aplicação estará preocupada com o que ela se destina a fazer, já o Servidor X está preocupado em desenhar na tela, onde pedirem.
Logo, quando a janela é arrastada, o Gerenciador de Janelas solicita ao Servidor X que redesenhe a janela em várias posições diferentes, apagando sempre o desenho anterior, dando a sensação de movimento. Porém, o Gerenciador de Janelas poderia pedir que ao X que desenhasse apenas quando chegasse ao destino, ou poderia não ter gerenciador de janela, fazendo com que a janela não pudesse ser movida.
Um gerenciador de janelas, normalmente, não oferece abstração para ícones e menus, eles esperam que o Ambiente Desktop faça esse trabalho, porém nada impede que sejam criados Gerenciadores de Janelas como o Fluxbox e Enlightenment, que foram feitos para não necessitarem de nenhum componente superior.
As imagens abaixo mostram a Ambiente Desktop GNOME, que veremos mais tarde, exibindo uma janela do Iceweasel.
Na primeira imagem o Gerenciador de Janelas metacity está em execução. Note que a janela apresenta a barra de título, os botões de controle, bordas etc. Todas estas funcionalidades existem pois o metacity está controlando-as.
Na segunda imagem temos o mesmo ambiente, porém o processo do metacity foi destruído, logo, não há mais um Gerenciador de Janelas sendo executado. Note que todas as funcionalidades referentes ao Gerenciador de Janelas deixou de existir.
Em ambos os casos, o Servidor X, neste caso o Xorg, e o ambiente Desktop, o GNOME, estão em execução.
Como foi mostrado, o Ambiente Desktop é algo bastante abstrato. Ele é formado por um conjunto de bibliotecas, serviços muito bem integrados e disponibilizado de forma agradável para utilização dos usuários. Porém, isso tem um custo. O desempenho da máquina é diminuindo de forma sensível. Isso faz com que usuários mais hardcore prefiram usar Gerenciadores de Janelas como, os já citados, Fluxbox e Enlightenment.
Os GNOME, KDE, XFCE, XPde, WindowMaker e IceWM são exemplos de Ambiente Desktop bastante usado no Linux. O XFCE, por exemplo, embora seja bem modesto, também é muito leve, contudo, traz muito mais funcionalidade que qualquer Gerenciador de Janelas, isso o torna uma opção bastante interessante para usuários de máquinas mais modestas.
Recentemente a Novell liberou o servidor XGL que usa a aceleração 3D da placa de vídeo para fazer efeitos maravilhosos. Graças a essa independência dos pacotes, esses efeitos podem ser vistos em qualquer Desktop (GNOME, KDE, XFCE, XPde, WindowMaker, IceWM etc) e qualquer Gerenciador de Janelas (metacity, fluxbox, enlightenment etc), pois o XGL é um Servidor X (que segue o padrão X11), logo ele é transparente as camadas superiores. Além do XGL, existe também o AIGLX da X.Org.
Percebam a modularização, essa independência das camadas do "Linux" (aqui entre aspas pois me refiro ao Linux de uma forma mais abrangente ainda do que vinha tratando) é um dos motivos que levam cada dia mais o "Linux" ganhar não usuários, mas amantes.
Brincado com as camadas
Veremos, praticando, o funcionamento das três camadas vistas neste artigo. Para isso, será usada a instalação Desktop básica de uma distribuição Debian, os testes poderão ser feitos usando o Ambiente Gráfico de qualquer distribuição, levando em consideração - é claro - suas diferenças.
De todas as três camadas; Servidor X, Gerenciador de Janelas e Ambiente Desktop; o único processo que não será parado é o Servidor X, pois se este for destruído, torna-se impossível utilizarmos a parte gráfica da distribuição.
Nestes exemplos usaremos o XOrg como Servidor X, o metacity como Gerenciador de Janelas e o GNOME como Ambiente Desktop.
Você poderá instalá-los usando (para usuários do Debian):
# apt-get install xorg metacity gnome
Na seção de login, use a seção Terminal de segurança, abrirá um terminal em um ambiente gráfico. Neste momento, apenas o XOrg (servidor X) estará rodando.
Digite no terminal:
$ ps -ax
Veja que não há ocorrência do Gerenciador de Janelas (metacity) e nem do Ambiente Desktop (gnome).
Apenas com o Servidor X ativo, digite:
$ xcalc &
$ gimp &
Você terá seguinte tela.
Tente mover ou redimensionar a janela, verá que não é possível.
Note que as janelas estão sem a barra de título, os botões de controle etc. Isso se deve pelo fato de que o Gerenciador de Janelas não está ativo. Também não há a barra de menu do gnome, controle de volume etc, afinal, o Ambiente Desktop também não está ativo.
Ativaremos então, o Gerenciador de Janelas. Digite no terminal:
$ metacity &
Obs.: Caso não consiga passar o foco para o terminal, feche o gimp (pois o gimp prende o foco em sua janela) execute o metacity e depois o gimp novamente.
Agora o seguinte ambiente será mostrado.
Note que agora, como o metacity, as janelas já apresentam sua funcionalidades, apesar do Ambiente Desktop ainda não estar ativo.
Então, ativaremos o Ambiente Desktop. Digite no terminal:
$ gnome &
Teremos agora o ambiente que estamos acostumados com o Servidor X, Gerenciador de Janelas e Ambiente Desktop.
Faltou vermos o Ambiente Desktop redando direto sobre o Servidor X, sem um Gerenciador de Janelas entre eles. Então, mate o processo metacity. Digite no terminal:
$ ps -ax | grep metacity
Anote o número do processo do metacity e:
$ kill -9
ou digite no terminal:
$ exit
Logue novamente na seção Terminal de segurança. No terminal digite:
$ gnome &
$ xcalc &
$ gimp &
Teremos então a seguinte tela:
Espero ter esclarecido algumas dúvidas com relação ao assunto proposto.
Nenhum comentário:
Postar um comentário