FluxboxOld

Guia do Fluxbox no Ubuntu

O que é o Fluxbox?

Fluxbox é um gerenciador de janelas leve e receptivo para GNU/Linux. Não é tão elaborado quanto o GNOME ou KDE, mas utiliza consideravelmente menos recursos do sistema. Isso o faz único para situações onde os recursos do sistema, especialmente RAM, são muito limitados.

O Fluxbox é um tanto minimalista em sua configuração padrão. Felizmente, é fácil padroniza-lo e reconfigurá-lo somente editando arquivos de texto.

Por que usar o Fluxbox?

Como mencionado acima, o Fluxbox roda com facilidade em sistemas com muito pouco recurso. Por isso, se torna ideal para o uso em máquinas antigas. (Por essa razão, é o gerenciador de janelas padrão para as distribuições chamadas DamnSmallLinux).

O Fluxbox é feito esteticamente minimalista para mais eficiência do ambiente de trabalho; além disso, sua função de abas nas janelas é um excelente modo de minimizar a bagunça e maximizar o uso real da tela.

PRIMEIRO PASSO: Instalando o Fluxbox

(N.B. As seguintes instruções de instalação supõe que você esta instalando o Fluxbox em uma instalação padrão do Ubuntu, que usa o GDM. Usuários que desejam instalar absolutamente o mínimo devem primeiro consultar a página wiki Installation/LowMemorySystems de instruções para uma instalação mínima mais direcionada para sua necessidade.)

Essa é a parte fácil. O Fluxbox esta no repositório universe. Ative o repositório universe no Synaptic ou descomentando ele no seu /etc/apt/sources.list arquivo, abra um terminal, e execute:

$ sudo apt-get install fluxbox

Reinicie o X com CTRL + ALT + BACKSPACE o que fará carregar o GDM, e aparecer o Fluxbox no menu de seções. De qualquer modo, NÃO irei reiniciar o X ainda.

Por que? Por alguma razão, o pacote do Fluxbox no repositório universe cria um arquivo xsession fora do padrão (no mínimo para o Fluxbox),o que significa que o arquivo de configuração ~/.fluxbox/startup não é automaticamente gerado na primeira vez que o Fluxbox é iniciado.

Depois de iniciar o Fluxbox, nós devemos corrigir esse descuido.

Em um terminal, execute

$ sudo nano /usr/share/xsessions/fluxbox.desktop

Você ira ver o seguinte texto:

exec=fluxbox

substitua essa linha por

exec=startfluxbox

Após você terminar de editar /usr/share/xsessions/fluxbox.desktop , reinicie o servidor X e entre no Fluxbox.

SEGUNDO PASSO: Usando o Fluxbox

Como você pode perceber, o Fluxbox faz as coisas um pouco diferentes do GNOME/KDE/XFCE.

Chamando o Menu e carregando Programas

Diferente do GNOME, KDE, e XFCE o Fluxbox não tem um botão "Iniciar". Para ver o menu, simplesmente click com o botão direito do mouse em qualquer parte do desktop. Submenus irão se expandir simplesmente passando o mouse por cima deles. Para abrir um programa, selecione um item no menu e click nele.

Alternar áreas de trabalho

Girando a roda do mouse sobre qualquer espaço vazio na área de trabalho irá alternar as áreas. Esse é um meio rápido de ir para a próxima área.

Tabulando janelas

Tabular janelas é um bom meio de conservar todos os estados reais da tela e reduzir a desordem. É um comportamento único do Fluxbox, e parte disso apela para o ambiente de trabalho. Clique com o botão do meio do mouse em uma barra de título de uma janela; mantenha o botão pressionado e arraste em uma outra janela. As duas janelas parecem se fundir em uma única janela com duas pequenas barras. Você agora pode ver cada barra com as janelas recém-fundidas clicando em sua barra de título respectiva.

Isso é particularmente útil se você estiver rodando uma aplicação de um terminal. Tabulando a aplicação com sua janela de terminal correspondente, é fácil lançar para a frente e para trás eliminar erros de saída no terminal para a aplicação.

TERCEIRO PASSO: Configuração & Personalização

