src/unix/fswatcher_kqueue.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/unix/fswatcher_kqueue.cpp
// Purpose:     kqueue-based wxFileSystemWatcher implementation
// Author:      Bartosz Bekier
// Created:     2009-05-26
// RCS-ID:      $Id$
// Copyright:   (c) 2009 Bartosz Bekier <bartosz.bekier@gmail.com>
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_FSWATCHER

#include "wx/fswatcher.h"

#ifdef wxHAS_KQUEUE

#include <sys/types.h>
#include <sys/event.h>

#include "wx/dynarray.h"
#include "wx/evtloop.h"
#include "wx/evtloopsrc.h"

#include "wx/private/fswatcher.h"

// ============================================================================
// wxFSWSourceHandler helper class
// ============================================================================

class wxFSWatcherImplKqueue;

/**
 * Handler for handling i/o from inotify descriptor
 */
class wxFSWSourceHandler : public wxEventLoopSourceHandler
{
public:
    wxFSWSourceHandler(wxFSWatcherImplKqueue* service) :
        m_service(service)
    {  }

    virtual void OnReadWaiting();
    virtual void OnWriteWaiting();
    virtual void OnExceptionWaiting();

protected:
    wxFSWatcherImplKqueue* m_service;
};

// ============================================================================
// wxFSWatcherImpl implementation & helper wxFSWSourceHandler implementation
// ============================================================================

/**
 * Helper class encapsulating inotify mechanism
 */
class wxFSWatcherImplKqueue : public wxFSWatcherImpl
{
public:
    wxFSWatcherImplKqueue(wxFileSystemWatcherBase* watcher) :
        wxFSWatcherImpl(watcher),
        m_source(NULL),
        m_kfd(-1)
    {
        m_handler = new wxFSWSourceHandler(this);
    }

    virtual ~wxFSWatcherImplKqueue()
    {
        // we close kqueue only if initialized before
        if (IsOk())
        {
            Close();
        }

        delete m_handler;
    }

    bool Init()
    {
        wxCHECK_MSG( !IsOk(), false,
                     "Kqueue appears to be already initialized" );

        wxEventLoopBase *loop = wxEventLoopBase::GetActive();
        wxCHECK_MSG( loop, false, "File system watcher needs an active loop" );

        // create kqueue
        m_kfd = kqueue();
        if (m_kfd == -1)
        {
            wxLogSysError(_("Unable to create kqueue instance"));
            return false;
        }

        // create source
        m_source = loop->AddSourceForFD(m_kfd, m_handler, wxEVENT_SOURCE_INPUT);

        return m_source != NULL;
    }

    void Close()
    {
        wxCHECK_RET( IsOk(),
                    "Kqueue not initialized or invalid kqueue descriptor" );

        if ( close(m_kfd) != 0 )
        {
            wxLogSysError(_("Error closing kqueue instance"));
        }

        delete m_source;
        m_source = NULL;
    }

    virtual bool DoAdd(wxSharedPtr<wxFSWatchEntryKq> watch)
    {
        wxCHECK_MSG( IsOk(), false,
                    "Kqueue not initialized or invalid kqueue descriptor" );

        struct kevent event;
        int action = EV_ADD | EV_ENABLE | EV_CLEAR | EV_ERROR;
        int flags = Watcher2NativeFlags(watch->GetFlags());
        EV_SET( &event, watch->GetFileDescriptor(), EVFILT_VNODE, action,
                flags, 0, watch.get() );

        // TODO more error conditions according to man
        // TODO best deal with the error here
        int ret = kevent(m_kfd, &event, 1, NULL, 0, NULL);
        if (ret == -1)
        {
            wxLogSysError(_("Unable to add kqueue watch"));
            return false;
        }

        return true;
    }

    virtual bool DoRemove(wxSharedPtr<wxFSWatchEntryKq> watch)
    {
        wxCHECK_MSG( IsOk(), false,
                    "Kqueue not initialized or invalid kqueue descriptor" );

        // TODO more error conditions according to man
        // XXX closing file descriptor removes the watch. The logic resides in
        // the watch which is not nice, but effective and simple
        bool ret = watch->Close();
        if (ret == -1)
        {
            wxLogSysError(_("Unable to remove kqueue watch"));
            return false;
        }

        return true;
    }

