1145 lines
32 KiB
C++
1145 lines
32 KiB
C++
/**
|
|
* @file treeprj_frame.cpp
|
|
* @brief TODO
|
|
*/
|
|
|
|
|
|
#ifdef KICAD_PYTHON
|
|
#include <pyhandler.h>
|
|
#endif
|
|
|
|
#include "fctsys.h"
|
|
#include "gr_basic.h"
|
|
#include "common.h"
|
|
|
|
#include "kicad.h"
|
|
#include "protos.h"
|
|
|
|
#include "wx/image.h"
|
|
#include "wx/imaglist.h"
|
|
#include "wx/treectrl.h"
|
|
#include "wx/regex.h"
|
|
#include "wx/dir.h"
|
|
|
|
#include "bitmaps.h"
|
|
|
|
#include "id.h"
|
|
|
|
// Comment this if you do no want to load subdirs files in the tree project
|
|
// UnComment this to load subdirs files in the tree project
|
|
#define ADD_FILES_IN_SUBDIRS
|
|
|
|
// 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
|
|
const wxChar * s_AllowedExtensionsToList[] =
|
|
{
|
|
wxT( "^.*\\.pro$" ),
|
|
wxT( "^.*\\.pdf$" ),
|
|
wxT( "^[^$].*\\.brd$" ),
|
|
wxT( "^.*\\.net$" ),
|
|
wxT( "^.*\\.txt$" ),
|
|
wxT( "^.*\\.pho$" ),
|
|
wxT( "^.*\\.odt$" ),
|
|
wxT( "^.*\\.sxw$" ),
|
|
wxT( "^.*\\.htm$" ),
|
|
wxT( "^.*\\.html$" ),
|
|
NULL // end of list
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/******************************************************************/
|
|
WinEDA_PrjFrame::WinEDA_PrjFrame( WinEDA_MainFrame* parent,
|
|
const wxPoint& pos,
|
|
const wxSize& size ) :
|
|
wxSashLayoutWindow( parent,
|
|
ID_LEFT_FRAME,
|
|
pos,
|
|
size,
|
|
wxNO_BORDER | wxSW_3D )
|
|
/******************************************************************/
|
|
{
|
|
m_Parent = parent;
|
|
m_TreeProject = NULL;
|
|
wxMenuItem* item;
|
|
m_PopupMenu = NULL;
|
|
|
|
/*
|
|
* 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" ) );
|
|
|
|
|
|
#ifdef KICAD_PYTHON
|
|
m_Filters.push_back( wxT( "^.*\\.py$" ) );
|
|
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::RunScript" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::EditScript" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::TreeContextMenu" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::TreeAddFile" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::NewFile" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::NewDirectory" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::DeleteFile" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::RenameFile" ) );
|
|
PyHandler::GetInstance()->DeclareEvent( wxT( "kicad::MoveFile" ) );
|
|
#endif /* KICAD_PYTHON */
|
|
|
|
|
|
for( int i = 0; i < TREE_MAX; i++ )
|
|
m_ContextMenus.push_back( new wxMenu() );
|
|
|
|
wxMenu* menu = m_ContextMenus[TREE_PY];
|
|
|
|
// Python script context menu
|
|
#ifdef KICAD_PYTHON
|
|
item = new wxMenuItem( menu, ID_PROJECT_RUNPY,
|
|
_( "&Run" ),
|
|
_( "Run the Python Script" ) );
|
|
item->SetBitmap( icon_python_small_xpm );
|
|
menu->Append( item );
|
|
#endif /* KICAD_PYTHON */
|
|
|
|
|
|
// ID_PROJECT_TXTEDIT
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_TXTEDIT,
|
|
_( "&Edit in a text editor" ),
|
|
_( "&Open the file in a Text Editor" ) );
|
|
item->SetBitmap( icon_txt_xpm );
|
|
menu->Append( item );
|
|
|
|
|
|
// New files context menu:
|
|
wxMenu* menus[2];
|
|
menus[0] = m_ContextMenus[TREE_DIRECTORY];
|
|
menus[1] = m_ContextMenus[TREE_PROJECT];
|
|
|
|
for( int i = 0; i < 2; i++ )
|
|
{
|
|
menu = menus[i];
|
|
|
|
// ID_PROJECT_NEWDIR
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_NEWDIR,
|
|
_( "New D&irectory" ),
|
|
_( "Create a New Directory" ) );
|
|
item->SetBitmap( directory_xpm );
|
|
menu->Append( item );
|
|
|
|
|
|
// ID_PROJECT_NEWPY
|
|
#ifdef KICAD_PYTHON
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_NEWPY,
|
|
_( "New P&ython Script" ),
|
|
_( "Create a New Python Script" ) );
|
|
item->SetBitmap( new_python_xpm );
|
|
menu->Append( item );
|
|
#endif /* KICAD_PYTHON */
|
|
|
|
|
|
// ID_PROJECT_NEWTXT
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_NEWTXT,
|
|
_( "New &Text File" ),
|
|
_( "Create a New Txt File" ) );
|
|
item->SetBitmap( new_txt_xpm );
|
|
menu->Append( item );
|
|
|
|
|
|
// ID_PROJECT_NEWFILE
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_NEWFILE,
|
|
_( "New &File" ),
|
|
_( "Create a New File" ) );
|
|
item->SetBitmap( new_xpm );
|
|
menu->Append( item );
|
|
}
|
|
|
|
|
|
// Put the Rename and Delete file menu commands:
|
|
for( int i = TREE_PROJECT + 1; i < TREE_MAX; i++ )
|
|
{
|
|
menu = m_ContextMenus[i];
|
|
|
|
|
|
// ID_PROJECT_RENAME
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_RENAME,
|
|
TREE_DIRECTORY != i ? _ ("&Rename file") :
|
|
_( "&Rename directory" ),
|
|
TREE_DIRECTORY != i ? _ ("Rename file") :
|
|
_( "&Rename directory" ) );
|
|
item->SetBitmap( right_xpm );
|
|
menu->Append( item );
|
|
|
|
|
|
if( TREE_DIRECTORY != i )
|
|
{
|
|
// ID_PROJECT_TXTEDIT
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_TXTEDIT,
|
|
_( "&Edit in a text editor" ),
|
|
_( "Open the file in a Text Editor" ) );
|
|
item->SetBitmap( icon_txt_xpm );
|
|
menu->Append( item );
|
|
}
|
|
|
|
// ID_PROJECT_DELETE
|
|
item = new wxMenuItem( menu,
|
|
ID_PROJECT_DELETE,
|
|
TREE_DIRECTORY != i ? _( "&Delete File" ) :
|
|
_( "&Delete Directory" ),
|
|
TREE_DIRECTORY != i ? _( "Delete the File" ) :
|
|
_( "&Delete the Directory and its content" ) );
|
|
item->SetBitmap( delete_xpm );
|
|
menu->Append( item );
|
|
}
|
|
|
|
ReCreateTreePrj();
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
BEGIN_EVENT_TABLE( WinEDA_PrjFrame, wxSashLayoutWindow )
|
|
/*****************************************************************************/
|
|
|
|
EVT_TREE_BEGIN_LABEL_EDIT( ID_PROJECT_TREE, WinEDA_PrjFrame::OnRenameAsk )
|
|
EVT_TREE_END_LABEL_EDIT( ID_PROJECT_TREE, WinEDA_PrjFrame::OnRename )
|
|
EVT_TREE_ITEM_ACTIVATED( ID_PROJECT_TREE, WinEDA_PrjFrame::OnSelect )
|
|
EVT_TREE_ITEM_RIGHT_CLICK( ID_PROJECT_TREE, WinEDA_PrjFrame::OnRight )
|
|
EVT_TREE_BEGIN_DRAG( ID_PROJECT_TREE, WinEDA_PrjFrame::OnDragStart )
|
|
EVT_TREE_END_DRAG( ID_PROJECT_TREE, WinEDA_PrjFrame::OnDragEnd )
|
|
EVT_MENU( ID_PROJECT_TXTEDIT, WinEDA_PrjFrame::OnTxtEdit )
|
|
EVT_MENU( ID_PROJECT_NEWFILE, WinEDA_PrjFrame::OnNewFile )
|
|
EVT_MENU( ID_PROJECT_NEWDIR, WinEDA_PrjFrame::OnNewDirectory )
|
|
EVT_MENU( ID_PROJECT_NEWPY, WinEDA_PrjFrame::OnNewPyFile )
|
|
EVT_MENU( ID_PROJECT_NEWTXT, WinEDA_PrjFrame::OnNewTxtFile )
|
|
EVT_MENU( ID_PROJECT_DELETE, WinEDA_PrjFrame::OnDeleteFile )
|
|
EVT_MENU( ID_PROJECT_RENAME, WinEDA_PrjFrame::OnRenameFile )
|
|
|
|
|
|
#ifdef KICAD_PYTHON
|
|
EVT_MENU( ID_PROJECT_RUNPY, WinEDA_PrjFrame::OnRunPy )
|
|
#endif /* KICAD_PYTHON */
|
|
|
|
|
|
/*****************************************************************************/
|
|
END_EVENT_TABLE()
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
WinEDA_TreePrj::~WinEDA_TreePrj()
|
|
/*****************************************************************************/
|
|
{
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief Allowing drag & drop of file other than the currently opened project
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnDragStart( wxTreeEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
/* Ensure item is selected
|
|
(Under Windows start drag does not activate the item) */
|
|
wxTreeItemId curr_item = event.GetItem();
|
|
|
|
m_TreeProject->SelectItem( curr_item );
|
|
TreePrjItemData* data = GetSelectedData();
|
|
if( data->GetFileName() == m_Parent->m_PrjFileName )
|
|
return;
|
|
|
|
wxTreeItemId id = m_TreeProject->GetSelection();
|
|
|
|
wxImage img = m_TreeProject->GetImageList()->GetBitmap( data->GetType() -
|
|
1 ).ConvertToImage();
|
|
m_DragCursor = wxCursor( img );
|
|
m_Parent->wxWindow::SetCursor( (wxCursor &)m_DragCursor );
|
|
event.Allow();
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnDragEnd( wxTreeEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
m_Parent->SetCursor( wxNullCursor );
|
|
|
|
wxTreeItemId moved = m_TreeProject->GetSelection();
|
|
TreePrjItemData* source_data = GetSelectedData();
|
|
wxTreeItemId dest = event.GetItem();
|
|
if( !dest.IsOk() )
|
|
return; // Cancelled ...
|
|
TreePrjItemData* destData = dynamic_cast<TreePrjItemData*>( m_TreeProject->GetItemData( dest ) );
|
|
if( !destData )
|
|
return;
|
|
|
|
// the item can be a member of the selected directory; get the directory itself
|
|
if( TREE_DIRECTORY != destData->GetType() && !m_TreeProject->ItemHasChildren( dest ) )
|
|
{ // the item is a member of the selected directory; get the directory itself
|
|
dest = m_TreeProject->GetItemParent( dest );
|
|
if( !dest.IsOk() )
|
|
return; // no parent ?
|
|
|
|
// Select the right destData:
|
|
destData = dynamic_cast<TreePrjItemData*>( m_TreeProject->GetItemData( dest ) );
|
|
if( !destData )
|
|
return;
|
|
}
|
|
|
|
source_data->Move( destData );
|
|
|
|
#if 0
|
|
/* Sort filenames by alphabetic order */
|
|
m_TreeProject->SortChildren( dest );
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::ClearFilters()
|
|
/*****************************************************************************/
|
|
{
|
|
m_Filters.clear();
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#ifdef KICAD_PYTHON
|
|
|
|
|
|
|
|
/**
|
|
* @brief Return the data corresponding to the file, or NULL
|
|
*/
|
|
/*****************************************************************************/
|
|
TreePrjItemData* WinEDA_PrjFrame::FindItemData(const boost::python::str& name)
|
|
/*****************************************************************************/
|
|
{
|
|
// (Interative tree parsing)
|
|
std::vector< wxTreeItemId > roots1, roots2;
|
|
std::vector< wxTreeItemId > * root, * reserve;
|
|
wxString filename = PyHandler::MakeStr( name );
|
|
|
|
root = &roots1;
|
|
reserve = &roots2;
|
|
|
|
root->push_back( m_TreeProject->GetRootItem() );
|
|
|
|
// if we look for the root, return it ...
|
|
TreePrjItemData* data = dynamic_cast< TreePrjItemData*>(
|
|
m_TreeProject->GetItemData( root->at( 0 ) ) );
|
|
|
|
if( data->GetFileName() == filename )
|
|
return data;
|
|
|
|
// Then find in its child
|
|
while( root->size() )
|
|
{
|
|
// look in all roots
|
|
for( unsigned int i = 0; i < root->size(); i++ )
|
|
{
|
|
wxTreeItemId id = root->at( i );
|
|
|
|
// for each root check any child:
|
|
void* cookie = NULL;
|
|
wxTreeItemId child = m_TreeProject->GetFirstChild( id, cookie );
|
|
|
|
while( child.IsOk() )
|
|
{
|
|
TreePrjItemData* data = dynamic_cast< TreePrjItemData*>(
|
|
m_TreeProject->GetItemData( child ) );
|
|
|
|
if( data )
|
|
{
|
|
if( data->GetFileName() == filename )
|
|
return data;
|
|
if( m_TreeProject->ItemHasChildren( child ) )
|
|
reserve->push_back( child );
|
|
}
|
|
child = m_TreeProject->GetNextSibling( child );
|
|
}
|
|
}
|
|
|
|
// Swap the roots
|
|
root->clear();
|
|
std::vector< wxTreeItemId > * tmp;
|
|
tmp = root;
|
|
root = reserve;
|
|
reserve = tmp;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::RemoveFilterPy(const boost::python::str& filter)
|
|
/*****************************************************************************/
|
|
{
|
|
RemoveFilter( PyHandler::MakeStr( filter ) );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::AddFilter( const boost::python::str& filter )
|
|
/*****************************************************************************/
|
|
{
|
|
wxRegEx reg;
|
|
wxString text = PyHandler::MakeStr( filter );
|
|
|
|
if( !reg.Compile( text ) )
|
|
return;
|
|
m_Filters.push_back( text );
|
|
}
|
|
|
|
#endif /* KICAD_PYTHON */
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
const std::vector<wxString>& WinEDA_PrjFrame::GetFilters()
|
|
/*****************************************************************************/
|
|
{
|
|
return m_Filters;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
wxMenu* WinEDA_PrjFrame::GetContextMenu( int type )
|
|
/*****************************************************************************/
|
|
{
|
|
return m_ContextMenus[type];
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnNewDirectory( wxCommandEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
NewFile( TREE_DIRECTORY );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnNewFile( wxCommandEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
NewFile( TREE_UNKNOWN );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnNewPyFile( wxCommandEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
NewFile( TREE_PY );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnNewTxtFile( wxCommandEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
NewFile( TREE_TXT );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::NewFile( TreeFileType type )
|
|
/*****************************************************************************/
|
|
{
|
|
wxString filename;
|
|
wxString mask = GetFileExt( type );
|
|
const wxString sep = wxFileName().GetPathSeparator();
|
|
|
|
// Get the directory:
|
|
wxString dir;
|
|
|
|
TreePrjItemData* treeData;
|
|
wxString FullFileName;
|
|
|
|
|
|
treeData = GetSelectedData();
|
|
if( !treeData )
|
|
return;
|
|
|
|
dir = treeData->GetDir();
|
|
|
|
// Ask for the new file name
|
|
filename = EDA_FileSelector( TREE_DIRECTORY !=
|
|
type ? _( "Create New File:" ) : _( "Create New Directory" ),
|
|
wxGetCwd() + sep + dir, /* Chemin par defaut */
|
|
_( "noname" ) + mask, /* nom fichier par defaut */
|
|
mask, /* extension par defaut */
|
|
mask, /* Masque d'affichage */
|
|
this,
|
|
wxFD_SAVE | wxFD_OVERWRITE_PROMPT,
|
|
TRUE
|
|
);
|
|
if( filename.IsEmpty() )
|
|
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();
|
|
}
|
|
|
|
NewFile( filename, type, root );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::NewFile( const wxString& name,
|
|
TreeFileType type,
|
|
wxTreeItemId& root )
|
|
/*****************************************************************************/
|
|
{
|
|
if( TREE_DIRECTORY != type )
|
|
{
|
|
wxFile( name, wxFile::write );
|
|
|
|
#ifdef KICAD_PYTHON
|
|
PyHandler::GetInstance()->TriggerEvent( wxT( "kicad::NewFile" ),
|
|
PyHandler::Convert( name ) );
|
|
#endif /* KICAD_PYTHON */
|
|
}
|
|
else
|
|
{
|
|
wxMkdir( name );
|
|
|
|
#ifdef KICAD_PYTHON
|
|
PyHandler::GetInstance()->TriggerEvent( wxT( "kicad::NewDirectory" ),
|
|
PyHandler::Convert( name ) );
|
|
#endif /* KICAD_PYTHON */
|
|
}
|
|
|
|
AddFile( name, root );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
wxString WinEDA_PrjFrame::GetFileExt( TreeFileType type )
|
|
/*****************************************************************************/
|
|
{
|
|
wxString ext;
|
|
|
|
switch( type )
|
|
{
|
|
case 0: // 0 is not used
|
|
break;
|
|
|
|
case TREE_PROJECT:
|
|
ext = wxT( ".pro" );
|
|
break;
|
|
|
|
case TREE_SCHEMA:
|
|
ext = g_SchExtBuffer;
|
|
break;
|
|
|
|
case TREE_PCB:
|
|
ext = g_BoardExtBuffer;
|
|
break;
|
|
|
|
case TREE_PY:
|
|
ext = wxT( ".py" );
|
|
break;
|
|
|
|
case TREE_GERBER:
|
|
ext = g_GerberExtBuffer;
|
|
break;
|
|
|
|
case TREE_PDF:
|
|
ext = wxT( ".pdf" );
|
|
break;
|
|
|
|
case TREE_TXT:
|
|
ext = wxT( ".txt" );
|
|
break;
|
|
|
|
case TREE_NET:
|
|
ext = wxT( ".net" );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ext;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief Add filename "name" to the tree \n
|
|
* if name is a directory, add the sub directory file names
|
|
* @return TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
bool WinEDA_PrjFrame::AddFile( const wxString& name, wxTreeItemId& root )
|
|
/*****************************************************************************/
|
|
{
|
|
wxTreeItemId cellule;
|
|
|
|
// Check the file type
|
|
TreeFileType type = TREE_UNKNOWN;
|
|
|
|
if( wxDirExists( name ) )
|
|
{
|
|
type = TREE_DIRECTORY;
|
|
}
|
|
else
|
|
{
|
|
// Filter
|
|
wxRegEx reg;
|
|
|
|
bool isSchematic=false;
|
|
bool addFile=false;
|
|
for( unsigned i=0; i < m_Filters.size(); i++ )
|
|
{
|
|
reg.Compile( m_Filters[i], wxRE_ICASE );
|
|
if( reg.Matches( name ) )
|
|
{
|
|
addFile=true;
|
|
if( i==0 )
|
|
isSchematic = true;
|
|
}
|
|
}
|
|
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 "
|
|
if( isSchematic )
|
|
{
|
|
char line[128]; // small because we just need a few bytes from the start of a line
|
|
FILE* fp;
|
|
|
|
wxString FullFileName = name;
|
|
|
|
fp = wxFopen( FullFileName, wxT( "rt" ) );
|
|
if( fp == NULL )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
addFile = false;
|
|
for( int i=0; i<20; ++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( name ) )
|
|
{
|
|
type = (TreeFileType) i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//also check to see if it is already there.
|
|
wxTreeItemIdValue cookie;
|
|
wxTreeItemId kid = m_TreeProject->GetFirstChild(root, cookie);
|
|
while(kid.IsOk())
|
|
{
|
|
TreePrjItemData* itemData = (TreePrjItemData*)
|
|
m_TreeProject->GetItemData(kid);
|
|
if( itemData ){
|
|
if( itemData->m_FileName == name ){
|
|
return true; //well, we would have added it, but it is already here!
|
|
}
|
|
}
|
|
kid = m_TreeProject->GetNextChild(root, cookie);
|
|
}
|
|
|
|
// Append the item (only appending the filename not the full path):
|
|
wxString file = wxFileNameFromPath( name );
|
|
cellule = m_TreeProject->AppendItem( root, file );
|
|
TreePrjItemData* data = new TreePrjItemData( type, name, m_TreeProject );
|
|
|
|
m_TreeProject->SetItemFont( cellule, *g_StdFont );
|
|
m_TreeProject->SetItemData( cellule, data );
|
|
data->SetState( 0 );
|
|
|
|
/* Mark root files (files which have the same name as the project) */
|
|
wxFileName project( m_Parent->m_PrjFileName );
|
|
wxFileName currfile( file );
|
|
|
|
if( currfile.GetName().CmpNoCase( project.GetName() ) == 0 )
|
|
data->m_IsRootFile = true;
|
|
else
|
|
data->m_IsRootFile = false;
|
|
|
|
|
|
#ifdef KICAD_PYTHON
|
|
PyHandler::GetInstance()->TriggerEvent( wxT( "kicad::TreeAddFile" ),
|
|
PyHandler::Convert( name ) );
|
|
#endif /* KICAD_YTHON */
|
|
|
|
|
|
// When enabled This section adds dirs and files found in the subdirs
|
|
// in this case AddFile is recursive.
|
|
#ifdef ADD_FILES_IN_SUBDIRS
|
|
if( TREE_DIRECTORY == type )
|
|
{
|
|
const wxString sep = wxFileName().GetPathSeparator();
|
|
wxDir dir( name );
|
|
wxString dir_filename;
|
|
|
|
if( dir.GetFirst( &dir_filename ) )
|
|
{
|
|
do
|
|
{
|
|
AddFile( name + sep + dir_filename, cellule );
|
|
}
|
|
while( dir.GetNext( &dir_filename ) );
|
|
}
|
|
|
|
/* Sort filenames by alphabetic order */
|
|
m_TreeProject->SortChildren( cellule );
|
|
}
|
|
#endif /* ADD_FILES_IN_SUBDIRS */
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief Create or modify the tree showing project file names
|
|
* @return TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::ReCreateTreePrj()
|
|
/*****************************************************************************/
|
|
{
|
|
wxTreeItemId rootcellule;
|
|
wxString Text;
|
|
bool prjOpened = false;
|
|
|
|
if( !m_TreeProject )
|
|
m_TreeProject = new WinEDA_TreePrj( this );
|
|
else
|
|
m_TreeProject->DeleteAllItems();
|
|
|
|
m_TreeProject->SetFont( *g_StdFont );
|
|
|
|
if( m_Parent->m_PrjFileName.IsEmpty() )
|
|
Text = wxT( "noname" );
|
|
else
|
|
Text = wxFileNameFromPath( m_Parent->m_PrjFileName );
|
|
|
|
prjOpened = wxFileExists( Text );
|
|
|
|
// root tree:
|
|
m_root = rootcellule = m_TreeProject->AddRoot( Text, TREE_PROJECT - 1, TREE_PROJECT - 1 );
|
|
|
|
m_TreeProject->SetItemBold( rootcellule, TRUE );
|
|
|
|
m_TreeProject->SetItemData( rootcellule,
|
|
new TreePrjItemData( TREE_PROJECT, wxEmptyString, m_TreeProject ) );
|
|
|
|
m_TreeProject->SetItemFont( rootcellule, *g_StdFont );
|
|
|
|
ChangeFileNameExt( Text, wxEmptyString );
|
|
|
|
// Add at least a .sch / .brd if not existing:
|
|
if( !wxFileExists( Text + g_SchExtBuffer ) )
|
|
AddFile( Text + g_SchExtBuffer, m_root );
|
|
|
|
if( !wxFileExists( Text + g_BoardExtBuffer ) )
|
|
AddFile( Text + g_BoardExtBuffer, m_root );
|
|
|
|
// Now adding all current files if available
|
|
if( prjOpened )
|
|
{
|
|
wxDir dir( wxGetCwd() );
|
|
wxString dir_str = dir.GetName();
|
|
wxString sep = wxFileName().GetPathSeparator();
|
|
wxString filename;
|
|
|
|
if( dir.GetFirst( &filename ) )
|
|
{
|
|
do
|
|
{
|
|
if( filename == Text + wxT( ".pro" ) )
|
|
continue;
|
|
|
|
AddFile(dir_str + sep + filename, m_root );
|
|
|
|
} while( dir.GetNext( &filename ) );
|
|
}
|
|
}
|
|
|
|
m_TreeProject->Expand( rootcellule );
|
|
|
|
/* Sort filenames by alphabetic order */
|
|
m_TreeProject->SortChildren( m_root );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief Opens *popup* the context menu
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnRight( wxTreeEvent& Event )
|
|
/*****************************************************************************/
|
|
{
|
|
int tree_id;
|
|
TreePrjItemData* 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 );
|
|
|
|
// Delete and recreate the context menu
|
|
delete( m_PopupMenu );
|
|
m_PopupMenu = new wxMenu();
|
|
|
|
// Get the current filename:
|
|
tree_data = GetSelectedData();
|
|
if( !tree_data )
|
|
return;
|
|
|
|
tree_id = tree_data->GetType();
|
|
FullFileName = tree_data->GetFileName();
|
|
|
|
// copy menu contents in order of the next array:
|
|
wxMenu* menus[] =
|
|
{
|
|
GetContextMenu( tree_id ),
|
|
const_cast<wxMenu*>( tree_data->GetMenu() )
|
|
};
|
|
|
|
for( unsigned int j=0; j < sizeof(menus)/sizeof(wxMenu*); j++ )
|
|
{
|
|
wxMenu* menu = menus[j];
|
|
if( !menu )
|
|
continue;
|
|
|
|
wxMenuItemList list = menu->GetMenuItems();
|
|
|
|
for( unsigned int i = 0; i < list.GetCount(); i++ )
|
|
{
|
|
// Grrrr! wxMenu does not have any copy constructor !! (do it by hand)
|
|
wxMenuItem* src = list[i];
|
|
wxString label = src->GetText();
|
|
|
|
// for obscure reasons, the & is translated into _ ... so replace it
|
|
label.Replace( wxT( "_" ), wxT( "&" ), true );
|
|
wxMenuItem* item = new wxMenuItem( m_PopupMenu, src->GetId(),
|
|
label, src->GetHelp(), src->GetKind() );
|
|
|
|
item->SetBitmap( src->GetBitmap() );
|
|
m_PopupMenu->Append( item );
|
|
}
|
|
}
|
|
|
|
// At last, call python to let python add menu items "on the fly"
|
|
|
|
|
|
#ifdef KICAD_PYTHON
|
|
PyHandler::GetInstance()->TriggerEvent( wxT( "kicad::TreeContextMenu" ),
|
|
PyHandler::Convert( FullFileName ) );
|
|
#endif /* KICAD_PYTHON */
|
|
|
|
|
|
if( m_PopupMenu )
|
|
PopupMenu( m_PopupMenu );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnTxtEdit( wxCommandEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
TreePrjItemData* tree_data = GetSelectedData();
|
|
|
|
if( !tree_data )
|
|
return;
|
|
|
|
wxString FullFileName = tree_data->GetFileName();
|
|
AddDelimiterString( FullFileName );
|
|
wxString editorname = GetEditorName();
|
|
|
|
if( !editorname.IsEmpty() )
|
|
{
|
|
|
|
#ifdef KICAD_PYTHON
|
|
PyHandler::GetInstance()->TriggerEvent( wxT( "kicad::EditScript" ),
|
|
PyHandler::Convert( FullFileName ) );
|
|
#endif
|
|
|
|
ExecuteFile( this, editorname, FullFileName );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnDeleteFile( wxCommandEvent& )
|
|
/*****************************************************************************/
|
|
{
|
|
TreePrjItemData* tree_data = GetSelectedData();
|
|
|
|
if( !tree_data )
|
|
return;
|
|
tree_data->Delete();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnRenameFile( wxCommandEvent& )
|
|
/*****************************************************************************/
|
|
{
|
|
wxTreeItemId curr_item = m_TreeProject->GetSelection();
|
|
TreePrjItemData* tree_data = GetSelectedData();
|
|
|
|
if( !tree_data )
|
|
return;
|
|
|
|
wxString buffer = m_TreeProject->GetItemText( curr_item );
|
|
wxString msg = _( "Change filename: " ) + tree_data->m_FileName;
|
|
|
|
if( Get_Message(msg, _("Change filename"), buffer, this ) != 0 )
|
|
return; //Abort command
|
|
|
|
if( tree_data->Rename( buffer, true ) )
|
|
m_TreeProject->SetItemText( curr_item, buffer );
|
|
}
|
|
|
|
|
|
|
|
#ifdef KICAD_PYTHON
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnRunPy( wxCommandEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
TreePrjItemData* tree_data = GetSelectedData();
|
|
|
|
if( !tree_data )
|
|
return;
|
|
|
|
wxString FullFileName = tree_data->GetFileName();
|
|
PyHandler::GetInstance()->TriggerEvent( wxT( "kicad::RunScript" ),
|
|
PyHandler::Convert( FullFileName ) );
|
|
PyHandler::GetInstance()->RunScript( FullFileName );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief Add a state to the image list
|
|
*/
|
|
/*****************************************************************************/
|
|
int WinEDA_PrjFrame::AddStatePy( boost::python::object& bitmap )
|
|
/*****************************************************************************/
|
|
{
|
|
wxBitmap* image;
|
|
bool success = wxPyConvertSwigPtr( bitmap.ptr(),
|
|
(void**) &image, _T( "wxBitmap" ) );
|
|
|
|
if( !success )
|
|
return -1;
|
|
|
|
wxImageList* list = m_TreeProject->GetImageList();
|
|
int ret = list->GetImageCount() / ( TREE_MAX - 2 );
|
|
|
|
for( int i = 0; i < TREE_MAX - 1; i++ )
|
|
{
|
|
wxBitmap composed( list->GetBitmap ( i ) );
|
|
|
|
wxMemoryDC dc;
|
|
dc.SelectObject( composed );
|
|
dc.DrawBitmap( *image, 0, 0, true );
|
|
list->Add( composed );
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif /* KICAD_PYTHON */
|
|
|
|
|
|
|
|
/**
|
|
* @brief Prevent the main project to be renamed
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnRenameAsk( wxTreeEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
TreePrjItemData* tree_data = GetSelectedData();
|
|
|
|
if( !tree_data )
|
|
return;
|
|
if( m_Parent->m_PrjFileName == tree_data->GetFileName() )
|
|
event.Veto();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief Rename a tree item on demand of the context menu
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnRename( wxTreeEvent& event )
|
|
/*****************************************************************************/
|
|
{
|
|
TreePrjItemData* tree_data = GetSelectedData();
|
|
|
|
if( !tree_data )
|
|
return;
|
|
|
|
tree_data->OnRename( event );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief TODO
|
|
*/
|
|
/*****************************************************************************/
|
|
void WinEDA_PrjFrame::OnSelect( wxTreeEvent& Event )
|
|
/*****************************************************************************/
|
|
{
|
|
wxString FullFileName;
|
|
|
|
TreePrjItemData* tree_data = GetSelectedData();
|
|
|
|
if( !tree_data )
|
|
return;
|
|
tree_data->Activate(this);
|
|
}
|