Difference between revisions of "Development/Tutorials/Programming Tutorial KDE 4/KDirWatch"

Latest revision as of 20:54, 29 June 2011

Warning

If this is going to be made into a proper tutorial, it should be on the main tutorial page. Not a part of this small tutorial series.

Using KDirWatch

If you want your program to be notified upon file changes, use KDirWatch. Here is an example.

khello.h

#ifndef _KHELLO_H_
#define _KHELLO_H_

#include <kmainwindow.h>
#include <kdirwatch.h>

/**
 * @short Application Main Window
 * @author Thorsten Staerk <[email protected]>
 * @version 0.1
 */
class khello : public KMainWindow
{
    Q_OBJECT
public:
    KDirWatch dw;
    /**
     * Default Constructor
     */
    khello(char* args);

public slots:
    void slotdirty();

};

#endif // _KHELLO_H_

This subclasses KMainWindow.

khello.cpp

#include "khello.h"

#include <qlabel.h>

#include <kdebug.h>
#include <kmainwindow.h>
#include <klocale.h>
#include <kmessagebox.h>

khello::khello(char* args)
    : KMainWindow()
{
    kdDebug() << "args = " << args << endl;
    dw.addFile(args);
    kdDebug() << "Watching file " << args << endl;
    connect(&dw, SIGNAL(dirty(const QString & ) ),
           SLOT( slotdirty() ) );
}

void khello::slotdirty()
{
  kdDebug() << "File has changed" << endl;
}

#include "khello.moc"

When instanciated, the class creates a KDirWatcher object and tells it to watch the file passed in by the arguments (

dw.addFile(args)

). The DirWatcher will now emit a SIGNAL dirty each time this file gets modified. This signal is connected to khello's slot slotdirty(). So, every time the file gets modified, slotdirty is called.

main.cpp

/*
This program is a demo how to react on file changes.
*/

#include "khello.h"
#include <kapplication.h>
#include <kaboutdata.h>
#include <kcmdlineargs.h>
#include <kdebug.h>
#include <klocale.h>

static const char description[] =
    I18N_NOOP("An ");

static const char version[] = "0.1";

static KCmdLineOptions options[] =
{
    { "+[URL]", I18N_NOOP( "Document to open" ), 0 },
    KCmdLineLastOption
};

int main(int argc, char **argv)
{
    KAboutData about("khello", I18N_NOOP("khello"), version, 
      description, KAboutData::License_GPL, 
      "(C) %{YEAR} Thorsten Staerk", 0, 0, "[email protected]");
    about.addAuthor( "Thorsten Staerk", 0, "[email protected]" );
    KCmdLineArgs::init(argc, argv, &about);
    KCmdLineArgs::addCmdLineOptions( options );
    KApplication app;

    KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
    kdDebug() << argv[1] << endl;
    khello *mainWin = new khello(argv[1]);
    mainWin->show();

    return app.exec();
}

CMake

The best way to build the program is to use CMake.

CMakeLists.txt

project (dirwatch)
find_package(KDE4 REQUIRED KIO KDIRWATCH)
include_directories( ${KDE4_INCLUDES} )
set(dirwatch_SRCS
        main.cpp
        khello.cpp
)
kde4_add_executable(dirwatch ${dirwatch_SRCS})
target_link_libraries( dirwatch ${KDE4_KDEUI_LIBS} 
  ${KDE4_KIO_LIBS} )

Note that we added ${KDE4_KIO_LIBS} to the target_link_libraries. If we do not do it, the linker complains about undefined symbols. In the kio-libs, KDirWatch is defined.

Compile it

To compile, link and run it, use:

cmake . && make && ./dirwatch /var/log/messages

If /var/log/messages changes, the program will notify you about it.

@@ Line 1: / Line 1: @@
-==Using KXmlGuiWindow==
+{{Warning|If this is going to be made into a proper tutorial, it should be on the ''main tutorial page''. '''Not''' a part of this small tutorial series.}}
-In order to have a useful KXmlGuiWindow, we must subclass it. So we create two files, a <tt>mainwindow.cpp</tt> and a <tt>mainwindow.h</tt> which will contain our code. Our class is called KXmlGuiWindow because it uses XML e.g. to define the application's menu structure.
+==Using KDirWatch==
-===mainwindow.h===
+If you want your program to be notified upon file changes, use {{class|KDirWatch}}. Here is an example.
-<code cppqt>
-#ifndef MAINWINDOW_H
-#define MAINWINDOW_H
-#include <KXmlGuiWindow>
+===khello.h===
-#include <KTextEdit>
+<syntaxhighlight lang="cpp-qt">
+#ifndef _KHELLO_H_
+#define _KHELLO_H_
-class MainWindow : public KXmlGuiWindow
+#include <kmainwindow.h>
+#include <kdirwatch.h>
+/**
+ * @short Application Main Window
+ * @author Thorsten Staerk <[email protected]>
+ * @version 0.1
+ */
+class khello : public KMainWindow
 {
-  public:
+    Q_OBJECT
-     MainWindow(QWidget *parent=0);
+public:
+     KDirWatch dw;
-  private:
+    /**
-     KTextEdit* textArea;
+     * Default Constructor
+     */
+    khello(char* args);
+public slots:
+     void slotdirty();
 };