    virtual bool RemoveAll()
    {
        wxFSWatchEntries::iterator it = m_watches.begin();
        for ( ; it != m_watches.end(); ++it )
        {
            (void) DoRemove(it->second);
        }
        m_watches.clear();
        return true;
    }

    // return true if there was no error, false on error
    bool ReadEvents()
    {
        wxCHECK_MSG( IsOk(), false,
                    "Kqueue not initialized or invalid kqueue descriptor" );

        // read events
        do
        {
            struct kevent event;
            struct timespec timeout = {0, 0};
            int ret = kevent(m_kfd, NULL, 0, &event, 1, &timeout);
            if (ret == -1)
            {
                wxLogSysError(_("Unable to get events from kqueue"));
                return false;
            }
            else if (ret == 0)
            {
                return true;
            }

            // we have event, so process it
            ProcessNativeEvent(event);
        }
        while (true);

        // when ret>0 we still have events, when ret<=0 we return
        wxFAIL_MSG( "Never reached" );
        return true;
    }

    bool IsOk() const
    {
        return m_source != NULL;
    }

protected:
    // returns all new dirs/files present in the immediate level of the dir
    // pointed by watch.GetPath(). "new" means created between the last time
    // the state of watch was computed and now
    void FindChanges(wxFSWatchEntryKq& watch,
                     wxArrayString& changedFiles,
                     wxArrayInt& changedFlags)
    {
        wxFSWatchEntryKq::wxDirState old = watch.GetLastState();
        watch.RefreshState();
        wxFSWatchEntryKq::wxDirState curr = watch.GetLastState();

        // iterate over old/curr file lists and compute changes
        wxArrayString::iterator oit = old.files.begin();
        wxArrayString::iterator cit = curr.files.begin();
        for ( ; oit != old.files.end() && cit != curr.files.end(); )
        {
            if ( *cit == *oit )
            {
                ++cit;
                ++oit;
            }
            else if ( *cit <= *oit )
            {
                changedFiles.push_back(*cit);
                changedFlags.push_back(wxFSW_EVENT_CREATE);
                ++cit;
            }
            else // ( *cit > *oit )
            {
                changedFiles.push_back(*oit);
                changedFlags.push_back(wxFSW_EVENT_DELETE);
                ++oit;
            }
        }

        // border conditions
        if ( oit == old.files.end() )
        {
            for ( ; cit != curr.files.end(); ++cit )
            {
                changedFiles.push_back( *cit );
                changedFlags.push_back(wxFSW_EVENT_CREATE);
            }
        }
        else if ( cit == curr.files.end() )
        {
            for ( ; oit != old.files.end(); ++oit )
            {
                changedFiles.push_back( *oit );
                changedFlags.push_back(wxFSW_EVENT_DELETE);
            }
        }

        wxASSERT( changedFiles.size() == changedFlags.size() );

#if 0
        wxLogTrace(wxTRACE_FSWATCHER, "Changed files:");
        wxArrayString::iterator it = changedFiles.begin();
        wxArrayInt::iterator it2 = changedFlags.begin();
        for ( ; it != changedFiles.end(); ++it, ++it2)
        {
            wxString action = (*it2 == wxFSW_EVENT_CREATE) ?
                                "created" : "deleted";
            wxLogTrace(wxTRACE_FSWATCHER, wxString::Format("File: '%s' %s",
                        *it, action));
        }
#endif
    }

