int main(int argc, char *argv[]) { // call this ONLY when linking with FreeImage as a static library #ifdef FREEIMAGE_LIB FreeImage_Initialise(); #endif // FREEIMAGE_LIB // initialize FreeImage error handler FreeImage_SetOutputMessage(MyMessageFunc); // print version & copyright infos cout << "FreeImage " << FreeImage_GetVersion() << "\n"; cout << FreeImage_GetCopyrightMessage() << "\n\n"; // Print input formats (including external plugins) known by the library fstream importFile("fif_import.csv", ios::out); PrintImportFormats(importFile); importFile.close(); // Print output formats (including plugins) known by the library // for each export format, supported bitdepths are given fstream exportFile("fif_export.csv", ios::out); PrintExportFormats(exportFile); exportFile.close(); // call this ONLY when linking with FreeImage as a static library #ifdef FREEIMAGE_LIB FreeImage_DeInitialise(); #endif // FREEIMAGE_LIB return 0; }
void KInfoCenter::exportClickedSlot() { QString moduleName = m_contain->name(); if(m_contain->exportText().isEmpty()) { KInfoCenter::showError(this,i18n("Export of the module has produced no output.")); return; } QString fileName = QFileDialog::getSaveFileName(this, QString(moduleName + ".txt")); if(fileName.isEmpty()) return; QFile exportFile(fileName); if(!exportFile.open(QIODevice::WriteOnly)) { KInfoCenter::showError(this,i18n("Unable to open file to write export information")); return; } QTextStream exportTextStream( &exportFile ); exportTextStream << (i18n("Export information for %1", moduleName)) << "\n\n" << m_contain->exportText() << endl; exportFile.close(); KInfoCenter::showError(this, i18n("Information exported")); }
//-------------------------------------------------------------------------- // //-------------------------------------------------------------------------- void tLogDatabaseExport::ExportFile( const QString& filepath ) { tFile exportFile( filepath ); if ( !exportFile.open( QIODevice::WriteOnly ) ) { m_Result = eExportResult_Error; m_ErrorCode = exportFile.error(); m_ErrorMessage = exportFile.errorString(); return; } // We need to open all the log files and write them in to the user selected file // in the correct order. QDir dir(tPath::HistoryFile()); QStringList filter; filter << "Nmea0183log???.log"; QStringList logs(dir.entryList(filter)); // Work out what the resulting file size will be so we can emit a % signal // during the export quint64 totalExportSize = 0; quint64 exportedSize = 0; foreach (QString log, logs) { QFileInfo fileInfo(dir.filePath(log)); totalExportSize += fileInfo.size(); }
bool NoteItem::shortCut(int k) { switch(k) { case Qt::Key_N: if(MainWindow::s_query.length()) { if(m_rich) { TextBrowser* textBrowser = findChild<TextBrowser *>("contentWidget"); textBrowser->find(MainWindow::s_query); } else { PlainTextBrowser* textBrowser = findChild<PlainTextBrowser *>("contentWidget"); textBrowser->find(MainWindow::s_query); } } return true; case Qt::Key_X: exportFile(); return true; case Qt::Key_Left: case Qt::Key_Right: { NoteList *noteList = qobject_cast<NoteList*>(parentWidget()); NoteItem* item = noteList->getNextNote(this,(k==Qt::Key_Right)?1:-1); if(item) NoteItem::setActiveItem(item); } return true; case Qt::Key_Return: g_mainWindow->editActiveNote(); return true; default: return false; } }
void MainWindow::enginioFinished(EnginioReply *msg) { if(msg->errorType() != EnginioReply::NoError) { return; } logDebug(QJsonDocument(msg->data()).toJson()); if(msg == m_exportReply) { QJsonArray jsonArray(m_exportReply->data().value("results").toArray()); QByteArray jsonText = QJsonDocument(jsonArray).toJson(); QFile exportFile(m_exportFile->text()); bool ok = exportFile.open(QIODevice::WriteOnly); if(ok) { exportFile.write(jsonText); log(tr("%1 object(s) exported to %2").arg(jsonArray.size()).arg(exportFile.fileName())); } else { logError(tr("Error %1 opening file %2").arg(exportFile.error()).arg(exportFile.fileName())); } } if(msg == m_queryForRemovalReply) { QJsonArray jsonArray(m_queryForRemovalReply->data().value("results").toArray()); foreach(const QJsonValue &v, jsonArray) { QJsonObject removeObject(v.toObject()); setObjectType(&removeObject); m_client->remove(removeObject); }
void FileEditionWidget::setFiles(const QStringList &filenames) { ui->tableWidget->clear(); ui->tableWidget->setColumnCount(2); ui->tableWidget->setRowCount(filenames.count()); ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents); ui->tableWidget->horizontalHeader()->setSectionResizeMode(FilenamePos, QHeaderView::Stretch); int row = 0; foreach(const QString& file, filenames) { QTableWidgetItem* item = new QTableWidgetItem(file); ui->tableWidget->setItem(row, FilenamePos, item); ButtonWidget* btns = new ButtonWidget(this); ui->tableWidget->setCellWidget(row, ButtonsPos, btns); _editMapper->setMapping(btns, file); _exportMapper->setMapping(btns, file); _importMapper->setMapping(btns, file); _resetMapper->setMapping(btns, file); connect(btns, SIGNAL(editFile()), _editMapper, SLOT(map())); connect(btns, SIGNAL(exportFile()), _exportMapper, SLOT(map())); connect(btns, SIGNAL(importFile()), _importMapper, SLOT(map())); connect(btns, SIGNAL(removeFile()), _resetMapper, SLOT(map())); ++row; }
int ProgramSenoko::prepGPIO(void) { QFile exportFile("/sys/class/gpio/export"); if (!exportFile.open(QIODevice::WriteOnly)) { testError(QString() + "Unable to open GPIO export file: " + exportFile.errorString()); return 1; } exportFile.write("149"); exportFile.close(); QFile directionFile("/sys/class/gpio/gpio149/direction"); if (!directionFile.open(QIODevice::WriteOnly)) { testError(QString() + "Unable to open GPIO149 direction file: " + directionFile.errorString()); return 1; } directionFile.write("out\n"); directionFile.close(); QFile valueFile("/sys/class/gpio/gpio149/value"); if (!valueFile.open(QIODevice::WriteOnly)) { testError(QString() + "Unable to open GPIO149 value file: " + valueFile.errorString()); return 1; } valueFile.write("0\n"); valueFile.close(); return 0; }
PmChart::PmChart() : QMainWindow(NULL) { my.dialogsSetup = false; setIconSize(QSize(22, 22)); setupUi(this); my.statusBar = new StatusBar; setStatusBar(my.statusBar); connect(my.statusBar->timeFrame(), SIGNAL(clicked()), this, SLOT(editSamples())); connect(my.statusBar->timeButton(), SIGNAL(clicked()), this, SLOT(optionsShowTimeControl())); my.timeAxisRightAlign = toolBar->height(); toolBar->setAllowedAreas(Qt::RightToolBarArea | Qt::TopToolBarArea); connect(toolBar, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(updateToolbarOrientation(Qt::Orientation))); updateToolbarLocation(); setupEnabledActionsList(); if (!globalSettings.initialToolbar && !outfile) toolBar->hide(); toolbarAction->setChecked(true); my.toolbarHidden = !globalSettings.initialToolbar; my.consoleHidden = true; if (!pmDebug) consoleAction->setVisible(false); consoleAction->setChecked(false); if (outfile) QTimer::singleShot(0, this, SLOT(exportFile())); else QTimer::singleShot(PmChart::defaultTimeout(), this, SLOT(timeout())); }
////////////////////////////////////////////////////////////////////// // Set Functions ////////////////////////////////////////////////////////////////////// bool GLC_WorldTo3ds::exportToFile(const QString& fileName, bool useAbsolutePosition) { m_ReferenceToMesh.clear(); m_NameToMaterial.clear(); m_pRootLib3dsNode= NULL; m_CurrentNodeId= 0; m_OccIdToNodeId.clear(); m_CurrentMeshIndex= 0; m_UseAbsolutePosition= useAbsolutePosition; m_TextureToFileName.clear(); m_FileName= fileName; bool subject= false; { QFile exportFile(m_FileName); subject= exportFile.open(QIODevice::WriteOnly); exportFile.close(); } if (subject) { m_pLib3dsFile= lib3ds_file_new(); saveWorld(); subject= lib3ds_file_save(m_pLib3dsFile, fileName.toLocal8Bit().data()); } return subject; }
// Methodes void Pin::exportPin() { ofstream exportFile(PATH_OF_EXPORT); if(!exportFile) { throw("EXPORT FAILED : " + string(strerror(errno))); } exportFile << this->m_number; exportFile.close(); }
void LLWearable::saveNewAsset() { // llinfos << "LLWearable::saveNewAsset() type: " << getTypeName() << llendl; //llinfos << *this << llendl; std::string new_asset_id_string; mAssetID.toString(new_asset_id_string); std::string filename; filename = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,new_asset_id_string) + ".wbl"; LLFILE* fp = LLFile::fopen(filename, "wb"); /* Flawfinder: ignore */ BOOL successful_save = FALSE; if(fp && exportFile(fp)) { successful_save = TRUE; } if(fp) { fclose(fp); fp = NULL; } if(!successful_save) { std::string buffer = llformat("Unable to save '%s' to wearable file.", mName.c_str()); llwarns << buffer << llendl; LLStringUtil::format_map_t args; args["[NAME]"] = mName; gViewerWindow->alertXml("CannotSaveWearableOutOfSpace", args); return; } // save it out to database if( gAssetStorage ) { /* std::string url = gAgent.getRegion()->getCapability("NewAgentInventory"); if (!url.empty()) { llinfos << "Update Agent Inventory via capability" << llendl; LLSD body; body["folder_id"] = gInventory.findCategoryUUIDForType(getAssetType()); body["asset_type"] = LLAssetType::lookup(getAssetType()); body["inventory_type"] = LLInventoryType::lookup(LLInventoryType::IT_WEARABLE); body["name"] = getName(); body["description"] = getDescription(); LLHTTPClient::post(url, body, new LLNewAgentInventoryResponder(body, filename)); } else { } */ LLWearableSaveData* data = new LLWearableSaveData; data->mType = mType; gAssetStorage->storeAssetData(filename, mTransactionID, getAssetType(), &LLWearable::onSaveNewAssetComplete, (void*)data); } }
void StandardActions::createStandardActions() { QAction *newAction = new QAction(tr("New"), mainWindow); newAction->setShortcut(QKeySequence("Ctrl+N")); mainWindow->getActionCollection()->addAction("new", newAction); connect(newAction, SIGNAL(triggered()), this, SLOT(newFile())); QAction *openAction = new QAction(tr("Open"), mainWindow); openAction->setShortcut(QKeySequence("Ctrl+O")); mainWindow->getActionCollection()->addAction("open", openAction); connect(openAction, SIGNAL(triggered()), this, SLOT(openFile())); QAction *saveAction = new QAction(tr("Save"), mainWindow); saveAction->setShortcut(QKeySequence("Ctrl+S")); mainWindow->getActionCollection()->addAction("save", saveAction); connect(saveAction, SIGNAL(triggered()), this, SLOT(saveFile())); QAction *saveAsAction = new QAction(tr("Save As"), mainWindow); mainWindow->getActionCollection()->addAction("saveas", saveAsAction); connect(saveAsAction, SIGNAL(triggered()), this, SLOT(saveFileAs())); QAction *exportAction = new QAction(tr("Export"), mainWindow); mainWindow->getActionCollection()->addAction("export", exportAction); connect(exportAction, SIGNAL(triggered()), this, SLOT(exportFile())); QAction *exitAction = new QAction(tr("Exit"), mainWindow); exitAction->setShortcut(QKeySequence("Ctrl+Q")); mainWindow->getActionCollection()->addAction("exit", exitAction); connect(exitAction, SIGNAL(triggered()), this, SLOT(exitApplication())); QAction* cutAction = new QAction(tr("Cut"), mainWindow); cutAction->setShortcut(QKeySequence("Ctrl+X")); mainWindow->getActionCollection()->addAction("cut", cutAction); connect(cutAction, SIGNAL(triggered()), this, SLOT(cut())); QAction* copyAction = new QAction(tr("Copy"), mainWindow); copyAction->setShortcut(QKeySequence("Ctrl+C")); mainWindow->getActionCollection()->addAction("copy", copyAction); connect(copyAction, SIGNAL(triggered()), this , SLOT(copy())); QAction* pasteAction = new QAction(tr("Paste"), mainWindow); pasteAction->setShortcut(QKeySequence("Ctrl+V")); mainWindow->getActionCollection()->addAction("paste", pasteAction); connect(pasteAction, SIGNAL(triggered()), this, SLOT(paste())); QAction* undoAction = new QAction(tr("Undo"), mainWindow); undoAction->setShortcut(QKeySequence("Ctrl+Z")); mainWindow->getActionCollection()->addAction("undo", undoAction); connect(undoAction, SIGNAL(triggered()), this, SLOT(undo())); QAction* redoAction = new QAction(tr("Redo"), mainWindow); redoAction->setShortcut(QKeySequence("Ctrl+R")); mainWindow->getActionCollection()->addAction("redo", redoAction); connect(redoAction, SIGNAL(triggered(bool)), this, SLOT(redo())); }
void PDFFactory::createActions() { openAction = new QAction(tr("&Open"), this); openAction->setIcon(QIcon(":/images/open.png")); openAction->setShortcut(tr("Ctrl+O")); openAction->setStatusTip(tr("Open a PDF")); connect(openAction, SIGNAL(triggered()), this, SLOT(openFile())); exportAction = new QAction(tr("&Export a single file"), this); exportAction->setIcon(QIcon(":/images/export.png")); exportAction->setShortcut(tr("Ctrl+S")); exportAction->setStatusTip(tr("Export the selected file to a new PDF")); connect(exportAction, SIGNAL(triggered()), this, SLOT(exportFile())); exportAllAction = new QAction(tr("Export all"), this); exportAllAction->setIcon(QIcon(":/images/exportall.png")); exportAllAction->setShortcut(tr("Shift+Ctrl+S")); exportAllAction->setStatusTip(tr("Export all to multiple PDF files")); connect(exportAllAction, SIGNAL(triggered()), this, SLOT(exportAllFiles())); cutAction = new QAction(tr("C&ut"), this); cutAction->setIcon(QIcon(":/images/cut.png")); cutAction->setShortcut(tr("Ctrl+X")); cutAction->setStatusTip(tr("Cut selected contents to clipboard")); connect(cutAction, SIGNAL(triggered()), pdfTableView, SLOT(cutSelected())); copyAction = new QAction(tr("&Copy"), this); copyAction->setIcon(QIcon(":/images/copy.png")); copyAction->setShortcut(tr("Ctrl+C")); copyAction->setStatusTip(tr("Copy selected contents to clipboard")); connect(copyAction, SIGNAL(triggered()), pdfTableView, SLOT(copySelected())); pasteAction = new QAction(tr("&Paste"), this); pasteAction->setIcon(QIcon(":/images/paste.png")); pasteAction->setShortcut(tr("Ctrl+V")); pasteAction->setStatusTip(tr("Paste clipboard's contents into current selection")); //connect(pasteAction, SIGNAL(triggered()), textEdit, SLOT(paste())); deleteAction = new QAction(tr("&Delete"), this); deleteAction->setIcon(QIcon(":/images/delete.png")); deleteAction->setShortcut(tr("Ctrl+D")); deleteAction->setStatusTip(tr("Delete selected contents")); connect(deleteAction, SIGNAL(triggered()), pdfTableView, SLOT(deleteSelected())); rotateAction = new QAction(tr("&Rotate"), this); rotateAction->setIcon(QIcon(":/images/rotate.png")); rotateAction->setShortcut(tr("Ctrl+R")); rotateAction->setStatusTip(tr("Rotate selected pages")); connect(rotateAction, SIGNAL(triggered()), pdfTableView, SLOT(rotateSelected())); aboutAction = new QAction(tr("A&bout"), this); aboutAction->setIcon(QIcon(":/images/about.png")); aboutAction->setStatusTip(tr("About this program")); connect(aboutAction, SIGNAL(triggered()), this, SLOT(about())); }
ReadWidget::ReadWidget(QWidget * parent) : QWidget(parent) { // resource file reader reader = 0; // table model QStringList modelHeaderData; modelHeaderData << "Index" << "File Name" << "File Size"; tableModel = new TableModel(modelHeaderData, false, this); // entire page layout pageLayout = new QVBoxLayout(this); // layout for the load controls loadLayout = new QHBoxLayout(); pageLayout->addLayout(loadLayout); // line edit for file path loadLocation = new QLineEdit(); loadLocation->setReadOnly(true); loadLayout->addWidget(loadLocation); // button to load open the file selection dialog loadButton = new QPushButton(); loadButton->setText("Load Resource File"); loadLayout->addWidget(loadButton); // layout to hold the table and controls tableLayout = new QHBoxLayout(); pageLayout->addLayout(tableLayout); // table view tableView = new TableView(); tableView->setModel(tableModel); tableLayout->addWidget(tableView); // layout to hold the table controls tableControlsLayout = new QVBoxLayout(); tableLayout->addLayout(tableControlsLayout); tableControlsLayout->addStretch(); // export button exportButton = new QPushButton(); exportButton->setText("Export"); tableControlsLayout->addWidget(exportButton); tableControlsLayout->addStretch(); // connect actions connect(loadButton, SIGNAL(clicked()), this, SLOT(load())); connect(exportButton, SIGNAL(clicked()), this, SLOT(exportFile())); }
void PhotonMapExportDB::RemoveExistingFiles() { QDir exportDirectory( m_dbDirectory ); QString filename = m_dbFileName; QString exportFilename = exportDirectory.absoluteFilePath( filename.append( QLatin1String( ".db" ) ) ); QFile exportFile( exportFilename ); if(exportFile.exists() && !exportFile.remove() ) { QString message= QString( "Error deleting database:%1.\n" "The database is in use. Please, close it before continuing. \n" ).arg( exportFilename ); QMessageBox::warning( NULL, QLatin1String( "Tonatiuh" ), message ); RemoveExistingFiles(); } }
WaterWidget::WaterWidget(MapTile *file, QWidget *parent) : WoWFileWidget(parent) ,adtFile(file) { saveButton = new QPushButton(tr("&Export"),this); importButton = new QPushButton(tr("&Import"),this); QLabel *label = new QLabel("Water Import/Export more features will be added in future",this); QVBoxLayout *mainLayout = new QVBoxLayout; mainLayout->addWidget(label); mainLayout->addWidget(saveButton,0,Qt::AlignRight); mainLayout->addWidget(importButton,0,Qt::AlignRight); connect(saveButton,SIGNAL(clicked()),this,SLOT(exportFile())); connect(importButton,SIGNAL(clicked()),this,SLOT(importFile())); this->setLayout(mainLayout); }
int MyExportButton::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QPushButton::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: requestMesh(); break; case 1: requestMtl(); break; case 2: exportFile(); break; case 3: acceptMesh((*reinterpret_cast< Mesh*(*)>(_a[1]))); break; case 4: acceptMtl((*reinterpret_cast< string(*)>(_a[1]))); break; default: ; } _id -= 5; } return _id; }
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QMainWindow::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { switch (_id) { case 0: eventChanged((*reinterpret_cast< AGSEventType(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break; case 1: newFile(); break; case 2: openFile(); break; case 3: closeFile(); break; case 4: exportFile(); break; case 5: importToDatabase(); break; case 6: loadFile((*reinterpret_cast< QString(*)>(_a[1]))); break; case 7: openRecentFile(); break; case 8: showOptions(); break; case 9: updateTime(); break; case 10: lookupAGS_ID(); break; case 11: lookupPCC_ID(); break; case 12: lookupPCC_ID((*reinterpret_cast< QString(*)>(_a[1]))); break; case 13: setEventTypeID((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break; case 14: setEvent((*reinterpret_cast< AGSEventType(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break; case 15: setLogoutTime(); break; case 16: setLogoutTime((*reinterpret_cast< int(*)>(_a[1]))); break; case 17: setTShirtCalc((*reinterpret_cast< double(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break; case 18: setTimer((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break; case 19: setTimer((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break; case 20: boo(); break; case 21: showError((*reinterpret_cast< QString(*)>(_a[1]))); break; case 22: login(); break; case 23: logout(); break; case 24: about(); break; case 25: tutorial(); break; case 26: reportABug(); break; case 27: testConnection(); break; case 28: { QString _r = generateHeader(); if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; } break; case 29: rewriteHeader(); break; default: ; } _id -= 30; } return _id; }
/* * Export the flux distribution */ void FluxAnalysis::ExportAnalysis( QString directory, QString fileName, bool saveCoords ) { if( m_pPhotonMap == 0 || !m_pPhotonMap ) return; if( directory.isEmpty() ) return; if( fileName.isEmpty() ) return; QFileInfo exportFileInfo( fileName ); if( exportFileInfo.completeSuffix().compare( "txt" ) ) fileName.append( ".txt" ); QFile exportFile( directory + "/" + fileName ); exportFile.open( QIODevice::WriteOnly ); QTextStream out( &exportFile ); double widthCell = ( m_xmax - m_xmin ) / m_widthDivisions; double heightCell = ( m_ymax - m_ymin ) / m_heightDivisions; double areaCell = widthCell * heightCell; if( saveCoords ) { out<<"x(m)\ty(m)\tFlux(W/m2)"<<"\n"; for( int i = 0; i < m_heightDivisions; i++ ) { for( int j = 0; j < m_widthDivisions; j++ ) { out<< m_xmin + widthCell/2 + j * widthCell << "\t" << m_ymin + heightCell/2 + i * heightCell << "\t" << m_photonCounts[i][j] * m_wPhoton / areaCell << "\n"; } } } else { for( int i = 0; i < m_heightDivisions; i++ ) { for( int j = 0; j < m_widthDivisions; j++ ) { out<< m_photonCounts[m_heightDivisions-1-i][j] * m_wPhoton / areaCell << "\t"; } out<<"\n" ; } } exportFile.close(); }
bool IoController::writeToGPIOFile( const QString file, QString outputData ) { QFile exportFile( file ); if ( exportFile.open( QIODevice::WriteOnly ) ) { QTextStream exportStream( &exportFile ); exportStream << outputData; exportFile.close(); return true; } //qDebug() << "Error writing " << file; return false; }
void EmberEntityFactory::dumpAttributesOfEntity(const std::string& entityId) const { EmberEntity* entity = static_cast<EmberEntity*>(mView.getEntity(entityId)); if (entity) { //make sure the directory exists std::string dir(EmberServices::getSingleton().getConfigService().getHomeDirectory() + "/entityexport/"); if (!oslink::directory(dir).isExisting()) { S_LOG_INFO("Creating directory " << dir); oslink::directory::mkdir(dir.c_str()); } const std::string fileName(dir + entityId + ".atlas"); std::fstream exportFile(fileName.c_str(), std::fstream::out); S_LOG_INFO("Dumping attributes to " << fileName); entity->dumpAttributes(exportFile, std::cout); ConsoleBackend::getSingletonPtr()->pushMessage(std::string("Dumped attributes to ") + fileName, "info"); } }
FileEditionWidget::FileEditionWidget(QWidget *parent) : QWidget(parent), ui(new Ui::FileEditionWidget), _askFileContext(None), _gridEditor(nullptr), _propertiesBrowser(nullptr), _propertyDialog(nullptr), _plainTextEditor(nullptr), _textDialog(nullptr), _nsEditor(nullptr), _nsDialog(nullptr) { ui->setupUi(this); _editMapper = new QSignalMapper(this); connect(_editMapper, SIGNAL(mapped(QString)), this, SLOT(editFile(QString))); connect(ui->tableWidget, SIGNAL(cellDoubleClicked(int,int)), this, SLOT(rowDoubleClicked(int))); _exportMapper = new QSignalMapper(this); connect(_exportMapper, SIGNAL(mapped(QString)), this, SLOT(exportFile(QString))); _importMapper = new QSignalMapper(this); connect(_importMapper, SIGNAL(mapped(QString)), this, SLOT(importFile(QString))); _resetMapper = new QSignalMapper(this); connect(_resetMapper, SIGNAL(mapped(QString)), this, SLOT(resetFile(QString))); connect(ui->btnImportFile, SIGNAL(clicked()), this, SLOT(importFromDisk())); connect(ui->btnNewFile, SIGNAL(clicked()), this, SLOT(newFile())); }
void ReginaMain::exportSource() { exportFile(SourceHandler::instance, tr(FILTER_CPP_SOURCE), tr("Export C++ Source")); }
void ReginaMain::exportRegina() { exportFile(ReginaHandler(true), tr(FILTER_REGINA), tr("Export Regina Data File")); }
void ReginaMain::exportPython() { exportFile(PythonHandler::instance, tr(FILTER_PYTHON_SCRIPTS), tr("Export Python Script")); }
void ReginaMain::exportReginaUncompressed() { exportFile(ReginaHandler(false), tr(FILTER_REGINA), tr("Export Regina Data File")); }
void ReginaMain::exportSnapPea() { exportFile(SnapPeaHandler::instance, tr(FILTER_SNAPPEA), tr("Export SnapPea Triangulation")); }
void ArcInfoExportFileNode::update(void) { /* Do nothing if there is no export file name: */ if(url.getNumValues()==0) return; /* Open the ARC/INFO export file: */ IO::AutoFile exportFileSource(Comm::openFile(multiplexer,url.getValue(0).c_str())); IO::ValueSource exportFile(*exportFileSource); /* Check the file's format: */ if(exportFile.readString()!="EXP"||exportFile.readInteger()!=0) return; /* Skip the rest of the header line: */ exportFile.skipLine(); exportFile.skipWs(); /* Create a shape node to contain the polylines read from embedded ARC files: */ ShapeNode* arcShape=new ShapeNode; IndexedLineSetNode* arcLineSet=new IndexedLineSetNode; arcShape->geometry.setValue(arcLineSet); ColorNode* arcLineSetColors=new ColorNode; arcLineSet->color.setValue(arcLineSetColors); CoordinateNode* arcLineSetCoords=new CoordinateNode; arcLineSet->coord.setValue(arcLineSetCoords); arcLineSet->colorPerVertex.setValue(false); /* Read embedded files until end-of-file: */ while(!exportFile.eof()) { /* Read the next embedded file's header: */ std::string fileType=exportFile.readString(); if(fileType=="EOS") { /* Marks the end of the file; ignore everything after here: */ break; } else if(fileType=="ARC") { /* Skip the rest of the line: */ exportFile.skipLine(); exportFile.skipWs(); /* Read polylines from the ARC file: */ while(true) { /* Read the next block header: */ int blockHeader[7]; if(!readBlockHeader(exportFile,blockHeader)||blockHeader[0]==-1) break; /* Read all vertices in this polyline: */ for(int i=0;i<blockHeader[6];++i) { /* Read the next vertex's 2D position: */ double px=exportFile.readNumber(); double py=exportFile.readNumber(); /* Add the vertex to the current polyline: */ arcLineSet->coordIndex.appendValue(arcLineSetCoords->point.getNumValues()); arcLineSetCoords->point.appendValue(Point(px,py,0)); } /* Finalize the current polyline: */ arcLineSet->coordIndex.appendValue(-1); arcLineSetColors->color.appendValue(Color(1.0f,1.0f,1.0f)); } } else if(fileType=="SIN") { /* Skip a SIN file: */ while(!exportFile.eof()&&exportFile.readString()!="EOX") ; } else if(fileType=="LOG") { /* Skip a LOG file: */ while(!exportFile.eof()&&exportFile.readString()!="EOL") ; } else if(fileType=="PRJ") { /* Skip a PRJ file: */ while(!exportFile.eof()&&exportFile.readString()!="EOP") ; } else if(fileType=="TX6"||fileType=="TX7"||fileType=="RXP"||fileType=="RPL") { /* Skip a text file: */ while(!exportFile.eof()&&exportFile.readString()!="JABBERWOCKY") // What the hell? ; } else if(fileType=="MTD") { /* Skip a MTD file: */ while(!exportFile.eof()&&exportFile.readString()!="EOD") ; } else if(fileType=="IFO") { /* Skip a IFO file: */ while(!exportFile.eof()&&exportFile.readString()!="EOI") ; } else { /* Temporarily mark newline characters as punctuation: */ exportFile.setPunctuation('\n',true); /* Skip an unrecognized file: */ while(!exportFile.eof()) { /* Try to read a block header: */ int values[7]; if(readBlockHeader(exportFile,values)&&values[0]==-1) break; /* Skip the rest of the line: */ exportFile.skipLine(); exportFile.skipWs(); } /* Mark newline characters as whitespace again: */ exportFile.setWhitespace('\n',true); } } /* Finalize the generated nodes: */ arcLineSetColors->update(); arcLineSetCoords->update(); arcLineSet->update(); arcShape->update(); /* Store all generated nodes as children: */ children.appendValue(arcShape); GroupNode::update(); }
void ReginaMain::exportRecogniser() { exportFile(RecogniserHandler::instance, tr(FILTER_RECOGNISER), tr("Export Triangulation to 3-Manifold Recogniser")); }
bool GLC_WorldTo3dxml::exportTo3dxml(const QString& filename, GLC_WorldTo3dxml::ExportType exportType, bool exportMaterial) { m_3dxmlFileSet.clear(); m_ListOfOverLoadedOccurence.clear(); m_FileNameIncrement= 0; m_ExportMaterial= exportMaterial; m_FileName= filename; m_ExportType= exportType; bool isExported= false; if (m_ExportType == Compressed3dxml) { m_p3dxmlArchive= new QuaZip(m_FileName); isExported= m_p3dxmlArchive->open(QuaZip::mdCreate); // Add the manifest addManifest(); } else { m_AbsolutePath= QFileInfo(m_FileName).absolutePath() + QDir::separator(); QFile exportFile(m_FileName); isExported= exportFile.open(QIODevice::WriteOnly); exportFile.close(); } if (isExported) { if (m_ExportMaterial && (m_ExportType != StructureOnly)) { writeAllMaterialRelatedFilesIn3dxml(); } // Export the assembly structure from the list of structure reference exportAssemblyStructure(); if (m_ExportType != StructureOnly) { int previousQuantumValue= 0; int currentQuantumValue= 0; emit currentQuantum(currentQuantumValue); int currentRepIndex= 0; const int size= m_ReferenceRepTo3dxmlFileName.size(); // Export the representation QHash<const GLC_3DRep*, QString>::const_iterator iRep= m_ReferenceRepTo3dxmlFileName.constBegin(); while ((m_ReferenceRepTo3dxmlFileName.constEnd() != iRep) && continu()) { write3DRep(iRep.key(), iRep.value()); ++iRep; // Progrees bar indicator ++currentRepIndex; currentQuantumValue = static_cast<int>((static_cast<double>(currentRepIndex) / size) * 100); if (currentQuantumValue > previousQuantumValue) { emit currentQuantum(currentQuantumValue); } previousQuantumValue= currentQuantumValue; if (!m_IsThreaded) { QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents); } } } } emit currentQuantum(100); return isExported; }