342 lines
12 KiB
C++
342 lines
12 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2012 Jean-Pierre Charras, jean-pierre.charras@ujf-grenoble.fr
|
|
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
|
* Copyright (C) 1992-2012 KiCad Developers, see AUTHORS.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
|
|
*/
|
|
|
|
/**
|
|
* @file pcbnew.cpp
|
|
* @brief Pcbnew main program.
|
|
*/
|
|
|
|
#ifdef KICAD_SCRIPTING
|
|
#include <python_scripting.h>
|
|
#include <pcbnew_scripting_helpers.h>
|
|
#endif
|
|
#include <fctsys.h>
|
|
#include <appl_wxstruct.h>
|
|
#include <confirm.h>
|
|
#include <macros.h>
|
|
#include <class_drawpanel.h>
|
|
#include <wxPcbStruct.h>
|
|
#include <eda_dde.h>
|
|
#include <pcbcommon.h>
|
|
#include <colors_selection.h>
|
|
#include <gr_basic.h>
|
|
|
|
#include <wx/file.h>
|
|
#include <wx/snglinst.h>
|
|
#include <wx/dir.h>
|
|
|
|
#include <pcbnew.h>
|
|
#include <protos.h>
|
|
#include <hotkeys.h>
|
|
#include <wildcards_and_files_ext.h>
|
|
#include <class_board.h>
|
|
|
|
|
|
// Colors for layers and items
|
|
COLORS_DESIGN_SETTINGS g_ColorsSettings;
|
|
|
|
bool g_Drc_On = true;
|
|
bool g_AutoDeleteOldTrack = true;
|
|
bool g_Show_Module_Ratsnest;
|
|
bool g_Raccord_45_Auto = true;
|
|
bool g_Alternate_Track_Posture = false;
|
|
bool g_Track_45_Only_Allowed = true; // True to allow horiz, vert. and 45deg only tracks
|
|
bool g_Segments_45_Only; // True to allow horiz, vert. and 45deg only graphic segments
|
|
bool g_TwoSegmentTrackBuild = true;
|
|
|
|
LAYER_NUM g_Route_Layer_TOP;
|
|
LAYER_NUM g_Route_Layer_BOTTOM;
|
|
int g_MaxLinksShowed;
|
|
int g_MagneticPadOption = capture_cursor_in_track_tool;
|
|
int g_MagneticTrackOption = capture_cursor_in_track_tool;
|
|
|
|
wxPoint g_Offset_Module; /* Distance to offset module trace when moving. */
|
|
|
|
/* Name of the document footprint list
|
|
* usually located in share/modules/footprints_doc
|
|
* this is of the responsibility to users to create this file
|
|
* if they want to have a list of footprints
|
|
*/
|
|
wxString g_DocModulesFileName = wxT( "footprints_doc/footprints.pdf" );
|
|
|
|
// wxWindow* DoPythonStuff(wxWindow* parent); // declaration
|
|
|
|
IMPLEMENT_APP( EDA_APP )
|
|
|
|
|
|
/* MacOSX: Needed for file association
|
|
* http://wiki.wxwidgets.org/WxMac-specific_topics
|
|
*/
|
|
void EDA_APP::MacOpenFile( const wxString& aFileName )
|
|
{
|
|
PCB_EDIT_FRAME* frame = ( (PCB_EDIT_FRAME*) GetTopWindow() );
|
|
wxFileName filename = aFileName;
|
|
|
|
if( !filename.FileExists() )
|
|
return;
|
|
|
|
frame->LoadOnePcbFile( aFileName, false );
|
|
}
|
|
|
|
|
|
bool EDA_APP::OnInit()
|
|
{
|
|
wxFileName fn;
|
|
PCB_EDIT_FRAME* frame = NULL;
|
|
wxString msg;
|
|
|
|
InitEDA_Appl( wxT( "Pcbnew" ), APP_PCBNEW_T );
|
|
|
|
#ifdef KICAD_SCRIPTING
|
|
msg.Empty();
|
|
#ifdef __WINDOWS__
|
|
// force python environment under Windows:
|
|
const wxString python_us("python27_us");
|
|
|
|
// Build our python path inside kicad
|
|
wxString kipython = m_BinDir + python_us;
|
|
|
|
// If our python install is existing inside kicad, use it
|
|
if( wxDirExists( kipython ) )
|
|
{
|
|
wxString ppath;
|
|
if( !wxGetEnv( wxT( "PYTHONPATH" ), &ppath ) || !ppath.Contains( python_us ) )
|
|
{
|
|
ppath << kipython << wxT("/pylib;");
|
|
ppath << kipython << wxT("/lib;");
|
|
ppath << kipython << wxT("/dll");
|
|
wxSetEnv( wxT( "PYTHONPATH" ), ppath );
|
|
DBG( std::cout << "set PYTHONPATH to " << TO_UTF8(ppath) << "\n"; )
|
|
|
|
// Add python executable path:
|
|
wxGetEnv( wxT( "PATH" ), &ppath );
|
|
if( !ppath.Contains( python_us ) )
|
|
{
|
|
kipython << wxT(";") << ppath;
|
|
wxSetEnv( wxT( "PATH" ), kipython );
|
|
DBG( std::cout << "set PATH to " << TO_UTF8(kipython) << "\n"; )
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: make this path definable by the user, and set more than one path
|
|
// (and remove the fixed paths from <src>/scripting/kicadplugins.i)
|
|
|
|
// wizard plugins are stored in kicad/bin/plugins.
|
|
// so add this path to python scripting defualt search paths
|
|
// which are ( [KICAD_PATH] is an environment variable to define)
|
|
// [KICAD_PATH]/scripting/plugins
|
|
// Add this default search path:
|
|
msg = wxGetApp().GetExecutablePath() + wxT("scripting/plugins");
|
|
#else
|
|
// Add this default search path:
|
|
msg = wxT("/usr/local/kicad/bin/scripting/plugins");
|
|
#endif
|
|
// On linux and osx, 2 others paths are
|
|
// [HOME]/.kicad_plugins/
|
|
// [HOME]/.kicad/scripting/plugins/
|
|
if ( !pcbnewInitPythonScripting( TO_UTF8(msg) ) )
|
|
{
|
|
wxMessageBox( wxT( "pcbnewInitPythonScripting() fails" ) );
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
if( argc > 1 )
|
|
{
|
|
fn = argv[1];
|
|
|
|
// Be sure the filename is absolute, to avoid issues
|
|
// when the filename is relative,
|
|
// for instance when stored in history list without path,
|
|
// and when building the config filename ( which should have a path )
|
|
if( fn.IsRelative() )
|
|
fn.MakeAbsolute();
|
|
|
|
if( fn.GetExt() != PcbFileExtension && fn.GetExt() != LegacyPcbFileExtension )
|
|
{
|
|
msg.Printf( _( "Pcbnew file <%s> has a wrong extension.\n"
|
|
"Changing extension to .%s." ),
|
|
GetChars( fn.GetFullPath() ),
|
|
GetChars( PcbFileExtension ) );
|
|
fn.SetExt( PcbFileExtension );
|
|
wxMessageBox( msg );
|
|
}
|
|
|
|
if( !wxGetApp().LockFile( fn.GetFullPath() ) )
|
|
{
|
|
DisplayError( NULL, _( "This file is already open." ) );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if( m_Checker && m_Checker->IsAnotherRunning() )
|
|
{
|
|
if( !IsOK( NULL, _( "Pcbnew is already running, Continue?" ) ) )
|
|
return false;
|
|
}
|
|
|
|
// read current setup and reopen last directory if no filename to open in command line
|
|
bool reopenLastUsedDirectory = argc == 1;
|
|
GetSettings( reopenLastUsedDirectory );
|
|
|
|
if( fn.IsOk() && fn.DirExists() )
|
|
wxSetWorkingDirectory( fn.GetPath() );
|
|
|
|
g_DrawBgColor = BLACK;
|
|
|
|
/* Must be called before creating the main frame in order to
|
|
* display the real hotkeys in menus or tool tips */
|
|
ReadHotkeyConfig( wxT( "PcbFrame" ), g_Board_Editor_Hokeys_Descr );
|
|
|
|
// Set any environment variables before loading FP_LIB_TABLE
|
|
SetFootprintLibTablePath();
|
|
|
|
frame = new PCB_EDIT_FRAME( NULL, wxT( "Pcbnew" ), wxPoint( 0, 0 ), wxSize( 600, 400 ) );
|
|
|
|
#ifdef KICAD_SCRIPTING
|
|
ScriptingSetPcbEditFrame(frame); /* give the scripting helpers access to our frame */
|
|
#endif
|
|
|
|
frame->UpdateTitle();
|
|
|
|
SetTopWindow( frame );
|
|
frame->Show( true );
|
|
|
|
CreateServer( frame, KICAD_PCB_PORT_SERVICE_NUMBER );
|
|
|
|
frame->Zoom_Automatique( true );
|
|
|
|
// Load config and default values before loading a board file
|
|
// Some will be overwritten after loading the board file
|
|
frame->LoadProjectSettings( fn.GetFullPath() );
|
|
|
|
/* Load file specified in the command line. */
|
|
if( fn.IsOk() )
|
|
{
|
|
/* Note the first time Pcbnew is called after creating a new project
|
|
* the board file may not exist so we load settings only.
|
|
* However, because legacy board files are named *.brd,
|
|
* and new files are named *.kicad_pcb,
|
|
* for all previous projects ( before 2012, december 14 ),
|
|
* because KiCad manager ask to load a .kicad_pcb file
|
|
* if this file does not exist, it is certainly useful
|
|
* to test if a legacy file is existing,
|
|
* under the same name, and therefore if the user want to load it
|
|
*/
|
|
bool file_exists = false;
|
|
|
|
if( fn.FileExists() )
|
|
{
|
|
file_exists = true;
|
|
frame->LoadOnePcbFile( fn.GetFullPath() );
|
|
}
|
|
else if( fn.GetExt() == KiCadPcbFileExtension )
|
|
{
|
|
// Try to find a legacy file with the same name:
|
|
wxFileName fn_legacy = fn;
|
|
fn_legacy.SetExt( LegacyPcbFileExtension );
|
|
|
|
if( fn_legacy.FileExists() )
|
|
{
|
|
msg.Printf( _( "File <%s> does not exist.\n"
|
|
"However a legacy file <%s> exists.\n"
|
|
"Do you want to load it?\n"
|
|
"It will be saved under the new file format." ),
|
|
GetChars( fn.GetFullPath() ),
|
|
GetChars( fn_legacy.GetFullPath() ) );
|
|
|
|
if( IsOK( frame, msg ) )
|
|
{
|
|
file_exists = true;
|
|
frame->LoadOnePcbFile( fn_legacy.GetFullPath() );
|
|
wxString filename = fn.GetFullPath();
|
|
filename.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
|
|
frame->GetBoard()->SetFileName( filename );
|
|
frame->UpdateTitle();
|
|
frame->OnModify(); // Ready to save the board under the new format
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ! file_exists )
|
|
{
|
|
// File does not exists: prepare an empty board
|
|
if( ! fn.GetPath().IsEmpty() )
|
|
wxSetWorkingDirectory( fn.GetPath() );
|
|
|
|
frame->GetBoard()->SetFileName( fn.GetFullPath( wxPATH_UNIX ) );
|
|
frame->UpdateTitle();
|
|
frame->UpdateFileHistory( frame->GetBoard()->GetFileName() );
|
|
frame->OnModify(); // Ready to save the new empty board
|
|
|
|
msg.Printf( _( "File <%s> does not exist.\nThis is normal for a new project" ),
|
|
GetChars( frame->GetBoard()->GetFileName() ) );
|
|
wxMessageBox( msg );
|
|
}
|
|
}
|
|
|
|
else
|
|
// No file to open: initialize a new empty board
|
|
// using default values for design settings:
|
|
frame->Clear_Pcb( false );
|
|
|
|
// update the layer names in the listbox
|
|
frame->ReCreateLayerBox( false );
|
|
|
|
/* For an obscure reason the focus is lost after loading a board file
|
|
* when starting (i.e. only at this point)
|
|
* (seems due to the recreation of the layer manager after loading the file)
|
|
* give focus to main window and Drawpanel
|
|
* must be done for these 2 windows (for an obscure reason ...)
|
|
* Linux specific
|
|
* This is more a workaround than a fix.
|
|
*/
|
|
frame->SetFocus();
|
|
frame->GetCanvas()->SetFocus();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
#if 0
|
|
// for some reason KiCad classes do not implement OnExit
|
|
// if I add it in the declaration, I need to fix it in every application
|
|
// so for now make a note TODO TODO
|
|
// we need to clean up python when the application exits
|
|
int EDA_APP::OnExit()
|
|
{
|
|
// Restore the thread state and tell Python to cleanup after itself.
|
|
// wxPython will do its own cleanup as part of that process. This is done
|
|
// in OnExit instead of ~MyApp because OnExit is only called if OnInit is
|
|
// successful.
|
|
#if KICAD_SCRIPTING_WXPYTHON
|
|
pcbnewFinishPythonScripting();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#endif
|