    void ProcessNativeEvent(const struct kevent& e)
    {
        wxASSERT_MSG(e.udata, "Null user data associated with kevent!");

        wxLogTrace(wxTRACE_FSWATCHER, "Event: ident=%d, filter=%d, flags=%u, "
                   "fflags=%u, data=%d, user_data=%p",
                   e.ident, e.filter, e.flags, e.fflags, e.data, e.udata);

        // for ease of use
        wxFSWatchEntryKq& w = *(static_cast<wxFSWatchEntry*>(e.udata));
        int nflags = e.fflags;

        // clear ignored flags
        nflags &= ~NOTE_REVOKE;

        // TODO ignore events we didn't ask for + refactor this cascade ifs
        // check for events
        while ( nflags )
        {
            // when monitoring dir, this means create/delete
            if ( nflags & NOTE_WRITE && wxDirExists(w.GetPath()) )
            {
                // NOTE_LINK is set when the dir was created, but we
                // don't care - we look for new names in directory
                // regardless of type. Also, clear all this, because
                // it cannot mean more by itself
                nflags &= ~(NOTE_WRITE | NOTE_ATTRIB | NOTE_LINK);

                wxArrayString changedFiles;
                wxArrayInt changedFlags;
                FindChanges(w, changedFiles, changedFlags);
                wxArrayString::iterator it = changedFiles.begin();
                wxArrayInt::iterator changeType = changedFlags.begin();
                for ( ; it != changedFiles.end(); ++it, ++changeType )
                {
                    wxFileName path;
                    if ( wxDirExists(*it) )
                    {
                        path = wxFileName::DirName(w.GetPath() + *it);
                    }
                    else
                    {
                        path = wxFileName::FileName(w.GetPath() + *it);
                    }

                    wxFileSystemWatcherEvent event(*changeType, path, path);
                    SendEvent(event);
                }
            }
            else if ( nflags & NOTE_RENAME )
            {
                // CHECK it'd be only possible to detect name if we had
                // parent files listing which we could confront with now and
                // still we couldn't be sure we have the right name...
                nflags &= ~NOTE_RENAME;
                wxFileSystemWatcherEvent event(wxFSW_EVENT_RENAME,
                                        w.GetPath(), wxFileName());
                SendEvent(event);
            }
            else if ( nflags & NOTE_WRITE || nflags & NOTE_EXTEND )
            {
                nflags &= ~(NOTE_WRITE | NOTE_EXTEND);
                wxFileSystemWatcherEvent event(wxFSW_EVENT_MODIFY,
                                        w.GetPath(), w.GetPath());
                SendEvent(event);
            }
            else if ( nflags & NOTE_DELETE )
            {
                nflags &= ~(NOTE_DELETE);
                wxFileSystemWatcherEvent event(wxFSW_EVENT_DELETE,
                                        w.GetPath(), w.GetPath());
                SendEvent(event);
            }
            else if ( nflags & NOTE_ATTRIB )
            {
                nflags &= ~(NOTE_ATTRIB);
                wxFileSystemWatcherEvent event(wxFSW_EVENT_ACCESS,
                                        w.GetPath(), w.GetPath());
                SendEvent(event);
            }

            // clear any flags that won't mean anything by themselves
            nflags &= ~(NOTE_LINK);
        }
    }

    void SendEvent(wxFileSystemWatcherEvent& evt)
    {
        m_watcher->GetOwner()->ProcessEvent(evt);
    }

    static int Watcher2NativeFlags(int WXUNUSED(flags))
    {
        // TODO: it would be better to only subscribe to what we need
        return NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND |
               NOTE_ATTRIB | NOTE_LINK | NOTE_RENAME |
               NOTE_REVOKE;
    }

    wxFSWSourceHandler* m_handler;        // handler for kqueue event source
    wxEventLoopSource* m_source;          // our event loop source

    // descriptor created by kqueue()
    int m_kfd;
};


// once we get signaled to read, actuall event reading occurs
void wxFSWSourceHandler::OnReadWaiting()
{
    wxLogTrace(wxTRACE_FSWATCHER, "--- OnReadWaiting ---");
    m_service->ReadEvents();
}

void wxFSWSourceHandler::OnWriteWaiting()
{
    wxFAIL_MSG("We never write to kqueue descriptor.");
}

void wxFSWSourceHandler::OnExceptionWaiting()
{
    wxFAIL_MSG("We never receive exceptions on kqueue descriptor.");
}


// ============================================================================
// wxKqueueFileSystemWatcher implementation
// ============================================================================