"Contribuição de ChrisPeterman"

Admito, a instalação básica do Fluxbox é bem simples. Você tem somente uma pequena barra de tarefas/systray/relógio combo na parte inferior da tela e um ótimo menu clicando com o botão direito do mouse (menu de clique direito). Mas como guiar você para iniciar todo o trabalho? Você já ouviu falar que Fluxbox é muito personalizável, certo? Bem, aqui vai a carne e as batatas. Você deve ser bem familiarizado com o terminal porque irá usá-lo muito para fazer várias coisas. Também deve ser familiar com seu editor de textos favoritos, porque toda a diversão na configuração do Fluxbox é controlada por arquivos de texto em ~/.fluxbox. Ah... A não ser que já tenha dito, você não precisa de privilégios de root (sudo) para coisa alguma porque você estará trabalhando com seu diretório home.

Personalização do Menu

O primeiro arquivo para isso é o ~/.fluxbox/menu. Esse arquivo controla o menu de clique direito. A sintaxe é muito simples. Note que se você está instalando o Fluxbox de uma instalação normal do Ubuntu/Kubuntu/Xubuntu (ou seja, você já tem um gerenciador de janelas), então todas as suas aplicações já estão no menu e seu arquivo de configuração irá parecer com:

[begin] (fluxbox)
[include] (/etc/X11/fluxbox/fluxbox-menu)
[end]

Ou pelo menos deveria parecer. A primeira e a última linha definem o começo e o fim do arquivo de menu, dessa forma tudo é colocado entre elas. Elas incluem coisas puxadas do arquivo gerado em /etc/fluxbox. Esse arquivo é gerado pelo pacote Debian Menu (sudo apt-get install menu) e esse pacote tiver sido instalado antes do Fluxbox, então ele será automaticamente colocado no arquivo de menu. No caso, no meu laptop eu fiz a instalação do Fluxbox antes do pacote Menu e ele não foi exibido (mas ele estava no mesmo lugar em /etc), mas em meu computador (o qual roda GNOME, XFCE e agora Fluxbox na mesma instalação) o pacote de menu estava instalado antes do Fluxbox e o arquivo foi importado. Não importa quão grande é o arquivo, nós veremos como fazer o nosso próprio menu agora!

A sintaxe básica para um executável (entrada normal de programa) é

[exec] (Nome que você quer que apareça no menu) {comando} <caminho para o ícone>

O exec diz que essa é uma entrada para executável. O () é o nome que você quer que apareça no menu. Agora comando é o que você digita em um terminal para rodar o executável. Também pode-se usar o caminho absoluto. Como eu acho isso? Com o comando:

$ which gaim
/usr/bin/gaim

Funciona para qualquer comando (quase...)

Se existir um ícone que veio com ele, então coloque em <>, mas é opcional. Ah, isso tudo é colocado em uma mesma linha e termina com uma nova linha (basicamente pressionando enter)

E sobre os submenus? No momento qualquer entrada exec estará no menu principal. Isso é realmente fácil:

[submenu]  (Nome do submenu) {}
  #conteúdo -- entradas exec, outros submenus, etc.
[end]

Novamente submenu diz que você está fazendo um submenu, o nome está em (). O {} é apenas um comando nulo e é incluído por convenção. Você pode colocar tudo que quiser no submenu, apenas quando você terminar suas definições encerre com [end].

Isso é o básico sobre o Menu. O Fluxbox gera todas as configurações quando é instalado, então ele já está presente e você não tem que se preocupar com ele. Ah sim, você PODE ter entradas duplicadas no menu.

Aqui está o arquivo de menu do meu laptop:

