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

From KDE TechBase
m (Text replace - "<code bash>" to "<syntaxhighlight lang="bash">")
m (Text replace - "</code>" to "</syntaxhighlight>")
Line 62: Line 62:
}
}


</code>
</syntaxhighlight>


Die main.cpp Datei ist die gleiche die in [[Development/Tutorials/KCmdLineArgs (de)|Anleitung 5 - Kommandozeilenargumente]] benutzt wurde. Der einzige Unterschied liegt in den Details von KAboutData.
Die main.cpp Datei ist die gleiche die in [[Development/Tutorials/KCmdLineArgs (de)|Anleitung 5 - Kommandozeilenargumente]] benutzt wurde. Der einzige Unterschied liegt in den Details von KAboutData.
Line 111: Line 111:
#endif // KPARTTUT1_H
#endif // KPARTTUT1_H


</code>
</syntaxhighlight>


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


</code>
</syntaxhighlight>


Die mainwindow.cpp Datei enthält die Implementation von MainWindow. Der Konstruktor dieser Klasse enthält den gesamten Code um das KPart zu laden.
Die mainwindow.cpp Datei enthält die Implementation von MainWindow. Der Konstruktor dieser Klasse enthält den gesamten Code um das KPart zu laden.
Line 224: Line 224:
</ToolBar>
</ToolBar>
</kpartgui>
</kpartgui>
</code>
</syntaxhighlight>


Die kparttut1ui.rc Datei wird benutzt, um zu definieren, wie die Aktionen im KPart und im Hauptfenster zusammengesmischt werden sollen. Die <tt><Merge /></tt> 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.  
Die kparttut1ui.rc Datei wird benutzt, um zu definieren, wie die Aktionen im KPart und im Hauptfenster zusammengesmischt werden sollen. Die <tt><Merge /></tt> 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.  
Line 250: Line 250:
install( FILES kparttut1ui.rc  
install( FILES kparttut1ui.rc  
     DESTINATION  ${DATA_INSTALL_DIR}/kparttut1 )
     DESTINATION  ${DATA_INSTALL_DIR}/kparttut1 )
</code>
</syntaxhighlight>
Die CMakeLists.txt Datei ist in diesem Fall sehr einfach.
Die CMakeLists.txt Datei ist in diesem Fall sehr einfach.


Line 258: Line 258:
<syntaxhighlight lang="bash">
<syntaxhighlight lang="bash">
kparttut1 filename
kparttut1 filename
</code>
</syntaxhighlight>
ausgeführt werden. filename ist dabei eine Textdatei, die geladen werden soll. Eine der Quellcodedateien wäre ein gutes Beispiel dafür.
ausgeführt werden. filename ist dabei eine Textdatei, die geladen werden soll. Eine der Quellcodedateien wäre ein gutes Beispiel dafür.



Revision as of 20:56, 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>&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> </syntaxhighlight>

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})

                      1. install files ###############

install(TARGETS kparttut1 DESTINATION ${BIN_INSTALL_DIR} ) install( FILES kparttut1ui.rc

   DESTINATION  ${DATA_INSTALL_DIR}/kparttut1 )

</syntaxhighlight> 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.