void DeleteAllFilesFromDirectory(QString folder, QString filterExpression)
{
QRegExp rx(filterExpression);
rx.setPatternSyntax(QRegExp::Wildcard);
if(QDir(folder).exists())
{
QDirIterator folderIterator(folder);
while (folderIterator.hasNext())
{
folderIterator.next();
if(folderIterator.fileName() == "." || folderIterator.fileName() == "..") continue;
if(rx.exactMatch(folderIterator.fileName()))
{
if(QFile::remove(folderIterator.filePath()))
{
WriteLogString("File deleted", folderIterator.filePath());
}
else
{
WriteLogString("File not deleted", folderIterator.filePath());
}
}
}
}
else
{
WriteLogString("Directory does not exist", folder);
}
}
void CLog::LogString(int logLevel, std::string&& logString)
{
CSingleLock waitLock(g_logState.critSec);
std::string strData(logString);
StringUtils::TrimRight(strData);
if (!strData.empty())
{
if (g_logState.m_repeatLogLevel == logLevel && g_logState.m_repeatLine == strData)
{
g_logState.m_repeatCount++;
return;
}
else if (g_logState.m_repeatCount)
{
std::string strData2 = StringUtils::Format("Previous line repeats %d times.",
g_logState.m_repeatCount);
PrintDebugString(strData2);
WriteLogString(g_logState.m_repeatLogLevel, strData2);
g_logState.m_repeatCount = 0;
}
g_logState.m_repeatLine = strData;
g_logState.m_repeatLogLevel = logLevel;
PrintDebugString(strData);
WriteLogString(logLevel, strData);
}
}
void UpdateLanguage(QCoreApplication *app)
{
// Set language from locale
WriteLog("Prepare translator");
static QTranslator mandelbulberMainTranslator;
static QTranslator mandelbulberFractalUiTranslator;
static QTranslator qtTranslator;
QString locale = systemData.locale.name();
if (gPar)
{
if (systemData.supportedLanguages.contains(gPar->Get<QString>("language")))
{
locale = gPar->Get<QString>("language");
}
}
WriteLogString("locale", locale);
mandelbulberMainTranslator.load(locale, systemData.sharedDir + QDir::separator() + "language");
mandelbulberFractalUiTranslator.load("qt_data_" + locale,
systemData.sharedDir + QDir::separator() + "language");
WriteLog("Instaling translator");
app->installTranslator(&mandelbulberMainTranslator);
app->installTranslator(&mandelbulberFractalUiTranslator);
// try to load qt translator
if (qtTranslator.load(QLatin1String("qt_") + locale,
QLibraryInfo::location(QLibraryInfo::TranslationsPath))
|| qtTranslator.load(QLatin1String("qtbase_") + locale,
QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
{
app->installTranslator(&qtTranslator);
}
}
bool CreateDirectory(QString qname)
{
if(QDir(qname).exists())
{
WriteLogString("Directory already exists", qname);
return true;
}
else
{
if(QDir().mkdir(qname))
{
WriteLogString("Directory created", qname);
return true;
}
else
{
WriteLogString("Directory can't be created", qname);
qCritical() << "error: directory " << qname << " cannot be created" << endl;
return false;
}
}
}
void UpdateLanguage (QCoreApplication *app)
{
// Set language from locale
WriteLog("Prepare translator");
static QTranslator main_translator;
static QTranslator qt_data_translator;
QString locale = systemData.locale.name();
if(gPar)
{
if(systemData.supportedLanguages.contains(gPar->Get<QString>("language")))
{
locale = gPar->Get<QString>("language");
}
}
WriteLogString("locale", locale);
main_translator.load(locale, systemData.sharedDir + QDir::separator() + "language");
qt_data_translator.load("qt_data_" + locale, systemData.sharedDir + QDir::separator() + "language");
WriteLog("Instaling translator");
app->installTranslator(&main_translator);
app->installTranslator(&qt_data_translator);
}
// 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);
}
bool InitSystem(void)
{
setlocale(LC_ALL, "");
systemData.locale = QLocale::system();
systemData.locale.setNumberOptions(QLocale::OmitGroupSeparator);
QLocale::setDefault(systemData.locale);
QTextStream out(stdout);
systemData.homedir = QDir::homePath() + QDir::separator();
#ifdef WIN32 /* WINDOWS */
systemData.sharedDir = (QDir::currentPath() + QDir::separator());
#else
systemData.sharedDir = QString(SHARED_DIR) + QDir::separator();
#endif /* WINDOWS */
//logfile
#ifdef WIN32 /* WINDOWS */
systemData.logfileName = systemData.homedir + "mandelbulber_log.txt";
#else
systemData.logfileName = systemData.homedir + ".mandelbulber_log.txt";
#endif
FILE *logfile = fopen(systemData.logfileName.toUtf8().constData(), "w");
fclose(logfile);
out << "Mandelbulber " << MANDELBULBER_VERSION_STRING << ", build date: " << QString(__DATE__) << "\n";
out << "Log file name: " << systemData.logfileName << endl;
WriteLogString("Mandelbulber version", QString(MANDELBULBER_VERSION_STRING));
WriteLogString("Mandelbulber compilation date", QString(__DATE__) + " " + QString(__TIME__));
//detecting number of CPU cores
systemData.numberOfThreads = get_cpu_count();
//NR_THREADS = 1;
printf("Detected %d CPUs\n", systemData.numberOfThreads);
WriteLogDouble("CPUs detected", systemData.numberOfThreads);
#ifdef ONETHREAD //for debugging
NR_THREADS = 1;
#endif
//data directory location
#ifdef WIN32 /* WINDOWS */
systemData.dataDirectory = systemData.homedir + "mandelbulber" + QDir::separator();
#else
systemData.dataDirectory = systemData.homedir + ".mandelbulber" + QDir::separator();
#endif
out << "Default data directory: " << systemData.dataDirectory << endl;
WriteLogString("Default data directory", systemData.dataDirectory);
systemData.thumbnailDir = systemData.dataDirectory + "thumbnails" + QDir::separator();
systemData.autosaveFile = systemData.dataDirectory + ".autosave.fract";
//*********** temporary set to false ************
systemData.noGui = false;
systemData.lastSettingsFile = systemData.dataDirectory + "settings" + QDir::separator() + QString("settings.fract");
systemData.lastImageFile = systemData.dataDirectory + "images" + QDir::separator() + QString("image.jpg");
systemData.lastImagePaletteFile = systemData.sharedDir + "textures" + QDir::separator() + QString("colour palette.jpg");
QLocale systemLocale = QLocale::system();
systemData.decimalPoint = systemLocale.decimalPoint();
WriteLogString("Decimal point", QString(systemData.decimalPoint));
systemData.supportedLanguages.insert("en_EN", "English");
systemData.supportedLanguages.insert("pl_PL", "Polski");
systemData.supportedLanguages.insert("de_DE", "Deutsch");
systemData.supportedLanguages.insert("it_IT", "Italiano");
//get number of columns of console
#ifdef WIN32
systemData.terminalWidth = 80;
#else
handle_winch(-1);
#endif
return true;
}
int fcopy(QString source, QString dest)
{
// ------ file reading
FILE * pFile;
long int lSize;
char *buffer;
size_t result;
pFile = fopen(source.toUtf8().constData(), "rb");
if (pFile == NULL)
{
qCritical() << "Can't open source file for copying: " << source << endl;
WriteLogString("Can't open source file for copying", source);
return 1;
}
// obtain file size:
fseek(pFile, 0, SEEK_END);
lSize = ftell(pFile);
rewind(pFile);
// allocate memory to contain the whole file:
if(lSize > 0)
{
buffer = new char[lSize];
// copy the file into the buffer:
result = fread(buffer, 1, lSize, pFile);
if (result != (size_t)lSize)
{
qCritical() << "Can't read source file for copying: " << source << endl;
WriteLogString("Can't read source file for copying", source);
delete[] buffer;
fclose(pFile);
return 2;
}
}
else
{
qCritical() << "Can't obtain file size: " << source;
fclose(pFile);
return 4;
}
fclose(pFile);
// ----- file writing
pFile = fopen(dest.toUtf8().constData(), "wb");
if (pFile == NULL)
{
qCritical() << "Can't open destination file for copying: " << dest << endl;
WriteLogString("Can't open destination file for copying", dest);
delete[] buffer;
return 3;
}
fwrite(buffer, 1, lSize, pFile);
fclose(pFile);
delete [] buffer;
WriteLogString("File copied", dest);
return 0;
}
void cOpenClHardware::ListOpenClDevices()
{
devicesInformation.clear();
clDeviceWorkers.clear();
clDevices.clear();
cl_int err = 0;
if (contextReady)
{
clDevices = context->getInfo<CL_CONTEXT_DEVICES>(&err);
if (checkErr(err, "Context::getInfo()"))
{
if (clDevices.size() > 0)
{
for (unsigned int i = 0; i < clDevices.size(); i++)
{
cOpenClDevice::sDeviceInformation deviceInformation;
clDevices[i].getInfo(CL_DEVICE_MAX_COMPUTE_UNITS, &deviceInformation.deviceAvailable);
clDevices[i].getInfo(CL_DEVICE_COMPILER_AVAILABLE, &deviceInformation.compilerAvailable);
clDevices[i].getInfo(CL_DEVICE_DOUBLE_FP_CONFIG, &deviceInformation.doubleFpConfig);
clDevices[i].getInfo(
CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, &deviceInformation.globalMemCacheSize);
clDevices[i].getInfo(
CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, &deviceInformation.globalMemCachelineSize);
clDevices[i].getInfo(CL_DEVICE_GLOBAL_MEM_SIZE, &deviceInformation.globalMemSize);
clDevices[i].getInfo(CL_DEVICE_LOCAL_MEM_SIZE, &deviceInformation.localMemSize);
clDevices[i].getInfo(CL_DEVICE_MAX_CLOCK_FREQUENCY, &deviceInformation.maxClockFrequency);
clDevices[i].getInfo(CL_DEVICE_MAX_COMPUTE_UNITS, &deviceInformation.maxComputeUnits);
clDevices[i].getInfo(
CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, &deviceInformation.maxConstantBufferSize);
clDevices[i].getInfo(CL_DEVICE_MAX_MEM_ALLOC_SIZE, &deviceInformation.maxMemAllocSize);
clDevices[i].getInfo(CL_DEVICE_MAX_PARAMETER_SIZE, &deviceInformation.maxParameterSize);
clDevices[i].getInfo(CL_DEVICE_MAX_WORK_GROUP_SIZE, &deviceInformation.maxWorkGroupSize);
std::string deviceName;
clDevices[i].getInfo(CL_DEVICE_NAME, &deviceName);
deviceInformation.deviceName = QString(deviceName.c_str());
std::string deviceVersion;
clDevices[i].getInfo(CL_DEVICE_VERSION, &deviceVersion);
deviceInformation.deviceVersion = QString(deviceVersion.c_str());
std::string driverVersion;
clDevices[i].getInfo(CL_DRIVER_VERSION, &driverVersion);
deviceInformation.driverVersion = QString(driverVersion.c_str());
WriteLogInt("OpenCL Device # ", i, 2);
WriteLogInt("CL_DEVICE_MAX_COMPUTE_UNITS", deviceInformation.deviceAvailable, 2);
WriteLogInt("CL_DEVICE_COMPILER_AVAILABLE", deviceInformation.compilerAvailable, 2);
WriteLogInt("CL_DEVICE_DOUBLE_FP_CONFIG", deviceInformation.doubleFpConfig, 2);
WriteLogInt("CL_DEVICE_GLOBAL_MEM_CACHE_SIZE", deviceInformation.globalMemCacheSize, 2);
WriteLogInt(
"CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE", deviceInformation.globalMemCachelineSize, 2);
WriteLogInt("CL_DEVICE_GLOBAL_MEM_SIZE", deviceInformation.globalMemSize, 2);
WriteLogInt("CL_DEVICE_LOCAL_MEM_SIZE", deviceInformation.localMemSize, 2);
WriteLogInt("CL_DEVICE_MAX_CLOCK_FREQUENCY", deviceInformation.maxClockFrequency, 2);
WriteLogInt("CL_DEVICE_MAX_COMPUTE_UNITS", deviceInformation.maxComputeUnits, 2);
WriteLogInt(
"CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE", deviceInformation.maxConstantBufferSize, 2);
WriteLogInt("CL_DEVICE_MAX_MEM_ALLOC_SIZE", deviceInformation.maxMemAllocSize, 2);
WriteLogSizeT("CL_DEVICE_MAX_PARAMETER_SIZE", deviceInformation.maxParameterSize, 2);
WriteLogSizeT("CL_DEVICE_MAX_WORK_GROUP_SIZE", deviceInformation.maxWorkGroupSize, 2);
WriteLogString("CL_DEVICE_NAME", deviceInformation.deviceName, 2);
WriteLogString("CL_DEVICE_VERSION", deviceInformation.deviceVersion, 2);
WriteLogString("CL_DRIVER_VERSION", deviceInformation.driverVersion, 2);
// calculate hash code
QCryptographicHash hashCrypt(QCryptographicHash::Md4);
hashCrypt.addData(deviceInformation.deviceName.toLocal8Bit());
hashCrypt.addData(deviceInformation.deviceVersion.toLocal8Bit());
char index = char(i);
hashCrypt.addData(&index);
deviceInformation.hash = hashCrypt.result().left(3);
devicesInformation.append(deviceInformation);
clDeviceWorkers.append(cOpenClDevice(clDevices[i], deviceInformation));
}
}
else
{
cErrorMessage::showMessage(
QObject::tr("There are no available devices for selected OpenCL platform"),
cErrorMessage::errorMessage);
}
}
else
{
cErrorMessage::showMessage(QObject::tr("Cannot list devices from selected OpenCL platform"),
cErrorMessage::errorMessage);
}
}
}