[begin] (Fluxbox) {}
   [exec] (Gaim) {/usr/bin/gaim}
   [exec] (Firefox) {/usr/bin/firefox}
   [exec] (Irssi) { x-terminal-emulator -T "irssi-text" -e /usr/bin/irssi-text}
   [exec] (Bash) { x-terminal-emulator -T "Bash" -e /bin/bash --login}
   [exec] (BMP) {/usr/bin/beep-media-player}
   [exec] (VLC) {/usr/bin/vlc}
   [exec] (F-Spot) {/usr/bin/f-spot}
   [exec] (Acrobat Reader) {/usr/bin/acroread}
   [submenu] (Apps) {}
        [submenu] (Editors) {}
            [exec] (Emacs) {/usr/bin/emacs21}
            [exec] (Nano) { x-terminal-emulator -T "Nano" -e /bin/nano}
        [end]
        [submenu] (Net) {}

            [exec] (Telnet) { x-terminal-emulator -T "Telnet" -e /usr/bin/telnet}
            [exec] (w3m) { x-terminal-emulator -T "w3m" -e /usr/bin/w3m /usr/share/doc/w3m/MANUAL.html}
        [end]
        [submenu] (Programming) {}
            [exec] (Python) { x-terminal-emulator -T "Python (v2.4)" -e /usr/bin/python2.4}
        [end]
        [submenu] (Shells) {}

            [exec] (Dash) { x-terminal-emulator -T "Dash" -e /bin/dash -i}
            [exec] (Sh) { x-terminal-emulator -T "Sh" -e /bin/sh --login}
        [end]
        [submenu] (System) {}
            [exec] (gkrellm) { /usr/bin/gkrellm }
            [submenu] (Admin) {}
                [exec] (alsaconf) { x-terminal-emulator -T "alsaconf" -e /usr/sbin/su-to-root -p root -c /usr/sbin/alsaconf}
                [exec] (pppconfig) { x-terminal-emulator -T "pppconfig" -e /usr/sbin/su-to-root -p root -c /usr/sbin/pppconfig}
            [end]
            [exec] (aptitude) { x-terminal-emulator -T "aptitude" -e /usr/bin/aptitude}
            [exec] (DSL/PPPoE configuration tool) { x-terminal-emulator -T "DSL/PPPoE configuration tool" -e /usr/sbin/pppoeconf}
            [exec] (GDM flexiserver) {gdmflexiserver}
            [exec] (GDM flexiserver in Xnest) {gdmflexiserver -n}
            [exec] (GDM Photo Setup) {gdmphotosetup}
            [exec] (GDM Setup) {gksu gdmsetup}
            [exec] (pstree) { x-terminal-emulator -T "pstree" -e /usr/bin/pstree.x11}
            [exec] (reportbug) { x-terminal-emulator -T "reportbug" -e /usr/bin/reportbug --exit-prompt}
            [exec] (Run as different user) {/usr/bin/gksuexec}
            [exec] (Top) { x-terminal-emulator -T "Top" -e /usr/bin/top}
            [exec] (X-Terminal as root) {/usr/bin/gksu -u root /usr/bin/x-terminal-emulator}
        [end]
    [end]
    [submenu] (Help) {}
        [exec] (Info) { x-terminal-emulator -T "Info" -e info}
    [end]
    [submenu] (WindowManagers) {}
        [restart] (FluxBox) {/usr/bin/fluxbox}
    [end]
    [config] (Configuration) {}
    [submenu] (Styles) {}
        [stylesdir] (/usr/share/fluxbox/styles) {}
        [stylesdir] (~/.fluxbox/styles) {}
    [end]
    [workspaces] (Workspaces) {}
    [reconfig] (Reconfigure) {}
    [restart] (Restart) {}
    [exit] (Exit) {}
[end]

E o do meu computador:

[begin] (fluxbox)
        [exec] (Evolution) {/usr/bin/evolution}
        [exec] (GAIM) {/usr/bin/gaim}
        [exec] (Bash) { x-terminal-emulator -T "Bash" -e /bin/bash --login}
        [exec] (Epiphany) {/usr/bin/epiphany}
        [exec] (BMP) {/usr/bin/beep-media-player}
        [exec] (Xine) {/usr/bin/xine}
[include] (/etc/X11/fluxbox/fluxbox-menu)
[end]

Você pode ver a diferença. Meu computador tinha o Debian Menus antes de eu instalar o Fluxbox, dessa forma o menu foi importado.

Para exemplos futuros do que você pode fazer com o menu, acesse essa página na documentação do Fluxbox.

Geração de menus tradicional

