void RenderWindow::slotMenuSaveSettings() { cSettings parSettings(cSettings::formatCondensedText); gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::read); parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes); QFileDialog dialog(this); dialog.setOption(QFileDialog::DontUseNativeDialog); dialog.setFileMode(QFileDialog::AnyFile); dialog.setNameFilter(tr("Fractals (*.txt *.fract)")); dialog.setDirectory( QDir::toNativeSeparators(QFileInfo(systemData.lastSettingsFile).absolutePath())); dialog.selectFile( QDir::toNativeSeparators(QFileInfo(systemData.lastSettingsFile).completeBaseName())); dialog.setAcceptMode(QFileDialog::AcceptSave); dialog.setWindowTitle(tr("Save settings...")); dialog.setDefaultSuffix("fract"); QStringList filenames; if (dialog.exec()) { filenames = dialog.selectedFiles(); QString filename = QDir::toNativeSeparators(filenames.first()); parSettings.SaveToFile(filename); systemData.lastSettingsFile = filename; SaveSettingsToRecent(filename); setWindowTitle(QString("Mandelbulber (") + filename + ")"); // QString hash = parSettings.GetHashCode(); // cThumbnail thumbnail(gPar, gParFractal, 200, 200); // thumbnail.Render(); // thumbnail.Save(systemData.thumbnailDir + hash); } }
void RenderWindow::slotMenuLoadSettingsFromClipboard() { gMainInterface->SynchronizeInterface( gPar, gParFractal, qInterface::read); // update appParam before loading new settings cSettings parSettings(cSettings::formatFullText); if (parSettings.LoadFromClipboard()) { gMainInterface->DisablePeriodicRefresh(); gInterfaceReadyForSynchronization = false; parSettings.Decode(gPar, gParFractal, gAnimFrames, gKeyframes); gMainInterface->RebuildPrimitives(gPar); gMainInterface->materialListModel->Regenerate(); gInterfaceReadyForSynchronization = true; gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::write); gMainInterface->ComboMouseClickUpdate(); systemData.lastSettingsFile = "from clipboard"; setWindowTitle(QString("Mandelbulber (") + "from clipboard" + ")"); gFlightAnimation->RefreshTable(); gKeyframeAnimation->RefreshTable(); gMainInterface->ReEnablePeriodicRefresh(); showDescriptionPopup(); } else { cErrorMessage::showMessage(QObject::tr("Cannot load settings from clipboard!"), cErrorMessage::errorMessage, gMainInterface->mainWindow); } }
void PreviewFileDialog::OnCurrentChanged(const QString & _filename) { filename = _filename; QPixmap pixmap; if (QFileInfo(filename).suffix() == QString("fract") && checkbox->isChecked()) { thumbWidget->show(); preview->hide(); cSettings parSettings(cSettings::formatFullText); parSettings.BeQuiet(true); if (parSettings.LoadFromFile(filename)) { progressBar->show(); cParameterContainer *par = new cParameterContainer; cFractalContainer *parFractal = new cFractalContainer; InitParams(par); for (int i = 0; i < NUMBER_OF_FRACTALS; i++) InitFractalParams(&parFractal->at(i)); /****************** TEMPORARY CODE FOR MATERIALS *******************/ InitMaterialParams(1, par); /*******************************************************************/ if (parSettings.Decode(par, parFractal)) { thumbWidget->AssignParameters(*par, *parFractal); thumbWidget->update(); } else { preview->setText(" "); info->setText(" "); } delete par; delete parFractal; } } else { thumbWidget->hide(); preview->show(); pixmap.load(filename); if (pixmap.isNull() || !checkbox->isChecked()) { preview->setText(" "); info->setText(" "); } else { preview->setPixmap(pixmap.scaled(200, 200, Qt::KeepAspectRatio, Qt::SmoothTransformation)); QString text = QString::number(pixmap.width()) + QString(" x ") + QString::number(pixmap.height()); info->setText(text); } } }
void RenderWindow::slotPresetAddToToolbar() { cSettings parSettings(cSettings::formatCondensedText); gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::read); parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes); QString filename = systemData.dataDirectory + "toolbar/" + parSettings.GetHashCode() + ".fract"; parSettings.SaveToFile(filename); slotPopulateToolbar(); }
void RenderWindow::slotMenuSaveSettingsToClipboard() { cSettings parSettings(cSettings::formatCondensedText); gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::read); parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes); parSettings.SaveToClipboard(); cErrorMessage::showMessage( QObject::tr("Settings saved to clipboard"), cErrorMessage::infoMessage); }
void cRenderQueue::slotRenderQueue() { int queueFinished = 0; WriteLog("cRenderQueue::slotRenderQueue()", 2); gQueue->stopRequest = false; while (!gQueue->stopRequest) { int queueTotalLeft = gQueue->GetQueueSize(); cQueue::structQueueItem queueItem = gQueue->GetNextFromList(); if (queueItem.filename == "") break; // last item reached emit updateProgressAndStatus(QFileInfo(queueItem.filename).fileName(), QObject::tr("Queue Item %1 of %2").arg(queueFinished + 1).arg(queueTotalLeft + queueFinished), (1.0 * queueFinished / (queueTotalLeft + queueFinished)), cProgressText::progress_QUEUE); if (QFile::exists(queueItem.filename)) { cSettings parSettings(cSettings::formatFullText); parSettings.LoadFromFile(queueItem.filename); parSettings.Decode(queuePar, queueParFractal, queueAnimFrames, queueKeyframes); queuePar->Set("image_preview_scale", 0); bool result = false; switch (queueItem.renderType) { case cQueue::queue_STILL: result = RenderStill(queueItem.filename); break; case cQueue::queue_FLIGHT: result = RenderFlight(); break; case cQueue::queue_KEYFRAME: result = RenderKeyframe(); break; } if (result) { gQueue->RemoveQueueItem(queueItem); queueFinished++; } else { break; } } else { cErrorMessage::showMessage("Cannot load file!\n", cErrorMessage::errorMessage); qCritical() << "\nSetting file " << queueItem.filename << " not found\n"; } } emit updateProgressAndStatus( QObject::tr("Queue Render"), QObject::tr("Queue Done"), 1.0, cProgressText::progress_QUEUE); emit finished(); }
bool cRenderQueue::RenderStill(const QString& filename) { QString extension; enumImageFileType imageFormat = (enumImageFileType) gPar->Get<int>("queue_image_format"); extension = ImageFileExtension(imageFormat); QString saveFilename = QFileInfo(filename).baseName() + extension; //setup of rendering engine cRenderJob *renderJob = new cRenderJob(queuePar, queueParFractal, image, &gQueue->stopRequest, imageWidget); connect(renderJob, SIGNAL(updateProgressAndStatus(const QString&, const QString&, double)), this, SIGNAL(updateProgressAndStatus(const QString&, const QString&, double))); connect(renderJob, SIGNAL(updateStatistics(cStatistics)), this, SIGNAL(updateStatistics(cStatistics))); cRenderingConfiguration config; if (systemData.noGui) { config.DisableProgressiveRender(); config.DisableRefresh(); } config.EnableNetRender(); renderJob->Init(cRenderJob::still, config); gQueue->stopRequest = false; //render image bool result = renderJob->Execute(); if (!result) { delete renderJob; return false; } QString fullSaveFilename = gPar->Get<QString>("default_image_path") + QDir::separator() + saveFilename; SaveImage(fullSaveFilename, imageFormat, image); fullSaveFilename = gPar->Get<QString>("default_image_path") + QDir::separator() + QFileInfo(filename).baseName() + ".fract"; cSettings parSettings(cSettings::formatCondensedText); parSettings.CreateText(queuePar, queueParFractal); parSettings.SaveToFile(fullSaveFilename); delete renderJob; return true; }
void Test::renderExamples() { // this renders all example files in a resolution of 5x5 px // and benchmarks the runtime QString examplePath = QDir::toNativeSeparators(systemData.sharedDir + QDir::separator() + "examples"); QDirIterator it(examplePath, QStringList() << "*.fract", QDir::Files); cParameterContainer *testPar = new cParameterContainer; cFractalContainer *testParFractal = new cFractalContainer; cAnimationFrames *testAnimFrames = new cAnimationFrames; cKeyframes *testKeyframes = new cKeyframes; testPar->SetContainerName("main"); InitParams(testPar); /****************** TEMPORARY CODE FOR MATERIALS *******************/ InitMaterialParams(1, testPar); /*******************************************************************/ for (int i = 0; i < NUMBER_OF_FRACTALS; i++) { testParFractal->at(i).SetContainerName(QString("fractal") + QString::number(i)); InitFractalParams(&testParFractal->at(i)); } bool stopRequest = false; cImage *image = new cImage(testPar->Get<int>("image_width"), testPar->Get<int>("image_height")); cRenderingConfiguration config; config.DisableRefresh(); config.DisableProgressiveRender(); while (it.hasNext()) { QString filename = it.next(); cSettings parSettings(cSettings::formatFullText); parSettings.BeQuiet(true); parSettings.LoadFromFile(filename); parSettings.Decode(testPar, testParFractal, testAnimFrames, testKeyframes); testPar->Set("image_width", 5); testPar->Set("image_height", 5); cRenderJob *renderJob = new cRenderJob(testPar, testParFractal, image, &stopRequest); renderJob->Init(cRenderJob::still, config); QVERIFY2(renderJob->Execute(), "example render failed."); delete renderJob; } delete image; delete testKeyframes; delete testAnimFrames; delete testParFractal; delete testPar; }
void RenderWindow::slotMenuLoadPreset(QString filename) { cSettings parSettings(cSettings::formatFullText); parSettings.LoadFromFile(filename); parSettings.Decode(gPar, gParFractal); gMainInterface->RebuildPrimitives(gPar); gMainInterface->SynchronizeInterface(gPar, gParFractal, cInterface::write); gMainInterface->ComboMouseClickUpdate(); systemData.lastSettingsFile = gPar->Get<QString>("default_settings_path") + QDir::separator() + QFileInfo(filename).fileName(); this->setWindowTitle(QString("Mandelbulber (") + systemData.lastSettingsFile + ")"); }
void Test::testKeyframe() { QString exampleKeyframeFile = QDir::toNativeSeparators(systemData.sharedDir + QDir::separator() + "examples" + QDir::separator() + "keyframe_anim_mandelbulb.fract"); cParameterContainer *testPar = new cParameterContainer; cFractalContainer *testParFractal = new cFractalContainer; cAnimationFrames *testAnimFrames = new cAnimationFrames; cKeyframes *testKeyframes = new cKeyframes; testPar->SetContainerName("main"); InitParams(testPar); /****************** TEMPORARY CODE FOR MATERIALS *******************/ InitMaterialParams(1, testPar); /*******************************************************************/ for (int i = 0; i < NUMBER_OF_FRACTALS; i++) { testParFractal->at(i).SetContainerName(QString("fractal") + QString::number(i)); InitFractalParams(&testParFractal->at(i)); } cImage *image = new cImage(testPar->Get<int>("image_width"), testPar->Get<int>("image_height")); cRenderingConfiguration config; config.DisableRefresh(); config.DisableProgressiveRender(); cSettings parSettings(cSettings::formatFullText); parSettings.BeQuiet(true); parSettings.LoadFromFile(exampleKeyframeFile); parSettings.Decode(testPar, testParFractal, testAnimFrames, testKeyframes); testPar->Set("image_width", 5); testPar->Set("image_height", 5); testPar->Set("keyframe_first_to_render", 50); testPar->Set("keyframe_last_to_render", 55); cKeyframeAnimation *testKeyframeAnimation = new cKeyframeAnimation( gMainInterface, testKeyframes, image, NULL, testPar, testParFractal, NULL); QVERIFY2(testKeyframeAnimation->slotRenderKeyframes(), "keyframe render failed."); delete image; delete testKeyframes; delete testAnimFrames; delete testParFractal; delete testPar; delete testKeyframeAnimation; testKeyframeAnimation = NULL; return; }
void cUndo::Store(cParameterContainer *par, cFractalContainer *parFractal, cAnimationFrames *frames, cKeyframes *keyframes) { sUndoRecord record; // autosave WriteLog("Autosave started", 2); cSettings parSettings(cSettings::formatCondensedText); parSettings.CreateText(gPar, gParFractal, gAnimFrames, gKeyframes); parSettings.SaveToFile(systemData.GetAutosaveFile()); WriteLog("Autosave finished", 2); WriteLog("cUndo::Store() started", 2); record.mainParams = *par; record.fractParams = *parFractal; if (frames) { record.animationFrames = *frames; record.hasFrames = true; } else { record.hasFrames = false; record.animationFrames = cAnimationFrames(); } if (keyframes) { record.animationKeyframes = *keyframes; record.hasKeyframes = true; } else { record.hasKeyframes = false; record.animationKeyframes = cKeyframes(); } if (undoBuffer.size() > level) { for (int i = undoBuffer.size() - 1; i >= level; i--) { undoBuffer.removeAt(i); } } undoBuffer.append(record); level++; WriteLog("cUndo::Store() finished", 2); }
void RenderWindow::slotMenuLoadSettingsFromFile(QString fileName) { cSettings parSettings(cSettings::formatFullText); gMainInterface->DisablePeriodicRefresh(); gInterfaceReadyForSynchronization = false; parSettings.LoadFromFile(fileName); parSettings.Decode(gPar, gParFractal, gAnimFrames, gKeyframes); gMainInterface->RebuildPrimitives(gPar); gMainInterface->materialListModel->Regenerate(); gInterfaceReadyForSynchronization = true; gMainInterface->SynchronizeInterface(gPar, gParFractal, qInterface::write); gMainInterface->ComboMouseClickUpdate(); systemData.lastSettingsFile = fileName; SaveSettingsToRecent(fileName); setWindowTitle(QString("Mandelbulber (") + fileName + ")"); gFlightAnimation->RefreshTable(); gKeyframeAnimation->RefreshTable(); gMainInterface->ReEnablePeriodicRefresh(); showDescriptionPopup(); }
void cCommandLineInterface::ReadCLI (void) { bool checkParse = true; bool settingsSpecified = false; QTextStream out(stdout); // show input help only if(cliData.showInputHelp) { out << QObject::tr("Mandelbulber also accepts an arbitrary number of input files\n" "These files can be of type:\n" ".fract File - An ordinary fractal file\n" ".fractlist File - A queue file, all entries inside the queue file will be added to the current queue\n" "Folder - if the specified argument is a folder all .fract files inside the folder will be added to the queue\n"); out.flush(); exit(0); } // list parameters only if(cliData.listParameters) { QList<QString> listOfParameters = gPar->GetListOfParameters(); out << cHeadless::colorize("\nList of main parameters:\n", cHeadless::ansiYellow, cHeadless::noExplicitColor, true); out << "KEY=VALUE\n"; for(int i = 0; i < listOfParameters.size(); i++) { QString parameterName = listOfParameters.at(i); QString defaultValue = gPar->GetDefault<QString>(parameterName); out << parameterName + "=" + defaultValue + "\n"; } QList<QString> listOfFractalParameters = gParFractal->at(0).GetListOfParameters(); out << cHeadless::colorize(QObject::tr("\nList of fractal parameters:\n"), cHeadless::ansiYellow, cHeadless::noExplicitColor, true); for(int i = 0; i < listOfFractalParameters.size(); i++) { QString parameterName = listOfFractalParameters.at(i); QString defaultValue = gParFractal->at(0).GetDefault<QString>(parameterName); out << parameterName + "=" + defaultValue + "\n"; } out.flush(); exit(0); } // check netrender server / client if(cliData.server) { int port = gPar->Get<int>("netrender_server_local_port"); if(cliData.portText != "") { port = cliData.portText.toInt(&checkParse); if(!checkParse || port <= 0){ cErrorMessage::showMessage(QObject::tr("Specified server port is invalid\n"), cErrorMessage::errorMessage); parser.showHelp(cliErrorServerInvalidPort); } gPar->Set("netrender_server_local_port", port); } cliData.nogui = true; systemData.noGui = true; gNetRender->SetServer(gPar->Get<int>("netrender_server_local_port")); QElapsedTimer timer; timer.start(); if(systemData.noGui) { out << QObject::tr("NetRender - Waiting for clients\n"); out.flush(); } while(timer.elapsed() < 5000) { gApplication->processEvents(); } } else if(cliData.host != "") { int port = gPar->Get<int>("netrender_client_remote_port"); gPar->Set("netrender_client_remote_address", cliData.host); if(cliData.portText != "") { port = cliData.portText.toInt(&checkParse); if(!checkParse || port <= 0){ cErrorMessage::showMessage(QObject::tr("Specified client port is invalid\n"), cErrorMessage::errorMessage); parser.showHelp(cliErrorClientInvalidPort); } gPar->Set("netrender_client_remote_port", port); } cliData.nogui = true; systemData.noGui = true; cliTODO = modeNetrender; return; } if(cliData.queue) { cliTODO = modeQueue; settingsSpecified = true; cliData.nogui = true; systemData.noGui = true; try { gQueue = new cQueue(gMainInterface, systemData.dataDirectory + "queue.fractlist", systemData.dataDirectory + "queue", NULL); } catch(QString &ex) { cErrorMessage::showMessage(QObject::tr("Cannot init queue: ") + ex, cErrorMessage::errorMessage); parser.showHelp(cliErrorQueueInit); } } else { if(args.size() > 0){ // file specified -> load it if(args.size() == 1 && QFileInfo(args[0]).suffix() != QString("fractlist") && !QDir(args[0]).exists()) { QString filename = args[0]; if(!QFile::exists(filename)) { // try to find settings in default settings path filename = systemData.dataDirectory + "settings" + QDir::separator() + filename; } if(QFile::exists(filename)) { cSettings parSettings(cSettings::formatFullText); parSettings.LoadFromFile(filename); parSettings.Decode(gPar, gParFractal, gAnimFrames, gKeyframes); settingsSpecified = true; systemData.lastSettingsFile = filename; } else { cErrorMessage::showMessage(QObject::tr("Cannot load file!\n"), cErrorMessage::errorMessage); qCritical() << "\nSetting file " << filename << " not found\n"; parser.showHelp(cliErrorLoadSettingsFile); } } else { // queue render cliTODO = modeQueue; cliData.nogui = true; systemData.noGui = true; try { gQueue = new cQueue(gMainInterface, systemData.dataDirectory + "queue.fractlist", systemData.dataDirectory + "queue", NULL); } catch(QString &ex) { cErrorMessage::showMessage(QObject::tr("Cannot init queue: ") + ex, cErrorMessage::errorMessage); parser.showHelp(cliErrorQueueInit); } for(int i = 0; i < args.size(); i++) { QString filename = args[i]; if(QDir(args[i]).exists()) { // specified input is a folder, load all fractal files contained in this folder gQueue->AppendFolder(filename); settingsSpecified = true; } else if(QFileInfo(filename).suffix() == QString("fractlist")) { // specified input is a queue list file, append all entries to the current queue gQueue->AppendList(filename); settingsSpecified = true; } else { // specified input can only be an ordinary fract file, try to append to queuelist gQueue->Append(filename); settingsSpecified = true; } } } } } // overwriting parameters if(cliData.overrideParametersText != "") { QStringList overrideParameters = cliData.overrideParametersText.split("#", QString::SkipEmptyParts); for(int i = 0; i < overrideParameters.size(); i++) { int fractalIndex = -1; QRegularExpression reType("^fractal([0-9]+)_(.*)$"); QRegularExpressionMatch matchType = reType.match(overrideParameters[i]); if (matchType.hasMatch()) { fractalIndex = matchType.captured(1).toInt() - 1; overrideParameters[i] = matchType.captured(2); } QStringList overrideParameter = overrideParameters[i].split(QRegExp("\\=")); if(overrideParameter.size() == 2) { if(fractalIndex >= 0 && fractalIndex < NUMBER_OF_FRACTALS) { gParFractal->at(fractalIndex).Set(overrideParameter[0].trimmed(), overrideParameter[1].trimmed()); } else { gPar->Set(overrideParameter[0].trimmed(), overrideParameter[1].trimmed()); } } } } // specified resolution if(cliData.resolution != "") { QStringList resolutionParameters = cliData.resolution.split(QRegExp("x")); if(resolutionParameters.size() == 2) { int xRes = resolutionParameters[0].toInt(&checkParse); int yRes = resolutionParameters[1].toInt(&checkParse); if(!checkParse || xRes <= 0 || yRes <= 0){ cErrorMessage::showMessage(QObject::tr("Specified resolution not valid\n" "both dimensions need to be > 0"), cErrorMessage::errorMessage); parser.showHelp(cliErrorResolutionInvalid); } gPar->Set("image_width", xRes); gPar->Set("image_height", yRes); } else{ cErrorMessage::showMessage(QObject::tr("Specified resolution not valid\n" "resolution has to be in the form WIDTHxHEIGHT"), cErrorMessage::errorMessage); parser.showHelp(cliErrorResolutionInvalid); } } // specified frames per keyframe if(cliData.fpkText != "") { int fpk = cliData.fpkText.toInt(&checkParse); if(!checkParse || fpk <= 0){ cErrorMessage::showMessage(QObject::tr("Specified frames per key not valid\n" "need to be > 0"), cErrorMessage::errorMessage); parser.showHelp(cliErrorFPKInvalid); } gPar->Set("frames_per_keyframe", fpk); } // specified image file format if(cliData.imageFileFormat != "") { QStringList allowedImageFileFormat; allowedImageFileFormat << "jpg" << "png" << "png16" << "png16alpha" << "exr"; if(!allowedImageFileFormat.contains(cliData.imageFileFormat)){ cErrorMessage::showMessage(QObject::tr("Specified imageFileFormat is not valid\n" "allowed formats are: ") + allowedImageFileFormat.join(", "), cErrorMessage::errorMessage); parser.showHelp(cliErrorImageFileFormatInvalid); } } else { cliData.imageFileFormat = "jpg"; } //flight animation if(cliData.flight) { if(gAnimFrames->GetNumberOfFrames() > 0) { cliTODO = modeFlight; cliData.nogui = true; systemData.noGui = true; } else { cErrorMessage::showMessage(QObject::tr("There are no flight animation frames in specified settings file"), cErrorMessage::errorMessage); parser.showHelp(cliErrorFlightNoFrames); } } //keyframe animation if(cliData.keyframe) { if(cliTODO == modeFlight) { cErrorMessage::showMessage(QObject::tr("You cannot render keyframe animation at the same time as flight animation"), cErrorMessage::errorMessage); } else { if(gKeyframes->GetNumberOfFrames() > 0) { cliTODO = modeKeyframe; cliData.nogui = true; systemData.noGui = true; } else { cErrorMessage::showMessage(QObject::tr("There are no keyframes in specified settings file"), cErrorMessage::errorMessage); parser.showHelp(cliErrorKeyframeNoFrames); } } } // start frame of animation if (cliData.startFrameText != "") { int startFrame = cliData.startFrameText.toInt(&checkParse); if (cliTODO == modeFlight) { if (startFrame <= gAnimFrames->GetNumberOfFrames()) { gPar->Set("flight_first_to_render", startFrame); } else { cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(gAnimFrames->GetNumberOfFrames()), cErrorMessage::errorMessage); parser.showHelp(cliErrorFlightStartFrameOutOfRange); } } if (cliTODO == modeKeyframe) { int numberOfFrames = (gKeyframes->GetNumberOfFrames() - 1) * gPar->Get<int>("frames_per_keyframe"); if (numberOfFrames < 0) numberOfFrames = 0; if (startFrame <= numberOfFrames) { gPar->Set("keyframe_first_to_render", startFrame); } else { cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(numberOfFrames), cErrorMessage::errorMessage); parser.showHelp(cliErrorKeyframeStartFrameOutOfRange); } } } // end frame of animation if (cliData.endFrameText != "") { int endFrame = cliData.endFrameText.toInt(&checkParse); if (cliTODO == modeFlight) { if (endFrame <= gAnimFrames->GetNumberOfFrames()) { if (endFrame > gPar->Get<int>("flight_first_to_render")) { gPar->Set("flight_last_to_render", endFrame); } else { cErrorMessage::showMessage(QObject::tr("End frame has to be greater than start frame which is %1").arg(gPar->Get<int>("flight_first_to_render")), cErrorMessage::errorMessage); parser.showHelp(cliErrorFlightEndFrameSmallerStartFrame); } } else { cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(gAnimFrames->GetNumberOfFrames()), cErrorMessage::errorMessage); parser.showHelp(cliErrorFlightEndFrameOutOfRange); } } if (cliTODO == modeKeyframe) { int numberOfFrames = (gKeyframes->GetNumberOfFrames() - 1) * gPar->Get<int>("frames_per_keyframe"); if (numberOfFrames < 0) numberOfFrames = 0; if (endFrame <= numberOfFrames) { if (endFrame > gPar->Get<int>("keyframe_first_to_render")) { gPar->Set("keyframe_last_to_render", endFrame); } else { cErrorMessage::showMessage(QObject::tr("End frame has to be greater than start frame which is %1").arg(gPar->Get<int>("keyframe_first_to_render")), cErrorMessage::errorMessage); parser.showHelp(cliErrorKeyframeEndFrameSmallerStartFrame); } } else { cErrorMessage::showMessage(QObject::tr("Animation has only %1 frames").arg(numberOfFrames), cErrorMessage::errorMessage); parser.showHelp(cliErrorKeyframeEndFrameOutOfRange); } } } //folder for animation frames if(cliData.outputText != "" && cliTODO == modeFlight) { gPar->Set("anim_flight_dir", cliData.outputText); } if(cliData.outputText != "" && cliTODO == modeKeyframe) { gPar->Set("anim_keyframe_dir", cliData.outputText); } if(!settingsSpecified && cliData.nogui && cliTODO != modeNetrender) { cErrorMessage::showMessage(QObject::tr("You have to specify a settings file, for this configuration!"), cErrorMessage::errorMessage); parser.showHelp(cliErrorSettingsFileNotSpecified); } if(cliData.nogui && cliTODO != modeKeyframe && cliTODO != modeFlight && cliTODO != modeQueue) { //creating output filename if it's not specified if(cliData.outputText == "") { cliData.outputText = gPar->Get<QString>("default_image_path") + QDir::separator(); cliData.outputText += QFileInfo(systemData.lastSettingsFile).completeBaseName(); } cliTODO = modeStill; return; } }
// adds dynamic actions to the toolbar (example settings) void RenderWindow::slotPopulateToolbar(bool completeRefresh) { WriteLog("cInterface::PopulateToolbar(QWidget *window, QToolBar *toolBar) started", 2); QDir toolbarDir = QDir(systemData.dataDirectory + "toolbar"); toolbarDir.setSorting(QDir::Time); QStringList toolbarFiles = toolbarDir.entryList(QDir::NoDotAndDotDot | QDir::Files); QSignalMapper *mapPresetsFromExamplesLoad = new QSignalMapper(this); QSignalMapper *mapPresetsFromExamplesRemove = new QSignalMapper(this); ui->toolBar->setIconSize( QSize(gPar->Get<int>("toolbar_icon_size"), gPar->Get<int>("toolbar_icon_size"))); QList<QAction *> actions = ui->toolBar->actions(); QStringList toolbarInActions; for (int i = 0; i < actions.size(); i++) { QAction *action = actions.at(i); if (action->objectName() == "actionAdd_Settings_to_Toolbar") continue; if (!toolbarFiles.contains(action->objectName()) || completeRefresh) { // preset has been removed ui->toolBar->removeAction(action); } else { toolbarInActions << action->objectName(); } } for (int i = 0; i < toolbarFiles.size(); i++) { if (toolbarInActions.contains(toolbarFiles.at(i))) { // already present continue; } QString filename = systemData.dataDirectory + "toolbar/" + toolbarFiles.at(i); cThumbnailWidget *thumbWidget = NULL; if (QFileInfo(filename).suffix() == QString("fract")) { WriteLogString("Generating thumbnail for preset", filename, 2); cSettings parSettings(cSettings::formatFullText); parSettings.BeQuiet(true); if (parSettings.LoadFromFile(filename)) { cParameterContainer *par = new cParameterContainer; cFractalContainer *parFractal = new cFractalContainer; InitParams(par); for (int i = 0; i < NUMBER_OF_FRACTALS; i++) InitFractalParams(&parFractal->at(i)); /****************** TEMPORARY CODE FOR MATERIALS *******************/ InitMaterialParams(1, par); /*******************************************************************/ if (parSettings.Decode(par, parFractal)) { thumbWidget = new cThumbnailWidget( gPar->Get<int>("toolbar_icon_size"), gPar->Get<int>("toolbar_icon_size"), 2, this); thumbWidget->UseOneCPUCore(true); thumbWidget->AssignParameters(*par, *parFractal); } delete par; delete parFractal; } } if (thumbWidget) { QWidgetAction *action = new QWidgetAction(this); QToolButton *buttonLoad = new QToolButton; QVBoxLayout *tooltipLayout = new QVBoxLayout; QToolButton *buttonRemove = new QToolButton; tooltipLayout->setContentsMargins(3, 3, 3, 3); tooltipLayout->addWidget(thumbWidget); QIcon iconDelete = QIcon::fromTheme("list-remove", QIcon(":system/icons/list-remove.svg")); buttonRemove->setIcon(iconDelete); buttonRemove->setMaximumSize(QSize(15, 15)); buttonRemove->setStyleSheet("margin-bottom: -2px; margin-left: -2px;"); tooltipLayout->addWidget(buttonRemove); buttonLoad->setToolTip(QObject::tr("Toolbar settings: ") + filename); buttonLoad->setLayout(tooltipLayout); action->setDefaultWidget(buttonLoad); action->setObjectName(toolbarFiles.at(i)); ui->toolBar->addAction(action); mapPresetsFromExamplesLoad->setMapping(buttonLoad, filename); mapPresetsFromExamplesRemove->setMapping(buttonRemove, filename); QApplication::connect(buttonLoad, SIGNAL(clicked()), mapPresetsFromExamplesLoad, SLOT(map())); QApplication::connect( buttonRemove, SIGNAL(clicked()), mapPresetsFromExamplesRemove, SLOT(map())); } } QApplication::connect( mapPresetsFromExamplesLoad, SIGNAL(mapped(QString)), this, SLOT(slotMenuLoadPreset(QString))); QApplication::connect(mapPresetsFromExamplesRemove, SIGNAL(mapped(QString)), this, SLOT(slotMenuRemovePreset(QString))); WriteLog("cInterface::PopulateToolbar(QWidget *window, QToolBar *toolBar) finished", 2); }
void CNetRender::ProcessData(QTcpSocket *socket, sMessage *inMsg) { // beware: payload points to char, first cast to target type pointer, then dereference // *(qint32*)msg->payload //------------------------- CLIENT ------------------------ if(IsClient()) { switch ((netCommand)inMsg->command) { case netRender_VERSION: { sMessage outMsg; if(*(qint32*)inMsg->payload.data() == version) { WriteLog("NetRender - version matches (" + QString::number(version) + "), connection established"); if(systemData.noGui) { QTextStream out(stdout); out << "NetRender - version matches (" + QString::number(version) + "), connection established\n"; } // server version matches, send worker count outMsg.command = netRender_WORKER; QDataStream stream(&outMsg.payload, QIODevice::WriteOnly); stream << workerCount; QString machineName = QHostInfo::localHostName(); stream << (qint32)machineName.toUtf8().size(); stream.writeRawData(machineName.toUtf8().data(), machineName.toUtf8().size()); status = netRender_READY; emit NewStatusClient(); } else { qWarning() << "CNetRender - version mismatch! client version: " << version << ", server: " << *(qint32*)inMsg->payload.data(); outMsg.command = netRender_BAD; } SendData(clientSocket, outMsg); break; } case netRender_STOP: { status = netRender_READY; gMainInterface->stopRequest = true; emit NotifyStatus(); WriteLog("CNetRender - STOP"); break; } case netRender_STATUS: { emit NotifyStatus(); break; } case netRender_JOB: { if (inMsg->id == actualId) { WriteLog("NetRender - received new job"); QDataStream stream(&inMsg->payload, QIODevice::ReadOnly); QByteArray buffer; qint32 size; status = netRender_WORKING; emit NotifyStatus(); // read settings stream >> size; buffer.resize(size); stream.readRawData(buffer.data(), size); settingsText = QString::fromUtf8(buffer.data(), buffer.size()); // read textures for (int i = 0; i < textures.textureList.size(); i++) { stream >> size; if (size > 0) { buffer.resize(size); stream.readRawData(buffer.data(), size); textures.textureList[i]->FromQByteArray(buffer); } } cSettings parSettings(cSettings::formatCondensedText); parSettings.BeQuiet(true); parSettings.LoadFromString(settingsText); parSettings.Decode(gPar, gParFractal); if(!systemData.noGui) { gMainInterface->SynchronizeInterface(gPar, gParFractal, cInterface::write); gMainInterface->StartRender(true); } else { //in noGui mode it must be started as separate thread to be able to process event loop gMainInterface->headless = new cHeadless; QThread *thread = new QThread; //deleted by deleteLater() gMainInterface->headless->moveToThread(thread); QObject::connect(thread, SIGNAL(started()), gMainInterface->headless, SLOT(slotNetRender())); thread->setObjectName("RenderJob"); thread->start(); QObject::connect(gMainInterface->headless, SIGNAL(finished()), gMainInterface->headless, SLOT(deleteLater())); QObject::connect(gMainInterface->headless, SIGNAL(finished()), thread, SLOT(quit())); QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater())); } } else { WriteLog("NetRender - received JOB message with wrong id"); } break; } case netRender_RENDER: { if (inMsg->id == actualId) { QDataStream stream(&inMsg->payload, QIODevice::ReadOnly); qint32 doneSize; stream >> doneSize; QList<int> done; for (int i = 0; i < doneSize; i++) { qint32 line; stream >> line; done.append(line); } emit ToDoListArrived(done); } else {
int main(int argc, char *argv[]) { //Initialization of system functions InitSystem(); //configure debug output qInstallMessageHandler(myMessageOutput); //class for interface windows gMainInterface = new cInterface; WriteLog("Prepare QApplication", 2); QCoreApplication *gCoreApplication = new QCoreApplication(argc, argv); gCoreApplication->setOrganizationName("Mandelbulber"); gCoreApplication->setApplicationName("Mandelbulber"); gCoreApplication->setApplicationVersion(MANDELBULBER_VERSION_STRING); UpdateLanguage(gCoreApplication); cCommandLineInterface commandLineInterface(gApplication); if (commandLineInterface.isNoGUI()) { gApplication = qobject_cast<QApplication *>(gCoreApplication); } else { delete gCoreApplication; gApplication = new QApplication(argc, argv); gApplication->setOrganizationName("Mandelbulber"); gApplication->setApplicationName("Mandelbulber"); gApplication->setApplicationVersion(MANDELBULBER_VERSION_STRING); } //registering types for queued connections qRegisterMetaType<cStatistics>("cStatistics"); qRegisterMetaType<QList<QByteArray> >("QList<QByteArray>"); qRegisterMetaType<QList<int> >("QList<int>"); qRegisterMetaType<cParameterContainer>("cParameterContainer"); qRegisterMetaType<cFractalContainer>("cFractalContainer"); qRegisterMetaType<sTextures>("sTextures"); qRegisterMetaType<cProgressText::enumProgressType>("cProgressText::enumProgressType"); qRegisterMetaType<QVector<int> >("QVector<int>"); qRegisterMetaType<CVector2<double> >("CVector2<double>"); qRegisterMetaType<QMessageBox::StandardButtons>("QMessageBox::StandardButtons"); qRegisterMetaType<QMessageBox::StandardButtons*>("QMessageBox::StandardButtons*"); qRegisterMetaType<cErrorMessage::enumMessageType>("cErrorMessage::enumMessageType"); gErrorMessage = new cErrorMessage; //create default directories and copy all needed files WriteLog("CreateDefaultFolders()", 2); if (!CreateDefaultFolders()) { qCritical() << "Files/directories initialization failed" << endl; return 73; } //create internal database with parameters gPar = new cParameterContainer; gParFractal = new cFractalContainer; //Allocate container for animation frames gAnimFrames = new cAnimationFrames; //Allocate container for key frames gKeyframes = new cKeyframes; gPar->SetContainerName("main"); InitParams(gPar); for (int i = 0; i < NUMBER_OF_FRACTALS; i++) { gParFractal->at(i).SetContainerName(QString("fractal") + QString::number(i)); InitFractalParams(&gParFractal->at(i)); } /****************** TEMPORARY CODE FOR MATERIALS *******************/ //InitMaterialParams(1, gPar); //InitMaterialParams(2, gPar); //InitMaterialParams(3, gPar); /*******************************************************************/ //Define list of fractal formulas DefineFractalList(&fractalList); //Netrender gNetRender = new CNetRender(systemData.numberOfThreads); //loading AppSettings if (QFile(systemData.dataDirectory + "mandelbulber.ini").exists()) { cSettings parSettings(cSettings::formatAppSettings); parSettings.LoadFromFile(systemData.dataDirectory + "mandelbulber.ini"); parSettings.Decode(gPar, gParFractal); } systemData.loggingVerbosity = gPar->Get<int>("logging_verbosity"); UpdateDefaultPaths(); if (!commandLineInterface.isNoGUI()) { UpdateUIStyle(); UpdateUISkin(); } UpdateLanguage(gApplication); commandLineInterface.ReadCLI(); if (!commandLineInterface.isNoGUI()) { gMainInterface->ShowUi(); gFlightAnimation = new cFlightAnimation(gMainInterface, gAnimFrames, gMainInterface->mainImage, gMainInterface->renderedImage, gPar, gParFractal, gMainInterface->mainWindow); gKeyframeAnimation = new cKeyframeAnimation(gMainInterface, gKeyframes, gMainInterface->mainImage, gMainInterface->renderedImage, gPar, gParFractal, gMainInterface->mainWindow); QObject::connect(gFlightAnimation, SIGNAL(updateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType)), gMainInterface->mainWindow, SLOT(slotUpdateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType))); QObject::connect(gFlightAnimation, SIGNAL(updateProgressHide(cProgressText::enumProgressType)), gMainInterface->mainWindow, SLOT(slotUpdateProgressHide(cProgressText::enumProgressType))); QObject::connect(gFlightAnimation, SIGNAL(updateStatistics(cStatistics)), gMainInterface->mainWindow, SLOT(slotUpdateStatistics(cStatistics))); QObject::connect(gKeyframeAnimation, SIGNAL(updateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType)), gMainInterface->mainWindow, SLOT(slotUpdateProgressAndStatus(const QString&, const QString&, double, cProgressText::enumProgressType))); QObject::connect(gKeyframeAnimation, SIGNAL(updateProgressHide(cProgressText::enumProgressType)), gMainInterface->mainWindow, SLOT(slotUpdateProgressHide(cProgressText::enumProgressType))); QObject::connect(gKeyframeAnimation, SIGNAL(updateStatistics(cStatistics)), gMainInterface->mainWindow, SLOT(slotUpdateStatistics(cStatistics))); try { gQueue = new cQueue(gMainInterface, systemData.dataDirectory + "queue.fractlist", systemData.dataDirectory + "queue", gMainInterface->mainWindow); } catch (QString &ex) { cErrorMessage::showMessage(QObject::tr("Cannot init queue: ") + ex, cErrorMessage::errorMessage); return -1; } }