QSmartCard::ErrorType QSmartCard::login( QSmartCardData::PinType type )
{
PinDialog::PinFlags flags = PinDialog::Pin1Type;
QSslCertificate cert;
switch( type )
{
case QSmartCardData::Pin1Type: flags = PinDialog::Pin1Type; cert = d->t.authCert(); break;
case QSmartCardData::Pin2Type: flags = PinDialog::Pin2Type; cert = d->t.signCert(); break;
default: return UnknownError;
}
QScopedPointer<PinDialog> p;
PinString pin;
if( !d->t.isPinpad() )
{
p.reset( new PinDialog( flags, cert, 0, qApp->activeWindow() ) );
if( !p->exec() )
return CancelError;
pin = p->text().toUtf8().constData();
} else {
p.reset( new PinDialog( PinDialog::PinFlags(flags|PinDialog::PinpadFlag), cert, 0, qApp->activeWindow() ) );
p->open();
}
d->m.lock();
if( !d->card ) return QSmartCard::UnknownError;
d->cmd = QSmartCardPrivate::Validate;
d->type = type;
d->pin = pin;
connect( this, SIGNAL(eventStarted()), p.data(), SIGNAL(startTimer()) );
d->e.exec();
if( d->result != QSmartCard::NoError )
d->m.unlock();
return d->result;
}
bool HistoryDAO::removeEntry(BaseBean *bean, const QString connection)
{
QString sql = QString(SQL_NEW_ENTRY).arg(configuracion.systemTablePrefix());
QScopedPointer<QSqlQuery> qry (new QSqlQuery(Database::getQDatabase(connection)));
QString userName = qApp->property("userName").toString();
qry->prepare(sql);
qry->bindValue(":username", userName, QSql::In);
qry->bindValue(":action", QString("DELETE"), QSql::In);
qry->bindValue(":tablename", bean->metadata()->tableName(), QSql::In);
qry->bindValue(":pkey", bean->pkSerializedValue(), QSql::In);
qry->bindValue(":changed_data", HistoryDAO::createData(bean), QSql::In);
bool result = qry->exec();
qDebug() << "HistoryDAO: removeEntry: [ " << qry->lastQuery() << " ]";
if ( !result ) {
BaseDAO::writeDbMessages(qry.data());
}
return result;
}
QAbstractButton *ResolveLocationContext::execLocationMessageBox(QWidget *parent,
const QString &file,
bool wantSkipButton)
{
if (messageBox.isNull()) {
messageBox.reset(new QMessageBox(QMessageBox::Warning,
QrcEditor::tr("Invalid file location"),
QString(), QMessageBox::NoButton, parent));
copyButton = messageBox->addButton(QrcEditor::tr("Copy"), QMessageBox::ActionRole);
abortButton = messageBox->addButton(QrcEditor::tr("Abort"), QMessageBox::RejectRole);
messageBox->setDefaultButton(copyButton);
}
if (wantSkipButton && !skipButton) {
skipButton = messageBox->addButton(QrcEditor::tr("Skip"), QMessageBox::DestructiveRole);
messageBox->setEscapeButton(skipButton);
}
messageBox->setText(QrcEditor::tr("The file %1 is not in a subdirectory of the resource file. You now have the option to copy this file to a valid location.")
.arg(QDir::toNativeSeparators(file)));
messageBox->exec();
return messageBox->clickedButton();
}
int main(int argc, char *argv[])
{
QScopedPointer<QGuiApplication> app (SailfishApp::application(argc, argv));
QScopedPointer<QQuickView> view (SailfishApp::createView());
MGConfItem partnerSpaceQml (PARTNERSPACEMANAGER_QML_DCONF);
QString qmlFile = partnerSpaceQml.value(QString()).toString();
if (qmlFile.isEmpty()) {
return 1;
}
qDebug() << "Running partner-space launcher with" << qmlFile;
view->setSource(QUrl(qmlFile));
// The view is a partner window
view->create();
QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface();
native->setWindowProperty(view->handle(), QLatin1String("CATEGORY"), QString(QLatin1String("partner")));
view->show();
return app->exec();
}
QString ResolveLocationContext::execCopyFileDialog(QWidget *parent, const QDir &dir, const QString &targetPath)
{
// Delayed creation of file dialog.
if (copyFileDialog.isNull()) {
copyFileDialog.reset(new QFileDialog(parent, QrcEditor::tr("Choose Copy Location")));
copyFileDialog->setFileMode(QFileDialog::AnyFile);
copyFileDialog->setAcceptMode(QFileDialog::AcceptSave);
}
copyFileDialog->selectFile(targetPath);
// Repeat until the path entered is no longer above 'dir'
// (relative is not "../").
while (true) {
if (copyFileDialog->exec() != QDialog::Accepted)
return QString();
const QStringList files = copyFileDialog->selectedFiles();
if (files.isEmpty())
return QString();
const QString relPath = dir.relativeFilePath(files.front());
if (!relPath.startsWith(QLatin1String("../")))
return files.front();
}
return QString();
}
void MainWindow::onFileDropWidgetContextMenuRequested(const QPoint &pos)
{
QScopedPointer<QMenu> menu;
QScopedPointer<QAction> downloadThumbnailAction;
QScopedPointer<QAction> addEntryAction;
QScopedPointer<QAction> addFilesAction;
QScopedPointer<QAction> addFolderAction;
QScopedPointer<QAction> editAction;
QScopedPointer<QAction> deleteAction;
QPointer<QAction> selectedAction;
QPoint cursorPos = QCursor::pos();
QHash<QString, QString> contentHash = getCurrentContentHash();
bool specialPlaylist = currentPlaylistIsSpecial();
bool allPlaylist = currentPlaylistIsAll();
bool actionsAdded = false;
if (m_browserAndPlaylistTabWidget->tabText(m_browserAndPlaylistTabWidget->currentIndex()) != msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_TAB_PLAYLISTS))
return;
menu.reset(new QMenu(this));
if (!specialPlaylist)
{
downloadThumbnailAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_THUMBNAIL)), this));
menu->addAction(downloadThumbnailAction.data());
}
if (!allPlaylist)
{
addEntryAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ADD_ENTRY)), this));
menu->addAction(addEntryAction.data());
addFilesAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ADD_FILES)), this));
menu->addAction(addFilesAction.data());
addFolderAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ADD_FOLDER)), this));
menu->addAction(addFolderAction.data());
editAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_EDIT)), this));
deleteAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DELETE)), this));
if (!contentHash.isEmpty())
{
menu->addAction(editAction.data());
menu->addAction(deleteAction.data());
}
actionsAdded = true;
}
if (actionsAdded)
selectedAction = menu->exec(cursorPos);
if (!selectedAction)
return;
if (!specialPlaylist)
{
if (selectedAction == downloadThumbnailAction.data())
{
QHash<QString, QString> hash = getCurrentContentHash();
QString system = QFileInfo(getCurrentPlaylistPath()).completeBaseName();
QString title = hash.value("label");
if (!title.isEmpty())
{
if (m_pendingThumbnailDownloadTypes.isEmpty())
{
m_pendingThumbnailDownloadTypes.append(THUMBNAIL_BOXART);
m_pendingThumbnailDownloadTypes.append(THUMBNAIL_SCREENSHOT);
m_pendingThumbnailDownloadTypes.append(THUMBNAIL_TITLE);
downloadThumbnail(system, title);
}
else
{
showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_ALREADY_IN_PROGRESS), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
}
}
}
}
if (!allPlaylist)
{
if (selectedAction == addFilesAction.data())
{
QStringList filePaths = QFileDialog::getOpenFileNames(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SELECT_FILES));
if (!filePaths.isEmpty())
addFilesToPlaylist(filePaths);
}
else if (selectedAction == addEntryAction.data())
{
addFilesToPlaylist(QStringList());
}
else if (selectedAction == addFolderAction.data())
{
QString dirPath = QFileDialog::getExistingDirectory(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SELECT_FOLDER), QString(), QFileDialog::ShowDirsOnly);
if (!dirPath.isEmpty())
addFilesToPlaylist(QStringList() << dirPath);
}
else if (selectedAction == editAction.data())
{
PlaylistEntryDialog *playlistDialog = playlistEntryDialog();
QHash<QString, QString> selectedCore;
QString selectedDatabase;
QString selectedName;
QString selectedPath;
QString currentPlaylistPath = getCurrentPlaylistPath();
if (!playlistDialog->showDialog(contentHash))
return;
selectedName = m_playlistEntryDialog->getSelectedName();
selectedPath = m_playlistEntryDialog->getSelectedPath();
selectedCore = m_playlistEntryDialog->getSelectedCore();
selectedDatabase = m_playlistEntryDialog->getSelectedDatabase();
if (selectedCore.isEmpty())
{
selectedCore["core_name"] = "DETECT";
selectedCore["core_path"] = "DETECT";
}
if (selectedDatabase.isEmpty())
{
selectedDatabase = QFileInfo(currentPlaylistPath).fileName().remove(file_path_str(FILE_PATH_LPL_EXTENSION));
}
contentHash["label"] = selectedName;
contentHash["path"] = selectedPath;
contentHash["core_name"] = selectedCore.value("core_name");
contentHash["core_path"] = selectedCore.value("core_path");
contentHash["db_name"] = selectedDatabase;
if (!updateCurrentPlaylistEntry(contentHash))
{
showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_UPDATE_PLAYLIST_ENTRY), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
return;
}
}
else if (selectedAction == deleteAction.data())
{
deleteCurrentPlaylistItem();
}
}
}
void iAFoamCharacterizationItemBinarization::dialog()
{
QScopedPointer<iAFoamCharacterizationDialogBinarization> pDialog
(new iAFoamCharacterizationDialogBinarization(this, qApp->focusWidget()));
pDialog->exec();
}
void MainWindow::onPlaylistWidgetContextMenuRequested(const QPoint&)
{
settings_t *settings = config_get_ptr();
QScopedPointer<QMenu> menu;
QScopedPointer<QMenu> associateMenu;
QScopedPointer<QMenu> hiddenPlaylistsMenu;
QScopedPointer<QAction> hideAction;
QScopedPointer<QAction> newPlaylistAction;
QScopedPointer<QAction> deletePlaylistAction;
QPointer<QAction> selectedAction;
QPoint cursorPos = QCursor::pos();
QListWidgetItem *selectedItem = m_listWidget->itemAt(m_listWidget->viewport()->mapFromGlobal(cursorPos));
QDir playlistDir(settings->paths.directory_playlist);
QString playlistDirAbsPath = playlistDir.absolutePath();
QString currentPlaylistDirPath;
QString currentPlaylistPath;
QString currentPlaylistFileName;
QFile currentPlaylistFile;
QByteArray currentPlaylistFileNameArray;
QFileInfo currentPlaylistFileInfo;
QMap<QString, const core_info_t*> coreList;
core_info_list_t *core_info_list = NULL;
union string_list_elem_attr attr = {0};
struct string_list *stnames = NULL;
struct string_list *stcores = NULL;
unsigned i = 0;
int j = 0;
size_t found = 0;
const char *currentPlaylistFileNameData = NULL;
char new_playlist_names[PATH_MAX_LENGTH];
char new_playlist_cores[PATH_MAX_LENGTH];
bool specialPlaylist = false;
bool foundHiddenPlaylist = false;
new_playlist_names[0] = new_playlist_cores[0] = '\0';
stnames = string_split(settings->arrays.playlist_names, ";");
stcores = string_split(settings->arrays.playlist_cores, ";");
if (selectedItem)
{
currentPlaylistPath = selectedItem->data(Qt::UserRole).toString();
currentPlaylistFile.setFileName(currentPlaylistPath);
currentPlaylistFileInfo = QFileInfo(currentPlaylistPath);
currentPlaylistFileName = currentPlaylistFileInfo.fileName();
currentPlaylistDirPath = currentPlaylistFileInfo.absoluteDir().absolutePath();
currentPlaylistFileNameArray.append(currentPlaylistFileName);
currentPlaylistFileNameData = currentPlaylistFileNameArray.constData();
}
menu.reset(new QMenu(this));
menu->setObjectName("menu");
hiddenPlaylistsMenu.reset(new QMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_HIDDEN_PLAYLISTS), this));
newPlaylistAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST)) + "...", this));
hiddenPlaylistsMenu->setObjectName("hiddenPlaylistsMenu");
menu->addAction(newPlaylistAction.data());
if (currentPlaylistFile.exists())
{
deletePlaylistAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DELETE_PLAYLIST)) + "...", this));
menu->addAction(deletePlaylistAction.data());
}
if (selectedItem)
{
hideAction.reset(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_HIDE), this));
menu->addAction(hideAction.data());
}
for (j = 0; j < m_listWidget->count(); j++)
{
QListWidgetItem *item = m_listWidget->item(j);
bool hidden = m_listWidget->isItemHidden(item);
if (hidden)
{
QAction *action = hiddenPlaylistsMenu->addAction(item->text());
action->setProperty("row", j);
action->setProperty("core_path", item->data(Qt::UserRole).toString());
foundHiddenPlaylist = true;
}
}
if (!foundHiddenPlaylist)
{
QAction *action = hiddenPlaylistsMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE));
action->setProperty("row", -1);
}
menu->addMenu(hiddenPlaylistsMenu.data());
if (currentPlaylistDirPath != playlistDirAbsPath)
{
/* special playlists like history etc. can't have an association */
specialPlaylist = true;
}
if (!specialPlaylist)
{
associateMenu.reset(new QMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ASSOCIATE_CORE), this));
associateMenu->setObjectName("associateMenu");
core_info_get_list(&core_info_list);
for (i = 0; i < core_info_list->count && core_info_list->count > 0; i++)
{
const core_info_t *core = &core_info_list->list[i];
coreList[core->core_name] = core;
}
{
QMapIterator<QString, const core_info_t*> coreListIterator(coreList);
QVector<QHash<QString, QString> > cores;
while (coreListIterator.hasNext())
{
QString key;
const core_info_t *core = NULL;
QString name;
QHash<QString, QString> hash;
coreListIterator.next();
key = coreListIterator.key();
core = coreList.value(key);
if (string_is_empty(core->core_name))
name = core->display_name;
else
name = core->core_name;
if (name.isEmpty())
continue;
hash["name"] = name;
hash["core_path"] = core->path;
cores.append(hash);
}
std::sort(cores.begin(), cores.end(), comp_hash_name_key_lower);
for (j = 0; j < cores.count(); j++)
{
const QHash<QString, QString> &hash = cores.at(j);
QAction *action = associateMenu->addAction(hash.value("name"));
action->setProperty("core_path", hash.value("core_path"));
}
}
menu->addMenu(associateMenu.data());
}
selectedAction = menu->exec(cursorPos);
if (!selectedAction)
goto end;
if (!specialPlaylist && selectedAction->parent() == associateMenu.data())
{
found = string_list_find_elem(stnames, currentPlaylistFileNameData);
if (found)
string_list_set(stcores, static_cast<unsigned>(found - 1), selectedAction->property("core_path").toString().toUtf8().constData());
else
{
string_list_append(stnames, currentPlaylistFileNameData, attr);
string_list_append(stcores, "DETECT", attr);
found = string_list_find_elem(stnames, currentPlaylistFileNameData);
if (found)
string_list_set(stcores, static_cast<unsigned>(found - 1), selectedAction->property("core_path").toString().toUtf8().constData());
}
string_list_join_concat(new_playlist_names,
sizeof(new_playlist_names), stnames, ";");
string_list_join_concat(new_playlist_cores,
sizeof(new_playlist_cores), stcores, ";");
strlcpy(settings->arrays.playlist_names,
new_playlist_names, sizeof(settings->arrays.playlist_names));
strlcpy(settings->arrays.playlist_cores,
new_playlist_cores, sizeof(settings->arrays.playlist_cores));
}
else if (selectedItem && selectedAction == deletePlaylistAction.data())
{
if (currentPlaylistFile.exists())
{
if (showMessageBox(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CONFIRM_DELETE_PLAYLIST)).arg(selectedItem->text()), MainWindow::MSGBOX_TYPE_QUESTION_YESNO, Qt::ApplicationModal, false))
{
if (currentPlaylistFile.remove())
reloadPlaylists();
else
showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_DELETE_FILE), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
}
}
}
else if (selectedAction == newPlaylistAction.data())
{
QString name = QInputDialog::getText(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ENTER_NEW_PLAYLIST_NAME));
QString newPlaylistPath = playlistDirAbsPath + "/" + name + file_path_str(FILE_PATH_LPL_EXTENSION);
QFile file(newPlaylistPath);
if (file.open(QIODevice::WriteOnly))
file.close();
reloadPlaylists();
}
else if (selectedItem && selectedAction == hideAction.data())
{
int row = m_listWidget->row(selectedItem);
if (row >= 0)
{
QStringList hiddenPlaylists = m_settings->value("hidden_playlists").toStringList();
if (!hiddenPlaylists.contains(currentPlaylistFileName))
{
hiddenPlaylists.append(currentPlaylistFileName);
m_settings->setValue("hidden_playlists", hiddenPlaylists);
}
m_listWidget->setRowHidden(row, true);
}
}
else if (selectedAction->parent() == hiddenPlaylistsMenu.data())
{
QVariant rowVariant = selectedAction->property("row");
if (rowVariant.isValid())
{
QStringList hiddenPlaylists = m_settings->value("hidden_playlists").toStringList();
int row = rowVariant.toInt();
if (row >= 0)
{
QString playlistPath = selectedAction->property("core_path").toString();
QFileInfo playlistFileInfo(playlistPath);
QString playlistFileName = playlistFileInfo.fileName();
if (hiddenPlaylists.contains(playlistFileName))
{
hiddenPlaylists.removeOne(playlistFileName);
m_settings->setValue("hidden_playlists", hiddenPlaylists);
}
m_listWidget->setRowHidden(row, false);
}
}
}
setCoreActions();
end:
if (stnames)
string_list_free(stnames);
if (stcores)
string_list_free(stcores);
}
// --------------------------------------------------------------------------
int appLauncherMain(int argc, char** argv)
{
#ifdef QT_MAC_USE_COCOA
// See http://doc.trolltech.com/4.7/qt.html#ApplicationAttribute-enum
// Setting the application to be a plugin will avoid the loading of qt_menu.nib files
QCoreApplication::setAttribute(Qt::AA_MacPluginApplication, true);
#endif
ctkAppArguments appArguments(argc, argv);
// See http://qt-project.org/doc/qt-4.8/qapplication.html#QApplication
appArguments.setArgumentToFilterList(
ctkAppArguments::ArgToFilterListType()
<< ctkAppArguments::ArgToFilterType("-style", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE | ctkAppArguments::ARG_TO_FILTER_SPACE_VALUE)
<< ctkAppArguments::ArgToFilterType("-stylesheet", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE | ctkAppArguments::ARG_TO_FILTER_SPACE_VALUE)
<< ctkAppArguments::ArgToFilterType("-session", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE | ctkAppArguments::ARG_TO_FILTER_SPACE_VALUE)
<< ctkAppArguments::ArgToFilterType("-widgetcount")
<< ctkAppArguments::ArgToFilterType("-reverse")
<< ctkAppArguments::ArgToFilterType("-graphicssystem")
<< ctkAppArguments::ArgToFilterType("-qmljsdebugger=", ctkAppArguments::ARG_TO_FILTER_EQUAL_VALUE)
#ifdef QT_DEBUG
<< ctkAppArguments::ArgToFilterType("-nograb")
#endif
#ifdef Q_WS_X11
<< ctkAppArguments::ArgToFilterType("-display")
<< ctkAppArguments::ArgToFilterType("-geometry")
<< ctkAppArguments::ArgToFilterType("-fn")
<< ctkAppArguments::ArgToFilterType("-font")
<< ctkAppArguments::ArgToFilterType("-bg")
<< ctkAppArguments::ArgToFilterType("-background")
<< ctkAppArguments::ArgToFilterType("-fg")
<< ctkAppArguments::ArgToFilterType("-foreground")
<< ctkAppArguments::ArgToFilterType("-btn")
<< ctkAppArguments::ArgToFilterType("-button")
<< ctkAppArguments::ArgToFilterType("-name")
<< ctkAppArguments::ArgToFilterType("-title")
<< ctkAppArguments::ArgToFilterType("-visual")
<< ctkAppArguments::ArgToFilterType("-ncols")
<< ctkAppArguments::ArgToFilterType("-cmap")
<< ctkAppArguments::ArgToFilterType("-im")
<< ctkAppArguments::ArgToFilterType("-inputstyle")
# ifdef QT_DEBUG
<< ctkAppArguments::ArgToFilterType("-dograb")
<< ctkAppArguments::ArgToFilterType("-sync")
# endif
#endif
);
QFileInfo launcherFile(QDir::current(), QString(argv[0]));
// Initialize resources in static libs
Q_INIT_RESOURCE(CTKAppLauncherBase);
QScopedPointer<ctkAppLauncher> appLauncher(new ctkAppLauncher);
appLauncher->setArguments(appArguments.arguments());
bool exec = appLauncher->initialize(launcherFile.absoluteFilePath());
exec = appLauncher->configure() && exec;
if (!exec)
{
return EXIT_SUCCESS;
}
QScopedPointer<QCoreApplication> app;
if (appLauncher->disableSplash())
{
app.reset(new QCoreApplication(
appArguments.argumentCount(ctkAppArguments::ARG_REGULAR_LIST),
appArguments.argumentValues(ctkAppArguments::ARG_REGULAR_LIST)));
}
else
{
app.reset(new QApplication(
appArguments.argumentCount(ctkAppArguments::ARG_REGULAR_LIST),
appArguments.argumentValues(ctkAppArguments::ARG_REGULAR_LIST)));
}
appLauncher->setApplication(*app.data());
QTimer::singleShot(0, appLauncher.data(), SLOT(startLauncher()));
int res = app->exec();
// Delete application launcher appLauncher before the application app so that
// graphical items such as pixmaps, widgets, etc can be released.
appLauncher.reset();
return res;
}