Se você preferir criar um menu usando o método tradicional para a maioria dos visuais padrões, então você deve seguir o processo básico que é destacado abaixo.

Primeiro extraia o arquivo necessário e copie-o para /usr/bin.

# cd /usr/share/doc/fluxbox
# gzip -d fluxbox-generate_menu.gz
# cp fluxbox-generate_menu /usr/bin

Agora, faça dele um executável:

# chmod a+x /usr/bin/fluxbox-generate_menu

Em seguida, é hora de gerar o menu. Digite o comando abaixo como usuário comum.

$ cd /home/username
$ fluxbox-generate_menu

Isso irá criar um arquivo ~/.fluxbox/menuconfig que pode ser personalizado com suas preferências. Você pode, por exemplo, adicionar suporte ao Gnome ou Kde para o menu, mudar o navegador padrão, terminal, etc.

Finalmente, você precisa editar o arquivo init e mudar o caminho de menuFile. Mude a entrada 'session.menuFile' para indicar o nome do usuário desejado editando /home/nomedousuario/.fluxbox/init

session.menuFile:       /home/nomedousuario/.fluxbox/menu

Faça um novo login e divirta-se com seu novo menu.

Atalhos de Teclado

Atalhos de teclado são assombrosos por dizer o mínimo. Por que usar o mouse quando você pode apenas pressionar um seqüência teclas e pronto? As definições de atalhos de teclado são todas armazenadas em ~/.fluxbox/keys.

O Fluxbox já vem com uma pequena quantidade de atalhos de teclado configurados, como o familiar Alt+TAB e os Alt+F1 até F12 para as 12 áreas de trabalho (se você tiver todas habilitadas. Por padrão o Fluxbox tem 4 ativadas). Mas nós queremos fazer os nossos próprios atalhos, não queremos? Muito fácil. Siga a sintaxe (novamente, uma por linha)

<seqüência de teclas> :AÇÃO

Agora algumas coisas precisam de explicação. Primeiro, o nome das teclas. O Alt é referenciado por Mod1, CTRL por Control e a tecla Windows por Mod4. A maioria das outras teclas é o que você espera. Porém, se você quiser ter certeza, existe uma ferramenta chamada  xev . Execute-a em um terminal e pressione as teclas. Um monte de coisa irá aparecer, como por exemplo:

KeyPress event, serial 30, synthetic NO, window 0x1800001,
    root 0x3e, subw 0x0, time 3967824504, (728,435), root:(799,525),
    state 0x0, keycode 50 (keysym 0xffe1, Shift_L), same_screen YES,
    XLookupString gives 0 bytes:
    XmbLookupString gives 0 bytes:
    XFilterEvent returns: False

A maioria dessas coisas nós não precisamos. O que nós queremos é a parte em  keycode <alguma coisa> (keysym <alguma coisa>, Shift_L) . A última parte (Shift_L) é como o gerenciador de janelas enxerga a tecla, dessa forma esse é o seu nome. Então use-o (note que os nomes ditos antes do uso desse comando são prioritários, ou seja, Alt continua sendo Mod1).

Então agora nós temos os nomes das teclas. O formato para a seqüência de teclas é simples. Apenas escreva seus nomes! Então Alt+F1 seria  Mod1 F1 . Fácil! Agora a parte seguinte: é o que a seqüência faz. Existem muitas opções, mas eu vou exibir as que eu acho que serão mais úteis.

Ação

Descrição

Close

Fecha a janele atual

Minimize

Minimiza a janela atual

MaximizeWindow

Maximiza a janela atual

ShowDesktop

Minimiza todas as janelas

Restart

Reinicia o Fluxbox

Quit

Sair do Fluxbox e retorna para a tela de login

ExecCommand

Executa o comando especificado. Tanto faz colocar só o comando ou o caminho absoluto para ele (lembre-se do que você fez com o arquivo de menu)

Novamente, nós temos um exemplo do arquivo para o meu computador:

