Merge pull request #4 from FOSSEE/develop

merging dev into master

1 files changed, 1093 insertions, 0 deletions

diff --git a/kicad/tree_project_frame.cpp b/kicad/tree_project_frame.cpp
new file mode 100644
index 0000000..88df16a
--- /dev/null
+++ b/kicad/tree_project_frame.cpp
@@ -0,0 +1,1093 @@
+/**
+ * @file tree_project_frame.cpp
+ * @brief Function to build the tree of files in the current project directory
+ */
+
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 2012 Jean-Pierre Charras, jp.charras at wanadoo.fr
+ * Copyright (C) 1992-2016 KiCad Developers, see change_log.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <fctsys.h>
+#include <confirm.h>
+#include <gestfich.h>
+#include <pgm_base.h>
+#include <macros.h>
+
+#include <tree_project_frame.h>
+#include <class_treeprojectfiles.h>
+#include <class_treeproject_item.h>
+#include <wildcards_and_files_ext.h>
+
+#include <wx/regex.h>
+#include <wx/dir.h>
+#include <wx/imaglist.h>
+#include <wx/stdpaths.h>
+#include <menus_helpers.h>
+#include <stack>
+
+
+/* Note about the tree project build process:
+ * Building the tree project can be *very* long if there are a lot of subdirectories
+ * in the working directory.
+ * Unfortunately, this happens easily if the project file *.pro is in the home directory
+ * So the tree project is built "on demand":
+ * First the tree is built from the current directory and shows files and subdirs.
+ *   > First level subdirs trees are built (i.e subdirs contents are not read)
+ *   > When expanding a subdir, each subdir contains is read,
+ *     and the corresponding sub tree is populated on the fly.
+ */
+
+// list of files extensions listed in the tree project window
+// *.sch files are always allowed, do not add here
+// Add extensions in a compatible regex format to see others files types
+static const wxChar* s_allowedExtensionsToList[] =
+{
+    wxT( "^.*\\.pro$" ),
+    wxT( "^.*\\.pdf$" ),
+    wxT( "^[^$].*\\.brd$" ),        // Legacy Pcbnew files
+    wxT( "^[^$].*\\.kicad_pcb$" ),  // S format Pcbnew board files
+    wxT( "^[^$].*\\.kicad_wks$" ),  // S format kicad page layout descr files
+    wxT( "^[^$].*\\.kicad_mod$" ),  // S format kicad footprint files, currently not listed
+    wxT( "^.*\\.net$" ),
+    wxT( "^.*\\.lib$" ),            // Schematic library file
+    wxT( "^.*\\.txt$" ),
+    wxT( "^.*\\.pho$" ),            // Gerber file (Old Kicad extension)
+    wxT( "^.*\\.gbr$" ),            // Gerber file
+    wxT( "^.*\\.gb[alops]$" ),      // Gerber back (or bottom) layer file
+    wxT( "^.*\\.gt[alops]$" ),      // Gerber front (or top) layer file
+    wxT( "^.*\\.g[0-9]{1,2}$" ),    // Gerber inner layer file
+    wxT( "^.*\\.odt$" ),
+    wxT( "^.*\\.htm$" ),
+    wxT( "^.*\\.html$" ),
+    wxT( "^.*\\.rpt$" ),            // Report files
+    wxT( "^.*\\.csv$" ),            // Report files in comma separated format
+    wxT( "^.*\\.pos$" ),            // Footprint position files
+    wxT( "^.*\\.cmp$" ),            // Cvpcb cmp/footprint link files
+    wxT( "^.*\\.drl$" ),            // Excellon drill files
+    wxT( "^.*\\.svg$" ),            // SVG print/plot files
+    NULL                            // end of list
+};
+
+
+/* TODO: Check if these file extension and wildcard definitions are used
+ *       in any of the other KiCad programs and move them into the common
+ *       library as required.
+ */
+
+// File extension definitions.
+const wxChar  TextFileExtension[] = wxT( "txt" );
+
+// File wildcard definitions.
+const wxChar  TextFileWildcard[] = wxT( "Text files (*.txt)|*.txt" );
+
+
+/**
+ * @brief class TREE_PROJECT_FRAME is the frame that shows the tree list
+ * of files and subdirs inside the working directory
+ * Files are filtered (see s_allowedExtensionsToList) so
+ * only useful files are shown.
+ */
+
+
+BEGIN_EVENT_TABLE( TREE_PROJECT_FRAME, wxSashLayoutWindow )
+    EVT_TREE_ITEM_ACTIVATED( ID_PROJECT_TREE, TREE_PROJECT_FRAME::OnSelect )
+    EVT_TREE_ITEM_EXPANDED( ID_PROJECT_TREE, TREE_PROJECT_FRAME::OnExpand )
+    EVT_TREE_ITEM_RIGHT_CLICK( ID_PROJECT_TREE, TREE_PROJECT_FRAME::OnRight )
+    EVT_MENU( ID_PROJECT_TXTEDIT, TREE_PROJECT_FRAME::OnOpenSelectedFileWithTextEditor )
+    EVT_MENU( ID_PROJECT_NEWDIR, TREE_PROJECT_FRAME::OnCreateNewDirectory )
+    EVT_MENU( ID_PROJECT_DELETE, TREE_PROJECT_FRAME::OnDeleteFile )
+    EVT_MENU( ID_PROJECT_RENAME, TREE_PROJECT_FRAME::OnRenameFile )
+END_EVENT_TABLE()
+
+
+TREE_PROJECT_FRAME::TREE_PROJECT_FRAME( KICAD_MANAGER_FRAME* parent ) :
+    wxSashLayoutWindow( parent,
+                        ID_LEFT_FRAME,
+                        wxDefaultPosition,
+                        wxDefaultSize,
+                        wxNO_BORDER | wxSW_3D | wxTAB_TRAVERSAL )
+{
+    m_Parent = parent;
+    m_TreeProject = NULL;
+
+    m_watcher = NULL;
+    Connect( wxEVT_FSWATCHER,
+             wxFileSystemWatcherEventHandler( TREE_PROJECT_FRAME::OnFileSystemEvent ) );
+
+    /*
+     * Filtering is now inverted: the filters are actually used to _enable_ support
+     * for a given file type.
+     */
+
+    // NOTE: sch filter must be first because of a test in AddFile() below
+    m_filters.push_back( wxT( "^.*\\.sch$" ) );
+
+    for( int ii = 0; s_allowedExtensionsToList[ii] != NULL; ii++ )
+        m_filters.push_back( s_allowedExtensionsToList[ii] );
+
+    m_filters.push_back( wxT( "^no KiCad files found" ) );
+
+    ReCreateTreePrj();
+}
+
+
+TREE_PROJECT_FRAME::~TREE_PROJECT_FRAME()
+{
+    if( m_watcher )
+    {
+        m_watcher->RemoveAll();
+        m_watcher->SetOwner( NULL );
+        delete m_watcher;
+    }
+}
+
+
+void TREE_PROJECT_FRAME::RemoveFilter( const wxString& filter )
+{
+    for( unsigned int i = 0; i < m_filters.size(); i++ )
+    {
+        if( filter == m_filters[i] )
+        {
+            m_filters.erase( m_filters.begin() + i );
+            return;
+        }
+    }
+}
+
+
+void TREE_PROJECT_FRAME::OnCreateNewDirectory( wxCommandEvent& event )
+{
+    // Get the root directory name:
+    TREEPROJECT_ITEM* treeData = GetSelectedData();
+
+    if( !treeData )
+        return;
+
+    TreeFileType    rootType = treeData->GetType();
+    wxTreeItemId    root;
+
+    if( TREE_DIRECTORY == rootType )
+    {
+        root = m_TreeProject->GetSelection();
+    }
+    else
+    {
+        root = m_TreeProject->GetItemParent( m_TreeProject->GetSelection() );
+
+        if( !root.IsOk() )
+            root = m_TreeProject->GetSelection();
+    }
+
+    wxString prj_dir = wxPathOnly( m_Parent->GetProjectFileName() );
+
+    // Ask for the new sub directory name
+    wxString curr_dir = treeData->GetDir();
+
+    if( !curr_dir.IsEmpty() )    // A subdir is selected
+    {
+        // Make this subdir name relative to the current path.
+        // It will be more easy to read by the user, in the next dialog
+        wxFileName fn;
+        fn.AssignDir( curr_dir );
+        fn.MakeRelativeTo( prj_dir );
+        curr_dir = fn.GetPath();
+
+        if( !curr_dir.IsEmpty() )
+            curr_dir += wxFileName::GetPathSeparator();
+    }
+
+    wxString  msg = wxString::Format( _( "Current project directory:\n%s" ), GetChars( prj_dir ) );
+    wxString  subdir = wxGetTextFromUser( msg, _( "Create New Directory" ), curr_dir );
+
+    if( subdir.IsEmpty() )
+        return;
+
+    wxString full_dirname = prj_dir + wxFileName::GetPathSeparator() + subdir;
+
+    if( wxMkdir( full_dirname ) )
+    {
+        // the new itel will be added by the file watcher
+        // AddItemToTreeProject( subdir, root );
+    }
+}
+
+
+wxString TREE_PROJECT_FRAME::GetFileExt( TreeFileType type )
+{
+    wxString ext;
+
+    switch( type )
+    {
+    case TREE_PROJECT:
+        ext = ProjectFileExtension;
+        break;
+
+    case TREE_SCHEMA:
+        ext = SchematicFileExtension;
+        break;
+
+    case TREE_LEGACY_PCB:
+        ext = LegacyPcbFileExtension;
+        break;
+
+    case TREE_SEXP_PCB:
+        ext = KiCadPcbFileExtension;
+        break;
+
+    case TREE_GERBER:
+        ext = GerberFileExtension;
+        break;
+
+    case TREE_HTML:
+        ext = HtmlFileExtension;
+        break;
+
+    case TREE_PDF:
+        ext = PdfFileExtension;
+        break;
+
+    case TREE_TXT:
+        ext = TextFileExtension;
+        break;
+
+    case TREE_NET:
+        ext = NetlistFileExtension;
+        break;
+
+    case TREE_CMP_LINK:
+        ext = ComponentFileExtension;
+        break;
+
+    case TREE_REPORT:
+        ext = ReportFileExtension;
+        break;
+
+    case TREE_FP_PLACE:
+        ext = FootprintPlaceFileExtension;
+        break;
+
+    case TREE_DRILL:
+        ext = DrillFileExtension;
+        break;
+
+    case TREE_SVG:
+        ext = SVGFileExtension;
+        break;
+
+    case TREE_PAGE_LAYOUT_DESCR:
+        ext = PageLayoutDescrFileExtension;
+        break;
+
+    case TREE_FOOTPRINT_FILE:
+        ext = KiCadFootprintFileExtension;
+        break;
+
+    case TREE_SCHEMATIC_LIBFILE:
+        ext = SchematicLibraryFileExtension;
+        break;
+
+    default:                       // Eliminates unnecessary GCC warning.
+        break;
+    }
+
+    return ext;
+}
+
+
+/*
+ * Return the wxFileDialog wildcard string for the selected file type.
+ */
+wxString TREE_PROJECT_FRAME::GetFileWildcard( TreeFileType type )
+{
+    wxString ext;
+
+    switch( type )
+    {
+    case TREE_PROJECT:
+        ext = ProjectFileWildcard;
+        break;
+
+    case TREE_SCHEMA:
+        ext = SchematicFileWildcard;
+        break;
+
+    case TREE_LEGACY_PCB:
+    case TREE_SEXP_PCB:
+        ext = PcbFileWildcard;
+        break;
+
+    case TREE_GERBER:
+        ext = GerberFileWildcard;
+        break;
+
+    case TREE_HTML:
+        ext = HtmlFileWildcard;
+        break;
+
+    case TREE_PDF:
+        ext = PdfFileWildcard;
+        break;
+
+    case TREE_TXT:
+        ext = TextFileWildcard;
+        break;
+
+    case TREE_NET:
+        ext = NetlistFileWildcard;
+        break;
+
+    case TREE_CMP_LINK:
+        ext = ComponentFileWildcard;
+        break;
+
+    case TREE_REPORT:
+        ext = ReportFileWildcard;
+        break;
+
+    case TREE_FP_PLACE:
+        ext = FootprintPlaceFileWildcard;
+        break;
+
+    case TREE_DRILL:
+        ext = DrillFileWildcard;
+        break;
+
+    case TREE_SVG:
+        ext = SVGFileWildcard;
+        break;
+
+    case TREE_PAGE_LAYOUT_DESCR:
+        ext = PageLayoutDescrFileWildcard;
+        break;
+
+    case TREE_FOOTPRINT_FILE:
+        ext = KiCadFootprintLibFileWildcard;
+        break;
+
+    case TREE_SCHEMATIC_LIBFILE:
+        ext = SchematicLibraryFileWildcard;
+        break;
+
+     default:                       // Eliminates unnecessary GCC warning.
+        break;
+    }
+
+    return ext;
+}
+
+
+bool TREE_PROJECT_FRAME::AddItemToTreeProject( const wxString& aName,
+                                        wxTreeItemId& aRoot, bool aRecurse )
+{
+    wxTreeItemId    cellule;
+
+    // Check the file type
+    TreeFileType    type = TREE_UNKNOWN;
+
+    // Skip not visible files and dirs
+    wxFileName      fn( aName );
+
+    // Files/dirs names starting by "." are not visible files under unices.
+    // Skip them also under Windows
+    if( fn.GetName().StartsWith( wxT( "." ) ) )
+        return false;
+
+    if( wxDirExists( aName ) )
+    {
+        type = TREE_DIRECTORY;
+    }
+    else
+    {
+        // Filter
+        wxRegEx reg;
+
+        bool    isSchematic = false;
+        bool    addFile     = false;
+
+        for( unsigned i = 0; i < m_filters.size(); i++ )
+        {
+            wxCHECK2_MSG( reg.Compile( m_filters[i], wxRE_ICASE ), continue,
+                          wxT( "Regular expression " ) + m_filters[i] +
+                          wxT( " failed to compile." ) );
+
+            if( reg.Matches( aName ) )
+            {
+                addFile = true;
+
+                if( i==0 )
+                    isSchematic = true;
+
+                break;
+            }
+        }
+
+        if( !addFile )
+            return false;
+
+        // only show the schematic if it is a top level schematic.  Eeschema
+        // cannot open a schematic and display it properly unless it starts
+        // at the top of the hierarchy.  The schematic is top level only if
+        // there is a line in the header saying:
+        // "Sheet 1 "
+        // However if the file has the same name as the project, it is always
+        // shown, because it is expected the root sheet.
+        // (and to fix an issue (under XP but could exist under other OS),
+        // when a .sch file is created, the file
+        // create is sent to the wxFileSystemWatcher, but the file still has 0 byte
+        // so it cannot detected as root sheet
+        // This is an ugly fix.
+        if( isSchematic )
+        {
+            wxString    fullFileName = aName.BeforeLast( '.' );
+            wxString    rootName;
+            TREEPROJECT_ITEM* itemData = GetItemIdData( m_root );
+            if( itemData )
+                rootName = itemData->GetFileName().BeforeLast( '.' );
+
+            if( fullFileName != rootName )
+            {
+                char        line[128]; // small because we just need a few bytes from the start of a line
+                FILE*       fp;
+
+                fullFileName = aName;
+                fp = wxFopen( fullFileName, wxT( "rt" ) );
+
+                if( fp == NULL )
+                    return false;
+
+                addFile = false;
+
+                // check the first 100 lines for the "Sheet 1" string
+                for( int i = 0; i<100; ++i )
+                {
+                    if( !fgets( line, sizeof(line), fp ) )
+                        break;
+
+                    if( !strncmp( line, "Sheet 1 ", 8 ) )
+                    {
+                        addFile = true;
+                        break;
+                    }
+                }
+
+                fclose( fp );
+
+                if( !addFile )
+                    return false; // it is a non-top-level schematic
+            }
+        }
+
+        for( int i = TREE_PROJECT; i < TREE_MAX; i++ )
+        {
+            wxString ext = GetFileExt( (TreeFileType) i );
+
+            if( ext == wxT( "" ) )
+                continue;
+
+            reg.Compile( wxString::FromAscii( "^.*\\" ) + ext +
+                         wxString::FromAscii( "$" ), wxRE_ICASE );
+
+            if( reg.Matches( aName ) )
+            {
+                type = (TreeFileType) i;
+                break;
+            }
+        }
+    }
+
+    // also check to see if it is already there.
+    wxTreeItemIdValue   cookie;
+    wxTreeItemId        kid = m_TreeProject->GetFirstChild( aRoot, cookie );
+
+    while( kid.IsOk() )
+    {
+        TREEPROJECT_ITEM* itemData = GetItemIdData( kid );
+
+        if( itemData )
+        {
+            if( itemData->GetFileName() == aName )
+            {
+                return true;    // well, we would have added it, but it is already here!
+            }
+        }
+
+        kid = m_TreeProject->GetNextChild( aRoot, cookie );
+    }
+
+    // Append the item (only appending the filename not the full path):
+    wxString            file = wxFileNameFromPath( aName );
+    cellule = m_TreeProject->AppendItem( aRoot, file );
+    TREEPROJECT_ITEM*   data = new TREEPROJECT_ITEM( type, aName, m_TreeProject );
+
+    m_TreeProject->SetItemData( cellule, data );
+    data->SetState( 0 );
+
+    // Mark root files (files which have the same aName as the project)
+    wxFileName  project( m_Parent->GetProjectFileName() );
+    wxFileName  currfile( file );
+
+    if( currfile.GetName().CmpNoCase( project.GetName() ) == 0 )
+        data->SetRootFile( true );
+    else
+        data->SetRootFile( false );
+
+    // This section adds dirs and files found in the subdirs
+    // in this case AddFile is recursive, but for the first level only.
+    if( TREE_DIRECTORY == type && aRecurse )
+    {
+        wxDir   dir( aName );
+
+        if( dir.IsOpened() )    // protected dirs will not open properly.
+        {
+            wxString        dir_filename;
+
+            data->SetPopulated( true );
+
+            if( dir.GetFirst( &dir_filename ) )
+            {
+                do    // Add name in tree, but do not recurse
+                {
+                    wxString path = aName + wxFileName::GetPathSeparator() + dir_filename;
+                    AddItemToTreeProject( path, cellule, false );
+                } while( dir.GetNext( &dir_filename ) );
+            }
+        }
+
+        // Sort filenames by alphabetic order
+        m_TreeProject->SortChildren( cellule );
+    }
+
+    return true;
+}
+
+
+void TREE_PROJECT_FRAME::ReCreateTreePrj()
+{
+    wxTreeItemId    rootcellule;
+    bool            prjOpened = false;
+    wxString        pro_dir = m_Parent->GetProjectFileName();
+
+    if( !m_TreeProject )
+        m_TreeProject = new TREEPROJECTFILES( this );
+    else
+        m_TreeProject->DeleteAllItems();
+
+    if( !pro_dir )  // This is empty from TREE_PROJECT_FRAME constructor
+        return;
+
+    wxFileName fn = pro_dir;
+
+    if( !fn.IsOk() )
+    {
+        fn.Clear();
+        fn.SetPath( wxStandardPaths::Get().GetDocumentsDir() );
+        fn.SetName( NAMELESS_PROJECT );
+        fn.SetExt( ProjectFileExtension );
+    }
+
+    prjOpened = fn.FileExists();
+
+    // root tree:
+    m_root = rootcellule = m_TreeProject->AddRoot( fn.GetFullName(),
+                                                   TREE_PROJECT - 1,
+                                                   TREE_PROJECT - 1 );
+
+    m_TreeProject->SetItemBold( rootcellule, true );
+
+    m_TreeProject->SetItemData( rootcellule,
+                                new TREEPROJECT_ITEM( TREE_PROJECT,
+                                                      fn.GetFullPath(),
+                                                      m_TreeProject ) );
+
+    // Now adding all current files if available
+    if( prjOpened )
+    {
+        wxString    pro_dir = wxPathOnly( m_Parent->GetProjectFileName() );
+        wxDir       dir( pro_dir );
+
+        if( dir.IsOpened() )    // protected dirs will not open, see "man opendir()"
+        {
+            wxString    filename;
+            bool        cont = dir.GetFirst( &filename );
+
+            while( cont )
+            {
+                if( filename != fn.GetFullName() )
+                {
+                    wxString name = dir.GetName() + wxFileName::GetPathSeparator() + filename;
+                    AddItemToTreeProject( name, m_root );
+                }
+
+                cont = dir.GetNext( &filename );
+            }
+        }
+    }
+    else
+    {
+        m_TreeProject->AppendItem( m_root, wxT( "Empty project" ) );
+    }
+
+    m_TreeProject->Expand( rootcellule );
+
+    // Sort filenames by alphabetic order
+    m_TreeProject->SortChildren( m_root );
+}
+
+
+void TREE_PROJECT_FRAME::OnRight( wxTreeEvent& Event )
+{
+    int                 tree_id;
+    TREEPROJECT_ITEM*   tree_data;
+    wxString            fullFileName;
+    wxTreeItemId        curr_item = Event.GetItem();
+
+    // Ensure item is selected (Under Windows right click does not select the item)
+    m_TreeProject->SelectItem( curr_item );
+
+    tree_data = GetSelectedData();
+
+    if( !tree_data )
+        return;
+
+    tree_id = tree_data->GetType();
+    fullFileName = tree_data->GetFileName();
+
+    wxMenu popupMenu;
+
+    switch( tree_id )
+    {
+        case TREE_PROJECT:
+            AddMenuItem( &popupMenu, ID_PROJECT_NEWDIR,
+                         _( "New D&irectory" ),
+                         _( "Create a New Directory" ),
+                         KiBitmap( directory_xpm ) );
+            break;
+
+        case TREE_DIRECTORY:
+            AddMenuItem( &popupMenu, ID_PROJECT_NEWDIR,
+                         _( "New D&irectory" ),
+                         _( "Create a New Directory" ),
+                         KiBitmap( directory_xpm ) );
+            AddMenuItem( &popupMenu,  ID_PROJECT_DELETE,
+                         _( "&Delete Directory" ),
+                         _( "Delete the Directory and its content" ),
+                         KiBitmap( delete_xpm ) );
+            break;
+
+        default:
+            AddMenuItem( &popupMenu, ID_PROJECT_TXTEDIT,
+                         _( "&Edit in a text editor" ),
+                         _( "Open the file in a Text Editor" ),
+                         KiBitmap( icon_txt_xpm ) );
+            AddMenuItem( &popupMenu, ID_PROJECT_RENAME,
+                         _( "&Rename file" ),
+                         _( "Rename file" ),
+                         KiBitmap( right_xpm ) );
+            AddMenuItem( &popupMenu,  ID_PROJECT_DELETE,
+                         _( "&Delete File" ),
+                         _( "Delete the Directory and its content" ),
+                         KiBitmap( delete_xpm ) );
+            break;
+    }
+
+    PopupMenu( &popupMenu );
+}
+
+
+void TREE_PROJECT_FRAME::OnOpenSelectedFileWithTextEditor( wxCommandEvent& event )
+{
+    TREEPROJECT_ITEM* tree_data = GetSelectedData();
+
+    if( !tree_data )
+        return;
+
+    if( tree_data->GetType() == TREE_DIRECTORY )
+        return;
+
+    wxString    fullFileName = tree_data->GetFileName();
+    AddDelimiterString( fullFileName );
+    wxString    editorname = Pgm().GetEditorName();
+
+    if( !editorname.IsEmpty() )
+        ExecuteFile( this, editorname, fullFileName );
+}
+
+
+void TREE_PROJECT_FRAME::OnDeleteFile( wxCommandEvent& )
+{
+    TREEPROJECT_ITEM* tree_data = GetSelectedData();
+
+    if( !tree_data )
+        return;
+
+    tree_data->Delete();
+}
+
+
+void TREE_PROJECT_FRAME::OnRenameFile( wxCommandEvent& )
+{
+    wxTreeItemId        curr_item   = m_TreeProject->GetSelection();
+    TREEPROJECT_ITEM*   tree_data   = GetSelectedData();
+
+    if( !tree_data )
+        return;
+
+    wxString buffer = m_TreeProject->GetItemText( curr_item );
+    wxString msg = wxString::Format(
+                    _( "Change filename: '%s'" ),
+                    GetChars( tree_data->GetFileName() ) );
+
+    wxTextEntryDialog   dlg( this, msg, _( "Change filename" ), buffer );
+
+    if( dlg.ShowModal() != wxID_OK )
+        return; // canceled by user
+
+    buffer = dlg.GetValue();
+    buffer.Trim( true );
+    buffer.Trim( false );
+
+    if( buffer.IsEmpty() )
+        return; // empty file name not allowed
+
+    if( tree_data->Rename( buffer, true ) )
+        m_TreeProject->SetItemText( curr_item, buffer );
+}
+
+
+void TREE_PROJECT_FRAME::OnSelect( wxTreeEvent& Event )
+{
+    TREEPROJECT_ITEM*   tree_data = GetSelectedData();
+
+    if( !tree_data )
+        return;
+
+    tree_data->Activate( this );
+}
+
+
+void TREE_PROJECT_FRAME::OnExpand( wxTreeEvent& Event )
+{
+    wxTreeItemId        itemId      = Event.GetItem();
+    TREEPROJECT_ITEM*   tree_data   = GetItemIdData( itemId );
+
+    if( !tree_data )
+        return;
+
+    if( tree_data->GetType() != TREE_DIRECTORY )
+        return;
+
+    // explore list of non populated subdirs, and populate them
+    wxTreeItemIdValue   cookie;
+    wxTreeItemId        kid = m_TreeProject->GetFirstChild( itemId, cookie );
+
+    bool subdir_populated = false;
+
+    for( ; kid.IsOk(); kid = m_TreeProject->GetNextChild( itemId, cookie ) )
+    {
+        TREEPROJECT_ITEM* itemData = GetItemIdData( kid );
+
+        if( !itemData || itemData->GetType() != TREE_DIRECTORY )
+            continue;
+
+        if( itemData->IsPopulated() )
+            continue;
+
+        wxString    fileName = itemData->GetFileName();
+        wxDir       dir( fileName );
+
+        if( dir.IsOpened() )
+        {
+            wxString    dir_filename;
+
+            if( dir.GetFirst( &dir_filename ) )
+            {
+                do    // Add name to tree item, but do not recurse in subdirs:
+                {
+                    wxString name = fileName + wxFileName::GetPathSeparator() + dir_filename;
+                    AddItemToTreeProject( name, kid, false );
+                } while( dir.GetNext( &dir_filename ) );
+            }
+
+            itemData->SetPopulated( true );       // set state to populated
+            subdir_populated = true;
+        }
+
+        // Sort filenames by alphabetic order
+        m_TreeProject->SortChildren( kid );
+    }
+
+    if( subdir_populated )
+    {
+    #ifndef __WINDOWS__
+        FileWatcherReset();
+    #endif
+    }
+}
+
+
+TREEPROJECT_ITEM* TREE_PROJECT_FRAME::GetSelectedData()
+{
+    return dynamic_cast<TREEPROJECT_ITEM*>( m_TreeProject->GetItemData
+                                            ( m_TreeProject->GetSelection() ) );
+}
+
+
+TREEPROJECT_ITEM* TREE_PROJECT_FRAME::GetItemIdData( wxTreeItemId aId )
+{
+    return dynamic_cast<TREEPROJECT_ITEM*>( m_TreeProject->GetItemData( aId ) );
+}
+
+
+wxTreeItemId TREE_PROJECT_FRAME::findSubdirTreeItem( const wxString& aSubDir )
+{
+    wxString prj_dir = wxPathOnly( m_Parent->GetProjectFileName() );
+
+    // If the subdir is the current working directory, return m_root
+    // in main list:
+    if( prj_dir == aSubDir )
+        return m_root;
+
+    // The subdir is in the main tree or in a subdir: Locate it
+    wxTreeItemIdValue  cookie;
+    wxTreeItemId       root_id = m_root;
+    std::stack < wxTreeItemId > subdirs_id;
+
+    wxTreeItemId kid = m_TreeProject->GetFirstChild( root_id, cookie );
+
+    while( 1 )
+    {
+        if( ! kid.IsOk() )
+        {
+            if( subdirs_id.empty() )    // all items were explored
+            {
+                root_id = kid;          // Not found: return an invalid wxTreeItemId
+                break;
+            }
+            else
+            {
+                root_id = subdirs_id.top();
+                subdirs_id.pop();
+                kid = m_TreeProject->GetFirstChild( root_id, cookie );
+
+                if( ! kid.IsOk() )
+                    continue;
+            }
+        }
+
+        TREEPROJECT_ITEM* itemData = GetItemIdData( kid );
+
+        if( itemData && ( itemData->GetType() == TREE_DIRECTORY ) )
+        {
+            if( itemData->GetFileName() == aSubDir )    // Found!
+            {
+                root_id = kid;
+                break;
+            }
+
+            // kid is a subdir, push in list to explore it later
+            if( itemData->IsPopulated() )
+                subdirs_id.push( kid );
+        }
+
+        kid = m_TreeProject->GetNextChild( root_id, cookie );
+    }
+
+    return root_id;
+}
+
+
+void TREE_PROJECT_FRAME::OnFileSystemEvent( wxFileSystemWatcherEvent& event )
+{
+    wxFileName pathModified = event.GetPath();
+    wxString subdir = pathModified.GetPath();
+    wxString fn = pathModified.GetFullPath();
+
+    switch( event.GetChangeType() )
+    {
+    case wxFSW_EVENT_DELETE:
+        break;
+
+    case wxFSW_EVENT_CREATE:
+        break;
+
+    case wxFSW_EVENT_RENAME:
+        break;
+
+    case wxFSW_EVENT_MODIFY:
+    case wxFSW_EVENT_ACCESS:
+    default:
+        return;
+    }
+
+    wxTreeItemId root_id = findSubdirTreeItem( subdir );
+
+    if( !root_id.IsOk() )
+        return;
+
+    wxTreeItemIdValue  cookie;  // dummy variable needed by GetFirstChild()
+    wxTreeItemId kid = m_TreeProject->GetFirstChild( root_id, cookie );
+
+    switch( event.GetChangeType() )
+    {
+    case wxFSW_EVENT_CREATE:
+        AddItemToTreeProject( pathModified.GetFullPath(), root_id, false );
+        break;
+
+    case wxFSW_EVENT_DELETE:
+        while( kid.IsOk() )
+        {
+            TREEPROJECT_ITEM* itemData = GetItemIdData( kid );
+
+            if( itemData  &&  itemData->GetFileName() == fn )
+            {
+                m_TreeProject->Delete( kid );
+                return;
+            }
+            kid = m_TreeProject->GetNextChild( root_id, cookie );
+        }
+        break;
+
+    case wxFSW_EVENT_RENAME :
+        {
+            wxFileName  newpath = event.GetNewPath();
+            wxString    newfn = newpath.GetFullPath();
+
+            while( kid.IsOk() )
+            {
+                TREEPROJECT_ITEM* itemData = GetItemIdData( kid );
+
+                if( itemData  &&  itemData->GetFileName() == fn )
+                {
+                    m_TreeProject->Delete( kid );
+                    break;
+                }
+
+                kid = m_TreeProject->GetNextChild( root_id, cookie );
+            }
+
+            AddItemToTreeProject( newfn, root_id, false );
+        }
+        break;
+    }
+
+    // Sort filenames by alphabetic order
+    m_TreeProject->SortChildren( root_id );
+}
+
+
+void TREE_PROJECT_FRAME::FileWatcherReset()
+{
+    // Prepare file watcher:
+    if( m_watcher )
+    {
+        m_watcher->RemoveAll();
+    }
+    else
+    {
+        m_watcher = new wxFileSystemWatcher();
+        m_watcher->SetOwner( this );
+    }
+
+    // Add directories which should be monitored.
+    // under windows, we add the curr dir and all subdirs
+    // under unix, we add only the curr dir and the populated subdirs
+    // see  http://docs.wxwidgets.org/trunk/classwx_file_system_watcher.htm
+    // under unix, the file watcher needs more work to be efficient
+    // moreover, under wxWidgets 2.9.4, AddTree does not work properly.
+
+    // We can see wxString under a debugger, not a wxFileName
+    wxString prj_dir = wxPathOnly( m_Parent->GetProjectFileName() );
+    wxFileName fn;
+    fn.AssignDir( prj_dir );
+    fn.DontFollowLink();
+
+#ifdef __WINDOWS__
+    m_watcher->AddTree( fn );
+#else
+    m_watcher->Add( fn );
+
+    // Add subdirs
+    wxTreeItemIdValue  cookie;
+    wxTreeItemId       root_id = m_root;
+
+    std::stack < wxTreeItemId > subdirs_id;
+
+    wxTreeItemId kid = m_TreeProject->GetFirstChild( root_id, cookie );
+
+    while( 1 )
+    {
+        if( !kid.IsOk() )
+        {
+            if( subdirs_id.empty() )    // all items were explored
+                break;
+            else
+            {
+                root_id = subdirs_id.top();
+                subdirs_id.pop();
+                kid = m_TreeProject->GetFirstChild( root_id, cookie );
+
+                if( !kid.IsOk() )
+                    continue;
+            }
+        }
+
+        TREEPROJECT_ITEM* itemData = GetItemIdData( kid );
+
+        if( itemData && itemData->GetType() == TREE_DIRECTORY )
+        {
+            // we can see wxString under a debugger, not a wxFileName
+            wxString path = itemData->GetFileName();
+
+            wxLogDebug( "%s: add '%s'\n", __func__, TO_UTF8( path ) );
+
+            if( wxFileName::IsDirReadable( path ) )     // linux whines about watching protected dir
+            {
+                fn.AssignDir( path );
+                m_watcher->Add( fn );
+
+                // if kid is a subdir, push in list to explore it later
+                if( itemData->IsPopulated() && m_TreeProject->GetChildrenCount( kid ) )
+                    subdirs_id.push( kid );
+            }
+        }
+
+        kid = m_TreeProject->GetNextChild( root_id, cookie );
+    }
+#endif
+
+#if defined(DEBUG) && 1
+    wxArrayString paths;
+    m_watcher->GetWatchedPaths( &paths );
+    wxLogDebug( "%s: watched paths:", __func__ );
+
+    for( unsigned ii = 0; ii < paths.GetCount(); ii++ )
+        wxLogDebug( " %s\n", TO_UTF8( paths[ii] ) );
+#endif
+}
+
+
+void KICAD_MANAGER_FRAME::OnChangeWatchedPaths( wxCommandEvent& aEvent )
+{
+    m_LeftWin->FileWatcherReset();
+}