void WriteThread::internalWrite() { if(stopIt) return; //read one block if(theBlockList.size()<=0) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"["+QString::number(id)+"] End detected of the file"); return; } else { QMutexLocker lock_mutex(&accessList); blockArray=theBlockList.first(); theBlockList.removeFirst(); } //write one block freeBlock.release(); if(stopIt) return; #ifdef ULTRACOPIER_PLUGIN_DEBUG stat=Write; #endif bytesWriten=file.write(blockArray); #ifdef ULTRACOPIER_PLUGIN_DEBUG stat=Idle; #endif //mutex for stream this data if(CurentCopiedSize==0) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+QString::number(id)+"] emit writeIsStarted()"); emit writeIsStarted(); } CurentCopiedSize+=bytesWriten; if(stopIt) return; if(file.error()!=QFile::NoError) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"["+QString::number(id)+"] "+QString("Error in writing: %1 (%2)").arg(file.errorString()).arg(file.error())); errorString_internal=QString("Error in writing: %1 (%2)").arg(file.errorString()).arg(file.error()); stopIt=true; emit error(); return; } if(bytesWriten!=blockArray.size()) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"["+QString::number(id)+"] "+QString("Error in writing, bytesWriten: %1, blockArray.size(): %2").arg(bytesWriten).arg(blockArray.size())); errorString_internal=QString("Error in writing, bytesWriten: %1, blockArray.size(): %2").arg(bytesWriten).arg(blockArray.size()); stopIt=true; emit error(); return; } lastGoodPosition+=bytesWriten; }
void SystrayIcon::reloadEngineList() { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"start"); copyMenu->clear(); if(engineEntryList.size()==0) { copyMenu->setEnabled(false); return; } ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"engineEntryList.size(): "+QString::number(engineEntryList.size())); copyMenu->setEnabled(true); if(engineEntryList.size()==1) { QAction *copy=new QAction(IconAdd,tr("Add ©"),copyMenu); connect(copy,&QAction::triggered,this,&SystrayIcon::CatchCopyQuery); copy->setData(engineEntryList.first().name); copyMenu->addAction(copy); if(!engineEntryList.first().canDoOnlyCopy) { QAction *transfer=new QAction(IconAdd,tr("Add &transfer"),copyMenu); connect(transfer,&QAction::triggered,this,&SystrayIcon::CatchTransferQuery); transfer->setData(engineEntryList.first().name); copyMenu->addAction(transfer); QAction *move=new QAction(IconAdd,tr("Add &move"),copyMenu); connect(move,&QAction::triggered,this,&SystrayIcon::CatchMoveQuery); move->setData(engineEntryList.first().name); copyMenu->addAction(move); } } else { int index=0; while(index<engineEntryList.size()) { QMenu * menu=new QMenu(engineEntryList.at(index).name); QAction *copy=new QAction(IconAdd,tr("Add ©"),menu); connect(copy,&QAction::triggered,this,&SystrayIcon::CatchCopyQuery); copy->setData(engineEntryList.at(index).name); menu->addAction(copy); if(!engineEntryList.at(index).canDoOnlyCopy) { QAction *transfer=new QAction(IconAdd,tr("Add &transfer"),menu); connect(transfer,&QAction::triggered,this,&SystrayIcon::CatchTransferQuery); transfer->setData(engineEntryList.at(index).name); menu->addAction(transfer); QAction *move=new QAction(IconAdd,tr("Add &move"),menu); connect(move,&QAction::triggered,this,&SystrayIcon::CatchMoveQuery); move->setData(engineEntryList.at(index).name); menu->addAction(move); } copyMenu->addMenu(menu); index++; } } }
TransferModel::currentTransfertItem TransferModel::getCurrentTransfertItem() { currentTransfertItem returnItem; returnItem.haveItem=startId.size()>0; if(returnItem.haveItem) { if(!internalRunningOperation.contains(*startId.constBegin())) { returnItem.haveItem=false; return returnItem; } const ItemOfCopyListWithMoreInformations &itemTransfer=internalRunningOperation[*startId.constBegin()]; returnItem.from=itemTransfer.generalData.sourceFullPath; returnItem.to=itemTransfer.generalData.destinationFullPath; returnItem.current_file=itemTransfer.generalData.destinationFileName+", "+facilityEngine->sizeToString(itemTransfer.generalData.size); switch(itemTransfer.actionType) { case Ultracopier::CustomOperation: if(!itemTransfer.custom_with_progression) returnItem.progressBar_file=-1; else { if(itemTransfer.generalData.size>0) returnItem.progressBar_file=((double)itemTransfer.currentProgression/itemTransfer.generalData.size)*65535; else returnItem.progressBar_file=-1; } break; case Ultracopier::Transfer: if(itemTransfer.generalData.size>0) returnItem.progressBar_file=((double)itemTransfer.currentProgression/itemTransfer.generalData.size)*65535; else returnItem.progressBar_file=0; break; //should never pass here case Ultracopier::PostOperation: ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QString("wrong action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType)); returnItem.progressBar_file=65535; break; //should never pass here case Ultracopier::PreOperation: ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QString("wrong action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType)); returnItem.progressBar_file=0; break; default: returnItem.progressBar_file=0; ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QString("unknow action type for file %1: actionType: %2").arg(itemTransfer.generalData.id).arg(itemTransfer.actionType)); break; } } /* else ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QString("No have running item"));*/ return returnItem; }
void WriteThread::postOperation() { if(postOperationRequested) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,QStringLiteral("[")+QString::number(id)+QStringLiteral("] double event dropped")); return; } postOperationRequested=true; ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("[")+QString::number(id)+QStringLiteral("] start")); emit internalStartClose(); }
/* drag event processing need setAcceptDrops(true); into the constructor need implementation to accept the drop: void dragEnterEvent(QDragEnterEvent* event); void dragMoveEvent(QDragMoveEvent* event); void dragLeaveEvent(QDragLeaveEvent* event); */ void Themes::dropEvent(QDropEvent *event) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("start")); const QMimeData* mimeData = event->mimeData(); if(mimeData->hasUrls()) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("hasUrls")); emit urlDropped(mimeData->urls()); event->acceptProposedAction(); } }
void Themes::dragEnterEvent(QDragEnterEvent* event) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("start")); // if some actions should not be usable, like move, this code must be adopted const QMimeData* mimeData = event->mimeData(); if(mimeData->hasUrls()) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("hasUrls")); event->acceptProposedAction(); } }
/** \brief For catch an action on the systray icon \param reason Why it activated */ void Themes::catchAction(QSystemTrayIcon::ActivationReason reason) { if(reason==QSystemTrayIcon::DoubleClick || reason==QSystemTrayIcon::Trigger) { sysTrayIcon->hide(); this->show(); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,"Double Click detected"); } else ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QStringLiteral("reason: %1").arg(reason)); }
void WriteThread::endIsDetected() { if(endDetected) { ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"["+QString::number(id)+"] double event dropped"); return; } endDetected=true; ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"["+QString::number(id)+"] start"); emit internalStartEndOfFile(); }
/// \brief To catch transfer menu action void SystrayIcon::CatchTransferQuery() { QAction * currentAction=qobject_cast<QAction *>(QObject::sender()); if(currentAction==NULL) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"action not found"); return; } ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"start: "+currentAction->data().toString()); emit addWindowTransfer(currentAction->data().toString()); }
//reopen after an error void ReadThread::reopen() { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+QString::number(id)+"] start"); if(isInReadLoop) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"["+QString::number(id)+"] try reopen where read is not finish"); return; } stopIt=true; emit internalStartReopen(); }
void WriteThread::postOperation() { if(postOperationRequested) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,"["+std::to_string(id)+"] double event dropped"); return; } postOperationRequested=true; ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+std::to_string(id)+"] start"); emit internalStartClose(); }
QWidget * ThemesFactory::options() { if(optionsEngine!=NULL) { bool ok; currentSpeed=optionsEngine->getOptionValue("currentSpeed").toUInt(&ok); if(!ok) currentSpeed=0; ui->comboBox_copyEnd->setCurrentIndex(optionsEngine->getOptionValue("comboBox_copyEnd").toUInt()); ui->speedWithProgressBar->setChecked(optionsEngine->getOptionValue("speedWithProgressBar").toBool()); ui->checkBoxShowSpeed->setChecked(optionsEngine->getOptionValue("checkBoxShowSpeed").toBool()); ui->checkBoxStartWithMoreButtonPushed->setChecked(optionsEngine->getOptionValue("moreButtonPushed").toBool()); ui->showDualProgression->setChecked(optionsEngine->getOptionValue("showDualProgression").toBool()); ui->showProgressionInTheTitle->setChecked(optionsEngine->getOptionValue("showProgressionInTheTitle").toBool()); ui->alwaysOnTop->setChecked(optionsEngine->getOptionValue("alwaysOnTop").toBool()); ui->minimizeToSystray->setChecked(optionsEngine->getOptionValue("minimizeToSystray").toBool()); progressColorWrite=optionsEngine->getOptionValue("progressColorWrite").value<QColor>(); progressColorRead=optionsEngine->getOptionValue("progressColorRead").value<QColor>(); progressColorRemaining=optionsEngine->getOptionValue("progressColorRemaining").value<QColor>(); QPixmap pixmap(75,20); pixmap.fill(progressColorWrite); ui->progressColorWrite->setIcon(pixmap); pixmap.fill(progressColorRead); ui->progressColorRead->setIcon(pixmap); pixmap.fill(progressColorRemaining); ui->progressColorRemaining->setIcon(pixmap); updateSpeed(); updateProgressionColorBar(); connect(ui->alwaysOnTop,&QCheckBox::stateChanged,this,&ThemesFactory::alwaysOnTop); connect(ui->checkBoxShowSpeed,&QCheckBox::stateChanged,this,&ThemesFactory::checkBoxShowSpeed); connect(ui->minimizeToSystray,&QCheckBox::stateChanged,this,&ThemesFactory::minimizeToSystray); connect(ui->checkBox_limitSpeed,&QCheckBox::stateChanged,this,&ThemesFactory::uiUpdateSpeed); connect(ui->SliderSpeed,&QAbstractSlider::valueChanged,this,&ThemesFactory::on_SliderSpeed_valueChanged); connect(ui->limitSpeed,static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &ThemesFactory::uiUpdateSpeed); connect(ui->checkBoxShowSpeed,&QAbstractButton::toggled,this,&ThemesFactory::checkBoxShowSpeedHaveChanged); connect(ui->checkBoxStartWithMoreButtonPushed,&QAbstractButton::toggled,this,&ThemesFactory::checkBoxStartWithMoreButtonPushedHaveChanged); connect(ui->speedWithProgressBar,&QAbstractButton::toggled,this,&ThemesFactory::speedWithProgressBar); connect(ui->comboBox_copyEnd, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,&ThemesFactory::comboBox_copyEnd); connect(ui->showDualProgression,&QCheckBox::stateChanged,this,&ThemesFactory::showDualProgression); connect(ui->showDualProgression,&QCheckBox::stateChanged,this,&ThemesFactory::updateProgressionColorBar); connect(ui->showProgressionInTheTitle,&QCheckBox::stateChanged,this,&ThemesFactory::setShowProgressionInTheTitle); connect(ui->progressColorWrite,&QAbstractButton::clicked,this,&ThemesFactory::progressColorWrite_clicked); connect(ui->progressColorRead, &QAbstractButton::clicked,this,&ThemesFactory::progressColorRead_clicked); connect(ui->progressColorRemaining,&QAbstractButton::clicked,this,&ThemesFactory::progressColorRemaining_clicked); } else ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,"internal error, crash prevented"); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"return the options"); return tempWidget; }
/** \brief To get image into the current themes, or default if not found \param filePath The file path to search, like toto.png resolved with the root of the current themes \see currentStylePath */ QIcon ThemesManager::loadIcon(const QString &fileName) { if(currentPluginIndex==-1) return QIcon(); if(pluginList.at(currentPluginIndex).factory==NULL) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,"Try get icon when the factory is not loaded"); return QIcon(); } ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"Send interface pixmap: "+fileName); return pluginList.at(currentPluginIndex).factory->getIcon(fileName); }
/// \brief Called when event loop is setup void EventDispatcher::initFunction() { if(core==NULL || copyEngineList==NULL) { ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Critical,"Unable to initialize correctly the software"); return; } ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"Initialize the variable of event loop"); connect(copyServer, SIGNAL(newCopy(quint32,QStringList,QStringList)), core, SLOT(newCopy(quint32,QStringList,QStringList))); connect(copyServer, SIGNAL(newCopy(quint32,QStringList,QStringList,QString,QString)), core, SLOT(newCopy(quint32,QStringList,QStringList,QString,QString))); connect(copyServer, SIGNAL(newMove(quint32,QStringList,QStringList)), core, SLOT(newMove(quint32,QStringList,QStringList))); connect(copyServer, SIGNAL(newMove(quint32,QStringList,QStringList,QString,QString)), core, SLOT(newMove(quint32,QStringList,QStringList,QString,QString))); connect(core, SIGNAL(copyFinished(quint32,bool)), copyServer, SLOT(copyFinished(quint32,bool))); connect(core, SIGNAL(copyCanceled(quint32)), copyServer, SLOT(copyCanceled(quint32))); if(localListener.tryConnect()) { stopIt=true; //why before removed??? QCoreApplication::quit(); return; } localListener.listenServer(); //load the systray icon if(backgroundIcon==NULL) { backgroundIcon=new SystrayIcon(); //connect the slot //quit is for this object // connect(core, SIGNAL(newCanDoOnlyCopy(bool)), backgroundIcon, SLOT(newCanDoOnlyCopy(bool))); connect(backgroundIcon, SIGNAL(quit()),this,SLOT(quit())); //show option is for OptionEngine object connect(backgroundIcon, SIGNAL(showOptions()), &optionDialog, SLOT(show())); connect(copyServer, SIGNAL(listenerReady(ListeningState,bool,bool)), backgroundIcon, SLOT(listenerReady(ListeningState,bool,bool))); connect(copyServer, SIGNAL(pluginLoaderReady(CatchState,bool,bool)), backgroundIcon, SLOT(pluginLoaderReady(CatchState,bool,bool))); connect(backgroundIcon, SIGNAL(tryCatchCopy()), copyServer, SLOT(listen())); connect(backgroundIcon, SIGNAL(tryUncatchCopy()), copyServer, SLOT(close())); if(options->getOptionValue("CopyListener","CatchCopyAsDefault").toBool()) copyServer->listen(); ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"copyServer.oneListenerIsLoaded(): "+QString::number(copyServer->oneListenerIsLoaded())); //backgroundIcon->readyToListen(copyServer.oneListenerIsLoaded()); connect(backgroundIcon, SIGNAL(addWindowCopyMove(CopyMode,QString)), core, SLOT(addWindowCopyMove(CopyMode,QString))); connect(backgroundIcon, SIGNAL(addWindowTransfer(QString)), core, SLOT(addWindowTransfer(QString))); connect(copyEngineList, SIGNAL(addCopyEngine(QString,bool)), backgroundIcon, SLOT(addCopyEngine(QString,bool))); connect(copyEngineList, SIGNAL(removeCopyEngine(QString)), backgroundIcon, SLOT(removeCopyEngine(QString))); copyEngineList->setIsConnected(); copyServer->resendState(); } //conntect the last chance signal before quit connect(QCoreApplication::instance(),SIGNAL(aboutToQuit()),this,SLOT(quit())); //connect the slot for the help dialog connect(backgroundIcon,SIGNAL(showHelp()),&theHelp,SLOT(show())); }
void WriteThread::flushBuffer() { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("[")+QString::number(id)+QStringLiteral("] start")); writeFull.release(); writeFull.acquire(); pauseMutex.release(); { QMutexLocker lock_mutex(&accessList); theBlockList.clear(); } ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("[")+QString::number(id)+QStringLiteral("] stop")); }
void WriteThread::endIsDetected() { if(endDetected) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,QStringLiteral("[")+QString::number(id)+QStringLiteral("] double event dropped")); return; } endDetected=true; pauseMutex.release(); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("[")+QString::number(id)+QStringLiteral("] start")); emit internalStartEndOfFile(); }
void Core::newCopyWithoutDestination(const quint32 &orderId,const QStringList &protocolsUsedForTheSources,const QStringList &sources) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"start"); if(openNewCopyEngineInstance(Ultracopier::Copy,false,protocolsUsedForTheSources)==-1) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"Unable to get a copy engine instance"); QMessageBox::critical(NULL,tr("Error"),tr("Unable to get a copy engine instance")); return; } copyList.last().orderId<<orderId; copyList.last().engine->newCopy(sources); copyList.last().interface->haveExternalOrder(); }
bool SessionLoader::getEnabled() { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"start"); //return the value into the variable HKEY ultracopier_regkey; bool temp=false; RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Run"), 0, 0, REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS, 0, &ultracopier_regkey, 0); DWORD kSize=254; if(RegQueryValueEx(ultracopier_regkey,TEXT("ultracopier"),NULL,NULL,(LPBYTE)0,&kSize) == ERROR_SUCCESS) temp=true; RegCloseKey(ultracopier_regkey); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"return this value: "+QString::number(temp)); return temp; }
void WriteThread::internalEndOfFile() { if(!bufferIsEmpty()) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+std::to_string(id)+"] start the write"); emit internalStartWrite(); } else { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"["+std::to_string(id)+"] writeIsStopped"); flushBuffer(); emit writeIsStopped(); } }
/// \brief To add option group to options bool OptionEngine::addOptionGroup(const QString &groupName,const QList<QPair<QString, QVariant> > &KeysList) { ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"start(\""+groupName+"\",[...])"); //search if previous with the same name exists if(GroupKeysList.contains(groupName)) { ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"group already used previously"); return false; } //if the backend is file, enter into the group if(currentBackend==File) settings->beginGroup(groupName); //browse all key, and append it to the key index=0; QList<OptionEngineGroupKey> KeyListTemp; loop_size=KeysList.size(); while(index<loop_size) { OptionEngineGroupKey theCurrentKey; theCurrentKey.defaultValue=KeysList.at(index).second; //if memory backend, load the default value into the current value if(currentBackend==Memory) theCurrentKey.currentValue=theCurrentKey.defaultValue; else { if(settings->contains(KeysList.at(index).first))//if file backend, load the default value from the file theCurrentKey.currentValue=settings->value(KeysList.at(index).first); else //or if not found load the default value and set into the file { theCurrentKey.currentValue=theCurrentKey.defaultValue; //to switch default value if is unchanged //settings->setValue(KeysList.at(index).first,theCurrentKey.defaultValue); } if(settings->status()!=QSettings::NoError) { ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,"Have writing error, switch to memory only options"); #ifdef ULTRACOPIER_VERSION_PORTABLE resources->disableWritablePath(); #endif // ULTRACOPIER_VERSION_PORTABLE currentBackend=Memory; } } GroupKeysList[groupName][KeysList.at(index).first]=theCurrentKey; index++; } //if the backend is file, leave into the group if(currentBackend==File) settings->endGroup(); return true; }
/// \brief To get option value QVariant OptionEngine::getOptionValue(const QString &groupName,const QString &variableName) const { if(GroupKeysList.contains(groupName)) { if(GroupKeysList.value(groupName).contains(variableName)) return GroupKeysList.value(groupName).value(variableName).currentValue; QMessageBox::critical(NULL,"Internal error",tr("The variable was not found: %1 %2").arg(groupName).arg(variableName)); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,"value not found, internal bug, groupName: "+groupName+", variableName: "+variableName); return QVariant(); } QMessageBox::critical(NULL,"Internal error",tr("The variable was not found: %1 %2").arg(groupName).arg(variableName)); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,QString("The variable was not found: %1 %2").arg(groupName).arg(variableName)); //return default value return QVariant(); }
bool MkPath::writeFileDateTime(const QFileInfo &destination) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"writeFileDateTime("+destination.absoluteFilePath()+")"); /** Why not do it with Qt? Because it not support setModificationTime(), and get the time with Qt, that's mean use local time where in C is UTC time */ #ifdef Q_OS_UNIX #ifdef Q_OS_LINUX return utime(destination.absoluteFilePath().toLatin1().data(),&butime)==0; #else //mainly for mac return utime(destination.absoluteFilePath().toLatin1().data(),&butime)==0; #endif #else #ifdef Q_OS_WIN32 #ifdef ULTRACOPIER_PLUGIN_SET_TIME_UNIX_WAY return utime(destination.toLatin1().data(),&butime)==0; #else wchar_t filePath[65535]; if(destination.absoluteFilePath().contains(regRead)) filePath[QDir::toNativeSeparators(QStringLiteral("\\\\?\\")+destination.absoluteFilePath()).toWCharArray(filePath)]=L'\0'; else filePath[QDir::toNativeSeparators(destination.absoluteFilePath()).toWCharArray(filePath)]=L'\0'; HANDLE hFileDestination = CreateFileW(filePath, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL); if(hFileDestination == INVALID_HANDLE_VALUE) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"open failed to write: "+QString::fromWCharArray(filePath)+", error: "+QString::number(GetLastError())); return false; } FILETIME ftCreate, ftAccess, ftWrite; ftCreate.dwLowDateTime=this->ftCreateL; ftCreate.dwHighDateTime=this->ftCreateH; ftAccess.dwLowDateTime=this->ftAccessL; ftAccess.dwHighDateTime=this->ftAccessH; ftWrite.dwLowDateTime=this->ftWriteL; ftWrite.dwHighDateTime=this->ftWriteH; if(!SetFileTime(hFileDestination, &ftCreate, &ftAccess, &ftWrite)) { CloseHandle(hFileDestination); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"unable to set the file time"); return false; } CloseHandle(hFileDestination); return true; #endif #else return false; #endif #endif return false; }
void InternetUpdater::httpFinished() { QVariant redirectionTarget = reply->attribute(QNetworkRequest::RedirectionTargetAttribute); if (!reply->isFinished()) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("get the new update failed: not finished")); reply->deleteLater(); return; } else if (reply->error()) { newUpdateTimer.stop(); newUpdateTimer.start(1000*3600*24); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("get the new update failed: %1").arg(reply->errorString())); reply->deleteLater(); return; } else if (!redirectionTarget.isNull()) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("redirection denied to: %1").arg(redirectionTarget.toUrl().toString())); reply->deleteLater(); return; } const QString &newVersion=QString::fromUtf8(reply->readAll()); if(newVersion.isEmpty()) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,QStringLiteral("version string is empty")); reply->deleteLater(); return; } if(!newVersion.contains(QRegularExpression(QLatin1Literal("^[0-9]+(\\.[0-9]+)+$")))) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Critical,QStringLiteral("version string don't match: %1").arg(newVersion)); reply->deleteLater(); return; } if(newVersion==ULTRACOPIER_VERSION) { reply->deleteLater(); return; } if(PluginsManager::compareVersion(newVersion,QStringLiteral("<="),ULTRACOPIER_VERSION)) { reply->deleteLater(); return; } newUpdateTimer.stop(); emit newUpdate(newVersion); reply->deleteLater(); }
QString PluginInformation::categoryToTranslation(const PluginType &category) const { switch(category) { case PluginType_CopyEngine: return tr("Copy engine"); break; case PluginType_Languages: return tr("Languages"); break; case PluginType_Listener: return tr("Listener"); break; case PluginType_PluginLoader: return tr("Plugin loader"); break; case PluginType_SessionLoader: return tr("Session loader"); break; case PluginType_Themes: return tr("Themes"); break; default: ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"cat translation not found"); return "Unknow"; break; } }
/// \brief get translated text QString PluginInformation::getTranslatedText(const PluginsAvailable &plugin,const QString &informationName,const QString &mainShortName) { int index=0; QString TextFound; while(index<plugin.informations.size()) { if(plugin.informations.at(index).size()==3) { if(plugin.informations.at(index).first()==informationName) { if(plugin.informations.at(index).at(1)==mainShortName) return plugin.informations.at(index).last(); else if(plugin.informations.at(index).at(1)=="en") TextFound=plugin.informations.at(index).last(); } } index++; } #ifdef ULTRACOPIER_DEBUG if(TextFound.isEmpty() || TextFound.isEmpty()) ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"text is not found or empty for: "+informationName+", with the language: "+mainShortName+", for the plugin: "+plugin.path); #endif // ULTRACOPIER_DEBUG return TextFound; }
bool ProductKey::parseKey(QString orgkey) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"ultimate key"); QString key=orgkey; if(orgkey.isEmpty()) key=QString::fromStdString(OptionEngine::optionEngine->getOptionValue("Ultracopier","key")); if(!key.isEmpty()) { QCryptographicHash hash(QCryptographicHash::Sha224); hash.addData(QStringLiteral("U2NgvbKVrVwlaXnx").toUtf8()); hash.addData(key.toUtf8()); const QByteArray &result=hash.result(); if(!result.isEmpty() && result.at(0)==0x00 && result.at(1)==0x00) { if(!orgkey.isEmpty()) OptionEngine::optionEngine->setOptionValue("Ultracopier","key",key.toStdString()); ultimate=true; } else ultimate=false; } else ultimate=false; return ultimate; }
void MkPath::addPath(const QFileInfo& source, const QFileInfo& destination, const ActionType &actionType) { ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("source: %1, destination: %2").arg(source.absoluteFilePath()).arg(destination.absoluteFilePath())); if(stopIt) return; emit internalStartAddPath(source,destination,actionType); }
void CopyListener::onePluginWillBeRemoved(const PluginsAvailable &plugin) { if(plugin.category!=PluginType_Listener) return; int indexPlugin=0; while(indexPlugin<pluginList.size()) { if((plugin.path+PluginsManager::getResolvedPluginName("listener"))==pluginList.at(indexPlugin).path) { int index=0; while(index<copyRunningList.size()) { if(copyRunningList.at(index).listenInterface==pluginList.at(indexPlugin).listenInterface) copyRunningList[index].listenInterface=NULL; index++; } if(pluginList.at(indexPlugin).listenInterface!=NULL) { pluginList.at(indexPlugin).listenInterface->close(); delete pluginList.at(indexPlugin).listenInterface; } if(pluginList.at(indexPlugin).pluginLoader!=NULL) { pluginList.at(indexPlugin).pluginLoader->unload(); delete pluginList.at(indexPlugin).options; } pluginList.removeAt(indexPlugin); sendState(); return; } indexPlugin++; } ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Warning,"not found"); }
void ThemesManager::newOptionValue(const QString &group,const QString &name,const QVariant &value) { if(group=="Themes" && name=="Ultracopier_current_theme") { if(!PluginsManager::pluginsManager->allPluginHaveBeenLoaded()) return; if(currentPluginIndex!=-1 && value.toString()!=pluginList.at(currentPluginIndex).plugin.name) { //int tempCurrentPluginIndex=currentPluginIndex; emit theThemeNeedBeUnloaded(); ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QString("unload the themes: %1 (%2)").arg(pluginList.at(currentPluginIndex).plugin.name).arg(currentPluginIndex)); /* Themes remain loaded for the options *if(pluginList.at(tempCurrentPluginIndex).options!=NULL) { delete pluginList.at(tempCurrentPluginIndex).options; pluginList[tempCurrentPluginIndex].options=NULL; } if(pluginList.at(tempCurrentPluginIndex).factory!=NULL) { delete pluginList.at(tempCurrentPluginIndex).factory; pluginList[tempCurrentPluginIndex].factory=NULL; } if(pluginList.at(tempCurrentPluginIndex).pluginLoader!=NULL) { pluginList.at(tempCurrentPluginIndex).pluginLoader->unload(); delete pluginList.at(tempCurrentPluginIndex).pluginLoader; pluginList[tempCurrentPluginIndex].pluginLoader=NULL; } */ } allPluginIsLoaded(); //emit theThemeIsReloaded(); -> do into allPluginIsLoaded(); now } }
/// \brief Create the manager and load the defaults variables ThemesManager::ThemesManager() { //load the debug engine as external part because ThemesManager is base class stopIt=false; currentPluginIndex=-1; //connect the plugin management PluginsManager::pluginsManager->lockPluginListEdition(); connect(this, &ThemesManager::previouslyPluginAdded, this,&ThemesManager::onePluginAdded,Qt::QueuedConnection); connect(PluginsManager::pluginsManager,&PluginsManager::onePluginAdded, this,&ThemesManager::onePluginAdded,Qt::QueuedConnection); #ifndef ULTRACOPIER_PLUGIN_ALL_IN_ONE connect(PluginsManager::pluginsManager,&PluginsManager::onePluginWillBeRemoved, this,&ThemesManager::onePluginWillBeRemoved,Qt::DirectConnection); connect(PluginsManager::pluginsManager,&PluginsManager::onePluginWillBeUnloaded, this,&ThemesManager::onePluginWillBeRemoved,Qt::DirectConnection); #endif connect(PluginsManager::pluginsManager,&PluginsManager::pluginListingIsfinish, this,&ThemesManager::allPluginIsLoaded,Qt::QueuedConnection); QList<PluginsAvailable> list=PluginsManager::pluginsManager->getPluginsByCategory(PluginType_Themes); foreach(PluginsAvailable currentPlugin,list) emit previouslyPluginAdded(currentPlugin); PluginsManager::pluginsManager->unlockPluginListEdition(); //do the options QList<QPair<QString, QVariant> > KeysList; KeysList.append(qMakePair(QString("Ultracopier_current_theme"),QVariant(ULTRACOPIER_DEFAULT_STYLE))); OptionEngine::optionEngine->addOptionGroup("Themes",KeysList); //load the default and current themes path defaultStylePath=":/Themes/"+QString(ULTRACOPIER_DEFAULT_STYLE)+"/"; ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"Default style: "+defaultStylePath); currentStylePath=defaultStylePath; connect(OptionEngine::optionEngine, &OptionEngine::newOptionValue, this, &ThemesManager::newOptionValue,Qt::QueuedConnection); connect(LanguagesManager::languagesManager, &LanguagesManager::newLanguageLoaded, &facilityEngine,&FacilityEngine::retranslate,Qt::QueuedConnection); }