Development/Tutorials/Programming Tutorial KDE 4/KDirWatch: Difference between revisions

From KDE TechBase
m (Text replace - "</code>" to "</syntaxhighlight>")
 
(11 intermediate revisions by 5 users not shown)
Line 1: Line 1:
{{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==
==Using KDirWatch==


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


===khello.h===
===khello.h===
<code cppqt>
<syntaxhighlight lang="cpp-qt">
#ifndef _KHELLO_H_
#ifndef _KHELLO_H_
#define _KHELLO_H_
#define _KHELLO_H_
Line 32: Line 34:


#endif // _KHELLO_H_
#endif // _KHELLO_H_
</code>
</syntaxhighlight>
This subclasses KMainWindow.
This subclasses {{class|KMainWindow}}.


===khello.cpp===
===khello.cpp===
<code cppqt>
<syntaxhighlight lang="cpp-qt">
#include "khello.h"
#include "khello.h"


Line 62: Line 64:


#include "khello.moc"
#include "khello.moc"
</code>
</syntaxhighlight>
When instanciated, the class creates a KDirWatcher object and tells it to watch the file passed in by the arguments (<code>dw.addFile(args)</code>). 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.
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.


===main.cpp===
===main.cpp===
<code cppqt>
<syntaxhighlight lang="cpp-qt">
/*
/*
This program reacts on file changes.
This program is a demo how to react on file changes.
*/
*/


Line 79: Line 81:


static const char description[] =
static const char description[] =
     I18N_NOOP("A KDE KPart Application");
     I18N_NOOP("An ");


static const char version[] = "0.1";
static const char version[] = "0.1";
Line 98: Line 100:
     KCmdLineArgs::addCmdLineOptions( options );
     KCmdLineArgs::addCmdLineOptions( options );
     KApplication app;
     KApplication app;
    khello *mainWin = 0;


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


     return app.exec();
     return app.exec();
}
}
</code>
</syntaxhighlight>


==CMake==
==CMake==
The best way to build the program is to use CMake.
The best way to build the program is to use CMake.
===CMakeLists.txt===
===CMakeLists.txt===
<code ini>
<syntaxhighlight lang="ini">
project (tutorial2)
project (dirwatch)
find_package(KDE4 REQUIRED KIO KDIRWATCH)
find_package(KDE4 REQUIRED KIO KDIRWATCH)
include_directories( ${KDE4_INCLUDES} )
include_directories( ${KDE4_INCLUDES} )
set(tutorial2_SRCS
set(dirwatch_SRCS
         main.cpp
         main.cpp
         khello.cpp
         khello.cpp
)
)
KDE4_AUTOMOC( ${tutorial2_SRCS} )
kde4_add_executable(dirwatch ${dirwatch_SRCS})
kde4_add_executable(tutorial2 ${tutorial2_SRCS})
target_link_libraries( dirwatch ${KDE4_KDEUI_LIBS}  
target_link_libraries( tutorial2 ${KDE4_KDEUI_LIBS} ${KDE4_KIO_LIBS})
  ${KDE4_KIO_LIBS} )
</code>
</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.
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:
To compile, link and run it, use:
  cmake . && make && ./tutorial2 /var/log/messages
  cmake . && make && ./dirwatch /var/log/messages
 
If {{path|/var/log/messages}} changes, the program will notify you about it.


[[Category:C++]]
[[Category:C++]]

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.

Retrieved from "https://techbase.kde.org/index.php?title=Development/Tutorials/Programming_Tutorial_KDE_4/KDirWatch&oldid=60673"