wxKqueueFileSystemWatcher::wxKqueueFileSystemWatcher()
    : wxFileSystemWatcherBase()
{
    Init();
}

wxKqueueFileSystemWatcher::wxKqueueFileSystemWatcher(const wxFileName& path,
                                                     int events)
    : wxFileSystemWatcherBase()
{
    if (!Init())
    {
        if (m_service)
        {
            delete m_service;
            m_service = NULL;
        }
        return;
    }

    Add(path, events);
}

wxKqueueFileSystemWatcher::~wxKqueueFileSystemWatcher()
{
}

bool wxKqueueFileSystemWatcher::Init()
{
    m_service = new wxFSWatcherImplKqueue(this);
    return m_service->Init();
}

#endif // wxHAS_KQUEUE

#endif // wxUSE_FSWATCHER
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/unix/fswatcher_kqueue.cpp
	3	// Purpose: kqueue-based wxFileSystemWatcher implementation
	4	// Author: Bartosz Bekier
	5	// Created: 2009-05-26
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2009 Bartosz Bekier <bartosz.bekier@gmail.com>
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#if wxUSE_FSWATCHER
	19
	20	#include "wx/fswatcher.h"
	21
	22	#ifdef wxHAS_KQUEUE
	23
	24	#include <sys/types.h>
	25	#include <sys/event.h>
	26
	27	#include "wx/dynarray.h"
	28	#include "wx/evtloop.h"
	29	#include "wx/evtloopsrc.h"
	30
	31	#include "wx/private/fswatcher.h"
	32
	33	// ============================================================================
	34	// wxFSWSourceHandler helper class
	35	// ============================================================================
	36
	37	class wxFSWatcherImplKqueue;
	38
	39	/**
	40	* Handler for handling i/o from inotify descriptor
	41	*/
	42	class wxFSWSourceHandler : public wxEventLoopSourceHandler
	43	{
	44	public:
	45	wxFSWSourceHandler(wxFSWatcherImplKqueue* service) :
	46	m_service(service)
	47	{ }
	48
	49	virtual void OnReadWaiting();
	50	virtual void OnWriteWaiting();
	51	virtual void OnExceptionWaiting();
	52
	53	protected:
	54	wxFSWatcherImplKqueue* m_service;
	55	};
	56
	57	// ============================================================================
	58	// wxFSWatcherImpl implementation & helper wxFSWSourceHandler implementation
	59	// ============================================================================
	60
	61	/**
	62	* Helper class encapsulating inotify mechanism
	63	*/
	64	class wxFSWatcherImplKqueue : public wxFSWatcherImpl
	65	{
	66	public:
	67	wxFSWatcherImplKqueue(wxFileSystemWatcherBase* watcher) :
	68	wxFSWatcherImpl(watcher),
	69	m_source(NULL),
	70	m_kfd(-1)
	71	{
	72	m_handler = new wxFSWSourceHandler(this);
	73	}
	74
	75	virtual ~wxFSWatcherImplKqueue()
	76	{
	77	// we close kqueue only if initialized before
	78	if (IsOk())
	79	{
	80	Close();
	81	}
	82
	83	delete m_handler;
	84	}
	85
	86	bool Init()
	87	{
	88	wxCHECK_MSG( !IsOk(), false,
	89	"Kqueue appears to be already initialized" );
	90
	91	wxEventLoopBase *loop = wxEventLoopBase::GetActive();
	92	wxCHECK_MSG( loop, false, "File system watcher needs an active loop" );
	93
	94	// create kqueue
	95	m_kfd = kqueue();
	96	if (m_kfd == -1)
	97	{
	98	wxLogSysError(_("Unable to create kqueue instance"));
	99	return false;
	100	}
	101
	102	// create source
	103	m_source = loop->AddSourceForFD(m_kfd, m_handler, wxEVENT_SOURCE_INPUT);
	104
	105	return m_source != NULL;
	106	}
	107
	108	void Close()
	109	{
	110	wxCHECK_RET( IsOk(),
	111	"Kqueue not initialized or invalid kqueue descriptor" );
	112
	113	if ( close(m_kfd) != 0 )
	114	{
	115	wxLogSysError(_("Error closing kqueue instance"));
	116	}
	117
	118	delete m_source;
	119	m_source = NULL;
	120	}
	121
	122	virtual bool DoAdd(wxSharedPtr<wxFSWatchEntryKq> watch)
	123	{
	124	wxCHECK_MSG( IsOk(), false,
	125	"Kqueue not initialized or invalid kqueue descriptor" );
	126
	127	struct kevent event;
	128	int action = EV_ADD \| EV_ENABLE \| EV_CLEAR \| EV_ERROR;
	129	int flags = Watcher2NativeFlags(watch->GetFlags());
	130	EV_SET( &event, watch->GetFileDescriptor(), EVFILT_VNODE, action,
	131	flags, 0, watch.get() );
	132
	133	// TODO more error conditions according to man
	134	// TODO best deal with the error here
	135	int ret = kevent(m_kfd, &event, 1, NULL, 0, NULL);
	136	if (ret == -1)
	137	{
	138	wxLogSysError(_("Unable to add kqueue watch"));
	139	return false;
	140	}
	141
	142	return true;
	143	}
	144
	145	virtual bool DoRemove(wxSharedPtr<wxFSWatchEntryKq> watch)
	146	{
	147	wxCHECK_MSG( IsOk(), false,
	148	"Kqueue not initialized or invalid kqueue descriptor" );
	149
	150	// TODO more error conditions according to man
	151	// XXX closing file descriptor removes the watch. The logic resides in
	152	// the watch which is not nice, but effective and simple
	153	bool ret = watch->Close();
	154	if (ret == -1)
	155	{
	156	wxLogSysError(_("Unable to remove kqueue watch"));
	157	return false;
	158	}
	159
	160	return true;
	161	}
	162
	163	virtual bool RemoveAll()
	164	{
	165	wxFSWatchEntries::iterator it = m_watches.begin();
	166	for ( ; it != m_watches.end(); ++it )
	167	{
	168	(void) DoRemove(it->second);
	169	}
	170	m_watches.clear();
	171	return true;
	172	}
	173
	174	// return true if there was no error, false on error
	175	bool ReadEvents()
	176	{
	177	wxCHECK_MSG( IsOk(), false,
	178	"Kqueue not initialized or invalid kqueue descriptor" );
	179
	180	// read events
	181	do
	182	{
	183	struct kevent event;
	184	struct timespec timeout = {0, 0};
	185	int ret = kevent(m_kfd, NULL, 0, &event, 1, &timeout);
	186	if (ret == -1)
	187	{
	188	wxLogSysError(_("Unable to get events from kqueue"));
	189	return false;
	190	}
	191	else if (ret == 0)
	192	{
	193	return true;
	194	}
	195
	196	// we have event, so process it
	197	ProcessNativeEvent(event);
	198	}
	199	while (true);
	200
	201	// when ret>0 we still have events, when ret<=0 we return
	202	wxFAIL_MSG( "Never reached" );
	203	return true;
	204	}
	205
	206	bool IsOk() const
	207	{
	208	return m_source != NULL;
	209	}
	210
	211	protected:
	212	// returns all new dirs/files present in the immediate level of the dir
	213	// pointed by watch.GetPath(). "new" means created between the last time
	214	// the state of watch was computed and now
	215	void FindChanges(wxFSWatchEntryKq& watch,
	216	wxArrayString& changedFiles,
	217	wxArrayInt& changedFlags)
	218	{
	219	wxFSWatchEntryKq::wxDirState old = watch.GetLastState();
	220	watch.RefreshState();
	221	wxFSWatchEntryKq::wxDirState curr = watch.GetLastState();
	222
	223	// iterate over old/curr file lists and compute changes
	224	wxArrayString::iterator oit = old.files.begin();
	225	wxArrayString::iterator cit = curr.files.begin();
	226	for ( ; oit != old.files.end() && cit != curr.files.end(); )
	227	{
	228	if ( cit == oit )
	229	{
	230	++cit;
	231	++oit;
	232	}
	233	else if ( cit <= oit )
	234	{
	235	changedFiles.push_back(*cit);
	236	changedFlags.push_back(wxFSW_EVENT_CREATE);
	237	++cit;
	238	}
	239	else // ( cit > oit )
	240	{
	241	changedFiles.push_back(*oit);
	242	changedFlags.push_back(wxFSW_EVENT_DELETE);
	243	++oit;
	244	}
	245	}
	246
	247	// border conditions
	248	if ( oit == old.files.end() )
	249	{
	250	for ( ; cit != curr.files.end(); ++cit )
	251	{
	252	changedFiles.push_back( *cit );
	253	changedFlags.push_back(wxFSW_EVENT_CREATE);
	254	}
	255	}
	256	else if ( cit == curr.files.end() )
	257	{
	258	for ( ; oit != old.files.end(); ++oit )
	259	{
	260	changedFiles.push_back( *oit );
	261	changedFlags.push_back(wxFSW_EVENT_DELETE);
	262	}
	263	}
	264
	265	wxASSERT( changedFiles.size() == changedFlags.size() );
	266
	267	#if 0
	268	wxLogTrace(wxTRACE_FSWATCHER, "Changed files:");
	269	wxArrayString::iterator it = changedFiles.begin();
	270	wxArrayInt::iterator it2 = changedFlags.begin();
	271	for ( ; it != changedFiles.end(); ++it, ++it2)
	272	{
	273	wxString action = (*it2 == wxFSW_EVENT_CREATE) ?
	274	"created" : "deleted";
	275	wxLogTrace(wxTRACE_FSWATCHER, wxString::Format("File: '%s' %s",
	276	*it, action));
	277	}
	278	#endif
	279	}
	280
	281	void ProcessNativeEvent(const struct kevent& e)
	282	{
	283	wxASSERT_MSG(e.udata, "Null user data associated with kevent!");
	284
	285	wxLogTrace(wxTRACE_FSWATCHER, "Event: ident=%d, filter=%d, flags=%u, "
	286	"fflags=%u, data=%d, user_data=%p",
	287	e.ident, e.filter, e.flags, e.fflags, e.data, e.udata);
	288
	289	// for ease of use
	290	wxFSWatchEntryKq& w = (static_cast<wxFSWatchEntry>(e.udata));
	291	int nflags = e.fflags;
	292
	293	// clear ignored flags
	294	nflags &= ~NOTE_REVOKE;
	295
	296	// TODO ignore events we didn't ask for + refactor this cascade ifs
	297	// check for events
	298	while ( nflags )
	299	{
	300	// when monitoring dir, this means create/delete
	301	if ( nflags & NOTE_WRITE && wxDirExists(w.GetPath()) )
	302	{
	303	// NOTE_LINK is set when the dir was created, but we
	304	// don't care - we look for new names in directory
	305	// regardless of type. Also, clear all this, because
	306	// it cannot mean more by itself
	307	nflags &= ~(NOTE_WRITE \| NOTE_ATTRIB \| NOTE_LINK);
	308
	309	wxArrayString changedFiles;
	310	wxArrayInt changedFlags;
	311	FindChanges(w, changedFiles, changedFlags);
	312	wxArrayString::iterator it = changedFiles.begin();
	313	wxArrayInt::iterator changeType = changedFlags.begin();
	314	for ( ; it != changedFiles.end(); ++it, ++changeType )
	315	{
	316	wxFileName path;
	317	if ( wxDirExists(*it) )
	318	{
	319	path = wxFileName::DirName(w.GetPath() + *it);
	320	}
	321	else
	322	{
	323	path = wxFileName::FileName(w.GetPath() + *it);
	324	}
	325
	326	wxFileSystemWatcherEvent event(*changeType, path, path);
	327	SendEvent(event);
	328	}
	329	}
	330	else if ( nflags & NOTE_RENAME )
	331	{
	332	// CHECK it'd be only possible to detect name if we had
	333	// parent files listing which we could confront with now and
	334	// still we couldn't be sure we have the right name...
	335	nflags &= ~NOTE_RENAME;
	336	wxFileSystemWatcherEvent event(wxFSW_EVENT_RENAME,
	337	w.GetPath(), wxFileName());
	338	SendEvent(event);
	339	}
	340	else if ( nflags & NOTE_WRITE \|\| nflags & NOTE_EXTEND )
	341	{
	342	nflags &= ~(NOTE_WRITE \| NOTE_EXTEND);
	343	wxFileSystemWatcherEvent event(wxFSW_EVENT_MODIFY,
	344	w.GetPath(), w.GetPath());
	345	SendEvent(event);
	346	}
	347	else if ( nflags & NOTE_DELETE )
	348	{
	349	nflags &= ~(NOTE_DELETE);
	350	wxFileSystemWatcherEvent event(wxFSW_EVENT_DELETE,
	351	w.GetPath(), w.GetPath());
	352	SendEvent(event);
	353	}
	354	else if ( nflags & NOTE_ATTRIB )
	355	{
	356	nflags &= ~(NOTE_ATTRIB);
	357	wxFileSystemWatcherEvent event(wxFSW_EVENT_ACCESS,
	358	w.GetPath(), w.GetPath());
	359	SendEvent(event);
	360	}
	361
	362	// clear any flags that won't mean anything by themselves
	363	nflags &= ~(NOTE_LINK);
	364	}
	365	}
	366
	367	void SendEvent(wxFileSystemWatcherEvent& evt)
	368	{
	369	m_watcher->GetOwner()->ProcessEvent(evt);
	370	}
	371
	372	static int Watcher2NativeFlags(int WXUNUSED(flags))
	373	{
	374	// TODO: it would be better to only subscribe to what we need
	375	return NOTE_DELETE \| NOTE_WRITE \| NOTE_EXTEND \|
	376	NOTE_ATTRIB \| NOTE_LINK \| NOTE_RENAME \|
	377	NOTE_REVOKE;
	378	}
	379
	380	wxFSWSourceHandler* m_handler; // handler for kqueue event source
	381	wxEventLoopSource* m_source; // our event loop source
	382
	383	// descriptor created by kqueue()
	384	int m_kfd;
	385	};
	386
	387
	388	// once we get signaled to read, actuall event reading occurs
	389	void wxFSWSourceHandler::OnReadWaiting()
	390	{
	391	wxLogTrace(wxTRACE_FSWATCHER, "--- OnReadWaiting ---");
	392	m_service->ReadEvents();
	393	}
	394
	395	void wxFSWSourceHandler::OnWriteWaiting()
	396	{
	397	wxFAIL_MSG("We never write to kqueue descriptor.");
	398	}
	399
	400	void wxFSWSourceHandler::OnExceptionWaiting()
	401	{
	402	wxFAIL_MSG("We never receive exceptions on kqueue descriptor.");
	403	}
	404
	405
	406	// ============================================================================
	407	// wxKqueueFileSystemWatcher implementation
	408	// ============================================================================
	409
	410	wxKqueueFileSystemWatcher::wxKqueueFileSystemWatcher()
	411	: wxFileSystemWatcherBase()
	412	{
	413	Init();
	414	}
	415
	416	wxKqueueFileSystemWatcher::wxKqueueFileSystemWatcher(const wxFileName& path,
	417	int events)
	418	: wxFileSystemWatcherBase()
	419	{
	420	if (!Init())
	421	{
	422	if (m_service)
	423	{
	424	delete m_service;
	425	m_service = NULL;
	426	}
	427	return;
	428	}
	429
	430	Add(path, events);
	431	}
	432
	433	wxKqueueFileSystemWatcher::~wxKqueueFileSystemWatcher()
	434	{
	435	}
	436
	437	bool wxKqueueFileSystemWatcher::Init()
	438	{
	439	m_service = new wxFSWatcherImplKqueue(this);
	440	return m_service->Init();
	441	}
	442
	443	#endif // wxHAS_KQUEUE
	444
	445	#endif // wxUSE_FSWATCHER