Development/Tutorials/Using KParts (de): Difference between revisions

Revision as of 21:05, 29 June 2011

Development/Tutorials/Using_KParts

Wie man KParts benutzt

Anleitungsserie	Plugins und KParts
Voriges Kapitel	Anleitung 5 - Kommandozeilenargumente
Nächstes Kapitel	n/a
Weiterführende Texte	KParts Dokumentation (englisch)
Navigation	Deutsche Startseite

Einführung

Die KPart Technologie wird in KDE benutzt, um GUI Komponenten wiederzuverwerten. Der Vorteile eines KParts sind dabei die vordefinierte Aktionen, wie Werkzeugleistenknöpfe. Indem man kparts in Applikationen benutzt, braucht ein Entwickler weniger Zeit in die Implementation eines Texteditors oder Kommandozeilenaktionen investieren und statt dessen einfach ein katepart oder ein konsolepart benutzen. KParts werden auch mit der Plugin Technologie benutzt, um Applikationen in andere einzubetten, wie es zum Beispiel die PIM Applikationen in Kontact machen.

Diese Anleitung zeigt, wie man ein KPart in der eigenen Applikation einsetzt und wie man sein eigenes KPart erzeugt.

Katepart benutzen

Einfache KDE Applikationen benutzen ein MainWindow welches von KMainWindow abgeleitet wird (so wie in den vorigen Anleitungen). Um ein KPart in einer Applikation verwenden zu können, muß das MainWindows statt dessen von KParts::MainWindow abgeleitet werden. Dadurch wird sichergestellt, dass die Integration von Werkzeugleiste und Menüeintragen und dem KPart vernünftig funktioniert.

Der folgende Code erzeugt ein KParts::MainWindow mit einem kpart darin.

main.cpp

#include <KApplication>
#include <KAboutData>
#include <KCmdLineArgs>
#include <KUrl>
 
#include "mainwindow.h"
 
int main (int argc, char *argv[])
{
    KAboutData aboutData( "kparttutorial1", "kparttutorial1",
        ki18n("KPart Tutorial 1"), "0.1",
        ki18n("A MainWindow for a KatePart."),
        KAboutData::License_GPL,
        ki18n("Copyright (c) 2007 Developer") );
    KCmdLineArgs::init( argc, argv, &aboutData );
 
    KCmdLineOptions options;
    options.add("+[file]", ki18n("Document to open"));
    KCmdLineArgs::addCmdLineOptions(options);
 
    KApplication app;
 
    MainWindow* window = new MainWindow();
    window->show();

    KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
    if(args->count())
    {
        window->load(args->url(0).url());
    }

    return app.exec();
}

Die main.cpp Datei ist die gleiche die in Anleitung 5 - Kommandozeilenargumente benutzt wurde. Der einzige Unterschied liegt in den Details von KAboutData.

mainwindow.h

#ifndef KPARTTUTORIAL1_H
#define KPARTTUTORIAL1_H

#include <kparts/mainwindow.h>

/**
 * This is the application "Shell".  It has a menubar, toolbar, and
 * statusbar but relies on the "Part" to do all the real work.
 *
 * @short Application Shell
 * @author Developer <[email protected]>
 * @version 0.1
 */
class MainWindow : public KParts::MainWindow
{
    Q_OBJECT
public:
    /**
     * Default Constructor
     */
    MainWindow();

    /**
     * Default Destructor
     */
    virtual ~MainWindow();

    /**
     * Use this method to load whatever file/URL you have
     */
    void load(const KUrl& url);

private:
    void setupActions();

private:
    KParts::ReadWritePart *m_part;
};

#endif // KPARTTUT1_H

Die mainwindow.h Datei ist sehr einfach. Das wichtigste darin ist, dass die MainWindo Klasse von KParts::MainWindow abgeleitet wird.

mainwindow.cpp

#include "mainwindow.h"

#include <kaction.h>
#include <kactioncollection.h>
#include <kconfig.h>
#include <kedittoolbar.h>
#include <kfiledialog.h>
#include <kshortcutsdialog.h>
#include <klibloader.h>
#include <kmessagebox.h>
#include <kstandardaction.h>
#include <kstatusbar.h>
#include <kurl.h>

#include <QApplication>

