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

    From KDE TechBase
    m (Text replace - "</code>" to "</syntaxhighlight>")
     
    (18 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>
    First, of course, on line 1 we have to include the header file containing the class declaration.
    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.
     
    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.
     
    Finally, KXmlGuiWindow::setupGUI() is called which does a lot of behind-the-scenes stuff and creates the default menu bars (Settings, Help).


    ===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 92: 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 104: 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.


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