Getting Started/Set up KDE 4 for development (pt BR)

Configurações do KDE 4 para desenvolvimento

Tutorial Series	Começando
Previous	Compilando o KDE 4
What's Next	Outros tópicos de desenvolvimento
Further Reading	n/a

{{{3}}}

Esta página presume que você tenha compilado kdelibs, kdepimlibs, e kdebase de acordo com estas instruções
Nota

Iniciando aplicativos de KDE 4 & sessões

Quando você começa o desenvolvimento para o KDE 4, geralmente há três opções disponíveis para você:

Você pode executar os aplicativos do KDE 4 ao lado de outros aplicativos no seu ambiente de trabalho atual.
Você pode inserir uma sessão do KDE 4 no seu ambiente de trabalho atual.
Você pode executar o KDE 4 como único ambiente de trabalho na sua máquina.

As três opções são descritas nas seções seguintes.

{{{3}}}

Se você obtiver erros ao executar qualquer aplicativo kde4, tais como:

 Qt: Session management error: Could not open network socket
 QMutex::lock: Deadlock detected in thread -1241241936

ou quando você executar startkde e ficar emperrado, leia este artigo para a solução.

Nota

Iniciando aplicativos do KDE 4

Usando o shell normal com sux

Para este método, é necessária a ferramenta sux (http://fgouget.free.fr/sux/sux-readme.shtml). sux está disponível na maioria das distribuições. De outro modo você pode contar com o método abaixo shell normal sem sux. sux permite que você mude para outro usuário com um gerenciamento implícito dos detalhes de encaminhamento de X (autenticação e exportação de DISPLAY) de uma forma clara e simples.

Para fazer o login, digite sux - kde-devel

Todas as variáveis de ambiente e todo o resto devem ser configurados corretamente pelo seu.bashrc. Para iniciar um aplicativo, basta digitar seu nome; por exemplo kwrite

{{{3}}}

Se você receber erros sobre mimetypes ausentes ou algo parecido, tente o seguinte:

execute unset XDG_DATA_DIRS ; kbuildsycoca4

Nota

Usando o shell normal sem sux

O método mais simples para iniciar aplicativos do KDE 4 é usando su para logar como usuário kde-devel e, em seguida, iniciar qualquer aplicativo do KDE 4 a partir da linha de comando. Para fazer o login, digite

su - kde-devel

e, em seguida, depois de digitar sua senha export DISPLAY=:0

{{{3}}}

A exportação da variável `DISPLAY` é necessária para que os aplicativos do KDE 4 apareçam normalmente no seu KDE 3 desktop.
Nota

Todas as variáveis de ambiente e todo o resto devem ser configurados corretamente pelo seu .bashrc. Para iniciar um aplicativo, basta digitar seu nome; por exemplo kwrite

{{{3}}}

Se você receber erros sobre mimetypes ausentes ou algo parecido, tente o seguinte:

execute unset XDG_DATA_DIRS ; kbuildsycoca4

Nota

{{{3}}}

{{{1}}}
Nota

Usando SSH

A maneira mais simples de executar um aplicativo do KDE 4 com SSH em seu ambiente de trabalho é obter um shell capaz de perceber que roda dentro do X como um usuário kde-devel como este: ssh -X kde-devel@localhost Agora você pode executar aplicativos do KDE apps como de costume, por exemplo: kwrite As duas linhas podem ser convenientemente combinadas: ssh -X kde-devel@localhost kwrite

{{{3}}}

Se isso lhe der alguns erros, tente as dicas para solução de problemas da seção acima.
Nota

Login sem senha

Antes de fazer qualquer coisa importante usando este método, um login sem senha precisa ser configurado. Para começar, execute o seguinte comando como usuário normal do desktop: ssh-keygen -t rsa Aperte enter três vezes para aceitar o caminho de ~/.ssh/id_rsa e uma senha vazia. Agora, copie a única linha no ~/.ssh/id_rsa.pub que é exibida depois da execução deste comando: cat ~/.ssh/id_rsa.pub Depois que a linha for copiada, volte ao ssh no usuário kde-devel e coloque-a no arquivo $HOME/.ssh/authorized_keys: ssh -X kde-devel@localhost $HOME/kde/bin/kwrite \

 $HOME/.ssh/authorized_keys

Cole na linha, salve o arquivo, e saia do KWrite.

Em seguida certifique-se de que $HOME/.ssh/authorized_keys tem as permissões corretas: ssh kde-devel@localhost chmod og-xrw ~kde-devel/.ssh/authorized_keys Agora tente executar KWrite novamente com o mesmo comando SSH, você não deve mais ter que digitar uma senha: ssh -X kde-devel@localhost $HOME/kde/bin/kwrite

{{{3}}}

Ao usar um login SSH sem senha existem certos riscos de segurança, então assegure a proteção de seu arquivo `~/.ssh/id_rsa` restringindo o acesso a ele com `chmod og-xrw ~/.ssh/id_rsa`(embora o arquivo deva ter essas permissões quando é criado)
Aviso

O arquivo SSH desktop

Se você quiser iniciar os aplicativos de um modo mais fácil que executando-os com um comando SSH a partir da linha de comando, crie um arquivo .desktop para o ssh em outra conta.

{{{3}}}

Isso só será útil se o seu ambiente de trabalho suportar arquivos .desktop, mas pelo menos o KDE e o GNOME suportam.
Nota

Você pode começar com um arquivo .desktop existente como modelo (como um de seu desktop) ou você pode criar um novo. A ideia principal é prefixar o comando a ser executado com esta string: ssh -X kde-devel@localhost $HOME/kde/bin/

Um simples arquivo .desktop que roda KWrite teria o seguinte conteúdo:

[Desktop Entry] Categories=Qt;KDE;TextEditor; Comment= DocPath=kwrite/index.html Encoding=UTF-8 Exec=ssh -X kde-devel@localhost /home/kde-devel/kde/bin/kwrite %U GenericName=Text Editor Icon=kwrite InitialPreference=8 MimeType=text/plain Name=KWrite (kde-devel) Path= StartupNotify=false Terminal=false TerminalOptions= Type=Application X-DBUS-StartupType=Multi X-DCOP-ServiceType=non X-KDE-StartupNotify=true X-KDE-SubstituteUID=false X-KDE-Username=

{{{3}}}

Aplicativos iniciados usando o SSH como esse não provocam o correto lançamento de respostas, então você provavelmente vai querer desativar "feedback de lançamento" para o seu arquivo .desktop
Dica

{{{3}}}

Para criar um arquivo .desktop de um aplicativo do KDE 4 usando esse padrão, o pacote do aplicativo terá que ter sido instalado em `~/kde/bin` usando o comando `cmakekde`
Nota

Iniciando sessões do KDE 4

Sessão aninhada do KDE 4

Aninhada

Em vez de usar um novo X virtual já desenvolvido para o desenvolvimento de software você pode utilizar o Xephyr para incorporar sua sessão do KDE 4 em sua sessão de trabalho do KDE 3 ou outro ambiente X11.

Você também pode fazer isso com o xnest, mas como xnest não consegue lidar com extensões como Render muitas pessoas preferem Xephyr.

Se você quiser ter uma sessão mínima do KDE instalada e funcionando, apenas inicie Xephyr (disponível no Kubuntu como xserver-xephyr; Usuários do Gentoo compilem x11-base/xorg-server com USE="kdrive"):

Xephyr :1 -extension GLX &

Agora você já pode iniciar o KDE:

su - $USER export DISPLAY=:1 /path/to/kde4/bin/startkde-modified &

startkde-modified é uma cópia de startkde-script que incluem as seguintes linhas no topo:

export KDEDIR=`kde4-config --prefix` export LD_LIBRARY_PATH=$KDEDIR/lib export PATH=$KDEDIR/bin/:$PATH export KDEHOME=~/.kde4

Você também pode usar Xephyr com KDM através do protocolo Xdmcp e simplesmente uma nova sessão do KDE 4 para KDM.

No Kubuntu, você pode habilitá-lo alterando

[Xdmcp]


 Whether KDM should listen to incoming XDMCP requests.
 Default is true

Enable=false

em /etc/kde3/kdm/kdmrc para

[Xdmcp]


 Whether KDM should listen to incoming XDMCP requests.
 Default is true

Enable=true

e ajustar seu /etc/kde3/kdm/Xaccess para permitir seu acesso à máquina local. Além disso, você deve certificar-se de criar uma política de bloqueio de porta em todas as interfaces externas para a porta Xdmcp, se você está fazendo isto em um laptop ou um PC em um ambiente não confiável.

Se você estiver pronto, basta iniciar Xephyr:

Xephyr -query localhost :1 -host-cursor -screen 1024x768&

onde -host-cursor tenta reutilizar o cursor do host e -screen define as dimensões da tela.

Nota: Se você tiver muitos erros de conexão recusada, você pode usar a opção -ac do Xephyr. Por exemplo:

Xephyr -ac :1&

Uma outra opção para tentar caso receba muitos erros de conexão recusada é garantir o acesso do seu usuário kde-devel ao seu servidor X. Como root ou usando sudo:

xhost +local:kde-devel

Se você não tem Xephyr, você pode também usar Xnest:

Xnest -ac :1& export DISPLAY=:1


Esta seção precisa de melhorias: Por favor, ajude-nos a limpar seções confusas e consertar seções que contenham um todo

Sping 00:25, 9 April 2007 (CEST)

Eu uso isso para meu script de inicialização nested_kde4.sh:

#! /bin/bash
NESTED_KDE_DISPLAY_BACKUP=$DISPLAY
export DISPLAY=:0
Xephyr :1 -screen 1024x768 &
export DISPLAY=:1
$HOME/kde/bin/startkde-modified &
export DISPLAY=${NESTED_KDE_DISPLAY_BACKUP}

Se você se deparar com

"Call to lnusertemp failed (temporary directories full?).
 Check your installation."

tente isto:

mkdir /var/tmp/kde-devel-kde4

O código acima assume que você trabalha com o usuário kde-devel.

{{{3}}}

Na maioria dos casos você tem que substituir startkde-modified por startkde
Nota

Sessão solitária do KDE 4

Solitária

Para executar uma sessão completa do ambiente de trabalho KDE 4, você pode começar a partir da linha de comando como normalmente faria, com algo parecido com isso:

X :1 & export DISPLAY=:1
startkde

{{{3}}}

Se o servidor X recusar a conexão dizendo algo como: `Xlib: connection to ":1.0" refused by server`, tente `X -ac :1` como alternativa.
Nota

ou você pode adicioná-lo ao seu gerenciador de login. Se você estiver usando o KDM (ou um gerenciador de login compatível) isso é feito criando um arquivo .desktop em `kde-config --prefix`/share/apps/kdm/sessions/ ou em /usr/share/xsessions/. A melhor coisa a fazer é copiar um arquivo existente kde.desktop e nomeá-lo kde4.desktop. Abra esse novo arquivo .desktop em um editor de texto e mude o Exec, TryExec e Name entradas para algo parecido com isso:

Exec=$HOME/kde/bin/startkde TryExec=$HOME/kde/bin/startkde Name=KDE4

Substitua $HOME/kde no exemplo acima pelo prefixo no qual você está instalando o KDE4.

Depois de reiniciar o gerenciador de login (Alt+e in KDM) essa nova entrada aparecerá no menu de sessões.

Você pode ter que editar seus scripts startkde,ou seja, mudar

esse kdehome=$HOME/.kde para esse kdehome=$HOME/.kde4 ou colar esse export KDEDIR=`kde4-config --prefix` export LD_LIBRARY_PATH=$KDEDIR/lib export PATH=$KDEDIR/bin/:$PATH export KDEHOME=~/.kde4 no topo.

{{{3}}}

Você deve ter um caminho para o programa 'qdbus' (geralmente ele é $QTDIR/bin) em seu $PATH para logar com êxito. Se ele não estiver lá, você vai receber uma mensagem de erro "Não foi possível iniciar DBus. Verifique sua instalação."
Nota

Tarefas do Desenvolvimento

KDevelop

Esta seção irá explicar como usar o KDevelop 3.4 para desenvolver aplicativos do KDE 4. Se você tiver dúvidas, correções ou reclamações sobre esta seção, por favor poste-as na página de discussão.

Pré-requisitos

Você precisa de pelo menos KDevelop 3.4 para isto, que ainda é um aplicativo do KDE 3. Versões inferiores a 3.4 não têm suporte ao Qt 4, entre outras coisas. A versão KDE 4 do KDevelop ainda não está pronta para o desenvolvimento sério. Você pode obter o KDevelop em KDevelop homepage. Certifique-se de instalar o KDevelop como todos os aplicativos do KDE 3, não com seu usuário kde-devel.

Você também precisa da versão mais recente do GDB, que atualmente é a 6.6.0. Note que a versão do GDB que é fornecida com o openSuse 10.3 está quebrada, ela constantemente quebra ao analisar as variáveis (que o KDevelop faz automaticamente). Use ao invés disso a versão do GDB deste repositório.

Você precisa ter a documentação da API kdelibs localmente, que está descrita em instruções de compilação.

Você também precisa de ctags, htdig, htmerge e htsearch. valgrind e callgrind também podem ser úteis.

Certifique-se de que você seguiu os passos das instruções de compilação do KDE 4 e tem um ambiente de trabalho KDE 4. Verifique se aplicativos simples do KDE 4 como Konsole ou KWrite podem ser iniciados pela linha de comando do usuário kde-devel sem problemas.

Os passos seguintes são todos feitos com usuário kde-devel. Você precisa logar como esse usuário digitando

su - kde-devel

Configurando o ambiente

KDevelop não tem suporte nativo para projetos CMake. Felizmente, o CMake tem a capacidade de gerar arquivos próprios de projeto do KDevelop. Se quiser fazer isso, você precisa passar a bandeira -GKDevelop3 para o comando cmake. Isto diz ao CMake para gerar arquivos de projeto para o KDevelop ao lado do makefiles normal. A melhor maneira de fazer isto é alterar a sua função cmakekde no seu .bashrc. Basta alterar cmake $srcFolder -DCMAKE_INSTALL_PREFIX=$KDEDIR \ -DCMAKE_BUILD_TYPE=debugfull&& \ make && \ make install; para cmake $srcFolder -GKDevelop3 -DCMAKE_INSTALL_PREFIX=$KDEDIR \ -DCMAKE_BUILD_TYPE=debugfull&& \ make && \ make install;

Depois de ter feito isso, faça o login novamente para que as alterações no arquivo .bashrc tenham efeito. Então você precisa executar novamente o cmakekde no (root) diretório de compilação do projeto se você quer trabalhar com KDevelop (se você não usa -GKDevelop3 na etapa de compilação). Por exemplo, se você quiser trabalhar com o Konsole, que existe no kdebase, você precisa executar cmakekde no diretório $KDE_BUILD/KDE/kdebase. Este, infelizmente, reconstrói tudo completamente, mas apenas uma vez quando você alterar o gerador.

Como todas as variáveis de ambiente do usuário kde-devel são específicas do KDE 4, estas precisam ser retrocedidas para corresponder ao seu ambiente KDE 3 antes de iniciar o KDevelop. Uma maneira simples de fazer isso é adicionar a seguinte função para o seu .bashrc:

function start3app {


 mkdir -p /tmp/$USER-kde
 export PATH=/opt/kde3/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11:/usr/games 
 export LD_LIBRARY_PATH= 
 export KDETMP=/tmp/$USER-kde 
 export KDEVARTMP=/var/tmp/$USER-kde 
 export KDEHOME=$HOME/.kde 
 export KDEDIR=/usr 
 export KDEDIRS=$KDEDIR 
 export DISPLAY=:0 
 eval "$@"
 source $HOME/.bashrc   #Reset environment variables again

}

As variáveis PATH e LD_LIBRARY_PATH são tomadas do usuário do KDE 3, e elas podem ser diferentes em seu sistema. Digite echo $PATH e echo $LD_LIBRARY_PATH como usuário KDE 3 normal para obter esses valores. A função acima assume que o KDE 3 está instalado no prefixo /usr, como é o caso em sistemas baseados em Debian. Se o seu KDE 3 está instalado em um prefixo diferente,você precisa alterar a configuração da linha KDEDIR. Aqui está um exemplo de como descobrir o seu prefixo de instalação KDE; neste exemplo ele é /opt/kde3:

kde-config --prefix /opt/kde3

Agora você deve ser capaz de iniciar o KDevelop digitando start3app kdevelop. Faça isso agora.

{{{3}}}

Você pode iniciar qualquer aplicativo do KDE 3 com a função start3app. Candidatos úteis incluem Kompare e kdesvn.

No entanto, você não pode iniciar KDbg desta forma para depurar aplicativos do KDE 4, já que as variáveis de ambiente para depurar aplicativos estão erradas.

Dica

Resolução de Problemas

Sintoma: kdevelop diz "cannot talk to klauncher". Você não pode abrir um arquivo.

Solução: adicione seu caminho da biblioteca do KDE library a LD_LIBRARY_PATH, por exemplo:

export LD_LIBRARY_PATH=/opt/kde3/lib

Configurando o KDevelop

Agora que o KDevelop foi iniciado, você precisa ajustar algumas configurações. Vá até Settings->Configure KDevelop...->Documentationpara fazer isso.Remova todas as entradas que não são relevantes para a codificação no KDE 4.

{{{3}}}

Embora as variáveis de ambiente como $ HOME sejam usados nesta seção, você deve substituí-las por caminhos reais, porque o KDevelop não resolve variáveis de ambiente.
Nota

Opcionalmente, você pode adicionar a documentação da API kdelibs. Você deve criá-la previamente. Então adicione a documentação clicando em Add.... Neste diálogo, use as seguintes configurações:

Type: Doxygen Documentation Collection (precisa ser configurada primeiro)
Location: $KDE_SRC/KDE/kdelibs/kdelibs-apidocs/index.html

Agora adicione a documentação da API Qt, que também deve ser criada previamente , usando as seguintes configurações:

Type: Qt Documentation Collection (precisa ser configurada primeiro)
Location: $HOME/qt-copy/doc/html/qt.dcf

Depois de ter adicionado a documentação da API kdelibs e Qt, certifique-se de que todas as caixas (TOC,Index and Search) estão habilitadas. Então, vá para a aba Full Text Search e certifique-se de que os caminhos para os executáveishtdig, htmerge e htsearch estão corretos. Você pode então fechar a janela de configuração.

Agora é hora de abrir o projeto que você quer trabalhar clicando em Project->Open Project.... Os arquivos do projeto estão localizados no diretório de compilação. Por exemplo, se você quer trabalhar com o Konsole,você precisa abrir $KDE_BUILD/KDE/kdebase/apps/konsole/konsole.kdevelop. Você agora precisa ajustar algumas configurações específicas do projeto em Project->Project Options. Você precisa fazer isso toda vez que começa a trabalhar em um projeto diferente.

{{{3}}}

Às vezes, um arquivo de projeto KDevelop não está presente na pasta que você deseja trabalhar.

Isto pode ter vários motivos, depende de como os arquivos CMake são escritos. Normalmente, arquivos do CMake que tenham uma declaração project(projectname) funcionam bem. Se você estiver bastante familiarizado com o CMake, você pode tentar adicionar essa declaração.

Uma solução para isso é simplesmente usar o arquivo de projeto KDevelop da pasta pai, ou até mais. Nesse caso, você precisa usar a entrada Make Active Directory no menu de contexto da aba lateral File Selector. Com isso, você pode ignorar as outras pastas indesejadas quando for compilar e instalar.

Nota

C++ Support->Code Completion

Here you need to add code completion databases for Qt and kdelibs, and more if you like, for example you might need a database for kdepimlibs when working on kdepim.

For kdelibs, click the Add... button and choose KDevelop Custom Directory PCS Importer, then add your KDE include directory ($HOME/kde/include) to the list and proceed. You can use the file selection dialog and the Add button to add it.

Now, add the database for Qt 4 by selecting KDevelop Qt4 PCS Importer this time. You need to select the Qt 4 include directory, which is $HOME/qt-copy/include.

Note
The Qt4 PCS Importer is only needed if you didn't install Qt4, i.e. you use it directly from the build directory. The drawback of using the Qt4 importer is that it doesn't show progress and the application seems to hang while it imports. The alternative is to use the Custom Directory PCS Importer for this too

C++ Support->Qt Options

Check Enable Qt options and choose Qt4 as your version. Set the QMake Binary path to $HOME/qt-copy/bin/qmake. Then choose Qt 4 style as Qt include syntax. Use $HOME/qt-copy/bin/designer as Designer Binary. Make sure to use the Change Plugin Paths dialog to add the plugin directory from KDE so you see the KDE widgets when designer is started. To do this add $HOME/kde/lib/kde4/plugins to the lineedit and then click the Add button.

Run Options

Make sure you use the correct binary as Executable. For example, if you want to run Konsole, this is $KDE_BUILD/KDE/kdebase/apps/konsole/src/konsole. You should add --nofork to the Debug Arguments or debugging some applications like KMail will not work at all.

Because the start3app functions changes some environment variables, you need to change them back here so the KDE 4 applications can be run without problems from within KDevelop.

For some applications, like Konsole, this is not strictly necessary, but others like KMail will crash if you do not change this.

Simply click the Add / Copy button to add new environment variables. You will need the following, which are the same as in your .bashrc:

Name	Value
KDEHOME	$HOME/.kde4
PATH	$KDEDIR/bin:$QTDIR/bin:/usr/local/bin:$PATH
LD_LIBRARY_PATH	$KDEDIR/lib:$QTDIR/lib:$LD_LIBRARY_PATH
KDETMP	/tmp/$USER-kde4
KDEVARTMP	/var/tmp/$USER-kde4
KDEDIR	$HOME/kde
KDEDIRS	$KDEDIR
LD_BIND_NOW	42

Build Options->Build

Make sure the correct build directory is selected. Again, for Konsole, this would be $KDE_BUILD/KDE/kdebase/apps/konsole.

Build Options->Make

You might want to check Abort on first error. You also might want to add VERBOSE= or VERBOSE=1 to Additional make options to control the level of verbosity for the build process.

If you have more than one processor or if you have access to an icecream cluster, you might want to check the Run multiple jobs option and set the Number of simultaneous jobs to the number of available processors. This increases the compile speed. It is the same as the -j option for make.

Formatting

You should set all options here to match the coding style of the project you are working on.

CTags->General

You need to correctly set the Path to ctags binary, which is /usr/bin/ctags on Debian-based systems.

You probably want to enable the When more than one hit, go directly to the first option.

Now you have finished adjusting your project-specific settings. Now you should remove some plugins you do not need, in Settings->Configure Plugins.... I for example disable the following plugins:

Abbreviation Expansion, Code Snippets, Doxygen Support, Embedded Konsole, File Tree, Final Packaging Support, "Open with" Menu Addon, QuickOpen, Regular Expression Tester, Scripting, Security Checker, Shell Filtering and Insertion, Text Structure and Tools Menu Addition.

You should at least disable the bold ones.

Now, open any source file if none is open already. This will enable the Settings->Configure Editor... entry, where you need to set the tab options to match the tab style used by the project you are working on. The important settings are:

Appearance->Borders->Show line numbers: Should be checked.
Appearance->Borders->Show icon border: Should be checked.
Editing->Tabulators
Editing->Static Word Wrap->Show marker: Should be checked
Indentation->Automatic Indentation->Indentation mode: Should be C Style
Indentation in general

In the mainwindow, click the CTags tab on the bottom tabbar, then click the Regenerate button to create a CTags database for easier source code navigation.

Now you have completed all essential configuration, congratulations!

Using KDevelop

Refer to the KDevelop manual for general help using KDevelop. The following section will only deal with special cases for KDE 4.

Debugging

KDE apps have many symbols, which means that you need a lot of memory to get a decent loading times for debugging. To quote a GDB developer: "I would be reluctant to debug KDE on something with <1GB RAM." If the stepping function of the debugger is slow for you, try the following tips:

Hide local variables. The Locals part of the variable tab on the left causes a big slowdown when stepping if you have many local variables. Simple collapse the Locals part of the tree, the local variables are then not updated every step. You can still examine variables by using the Evaluate expression function.
Use the patch at http://bugs.kde.org/show_bug.cgi?id=143977. It prevents the update of the framestack widget at each step, speeding up stepping considerably. The patch introduces some minor glitches, which is why it is not yet commited.

Note
KDevelop does not yet support modifing the CMake build system. This means you can not use KDevelop to add or remove files from the project or to change any other aspect of your project's build process. You need to modify the CMake files by hand and then rerun `cmakekde` instead. Read the CMake tutorial to learn how to do this.

Tip
When you work on libraries, you first need to install them before you can test or debug your changes. Since this is cumbersome and time consuming, you should create symlinks (ln -s) pointing from the build directory to the installation directory for all affected libraries. Often, even simple programs use libraries internally, for example the settings dialog of Konsole is really a library.

Eclipse

KDE4's ktimetracker loaded as eclipse project

This describes how to use Eclipse to develop KDE 4 applications. It has been tested with Eclipse Ganymed and SUSE Linux 11.1 but should work same or similar with every combination. As an example KDE application we use ktimetracker from the kdepim module, other applications short work analog.

Using this description you will be able to

update your working copy of KDE source code using the command svn
build your KDE module using cmake
build your KDE application from within eclipse using make
compile and run your application with one click from eclipse
get auto-completion when editing KDE source code
have an overview and navigation about your classes within eclipse
have call trees for your functions

Set up Eclipse with KDE

Check your requirements

Trying with a virtual machine I had problems starting Eclipse with less than 1 GB RAM. After assigning 3 GB RAM to my virtual machine, Eclipse finally started.

Install eclipse

Download Eclipse IDE for C/C++ developers from http://www.eclipse.org. We unpack it to /home/user/eclipse.

Install the CDT

Download the Eclipse IDE for C/C++ Developers (68 MB) from http://www.eclipse.org/cdt/ and unpack it into your eclipse folder, in our case /home/user/eclipse.

Download kdepim

As said, we use kdepim as example here. So, download ("checkout") kdepim using svn, e.g. as anonymous:

svn co svn://anonsvn.kde.org/home/kde/trunk/KDE/kdepim

We assume you checked out into /home/user/kdepim.

Compile kdepim

Compile kdepim so the usual makefiles are present for all kdepim applications. If you have problems doing this, follow our build instructions

Import your project into eclipse

Surprise: To import your project, you should not use "File -> Import". Rather do: File -> New -> C++ Project -> Makefile project -> Empty Project -> un-tag "use default location" -> choose /home/user/kdepim/ktimetracker. Call it "ktimetracker".

Build your project

Make sure Project -> Properties -> C/C++ Build -> Builder Settings -> Build location -> Build directory is set correctly.

Choose Project -> Build Project

Run the project

Choose Project -> Properties -> Run/Debug Settings -> New. As project, enter ktimetracker, as C/C++ Application, enter /home/user/kdepim/ktimetracker/ktimetracker. Choose Apply -> Ok -> Ok. Now you can click on the "Run" button and start it.

Know-How

Custom builders

If you want to integrate the cmake build step into your build toolchain, you will need to

create a custom builder like this:

cat >/bin/eclipsebuild<<EOF
cmake . && make -j4 && make install
EOF
chmod 777 /bin/eclipsebuild

Add your builder

Choose Project -> Properties -> Builders. Un-tag all existing builders. Click "new" -> Program -> (name it "Builder for KDE"). -> Location: /bin/eclipsebuild -> Working directory /home/user/workspace/myproject1/kdepim.

Build

Now you can build your project. Every time after you restarted eclipse, choose myproject1 -> Project -> Properties -> C/C++ Build -> Ok -> Project -> Build.

Revert what eclipse did

To revert what eclipse did to your project simply run

rm -rf .externalToolBuilders/ .project .cproject

Why Subversion does not work

When using eclipse's svn plugin and building a KDE program, you will get error messages complaining that your svn binary is too old. If you want to try and change this, here's how you get to that error:

Install the subversion plug-ins

Help -> Software Updates -> Available Software -> Add Site -> http://download.eclipse.org/technology/subversive/0.7/update-site/ -> Add Site -> http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site/

Now add it: Subversive Site -> Subversive SVN Team Provider Plugin

Subversive SVN Connectors Site -> Subversive SVN Connectors -> SVNKit 1.3.0 Implementation (Optional)

Click on Install

Restart eclipse

Import your KDE module

Choose File -> New -> Other -> SVN -> Project from SVN -> https://svn.kde.org/home/kde/trunk/KDE/kdepim -> Check out as project configured using the New Project Wizard -> C++ Project -> Makefile Project -> Empty Project. As name, we choose kdepim5 -> Finish

Set cmake as build environment

Choose Project -> Properties -> C/C++ Build -> Builder Settings. Un-tag "use default build command", set "cmake" instead. Choose Project -> Properties -> C/C++ Build -> Behavior. Replace "all" by ".".

QtCreator

This describes how to use QtCreator to develop KDE 4 applications. It has been tested with QtCreator 1.2.80 and SUSE Linux 11.1 but should work same or similar with every combination. As an example KDE application we use ktimetracker from the kdepim module, other applications should work same or similar.

Load an existing project

As discussed here we use ktimetracker as example project.

Import the CMakeLists.txt file

File -> Open -> kdepim/CMakeLists.txt.

Configure qtcreator to build only ktimetracker

Projects -> ktimetracker -> build settings -> Add a configuration ktimetracker.

As build directory choose kdepim. As arguments for cmake use e.g.

. -DCMAKE_INSTALL_PREFIX=/usr/local -DLIB_SUFFIX=64 -DCMAKE_BUILD_TYPE=debugfull

Start a KDE project

To start a new project you need to tell qtcreator to use the KDE libraries when building. So, choose File -> New... and create your project. We will call it yourproject here. To be able to use KDE's libraries, go to your home directory, cd into yourproject and modify yourproject.pro. Add a line

LIBS += -lkdeui

Getting Started/Set up KDE 4 for development (pt BR)

Contents