MainWindow::MainWindow()
    : KParts::MainWindow( )
{

    // Setup our actions
    setupActions();

    // this routine will find and load our Part.  
    KLibFactory *factory = KLibLoader::self()->factory("katepart");
    if (factory)
    {
        // now that the Part is loaded, we cast it to a Part to get
        // our hands on it
        m_part = static_cast<KParts::ReadWritePart *>
                 (factory->create(this, "KatePart" ));

        if (m_part)
        {
            // tell the KParts::MainWindow that this is indeed
            // the main widget
            setCentralWidget(m_part->widget());

            setupGUI(ToolBar | Keys | StatusBar | Save);

            // and integrate the part's GUI with the shell's
            createGUI(m_part);
        }
    }
    else
    {
        // if we couldn't find our Part, we exit since the Shell by
        // itself can't do anything useful
        KMessageBox::error(this, "Could not find our Part!");
        qApp->quit();
        // we return here, cause qApp->quit() only means "exit the
        // next time we enter the event loop...
        return;
    }
}

MainWindow::~MainWindow()
{
}

void MainWindow::load(const KUrl& url)
{
    m_part->openUrl( url );
}

void MainWindow::setupActions()
{
    KStandardAction::open(this, SLOT(fileOpen()), 
        actionCollection());
    KStandardAction::quit(qApp, SLOT(closeAllWindows()),
        actionCollection());
}

void MainWindow::load()
{
    load(KFileDialog::getOpenUrl());
}

Die mainwindow.cpp Datei enthält die Implementation von MainWindow. Der Konstruktor dieser Klasse enthält den gesamten Code um das KPart zu laden.

Als erstes werden hier die Aktionen des Hautfensters (Öffnen und Beenden) aufgesezt, und dann die Gui-Elemente aufgesetzt, die damit arbeiten sollen (Werkzeugleisten, Menüenträge, Tastenkürzel). Als nächstes kommt der Standardcode, um das KPart zu laden. Die createGUI Methode ist verantwortlich dafür, die Werkzeugleisten und Menüs des KParts mit denen der restlichen Applikation zu vermischen.

kparttut1ui.rc

<!DOCTYPE kpartgui SYSTEM "kpartgui.dtd">
<kpartgui name="kparttut1" version="1">
<MenuBar>
  <Menu noMerge="1" name="file"><text>&amp;File</text>
    <Action name="file_open"/>
    <Separator/>
    <Merge/>
    <Separator/>
    <Action name="file_quit"/>
  </Menu>

  <Merge />
</MenuBar>
<ToolBar noMerge="1" name="mainToolBar"><text>Main Toolbar</text>
  <Action name="file_open"/>
  <Merge/>
</ToolBar>
</kpartgui>

Die kparttut1ui.rc Datei wird benutzt, um zu definieren, wie die Aktionen im KPart und im Hauptfenster zusammengesmischt werden sollen. Die <Merge /> Elemente im Dateimenü zeigen zum Beispiel an, dass jeder Part, der Aktionen für das Dateimenü liefert, diese nach file_open und vor file_quit einfügen soll.

CMakeLists.txt

project(kparttut1)

FIND_PACKAGE(KDE4 REQUIRED)
INCLUDE_DIRECTORIES( ${KDE4_INCLUDES} . )

set(kparttut1_SRCS
   main.cpp
   mainwindow.cpp
 )

kde4_add_executable(kparttut1 ${kparttut1_SRCS})

target_link_libraries(kparttut1 ${KDE4_KDEUI_LIBS} ${KDE4_KPARTS_LIBS})

########### install files ###############
install(TARGETS kparttut1 DESTINATION ${BIN_INSTALL_DIR} )
install( FILES kparttut1ui.rc 
    DESTINATION  ${DATA_INSTALL_DIR}/kparttut1 )

Die CMakeLists.txt Datei ist in diesem Fall sehr einfach.

Die Applikation ausführen

Nach dem Kompilieren der Appikation kann diese mit

kparttut1 filename

ausgeführt werden. filename ist dabei eine Textdatei, die geladen werden soll. Eine der Quellcodedateien wäre ein gutes Beispiel dafür.

Wenn die Datei geladen wird, steht einem ein kompletter kate-Editor in seinem eigenen Fenster zu Verfügung. Alle Features des Editors sind über die Werkzeugleiste und Menüs verfügbar.

Weiterhin fällt die 'Öffnen' Aktion auf, welche in der MainWindow class definiert wurde und auch in der Werkzeugleiste und im Menü neben der 'Beenden' Aktion erscheint.

Die nächste Anleitung wird sich mit dem Erzeugen eigener kparts für die Benutzung in anderen Applikationen beschäftigen.

@@ Line 230: / Line 230: @@
 === CMakeLists.txt ===
-<code ini n>
+<syntaxhighlight lang="ini" line>
 project(kparttut1)