# Trabalhar nos Bastidores do &kde;

Nicolas
Goutte
goutte@kde.org

## Editar à Mão os Ficheiros de Configuração

### Introdução

No &kde;, os ficheiros de configuração são fáceis de alterar com um editor de texto simples como o &kate;, dado que os ficheiros de configuração são ficheiros de texto.

Um exemplo de um ficheiro de texto:

    [Geral]
    AutoGravar=1
    UltimoFicheiro=/var/tmp/teste.txt

Os ficheiros de configuração de um utilizador estão em `.kde/share/config` (substitua o `.kde` pela sua variável de ambiente $`KDEHOME`) e os globais estão na subpasta `share/config` do local onde o KDE foi instalado. (Poderá encontrar esta localização se executar o comando `kde-config --prefix`.) Os seus nomes terminam normalmente em 'rc' (sem um ponto inicial), como por exemplo `kopeterc`.

Contudo, os ficheiros de configuração editados manualmente, podem comprometer a estabilidade do seu &kde;. A maioria das aplicações não verificam o que lêem dos seus ficheiros de configuração e poderão ser prejudicadas pelo que obtêm da sua configuração, fazendo com que a aplicação inclusive estoire.

### Cópias de Segurança

Por isso, a primeira regra é fazer uma cópia de segurança do seu ficheiro antes de o modificar. A cópia de segurança deverá ser guardada fora de qualquer subpasta da `.kde` (ou da pasta correspondente a $`KDEHOME`). As cópias de segurança são sempre uma boa ideia no caso de uma falha geral do &kde; que destrua os ficheiros de configuração importantes (como por exemplo as suas opções do &kmail;, que se encontram no ficheiro `kmailrc`). (Uma falha grande dessas não deveria acontecer, mas pode à mesma ocorrer.)

### Edição

Assim, para quê mexer nos ficheiros de configuração? Bem, primeiro, é necessário se quiser obrigar o uso do modo KIOSK. Talvez um programador lhe tenha pedido para adicionar um item que o ajude a depurar um erro. Talvez queira recuperar de um problema sem ter de remover toda a pasta `.kde`. Talvez queira aprender mais sobre os detalhes do &kde;.

De qualquer forma, seja qual for a razão, poderá desejar modificar à mão um ficheiro de configuração.

Ao planear editar um ficheiro desses, certifique-se que a aplicação que o usa não está a correr. Se for um dos ficheiros de configuração, pense em editar o ficheiro enquanto o &kde; não está a correr de todo.

Está pronto? Faça então uma cópia de segurança (já foi dito alguma vez?), inicie o seu editor favorito (assumindo neste caso o &kate;), abra o ficheiro (tenha o cuidado de o carregar como UTF-8, dado que o &kate; o mostra utf8).

Agora terá um ficheiro do tipo:

    [Grupo]
    Chave1=Valor1
    Chave2=Valor2
    Chave3=Valor3

Poderá agora modificá-lo (com cuidado!) e depois gravá-lo (garantido outra vez que é UTF-8).

Agora, poderá testar a aplicação e, se esta não executar mais correctamente, feche-a e reponha a cópia de segurança.

#### Informação Relacionada

- tem mais informações sobre a estrutura de pastas do &kde;, de modo a ajudá-lo a encontrar o ficheiro que precisa de editar.

## Programar o Ambiente de Trabalho

O &kde; oferece um sistema de comunicação entre processos poderoso chamado &DCOP;, o Desktop COmmunication Protocol. Ao usar o &DCOP;, pode controlar uma grande quantidade de funções do &kde; a partir da linha de comandos ou a partir de um programa feito na sua linguagem de programação favorita. Poderá também obter informações fora das aplicações do &kde;: por exemplo, vários leitores multimédia do &kde; oferecem métodos para pesquisar por determinada informação no leitor sobre a faixa que está a tocar de momento.

Falando de um modo abrangente, cada aplicação do &kde; oferece uma ou mais interfaces de &DCOP; que, por sua vez, oferecem métodos (ou, se preferir, funções) que outra aplicação poderá então invocar. Como tal, o primeiro passo ao usar o &DCOP; é descobrir o método apropriado para a tarefa. A forma mais simples de fazer isto é com a interface kdcop para os métodos de &DCOP; disponíveis.

