dwm (Português) - ArchWiki

Jump to content

# dwm (Português)

From ArchWiki

Status de tradução: Esse artigo é uma tradução de Dwm. Data da última tradução: 2020-06-08. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- dmenu
- Gerenciador de janelas

O dwm é um gerenciador de janelas dinâmico para o Xorg. Ele gerencia janelas em layouts (formato de ordenação) lado a lado, empilhado e em tela cheia, além de muitos outros com a ajuda de patches opcionais. Os layouts podem ser aplicados dinamicamente, otimizando o ambiente para o aplicativo em uso e a tarefa que está sendo executada. O dwm é extremamente leve e rápido, escrito em C e com um objetivo de projeto declarado de permanecer com menos de 2000 linhas de código-fonte. Fornece suporte a múltiplos monitores para xrandr e Xinerama.

## Instalação

O dwm pode ser instalado com o pacote dwmAUR ou dwm-gitAUR. Faça a #Configuração antes de compilar e instalar, veja makepkg.

### Configuração

O dwm é configurado em tempo de compilação ao editar alguns de seus arquivos fonte, especificamente `config.h`. Para obter informações detalhadas sobre essas configurações, consulte as instruções bem comentadas e incluídas, `config.def.h` assim como a seção de personalização no site do dwm.

O site oficial possui vários patches que podem adicionar funcionalidades extras ao dwm. Esses patches fazem principalmente alterações no arquivo `dwm.c`, mas também fazem alterações no arquivo `config.h` quando necessário. Para obter informações sobre a aplicação de patches, consulte o artigo Aplicação de patch em pacotes.

## Iniciando

Selecione Dwm no gerenciador de exibição de sua escolha. Como alternativa, para iniciar o dwm com startx adicione `exec dwm` ao `~/.xinitrc` e o preceda com outros programas, para executá-los também, por exemplo:

    redshift -O3500; xset r rate 300 50; exec dwm

## Uso

Veja o tutorial do dwm (inglês) para obter informações sobre o uso básico do dwm.

## Dicas e truques

### Configuração da barra de status

Para mais exemplos de barras de status, veja [1].

Nota O seguinte requer o pacote xorg-xsetroot instalado.

O dwm lê o nome da janela raiz e o redireciona para a barra de status. A janela raiz é a janela na qual todas as outras janelas são desenhadas e organizadas pelo gerenciador de janelas. Como qualquer outra janela, a janela raiz tem um título/nome, mas geralmente é indefinida porque a janela raiz sempre é executada em segundo plano.

As informações que você deseja que o dwm mostre na barra de status devem ser definidas com o comando `xsetroot -name ""` no `~/.xinitrc` ou `~/.xprofile` (se você estiver usando um gerenciador de exibição). Por exemplo:

    xsetroot -name "Obrigado por todo o peixe!"

As informações atualizadas dinamicamente devem ser colocadas em um loop que é executado em segundo plano - veja o exemplo abaixo:

    # Statusbar loop
    while true; do
       xsetroot -name "$( date +"%F %R" )"
       sleep 1m    # Atualiza a cada minuto
    done &

    # Autostart section
    pcmanfm &

    exec dwm

Nesse caso, a data é mostrada no formato ISO 8601 e o PCManFM é iniciado na inicialização.

Nota Não é recomendado definir o intervalo de atualização igual a zero ou remover totalmente a linha "sleep", pois isso fará com que o uso da CPU aumente substancialmente (você pode avaliar o efeito com top e o powertop).

#### Conky na barra de status

O Conky pode ser impresso na barra de status com `xsetroot -name`:

    (conky | while read LINE; do xsetroot -name "$LINE"; done) &
    exec dwm

Se você não quiser gerar muitos PIDs pelo comando 'xsetroot', pode compilar este programa em C:

    #include <string.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <X11/Xlib.h>

    int main(int argc, char * argv[])
    {
            Display * dpy = NULL;
            Display * dpy = NULL;
            size_t length = 0;
            ssize_t bytes_read = 0;
            char * input = NULL;

            dpy = XOpenDisplay(getenv("DISPLAY"));
            if (dpy == NULL)
            {
                    fprintf(stderr, "Can't open display, exiting.\n");
                    exit(1);
            }
            win = DefaultRootWindow(dpy);

            while ((bytes_read = getline(&input, &length, stdin)) != EOF)
            {
                    input[strlen(input) - 1] = '\0';
                    XStoreName(dpy, win, input);
                    XFlush(dpy);
                    fprintf(stderr, "Input: %s", input);
                    fprintf(stderr, "\nbytes read: %ld\n", bytes_read);
            }
            free(input);
            return 0;
    }

