void MainWindow::loadSettings()
{
QVariant geometry = m_settings.value(QString::fromAscii("main/geometry"), QVariant::Invalid);
QVariant state = m_settings.value(QString::fromAscii("main/state"), QVariant::Invalid);
QVariant wizState = m_settings.value(QString::fromAscii("wizard/state"), QVariant::Invalid);
QVariant loadSettings = m_settings.value(QString::fromAscii("wizard/loadsettings"), QVariant::Invalid);
QVariant workingDir = m_settings.value(QString::fromAscii("wizard/workingdir"), QVariant::Invalid);
if (geometry !=QVariant::Invalid) restoreGeometry(geometry.toByteArray());
if (state !=QVariant::Invalid) restoreState (state.toByteArray());
if (wizState !=QVariant::Invalid) m_wizard->restoreState(wizState.toByteArray());
if (loadSettings!=QVariant::Invalid && loadSettings.toBool())
{
m_expert->loadSettings(&m_settings);
if (workingDir!=QVariant::Invalid && QDir(workingDir.toString()).exists())
{
setWorkingDir(workingDir.toString());
}
}
for (int i=0;i<MAX_RECENT_FILES;i++)
{
QString entry = m_settings.value(QString().sprintf("recent/config%d",i)).toString();
if (!entry.isEmpty() && QFileInfo(entry).exists())
{
addRecentFile(entry);
}
}
}
void MainWindow::openSingleFile(const Location& loc)
{
if (!loc.isDirectory())
{
BaseFile* file;
try
{
file = Location(loc).getFile();
}
catch(QString &e)
{
QLOG_ERROR() << "Error opening a single file" << loc.getPath() << ": " << e;
return;
}
if (file->isClosed())
file->open();
gWindowManager->displayFile(file);
gDispatcher->emitSelectFile(file);
addRecentFile(loc);
connect(file, SIGNAL(openStatusChanged(int)), this, SLOT(updateTitle()));
connect(file, SIGNAL(unsavedStatusChanged()), this, SLOT(updateTitle()));
}
void MainWindow::setProject()
{
QString shortname, filename;
int index = ui.editorTabs->currentIndex();
if (index > -1)
{
shortname = ui.editorTabs->tabText(index);
filename = ui.editorTabs->tabToolTip(index);
}
if (ui.editorTabs->count() > 0)
setWindowTitle(shortname + " - " +
QCoreApplication::applicationName());
else
setWindowTitle(QCoreApplication::applicationName());
addRecentFile(filename);
language.loadExtension(QFileInfo(filename).suffix());
parser = language.parser();
parser->setFile(filename);
parser->setLibraryPaths(spinIncludes);
recolorProjectView();
}
void MainWindow::openFile(QString fileName)
{
for(QMap<int, QTextEdit*>::const_iterator i = textEdits.constBegin();i != textEdits.constEnd();++i)
{
if(i.value()->windowFilePath()==fileName)
{
ui->tabWidget->setCurrentIndex(i.key());
return;
}
}
if(currentTextEdit() && currentTextEdit()->windowFilePath()=="" && !(currentTextEdit()->document()->isModified()) && ui->tabWidget->count()==1) on_actionFermer_triggered();
QTextEdit* textEdit=new QTextEdit();
textEdit->setWindowFilePath(fileName);
QFile file(fileName);
file.open(QIODevice::ReadOnly);
QTextStream textStream(&file);
QString content="";
content=textStream.readAll();
textEdit->setPlainText(content);
textEdit->document()->setModified(false);
int index=ui->tabWidget->addTab(textEdit,veryReducedFileName(fileName));
textEdits[index]=textEdit;
ui->tabWidget->setCurrentIndex(index);
addRecentFile();
}
bool MainWindow::saveAs() {
if (tabWidget->count()) {
QString fileName = QFileDialog::getSaveFileName(this, "Save - QSciTE", (openFiles.size() > 0 && !getCurFileObj()->path.isEmpty()) ? getCurFileObj()->path : lastDir);
if (fileName.isEmpty()) {
return false;
}
bool success = saveFile(fileName);
if (success) {
addRecentFile(fileName);
getCurFileObj()->setPathName(fileName);
setCurrentTabTitle();
setWindowTitleForFile(getCurFileObj()->baseName);
lastDir = getCurFileObj()->path;
QsciteEditor * curDoc = getCurDoc();
QsciLexer * newLexer = getLexerForDocument(fileName, curDoc->text());
if (newLexer != NULL) {
/*
QFont curFont = curDoc->font();
setLexerFont(newLexer, curFont.family(), curFont.pointSize());
newLexer->setParent(curDoc);
curDoc->setLexer(newLexer);
curDoc->recolor();
*/
setLexer(newLexer);
}
}
return success;
}
return false;
}
bool ComicModel::open(const QString &fileUrl)
{
if (m_currentFilename != "") {
close();
}
QUrl url(fileUrl);
std::shared_ptr<QuaZip> zip(new QuaZip(url.toLocalFile()));
zip->setFileNameCodec("Shift-JIS");
bool result = zip->open(QuaZip::mdUnzip);
if (result) {
int pageCount;
if (parseZip("", zip, pageCount)) {
setErrorMessage();
addRecentFile(url.toLocalFile());
m_currentFilename = url.toLocalFile();
emit currentFilenameChanged(m_currentFilename);
emit maxPageChanged(m_list.size());
QSettings settings;
QString key = QString(RECENTPAGE_KEY).arg(m_currentFilename);
int page = settings.value(key, 1).toInt();
setCurrentPage(page);
} else {
setErrorMessage("zip file is empty.");
}
} else {
setErrorMessage("open file error.");
}
return result;
}
void MainWindow::saveFile()
{
QFile file(currentTextEdit()->windowFilePath());
file.open(QIODevice::WriteOnly);
QTextStream textStream(&file);
textStream<<currentTextEdit()->toPlainText();
currentTextEdit()->document()->setModified(false);
addRecentFile();
}
void RecentFileMenu::setRecentFiles( QStringList filenames )
{
clear();
for( QString filename : filenames )
{
if ( filename != "" ) {
addRecentFile( filename );
}
}
}
void StPlayList::currentToRecent() {
StMutexAuto anAutoLock(myMutex);
if( myCurrent == NULL
|| !myPlsFile.isNull()) {
return;
}
StHandle<StPlayList::StRecentItem> aRecent = addRecentFile(*myCurrent->getFileNode());
aRecent->Params = myCurrent->getParams();
}
void GLShaderDev::openFile(const QString& filename)
{
if (filename.isEmpty())
return;
QFileInfo file(filename);
if (_editor->openFile(file.absoluteFilePath()))
addRecentFile(file.absoluteFilePath());
}
// -----------------------------------------------------------------------------
// Opens [dir] as a DirArchive and adds it to the list.
// Returns a pointer to the archive or nullptr if an error occurred.
// -----------------------------------------------------------------------------
Archive* ArchiveManager::openDirArchive(const string& dir, bool manage, bool silent)
{
auto new_archive = getArchive(dir);
LOG_MESSAGE(1, "Opening directory %s as archive", dir);
// If the archive is already open, just return it
if (new_archive)
{
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
return new_archive;
}
new_archive = new DirArchive();
// If it opened successfully, add it to the list if needed & return it,
// Otherwise, delete it and return nullptr
if (new_archive->open(dir))
{
if (manage)
{
// Add the archive
addArchive(new_archive);
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
// Add to recent files
addRecentFile(dir);
}
// Return the opened archive
return new_archive;
}
else
{
LOG_MESSAGE(1, "Error: " + Global::error);
delete new_archive;
return nullptr;
}
}
void MainWindow::openMindMap()
{
m_currentMindMapPath = QFileDialog::getOpenFileName(this, tr("Open Mind Map"), m_preferences->value("MindMapDirectory",QDir::homePath()).toString(), tr("Rolisteam Mind Map (*.rmap *.txt)"));
if(!m_currentMindMapPath.isNull())
{
if(m_currentMindMapPath.endsWith(".rmap"))
{
readFile();
addRecentFile();
updateTitle();
}
else if(m_currentMindMapPath.endsWith(".txt"))
{
readFileText();
addRecentFile();
updateTitle();
}
}
}
void MainWindow::updateConfigFileName(const QString &fileName)
{
if (m_fileName!=fileName)
{
m_fileName = fileName;
QString curPath = QFileInfo(fileName).path();
setWorkingDir(curPath);
addRecentFile(fileName);
updateTitle();
}
}
void StPlayList::loadRecentList(const StString theString) {
StMutexAuto anAutoLock(myMutex);
StArgumentsMap aMap;
aMap.parseString(theString);
myRecent.clear();
for(size_t anIter = 0; anIter < myRecentLimit; ++anIter) {
const StArgument anArgFile = aMap[StString("file") + anIter];
const StArgument anArgLeft = aMap[StString("left") + anIter];
const StArgument anArgRight = aMap[StString("right") + anIter];
const StArgument anArgTime = aMap[StString("time") + anIter];
StHandle<StRecentItem> aRecent;
if(anArgLeft.isValid() && anArgRight.isValid()) {
StHandle<StFileNode> aFileNode = new StFileNode(StString());
aFileNode->add(new StFileNode(anArgLeft.getValue(), aFileNode.access()));
aFileNode->add(new StFileNode(anArgRight.getValue(), aFileNode.access()));
aRecent = addRecentFile(*aFileNode, false);
} else if(anArgFile.isValid()) {
StHandle<StFileNode> aFileNode = new StFileNode(anArgFile.getValue());
const StArgument anArgPos = aMap[StString("pos") + anIter];
if(anArgPos.isValid()) {
aFileNode->add(new StFileNode(anArgPos.getValue(), aFileNode.access()));
}
aRecent = addRecentFile(*aFileNode, false);
}
if(aRecent.isNull()) {
continue;
}
if(anArgTime.isValid()) {
if(aRecent->Params.isNull()) {
aRecent->Params = new StStereoParams();
}
std::stringstream aStream;
aStream.imbue(std::locale("C"));
aStream << anArgTime.getValue().toCString();
aStream >> aRecent->Params->Timestamp;
}
}
}
bool KstApp::openDocumentFile(const QString& in_filename,
const QString& o_file, int o_n, int o_f, int o_s, bool o_ave) {
KURL url;
QFileInfo finfo(in_filename);
bool rc = false;
url.setPath(in_filename);
slotUpdateStatusMsg(i18n("Opening file..."));
if (doc->openDocument(url, o_file, o_n, o_f, o_s, o_ave)) {
setCaption(doc->getTitle());
if (url.isLocalFile()) {
addRecentFile(finfo.absFilePath());
} else {
addRecentFile(url);
}
rc = true;
}
slotUpdateStatusMsg(i18n("Ready"));
view->show();
return rc;
}
void StPlayList::addOneFile(const StString& theFilePath,
const StMIME& theFileMIME) {
StMutexAuto anAutoLock(myMutex);
StFileNode* aFileNode = new StFileNode(theFilePath, &myFoldersRoot);
aFileNode->setMIME(theFileMIME);
myFoldersRoot.add(aFileNode);
addRecentFile(*aFileNode); // append to recent files list
addPlayItem(new StPlayItem(aFileNode, myDefStParams));
anAutoLock.unlock();
signals.onPlaylistChange();
}
void MainWindow::open(QString fileName = QString("")) {
QStringList fileNames;
if (fileName.isEmpty()) {
fileNames = QFileDialog::getOpenFileNames(this, "Select one or more files to open", (openFiles.size() > 0 && !getCurFileObj()->path.isEmpty()) ? getCurFileObj()->path : lastDir);
} else {
fileNames.push_front(fileName);
}
while (fileNames.count()) {
if (!fileNames.back().isEmpty()) {
bool alreadyOpen = false;
QList<QsciteEditor *> openTabs = openFiles.keys();
QList<QsciteEditor *>::iterator tab;
for (tab = openTabs.begin(); tab != openTabs.end(); ++tab) {
if (fileNames.front() == openFiles[*tab].fullName) {
alreadyOpen = true;
if (fileNames.count() == 1) {
changeTabs(*tab);
}
qDebug() << "file is already open";
}
}
if (alreadyOpen) {
fileNames.pop_front();
continue;
}
if ((!tabWidget->count()) || (!getCurFileObj()->baseName.isEmpty()) || getCurDoc()->isModified()) {
createDocument();
}
loadFile(fileNames.front());
setCurrentTabTitle();
addRecentFile(fileNames.front());
}
fileNames.pop_front();
}
if (!openFiles.empty()) {
getCurDoc()->setFocus();
lastDir = getCurFileObj()->path;
}
}
void MainWindow::canvasFileInfoChanged(const QFileInfo& fileinfo)
{
if (fileinfo.fileName().isEmpty())
{
setWindowFilePath(QString());
setWindowTitle("untitled[*] - Dunnart");
}
else
{
addRecentFile(fileinfo.absoluteFilePath());
setWindowFilePath(fileinfo.absoluteFilePath());
setWindowTitle(fileinfo.fileName() + "[*] - Dunnart");
}
}
/**
* Create a query tab and connect it.
*
* @return a new QueryEditorWidget
*/
QueryEditorWidget* MainWindow::newQuery()
{
QueryEditorWidget *w = new QueryEditorWidget();
tabWidget->addTab(w, w->icon(), w->title());
tabWidget->setCurrentIndex(tabWidget->count() - 1);
connect(w, SIGNAL(actionAvailable(AbstractTabWidget::Actions)),
this, SLOT(refreshTab()));
connect(w, SIGNAL(fileChanged(QString)), this, SLOT(addRecentFile(QString)));
connect(w, SIGNAL(modificationChanged(bool)), this, SLOT(refreshTab()));
connect(w, SIGNAL(tableRequested(QSqlDatabase*,QString)),
this, SLOT(openTable(QSqlDatabase*,QString)));
return w;
}
// -----------------------------------------------------------------------------
// Adds a list of recent file paths to the recent file list
// -----------------------------------------------------------------------------
void ArchiveManager::addRecentFiles(vector<string> paths)
{
// Mute annoucements
setMuted(true);
// Clear existing list
recent_files_.clear();
// Add the files
for (const auto& path : paths)
addRecentFile(path);
// Announce
setMuted(false);
announce("recent_files_changed");
}
/* ArchiveManager::addRecentFiles
* Adds a list of recent file paths to the recent file list
*******************************************************************/
void ArchiveManager::addRecentFiles(vector<string> paths)
{
// Mute annoucements
setMuted(true);
// Clear existing list
recent_files.clear();
// Add the files
for (size_t a = 0; a < paths.size(); ++a)
{
addRecentFile(paths[a]);
}
// Announce
setMuted(false);
announce("recent_files_changed");
}
bool MainWindow::loadDiagram(const QString& filename)
{
newCanvasTab();
bool successful = canvas()->loadDiagram(filename);
addRecentFile(filename);
QFileInfo fileinfo(filename);
canvasFileInfoChanged(fileinfo);
view()->postDiagramLoad();
// Cause widget settings values to notice updated preferences
// from the loaded diagram.
m_tab_widget->currentChanged(m_tab_widget->currentIndex());
return successful;
}
void KstApp::slotFileOpen() {
slotUpdateStatusMsg(i18n("Opening file..."));
if(doc->saveModified()) {
QString fileToOpen=
KFileDialog::getOpenFileName("::<kstfiledir>",
i18n("*.kst|Kst Plot File "
"(*.kst)\n*|All Files"),
this, i18n("Open File"));
if(!fileToOpen.isEmpty()) {
doc->openDocument(fileToOpen);
view->update();
setCaption(doc->getTitle());
addRecentFile(fileToOpen);
}
}
slotUpdateStatusMsg(i18n("Ready"));
}
void KstApp::slotFileSaveAs() {
slotUpdateStatusMsg(i18n("Saving file with a new filename..."));
QString newName=
KFileDialog::getSaveFileName(QDir::currentDirPath(),
i18n("*.kst|Kst Plot File (*.kst)\n*|All Files"),
this, i18n("Save As"));
if(!newName.isEmpty()) {
if (doc->saveDocument(newName)) {
addRecentFile(newName);
QFileInfo saveAsInfo(newName);
doc->setTitle(saveAsInfo.fileName());
doc->setAbsFilePath(saveAsInfo.absFilePath());
setCaption(kapp->caption() + ": " + doc->getTitle());
}
}
slotUpdateStatusMsg(i18n("Ready"));
}
void MainWindow2::readSettings()
{
QSettings* settings = pencilSettings();
QRect desktopRect = QApplication::desktop()->screenGeometry();
desktopRect.adjust(80,80,-80,-80);
QPoint pos = settings->value("editorPosition", desktopRect.topLeft() ).toPoint();
QSize size = settings->value("editorSize", desktopRect.size() ).toSize();
move(pos);
resize(size);
editor->restorePalettesSettings(true, true, true);
QString myPath = settings->value("lastFilePath", QVariant(QDir::homePath())).toString();
addRecentFile(myPath);
setOpacity(100 - settings->value("windowOpacity").toInt());
}
void MainWindow::loadSettings()
{
QVariant geometry = m_settings.value(QString::fromAscii("main/geometry"), QVariant::Invalid);
QVariant state = m_settings.value(QString::fromAscii("main/state"), QVariant::Invalid);
QVariant wizState = m_settings.value(QString::fromAscii("wizard/state"), QVariant::Invalid);
QVariant loadSettings = m_settings.value(QString::fromAscii("wizard/loadsettings"), QVariant::Invalid);
if (geometry !=QVariant::Invalid) restoreGeometry(geometry.toByteArray());
if (state !=QVariant::Invalid) restoreState (state.toByteArray());
if (wizState !=QVariant::Invalid) m_wizard->restoreState(wizState.toByteArray());
if (loadSettings!=QVariant::Invalid && loadSettings.toBool())
{
m_expert->loadSettings(&m_settings);
}
for (int i=0;i<10;i++)
{
QString entry = m_settings.value(QString().sprintf("recent/config%d",i)).toString();
if (!entry.isEmpty()) addRecentFile(entry);
}
}
void* Bridge::processMessage(GUIMSG type, void* param1, void* param2)
{
if(dbgStopped) //there can be no more messages if the debugger stopped = BUG
__debugbreak();
switch(type)
{
case GUI_DISASSEMBLE_AT:
emit disassembleAt((int_t)param1, (int_t)param2);
break;
case GUI_SET_DEBUG_STATE:
emit dbgStateChanged((DBGSTATE)(int_t)param1);
break;
case GUI_ADD_MSG_TO_LOG:
emit addMsgToLog(QString((const char*)param1));
break;
case GUI_CLEAR_LOG:
emit clearLog();
break;
case GUI_UPDATE_REGISTER_VIEW:
emit updateRegisters();
break;
case GUI_UPDATE_DISASSEMBLY_VIEW:
emit repaintGui();
break;
case GUI_UPDATE_BREAKPOINTS_VIEW:
emit updateBreakpoints();
break;
case GUI_UPDATE_WINDOW_TITLE:
emit updateWindowTitle(QString((const char*)param1));
break;
case GUI_GET_WINDOW_HANDLE:
return winId;
case GUI_DUMP_AT:
emit dumpAt((int_t)param1);
break;
case GUI_SCRIPT_ADD:
{
BridgeResult result;
emit scriptAdd((int)param1, (const char**)param2);
result.Wait();
}
break;
case GUI_SCRIPT_CLEAR:
emit scriptClear();
break;
case GUI_SCRIPT_SETIP:
emit scriptSetIp((int)param1);
break;
case GUI_SCRIPT_ERROR:
{
BridgeResult result;
emit scriptError((int)param1, QString((const char*)param2));
result.Wait();
}
break;
case GUI_SCRIPT_SETTITLE:
emit scriptSetTitle(QString((const char*)param1));
break;
case GUI_SCRIPT_SETINFOLINE:
emit scriptSetInfoLine((int)param1, QString((const char*)param2));
break;
case GUI_SCRIPT_MESSAGE:
{
BridgeResult result;
emit scriptMessage(QString((const char*)param1));
result.Wait();
}
break;
case GUI_SCRIPT_MSGYN:
{
BridgeResult result;
emit scriptQuestion(QString((const char*)param1));
return (void*)result.Wait();
}
break;
case GUI_SCRIPT_ENABLEHIGHLIGHTING:
emit scriptEnableHighlighting((bool)param1);
break;
case GUI_SYMBOL_UPDATE_MODULE_LIST:
emit updateSymbolList((int)param1, (SYMBOLMODULEINFO*)param2);
break;
case GUI_SYMBOL_LOG_ADD:
emit addMsgToSymbolLog(QString((const char*)param1));
break;
case GUI_SYMBOL_LOG_CLEAR:
emit clearSymbolLog();
break;
case GUI_SYMBOL_SET_PROGRESS:
emit setSymbolProgress((int)param1);
break;
case GUI_REF_ADDCOLUMN:
emit referenceAddColumnAt((int)param1, QString((const char*)param2));
break;
case GUI_REF_SETROWCOUNT:
emit referenceSetRowCount((int_t)param1);
break;
case GUI_REF_GETROWCOUNT:
return (void*)referenceManager->currentReferenceView()->mList->getRowCount();
case GUI_REF_DELETEALLCOLUMNS:
GuiReferenceInitialize("References");
break;
case GUI_REF_SETCELLCONTENT:
{
CELLINFO* info = (CELLINFO*)param1;
emit referenceSetCellContent(info->row, info->col, QString(info->str));
}
break;
case GUI_REF_GETCELLCONTENT:
return (void*)referenceManager->currentReferenceView()->mList->getCellContent((int)param1, (int)param2).toUtf8().constData();
case GUI_REF_RELOADDATA:
emit referenceReloadData();
break;
case GUI_REF_SETSINGLESELECTION:
emit referenceSetSingleSelection((int)param1, (bool)param2);
break;
case GUI_REF_SETPROGRESS:
emit referenceSetProgress((int)param1);
break;
case GUI_REF_SETSEARCHSTARTCOL:
emit referenceSetSearchStartCol((int)param1);
break;
case GUI_REF_INITIALIZE:
{
BridgeResult result;
emit referenceInitialize(QString((const char*)param1));
result.Wait();
}
break;
case GUI_STACK_DUMP_AT:
emit stackDumpAt((uint_t)param1, (uint_t)param2);
break;
case GUI_UPDATE_DUMP_VIEW:
emit updateDump();
break;
case GUI_UPDATE_THREAD_VIEW:
emit updateThreads();
break;
case GUI_UPDATE_MEMORY_VIEW:
emit updateMemory();
break;
case GUI_ADD_RECENT_FILE:
emit addRecentFile(QString((const char*)param1));
break;
case GUI_SET_LAST_EXCEPTION:
emit setLastException((unsigned int)param1);
break;
case GUI_GET_DISASSEMBLY:
{
uint_t parVA = (uint_t)param1;
char* text = (char*)param2;
if(!text || !parVA || !DbgIsDebugging())
return 0;
byte_t wBuffer[16];
if(!DbgMemRead(parVA, wBuffer, 16))
return 0;
QBeaEngine disasm(-1);
Instruction_t instr = disasm.DisassembleAt(wBuffer, 16, 0, 0, parVA);
BeaTokenizer::TokenizeInstruction(&instr.tokens, &instr.disasm, -1);
QList<RichTextPainter::CustomRichText_t> richText;
BeaTokenizer::TokenToRichText(&instr.tokens, &richText, 0);
QString finalInstruction = "";
for(int i = 0; i < richText.size(); i++)
finalInstruction += richText.at(i).text;
strcpy_s(text, GUI_MAX_DISASSEMBLY_SIZE, finalInstruction.toUtf8().constData());
return (void*)1;
}
break;
case GUI_MENU_ADD:
{
BridgeResult result;
emit menuAddMenu((int)param1, QString((const char*)param2));
return (void*)result.Wait();
}
break;
case GUI_MENU_ADD_ENTRY:
{
BridgeResult result;
emit menuAddMenuEntry((int)param1, QString((const char*)param2));
return (void*)result.Wait();
}
break;
case GUI_MENU_ADD_SEPARATOR:
{
BridgeResult result;
emit menuAddSeparator((int)param1);
result.Wait();
}
break;
case GUI_MENU_CLEAR:
{
BridgeResult result;
emit menuClearMenu((int)param1);
result.Wait();
}
break;
case GUI_SELECTION_GET:
{
int hWindow = (int)param1;
SELECTIONDATA* selection = (SELECTIONDATA*)param2;
if(!DbgIsDebugging())
return (void*)false;
BridgeResult result;
switch(hWindow)
{
case GUI_DISASSEMBLY:
emit selectionDisasmGet(selection);
break;
case GUI_DUMP:
emit selectionDumpGet(selection);
break;
case GUI_STACK:
emit selectionStackGet(selection);
break;
default:
return (void*)false;
}
result.Wait();
if(selection->start > selection->end) //swap start and end
{
int_t temp = selection->end;
selection->end = selection->start;
selection->start = temp;
}
return (void*)true;
}
break;
case GUI_SELECTION_SET:
{
int hWindow = (int)param1;
const SELECTIONDATA* selection = (const SELECTIONDATA*)param2;
if(!DbgIsDebugging())
return (void*)false;
BridgeResult result;
switch(hWindow)
{
case GUI_DISASSEMBLY:
emit selectionDisasmSet(selection);
break;
case GUI_DUMP:
emit selectionDumpSet(selection);
break;
case GUI_STACK:
emit selectionStackSet(selection);
break;
default:
return (void*)false;
}
return (void*)result.Wait();
}
break;
case GUI_GETLINE_WINDOW:
{
QString text = "";
BridgeResult result;
emit getStrWindow(QString((const char*)param1), &text);
if(result.Wait())
{
strcpy_s((char*)param2, GUI_MAX_LINE_SIZE, text.toUtf8().constData());
return (void*)true;
}
return (void*)false; //cancel/escape
}
break;
case GUI_AUTOCOMPLETE_ADDCMD:
emit autoCompleteAddCmd(QString((const char*)param1));
break;
case GUI_AUTOCOMPLETE_DELCMD:
emit autoCompleteDelCmd(QString((const char*)param1));
break;
case GUI_AUTOCOMPLETE_CLEARALL:
emit autoCompleteClearAll();
break;
case GUI_ADD_MSG_TO_STATUSBAR:
emit addMsgToStatusBar(QString((const char*)param1));
break;
case GUI_UPDATE_SIDEBAR:
emit updateSideBar();
break;
case GUI_REPAINT_TABLE_VIEW:
emit repaintTableView();
break;
case GUI_UPDATE_PATCHES:
emit updatePatches();
break;
case GUI_UPDATE_CALLSTACK:
emit updateCallStack();
break;
case GUI_SYMBOL_REFRESH_CURRENT:
emit symbolRefreshCurrent();
break;
case GUI_LOAD_SOURCE_FILE:
emitLoadSourceFile(QString((const char*)param1), (int)param2);
break;
case GUI_MENU_SET_ICON:
{
int hMenu = (int)param1;
const ICONDATA* icon = (const ICONDATA*)param2;
BridgeResult result;
if(!icon)
emit setIconMenu(hMenu, QIcon());
else
{
QImage img;
img.loadFromData((uchar*)icon->data, icon->size);
QIcon qIcon(QPixmap::fromImage(img));
emit setIconMenu(hMenu, qIcon);
}
result.Wait();
}
break;
case GUI_MENU_SET_ENTRY_ICON:
{
int hEntry = (int)param1;
const ICONDATA* icon = (const ICONDATA*)param2;
BridgeResult result;
if(!icon)
emit setIconMenuEntry(hEntry, QIcon());
else
{
QImage img;
img.loadFromData((uchar*)icon->data, icon->size);
QIcon qIcon(QPixmap::fromImage(img));
emit setIconMenuEntry(hEntry, qIcon);
}
result.Wait();
}
break;
case GUI_SHOW_CPU:
emit showCpu();
break;
case GUI_ADD_QWIDGET_TAB:
emit addQWidgetTab((QWidget*)param1);
break;
case GUI_SHOW_QWIDGET_TAB:
emit showQWidgetTab((QWidget*)param1);
break;
case GUI_CLOSE_QWIDGET_TAB:
emit closeQWidgetTab((QWidget*)param1);
break;
case GUI_EXECUTE_ON_GUI_THREAD:
GuiAddLogMessage(QString().sprintf("thread id (bridge) %X\n", GetCurrentThreadId()).toUtf8().constData());
emit executeOnGuiThread(param1);
break;
case GUI_UPDATE_TIME_WASTED_COUNTER:
emit updateTimeWastedCounter();
break;
}
return nullptr;
}
void StPlayList::open(const StCString& thePath,
const StCString& theItem) {
StMutexAuto anAutoLock(myMutex);
// check if it is recently played playlist
bool hasTarget = !theItem.isEmpty();
StString aTarget = hasTarget ? theItem : thePath;
if(!hasTarget) {
for(size_t anIter = 0; anIter < myRecent.size(); ++anIter) {
const StHandle<StRecentItem>& aRecent = myRecent[anIter];
const StHandle<StFileNode>& aFile = aRecent->File;
if(aFile->size() != 1) {
continue;
}
if(thePath.isEquals(aFile->getPath())) {
hasTarget = true;
aTarget = aFile->getValue(0)->getSubPath();
break;
}
}
}
clear();
int aSearchDeep = myRecursionDeep;
StString aFolderPath;
StString aFileName;
if(StFolder::isFolder(thePath)) {
// add all files from the folder and subfolders
aFolderPath = thePath;
aSearchDeep = myRecursionDeep;
myPlsFile = addRecentFile(StFileNode(thePath)); // append to recent files list
} else if(StFileNode::isFileExists(thePath)) {
// search only current folder
StFileNode::getFolderAndFile(thePath, aFolderPath, aFileName);
aSearchDeep = 1;
bool hasSupportedExt = false;
StString anExt = StFileNode::getExtension(aFileName);
for(size_t anExtId = 0; anExtId < myExtensions.size() && !hasSupportedExt; ++anExtId) {
hasSupportedExt = anExt.isEqualsIgnoreCase(myExtensions[anExtId]);
}
// parse m3u playlist
if(anExt.isEqualsIgnoreCase(stCString("m3u"))) {
StRawFile aRawFile(thePath);
if(aRawFile.readFile()) {
StString aTitle;
char* anIter = (char* )aRawFile.getBuffer();
if(anIter[0] == '\xEF' && anIter[1] == '\xBB' && anIter[2] == '\xBF') {
// skip BOM for UTF8 written by some stupid programs
anIter += 3;
}
while(anIter != NULL) {
anIter = parseM3UIter(anIter, aTitle);
}
myPlsFile = addRecentFile(StFileNode(thePath)); // append to recent files list
if(hasTarget) {
// set current item
for(StPlayItem* anItem = myFirst; anItem != NULL; anItem = anItem->getNext()) {
if(anItem->getPath() == aTarget) {
myCurrent = anItem;
break;
}
}
}
anAutoLock.unlock();
signals.onPlaylistChange();
return;
}
}
if(!hasSupportedExt) {
// file with unsupported extension?
StFileNode* aFileNode = new StFileNode(thePath, &myFoldersRoot);
myFoldersRoot.add(aFileNode);
addPlayItem(new StPlayItem(aFileNode, myDefStParams));
}
} else {
// not a filesystem element - probably url or invalid path
StFileNode* aFileNode = new StFileNode(thePath, &myFoldersRoot);
myFoldersRoot.add(aFileNode);
addRecentFile(*aFileNode); // append to recent files list
addPlayItem(new StPlayItem(aFileNode, myDefStParams));
anAutoLock.unlock();
signals.onPlaylistChange();
return;
}
StFolder* aSubFolder = new StFolder(aFolderPath, &myFoldersRoot);
aSubFolder->init(myExtensions, aSearchDeep);
myFoldersRoot.add(aSubFolder);
addToPlayList(aSubFolder);
myCurrent = myFirst;
if(hasTarget || !aFileName.isEmpty()) {
// set current item
for(StPlayItem* anItem = myFirst; anItem != NULL; anItem = anItem->getNext()) {
if(anItem->getPath() == aTarget) {
myCurrent = anItem;
if(myPlsFile.isNull()) {
addRecentFile(*anItem->getFileNode()); // append to recent files list
}
break;
}
}
}
anAutoLock.unlock();
signals.onPlaylistChange();
}
// -----------------------------------------------------------------------------
// Opens and adds a archive to the list, returns a pointer to the newly opened
// and added archive, or nullptr if an error occurred
// -----------------------------------------------------------------------------
Archive* ArchiveManager::openArchive(const string& filename, bool manage, bool silent)
{
// Check for directory
if (!wxFile::Exists(filename) && wxDirExists(filename))
return openDirArchive(filename, manage, silent);
auto new_archive = getArchive(filename);
LOG_MESSAGE(1, "Opening archive %s", filename);
// If the archive is already open, just return it
if (new_archive)
{
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
return new_archive;
}
// Determine file format
if (WadArchive::isWadArchive(filename))
new_archive = new WadArchive();
else if (ZipArchive::isZipArchive(filename))
new_archive = new ZipArchive();
else if (ResArchive::isResArchive(filename))
new_archive = new ResArchive();
else if (DatArchive::isDatArchive(filename))
new_archive = new DatArchive();
else if (LibArchive::isLibArchive(filename))
new_archive = new LibArchive();
else if (PakArchive::isPakArchive(filename))
new_archive = new PakArchive();
else if (BSPArchive::isBSPArchive(filename))
new_archive = new BSPArchive();
else if (GrpArchive::isGrpArchive(filename))
new_archive = new GrpArchive();
else if (RffArchive::isRffArchive(filename))
new_archive = new RffArchive();
else if (GobArchive::isGobArchive(filename))
new_archive = new GobArchive();
else if (LfdArchive::isLfdArchive(filename))
new_archive = new LfdArchive();
else if (HogArchive::isHogArchive(filename))
new_archive = new HogArchive();
else if (ADatArchive::isADatArchive(filename))
new_archive = new ADatArchive();
else if (Wad2Archive::isWad2Archive(filename))
new_archive = new Wad2Archive();
else if (WadJArchive::isWadJArchive(filename))
new_archive = new WadJArchive();
else if (WolfArchive::isWolfArchive(filename))
new_archive = new WolfArchive();
else if (GZipArchive::isGZipArchive(filename))
new_archive = new GZipArchive();
else if (BZip2Archive::isBZip2Archive(filename))
new_archive = new BZip2Archive();
else if (TarArchive::isTarArchive(filename))
new_archive = new TarArchive();
else if (DiskArchive::isDiskArchive(filename))
new_archive = new DiskArchive();
else if (PodArchive::isPodArchive(filename))
new_archive = new PodArchive();
else if (ChasmBinArchive::isChasmBinArchive(filename))
new_archive = new ChasmBinArchive();
else if (SiNArchive::isSiNArchive(filename))
new_archive = new SiNArchive();
else
{
// Unsupported format
Global::error = "Unsupported or invalid Archive format";
return nullptr;
}
// If it opened successfully, add it to the list if needed & return it,
// Otherwise, delete it and return nullptr
if (new_archive->open(filename))
{
if (manage)
{
// Add the archive
addArchive(new_archive);
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
// Add to recent files
addRecentFile(filename);
}
// Return the opened archive
return new_archive;
}
else
{
LOG_MESSAGE(1, "Error: " + Global::error);
delete new_archive;
return nullptr;
}
}
