# Trabalhando nos Bastidores do &kde;

Nicolas
Goutte
goutte@kde.org

## Editando Manualmente os Arquivos de Configuração

### Introdução

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

Um exemplo de um arquivo de texto:

    [Geral]
    AutoSalvar=1
    UltimoArquivo=/var/tmp/teste.txt

Os arquivos de configuração de um usuário 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. (Você poderá encontrar esta localização se executar o comando `kde4-config --prefix`.) Os seus nomes terminam normalmente em 'rc' (sem um ponto inicial), como por exemplo `kopeterc`.

Contudo, os arquivos de configuração editados manualmente, podem comprometer a estabilidade do seu &kde;. A maioria dos aplicativos não verificam o que leem dos seus arquivos de configuração e poderão ser prejudicados pelo que obtêm da sua configuração, fazendo com que o aplicativo inclusive estoure.

### Cópias de Segurança

Por isso, a primeira regra é fazer uma cópia de segurança do seu arquivo antes de modificá-los. A cópia de segurança deverá ser guardada fora de qualquer sub-pasta 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 arquivos de configuração importantes (como por exemplo as suas opções do &kmail;, que se encontram no arquivo `kmailrc`). (Uma falha grande dessas não deveria acontecer, mas ainda assim pode ocorrer.)

### Editando

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

De qualquer forma, seja qual for a razão, você poderá desejar modificar manualmente um arquivo de configuração.

Ao planejar editar um arquivo desses, certifique-se que o aplicativo que o usa não está rodando. Se for um dos arquivos de configuração básica, considere editar o arquivo enquanto o todo o &kde; não está rodando.

Está pronto? Faça então uma cópia de segurança (já foi dito alguma vez?), inicie o seu editor favorito (assumiremos que neste caso é o &kate;), abra o arquivo (tenha o cuidado de carregá-lo como UTF-8, uma vez que que o &kate; exibe-o como utf8).

Agora você terá um arquivo do tipo:

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

Você poderá agora modificá-lo (com cuidado!) e depois salvá-lo (certificando-se novamente que é UTF-8).

Agora, você poderá testar o aplicativo e, se ele não se executar mais corretamente, feche-o e restaure a cópia de segurança.

#### Informações Relacionadas

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

## Programando o Ambiente de Trabalho

O &kde; oferece um sistema de comunicação entre processos poderoso chamado &DCOP;, o Desktop COmmunication Protocol. Usando o &DCOP;, você pode controlar uma grande quantidade de funções do &kde; a partir da linha de comando ou a partir de um programa feito na sua linguagem de programação favorita. Você poderá também obter informações a partir dos aplicativos 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á sendo tocada no momento.

Falando de um modo abrangente, cada aplicativo do &kde; oferece uma ou mais interfaces de &DCOP; que, por sua vez, oferecem métodos (ou, se preferir, funções) que outro aplicativo poderá então invocar. Assim, 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 comando (a janela que aparece com o &Alt;F2 ). A janela do kdcop mostra os aplicativos que estão rodando no momento e que oferecem interfaces de &DCOP;, usando uma árvore para isso. De um modo geral, a escolha do método correto obriga a alguma pesquisa pela árvore, mas uma sugestão útil é que a interface marcada como (padrão), contém normalmente as funções usadas com mais frequência.

Para testar se a função faz o que desejamos, faça um duplo-clique por exemplo no item setColor. Para escolher a cor `c`, clique no botão de seleção de cores e escolha uma. Indique se a cor deverá ser a cor A com a opção para assinalar. Clique OK para ver a cor de fundo modificada.

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

Nós especificamos o aplicativo, a interface e o método exatamente nessa ordem, seguido dos argumentos pela mesma ordem que são apresentados no kdcop. O `dcop` possui muitas outras opções: dê uma olhada no resultado do ``dcop` `--help``.

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

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

Com o aplicativo da linha de comando `dcop` e um pouco de Perl, vamos fazer então um pequeno programa que mude lentamente o fundo da tela, percorrendo o espectro de cores.

Em primeiro lugar, nós procuraremos pelo método apropriado com o kdcop. Para este exemplo, encurtaremos a busca e iremos ao método diretamente: o método que desejamos é 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 comando, usaremos o seguinte:

    % dcop kdesktop KBackgroundIface setColor '#ffffff' false

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

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

Assim, isto é tudo que precisamos 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 alterne a cor de fundo em um espectro bem definido, até que seja morto. Voilà!

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