Mod1 Tab :NextWindow
Mod1 Shift Tab :PrevWindow
Mod1 F1 :Workspace 1
Mod1 F2 :ExecCommand fbrun ;not the default for fluxbox, but this behaves like KDE/Gnome
Mod1 F3 :Workspace 3
Mod1 F4 :Workspace 4
Mod1 F5 :Workspace 5
Mod1 F6 :Workspace 6
Mod1 F7 :Workspace 7
Mod1 F8 :Workspace 8
Mod1 F9 :Workspace 9
Mod1 F10 :Workspace 10
Mod1 F11 :Workspace 11
Mod1 F12 :Workspace 12
Mod4 F1 :ExecCommand /usr/bin/evolution
Mod4 F5 :ExecCommand x-terminal-emulator -T "Bash" -e /bin/bash --login
Mod4 F2 :ExecCommand /usr/bin/epiphany
Mod4 F3 :ExecCommand /usr/bin/xine
Mod4 F4 :ExecCommand /usr/bin/best --no-tray

Configurando o Plano de Fundo

Agora os menus e as teclas de atalho estão bem e funcionando, mas você deseja configurar um plano de fundo, certo? Fácil!

fbsetbg <arquivo de imagem>

Viu? Big Grin :)

Dica: "fbsetbg -l" configura o último plano de fundo usado para ser o atual e poderia ser adicionado em ~/.fluxbox/init com:

session.screen0.rootCommand: fbsetbg -l

Nota: fbsetbg é apenas uma cara para outras coisas que configuram o plano de fundo, como o Esetroot e feh. Se você tiver um deles instalado o fbsetbg irá determinar o melhor para usar. Para saber o que o fbsetbg está usando execute  fbsetbg -i .

O Feh pode ser instalado com  sudo apt-get install feh 

O Esetroot é parte do ETerm, então  sudo apt-get install eterm 

Estilos

Você já pode configurar o plano de fundo, mas e quanto ao tema? Bem, existem boas notícias e más notícias. A boa notícia é que o Fluxbox vem com um monte de temas (chamados Estilos) por padrão. A má notícia é que eles somente afetam a janela em si, não o seu "interior". Isso quer dizer que se você está executando aplicações GTK, então elas usarão o tema padrão grayish. Isso é bom para ele mesmo, mas pode realmente virar um cenário colorido bagunçado. No entanto você pode mudar isso, mas primeiro como instalar e usar os Temas você mesmo.