Execute o kdcop a partir de um &konsole; ou da mini-linha de comandos (a janela que aparece com o &Alt;F2 ). A janela do kdcop mostra as aplicações que estão a correr de momento e que oferecem interfaces de &DCOP;, recorrendo a uma árvore para tal. De um modo geral, a escolha do método correcto obriga a alguma pesquisa pela árvore, mas uma sugestão útil é que a interface marcada como (default) (por omissão), contém normalmente as funções usadas com mais frequência.

Para testar se a função faz o que se pretende, faça duplo-click por exemplo no item setColor. Para escolher a cor `c`, carregue no botão de selecção de cores e escolha uma. Indique se a cor deverá ser a cor A com a opção para assinalar. Carregue em OK para ver a cor de fundo modificada.

Para aceder ao método de &DCOP; a partir da sua linguagem de programação favorita, poderá tanto usar as interfaces de &DCOP; existentes, se estiverem disponíveis no módulo 'kdebindings', ou então invocar a aplicação da linha de comandos `dcop`. Para uma utilização simples, a invocação da aplicação da linha de comandos `dcop` é suficiente. Para invocar um método de &DCOP; desta forma, é necessário indicar a aplicação e a interface que possui o método, o método em si e os argumentos, num formato adequado para a linha de comandos.

É indicada a aplicação, a interface e o método exactamente por essa ordem, seguido dos argumentos pela mesma ordem que são apresentados no kdcop. O `dcop` tem outras opções diversas: dê uma vista de olhos no resultado do ``dcop` `--help``.

Já chega de teoria: está na altura de um exemplo:

### Um Programa de Mudança da Cor de Fundo com o &DCOP;

Com a aplicação da linha de comandos `dcop` e um pouco de Perl, vamos fazer então um pequeno programa que mude lentamente o fundo do ecrã, percorrendo o espectro de cores.

Em primeiro lugar, terá de se procurar o método apropriado com o kdcop. Para este exemplo, passar-se-á um pouco ao lado da procura e vai-se usar o método directamente: o método que se pretende é o kdesktop KBackgroundIface setColor . Os argumentos e o tipo do valor devolvido da função são mostrados com o estilo da linguagem C++. Para o caso do `setColor`, os argumentos são uma cor `c` que define a nova cor de fundo e um valor booleano ('true' ou 'false'), `isColorA`, que define se a cor é a primeira ou a segunda (isto é útil para definir gradientes, por exemplo).

Para usar o método `setColor` na linha de comandos, usar-se-á o seguinte:

    % dcop kdesktop KBackgroundIface setColor '#ffffff' false

Para indicar a cor, é usado o valor RGB em hexadecimal, como é usado no &HTML;. Repare que este está delimitado por plicas, para proteger o # da linha de comandos.

Para descobrir o valor RGB em hexadecimal de uma cor, abra qualquer janela de selecção de cores numa aplicação do &kde; (como, por exemplo, o &kcontrolcenter;, em Aparência & Temas Cores ), seleccione a cor que deseja e use o valor indicado no campo de texto HTML.

Assim, é tudo o que é necessário do &DCOP;; agora, é apenas necessário criar um programa em torno dele. Aqui está uma implementação (muito!) rudimentar:

    $min=49;  # Valor mínimo da cor R, G ou B
    $max=174; # Valor máximo da cor R, G ou B
    $passo=5;  # Quantidade a incrementar em cada passo e cor
    $espera=15; # Intervalo em segundos entre cada iteração

    @inicio = ($max, $min, $min);
    @cor = @inicio;

    while (1) {
            foreach (0..5) {
                    my $qual = $_ % 3; # Qual a cor (R, G ou B) a alterar
                    my $cima_baixo = $_ % 2; # Se deseja aumentar ou diminuir o valor
                    do {
                            if ($cima_baixo == 0) { $cor[$qual]+=$passo; }
                            if ($cima_baixo == 1) { $cor[$qual]-=$passo; }
                            my $chamada=sprintf "dcop kdesktop KBackgroundIface setColor '#%x%x%x' true\n", @cor;
                            system($chamada);
                            sleep $espera;
                            } while (($cor[$qual]
    >= $min) and ($cor[$qual] <= $max));
                    }
    }

