// constructor supports creation of wxFileConfig objects of any type
wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
const wxString& strLocal, const wxString& strGlobal,
long style)
: wxConfigBase(::GetAppName(appName), vendorName,
strLocal, strGlobal,
style),
m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
{
// Make up names for files if empty
if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
{
m_strLocalFile = GetLocalFileName(GetAppName());
}
if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
{
m_strGlobalFile = GetGlobalFileName(GetAppName());
}
// Check if styles are not supplied, but filenames are, in which case
// add the correct styles.
if ( !m_strLocalFile.IsEmpty() )
SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
if ( !m_strGlobalFile.IsEmpty() )
SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
// if the path is not absolute, prepend the standard directory to it
// UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
{
if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
{
wxString strLocal = m_strLocalFile;
m_strLocalFile = GetLocalDir();
m_strLocalFile << strLocal;
}
if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
{
wxString strGlobal = m_strGlobalFile;
m_strGlobalFile = GetGlobalDir();
m_strGlobalFile << strGlobal;
}
}
SetUmask(-1);
Init();
}
// Read $HOME for what it says is home, if not
// read $USER or $LOGNAME for user name else determine
// the Real User, then determine the Real home dir.
static char * GetIniFile (char *dest, const char *filename)
{
char *home = NULL;
if (filename && wxIsAbsolutePath(filename))
{
strcpy(dest, filename);
}
else if ((home = wxGetUserHome("")) != NULL)
{
strcpy(dest, home);
if (dest[strlen(dest) - 1] != '/')
strcat (dest, "/");
if (filename == NULL)
{
if ((filename = getenv ("XENVIRONMENT")) == NULL)
filename = ".Xdefaults";
}
else if (*filename != '.')
strcat (dest, ".");
strcat (dest, filename);
} else
{
dest[0] = '\0';
}
return dest;
}
wxString wxHtmlBookRecord::GetFullPath(const wxString &page) const
{
if (wxIsAbsolutePath(page) || page.Find(wxT("file:")) == 0)
return page;
else
return m_BasePath + page;
}
/////////////////////////////
// Gets and stores full path
void AegisubApp::GetFullPath(wxString arg) {
if (wxIsAbsolutePath(arg)) {
fullPath = arg;
return;
}
// Is it a relative path?
wxString currentDir(wxFileName::GetCwd());
if (currentDir.Last() != wxFILE_SEP_PATH) currentDir += wxFILE_SEP_PATH;
wxString str = currentDir + arg;
if (wxFileExists(str)) {
fullPath = str;
return;
}
// OK, it's neither an absolute path nor a relative path.
// Search PATH.
wxPathList pathList;
pathList.AddEnvList(_T("PATH"));
str = pathList.FindAbsoluteValidPath(arg);
if (!str.IsEmpty()) {
fullPath = str;
return;
}
fullPath = _T("");
return;
}
wxString wxHtmlBookRecord::GetFullPath(const wxString &page) const
{
if (wxIsAbsolutePath(page))
return page;
else
return m_BasePath + page;
}
// find all files mentioned in structure, e.g. <bitmap>filename</bitmap>
void wxcXmlResourceCmp::FindFilesInXML(wxXmlNode* node, wxArrayString& flist, const wxString& inputPath)
{
// Is 'node' XML node element?
if(node == NULL) return;
if(node->GetType() != wxXML_ELEMENT_NODE) return;
bool containsFilename = NodeContainsFilename(node);
wxXmlNode* n = node->GetChildren();
while(n) {
if(containsFilename && (n->GetType() == wxXML_TEXT_NODE || n->GetType() == wxXML_CDATA_SECTION_NODE)) {
wxString fullname;
if(wxIsAbsolutePath(n->GetContent()) || inputPath.empty())
fullname = n->GetContent();
else
fullname = inputPath + wxFILE_SEP_PATH + n->GetContent();
wxString filename = GetInternalFileName(n->GetContent(), flist);
n->SetContent(filename);
if(flist.Index(filename) == wxNOT_FOUND) flist.Add(filename);
wxFileInputStream sin(fullname);
wxFileOutputStream sout(m_outputPath + wxFILE_SEP_PATH + filename);
sin.Read(sout); // copy the stream
}
// subnodes:
if(n->GetType() == wxXML_ELEMENT_NODE) FindFilesInXML(n, flist, inputPath);
n = n->GetNext();
}
}
//---------------------------------------------------------
wxString Get_FilePath_Absolute(const wxChar *Directory, const wxChar *FileName)
{
if( wxIsAbsolutePath(FileName) )
{
return( FileName );
}
return( wxString::Format(wxT("%s%s"), Directory, FileName) );
// return( SG_File_Make_Path(Directory, FileName, NULL).c_str() );
}
bool
strutil_isabsolutepath(const String &path)
{
#ifdef OS_UNIX
return !strutil_isempty(path) && (path[(size_t)0] == DIR_SEPARATOR ||
path[(size_t)0] == '~');
#elif defined ( OS_WIN )
// TODO copy the code from wxIsAbsolutePath() here if Karsten insists on it
return wxIsAbsolutePath(path);
#endif
}
void wxHtmlHelpController::SetTempDir(const wxString& path)
{
if (path == wxEmptyString) m_TempPath = path;
else {
if (wxIsAbsolutePath(path)) m_TempPath = path;
else m_TempPath = wxGetCwd() + "/" + path;
if (m_TempPath[m_TempPath.Length() - 1] != '/')
m_TempPath << "/";
}
}
// 'Main program' equivalent: the program execution "starts" here
bool MyApp::OnInit()
{
wxString lattestartxrcloc;
setlocale( LC_ALL, "en_US" );
wxImage::AddHandler( new wxXPMHandler );
wxXmlResource::Get() ->InitAllHandlers();
wxString loca = argv[0];
if (wxIsAbsolutePath(loca))
wxSetWorkingDirectory(wxPathOnly(loca));
else
{
loca.Prepend(wxGetCwd());
wxSetWorkingDirectory(wxPathOnly(loca));
}
lattestartxrcloc = loca+wxT(".xrc");
//cout << lattestartxrcloc.ToAscii() << endl;
if ( !wxFileExists(lattestartxrcloc) )
{
wxPathList loc;
loc.AddEnvList( wxT( "PATH" ) );
lattestartxrcloc = loc.FindAbsoluteValidPath( wxT( "lattestart.xrc" ) );
if ( lattestartxrcloc == wxEmptyString )
{
cout << "lattestart.xrc not found!" << endl;
exit(1);
}
}
//dialogs
wxXmlResource::Get() ->Load( lattestartxrcloc );
//frame
//wxXmlResource::Get()->Load(wxT("frame.xrc"));
wxToolTip::Enable( 1 );
MyFrame *frame = new MyFrame();
// Show the frame.
frame->Show( true );
// Return true to tell program to continue (false would terminate).
return true;
}
void SetUpWorkingDirectories(const char* argv0)
{
// set up working directories
workingDir = wxGetCwd().c_str();
#ifdef __WXGTK__
if (getenv("CN3D_HOME") != NULL)
programDir = getenv("CN3D_HOME");
else
#endif
if (wxIsAbsolutePath(argv0))
programDir = wxPathOnly(argv0).c_str();
else if (wxPathOnly(argv0) == "")
programDir = workingDir;
else
programDir = workingDir + wxFILE_SEP_PATH + wxPathOnly(argv0).c_str();
workingDir = workingDir + wxFILE_SEP_PATH;
programDir = programDir + wxFILE_SEP_PATH;
// find or create preferences folder
wxString localDir;
wxSplitPath((wxFileConfig::GetLocalFileName("unused")).c_str(), &localDir, NULL, NULL);
wxString prefsDirLocal = localDir + wxFILE_SEP_PATH + "Cn3D_User";
wxString prefsDirProg = wxString(programDir.c_str()) + wxFILE_SEP_PATH + "Cn3D_User";
if (wxDirExists(prefsDirLocal))
prefsDir = prefsDirLocal.c_str();
else if (wxDirExists(prefsDirProg))
prefsDir = prefsDirProg.c_str();
else {
// try to create the folder
if (wxMkdir(prefsDirLocal) && wxDirExists(prefsDirLocal))
prefsDir = prefsDirLocal.c_str();
else if (wxMkdir(prefsDirProg) && wxDirExists(prefsDirProg))
prefsDir = prefsDirProg.c_str();
}
if (prefsDir.size() == 0)
WARNINGMSG("Can't create Cn3D_User folder at either:"
<< "\n " << prefsDirLocal
<< "\nor " << prefsDirProg);
else
prefsDir += wxFILE_SEP_PATH;
// set data dir, and register the path in C toolkit registry (mainly for BLAST code)
#ifdef __WXMAC__
dataDir = programDir + "../Resources/data/";
#else
dataDir = programDir + "data" + wxFILE_SEP_PATH;
#endif
TRACEMSG("working dir: " << workingDir.c_str());
TRACEMSG("program dir: " << programDir.c_str());
TRACEMSG("data dir: " << dataDir.c_str());
TRACEMSG("prefs dir: " << prefsDir.c_str());
}
void wxHtmlHelpData::SetTempDir(const wxString& path)
{
if (path.empty())
m_tempPath = path;
else
{
if (wxIsAbsolutePath(path)) m_tempPath = path;
else m_tempPath = wxGetCwd() + wxT("/") + path;
if (m_tempPath[m_tempPath.length() - 1] != wxT('/'))
m_tempPath << wxT('/');
}
}
// ----------------------------------------------------------------------------
wxString MouseSap::FindAppPath(const wxString& argv0, const wxString& cwd, const wxString& appVariableName)
// ----------------------------------------------------------------------------
{
// Find the absolute path where this application has been run from.
// argv0 is wxTheApp->argv[0]
// cwd is the current working directory (at startup)
// appVariableName is the name of a variable containing the directory for this app, e.g.
// MYAPPDIR. This is checked first.
wxString str;
// Try appVariableName
if (!appVariableName.IsEmpty())
{
str = wxGetenv(appVariableName);
if (!str.IsEmpty())
return str;
}
#if defined(__WXMAC__) && !defined(__DARWIN__)
// On Mac, the current directory is the relevant one when
// the application starts.
return cwd;
#endif
if (wxIsAbsolutePath(argv0))
return wxPathOnly(argv0);
else
{
// Is it a relative path?
wxString currentDir(cwd);
if (currentDir.Last() != wxFILE_SEP_PATH)
currentDir += wxFILE_SEP_PATH;
str = currentDir + argv0;
if (wxFileExists(str))
return wxPathOnly(str);
}
// OK, it's neither an absolute path nor a relative path.
// Search PATH.
wxPathList pathList;
pathList.AddEnvList(wxT("PATH"));
str = pathList.FindAbsoluteValidPath(argv0);
if (!str.IsEmpty())
return wxPathOnly(str);
// Failed
return wxEmptyString;
}
// A version of the above but prepending 'cwd' (current path) first
// if 'path' is relative
wxString wxGetRealPath(const wxString& cwd, const wxString& path)
{
wxString path1(path);
if (!wxIsAbsolutePath(path))
{
path1 = cwd;
if (path1.Last() != wxFILE_SEP_PATH)
path1 += wxFILE_SEP_PATH;
path1 += path;
}
return wxGetRealPath(path1);
}
//
// Taken from http://wxwidgets.org/docs/technote/install.htm
//
wxString PlatformCompatibility::GetExecutablePath()
{
static bool found = false;
static wxString path;
if (found)
return path;
else
{
#ifdef __WXMSW__
wxChar buf[512];
*buf = '\0';
GetModuleFileName(NULL, buf, 511);
path = buf;
#elif defined(__WXMAC__)
ProcessInfoRec processinfo;
ProcessSerialNumber procno ;
FSSpec fsSpec;
procno.highLongOfPSN = 0 ;
procno.lowLongOfPSN = kCurrentProcess ;
processinfo.processInfoLength = sizeof(ProcessInfoRec);
processinfo.processName = NULL;
processinfo.processAppSpec = &fsSpec;
GetProcessInformation( &procno , &processinfo ) ;
path = wxMacFSSpec2MacFilename(&fsSpec);
#else
wxString argv0 = wxGetApp().argv[0];
if (wxIsAbsolutePath(argv0))
path = argv0;
else
{
wxPathList pathlist;
pathlist.AddEnvList(wxT("PATH"));
path = pathlist.FindAbsoluteValidPath(argv0);
}
wxFileName filename(path);
filename.Normalize();
path = filename.GetFullPath();
#endif
found = true;
return path;
}
}
wxFileName wxFindAppFullName(const wxString& argv0, const wxString& cwd, const wxString& appVariableName)
{
wxFileName fileName(argv0);
wxString str;
wxString path;
#if defined(__WXMSW__)
if (!fileName.HasExt())
fileName.SetExt(wxT("exe"));
#endif
// Try appVariableName
if (!appVariableName.IsEmpty())
path = wxGetenv(appVariableName);
#if defined(__WXMAC__) && !defined(__DARWIN__)
// On Mac, the current directory is the relevant one when
// the application starts.
if (path.IsEmpty())
path = cwd;
#endif
if (path.IsEmpty())
{
if (wxIsAbsolutePath(fileName.GetFullPath()))
path = fileName.GetFullPath();
else
{
// Is it a relative path?
wxString currentDir(cwd);
if (currentDir.Last() != wxFILE_SEP_PATH)
currentDir += wxFILE_SEP_PATH;
if (wxFileExists(currentDir + fileName.GetFullName()))
path = currentDir;
}
}
if (path.IsEmpty())
{
// OK, it's neither an absolute path nor a relative path.
// Search PATH.
wxPathList pathList;
pathList.AddEnvList(wxT("PATH"));
path = wxFileName(pathList.FindAbsoluteValidPath(fileName.GetFullName())).GetPath();
}
fileName.SetPath(path);
return fileName;
}
wxString wxPathList::FindAbsoluteValidPath (const wxString& file) const
{
wxString f = FindValidPath(file);
if ( f.empty() || wxIsAbsolutePath(f) )
return f;
wxString buf = ::wxGetCwd();
if ( !wxEndsWithPathSeparator(buf) )
{
buf += wxFILE_SEP_PATH;
}
buf += f;
return buf;
}
wxString wxStandardPathsBase::GetExecutablePath() const
{
if ( !wxTheApp || !wxTheApp->argv )
return wxEmptyString;
wxString argv0 = wxTheApp->argv[0];
if (wxIsAbsolutePath(argv0))
return argv0;
// Search PATH.environment variable...
wxPathList pathlist;
pathlist.AddEnvList(wxT("PATH"));
wxString path = pathlist.FindAbsoluteValidPath(argv0);
if ( path.empty() )
return argv0; // better than nothing
wxFileName filename(path);
filename.Normalize();
return filename.GetFullPath();
}
// Must be destroyed
wxChar *wxCopyAbsolutePath(const wxString& filename)
{
if (filename.empty())
return NULL;
if (! wxIsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer, filename)))
{
wxString buf = ::wxGetCwd();
wxChar ch = buf.Last();
#ifdef __WINDOWS__
if (ch != wxT('\\') && ch != wxT('/'))
buf << wxT("\\");
#else
if (ch != wxT('/'))
buf << wxT("/");
#endif
buf << wxFileFunctionsBuffer;
buf = wxRealPath( buf );
return MYcopystring( buf );
}
return MYcopystring( wxFileFunctionsBuffer );
}
wxString wxFindAppPath(const wxString& argv0, const wxString& cwd, const wxString& appVariableName)
{
wxString str;
// Try appVariableName
if (!appVariableName.empty())
{
str = wxGetenv(appVariableName);
if (!str.empty())
return str;
}
if (wxIsAbsolutePath(argv0))
return wxPathOnly(argv0);
else
{
// Is it a relative path?
wxString currentDir(cwd);
if (!wxEndsWithPathSeparator(currentDir))
currentDir += wxFILE_SEP_PATH;
str = currentDir + argv0;
if ( wxFile::Exists(str) )
return wxPathOnly(str);
}
// OK, it's neither an absolute path nor a relative path.
// Search PATH.
wxPathList pathList;
pathList.AddEnvList(wxT("PATH"));
str = pathList.FindAbsoluteValidPath(argv0);
if (!str.empty())
return wxPathOnly(str);
// Failed
return wxEmptyString;
}
// Converts a plucker: or file: filename to a regular OS filepath
wxString protocol_filename_to_normal_fullname( const wxString &input_filename )
{
wxString prefix_to_strip = wxEmptyString;
wxString output_fullname = input_filename;
bool prepend_plucker_path = FALSE;
// Call our function to find the prefix.
prefix_to_strip = get_protocol_prefix( output_fullname );
// If found one, then remove it, placing rest into output_fullname.
if ( prefix_to_strip != wxEmptyString )
{
output_fullname.StartsWith( prefix_to_strip, &output_fullname );
// If found one of plucker protocols, then tell to prepend full path to pluckerdir
if ( prefix_to_strip.Contains( wxT( "plucker" ) ) )
{
prepend_plucker_path = TRUE;
}
}
// Also prepend plucker path to relative filenames. Using wxIsAbsolutePath() instead
// of checking for a leading '/' as MSW/MAC can start an absolute with a drive.
if ( ! wxIsAbsolutePath( output_fullname ) )
{
prepend_plucker_path = TRUE;
}
// Do the prepend if so requested
if ( prepend_plucker_path )
{
// ?TODO: Should this be the user's pluckerdir on POSIX.
output_fullname = get_plucker_directory( PLUCKERHOME ) + wxT( "/" ) + output_fullname;
}
wxLogDebug( wxT( "Filename via protocol_filename_to_normal_fullname=" ) + output_fullname );
return output_fullname;
}
bool GetAssociatedDocument( wxWindow* aParent,
const wxString& aDocName,
const wxPathList* aPaths)
{
wxString docname, fullfilename;
wxString msg;
wxString command;
bool success = false;
// Is an internet url
static const wxChar* url_header[3] = {
wxT( "http:" ),
wxT( "ftp:" ),
wxT( "www." )
};
for( unsigned ii = 0; ii < DIM(url_header); ii++ )
{
if( aDocName.First( url_header[ii] ) == 0 ) //. seems an internet url
{
wxLaunchDefaultBrowser( aDocName );
return true;
}
}
docname = aDocName;
#ifdef __WINDOWS__
docname.Replace( UNIX_STRING_DIR_SEP, WIN_STRING_DIR_SEP );
#else
docname.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
#endif
/* Compute the full file name */
if( wxIsAbsolutePath( aDocName ) || aPaths == NULL)
fullfilename = aDocName;
/* If the file exists, this is a trivial case: return the filename
* "as this". the name can be an absolute path, or a relative path
* like ./filename or ../<filename>
*/
else if( wxFileName::FileExists( aDocName ) )
fullfilename = aDocName;
else
{
fullfilename = aPaths->FindValidPath( aDocName );
}
wxString mask( wxT( "*" ) ), extension;
#ifdef __WINDOWS__
mask += wxT( ".*" );
extension = wxT( ".*" );
#endif
if( wxIsWild( fullfilename ) )
{
fullfilename = EDA_FILE_SELECTOR( _( "Doc Files" ),
wxPathOnly( fullfilename ),
fullfilename,
extension,
mask,
aParent,
wxFD_OPEN,
true,
wxPoint( -1, -1 ) );
if( fullfilename.IsEmpty() )
return false;
}
if( !wxFileExists( fullfilename ) )
{
msg.Printf( _( "Doc File '%s' not found" ), GetChars( aDocName ) );
DisplayError( aParent, msg );
return false;
}
wxFileName currentFileName( fullfilename );
wxString file_ext = currentFileName.GetExt();
if( file_ext == wxT( "pdf" ) )
{
success = OpenPDF( fullfilename );
return success;
}
/* Try to launch some browser (useful under linux) */
wxFileType* filetype;
wxString type;
filetype = wxTheMimeTypesManager->GetFileTypeFromExtension( file_ext );
if( !filetype ) // 2nd attempt.
{
mimeDatabase = new wxMimeTypesManager;
mimeDatabase->AddFallbacks( EDAfallbacks );
filetype = mimeDatabase->GetFileTypeFromExtension( file_ext );
delete mimeDatabase;
mimeDatabase = NULL;
}
if( filetype )
{
wxFileType::MessageParameters params( fullfilename, type );
success = filetype->GetOpenCommand( &command, params );
delete filetype;
if( success )
success = ProcessExecute( command );
}
if( !success )
{
msg.Printf( _( "Unknown MIME type for doc file <%s>" ), GetChars( fullfilename ) );
DisplayError( aParent, msg );
}
return success;
}
void wxGenericFileDialog::HandleAction( const wxString &fn )
{
if (ignoreChanges)
return;
wxString filename( fn );
wxString dir = m_list->GetDir();
if (filename.empty()) return;
if (filename == wxT(".")) return;
// "some/place/" means they want to chdir not try to load "place"
bool want_dir = filename.Last() == wxFILE_SEP_PATH;
if (want_dir)
filename = filename.RemoveLast();
if (filename == wxT(".."))
{
ignoreChanges = true;
m_list->GoToParentDir();
m_list->SetFocus();
UpdateControls();
ignoreChanges = false;
return;
}
#ifdef __UNIX__
if (filename == wxT("~"))
{
ignoreChanges = true;
m_list->GoToHomeDir();
m_list->SetFocus();
UpdateControls();
ignoreChanges = false;
return;
}
if (filename.BeforeFirst(wxT('/')) == wxT("~"))
{
filename = wxString(wxGetUserHome()) + filename.Remove(0, 1);
}
#endif // __UNIX__
if (!(m_dialogStyle & wxSAVE))
{
if ((filename.Find(wxT('*')) != wxNOT_FOUND) ||
(filename.Find(wxT('?')) != wxNOT_FOUND))
{
if (filename.Find(wxFILE_SEP_PATH) != wxNOT_FOUND)
{
wxMessageBox(_("Illegal file specification."), _("Error"), wxOK | wxICON_ERROR );
return;
}
m_list->SetWild( filename );
return;
}
}
if (!IsTopMostDir(dir))
dir += wxFILE_SEP_PATH;
if (!wxIsAbsolutePath(filename))
{
dir += filename;
filename = dir;
}
if (wxDirExists(filename))
{
ignoreChanges = true;
m_list->GoToDir( filename );
UpdateControls();
ignoreChanges = false;
return;
}
// they really wanted a dir, but it doesn't exist
if (want_dir)
{
wxMessageBox(_("Directory doesn't exist."), _("Error"),
wxOK | wxICON_ERROR );
return;
}
// append the default extension to the filename if it doesn't have any
//
// VZ: the logic of testing for !wxFileExists() only for the open file
// dialog is not entirely clear to me, why don't we allow saving to a
// file without extension as well?
if ( !(m_dialogStyle & wxOPEN) || !wxFileExists(filename) )
{
filename = AppendExtension(filename, m_filterExtension);
}
// check that the file [doesn't] exist if necessary
if ( (m_dialogStyle & wxSAVE) &&
(m_dialogStyle & wxOVERWRITE_PROMPT) &&
wxFileExists( filename ) )
{
wxString msg;
msg.Printf( _("File '%s' already exists, do you really want to overwrite it?"), filename.c_str() );
if (wxMessageBox(msg, _("Confirm"), wxYES_NO) != wxYES)
return;
}
else if ( (m_dialogStyle & wxOPEN) &&
(m_dialogStyle & wxFILE_MUST_EXIST) &&
!wxFileExists(filename) )
{
wxMessageBox(_("Please choose an existing file."), _("Error"),
wxOK | wxICON_ERROR );
}
SetPath( filename );
// change to the directory where the user went if asked
if ( m_dialogStyle & wxCHANGE_DIR )
{
wxString cwd;
wxSplitPath(filename, &cwd, NULL, NULL);
if ( cwd != wxGetCwd() )
{
wxSetWorkingDirectory(cwd);
}
}
wxCommandEvent event;
wxDialog::OnOK(event);
}
void ProcessingDlg::CheckFilter(
const wxString& OldBasePath,
const wxStringStringMap& OldVars,
const wxArrayString& OldCompilers,
const LibraryDetectionConfig* Config,
const LibraryDetectionConfigSet* Set,
int WhichFilter)
{
if ( (int)Config->Filters.size() <= WhichFilter )
{
FoundLibrary(OldBasePath,OldVars,OldCompilers,Config,Set);
return;
}
const LibraryDetectionFilter& Filter = Config->Filters[WhichFilter];
switch ( Filter.Type )
{
case LibraryDetectionFilter::File:
{
// Split path
wxArrayString Pattern;
SplitPath(Filter.Value,Pattern);
// Fetch list of files with filename matching last pattern's element
const wxArrayString& PathArray = Map[Pattern[Pattern.Count()-1]];
if ( PathArray.empty() ) return;
// Process those files
for ( size_t i=0; i<PathArray.Count(); i++ )
{
wxArrayString Path;
wxStringStringMap Vars = OldVars;
SplitPath(PathArray[i],Path);
int path_index = (int)Path.Count() - 1;
int pattern_index = (int)Pattern.Count() - 1;
// Check if patterns do match
while ( ( path_index >= 0 ) && ( pattern_index >= 0 ) )
{
wxString& PatternPart = Pattern[pattern_index];
if ( IsVariable(PatternPart) )
{
wxString VarName = PatternPart.Mid(3,PatternPart.Len()-4);
if ( Vars[VarName].empty() )
{
Vars[VarName] = Path[path_index];
}
else
{
if ( Vars[VarName] != Path[path_index] ) break;
}
}
else
{
if ( PatternPart != Path[path_index] ) break;
}
path_index--;
pattern_index--;
}
// This is when patterns did not match
if ( pattern_index >= 0 ) continue;
// Construct base path from the rest of file's name
wxString BasePath;
for ( int j=0; j<=path_index; j++ )
{
BasePath += Path[j] + wxFileName::GetPathSeparator();
}
// And check if base path match the previous one
if ( !OldBasePath.IsEmpty() )
{
if ( BasePath != OldBasePath ) continue;
}
// Ok, this filter matches, let's advance to next filet
CheckFilter(BasePath,Vars,OldCompilers,Config,Set,WhichFilter+1);
}
break;
}
case LibraryDetectionFilter::Platform:
{
wxStringTokenizer Tokenizer(Filter.Value,_T("| \t"));
bool IsPlatform = false;
while ( Tokenizer.HasMoreTokens() )
{
wxString Platform = Tokenizer.GetNextToken();
if ( platform::windows )
{
if ( Platform==_T("win") || Platform==_T("windows") )
{
IsPlatform = true;
break;
}
}
if ( platform::macosx )
{
if ( Platform==_T("mac") || Platform==_T("macosx") )
{
IsPlatform = true;
break;
}
}
if ( platform::linux )
{
if ( Platform==_T("lin") || Platform==_T("linux") )
{
IsPlatform = true;
break;
}
}
if ( platform::freebsd )
{
if ( Platform==_T("bsd") || Platform==_T("freebsd") )
{
IsPlatform = true;
break;
}
}
if ( platform::netbsd )
{
if ( Platform==_T("bsd") || Platform==_T("netbsd") )
{
IsPlatform = true;
break;
}
}
if ( platform::openbsd )
{
if ( Platform==_T("bsd") || Platform==_T("openbsd") )
{
IsPlatform = true;
break;
}
}
if ( platform::darwin )
{
if ( Platform==_T("darwin") )
{
IsPlatform = true;
break;
}
}
if ( platform::solaris )
{
if ( Platform==_T("solaris") )
{
IsPlatform = true;
break;
}
}
if ( platform::unix )
{
if ( Platform==_T("unix") || Platform==_T("un*x") )
{
IsPlatform = true;
break;
}
}
}
if ( IsPlatform )
{
CheckFilter(OldBasePath,OldVars,OldCompilers,Config,Set,WhichFilter+1);
}
break;
}
case LibraryDetectionFilter::Exec:
{
bool IsExec = false;
if ( wxIsAbsolutePath(Filter.Value) )
{
// If this is absolute path, we don't search in PATH evironment var
IsExec = wxFileName::IsFileExecutable(Filter.Value);
}
else
{
// Let's search for the name in search paths
wxString Path;
if ( wxGetEnv(_T("PATH"),&Path) )
{
wxString Splitter = _T(":");
if ( platform::windows ) Splitter = _T(";");
wxStringTokenizer Tokenizer(Path,Splitter);
while ( Tokenizer.HasMoreTokens() )
{
wxString OnePath = Tokenizer.GetNextToken();
// Let's skip relative paths (f.ex. ".")
if ( !wxIsAbsolutePath(OnePath) ) continue;
OnePath += wxFileName::GetPathSeparator()+Filter.Value;
if ( wxFileName::IsFileExecutable(OnePath) )
{
IsExec = true;
break;
}
}
}
}
if ( IsExec )
{
CheckFilter(OldBasePath,OldVars,OldCompilers,Config,Set,WhichFilter+1);
}
break;
}
case LibraryDetectionFilter::PkgConfig:
{
if ( m_KnownResults[rtPkgConfig].IsShortCode(Filter.Value) )
{
CheckFilter(OldBasePath,OldVars,OldCompilers,Config,Set,WhichFilter+1);
}
break;
}
case LibraryDetectionFilter::Compiler:
{
if ( OldCompilers.IsEmpty() )
{
// If this is the first compiler filter, let's build new list and continue
CheckFilter(OldBasePath,OldVars,wxStringTokenize(Filter.Value,_T("| \t")),Config,Set,WhichFilter+1);
}
else
{
// We've set compiler list before, leave only the intersection
// of previous and current list
wxArrayString Compilers;
wxStringTokenizer Tokenizer(Filter.Value,_T("| \t"));
while ( Tokenizer.HasMoreTokens() )
{
wxString Comp = Tokenizer.GetNextToken();
if ( OldCompilers.Index(Comp) != wxNOT_FOUND )
{
Compilers.Add(Comp);
}
}
if ( !Compilers.IsEmpty() )
{
CheckFilter(OldBasePath,OldVars,Compilers,Config,Set,WhichFilter+1);
}
}
break;
}
case LibraryDetectionFilter::None:
{
CheckFilter(OldBasePath,OldVars,OldCompilers,Config,Set,WhichFilter+1);
break;
}
}
}
void wxGenericFileCtrl::HandleAction( const wxString &fn )
{
if ( m_ignoreChanges )
return;
wxString filename( fn );
if ( filename.empty() )
{
return;
}
if ( filename == wxT( "." ) ) return;
wxString dir = m_list->GetDir();
// "some/place/" means they want to chdir not try to load "place"
const bool want_dir = filename.Last() == wxFILE_SEP_PATH;
if ( want_dir )
filename = filename.RemoveLast();
if ( filename == wxT( ".." ) )
{
m_ignoreChanges = true;
m_list->GoToParentDir();
GenerateFolderChangedEvent( this, this );
UpdateControls();
m_ignoreChanges = false;
return;
}
#ifdef __UNIX__
if ( filename == wxT( "~" ) )
{
m_ignoreChanges = true;
m_list->GoToHomeDir();
GenerateFolderChangedEvent( this, this );
UpdateControls();
m_ignoreChanges = false;
return;
}
if ( filename.BeforeFirst( wxT( '/' ) ) == wxT( "~" ) )
{
filename = wxString( wxGetUserHome() ) + filename.Remove( 0, 1 );
}
#endif // __UNIX__
if ( !( m_style & wxFC_SAVE ) )
{
if ( ( filename.Find( wxT( '*' ) ) != wxNOT_FOUND ) ||
( filename.Find( wxT( '?' ) ) != wxNOT_FOUND ) )
{
if ( filename.Find( wxFILE_SEP_PATH ) != wxNOT_FOUND )
{
wxMessageBox( _( "Illegal file specification." ),
_( "Error" ), wxOK | wxICON_ERROR, this );
return;
}
m_list->SetWild( filename );
return;
}
}
if ( !IsTopMostDir( dir ) )
dir += wxFILE_SEP_PATH;
if ( !wxIsAbsolutePath( filename ) )
{
dir += filename;
filename = dir;
}
if ( wxDirExists( filename ) )
{
m_ignoreChanges = true;
m_list->GoToDir( filename );
UpdateControls();
GenerateFolderChangedEvent( this, this );
m_ignoreChanges = false;
return;
}
// they really wanted a dir, but it doesn't exist
if ( want_dir )
{
wxMessageBox( _( "Directory doesn't exist." ), _( "Error" ),
wxOK | wxICON_ERROR, this );
return;
}
// append the default extension to the filename if it doesn't have any
//
// VZ: the logic of testing for !wxFileExists() only for the open file
// dialog is not entirely clear to me, why don't we allow saving to a
// file without extension as well?
if ( !( m_style & wxFC_OPEN ) || !wxFileExists( filename ) )
{
filename = wxFileDialogBase::AppendExtension( filename, m_filterExtension );
GenerateFileActivatedEvent( this, this, wxFileName( filename ).GetFullName() );
return;
}
GenerateFileActivatedEvent( this, this );
}
bool PGM_KICAD::OnPgmInit( wxApp* aWxApp )
{
m_wx_app = aWxApp; // first thing.
wxString absoluteArgv0 = wxStandardPaths::Get().GetExecutablePath();
if( !wxIsAbsolutePath( absoluteArgv0 ) )
{
wxLogError( wxT( "No meaningful argv[0]" ) );
return false;
}
// Set LIB_ENV_VAR *before* loading the KIFACE DSOs, in case they have hard
// dependencies on subsidiary DSOs below it.
set_lib_env_var( absoluteArgv0 );
if( !initPgm() )
return false;
m_bm.Init();
// Add search paths to feed the PGM_KICAD::SysSearch() function,
// currenly limited in support to only look for project templates
{
SEARCH_STACK bases;
SystemDirsAppend( &bases );
// DBG( bases.Show( (std::string(__func__) + " bases").c_str() );)
for( unsigned i = 0; i < bases.GetCount(); ++i )
{
wxFileName fn( bases[i], wxEmptyString );
// Add KiCad template file path to search path list.
fn.AppendDir( wxT( "template" ) );
m_bm.m_search.AddPaths( fn.GetPath() );
}
//DBG( m_bm.m_search.Show( (std::string( __func__ ) + " SysSearch()").c_str() );)
}
// Must be called before creating the main frame in order to
// display the real hotkeys in menus or tool tips
extern struct EDA_HOTKEY_CONFIG kicad_Manager_Hokeys_Descr[];
ReadHotkeyConfig( KICAD_MANAGER_FRAME_NAME, kicad_Manager_Hokeys_Descr );
KICAD_MANAGER_FRAME* frame = new KICAD_MANAGER_FRAME( NULL, wxT( "KiCad" ),
wxDefaultPosition, wxDefaultSize );
App().SetTopWindow( frame );
Kiway.SetTop( frame );
bool prjloaded = false; // true when the project is loaded
if( App().argc > 1 )
frame->SetProjectFileName( App().argv[1] );
else if( GetFileHistory().GetCount() )
{
wxString last_pro = GetFileHistory().GetHistoryFile( 0 );
if( !wxFileExists( last_pro ) )
{
GetFileHistory().RemoveFileFromHistory( 0 );
wxFileName namelessProject( wxStandardPaths::Get().GetDocumentsDir(), NAMELESS_PROJECT,
ProjectFileExtension );
frame->SetProjectFileName( namelessProject.GetFullPath() );
}
else
{
// Try to open the last opened project,
// if a project name is not given when starting Kicad
frame->SetProjectFileName( last_pro );
wxCommandEvent cmd( 0, wxID_FILE1 );
frame->OnFileHistory( cmd );
prjloaded = true; // OnFileHistory() loads the project
}
}
else // there is no history
{
wxFileName namelessProject( wxStandardPaths::Get().GetDocumentsDir(), NAMELESS_PROJECT,
ProjectFileExtension );
frame->SetProjectFileName( namelessProject.GetFullPath() );
}
if( !prjloaded )
{
wxCommandEvent cmd( 0, wxID_ANY );
frame->OnLoadProject( cmd );
}
frame->Show( true );
frame->Raise();
return true;
}
bool PGM_SINGLE_TOP::OnPgmInit( wxApp* aWxApp )
{
// first thing: set m_wx_app
m_wx_app = aWxApp;
wxString absoluteArgv0 = wxStandardPaths::Get().GetExecutablePath();
if( !wxIsAbsolutePath( absoluteArgv0 ) )
{
wxLogError( wxT( "No meaningful argv[0]" ) );
return false;
}
if( !initPgm() )
return false;
#if !defined(BUILD_KIWAY_DLL)
// Get the getter, it is statically linked into this binary image.
KIFACE_GETTER_FUNC* getter = &KIFACE_GETTER;
int kiface_version;
// Get the KIFACE.
KIFACE* kiface = getter( &kiface_version, KIFACE_VERSION, this );
// Trick the KIWAY into thinking it loaded a KIFACE, by recording the KIFACE
// in the KIWAY. It needs to be there for KIWAY::OnKiwayEnd() anyways.
Kiway.set_kiface( KIWAY::KifaceType( TOP_FRAME ), kiface );
#endif
// Use KIWAY to create a top window, which registers its existence also.
// "TOP_FRAME" is a macro that is passed on compiler command line from CMake,
// and is one of the types in FRAME_T.
KIWAY_PLAYER* frame = Kiway.Player( TOP_FRAME, true );
Kiway.SetTop( frame );
App().SetTopWindow( frame ); // wxApp gets a face.
// Open project or file specified on the command line:
int argc = App().argc;
if( argc > 1 )
{
/*
gerbview handles multiple project data files, i.e. gerber files on
cmd line. Others currently do not, they handle only one. For common
code simplicity we simply pass all the arguments in however, each
program module can do with them what they want, ignore, complain
whatever. We don't establish policy here, as this is a multi-purpose
launcher.
*/
std::vector<wxString> argSet;
for( int i=1; i<argc; ++i )
{
argSet.push_back( App().argv[i] );
}
// special attention to the first argument: argv[1] (==argSet[0])
wxFileName argv1( argSet[0] );
if( argc == 2 )
{
#if defined(PGM_DATA_FILE_EXT)
// PGM_DATA_FILE_EXT, if present, may be different for each compile,
// it may come from CMake on the compiler command line, but often does not.
// This facillity is mostly useful for those program modules
// supporting a single argv[1].
if( !argv1.GetExt() )
argv1.SetExt( wxT( PGM_DATA_FILE_EXT ) );
#endif
argv1.MakeAbsolute();
argSet[0] = argv1.GetFullPath();
}
// Use the KIWAY_PLAYER::OpenProjectFiles() API function:
if( !frame->OpenProjectFiles( argSet ) )
{
// OpenProjectFiles() API asks that it report failure to the UI.
// Nothing further to say here.
// We've already initialized things at this point, but wx won't call OnExit if
// we fail out. Call our own cleanup routine here to ensure the relevant resources
// are freed at the right time (if they aren't, segfaults will occur).
OnPgmExit();
// Fail the process startup if the file could not be opened,
// although this is an optional choice, one that can be reversed
// also in the KIFACE specific OpenProjectFiles() return value.
return false;
}
}
frame->Show();
return true;
}
wxString MyApp::wxFindAppPath( const wxString& argv0, const wxString& cwd, const wxString& appVariableName, const wxString& appName )
{
wxString str;
#ifndef __WXWINCE__
// Try appVariableName
if ( !appVariableName.IsEmpty() )
{
str = wxGetenv( appVariableName );
if ( !str.IsEmpty() )
return str;
}
#endif
#if defined(__WXMAC__) && !defined(__DARWIN__)
return cwd;
#endif
if ( wxIsAbsolutePath( argv0 ) )
return wxPathOnly( argv0 );
else
{
// Is it a relative path?
if ( !cwd.IsEmpty() )
{
wxString currentDir( cwd );
if ( currentDir.Last() != wxFILE_SEP_PATH )
currentDir += wxFILE_SEP_PATH;
str = currentDir + argv0;
if ( wxFileExists( str ) )
return wxPathOnly( str );
#ifdef __WXMAC__
// The current directory may be above the actual
// bundle. So if we find the bundle below it,
// we know where we are.
if (!appName.IsEmpty())
{
wxString p = currentDir + appName + wxT(".app");
if (wxDirExists(p))
{
p += wxFILE_SEP_PATH;
p += wxT("Content/MacOS");
return p;
}
}
#endif
}
}
// OK, it's neither an absolute path nor a relative path.
// Search PATH.
wxPathList pathList;
pathList.AddEnvList( wxT("PATH") );
str = pathList.FindAbsoluteValidPath( argv0 );
if ( !str.IsEmpty() )
return wxPathOnly( str );
// Failed
return wxEmptyString;
}
bool GPACInit(void *application, GF_Terminal **term, GF_User *user, bool quiet)
{
memset(user, 0, sizeof(GF_User));
/*locate exec dir for cfg file*/
wxPathList pathList;
wxString currentDir(wxGetCwd());
wxString abs_gpac_path = "";
const char *gpac_cfg;
if (!quiet) ::wxLogMessage("Looking for GPAC configuration file");
#if defined(__WXMAC__) && !defined(__DARWIN__)
// On Mac, the current directory is the relevant one when the application starts.
abs_gpac_path = wxGetCwd();
gpac_cfg = "GPAC.cfg";
#else
#ifdef WIN32
V4StudioApp &app = wxGetApp();
gpac_cfg = "GPAC.cfg";
/*locate exe*/
if (wxIsAbsolutePath(app.argv[0])) {
abs_gpac_path = wxPathOnly(app.argv[0]);
} else {
if (currentDir.Last() != wxFILE_SEP_PATH) currentDir += wxFILE_SEP_PATH;
abs_gpac_path = currentDir + app.argv[0];
if (wxFileExists(abs_gpac_path)) {
abs_gpac_path = wxPathOnly(abs_gpac_path);
} else {
abs_gpac_path = "";
pathList.AddEnvList(wxT("PATH"));
abs_gpac_path = pathList.FindAbsoluteValidPath(app.argv[0]);
if (!abs_gpac_path.IsEmpty()) {
abs_gpac_path = wxPathOnly(abs_gpac_path);
} else {
/*ask user*/
wxDirDialog dlg(NULL, "Locate GPAC config file directory");
if ( dlg.ShowModal() != wxID_OK ) return 0;
abs_gpac_path = dlg.GetPath();
}
}
}
#else
gpac_cfg = ".gpacrc";
char *cfg_dir = getenv("HOME");
if (cfg_dir) {
abs_gpac_path = cfg_dir;
} else {
/*ask user*/
wxDirDialog dlg(NULL, "Locate GPAC config file directory");
if ( dlg.ShowModal() != wxID_OK ) return 0;
abs_gpac_path = dlg.GetPath();
}
#endif
#endif
/*load config*/
Bool first_launch = 0;
user->config = gf_cfg_init(NULL, &first_launch);
if (!user->config) {
wxMessageDialog(NULL, "Cannot create GPAC config file", "Init error", wxOK).ShowModal();
}
if (!quiet) ::wxLogMessage("GPAC configuration file opened - looking for modules");
const char *str = gf_cfg_get_key(user->config, "General", "ModulesDirectory");
user->modules = gf_modules_new(str, user->config);
if (! gf_modules_get_count(user->modules) ) {
wxMessageDialog(NULL, "No modules available - system cannot work", "Fatal Error", wxOK).ShowModal();
gf_modules_del(user->modules);
gf_cfg_del(user->config);
return 0;
}
if (!quiet) ::wxLogMessage("%d modules found:", gf_modules_get_count(user->modules));
for (u32 i=0; i<gf_modules_get_count(user->modules); i++) {
if (!quiet) ::wxLogMessage("\t%s", gf_modules_get_file_name(user->modules, i));
}
if (!quiet) ::wxLogMessage("Starting GPAC Terminal");
/*now load terminal*/
user->opaque = application;
user->EventProc = V4S_EventProc;
// user->os_window_handler = ((wxGPACPanel *)application)->GetV4SceneManager()->GetV4StudioFrame()->GetHandle();
// Forces the renderer to not use a thread and do the rendering by itfe
gf_cfg_set_key(user->config, "Systems", "NoVisualThread", "No");
*term = gf_term_new(user);
if (!*term) {
wxMessageDialog(NULL, "Fatal Error", "Cannot load GPAC Terminal", wxOK).ShowModal();
return 0;
} else {
if (!quiet) ::wxLogMessage("GPAC Terminal started");
}
return 1;
}
void Write_GENERIC_NetList(wxWindow * frame, const wxString & FullFileName)
/***********************************************************************/
/* Create a generic netlist, and call an external netlister
to change the netlist syntax and create the file
*/
{
wxString Line, FootprintName;
BASE_SCREEN *CurrScreen;
EDA_BaseStruct *DrawList;
EDA_SchComponentStruct *Component;
wxString netname;
int ii;
FILE * tmpfile;
wxString TmpFullFileName = FullFileName;
ChangeFileNameExt(TmpFullFileName, ".tmp");
if ((tmpfile = fopen(TmpFullFileName, "wt")) == NULL)
{
wxString msg = _("Failed to create file ") + TmpFullFileName;
DisplayError(frame, msg);
return;
}
ClearUsedFlags(); /* Reset the flags FlagControlMulti in all schematic files*/
fprintf( tmpfile, "$BeginNetlist\n" );
/* Create netlist module section */
fprintf( tmpfile, "$BeginComponentList\n" );
for(CurrScreen = ScreenSch; CurrScreen != NULL; CurrScreen = (BASE_SCREEN*)CurrScreen->Pnext )
{
for ( DrawList = CurrScreen->EEDrawList; DrawList != NULL; DrawList = DrawList->Pnext )
{
DrawList = Component = FindNextComponentAndCreatPinList(DrawList);
if ( Component == NULL ) break; // No component left
FootprintName.Empty();
if( ! Component->m_Field[FOOTPRINT].IsVoid() )
{
FootprintName = Component->m_Field[FOOTPRINT].m_Text;
FootprintName.Replace(" ", "_");
}
fprintf( tmpfile, "\n$BeginComponent\n" );
fprintf(tmpfile, "TimeStamp=%8.8lX\n", Component->m_TimeStamp);
fprintf(tmpfile, "Footprint=%s\n", FootprintName.GetData());
Line = "Reference=" + Component->m_Field[REFERENCE].m_Text + "\n";
Line.Replace(" ", "_");
fprintf(tmpfile, Line.GetData());
Line = Component->m_Field[VALUE].m_Text;
Line.Replace(" ", "_");
fprintf(tmpfile, "Value=%s\n", Line.GetData());
Line = Component->m_ChipName;
Line.Replace(" ", "_");
fprintf(tmpfile, "Libref=%s\n", Line.GetData());
// Write pin list:
fprintf( tmpfile, "$BeginPinList\n" );
for (ii = 0; ii < s_SortedPinCount; ii++)
{
ObjetNetListStruct *Pin = s_SortedComponentPinList[ii];
if( ! Pin ) continue;
netname = ReturnPinNetName(Pin, "$-%.6d");
if ( netname == "" ) netname = "?";
fprintf( tmpfile,"%.4s=%s\n",(char *)&Pin->m_PinNum, netname.GetData());
}
fprintf( tmpfile, "$EndPinList\n" );
fprintf( tmpfile, "$EndComponent\n" );
}
}
MyFree(s_SortedComponentPinList);
s_SortedComponentPinList = NULL;
fprintf( tmpfile, "$EndComponentList\n" );
fprintf( tmpfile, "\n$BeginNets\n" );
WriteGENERICListOfNets( tmpfile, g_TabObjNet );
fprintf( tmpfile, "$EndNets\n" );
fprintf( tmpfile, "\n$EndNetlist\n" );
fclose(tmpfile);
// Call the external module (plug in )
if ( g_NetListerCommandLine == "" ) return;
wxString CommandFile;
if ( wxIsAbsolutePath(g_NetListerCommandLine) )
CommandFile = g_NetListerCommandLine;
else CommandFile = FindKicadFile(g_NetListerCommandLine);
CommandFile += " " + TmpFullFileName;
CommandFile += " " + FullFileName;
wxExecute(CommandFile, wxEXEC_SYNC);
}