Salve este código no arquivo dwm-setstatus.c e compile:

    $ gcc dwm-setstatus.c -lX11 -o dwm-setstatus

mova 'dwm-setstatus' dentro do seu $PATH (/usr/local/bin, por exemplo)

    # mv dwm-setstatus /usr/local/bin

e executa:

    $ conky | dwm-setstatus

Para fazer isso, o conky precisa ser instruído a enviar texto apenas para o console. A seguir, é apresentado um exemplo da conkyrc para um processador com dois núcleos, exibindo várias estatísticas de uso:

    conky.config = {
    out_to_console = true,
    out_to_x = false,
    background = false,
    update_interval = 2,
    total_run_times = 0,
    use_spacer = 'none',
    };
    conky.text = [[
    $mpd_smart :: ${cpu cpu1}% / ${cpu cpu2}%  ${loadavg 1} ${loadavg 2 3} :: ${acpitemp}c :: $memperc% ($mem) :: ${downspeed eth0}K/s ${upspeed eth0}K/s :: ${time %a %b %d %I:%M%P}
    ]];

Para ícones e opções de cores, veja dzen.

### Reinicie o dwm

Para reiniciar o dwm sem sair ou fechar aplicativos, altere ou adicione um script de inicialização para carregar o dwm em um loop while, por exemplo:

    while true; do
        # Log do stderror para um arquivo
        dwm 2> ~/.dwm.log
        # sem log de erro
        #dwm >/dev/null 2>&1
    done

O dwm agora pode ser reinicializado sem destruir outras janelas X pressionando a combinação habitual Mod-Shift-Q.

É uma boa ideia colocar o script de inicialização acima em um arquivo separado por exemplo `~/bin/startdwm`, e executá-lo pelo `~/.xinitrc`. A partir deste momento, quando você desejar finalizar a sessão X, basta executar `killall xinit`, ou vincule-o a um atalho conveniente. Como alternativa, você pode configurar seu script de sessão do dwm para que ele reinicie o dwm apenas se o binário mudar. Isso pode ser útil no caso em que você modificar uma configuração ou atualizar a base de código do dwm.

    # execute o DWM se o binário mudar, senão saia
    csum=$(sha1sum $(which dwm))
    nova_csum=""
    while true
    do
        if [ "$csum" != "$nova_csum" ]
        then
            csum=$nova_csum
            dwm
        else
            exit 0
        fi
        nova_csum=$(sha1sum $(which dwm))
        sleep 0.5
    done

### Conecte a tecla Alt direita com Mod4

Ao usar o Mod4 (a tecla Super/Windows) como o `MODKEY`, pode ser igualmente conveniente ter a tecla `Alt` direita (`Alt_R`) agindo como `Mod4`. Isso permitirá que você pressione teclas, de outra maneira incômodas com uma mão, como zooming com `Alt_R`+`Enter`.

Primeiro, descubra qual keycode (código da tecla) está atribuído à `Alt_R`:

    xmodmap -pke | grep Alt_R

Em seguida, basta adicionar o seguinte ao script de inicialização (por exemplo, `~/.xinitrc`), alterando o keycode 113 se necessário, para o resultado obtido pelo o comando `xmodmap` anterior:

    xmodmap -e "keycode 113 = Super_L"  # reatribui Alt_R para Super_L
    xmodmap -e "remove mod1 = Super_L"  # garanta que o X mantém a tecla fora do grupo mod1

Depois disso, todas as funções que são acionadas pela tecla `Super_L` também serão acionadas por `Alt_R`.

Nota Existe uma opção `#define` em config.h que também permite alternar a modkey.

### Espaço ao redor da fonte na barra do dwm

Por padrão, a barra do dwm adiciona 2px ao redor do tamanho da fonte. Para mudar isto, modifique a seguinte linha em `dwm.c`:

    bh = dc.h = dc.font.height + 2;

### Desativar o foco seguindo o mouse

Para desativar o foco que segue o comportamento do mouse, comente a seguinte linha na definição do manipulador de estruturas em `dwm.c`

    [EnterNotify] = enternotify,

Observe que essa alteração pode causar algumas dificuldades; o primeiro clique em uma janela inativa trará apenas o foco para ela. Para interagir com o conteúdo da janela (botões, campos etc.), você precisa clicar novamente. Além disso, se você tiver alguns monitores, poderá observar que o foco do teclado não muda para outro monitor focado ao clicar.

### Layout flutuante para algumas janelas