Basta executar o programa sem argumentos, para que ele circule a cor de fundo por um espectro bem definido, até que seja morto. Voilà!

Claro que o Perl não é a única linguagem que poderá usar para fazer programas com o &DCOP;—se preferir o 'shell scripting', também está disponível:

### Aplicar um fundo da Internet

O seguinte programa obtém a imagem principal da página de banda desenhada User Friendly e coloca-a como papel de parede do ecrã, usando as ferramentas normais disponíveis e um pouco de &DCOP;:

    #!/bin/sh
    COMICURL=`wget -qO - http://www.userfriendly.org/static/index.html | \
              grep Latest | sed -e "s,.*SRC=\",," -e "s,\"
    >.*,,"`
    TMPFILE=`mktemp /tmp/$0.XXXXXX` || exit 1
    wget -q -O $TMPFILE $COMICURL
    dcop kdesktop KBackgroundIface setWallpaper $TMPFILE 1

A primeira linha após o '#!/bin/sh' usa o `wget` e alguma magia de expressões regulares para extrair a localização da imagem do código em &HTML; da página principal. A segunda e terceira linhas irão obter a imagem e, finalmente, o `dcop` aplica a imagem transferida como papel de parede.

## Adicionar Atalhos de Teclado Extra para o &kde;

Muitos teclados modernos contêm teclas extra que não estão atribuídas por omissão a nenhuma acção.

As teclas Multimédia geram normalmente um sinal e podem simplesmente ser escolhidas como uma combinação de teclas dentro de uma aplicação, como quem escolhe uma tecla qualquer. Algumas das teclas, todavia, não são detectadas e, se carregar nelas no Configurar os Atalhos, não fará efeito.

Alguns portáteis da IBM, por exemplo, têm teclas extra em torno dos cursores esquerdo e direito, e que parecem um Page Left e um Page Right.

1. Use o `xev` para descobrir o código das teclas. Neste caso, este é o 233 e o 234, respectivamente

2. Escolha os símbolos das teclas. Existe alguns intervalos que não são usados por omissão, por isso muitos estão livres. Poderá encontrar a lista em `/usr/X11R6/include/X11/keysymdef.h` (ou o equivalente no seu sistema).

3. Crie um ficheiro na sua pasta pessoal chamado `.Xmodmap` e adicione o seguinte a ele:

       keycode 233 = Next_Virtual_Screen
       keycode 234 = Prev_Virtual_Screen

4. Execute o comando ``xmodmap` `~/.Xmodmap``

Nesta altura, deverá ser capaz de executar o `xev` de novo e ver que as teclas geram agora o símbolo da tecla que atribuiu. Poderá agora atribuir esses símbolos a qualquer acção, como de costume.

### Informação Relacionada

- A página de manual do `xev`. Poderá ver isso se executar `man:/xev` numa janela do &konqueror; ou se executar ``man` xev` num terminal.

## Adicionar Combinações de Teclas às Acções Novas

A maioria das acções do ecrã ou das aplicações estão logo disponíveis para poder associar uma combinação de teclas. Se a acção a que deseja atribuir um atalho foi algo criado por si ou que ainda não esteja disponível, você poderá à mesma atribuir um atalho.

