Nível: Intermediário Martyn Honeyford, Software Engineer, IBM UK Labs
14/Jun/2009 O KDE 4 inclui várias novas tecnologias estimulantes, incluindo Plasma, um recurso que forma o shell do desktop
do KDE 4. Veja como gravar applets de Plasma simples (conhecidos como plasmóides) para melhorar muito a experiência
do desktop e como transformar um plasmóide em um monitor de memória simples.
KDE, o K Desktop Environment, é um projeto de software gratuito baseado em um ambiente de desktop para
sistemas estilo UNIX®. Ele fornece funções de desktop básicas e aplicativos para necessidades do dia a dia, bem como
ferramentas e documentação para os desenvolvedores gravarem aplicativos independentes para o sistema. O software KDE é
baseado no kit de ferramentas Qt. O principal aspecto da quarta série do KDE é um desktop reprojetado e painéis, chamados
coletivamente de Plasma, que integram a funcionalidade do Kicker, KDesktop e SuperKaramba em um pedaço de tecnologia.
KDE 4 Oferece uma Nova Esperança
A quarta versão principal do K Desktop Environment (KDE) foi liberada em janeiro de 2008 com reações
mistas. O release marcou um importante compromisso:
- Grande quantidade do código base do KDE 3 foi completamente regravada.
- Um grande número de novas tecnologias foi criado.
- A maioria dos códigos base foi refatorada de alguma forma.
Embora o release inicial 4.0 tenha mostrado um grande potencial, o escopo das mudanças significou que o
release não apresentaria uma igualdade de recursos com o KDE 3. Por isso ele foi amplamente relatado como instável em
certas áreas e alguns usuários foram relutantes em fazer a mudança imediatamente. Muitos desses defeitos foram abordados
no release 4.1, mas ainda havia muitas omissões de recurso importantes.
Com o release de janeiro de 2009 do KDE 4.2, entretanto, a maioria dessas preocupações foi abordada e
muitos usuários decidiram começar a utilizar o 4.2 como seu ambiente de desktop principal.
Agora é um bom momento para examinar esses novos recursos e tecnologias a fundo, já que muitos usuários
têm acesso a eles.
KDE 4.2 Ressuscita o Desktop
Este artigo se concentra em uma das mais estimulantes das novas tecnologias: Plasma e applets de Plasma
(que costumam ser chamados de plasmóides).
A ideia por trás do Plasma é simples: Você tem uma ou mais restrições de Plasma, que são
elementos exibíveis capazes de conter itens individuais como widgets/plasmóides e/ou outras restrições de Plasma.
Este conceito não parece particularmente inovador até você perceber que por trás do KDE 4, o shell de
desktop inteiro (o desktop principal que é apresentado ao usuário) é, de fato, uma restrição de Plasma, e que todos os
controles familiares, como a barra de tarefas, a lista de tarefas, o relógio, o alternador de tarefas, Menu k, ícones
de ativação rápida, etc., são todos implementados como applets de Plasma (como o relógio) ou como restrições de Plasma
(a barra de tarefas).
Isso é extremamente estimulante. Isso dá aos usuários do KDE 4 um potencial incrível para customização,
permitindo que desenvolvedores e/ou indivíduos alterem quase qualquer aspecto da experiência do desktop, alterando
completamente seu comportamento quando necessário. Por exemplo, se você quiser um ativador de aplicativos poderoso com
mais capacidade do que o padrão, utilize um ativador como Lancelot, que está atualmente em desenvolvimento. Se o espaço
for pequeno, grave um ativador de aplicativo mais parecido com o visto em DEs leves clássicos
(como XFCE), em que um simples pop-up é exibido com um clique com o botão direito, e remova o ativador comum para
fornecer mais espaço na tela.
Essa ideia simples deve permitir ao KDE 4 crescer em um desktop universal, pois distribuições e usuários
podem adaptar o KDE a várias configurações. Por exemplo, máquinas potentes podem se beneficiar com applets
e todos os seus adicionais grandes e complexos, enquanto máquinas com menos cavalo-vapor podem contar com versões
mais simples/leves dos componentes necessários e remover componentes desnecessários.
Além disso, não é mais necessário substituir o KDE 4 por um DE mais leve e especializado.
Embora esses applets de Plasma possam ser um pouco complicados, eles devem ser
aplicativos pequenos com estilo de utilitário, que você poderia preferir utilizar sempre em vez de aplicativos
completos. Normalmente eles são integrados em seu desktop e/ou barra de tarefas; alguns exemplos clássicos são monitores
de sistema, sistemas de mensagens instantâneas, ferramentas de redes de relacionamentos, etc.
Outro recurso de design comum é o seu uso relativamente pequeno de espaço na tela. Você não vai querer um monte
de plasmóides abertos no desktop todas as vezes, sem sobreposição. Eles não aparecem no gerenciador de janelas como janelas
separadas, portanto, você pode se mover rapidamente entre eles ou minimizá-los.
Além da tecnologia de restrição de Plasma básica, os desenvolvedores de KDE também tiveram o trabalho de
deixar a gravação de applets de Plasma poderosos o mais fáceis e flexíveis possível. Os recursos incluem:
- Suporte superior para scalar vector graphics (SVG) para todos os elementos da GUI. Todos
os aplicativos/applets podem então ser independentes de resolução com pouca escalação. O mesmo aplicativo parecerá bom
e se comportará bem em um monitor de alta definição de 30 polegadas e em uma tela de netbook de 8 polegadas—sem exigir nenhum
trabalho adicional do desenvolvedor.
- Excelente suporte para criação de temas. Os desenvolvedores são ativamente estimulados a consultar
todos os recursos como ícones, segundo plano, etc., utilizando caminhos relativos para que o KDE possa localizá-los no tempo de
execução com base no tema atualmente selecionado. Isso deve permitir que todos os aplicativos KDE 4 se beneficiem de um aspecto
consistente em diferentes temas, mais uma vez, sem trabalho adicional para o desenvolvedor.
- Suporte a várias linguagens. Os plasmóides do KDE 4 (como aplicativos KDE em geral) podem ser
gravados em inúmeras linguagens de programação diferentes. Este artigo se concentra em C++, mas outras linguagens estão
em desenvolvimento, como Ruby, Python e Javascript.
- Reutilização de componente. O KDE possui excelente suporte para permitir que componentes
reutilizem os serviços fornecidos pelos outros.
Agora que você tem um pouco de conhecimento sobre Plasma, vamos começar a gravar um plasmóide simples para
incluir em nosso desktop do KDE do 4.2.
O IDE do KDevelop 4
Estas instruções supõem que você esteja executando um desktop do KDE 4.2 Algumas ou todas as instruções
podem ser aplicáveis ao KDE 4.1, mas isso não foi confirmado.
Em primeiro lugar: Você precisa instalar todas as bibliotecas de desenvolvimento do KDE, cabeçalhos, etc.
Estou utilizando o release estável atual do Kubuntu 8.10 (Intrepid Ibex), fornecido com KDE 4.1 por padrão,
por isso tive que ativar os repositórios PPA para obter o KDE 4.2 e os cabeçalhos
(consulte
http://www.kubuntu.org/news/kde-4.2
para obter detalhes). (Esta etapa não é necessária para usuários do Kubuntu 9.04 (mas para instalar
g++ e kdesdk, etc, ela é). Observe que esta versão do KDE não é suportada atualmente pelo Canonical, portanto é melhor usar
um ambiente de desenvolvimento em vez de sua máquina principal.
Após o repositório PPA ser incluído, eu apenas instalei kdesdk, g++, cmake e alguns pacotes kde-dev, como a seguir:
Lista 1. Construindo o Ambiente de Desenvolvimento do KDE
sudo apt-get update
sudo apt-get install kdesdk
install cmake
sudo apt-get install g++
sudo apt-get install libphonon-dev libplasma-dev
|
Ela capturou tudo que eu precisava em minha máquina. Se você estiver utilizando outra distribuição, será
necessário determinar como instalar esses pacotes.
KDevelop 4 possui um modelo ideal para a geração automática de um plasmóide básico.
Infelizmente, no momento da gravação, o KDevelop 4 ainda está em beta, e não existe nenhum release binário disponível para
Intrepid, portanto, para seguir adiante,
você precisa construí-lo a partir da origem seguindo essas
instruções relativamente simples.
 |
Quando o KDevelop Não É Sua Escolha
Se você não quiser
utilizar o KDevelop, recomendo o excelente artigo de base tecnológica do KDE
Introdução," que explica seus princípios básicos. Se seguir as etapas, você vai terminar com um projeto bastante
semelhante ao que estamos criando com o KDevelop, e você pode pular para a seção "Modificando a Amostra." |
|
Após colocar o KDevelop em execução, conforme mostrado na Figura 1, abra o Projeto e selecione Novo do
Modelo. Quando o diálogo aparecer, expanda C++, em seguida, as ramificações do KDE e selecione Modelo de Applet
de Plasma. Em seguida, preencha o Nome do Aplicativo (sugiro dwPlasmoid). Em seguida, clique em Avançar e
Concluir.
Figura 1. Criação de Projeto
A caixa de diálogo final pede que você escolha um diretório Prefixo da Instalação (recomendo $HOME/plasmoids)
e um tipo de compilação (escolha Release ou
Depuração).
Isso deve criar o projeto. Pare um momento para ler os arquivos .cpp e .h bem documentados. Além disso, o
artigo de base tecnológica mencionado anteriormente tem explicações adicionais sobre o que o código está fazendo.
Agora que você criou o projeto, você está pronto para compilá-lo. Comece abrindo Projeto e escolhendo build (ou
pressionando F8). Na primeira vez, isso chamará configure, e depois disso, ocorrerá a compilação.
Supondo que a compilação tenha sido feita com sucesso, selecione Instalar no menu Projeto. Isso
copia os arquivos de instalação no diretório que você escolheu anteriormente. Se essa ação for concluída sem nenhum incidente,
você estará pronto para testar.
Antes de poder executar o novo plasmóide, você precisa informar o KDE sobre sua existência. Primeiro é
preciso conscientizar o KDE do diretório onde o plasmóide está instalado ($HOME/plasmoids). Comece abrindo um "konsole"
para configurar a variável de ambiente KDEDIRS e executando o comando kbuildsyscocoa4. Abra
um terminal e digite as linhas na Lista 2:
Lista 2. Conscientizando o KDE do Local do Plasmóide
export KDEDIRS=$KDEDIRS:$HOME/plasmoids
kbuildsyscocoa4
|
Agora que o KDE sabe do plasmóide, você pode tentar executá-lo.
plasmoidviewer é um utilitário conveniente que pode ser utilizado para fins de
teste. Obtenha-o digitando plasmoidviewer dwplasmoid. Você deverá ver o plasmóide de amostra
exibido em uma janela conforme mostrado na Figura 2:
Figura 2. Seu Plasmóide Básico
Como isso é um plasmóide, você também pode integrá-lo ao desktop. Entretanto, se tentar incluir o plasmóide
agora (utilizando o item de menu Incluir Widgets no desktop), você verá dwPlasmoid na lista de plasmóides, mas
se tentar incluí-lo, ele não funcionará! Embora KDEDIRS tenha sido configurado corretamente quando
você executou kbuildsyscocoa4, ele não foi configurado corretamente no ambiente quando o desktop
do Plasma foi iniciado, portanto, ele não poderá localizar todos os arquivos necessários.
Você pode corrigir isso encerrando a atual instância do Plasma que está em execução e reiniciando-a a
partir da linha de comandos (utilize a mesma de antes para que o KDEDIRS permaneça configurado
corretamente; caso contrário, reconfigure-o antes de executar os comandos a seguir). Observe que isso vai encerrar e
reiniciar o Plasma graciosamente, portanto, certifique-se de não estar fazendo nada que possa ser interrompido por essa
ação (por exemplo, salvar um trabalho não salvo em outros plasmóides). Você encerra a atual instância do Plasma conforme
mostrado na Lista 3.
Lista 3. Encerrando a Atual Instância do Plasma
kquitapp plasma && kstart plasma
|
Agora você deve estar preparado para incluir o plasmóide no desktop, e ele permanecerá lá exibindo seus
ícones e suas mensagens simples o dia inteiro. Você pode até incluir três deles e se beneficiar com os recursos de rotação
e escalação integrados, conforme mostrado na Figura 3:
Figura 3. Várias Instâncias do Plasmóide Integrado no Desktop
Uma alternativa para o que acabei de mostrar é configurar o diretório de instalação para /usr (supondo que
ele seja o diretório onde o KDE está instalado no sistema). Isso causará falha da etapa de instalação, a menos que você
execute o KDevelop como um superusuário (ou faça a instalação manualmente como superusuário mudando para o diretório de
compilação, $HOME/projects/dwPlasmoid/build, e executando sudo make install).
Nota:: Se quiser manter esses plasmóides em seu desktop, e quiser que eles trabalhem após uma
reinicialização sem parar e iniciar o Plasma novamente, você vai precisar dizer ao KDE 4 para examinar seu diretório
do plasmóide na inicialização. Uma maneira de se fazer isso é incluir uma linha no arquivo kde4rc (/etc/kde4rc), como
mostra a Lista 4:
Lista 4. Dizendo ao KDE para Examinar o Diretório do Plasmóide na Inicialização
[Directories]
prefixes=/home/martynh/plasmoids
|
Modificando a Amostra
Bem, agora que temos um plasmóide simples, vamos fazer com que ele faça coisas mais interessantes do que
apenas exibir textos estáticos.
Vamos transformar o plasmóide em um monitor de memória simples.
Primeiro, tente organizar a bagunça na janela removendo o ícone e o plano de fundo. No construtor
(dwPlasmoid::dwPlasmoid), você vai comentar a linha do código que define o
plano de fundo, conforme mostrado na Lista 5:
Lista 5. Comentando a Linha do Código que Define o Segundo Plano
// setBackgroundHints(DefaultBackground);
// m_svg.setImagePath("widgets/background");
|
Em seguida, no método de interface de coloração (dwPlasmoid::paintInterface), comente a linha
da parte que inclui o ícone, como mostra a Lista 6:
Lista 6. Comentando a Linha do Código que Inclui o Ícone
// p->ldrawPixmap(7, 0, m_icon.pixmap((int)contentsRect.width(),
(int)contentsRect.width()-14));
// p->save();
|
Se reconstruir e reiniciar tudo isso como antes, você verá que agora a janela é apenas uma janela preta
com o texto "Hello Plasmoid", conforme mostrado na Figura 4:
Figura 4. Plasmóide com Plano de Fundo e Ícone Removidos
Em seguida, você vai substituir o texto por algo um pouco mais útil: algumas informações em tempo real
sobre o uso de memória do sistema.
Se estiver familiarizado com Linux®, talvez você saiba que existem inúmeros arquivos especiais sob
o diretório /proc que dão informações em tempo real sobre o sistema em execução. O arquivo no qual estamos interessados
é o /proc/meminfo. Você pode examinar o conteúdo desse arquivo digitando este comando:
cat /proc/meminfo. Esse comando mostra várias informações sobre o estado atual
da memória em nosso sistema.
Vamos alterar o programa que construímos para que ele leia periodicamente esse arquivo e exiba as
informações dentro do plasmóide. Comece lendo o arquivo e extraindo as informações. Felizmente, o kit de ferramentas
Qt torna isso relativamente simples.
Você vai criar um novo método e vai incluir algumas novas variáveis de membro na classe. No arquivo de
cabeçalho, você vai incluir o método como um slot, conforme mostrado na Lista 7 (você verá o porque em breve):
Lista 7. Incluindo o Método como um Slot
public slots:
void updateMemoryCount();
|
Em seguida, inclua algumas novas variáveis de membro privadas, conforme mostrado na Lista 8:
Lista 8. Incluindo Novas Variáveis de Membro Privadas
private:
Plasma::Svg m_svg;
KIcon m_icon;
int m_totalMemory;
int m_freeMemory;
int m_swapMemory;
int m_freeSwapMemory;
|
Em seguida, coloque a implementação no arquivo cpp, conforme mostrado na Lista 9:
Lista 9. Incluindo a Implementação no Arquivo cpp
#include <QFile>
...
void dwPlasmoid::updateMemoryCount()
{
// abra o arquivo
QFile file("/proc/meminfo");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
exit(-1);
}
QTextStream in(&file);
QString line = in.readAll();
// remova quaisquer caracteres estranhos
line = line.simplified();
// extraia as informações nas quais estamos interessados utilizando uma
expressão regular
QRegExp regex("MemTotal: (\\d+).*MemFree: (\\d+).*SwapTotal: (\\d+)"
".*SwapFree: (\\d+)"); regex.indexIn(line);
m_totalMemory = (regex.cap(1).toInt());
m_freeMemory = (regex.cap(2).toInt());
m_swapMemory = (regex.cap(3).toInt());
m_freeSwapMemory = (regex.cap(4).toInt());
// force uma nova remoção
update();
}
|
Esse método abre o arquivo, lê o conteúdo e extrai os valores nos quais estamos interessados utilizando uma
expressão regular.
Em seguida, você precisa alterar o método de coloração (dwPlasmoid::paintInterface) para
incluir essas informações, e não a mensagem existente, conforme mostrado na Lista 10:
Lista 10. Alterando o Método de Coloração
int percentageFreeMem = (m_freeMemory * 100) / m_totalMemory;
int percentageFreeSwap = (m_freeSwapMemory * 100) / m_swapMemory;
char message[256];
sprintf(message,"Total Memory: %d\nFree Memory: %d\nPercent free mem: %d\n"
"Total Swap: %d\nFree Swap: %d\nPercent free swap: %d",
m_totalMemory, m_freeMemory, percentageFreeMem,
m_swapMemory, m_freeSwapMemory, percentageFreeSwap);
p->setPen(Qt::white);
p->drawText(contentsRect,
Qt::AlignTop | Qt::AlignHCenter,
message);
p->restore();
|
Por fim, coloque uma chamada para updateMemoryCount no construtor para ler os
valores iniciais para os números da memória:
updateMemoryCount();.
Se compilar e executar isso, você verá que será exibido o uso de memória correto de quando o plasmóide for
iniciado, como mostra a Figura 5:
Figura 5. Um Monitor de Memória Estática
Isso é um progresso, mas uma exibição estática do uso de memória do sistema não é tão interessante. A parte
final do enigma é fazer o plasmóide se atualizar periodicamente para fornecer as leituras atuais durante todo o seu ciclo de
vida. Isso é fácil porque você declarou o método de atualização como um slot. Você só precisa incluir o seguinte no
método init, como mostra a Lista 11:
Lista 11. Fazendo o Plasmóide se Atualizar Periodicamente
#include <QTimer>
...
// Inicie um cronômetro de atualização
QTimer* m_timer = new QTimer(this);
connect(m_timer, SIGNAL(timeout()), this, SLOT(updateMemoryCount()));
m_timer->start(1000);
|
Isso inicia um cronômetro que é disparado a cada segundo e que chama o slot updateMemoryCount.
Se compilá-lo e iniciá-lo, você verá que ele será atualizado automaticamente a cada segundo!
Figura 6. Atualizando Dinamicamente Plasmóides de Memória
Integrados no Desktop
Observe que esses valores não estão necessariamente sincronizados. Essas instâncias do plasmóide foram
incluídas em momentos diferentes, portanto, cada uma iniciou seu cronômetro em um momento diferente.
Conclusão
Como você pode ver, em um curto período de tempo, você pode gravar um monitor de memória razoavelmente
sofisticado integrado em seu desktop.
A tecnologia de plasmóides permite gravar utilitários/monitores poderosos e com várias finalidades. E
consideravelmente, os plasmóides são tão simples que você pode gravar utilitários bastante especializados que sejam
úteis para você e que se integrem perfeitamente ao seu ambiente de desktop.
Espero que este artigo inspire você a continuar e a criar plasmóides interessantes. Utilize a seção de
comentários abaixo para contar para mim e para outros leitores sua experiência e seus resultados.
Download | Descrição | Nome | Tamanho | Método de download |
|---|
| Code samples for this article | code.zip | 23KB | HTTP |
|---|
Recursos Aprender
Obter produtos e tecnologias
-
Com o
software de teste da IBM,
disponível para download diretamente a partir do developerWorks, construa seu próximo projeto de desenvolvimento no Linux.
Discutir
-
Envolva-se na
comunidade do My developerWorks; com seu perfil pessoal e sua página inicial customizada, você pode padronizar o developerWorks de
acordo com seus interesses e interagir com outros usuários do developerWorks.
Sobre o autor | 
| | Martyn Honeyford se formou pela Nottingham University com BSc em ciência de computação em 1996. Ele trabalhou como engenheiro de software em vários estilos desde então. Como sua carreira de snowboarding internacional passou a dar sinais de que não iria decolar, e ele ainda tinha que encontrar uma maneira de pagar as contas jogando vídeo game, seu trabalho
hoje é como Desenvolvedor Sênior de Java para uma empresa de comércio derivativo on-line em Londres. |
Avalie esta página
| 
