Development/Tutorials/Using KParts (de)

< Development‎ | Tutorials
Revision as of 17:28, 15 July 2012 by AnneW (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search


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

Contents

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

  1. #include <KApplication>
  2. #include <KAboutData>
  3. #include <KCmdLineArgs>
  4. #include <KUrl>
  5.  
  6. #include "mainwindow.h"
  7.  
  8. int main (int argc, char *argv[])
  9. {
  10.     KAboutData aboutData( "kparttutorial1", "kparttutorial1",
  11.         ki18n("KPart Tutorial 1"), "0.1",
  12.         ki18n("A MainWindow for a KatePart."),
  13.         KAboutData::License_GPL,
  14.         ki18n("Copyright (c) 2007 Developer") );
  15.     KCmdLineArgs::init( argc, argv, &aboutData );
  16.  
  17.     KCmdLineOptions options;
  18.     options.add("+[file]", ki18n("Document to open"));
  19.     KCmdLineArgs::addCmdLineOptions(options);
  20.  
  21.     KApplication app;
  22.  
  23.     MainWindow* window = new MainWindow();
  24.     window->show();
  25.  
  26.     KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
  27.     if(args->count())
  28.     {
  29.         window->load(args->url(0).url());
  30.     }
  31.  
  32.     return app.exec();
  33. }

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

  1. #ifndef KPARTTUTORIAL1_H
  2. #define KPARTTUTORIAL1_H
  3.  
  4. #include <kparts/mainwindow.h>
  5.  
  6. /**
  7.  * This is the application "Shell".  It has a menubar, toolbar, and
  8.  * statusbar but relies on the "Part" to do all the real work.
  9.  *
  10.  * @short Application Shell
  11.  * @author Developer <developer@kde.org>
  12.  * @version 0.1
  13.  */
  14. class MainWindow : public KParts::MainWindow
  15. {
  16.     Q_OBJECT
  17. public:
  18.     /**
  19.      * Default Constructor
  20.      */
  21.     MainWindow();
  22.  
  23.     /**
  24.      * Default Destructor
  25.      */
  26.     virtual ~MainWindow();
  27.  
  28.     /**
  29.      * Use this method to load whatever file/URL you have
  30.      */
  31.     void load(const KUrl& url);
  32.  
  33. private:
  34.     void setupActions();
  35.  
  36. private:
  37.     KParts::ReadWritePart *m_part;
  38. };
  39.  
  40. #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

  1. #include "mainwindow.h"
  2.  
  3. #include <kaction.h>
  4. #include <kactioncollection.h>
  5. #include <kconfig.h>
  6. #include <kedittoolbar.h>
  7. #include <kfiledialog.h>
  8. #include <kshortcutsdialog.h>
  9. #include <klibloader.h>
  10. #include <kmessagebox.h>
  11. #include <kstandardaction.h>
  12. #include <kstatusbar.h>
  13. #include <kurl.h>
  14.  
  15. #include <QApplication>
  16.  
  17. MainWindow::MainWindow()
  18.     : KParts::MainWindow( )
  19. {
  20.  
  21.     // Setup our actions
  22.     setupActions();
  23.  
  24.     // this routine will find and load our Part.  
  25.     KLibFactory *factory = KLibLoader::self()->factory("katepart");
  26.     if (factory)
  27.     {
  28.         // now that the Part is loaded, we cast it to a Part to get
  29.         // our hands on it
  30.         m_part = static_cast<KParts::ReadWritePart *>
  31.                  (factory->create(this, "KatePart" ));
  32.  
  33.         if (m_part)
  34.         {
  35.             // tell the KParts::MainWindow that this is indeed
  36.             // the main widget
  37.             setCentralWidget(m_part->widget());
  38.  
  39.             setupGUI(ToolBar | Keys | StatusBar | Save);
  40.  
  41.             // and integrate the part's GUI with the shell's
  42.             createGUI(m_part);
  43.         }
  44.     }
  45.     else
  46.     {
  47.         // if we couldn't find our Part, we exit since the Shell by
  48.         // itself can't do anything useful
  49.         KMessageBox::error(this, "Could not find our Part!");
  50.         qApp->quit();
  51.         // we return here, cause qApp->quit() only means "exit the
  52.         // next time we enter the event loop...
  53.         return;
  54.     }
  55. }
  56.  
  57. MainWindow::~MainWindow()
  58. {
  59. }
  60.  
  61. void MainWindow::load(const KUrl& url)
  62. {
  63.     m_part->openUrl( url );
  64. }
  65.  
  66. void MainWindow::setupActions()
  67. {
  68.     KStandardAction::open(this, SLOT(fileOpen()), 
  69.         actionCollection());
  70.     KStandardAction::quit(qApp, SLOT(closeAllWindows()),
  71.         actionCollection());
  72. }
  73.  
  74. void MainWindow::load()
  75. {
  76.     load(KFileDialog::getOpenUrl());
  77. }

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

  1. <!DOCTYPE kpartgui SYSTEM "kpartgui.dtd">
  2. <kpartgui name="kparttut1" version="1">
  3. <MenuBar>
  4.   <Menu noMerge="1" name="file"><text>&amp;File</text>
  5.     <Action name="file_open"/>
  6.     <Separator/>
  7.     <Merge/>
  8.     <Separator/>
  9.     <Action name="file_quit"/>
  10.   </Menu>
  11.  
  12.   <Merge />
  13. </MenuBar>
  14. <ToolBar noMerge="1" name="mainToolBar"><text>Main Toolbar</text>
  15.   <Action name="file_open"/>
  16.   <Merge/>
  17. </ToolBar>
  18. </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

  1. project(kparttut1)
  2.  
  3. FIND_PACKAGE(KDE4 REQUIRED)
  4. INCLUDE_DIRECTORIES( ${KDE4_INCLUDES} . )
  5.  
  6. set(kparttut1_SRCS
  7.    main.cpp
  8.    mainwindow.cpp
  9.  )
  10.  
  11. kde4_add_executable(kparttut1 ${kparttut1_SRCS})
  12.  
  13. target_link_libraries(kparttut1 ${KDE4_KDEUI_LIBS} ${KDE4_KPARTS_LIBS})
  14.  
  15. ########### install files ###############
  16. install(TARGETS kparttut1 DESTINATION ${BIN_INSTALL_DIR} )
  17. install( FILES kparttut1ui.rc 
  18.     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.


This page was last modified on 15 July 2012, at 17:28. This page has been accessed 2,731 times. Content is available under Creative Commons License SA 3.0 as well as the GNU Free Documentation License 1.2.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V.Legal