Para reunir as duas secções anteriores, talvez queira atribuir uma tecla não usada do seu teclado a um programa ou comando de DCOP. O exemplo aqui será então atribuir as duas teclas que foram adicionadas em para ir para o ecrã virtual anterior ou o seguinte, ou seja, duas funções para as quais irá necessitar do DCOP (tal como foi descrito em .

Isto pode ser conseguido facilmente com o seguinte método:

1. Abra o &kcontrol; na secção Regional & Acessibilidade, mais concretamente no KHotKeys

2. Escolha a Nova Acção

3. Dê um nome à acção nova, &eg; `Próximo Ecrã Virtual`

4. Seleccione o Atalho de teclado -> Comando/URL (simples) para o Tipo de acção:

5. Na página do Atalho do Teclado, carregue no botão que deseja usar para despoletar o comando. Para este exemplo, iria carregar na tecla com a imagem do Próxima Página nele. O Next_Virtual_Screen irá aparecer na imagem da tecla.

6. Na página do Configuração do Comando/URL, indique o comando a executar no campo: ``dcop kwin default nextDesktop``

Repita os passos anteriores com a tecla Prev_Virtual_Screen e a acção ``dcop kwin default previousDesktop``.

Agora, se carregar nas teclas Prev_Virtual_Screen ou Next_Virtual_Screen, irá mudar para o ecrã virtual anterior ou o próximo, respectivamente.

Obviamente, poderá atribuir qualquer tecla livre a qualquer acção.

### Informação Relacionada

- Veja a documentação do KHotKeys no &khelpcenter;, ou escreva `help:/khotkeys` numa janela do &konqueror;.

Adriaan
de Groot
groot@kde.org

## &kdebugdialog; - Controlar o Resultado da Depuração do &kde;

### Utilização Básica

O &kdebugdialog; não está no &kmenu; por omissão. Terá de o executar na linha de comandos ou na mini-janela de execução de comandos com ``kdebugdialog``. O &kdebugdialog; mostra uma janela com uma lista grande de áreas de depuração. Cada área tem uma opção que poderá ligar ou desligar para activar ou desactivar o resultado de depuração dessa parte do &kde;.

A lista de áreas de depuração vem ordenada numericamente, não alfabeticamente, como tal o kio (127) vem antes do artskde (400). Os números vão até perto de 200 000, mas normalmente só existem 400 áreas. Não terá de percorrer a lista completa para encontrar a área que precisa. Existe um campo de texto no topo da janela, onde poderá indicar uma parte do nome da área que deseja. A lista de itens que é apresentada é filtrada de modo a incluir apenas as áreas de depuração que contêm o texto que introduziu, &eg; se introduzir `k` não irá filtrar muito mas, se indicar `kont`, deverá aparecer apenas as áreas de depuração do &kontact;. Como uma forma mais rápida de activar ou desactivar o resultado de depuração, existe também os botões para seleccionar tudo e deseleccionar tudo, que fará com que o &kde; produza bastantes dados de depuração, ou quase nenhuns.

### O KDebugDialog no modo completo

No modo completo, que é o que você irá obter ao executar o KDebugDialog como ``kdebugdialog` `--fullmode``, fica disponível a mesma lista de áreas de depuração, podendo seleccionar apenas uma de cada vez numa lista. Poderá então definir o resultado para os vários tipos de mensagens: Informação, Aviso, Erro e Erro Fatal. Para cada um destes tipos, poderá escolher para onde são enviadas as mensagens. As opções são:

Ficheiro, onde terá de indicar o nome de um ficheiro. Este será escrita na sua pasta $`HOME`.

Janela de Mensagem. Cada mensagem de depuração é mostrada numa janela de informação, pelo que terá de carregar em OK para continuar com a a aplicação.

Linha de Comandos, o item por omissão. As mensagens são impressas no 'stderr' e irão aparecer tanto na janela da linha de comandos em que a aplicação foi iniciada, como no `.xsession-errors`.

Syslog. Este envia cada mensagem de depuração para a funcionalidade de registo do sistema ('syslog'), o qual poderá efectuar um processamento prévio da mensagem.

Nenhum. Isto elimina o resultado deste tipo de mensagem.

Para as mensagens geradas pelos erros fatais, é normalmente uma má ideia escolher o Nenhum ou o Syslog, dado que em ambos os casos poderá não ver a mensagem e a aplicação que obtenha o erro fatal irá desaparecer ser deixar uma razão do seu desaparecimento. Se a aplicação desaparecerá ou não no caso de um erro fatal, poderá ser definido na opção Abortar nos erros fatais, que está assinalada por omissão — mas poderá contar à mesma que uma aplicação estoire (de forma confusa) se for encontrado um erro à mesma.