-#endif
+#endif // _KHELLO_H_
-</code>
+</syntaxhighlight>
-First we Subclass KXmlGuiWindow on line 7 with with <tt>class MainWindow : public KXmlGuiWindow</tt>.
+This subclasses {{class|KMainWindow}}.
-Then we declare the constructor with <tt>MainWindow(QWidget *parent=0);</tt>.
+===khello.cpp===
+<syntaxhighlight lang="cpp-qt">
+#include "khello.h"
-And finally we declare a pointer to the object that will make up the bulk of our program. {{class|KTextEdit}} is a generic richtext editor with some KDE niceties like cursor auto-hiding.
+#include <qlabel.h>
-===mainwindow.cpp===
+#include <kdebug.h>
-<code cppqt>
+#include <kmainwindow.h>
-#include "mainwindow.h"
+#include <klocale.h>
+#include <kmessagebox.h>
-MainWindow::MainWindow(QWidget *parent) : KXmlGuiWindow(parent)
+khello::khello(char* args)
+    : KMainWindow()
 {
-  textArea = new KTextEdit;
+    kdDebug() << "args = " << args << endl;
-  setCentralWidget(textArea);
+    dw.addFile(args);
-  setupGUI();
+    kdDebug() << "Watching file " << args << endl;
+    connect(&dw, SIGNAL(dirty(const QString & ) ),
+           SLOT( slotdirty() ) );
 }
-</code>
-First, of course, on line 1 we have to include the header file containing the class declaration.
-On line 5, we initialise our text editor with an object. Then on line 6 we use the built-in setCentralWidget() function which tells the KXmlGuiWindow what should appear in the central section of the window.
+void khello::slotdirty()
+{
+  kdDebug() << "File has changed" << endl;
+}
-Finally, KXmlGuiWindow::setupGUI() is called which does a lot of behind-the-scenes stuff and creates the default menu bars (Settings, Help).
+#include "khello.moc"
+</syntaxhighlight>
+When instanciated, the class creates a KDirWatcher object and tells it to watch the file passed in by the arguments (<syntaxhighlight lang="text">dw.addFile(args)</syntaxhighlight>). The DirWatcher will now emit a SIGNAL dirty each time this file gets modified. This signal is connected to khello's slot ''slotdirty()''. So, every time the file gets modified, slotdirty is called.
-==Back to main.cpp==
-In order to actually run this window, we need to add a few lines in main.cpp:
 ===main.cpp===
-<code cppqt>
+<syntaxhighlight lang="cpp-qt">
-#include <KApplication>
+/*
-#include <KAboutData>
+This program is a demo how to react on file changes.
-#include <KCmdLineArgs>
+*/
+#include "khello.h"
+#include <kapplication.h>
+#include <kaboutdata.h>
+#include <kcmdlineargs.h>
+#include <kdebug.h>
+#include <klocale.h>
+static const char description[] =
+    I18N_NOOP("An ");
-#include "mainwindow.h"
+static const char version[] = "0.1";
+static KCmdLineOptions options[] =
+{
+    { "+[URL]", I18N_NOOP( "Document to open" ), 0 },
+    KCmdLineLastOption
+};
-int main (int argc, char *argv[])
+int main(int argc, char **argv)
 {
-  KAboutData aboutData( "tutorial2",
+    KAboutData about("khello", I18N_NOOP("khello"), version,
-      "Tutorial2", "1.0", "A simple text area",
+       description, KAboutData::License_GPL,
-       KAboutData::License_GPL, "(c) 2006" );
+      "(C) %{YEAR} Thorsten Staerk", 0, 0, "[email protected]");
-  KCmdLineArgs::init( argc, argv, &aboutData );
+    about.addAuthor( "Thorsten Staerk", 0, "[email protected]" );
+    KCmdLineArgs::init(argc, argv, &about);
-  KApplication app;
+    KCmdLineArgs::addCmdLineOptions( options );
+    KApplication app;
-  MainWindow* window = new MainWindow();
-  window->show();
-  return app.exec();
+    KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
+    kdDebug() << argv[1] << endl;
+    khello *mainWin = new khello(argv[1]);
+    mainWin->show();
+    return app.exec();
 }
-</code>
+</syntaxhighlight>
-The only new lines here (compared to Tutorial 1) are 16 and 17. On line 16, we create our MainWindow object and then on line 17, we display it.
 ==CMake==
-The best way to build the program is to use CMake. All that's changed since tutorial 1 is that <tt>mainwindow.cpp</tt> has been added to the sources list and any <tt>tutorial1</tt> has become <tt>tutorial2</tt>.
+The best way to build the program is to use CMake.
 ===CMakeLists.txt===
-<code ini>
+<syntaxhighlight lang="ini">
-project (tutorial2)
+project (dirwatch)
-find_package(KDE4 REQUIRED)
+find_package(KDE4 REQUIRED KIO KDIRWATCH)
 include_directories( ${KDE4_INCLUDES} )
-set(tutorial2_SRCS
+set(dirwatch_SRCS
-	main.cpp
+        main.cpp
-	mainwindow.cpp
+        khello.cpp
 )
-kde4_add_executable(tutorial2 ${tutorial2_SRCS})
+kde4_add_executable(dirwatch ${dirwatch_SRCS})
-target_link_libraries( tutorial2 ${KDE4_KDEUI_LIBS} ${KDE4_KIO_LIBS} )
+target_link_libraries( dirwatch ${KDE4_KDEUI_LIBS}
-</code>
+  ${KDE4_KIO_LIBS} )
+</syntaxhighlight>
+Note that we added ''${KDE4_KIO_LIBS}'' to the ''target_link_libraries''. If we do not do it, the linker complains about undefined symbols. In the kio-libs, KDirWatch is defined.
-===Kompile it===
+===Compile it===
 To compile, link and run it, use:
-  cmake . && make && ./tutorial2
+  cmake . && make && ./dirwatch /var/log/messages
+If {{path|/var/log/messages}} changes, the program will notify you about it.
-==Moving On==
-Now you can move on to [[Development/Tutorials/Programming_Tutorial_KDE_4/Using_KActions|using KActions]].
 [[Category:C++]]