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

From KDE TechBase
m (Text replace - "</code>" to "</syntaxhighlight>")
 
(16 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 25: Line 27:
     */
     */
     khello(char* args);
     khello(char* args);
    /**
    * Default Destructor
    */
    virtual ~khello();


public slots:
public slots:
Line 37: 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 59: Line 56:
     connect(&dw, SIGNAL(dirty(const QString & ) ),
     connect(&dw, SIGNAL(dirty(const QString & ) ),
           SLOT( slotdirty() ) );
           SLOT( slotdirty() ) );
}
khello::~khello()
{
}
}


Line 71: 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 (<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 87: 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 99: Line 93:
int main(int argc, char **argv)
int main(int argc, char **argv)
{
{
     KAboutData about("khello", I18N_NOOP("khello"), version, description,
     KAboutData about("khello", I18N_NOOP("khello"), version,  
                    KAboutData::License_GPL, "(C) %{YEAR} Thorsten Staerk", 0, 0, "[email protected]");
      description, KAboutData::License_GPL,  
      "(C) %{YEAR} Thorsten Staerk", 0, 0, "[email protected]");
     about.addAuthor( "Thorsten Staerk", 0, "[email protected]" );
     about.addAuthor( "Thorsten Staerk", 0, "[email protected]" );
     KCmdLineArgs::init(argc, argv, &about);
     KCmdLineArgs::init(argc, argv, &about);
     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. 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===
===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.
==Moving On==
Now you can move on to [[Development/Tutorials/Programming_Tutorial_KDE_4/Using_KActions|using KActions]].


[[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.