FilePath FilePath::FromAbsoluteWx(const wxFileName& wxFn){
assert(wxFn.IsAbsolute());
assert(!wxFn.IsDir());
return FilePath(new PathImpl(wxFn));
}
void PluginManager::AddWorkspaceToRecentlyUsedList(const wxFileName& filename)
{
if(filename.Exists()) {
ManagerST::Get()->AddToRecentlyOpenedWorkspaces(filename.GetFullPath());
}
}
bool
header_editor_frame_c::open_file(wxFileName file_name) {
if (!kax_analyzer_c::probe(wxMB(file_name.GetFullPath()))) {
wxMessageBox(Z("The file you tried to open is not a Matroska file."), Z("Wrong file selected"), wxOK | wxCENTER | wxICON_ERROR);
return false;
}
m_e_segment_info.reset();
m_e_tracks.reset();
m_analyzer = wx_kax_analyzer_cptr(new wx_kax_analyzer_c(this, wxMB(file_name.GetFullPath())));
if (!m_analyzer->process(kax_analyzer_c::parse_mode_fast)) {
wxMessageBox(Z("This file could not be opened or parsed."), Z("File parsing failed"), wxOK | wxCENTER | wxICON_ERROR);
m_analyzer.reset();
return false;
}
m_file_name = file_name;
m_file_name.GetTimes(nullptr, &m_file_mtime, nullptr);
set_window_title();
m_ignore_tree_selection_changes = true;
enable_menu_entries();
m_bs_main->Hide(m_tc_tree);
for (auto &page : m_pages)
if (page->IsShown())
page->Hide();
m_tc_tree->DeleteChildren(m_root_id);
m_bs_page->Clear();
m_pages.clear();
m_top_level_pages.clear();
for (auto &data : m_analyzer->m_data)
if (data->m_id == KaxInfo::ClassInfos.GlobalId) {
handle_segment_info(data.get());
break;
}
for (auto &data : m_analyzer->m_data)
if (data->m_id == KaxTracks::ClassInfos.GlobalId) {
handle_tracks(data.get());
break;
}
m_analyzer->close_file();
m_bs_main->Show(m_tc_tree);
m_bs_main->Layout();
last_open_dir = file_name.GetPath();
m_ignore_tree_selection_changes = false;
return true;
}
bool wxFileSystemWatcherBase::RemoveTree(const wxFileName& path)
{
if (!path.DirExists())
return false;
// OPT could be optimised if we stored information about relationships
// between paths
class RemoveTraverser : public wxDirTraverser
{
public:
RemoveTraverser(wxFileSystemWatcherBase* watcher,
const wxString& filespec) :
m_watcher(watcher), m_filespec(filespec)
{
}
virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
{
// We never watch the individual files when watching the tree, so
// nothing to do here.
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& dirname)
{
m_watcher->Remove(wxFileName::DirName(dirname));
return wxDIR_CONTINUE;
}
private:
wxFileSystemWatcherBase* m_watcher;
wxString m_filespec;
};
// If AddTree() used a filespec, we must use the same one
wxString canonical = GetCanonicalPath(path);
wxFSWatchInfoMap::iterator it = m_watches.find(canonical);
wxCHECK_MSG( it != m_watches.end(), false,
wxString::Format("Path '%s' is not watched", canonical) );
wxFSWatchInfo watch = it->second;
const wxString filespec = watch.GetFilespec();
#if defined(__WINDOWS__)
// When there's no filespec, the wxMSW AddTree() would have set a watch
// on only the passed 'path'. We must therefore remove only this
if (filespec.empty())
{
return Remove(path);
}
// Otherwise fall through to the generic implementation
#endif // __WINDOWS__
wxDir dir(path.GetFullPath());
// AddTree() might have used the wxDIR_NO_FOLLOW to prevent asserts or
// infinite loops in trees containing symlinks. We need to do the same
// or we'll try to remove unwatched items. Let's hope the caller used
// the same ShouldFollowLink() setting as in AddTree()...
int flags = wxDIR_DIRS;
if ( !path.ShouldFollowLink() )
{
flags |= wxDIR_NO_FOLLOW;
}
RemoveTraverser traverser(this, filespec);
dir.Traverse(traverser, filespec, flags);
// As in AddTree() above, handle the path itself explicitly.
Remove(path);
return true;
}
/** DoLoadFile
*
* Handles loading an assembly file into the simulator
*/
void ComplxFrame::DoLoadFile(const wxFileName& filename)
{
//CleanUp();
lc3_state dummy_state;
lc3_init(dummy_state);
// Save the symbols
std::map<std::string, unsigned short> symbol_table = state.symbols;
std::map<unsigned short, std::string> rev_symbol_table = state.rev_symbols;
state.symbols.clear();
state.rev_symbols.clear();
lc3_remove_plugins(state);
try
{
std::vector<code_range> ranges;
lc3_assemble(dummy_state, filename.GetFullPath().ToStdString(), false);
lc3_assemble(state, filename.GetFullPath().ToStdString(), ranges);
modified_addresses.clear();
for (const auto& code_range : ranges)
modified_addresses.push_back(ViewRange(code_range.location, code_range.location + code_range.size));
// Dummy call to update hidden addresses.
wxCommandEvent event;
OnUpdateHideAddresses(event);
}
catch (LC3AssembleException e)
{
wxMessageBox(wxString::Format("BAD STUDENT! %s", e.what()), _("Loading ") + filename.GetFullName() + _(" Failed"));
goto merge;
}
catch (std::vector<LC3AssembleException> e)
{
std::stringstream oss;
for (unsigned int i = 0; i < e.size(); i++)
oss << e[i].what() << std::endl;
wxMessageBox(wxString::Format("BAD STUDENT! %s", oss.str()), _("Loading ") + filename.GetFullName() + _(" Failed"));
goto merge;
}
//if (DoAssemble(filename)) return;
currentFile = filename;
SetTitle(wxString::Format("Complx - %s", filename.GetFullPath()));
merge:
std::map<std::string, unsigned short>::const_iterator i;
std::map<unsigned short, std::string>::const_iterator j;
for (i = symbol_table.begin(); i != symbol_table.end(); ++i)
{
state.symbols[i->first] = i->second;
}
for (j = rev_symbol_table.begin(); j != rev_symbol_table.end(); ++j)
{
state.rev_symbols[j->first] = j->second;
}
//DoLoad(filename);
UpdateStatus();
UpdateRegisters();
UpdateMemory();
}
void SymbolTree::BuildTree(const wxFileName &fileName, TagEntryPtrVector_t* tags /*NULL*/)
{
TagEntryPtrVector_t newTags;
if ( !tags ) {
// Get the current database
ITagsStoragePtr db = TagsManagerST::Get()->GetDatabase();
if ( ! db ) {
Clear();
return;
}
// Load the new tags from the database
db->SelectTagsByFile(fileName.GetFullPath(), newTags);
// Compare the new tags with the old ones
if ( TagsManagerST::Get()->AreTheSame(newTags, m_currentTags) )
return;
m_currentTags.clear();
m_currentTags.insert(m_currentTags.end(), newTags.begin(), newTags.end());
} else {
m_currentTags.clear();
m_currentTags.insert(m_currentTags.end(), tags->begin(), tags->end());
}
wxWindowUpdateLocker locker(this);
Clear();
m_fileName = fileName;
// Convert them into tree
m_tree = TagsManagerST::Get()->Load(m_fileName, &m_currentTags);
if ( !m_tree ) {
return;
}
// Add invisible root node
wxTreeItemId root;
root = AddRoot(fileName.GetFullName(), 15, 15);
TreeWalker<wxString, TagEntry> walker(m_tree->GetRoot());
// add three items here:
// the globals node, the mcros and the prototype node
m_globalsNode = AppendItem(root, wxT("Global Functions and Variables"), 2, 2, new MyTreeItemData(wxT("Global Functions and Variables"), wxEmptyString));
m_prototypesNode = AppendItem(root, wxT("Functions Prototypes"), 2, 2, new MyTreeItemData(wxT("Functions Prototypes"), wxEmptyString));
m_macrosNode = AppendItem(root, wxT("Macros"), 2, 2, new MyTreeItemData(wxT("Macros"), wxEmptyString));
// Iterate over the tree and add items
m_sortItems.clear();
Freeze();
for (; !walker.End(); walker++) {
// Add the item to the tree
TagNode* node = walker.GetNode();
// Skip root node
if (node->IsRoot())
continue;
// Add the node
AddItem(node);
}
SortTree(m_sortItems);
if ( ItemHasChildren(m_globalsNode) == false ) {
Delete(m_globalsNode);
}
if ( ItemHasChildren(m_prototypesNode) == false ) {
Delete(m_prototypesNode);
}
if ( ItemHasChildren(m_macrosNode) == false ) {
Delete(m_macrosNode);
}
Thaw();
//select the root node by default
if (!(GetWindowStyleFlag() & wxTR_HIDE_ROOT)) {
//root is visible, select it
SelectItem(GetRootItem());
}
}
wxArrayString FSOExecutable::GetBinariesFromRootFolder(const wxFileName& path, const wxString& globPattern, bool quiet) {
wxArrayString files;
// Check args because this function gets crap tossed at it to validate
wxString pathStr(path.GetPath());
if (pathStr.IsEmpty())
{
wxLogInfo(wxT("GetBinaries called with empty root folder"));
return files;
}
wxDir folder(pathStr);
if (!folder.IsOpened())
{
wxLogInfo(wxT("GetBinaries called on '%s' which cannot be opened"),
pathStr.c_str());
return files;
}
wxString filename;
#if IS_APPLE // Binaries are directories on OSX.
bool cont = folder.GetFirst(&filename, globPattern, wxDIR_DIRS);
#else
bool cont = folder.GetFirst(&filename, globPattern, wxDIR_FILES);
#endif
while (cont) {
#if IS_LINUX
if ( !IsFileToIgnore(filename) ) {
#endif
files.Add(filename);
#if IS_LINUX
}
#endif
cont = folder.GetNext(&filename);
}
// filter out launcher binaries (at least on OSX)
for (int i = files.GetCount() - 1; i >= 0; --i) {
if (files[i].Lower().Find(_T("launcher")) != wxNOT_FOUND) {
files.RemoveAt(i);
}
}
#if IS_APPLE
// find actual (Unix) executable inside .app bundle and call the path to it the "executable"
for (wxArrayString::iterator it = files.begin(), end = files.end(); it != end; ++it) {
wxString pathToBin =
wxDir::FindFirst(path.GetPath(wxPATH_GET_SEPARATOR) + *it + _T("/Contents/MacOS"),
_T("*"),
wxDIR_FILES);
pathToBin.Replace(path.GetPath(wxPATH_GET_SEPARATOR), _T(""));
*it = pathToBin;
}
#endif
if (!quiet) {
wxString execType = globPattern.Lower().Find(_T("fred")) == wxNOT_FOUND ? _T("FS2") : _T("FRED2");
wxLogInfo(_T(" Found %d %s Open executables in '%s'"),
files.GetCount(), execType.c_str(), path.GetPath().c_str());
for (size_t i = 0, n = files.GetCount(); i < n; ++i) {
wxLogDebug(_T("Found executable: %s"), files.Item(i).c_str());
}
}
return files;
}
// file is a misnomer as it's the name of the base help directory
bool wxExtHelpController::LoadFile(const wxString& file)
{
wxFileName helpDir(wxFileName::DirName(file));
helpDir.MakeAbsolute();
bool dirExists = false;
#if wxUSE_INTL
// If a locale is set, look in file/localename, i.e. If passed
// "/usr/local/myapp/help" and the current wxLocale is set to be "de", then
// look in "/usr/local/myapp/help/de/" first and fall back to
// "/usr/local/myapp/help" if that doesn't exist.
const wxLocale * const loc = wxGetLocale();
if ( loc )
{
wxString locName = loc->GetName();
// the locale is in general of the form xx_YY.zzzz, try the full firm
// first and then also more general ones
wxFileName helpDirLoc(helpDir);
helpDirLoc.AppendDir(locName);
dirExists = helpDirLoc.DirExists();
if ( ! dirExists )
{
// try without encoding
const wxString locNameWithoutEncoding = locName.BeforeLast(_T('.'));
if ( !locNameWithoutEncoding.empty() )
{
helpDirLoc = helpDir;
helpDirLoc.AppendDir(locNameWithoutEncoding);
dirExists = helpDirLoc.DirExists();
}
}
if ( !dirExists )
{
// try without country part
wxString locNameWithoutCountry = locName.BeforeLast(_T('_'));
if ( !locNameWithoutCountry.empty() )
{
helpDirLoc = helpDir;
helpDirLoc.AppendDir(locNameWithoutCountry);
dirExists = helpDirLoc.DirExists();
}
}
if ( dirExists )
helpDir = helpDirLoc;
}
#endif // wxUSE_INTL
if ( ! dirExists && !helpDir.DirExists() )
{
wxLogError(_("Help directory \"%s\" not found."),
helpDir.GetFullPath().c_str());
return false;
}
const wxFileName mapFile(helpDir.GetFullPath(), WXEXTHELP_MAPFILE);
if ( ! mapFile.FileExists() )
{
wxLogError(_("Help file \"%s\" not found."),
mapFile.GetFullPath().c_str());
return false;
}
DeleteList();
m_MapList = new wxList;
m_NumOfEntries = 0;
wxTextFile input;
if ( !input.Open(mapFile.GetFullPath()) )
return false;
for ( wxString& line = input.GetFirstLine();
!input.Eof();
line = input.GetNextLine() )
{
if ( !ParseMapFileLine(line) )
{
wxLogWarning(_("Line %lu of map file \"%s\" has invalid syntax, skipped."),
(unsigned long)input.GetCurrentLine(),
mapFile.GetFullPath().c_str());
}
}
if ( !m_NumOfEntries )
{
wxLogError(_("No valid mappings found in the file \"%s\"."),
mapFile.GetFullPath().c_str());
return false;
}
m_helpDir = helpDir.GetFullPath(); // now it's valid
return true;
}
wxString GetName() const { return m_file_name.GetDirs().Last(); }
bool BinaryDataGenerator::IsFilenameSupported(const wxFileName &fileName)
{
return fileName.GetExt() == "bin";
}
bool CodeFormatter::DoClangFormat(const wxFileName& filename,
wxString& formattedOutput,
int& cursorPosition,
int startOffset,
int length,
const FormatOptions& options)
{
// clang-format
// Build the command line to run
if(options.GetClangFormatExe().IsEmpty()) {
return false;
}
wxString command, file;
clClangFormatLocator locator;
double version = locator.GetVersion(options.GetClangFormatExe());
command << options.GetClangFormatExe();
file = filename.GetFullPath();
::WrapWithQuotes(command);
::WrapWithQuotes(file);
command << options.ClangFormatOptionsAsString(filename, version);
if(cursorPosition != wxNOT_FOUND) {
command << " -cursor=" << cursorPosition;
}
if(startOffset != wxNOT_FOUND && length != wxNOT_FOUND) {
command << " -offset=" << startOffset << " -length=" << length;
}
command << " " << file;
// Wrap the command in the local shell
::WrapInShell(command);
// Log the command
CL_DEBUG("CodeForamtter: running:\n%s\n", command);
// Execute clang-format and reand the output
formattedOutput.Clear();
IProcess::Ptr_t clangFormatProc(
::CreateSyncProcess(command, IProcessCreateDefault | IProcessCreateWithHiddenConsole));
CHECK_PTR_RET_FALSE(clangFormatProc);
clangFormatProc->WaitForTerminate(formattedOutput);
CL_DEBUG("clang-format returned with:\n%s\n", formattedOutput);
if(formattedOutput.IsEmpty()) {
// crash?
return false;
}
// The first line contains the cursor position
if(cursorPosition != wxNOT_FOUND) {
wxString metadata = formattedOutput.BeforeFirst('\n');
JSONRoot root(metadata);
cursorPosition = root.toElement().namedObject("cursor").toInt(wxNOT_FOUND);
formattedOutput = formattedOutput.AfterFirst('\n');
}
return true;
}
bool operator()(const wxFileName& one, const wxFileName& two) const {
return one.GetModificationTime().GetTicks() > two.GetModificationTime().GetTicks();
}
/** @brief Processes a single line from a LOF text file, doing whatever is
* indicated on the line.
*
* This function should just return for lines it cannot deal with, and the
* caller will continue to the next line of the input file
*/
void LOFImportFileHandle::lofOpenFiles(wxString* ln)
{
wxStringTokenizer tok(*ln, wxT(" "));
wxStringTokenizer temptok1(*ln, wxT("\""));
wxStringTokenizer temptok2(*ln, wxT(" "));
int tokenplace = 0;
wxString targetfile;
wxString tokenholder = tok.GetNextToken();
if (tokenholder.IsSameAs(wxT("window"), false))
{
// set any duration/offset factors for last window, as all files were called
doDuration();
doScrollOffset();
if (windowCalledOnce)
{
mProject = CreateNewAudacityProject();
}
windowCalledOnce = true;
while (tok.HasMoreTokens())
{
tokenholder = tok.GetNextToken();
if (tokenholder.IsSameAs(wxT("offset"), false))
{
if (tok.HasMoreTokens())
tokenholder = tok.GetNextToken();
if (Internat::CompatibleToDouble(tokenholder, &scrollOffset))
{
callScrollOffset = true;
}
else
{
/* i18n-hint: You do not need to translate "LOF" */
wxMessageBox(_("Invalid window offset in LOF file."),
/* i18n-hint: You do not need to translate "LOF" */
_("LOF Error"), wxOK | wxCENTRE);
}
if (tok.HasMoreTokens())
tokenholder = tok.GetNextToken();
}
if (tokenholder.IsSameAs(wxT("duration"), false))
{
if (tok.HasMoreTokens())
tokenholder = tok.GetNextToken();
if (Internat::CompatibleToDouble(tokenholder, &durationFactor))
{
callDurationFactor = true;
}
else
{
/* i18n-hint: You do not need to translate "LOF" */
wxMessageBox(_("Invalid duration in LOF file."),
/* i18n-hint: You do not need to translate "LOF" */
_("LOF Error"), wxOK | wxCENTRE);
}
} // End if statement
if (tokenholder.IsSameAs(wxT("#")))
{
// # indicates comments; ignore line
tok = wxStringTokenizer(wxT(""), wxT(" "));
}
} // End while loop
} // End if statement handling "window" lines
else if (tokenholder.IsSameAs(wxT("file"), false))
{
// To identify filename and open it
tokenholder = temptok1.GetNextToken();
targetfile = temptok1.GetNextToken();
// If path is relative, make absolute path from LOF path
if(!wxIsAbsolutePath(targetfile)) {
wxFileName fName(targetfile);
fName.Normalize(wxPATH_NORM_ALL, mLOFFileName.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR));
if(fName.FileExists()) {
targetfile = fName.GetFullPath();
}
}
#ifdef USE_MIDI
// If file is a midi
if (targetfile.AfterLast(wxT('.')).IsSameAs(wxT("mid"), false)
|| targetfile.AfterLast(wxT('.')).IsSameAs(wxT("midi"), false))
{
mProject->DoImportMIDI(targetfile);
}
// If not a midi, open audio file
else
#else // !USE_MIDI
/* if we don't have midi support, go straight on to opening as an
* audio file. TODO: Some sort of message here? */
#endif // USE_MIDI
{
mProject->OpenFile(targetfile);
}
// Set tok to right after filename
temptok2.SetString(targetfile);
tokenplace = temptok2.CountTokens();
for (int i = 0; i < tokenplace; i++)
tokenholder = tok.GetNextToken();
if (tok.HasMoreTokens())
{
tokenholder = tok.GetNextToken();
if (tokenholder.IsSameAs(wxT("#")))
{
// # indicates comments; ignore line
tok = wxStringTokenizer(wxT(""), wxT(" "));
}
if (tokenholder.IsSameAs(wxT("offset"), false))
{
if (tok.HasMoreTokens())
tokenholder = tok.GetNextToken();
double offset;
// handle an "offset" specifier
if (Internat::CompatibleToDouble(tokenholder, &offset))
{
Track *t;
TrackListIterator iter(mProject->GetTracks());
t = iter.First();
for (int i = 1; i < CountNumTracks(mProject) - 1; i++)
t = iter.Next();
// t is now the last track in the project, unless the import of
// all tracks failed, in which case it will be null. In that
// case we return because we cannot offset a non-existent track.
if (t == NULL) return;
#ifdef USE_MIDI
if (targetfile.AfterLast(wxT('.')).IsSameAs(wxT("mid"), false) ||
targetfile.AfterLast(wxT('.')).IsSameAs(wxT("midi"), false))
{
wxMessageBox(_("MIDI tracks cannot be offset individually, only audio files can be."),
_("LOF Error"), wxOK | wxCENTRE);
}
else
#endif
{
if (CountNumTracks(mProject) == 1)
t->SetOffset(offset);
else
{
if (t->GetLinked())
t->SetOffset(offset);
t = iter.Next();
t->SetOffset(offset);
}
}
} // end of converting "offset" argument
else
{
/* i18n-hint: You do not need to translate "LOF" */
wxMessageBox(_("Invalid track offset in LOF file."),
_("LOF Error"), wxOK | wxCENTRE);
}
} // End if statement for "offset" parameters
} // End if statement (more tokens after file name)
} // End if statement "file" lines
else if (tokenholder.IsSameAs(wxT("#")))
{
// # indicates comments; ignore line
tok = wxStringTokenizer(wxT(""), wxT(" "));
}
else
{
// Couldn't parse a line
}
}
bool wxFsEventsFileSystemWatcher::AddTree(const wxFileName& path, int events,
const wxString& filespec)
{
if (!path.DirExists())
{
return false;
}
wxString canonical = GetCanonicalPath(path);
if ( canonical.empty() )
{
return false;
}
CFRunLoopRef cfLoop = CFRunLoopGetCurrent();
wxASSERT_MSG(
cfLoop,
"there must be a current event loop; this file watcher needs it."
);
if ( ! cfLoop )
{
return false;
}
if ( m_streams.find(canonical) != m_streams.end() )
{
// How to take into account filespec
// if client adds a watch for /home/*.cpp
// and then on another call wants to add a
// call to /home/*.h
// Ideally we should not create another watch
// however we would need to keep both filespecs
// around, which we don't do now.
return false;
}
// Will need to pass the desired event flags
// and filespec to our callback via the context
// we make sure to give the context a cleanup
// callback.
FSEventStreamContext ctx;
wxFSEventWatcherContext* watcherContext = new wxFSEventWatcherContext(
this, events, filespec.Clone()
);
ctx.version = 0;
ctx.info = watcherContext;
ctx.retain = NULL;
ctx.release = &wxDeleteContext;
ctx.copyDescription = NULL;
CFTimeInterval latency = 0.2;
wxMacUniCharBuffer pathChars(path.GetPath());
CFStringRef pathRef = CFStringCreateWithCharacters(
kCFAllocatorDefault,
pathChars.GetBuffer(),
pathChars.GetChars()
);
CFArrayRef pathRefs = CFArrayCreate(
kCFAllocatorDefault, (const void**)&pathRef, 1, NULL
);
FSEventStreamCreateFlags flags = kFSEventStreamCreateFlagWatchRoot
| kFSEventStreamCreateFlagFileEvents;
FSEventStreamRef stream = FSEventStreamCreate(
kCFAllocatorDefault,
&wxFSEventCallback,
&ctx,
pathRefs, kFSEventStreamEventIdSinceNow,
latency, flags);
bool started = false;
if ( stream )
{
FSEventStreamScheduleWithRunLoop(stream, cfLoop, kCFRunLoopDefaultMode);
started = FSEventStreamStart(stream);
if ( started )
{
m_streams[canonical] = stream;
}
}
// cleanup the paths, as we own the pointers
CFRelease(pathRef);
CFRelease(pathRefs);
wxASSERT_MSG(stream, "could not create FS stream");
return started;
}
void CMakePlugin::OnExportMakefile(clBuildEvent& event)
{
const wxString project = event.GetProjectName();
const wxString config = event.GetConfigurationName();
// Get settings
const CMakeProjectSettings* settings = GetSettingsManager()->GetProjectSettings(project, config);
// Doesn't exists or not enabled
if(!settings || !settings->enabled) {
// Unable to export makefile
event.Skip();
return;
}
// Get project directory - this is directory where the makefile is stored
const wxFileName projectDir = GetProjectDirectory(project);
// Targets forward inspired by
// https://gist.github.com/doitian/4978329
// Content of the generated makefile
wxString content = wxString() << "# Generated by CMakePlugin\n"
".PHONY: all clean $(MAKECMDGOALS)\n"
"\n";
// Parent project is set
if(!settings->parentProject.IsEmpty()) {
// Configure parent project instead
const wxString& parentProject = settings->parentProject;
settings = GetSettingsManager()->GetProjectSettings(parentProject, config);
// Parent project not found
if(!settings || !settings->enabled) {
CL_ERROR("Unable to find or not enabled parent project "
"'" +
parentProject + "' for project '" + project + "'");
return;
}
// Get parent project directory
wxFileName parentProjectDir = GetProjectDirectory(parentProject);
parentProjectDir.MakeRelativeTo(projectDir.GetFullPath());
// Path is relative so UNIX path system can be used
const wxString parentProjectDirEsc = parentProjectDir.GetPath(wxPATH_NO_SEPARATOR, wxPATH_UNIX);
// Redirect make to the parent project
content << "# Parent project\n"
"PARENT := " << parentProjectDirEsc << "\n"
"PARENT_MAKEFILE := " << parentProject
<< ".mk\n"
"\n"
"all:\n"
"\t$(MAKE) -C \"$(PARENT)\" -f \"$(PARENT_MAKEFILE)\" " << project
<< "\n"
"\n"
"clean:\n"
"\t$(MAKE) -C \"$(PARENT)\" -f \"$(PARENT_MAKEFILE)\" " << project << " clean\n"
"\n";
} else {
// Macro expander
// FIXME use IMacroManager (unable to find it yet)
MacroManager* macro = MacroManager::Instance();
wxASSERT(macro);
// Get variables
// Expand variables for final project
const wxString cmake = GetConfiguration()->GetProgramPath();
wxFileName sourceDir =
wxFileName::DirName(macro->Expand(settings->sourceDirectory, GetManager(), project, config));
wxFileName buildDir =
wxFileName::DirName(macro->Expand(settings->buildDirectory, GetManager(), project, config));
// Source dir must be relative to build directory (here is cmake called)
sourceDir.MakeRelativeTo(buildDir.GetFullPath());
// Build dir must be relative to project directory
buildDir.MakeRelativeTo(projectDir.GetFullPath());
// Relative paths
const wxString sourceDirEsc = sourceDir.GetPath(wxPATH_NO_SEPARATOR, wxPATH_UNIX);
const wxString buildDirEsc = buildDir.GetPath(wxPATH_NO_SEPARATOR, wxPATH_UNIX);
// Generated makefile
content << "CMAKE := \"" << cmake << "\"\n"
"BUILD_DIR := " << buildDirEsc << "\n"
"SOURCE_DIR := " << sourceDirEsc
<< "\n"
"CMAKE_ARGS := " << CreateArguments(*settings, *m_configuration)
<< "\n"
"\n"
"# Building project(s)\n"
"$(or $(lastword $(MAKECMDGOALS)), all): $(BUILD_DIR)/Makefile\n"
"\t$(MAKE) -C \"$(BUILD_DIR)\" $(MAKECMDGOALS)\n"
"\n"
"# Building directory\n"
"$(BUILD_DIR):\n"
"\t$(CMAKE) -E make_directory \"$(BUILD_DIR)\"\n"
"\n"
"# Rule that detects if cmake is called\n"
"$(BUILD_DIR)/Makefile: .cmake_dirty | $(BUILD_DIR)\n"
"\tcd \"$(BUILD_DIR)\" && $(CMAKE) $(CMAKE_ARGS) \"$(SOURCE_DIR)\"\n"
"\n"
"# This rule / file allows force cmake run\n"
".cmake_dirty:\n"
"\t@echo '' > .cmake_dirty\n"
"\n";
}
// Path to makefile - called project directory required
wxFileName makefile = projectDir;
makefile.SetName(project);
makefile.SetExt("mk");
// Read old content from disk
wxString oldContent;
bool ok = ReadFileWithConversion(makefile.GetFullPath(), oldContent);
// Write only if there are some changes
if(!ok || content != oldContent) {
// Write make file content
wxFile file(makefile.GetFullPath(), wxFile::write);
if(!file.Write(content)) {
CL_ERROR("Unable to write custom makefile (CMakePlugin): " + makefile.GetFullPath());
}
}
}
void UpdateModificationTime() { m_mod_time = m_file_name.GetModificationTime(); }
//~~ void RunMake(const AdeConfiguration& configuration, const wxString& target) [AstadeFrame] ~~
wxConfigBase* theConfig = wxConfigBase::Get();
wxFileName make(theConfig->Read(wxS("Tools/Make")));
wxFileName configurationPath = configuration.GetFileName();
configurationPath.MakeAbsolute();
wxFileName componentPath = configuration.GetFileName();
componentPath.MakeAbsolute();
componentPath.RemoveLastDir();
AdeComponent* component = dynamic_cast<AdeComponent*>(AdeModelElement::CreateNewElement(componentPath));
assert(component);
wxString command = make.GetFullPath() + wxS(" -C \"") +
configurationPath.GetPath() +
wxS("\" ") +
wxS("\"TRACECLASSES=") + GetTraceClassList() + wxS("\" \"TARGET=") +
component->GetLabel() +
wxS("\" ") + target;
delete component;
assert(myMakeOutput);
myMakeOutput->SetNormalStyle();
myMakeOutput->TheEdit()->Clear();
*(myMakeOutput->TheEdit()) << wxS("make started ... \n");
myMakeOutput->SetactiveConfiguration(configurationPath);
myMakeOutput->Show();
myMakeOutput->Maximize(false); //true, maximizes the window, otherwise it restores it.
wxString GetPath() const { return m_lib_path.GetPath(); }
AVSValue AvisynthVideoProvider::Open(wxFileName const& fname, wxString const& extension) {
IScriptEnvironment *env = avs.GetEnv();
char *videoFilename = env->SaveString(fname.GetShortPath().mb_str(csConvLocal));
// Avisynth file, just import it
if (extension == ".avs") {
LOG_I("avisynth/video") << "Opening .avs file with Import";
decoderName = "Avisynth/Import";
return env->Invoke("Import", videoFilename);
}
// Open avi file with AviSource
if (extension == ".avi") {
LOG_I("avisynth/video") << "Opening .avi file with AviSource";
try {
const char *argnames[2] = { 0, "audio" };
AVSValue args[2] = { videoFilename, false };
decoderName = "Avisynth/AviSource";
return env->Invoke("AviSource", AVSValue(args,2), argnames);
}
// On Failure, fallback to DSS
catch (AvisynthError &err) {
LOG_E("avisynth/video") << err.msg;
LOG_I("avisynth/video") << "Failed to open .avi file with AviSource, trying DirectShowSource";
}
}
// Open d2v with mpeg2dec3
if (extension == ".d2v" && env->FunctionExists("Mpeg2Dec3_Mpeg2Source")) {
LOG_I("avisynth/video") << "Opening .d2v file with Mpeg2Dec3_Mpeg2Source";
AVSValue script = env->Invoke("Mpeg2Dec3_Mpeg2Source", videoFilename);
decoderName = "Avisynth/Mpeg2Dec3_Mpeg2Source";
//if avisynth is 2.5.7 beta 2 or newer old mpeg2decs will crash without this
if (env->FunctionExists("SetPlanarLegacyAlignment")) {
AVSValue args[2] = { script, true };
script = env->Invoke("SetPlanarLegacyAlignment", AVSValue(args,2));
}
return script;
}
// If that fails, try opening it with DGDecode
if (extension == ".d2v" && env->FunctionExists("DGDecode_Mpeg2Source")) {
LOG_I("avisynth/video") << "Opening .d2v file with DGDecode_Mpeg2Source";
decoderName = "DGDecode_Mpeg2Source";
return env->Invoke("Avisynth/Mpeg2Source", videoFilename);
//note that DGDecode will also have issues like if the version is too
// ancient but no sane person would use that anyway
}
if (extension == ".d2v" && env->FunctionExists("Mpeg2Source")) {
LOG_I("avisynth/video") << "Opening .d2v file with other Mpeg2Source";
AVSValue script = env->Invoke("Mpeg2Source", videoFilename);
decoderName = "Avisynth/Mpeg2Source";
//if avisynth is 2.5.7 beta 2 or newer old mpeg2decs will crash without this
if (env->FunctionExists("SetPlanarLegacyAlignment"))
script = env->Invoke("SetPlanarLegacyAlignment", script);
return script;
}
// Try loading DirectShowSource2
if (!env->FunctionExists("dss2")) {
wxFileName dss2path(StandardPaths::DecodePath("?data/avss.dll"));
if (dss2path.FileExists()) {
env->Invoke("LoadPlugin", env->SaveString(dss2path.GetFullPath().mb_str(csConvLocal)));
}
}
// If DSS2 loaded properly, try using it
if (env->FunctionExists("dss2")) {
LOG_I("avisynth/video") << "Opening file with DSS2";
decoderName = "Avisynth/DSS2";
return env->Invoke("DSS2", videoFilename);
}
// Try DirectShowSource
// Load DirectShowSource.dll from app dir if it exists
wxFileName dsspath(StandardPaths::DecodePath("?data/DirectShowSource.dll"));
if (dsspath.FileExists()) {
env->Invoke("LoadPlugin",env->SaveString(dsspath.GetFullPath().mb_str(csConvLocal)));
}
// Then try using DSS
if (env->FunctionExists("DirectShowSource")) {
const char *argnames[3] = { 0, "video", "audio" };
AVSValue args[3] = { videoFilename, true, false };
decoderName = "Avisynth/DirectShowSource";
warning = "Warning! The file is being opened using Avisynth's DirectShowSource, which has unreliable seeking. Frame numbers might not match the real number. PROCEED AT YOUR OWN RISK!";
LOG_I("avisynth/video") << "Opening file with DirectShowSource";
return env->Invoke("DirectShowSource", AVSValue(args,3), argnames);
}
// Failed to find a suitable function
LOG_E("avisynth/video") << "DSS function not found";
throw VideoNotSupported("No function suitable for opening the video found");
}
bool IsWritable() const { return m_lib_path.IsOk() && m_lib_path.IsDirWritable(); }
bool PHPProject::HasFile(const wxFileName& filename) const
{
return filename.GetFullPath().StartsWith(GetFilename().GetPath());
}
bool DirManager::EnsureSafeFilename(wxFileName fName)
{
// Quick check: If it's not even in our alias list,
// then the file name is A-OK.
#if 0
printf("file name: %s\n", fName.GetFullPath().c_str());
printf("string list:\n");
wxStringListNode *node = aliasList.GetFirst();
while (node)
{
wxString string = node->GetData();
printf("%s\n", string.c_str());
node = node->GetNext();
}
#endif
if (!aliasList.Member(fName.GetFullPath()))
return true;
// If any of the following commands fail, your guess is as
// good as mine why. The following error message is the
// best we can do - we'll use it if any of the renames,
// creates, or deletes fail.
wxString errStr =
_( "Error: is directory write-protected or disk full?" );
/* i18n-hint: 'old' is part of a filename used when a file is renamed. */
// Figure out what the new name for the existing file would be.
/* i18n-hint: e.g. Try to go from "mysong.wav" to "mysong-old1.wav". */
// Keep trying until we find a filename that doesn't exist.
wxFileName renamedFile = fName;
int i = 0;
do {
i++;
/* i18n-hint: This is the pattern for filenames that are created
when a file needs to be backed up to a different name. For
example, mysong would become mysong-old1, mysong-old2, etc. */
renamedFile.SetName(wxString::Format(_("%s-old%d"), fName.GetName().c_str(), i));
} while (wxFileExists(FILENAME(renamedFile.GetFullPath())));
// Test creating a file by that name to make sure it will
// be possible to do the rename
wxFile testFile(FILENAME(renamedFile.GetFullPath()), wxFile::write);
if (!testFile.IsOpened()) {
wxMessageBox(errStr);
return false;
}
if (!wxRemoveFile(FILENAME(renamedFile.GetFullPath()))) {
wxMessageBox(errStr);
return false;
}
printf(_("Renamed file: %s\n"), (const char *)renamedFile.GetFullPath());
// Go through our block files and see if any indeed point to
// the file we're concerned about. If so, point the block file
// to the renamed file and when we're done, perform the rename.
bool needToRename = false;
wxBusyCursor busy;
blockFileHash->BeginFind();
wxNode *n = blockFileHash->Next();
while(n) {
BlockFile *b = (BlockFile *)n->GetData();
// don't worry, we don't rely on this cast unless IsAlias is true
AliasBlockFile *ab = (AliasBlockFile*)b;
if (b->IsAlias() && ab->GetAliasedFile() == fName) {
needToRename = true;
printf(_("Changing block %s\n"), (const char *)b->GetFileName().GetFullName());
ab->ChangeAliasedFile(renamedFile);
}
n = blockFileHash->Next();
}
if (needToRename) {
if (!wxRenameFile(FILENAME(fName.GetFullPath()),
FILENAME(renamedFile.GetFullPath()))) {
// ACK!!! The renaming was unsuccessful!!!
// (This shouldn't happen, since we tried creating a
// file of this name and then deleted it just a
// second earlier.) But we'll handle this scenario
// just in case!!!
// Put things back where they were
blockFileHash->BeginFind();
n = blockFileHash->Next();
while(n) {
BlockFile *b = (BlockFile *)n->GetData();
AliasBlockFile *ab = (AliasBlockFile*)b;
if (b->IsAlias() && ab->GetAliasedFile() == renamedFile)
ab->ChangeAliasedFile(fName);
n = blockFileHash->Next();
}
// Print error message and cancel the export
wxMessageBox(errStr);
return false;
}
aliasList.Delete(fName.GetFullPath());
aliasList.Add(renamedFile.GetFullPath());
}
// Success!!! Either we successfully renamed the file,
// or we didn't need to!
return true;
}
/// Constructs a SimpleBlockFile based on sample data and writes
/// it to disk.
///
/// @param baseFileName The filename to use, but without an extension.
/// This constructor will add the appropriate
/// extension (.au in this case).
/// @param sampleData The sample data to be written to this block.
/// @param sampleLen The number of samples to be written to this block.
/// @param format The format of the given samples.
SimpleBlockFile::SimpleBlockFile(wxFileName baseFileName,
samplePtr sampleData, sampleCount sampleLen,
sampleFormat format):
BlockFile(wxFileName(baseFileName.GetFullPath() + ".au"), sampleLen)
{
wxASSERT( !mFileName.FileExists() );
// Open and write the file
wxFFile file;
if( !file.Open((const wxChar *) mFileName.GetFullPath(), "wb") )
// Throw an exception?
return;
auHeader header;
// AU files can be either big or little endian. Which it is is
// determined implicitly by the byte-order of the magic 0x2e736e64
// (.snd). We want it to be native-endian, so we write the magic
// to memory and then let it write that to a file in native
// endianness
header.magic = 0x2e736e64;
// We store the summary data at the end of the header, so the data
// offset is the length of the summary data plus the length of the header
header.dataOffset = sizeof(auHeader) + mSummaryInfo.totalSummaryBytes;
// dataSize is optional, and we opt out
header.dataSize = 0xffffffff;
switch(format) {
case int16Sample:
header.encoding = AU_SAMPLE_FORMAT_16;
break;
case int24Sample:
header.encoding = AU_SAMPLE_FORMAT_24;
break;
case floatSample:
header.encoding = AU_SAMPLE_FORMAT_FLOAT;
break;
}
// TODO: don't fabricate
header.sampleRate = 44100;
// BlockFiles are always mono
header.channels = 1;
// Write the file
void *summaryData = BlockFile::CalcSummary(sampleData, sampleLen, format);
file.Write(&header, sizeof(header));
file.Write(summaryData, mSummaryInfo.totalSummaryBytes);
if( format == int24Sample )
{
// we can't write the buffer directly to disk, because 24-bit samples
// on disk need to be packed, not padded to 32 bits like they are in
// memory
int *int24sampleData = (int*)sampleData;
for( int i = 0; i < sampleLen; i++ )
#if wxBYTE_ORDER == wxBIG_ENDIAN
file.Write((char*)&int24sampleData[i] + 1, 3);
#else
file.Write((char*)&int24sampleData[i], 3);
#endif
}
else
{
// for all other sample formats we can write straight from the buffer
// to disk
file.Write(sampleData, sampleLen * SAMPLE_SIZE(format));
}
}
wxString xsDirNamePropIO::ToString(const wxFileName& value)
{
return value.GetPath();
}
bool PluginManager::ClosePage(const wxFileName& filename)
{
MainBook* book = clMainFrame::Get()->GetMainBook();
LEditor* editor = book->FindEditor(filename.GetFullPath());
return clMainFrame::Get()->GetMainBook()->ClosePage(editor);
}
//~~ void OmdViewPathBrowse(wxCommandEvent& event) [AstadeDirDialog] ~~
wxConfigBase* theConfig = wxConfigBase::Get();
wxFileName theFileName(theConfig->Read(wxS("Tools/OmdViewPath")));
const wxString& dir = wxFileSelector(wxS("Set OMD viewer"), theFileName.GetPath(), theFileName.GetFullName(), wxEmptyString, wxS("*"), 0, this);
wxFileName filename(dir);
if (!dir.empty())
omdPathTextControl->SetValue(filename.GetFullPath());
void EDA_BASE_FRAME::CheckForAutoSaveFile( const wxFileName& aFileName,
const wxString& aBackupFileExtension )
{
wxCHECK_RET( aFileName.IsOk(), wxT( "Invalid file name!" ) );
wxCHECK_RET( !aBackupFileExtension.IsEmpty(), wxT( "Invalid backup file extension!" ) );
wxFileName autoSaveFileName = aFileName;
// Check for auto save file.
autoSaveFileName.SetName( AUTOSAVE_PREFIX_FILENAME + aFileName.GetName() );
wxLogTrace( traceAutoSave,
wxT( "Checking for auto save file " ) + autoSaveFileName.GetFullPath() );
if( !autoSaveFileName.FileExists() )
return;
wxString msg = wxString::Format( _(
"Well this is potentially embarrassing!\n"
"It appears that the last time you were editing the file\n"
"'%s'\n"
"it was not saved properly. Do you wish to restore the last saved edits you made?" ),
GetChars( aFileName.GetFullName() )
);
int response = wxMessageBox( msg, Pgm().App().GetAppName(), wxYES_NO | wxICON_QUESTION, this );
// Make a backup of the current file, delete the file, and rename the auto save file to
// the file name.
if( response == wxYES )
{
// Get the backup file name.
wxFileName backupFileName = aFileName;
backupFileName.SetExt( aBackupFileExtension );
// If an old backup file exists, delete it. If an old copy of the file exists, rename
// it to the backup file name
if( aFileName.FileExists() )
{
// Remove the old file backup file.
if( backupFileName.FileExists() )
wxRemoveFile( backupFileName.GetFullPath() );
// Rename the old file to the backup file name.
if( !wxRenameFile( aFileName.GetFullPath(), backupFileName.GetFullPath() ) )
{
msg.Printf( _( "Could not create backup file <%s>" ),
GetChars( backupFileName.GetFullPath() ) );
wxMessageBox( msg );
}
}
if( !wxRenameFile( autoSaveFileName.GetFullPath(), aFileName.GetFullPath() ) )
{
wxMessageBox( _( "The auto save file could not be renamed to the board file name." ),
Pgm().App().GetAppName(), wxOK | wxICON_EXCLAMATION, this );
}
}
else
{
wxLogTrace( traceAutoSave,
wxT( "Removing auto save file " ) + autoSaveFileName.GetFullPath() );
// Remove the auto save file when using the previous file as is.
wxRemoveFile( autoSaveFileName.GetFullPath() );
}
}
void EDA_3D_CANVAS::TakeScreenshot( wxCommandEvent& event )
{
static wxFileName fn; // Remember path between saves during this session only.
wxString FullFileName;
wxString file_ext, mask;
bool fmt_is_jpeg = false;
// First time path is set to the project path.
if( !fn.IsOk() )
fn = Parent()->Prj().GetProjectFullName();
if( event.GetId() == ID_MENU_SCREENCOPY_JPEG )
fmt_is_jpeg = true;
if( event.GetId() != ID_TOOL_SCREENCOPY_TOCLIBBOARD )
{
file_ext = fmt_is_jpeg ? wxT( "jpg" ) : wxT( "png" );
mask = wxT( "*." ) + file_ext;
fn.SetExt( file_ext );
FullFileName = EDA_FILE_SELECTOR( _( "3D Image File Name:" ), fn.GetPath(),
fn.GetFullName(), file_ext, mask, this,
wxFD_SAVE | wxFD_OVERWRITE_PROMPT, true );
if( FullFileName.IsEmpty() )
return;
fn = FullFileName;
// Be sure the screen area destroyed by the file dialog is redrawn before making
// a screen copy.
// Without this call, under Linux the screen refresh is made to late.
wxYield();
}
struct viewport_params
{
GLint originx;
GLint originy;
GLint x;
GLint y;
} viewport;
// Be sure we have the latest 3D view (remember 3D view is buffered)
Refresh();
wxYield();
// Build image from the 3D buffer
wxWindowUpdateLocker noUpdates( this );
glGetIntegerv( GL_VIEWPORT, (GLint*) &viewport );
unsigned char* pixelbuffer = (unsigned char*) malloc( viewport.x * viewport.y * 3 );
unsigned char* alphabuffer = (unsigned char*) malloc( viewport.x * viewport.y );
wxImage image( viewport.x, viewport.y );
glPixelStorei( GL_PACK_ALIGNMENT, 1 );
glReadBuffer( GL_BACK_LEFT );
glReadPixels( viewport.originx, viewport.originy,
viewport.x, viewport.y,
GL_RGB, GL_UNSIGNED_BYTE, pixelbuffer );
glReadPixels( viewport.originx, viewport.originy,
viewport.x, viewport.y,
GL_ALPHA, GL_UNSIGNED_BYTE, alphabuffer );
image.SetData( pixelbuffer );
image.SetAlpha( alphabuffer );
image = image.Mirror( false );
wxBitmap bitmap( image );
if( event.GetId() == ID_TOOL_SCREENCOPY_TOCLIBBOARD )
{
if( wxTheClipboard->Open() )
{
wxBitmapDataObject* dobjBmp = new wxBitmapDataObject( bitmap );
if( !wxTheClipboard->SetData( dobjBmp ) )
wxMessageBox( _( "Failed to copy image to clipboard" ) );
wxTheClipboard->Flush(); /* the data in clipboard will stay
* available after the application exits */
wxTheClipboard->Close();
}
}
else
{
wxImage image = bitmap.ConvertToImage();
if( !image.SaveFile( FullFileName,
fmt_is_jpeg ? wxBITMAP_TYPE_JPEG : wxBITMAP_TYPE_PNG ) )
wxMessageBox( _( "Can't save file" ) );
image.Destroy();
}
}
//~~ void doH() [CGenerator] ~~
target.SetExt(wxS("h"));
std::ofstream out(target.GetFullPath().utf8_str());
wxFileName PrefixName(myAdeComponent->GetFileName());
PrefixName.SetFullName(wxS("prolog.h"));
wxTextFile Gprefixtext(PrefixName.GetFullPath());
if (Gprefixtext.Exists())
Gprefixtext.Open();
if (Gprefixtext.IsOpened() && Gprefixtext.GetLineCount() > 0)
{
wxString str;
for (str = Gprefixtext.GetFirstLine(); !Gprefixtext.Eof(); str = Gprefixtext.GetNextLine())
out << str.utf8_str() << std::endl;
if (!str.empty())
out << str.utf8_str() << std::endl;
out << std::endl;
}
PrintHeader(out);
wxString defname(target.GetFullName());
defname.MakeUpper();
defname.Replace(wxS("."), wxS("_"));
out << "#ifndef __" << defname.utf8_str() << std::endl;
out << "# define __" << defname.utf8_str() << std::endl;
out << std::endl;
PrefixName = source->GetFileName();
bool wxFileDialog::Create(wxWindow *parent, const wxString& message,
const wxString& defaultDir,
const wxString& defaultFileName,
const wxString& wildCard,
long style, const wxPoint& pos,
const wxSize& sz,
const wxString& name)
{
parent = GetParentForModalDialog(parent, style);
if (!wxFileDialogBase::Create(parent, message, defaultDir, defaultFileName,
wildCard, style, pos, sz, name))
{
return false;
}
if (!PreCreation(parent, pos, wxDefaultSize) ||
!CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style,
wxDefaultValidator, wxT("filedialog")))
{
wxFAIL_MSG( wxT("wxFileDialog creation failed") );
return false;
}
GtkFileChooserAction gtk_action;
GtkWindow* gtk_parent = NULL;
if (parent)
gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) );
const gchar* ok_btn_stock;
if ( style & wxFD_SAVE )
{
gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE;
ok_btn_stock = GTK_STOCK_SAVE;
}
else
{
gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN;
ok_btn_stock = GTK_STOCK_OPEN;
}
m_widget = gtk_file_chooser_dialog_new(
wxGTK_CONV(m_message),
gtk_parent,
gtk_action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
ok_btn_stock, GTK_RESPONSE_ACCEPT,
NULL);
g_object_ref(m_widget);
GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget);
m_fc.SetWidget(file_chooser);
gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT);
if ( style & wxFD_MULTIPLE )
gtk_file_chooser_set_select_multiple(file_chooser, true);
// local-only property could be set to false to allow non-local files to be
// loaded. In that case get/set_uri(s) should be used instead of
// get/set_filename(s) everywhere and the GtkFileChooserDialog should
// probably also be created with a backend, e.g. "gnome-vfs", "default", ...
// (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept
// as the default - true:
// gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);
g_signal_connect (m_widget, "response",
G_CALLBACK (gtk_filedialog_response_callback), this);
g_signal_connect (m_widget, "selection-changed",
G_CALLBACK (gtk_filedialog_selchanged_callback), this);
// deal with extensions/filters
SetWildcard(wildCard);
wxString defaultFileNameWithExt = defaultFileName;
if ( !wildCard.empty() && !defaultFileName.empty() &&
!wxFileName(defaultFileName).HasExt() )
{
// append the default extension, if any, to the initial file name: GTK
// won't do it for us by default (unlike e.g. MSW)
const wxFileName fnWC(m_fc.GetCurrentWildCard());
if ( fnWC.HasExt() )
{
// Notice that we shouldn't append the extension if it's a wildcard
// because this is not useful: the user would need to change it to use
// some fixed extension anyhow.
const wxString& ext = fnWC.GetExt();
if ( ext.find_first_of("?*") == wxString::npos )
defaultFileNameWithExt << "." << ext;
}
}
// if defaultDir is specified it should contain the directory and
// defaultFileName should contain the default name of the file, however if
// directory is not given, defaultFileName contains both
wxFileName fn;
if ( defaultDir.empty() )
fn.Assign(defaultFileNameWithExt);
else if ( !defaultFileNameWithExt.empty() )
fn.Assign(defaultDir, defaultFileNameWithExt);
else
fn.AssignDir(defaultDir);
// set the initial file name and/or directory
fn.MakeAbsolute(); // GTK+ needs absolute path
const wxString dir = fn.GetPath();
if ( !dir.empty() )
{
gtk_file_chooser_set_current_folder(file_chooser, wxGTK_CONV_FN(dir));
}
const wxString fname = fn.GetFullName();
if ( style & wxFD_SAVE )
{
if ( !fname.empty() )
{
gtk_file_chooser_set_current_name(file_chooser, wxGTK_CONV_FN(fname));
}
#if GTK_CHECK_VERSION(2,7,3)
if ((style & wxFD_OVERWRITE_PROMPT)
#ifndef __WXGTK3__
&& gtk_check_version(2,7,3) == NULL
#endif
)
{
gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true);
}
#endif
}
else // wxFD_OPEN
{
if ( !fname.empty() )
{
gtk_file_chooser_set_filename(file_chooser,
wxGTK_CONV_FN(fn.GetFullPath()));
}
}
if ( style & wxFD_PREVIEW )
{
GtkWidget *previewImage = gtk_image_new();
gtk_file_chooser_set_preview_widget(file_chooser, previewImage);
g_signal_connect(m_widget, "update-preview",
G_CALLBACK(gtk_filedialog_update_preview_callback),
previewImage);
}
return true;
}