Para algumas janelas, como as caixas de diálogo de preferências, não faz sentido que essas janelas sejam lado a lado - elas devem flutuar livremente. Por exemplo, para fazer a caixa de diálogo de preferências do Firefox flutuar, adicione o seguinte à sua matriz de regras em `config.h`:

     { "Firefox",     NULL,       "Firefox Preferences",        1 << 8,         True,     -1 },

### Usando Tilda com dwm

dwm pode gerenciar a localização das janelas automaticamente, então é necessário configurar para que o Tilda funcione adequadamente.

Você tem que editar o `config.h` do dwm:

    static const Rule rules[] = {
    	/* class      instance    title       tags mask     isfloating   monitor */
    	{ "Gimp",     NULL,       NULL,       0,            True,        -1 },
    	{ "Firefox",  NULL,       NULL,       1 << 8,       False,       -1 },
    //add the line below
    	{ "Tilda",  NULL,       NULL,       0,       True,       -1 },
    	{ "Volumeicon",  NULL,       NULL,       0,       True,       -1 },
    };

Isto acima faz com que todas as janelas com a WM_CLASS "Tilda" estejam no modo flutuante.

Execute o tilda com a opção `-C`:

    $ tilda -C

Agora você pode configurar o Tilda, as opções a seguir são recomendadas:

    Font: Clean 9
    Font: Clean 9
    Appearance: Height: 50%, Width: 70%, Centered Horizontally
    Extras: Enable Transparency Level 15
    Animated Pulldown: 1500 usec, Orientation: Top
    Colors: Built-in Scheme "Green on Black"
    Scrolling: Scrollbar is on the left, 2000 lines scrollback
    Key Binding: F9

Abaixo é como a configuração vai ficar parecida depois dessas configurações na `~/.config/tilda/config_0`:

    tilda_config_version = "0.9.6"
    # image = ""
    # command = ""
    font = "Clean 9"
    key = "F9"
    title = "Tilda"
    background_color = "white"
    # working_dir = ""
    web_browser = "firefox"
    lines = 2000
    max_width = 956
    max_height = 384
    min_width = 1
    min_height = 1
    transparency = 15
    x_pos = 205
    y_pos = 1
    tab_pos = 0
    backspace_key = 0
    delete_key = 1
    d_set_title = 3
    command_exit = 2
    scheme = 1
    slide_sleep_usec = 1500
    animation_orientation = 0
    scrollbar_pos = 0
    back_red = 0
    back_green = 0
    back_blue = 0
    text_red = 0
    text_green = 65535
    text_blue = 0
    scroll_background = true
    scroll_on_output = false
    notebook_border = false
    antialias = true
    scrollbar = false
    use_image = false
    grab_focus = true
    above = true
    notaskbar = true
    bold = true
    blinks = true
    scroll_on_key = true
    bell = false
    run_command = false
    pinned = true
    animation = true
    hidden = true
    centered_horizontally = true
    centered_vertically = false
    enable_transparency = true
    double_buffer = false

É importante que você habilite pulldown-animation, de outro modo Tilda vai continuamente pular toda vez que for exibida, provavelmente um problema do dwm.

## Resolução de problemas

### Corrigindo aplicativos Java com comportamento inadequado

Tente definir `export _JAVA_AWT_WM_NONREPARENTING=1`. Veja também a página do Java.

### Corrigindo lacunas nas janelas dos terminais

Se houver gaps vazios no espaço da área de trabalho fora das janelas dos terminais, provavelmente isso se deve ao tamanho da fonte dos terminais. Ajuste o tamanho até encontrar a escala ideal que fecha os gaps ou alterne `resizehints` para 0 em `config.h`.

Isso fará com que o dwm ignore as solicitações de redimensionamento de todas as janelas cliente, não apenas dos terminais. A desvantagem dessa solução alternativa é que alguns terminais podem sofrer anomalias de redesenho, como linhas fantasmas e quebra de linha prematura, entre outros.

Como alternativa, se você usar o emulador de terminal st, poderá aplicar o patch anysize e recompilar o st.

## Veja também

- Site oficial do dwm
- Introdução ao dwm
- dmenu - Iniciador de aplicativos simples dos desenvolvedores do dwm
- A discussão do dwm nos fóruns
- Hacking dwm thread
- Confira as discussões de wallpaper nos fóruns para uma seleção de papéis de parede dwm
- Mostre sua configuração do dwm na discussão do fórum

Categories:

- Dynamic WMs (Português)
- Suckless (Português)

dwm (Português)
Add topic