Mudar estilos é muito fácil. Apenas vá ao submenu Estilos (Sytles) e clique nele. No entanto esteja avisado, alguns estilos irão sobrescrever seu plano de fundo pelo o dele, então você terá que mudar para o seu. Agora o que fazer para instalar um novo estilo? Bem, primeiro você tem que saber onde achá-los. Freshmeat tem um monte de estilos, então veja lá primeiro. (http://themes.freshmeat.net/browse/962/)

Uma vez que você encontrou um que goste, baixe o arquivo para ~/.fluxbox e extraia-o. Uma das duas coisas irá acontecer: ele será um "bom" arquivo e ficará em ~/.fluxbox/styles ou será um "mau" arquivo e ficará em algum lugar em ~/.fluxbox. Se a primeira coisa ocorrer, então está tudo ok e o tema está no menu Estilo. Caso contrário, você terá que procurar o diretório do estilo e mover seu arquivo para ~/.fluxbox/styles. Felizmente 99% das vezes isso fará seu próprio diretório e o diretório do estilo estará nele (esse é o porque de nós extrairmos para ~/.fluxbox, não existem muitos diretórios começando nele, então fica óbvio quando um novo é criado).

Agora tudo está bem e funcionando, mas eu mencionei que é possível aplicar Temas GTK. Sim, você pode. Instale Temas GTK com  sudo apt-get install gtk-theme-switch  e execute com  switch2 . Uma pequena caixa de diálogo irá aparecer com uma lista com todos os Temas GTK instalados. Apenas selecione e aplique. Tenha em mente que o Estilo ainda estará no controle da decoração da janela (Barra de título, bordas da janela, etc), então se o Tema GTK normalmente os configurou, ou não, o resto irá funcionar. Uma boa fonte de Temas GTK é o GNOME-Look. No entanto, fique longe dos temas Metacity. Eles não funcionarão bem. Se você precisa instalar um novo Tema GTK, apenas baixe o arquivo para ~/.themes e extraia-o.

O arquivo ~/.fluxbox/startup

Você ouviu falar sobre ~/.fluxbox/startup, agora aprenda a usá-lo.

Como todos os bons scripts, esse é bem comentado com rápidas instruções.

Setting the Background

Para configurar o plano de fundo (sobrescrevendo o estilo!) descomente o fbsetbg e coloque a localização da imagem como argumento para ele. Então comente a parte sobre configuração de um plano de fundo preto.

Carregando programas quando o Fluxbox inicia

Próximo do fim de ~/.fluxbox/startup você encontrará uma seção onde lerá:

# Applications you want to run with fluxbox. (Aplicações que você quer executar com o fluxbox)
# MAKE SURE THAT APPS THAT KEEP RUNNING HAVE AN ''&'' AT THE END. (PARA TER CERTEZA QUE AS APLICAÇÕES CONTINUARÃO EXECUTANDO USE UM ''&'' NO FIM DO COMANDO)

Aqui coloque todos os programas que você quer carregar com o Fluxbox. Algumas coisas a considerar. O XScreensaver (o qual controla o screensaver e travamento da janela) não é carregado com o Fluxbox por padrão, então você pode querer adicioná-lo ao script startup com  xscreensaver & . O símbolo de "e comercial" (&) diz que ele executará em modo oculto, como deve ser. Será o mesmo para outros programas como o daemon Beagle,  beagled & . Para os demais programas, como GAIM, GKrellm (que é REALMENTE um bom complemento para o Fluxbox) e qualquer outra coisa que você queira iniciar apenas coloque o comando.

"Dockapps" e "Slit"

Dockapps são aplicações que ficam em uma pequena "Doca" (a qual, na terminologia Fluxbox, é chamada "a fenda", "slit") em um dos cantos de sua tela. Elas podem ser informativas (relógio, calendário, informação do sistema), funcionais (controle de volume, utilitários de montagem de dispositivos), convenientes (controles para outras aplicações) ou meramente entretenimento (mini jogos, por exemplo). A vasta maioria dos "dockapps" parecem ter sido originalmente desenvolvidas para os gerenciadores de janela WindowMaker e AfterStep, mas funcionam bem com o Fluxbox. Uma boa seleção deles está disponível nos repositórios do Ubuntu (se você quiser dar uma olhada, execute sudo apt-cache search dockapp em um terminal) e muito mais pode ser encontrado e compilado se você desejar.

Você pode carregar seus "dockapps" quando o Fluxbox iniciar incluindo-os em ~/.fluxbox/startup da mesma forma que você inicia qualquer outro programa no arquivo startup: simplesmente digite o comando, seguido pelo "e comercial" (&).

Iniciando o Fluxbox

Logo na parte de baixo está o comando para iniciar o Fluxbox. Note que aqui nós executamos /usr/bin/fluxbox SEM o "e comercial" (&).

Futuras Fontes

  • Principal site do Fluxbox

  • As próprias Página de Documentação do projeto Fluxbox são uma fonte inestimável. A documentação é disponível para leitura e impressão em formato PDF. Traduções também são disponíveis em muitas linguagens.

  • O Gentoo Wiki contém um excelente manual para o Fluxbox, para o qual esse guia está em débito.

Para aqueles que precisam do Fluxbox com uma instalação extremamente leve, as seguintes fontes serão particularmente úteis:

  • A página wiki Installation/LowMemorySystems será sua primeira opção. Uma (muito) minimalista instalação do Fluxbox é descrito lá.

  • Essa página tem instruções detalhadas para uma instalação extremamente leve do Fluxbox usando XDM como gerenciador de exibição.

(A Fazer: guia do xcompmgr e de transparência)

Créditos

Original: Fluxbox

Autor: Community Ubuntu

Tradutor e Wiki: LuizAquino, RodrigodaSilvaVaz

Data: 15/03/2008



CategoryRevisada

FluxboxOld (last edited 2011-09-19 23:19:05 by localhost)