### Aplicando um fundo da Internet

O seguinte programa obtém a imagem principal da tira de quadrinhos User Friendly e coloca-a como papel de parede da área de trabalho, 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 uma mágica das 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.

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

Muitos teclados modernos contém teclas adicionais que não estão atribuídas por padrão a nenhuma ação.

As teclas Multimídia geram normalmente um sinal e podem simplesmente ser escolhidas como uma combinação de teclas dentro de um aplicativo, como quem escolhe uma tecla qualquer. Algumas das teclas, todavia, não são detectadas e, pressionando-as no Configurar Atalhos, não acontecerá nada.

Alguns portáteis da IBM, por exemplo, possuem teclas adicionais 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, são o 233 e o 234, respectivamente

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

3. Crie um arquivo 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``

Neste momento, você deverá ser capaz de executar o `xev` novamente e ver que as teclas geram agora o símbolo da tecla que atribuiu. Você poderá agora atribuir esses símbolos a qualquer ação, como de costume.

### Informações Relacionadas

- A página de manual do `xev`. Você poderá vê-la digitando `man:/xev` numa janela do &konqueror; ou digitando ``man` xev` num terminal.

## Adicionando Combinações de Teclas às Ações Novas

A maioria das ações do ambiente de trabalho ou dos aplicativos estão imediatamente disponíveis para poder associar-se uma combinação de teclas. Se a ação a que deseja atribuir um atalho foi criada por você ou ainda não esteja disponível, você poderá ainda assim atribuir um atalho.

Para reunir as duas seções anteriores, talvez você 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 a área de trabalho virtual anterior ou a seguinte, ou seja, duas funções para as quais irá precisar do DCOP (tal como foi descrito em .

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

1. Abra o &kcontrol; na seção Regional & Acessibilidade, e selecione Ações de Entrada

2. Escolha Nova Ação

3. Dê um nome à ação nova, &eg; `Próxima Área de Trabalho Virtual`

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

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

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

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

Agora, pressionando as teclas Prev_Virtual_Screen ou Next_Virtual_Screen, mudará para a área de trabalho virtual anterior ou a próxima, respectivamente.

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

### Informações Relacionadas

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

Adriaan
de Groot
groot@kde.org

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

### Utilização Básica

O &kdebugdialog; não está no &kmenu; por padrão. Você terá que executá-lo na linha de comando 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 você poderá ligar ou desligar para ativar ou desativar o resultado de depuração dessa parte do &kde;.

A lista de áreas de depuração vem ordenada numericamente, não alfabeticamente, assim o kio (127) vem antes do artskde (400). Os números vão até perto de 200 000, mas normalmente só existem 400 áreas. Você não terá que percorrer a lista completa para encontrar a área que precisa. Existe um campo de texto no topo da janela, onde poderá inserir 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 inserir `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 ativar ou desativar o resultado de depuração, existe também os botões para selecionar tudo e deselecionar tudo, que fará com que o &kde; produza muitos dados de depuração, ou quase nenhum.

### O KDebugDialog no modo completo

No modo completo, que é o que irá obter ao executar o KDebugDialog como ``kdebugdialog` `--fullmode``, fica disponível a mesma lista de áreas de depuração, podendo selecionar apenas uma de cada vez numa lista. Você 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, você poderá escolher para onde são enviadas as mensagens. As opções são:

Arquivo, onde terá que inserir o nome de um arquivo. Ele será escrito na sua pasta $`HOME`.

Caixa de Mensagem. Cada mensagem de depuração é mostrada num diálogo de informação, que você terá que pressionar OK para continuar com o aplicativo.

Linha de Comando, a entrada padrão. As mensagens são impressas no 'stderr' e irão aparecer tanto na janela da linha de comado em que a aplicativo foi iniciado, como no `.xsession-errors`.

Syslog. Isto envia cada mensagem de depuração para a funcionalidade de registro do systema ('syslog'), que poderá efetuar 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, uma vez que em ambos os casos poderá não ver a mensagem e o aplicativo que obtenha o erro fatal irá desaparecer sem deixar uma razão do seu desaparecimento. Se o aplicativo desaparecerá ou não no caso de um erro fatal, poderá ser definido na opção Abortar nos erros fatais, que está assinalada por padrão — mas você poderá esperar ainda que um aplicativo estoure (de forma confusa) se for encontrado ainda um erro.