void ribi::pvdb::QtPvdbCreateAssessmentCompleteDialog::on_button_save_clicked()
{
const auto d = pvdb::QtFileDialog::GetSaveFileDialog(pvdb::QtFileDialog::FileType::cmp);
d->setWindowTitle("Sla het assessment invoer-bestand op");
const int status = d->exec();
if (status == QDialog::Rejected)
{
this->show();
return;
}
assert(d->selectedFiles().size() == 1);
const std::string filename_raw = d->selectedFiles()[0].toStdString();
assert(!filename_raw.empty());
const std::string filename
= (filename_raw.size() < pvdb::File::GetFilenameExtension().size()
|| filename_raw.substr( filename_raw.size() - 3, 3 ) != pvdb::File::GetFilenameExtension()
? filename_raw + std::string(".") + pvdb::File::GetFilenameExtension()
: filename_raw);
assert(filename.size() > 3
&& filename.substr( filename.size() - 3, 3 ) == pvdb::File::GetFilenameExtension()
&& "File must have correct file extension name");
Save(filename);
m_back_to_menu = true;
close();
}
void UIAddExistingFiles::accept()
{
QStringList fileNames = selectedFiles();
if ( fileNames.isEmpty() )
return;
QString suffix;
QMakeProject* project = QMakeProject::getProjectByName( cbProjects->currentText(), projectParent );
foreach ( QString file, fileNames )
{
switch ( project->getFileTypeFromFilePath( file ) )
{
case pForm:
project->addStringListValue( "FORMS", cbPlatforms->currentText(), file );
break;
case pHeader:
project->addStringListValue( "HEADERS", cbPlatforms->currentText(), file );
break;
case pSource:
project->addStringListValue( "SOURCES", cbPlatforms->currentText(), file );
break;
/*
case pTranslation:
project->addStringListValue( "TRANSLATIONS", cbPlatforms->currentText(), file );
break;
*/
case pText:
project->addStringListValue( "TEXTS", cbPlatforms->currentText(), file );
break;
default:
break;
}
}
QDialog::accept();
}
void FolderView::onFileClicked(int type, FmFileInfo* fileInfo) {
if(type == ActivatedClick) {
if(fileLauncher_) {
GList* files = g_list_append(NULL, fileInfo);
fileLauncher_->launchFiles(NULL, files);
g_list_free(files);
}
}
else if(type == ContextMenuClick) {
FmPath* folderPath = path();
QMenu* menu = NULL;
if(fileInfo) {
// show context menu
if (FmFileInfoList* files = selectedFiles()) {
Fm::FileMenu* fileMenu = new Fm::FileMenu(files, fileInfo, folderPath);
fileMenu->setFileLauncher(fileLauncher_);
prepareFileMenu(fileMenu);
fm_file_info_list_unref(files);
menu = fileMenu;
}
}
else {
FmFolder* _folder = folder();
FmFileInfo* info = fm_folder_get_info(_folder);
Fm::FolderMenu* folderMenu = new Fm::FolderMenu(this);
prepareFolderMenu(folderMenu);
menu = folderMenu;
}
if (menu) {
menu->popup(QCursor::pos());
connect(menu, SIGNAL(aboutToHide()), menu, SLOT(deleteLater()));
}
}
}
void FileOrganiserWidget::keyPressEvent(QKeyEvent *pEvent)
{
// Default handling of the event
TreeViewWidget::keyPressEvent(pEvent);
// Let people know about a key having been pressed with the view of opening
// one or several files
QStringList crtSelectedFiles = selectedFiles();
if ( crtSelectedFiles.count()
#if defined(Q_OS_WIN) || defined(Q_OS_LINUX)
&& ( (pEvent->key() == Qt::Key_Enter)
|| (pEvent->key() == Qt::Key_Return))
#elif defined(Q_OS_MAC)
&& ( (pEvent->modifiers() & Qt::ControlModifier)
&& (pEvent->key() == Qt::Key_Down))
#else
#error Unsupported platform
#endif
)
// There are some files that are selected and we want to open them, so
// let people know about it
emit filesOpenRequested(crtSelectedFiles);
}
void AppImportFile::open()
{
const QString MetaIOImageFilter("MetaIO Image (*.mhd)"), DICOMImageFilter("DICOM Images (*.dcm)"), AllFilesFilter("All Files (*)");
QStringList imagesFilter;
imagesFilter << MetaIOImageFilter << DICOMImageFilter << AllFilesFilter;
QFileDialog *openDialog = new QFileDialog(0);
openDialog->setWindowTitle(tr("Select files to open..."));
openDialog->setDirectory(m_workingDirectory);
openDialog->setNameFilters(imagesFilter);
openDialog->selectNameFilter (m_lastExtension);
openDialog->setFileMode(QFileDialog::ExistingFiles);
openDialog->setAcceptMode(QFileDialog::AcceptOpen);
if (openDialog->exec() == QDialog::Accepted)
{
QStringList fileNames = openDialog->selectedFiles();
emit selectedFiles(fileNames);
m_workingDirectory = QFileInfo(fileNames.first()).dir().path();
m_lastExtension = openDialog->selectedNameFilter();
writeSettings();
}
delete openDialog;
}
void DataSourceSelectorDialog::accept() {
QStringList files = selectedFiles();
if (files.isEmpty()) {
return;
}
for (int i = 0; i < files.count(); ++i) {
QFileInfo info(files.at(i));
if (!info.exists()) {
#ifndef QT_NO_MESSAGEBOX
QString message = tr("%1\nFile not found.\nPlease verify the "
"correct file name was given.");
QMessageBox::warning(this, windowTitle(), message.arg(info.fileName()));
#endif // QT_NO_MESSAGEBOX
return;
}
if (info.isDir()) {
if (info.fileName().isEmpty() || (info.filePath() == directory().path())) {
QDialog::accept();
return;
}
}
}
QFileDialog::accept();
}
void SetLibraryDialog::on_addButton_clicked()
{
QStringList list = QFileDialog::getOpenFileNames(this,"Select library files",QDir::homePath(),"Library (*.lb3)");
QStringList current = selectedFiles();
current << list;
setFiles(current);
}
QString QG_FileDialog::getOpenFile(RS2::FormatType* type){
// bool fileAccepted = false;
setAcceptMode ( QFileDialog::AcceptOpen );
// read default settings:
RS_SETTINGS->beginGroup("/Paths");
QString defDir = RS_SETTINGS->readEntry("/Open",
RS_SYSTEM->getHomeDir());
RS_SETTINGS->endGroup();
RS_DEBUG->print("defDir: %s", defDir.toLatin1().data());
QString fn = "";
QStringList filters;
filters << fDxfrw << fDxf1 << fLff << fCxf << fJww;
setWindowTitle(tr("Open %1").arg(name));
#if QT_VERSION >= 0x040400
setNameFilters(filters);
#endif
setDirectory(defDir);
setFileMode(QFileDialog::ExistingFile);
#if QT_VERSION >= 0x040400
selectNameFilter(fDxfrw);
#endif
ftype= RS2::FormatDXFRW;
RS_DEBUG->print("defFilter: %s", fDxfrw.toLatin1().data());
/* preview RVT PORT preview is currently not supported by QT4
RS_Graphic* gr = new RS_Graphic;
QG_GraphicView* prev = new QG_GraphicView(parent);
prev->setContainer(gr);
prev->setBorders(1, 1, 1, 1);
fileDlg->setContentsPreviewEnabled(true);
fileDlg->setContentsPreview(prev, prev); */
if (exec()==QDialog::Accepted) {
QStringList fl = selectedFiles();
if (!fl.isEmpty()) {
fn = fl[0];
}
fn = QDir::toNativeSeparators( QFileInfo(fn).absoluteFilePath() );
if (type!=NULL) {
getType(selectedFilter());
*type = ftype;
}
// store new default settings:
RS_SETTINGS->beginGroup("/Paths");
RS_SETTINGS->writeEntry("/Open", QFileInfo(fn).absolutePath());
RS_SETTINGS->writeEntry("/OpenFilter", selectedFilter());
RS_SETTINGS->endGroup();
}
RS_DEBUG->print("QG_FileDialog::getOpenFileName: fileName: %s", fn.toLatin1().data());
RS_DEBUG->print("QG_FileDialog::getOpenFileName: OK");
// RVT PORT delete prev;
// RVT PORT delete gr;
return fn;
}
QString ScFileWidget::selectedFile()
{
QStringList l(selectedFiles());
if (l.count() == 0)
return QString();
return l.at(0);
}
void SubmitEditorWidget::triggerDiffSelected()
{
const QStringList sel = selectedFiles();
if (!sel.empty()) {
emit diffSelected(sel);
}
}
void DesktopWindow::onRenameActivated() {
if(FmFileInfoList* files = selectedFiles()) {
for(GList* l = fm_file_info_list_peek_head_link(files); l; l = l->next) {
FmFileInfo* info = FM_FILE_INFO(l->data);
Fm::renameFile(info, NULL);
fm_file_info_list_unref(files);
}
}
}
int CaptureFileDialog::exec() {
m_fileName.clear();
m_displayFilter.clear();
if (QFileDialog::exec() && selectedFiles().length() > 0) {
m_fileName.append(selectedFiles()[0]);
m_displayFilter.append(m_displayFilterEdit->text());
gbl_resolv_flags.mac_name = m_macRes.isChecked();
gbl_resolv_flags.transport_name = m_transportRes.isChecked();
gbl_resolv_flags.network_name = m_networkRes.isChecked();
gbl_resolv_flags.use_external_net_name_resolver = m_externalRes.isChecked();
return QDialog::Accepted;
} else {
return QDialog::Rejected;
}
}
void GtkFileDialog::hideHelper() {
// After GtkFileChooserDialog has been hidden, gtk_file_chooser_get_current_folder()
// & gtk_file_chooser_get_filenames() will return bogus values -> cache the actual
// values before hiding the dialog
_dir = directory().absolutePath();
_selection = selectedFiles();
d->hide();
}
void MultiQFileDialog::accept()
{
QStringList files = selectedFiles();
if (files.isEmpty())
{
return;
}
emit filesSelected(files);
QDialog::accept();
}
void LibraryPage::addSelectionToPlaylist(const QString &name, bool replace, quint8 priorty)
{
QStringList files=selectedFiles(name.isEmpty());
if (!files.isEmpty()) {
if (name.isEmpty()) {
emit add(files, replace, priorty);
} else {
emit addSongsToPlaylist(name, files);
}
view->clearSelection();
}
}
void SinglePageWidget::addSelectionToPlaylist(const QString &name, int action, quint8 priority, bool decreasePriority)
{
// Always get tracks and playlists - this way error message can be shown. #902
QStringList files=selectedFiles(true);
if (!files.isEmpty()) {
if (name.isEmpty()) {
emit add(files, action, priority, decreasePriority);
} else {
emit addSongsToPlaylist(name, files);
}
view->clearSelection();
}
}
QString QG_FileDialog::getSaveFile(RS2::FormatType* type){
setAcceptMode ( QFileDialog::AcceptSave );
// read default settings:
RS_SETTINGS->beginGroup("/Paths");
QString defDir = RS_SETTINGS->readEntry("/Save",
RS_SYSTEM->getHomeDir());
/* QString defFilter = RS_SETTINGS->readEntry("/SaveFilter",
"Drawing Exchange DXF 2000 (*.dxf)");*/
RS_SETTINGS->endGroup();
RS_DEBUG->print("defDir: %s", defDir.toLatin1().data());
QString fn = "";
QStringList filters;
#ifdef USE_DXFRW
filters << fDxf2000 << fDxfrw2000 << fDxfR12 << fLff << fCxf << fJww;
#else
filters << fDxf2000 << fDxfR12 << fLff << fCxf << fJww;
#endif
setWindowTitle(tr("Save Drawing As"));
setFileMode(QFileDialog::AnyFile);
setDirectory(defDir);
setFilters(filters);
#if QT_VERSION >= 0x040400
selectNameFilter(fDxf2000);
#endif
ftype= RS2::FormatDXF;
RS_DEBUG->print("defFilter: %s", fDxf2000.toLatin1().data());
if (exec()==QDialog::Accepted) {
QStringList fl = selectedFiles();
if (!fl.isEmpty())
fn = fl[0];
fn = QDir::convertSeparators( QFileInfo(fn).absoluteFilePath() );
getType(selectedFilter());
if (type!=NULL)
*type = ftype;
// append default extension:
if (QFileInfo(fn).fileName().indexOf('.')==-1) {
fn += getExtension(ftype);
}
// store new default settings:
RS_SETTINGS->beginGroup("/Paths");
RS_SETTINGS->writeEntry("/Save", QFileInfo(fn).absolutePath());
//RS_SETTINGS->writeEntry("/SaveFilter", fileDlg->selectedFilter());
RS_SETTINGS->endGroup();
}
return fn;
}
void ribi::pvdb::QtPvdbStudentMenuDialog::on_button_save_clicked()
{
const auto d = pvdb::QtFileDialog::GetSaveFileDialog(pvdb::QtFileDialog::FileType::cmp);
d->setWindowTitle("Sla de concept map op");
const int status = d->exec();
if (status == QDialog::Rejected)
{
return;
}
assert(d->selectedFiles().size() == 1);
const std::string filename_raw = d->selectedFiles()[0].toStdString();
assert(!filename_raw.empty());
const std::string filename
= (filename_raw.size() < pvdb::File::GetFilenameExtension().size()
|| filename_raw.substr( filename_raw.size() - 3, 3 ) != pvdb::File::GetFilenameExtension()
? filename_raw + std::string(".") + pvdb::File::GetFilenameExtension()
: filename_raw);
assert(filename.size() > 3
&& filename.substr( filename.size() - 3, 3 ) == pvdb::File::GetFilenameExtension()
&& "File must have correct file extension name");
Save(filename);
}
void SetLibraryDialog::on_downButton_clicked()
{
QModelIndexList selectedList = ui->libraryList->selectionModel()->selectedIndexes();
if(selectedList.size() == 0)
return;
Q_ASSERT_X(selectedList.size() == 1,"library dialog","more than one selection");
if(selectedList[0].row() == _model.rowCount()-1)
return;
QStringList current = selectedFiles();
QString line = current[selectedList[0].row()];
current.removeAt(selectedList[0].row());
current.insert(selectedList[0].row()+1,line);
setFiles(current);
ui->libraryList->selectionModel()->select(_model.index(selectedList[0].row()+1),QItemSelectionModel::ClearAndSelect);
}
void OpenFileDialog::accept()
{
QStringList fileNames;
QString modelFile;
fileNames = selectedFiles();
if (fileNames.size() > 0)
modelFile = fileNames.at(0);
if (modelFile.isEmpty())
QMessageBox::warning(0, QString("Information"), QString(" Filename is empty."));
_path = Util::getPath(modelFile.toStdString()); // /home/user/models/
_modelFile = Util::getFileName(modelFile.toStdString()); // modelX.fmu
QDialog::accept();
}
STDMETHODIMP CContextMenuShellExtension::Initialize(PCIDLIST_ABSOLUTE pidlFolder, IDataObject *pDataObj, HKEY hkeyProgID)
{
COM_EXCEPTION_GUARD_BEGIN
DataObjectEnumerator selectedFiles(pDataObj);
m_lstFiles.clear();
for (UINT i = 0; i < selectedFiles.Count(); ++i)
{
std::wstring fileName(selectedFiles.Get(i));
if (!fileName.empty())
{
m_lstFiles.push_back(fileName);
}
}
return m_lstFiles.empty() ? E_INVALIDARG : S_OK;
COM_EXCEPTION_GUARD_END
}
void DesktopWindow::onRenameActivated() {
// do inline renaming if only one item is selected,
// otherwise use the renaming dialog
if(selectedIndexes().size() == 1) {
QModelIndex cur = listView_->currentIndex();
if (cur.isValid()) {
listView_->edit(cur);
return;
}
}
auto files = selectedFiles();
if(!files.empty()) {
for(auto& info: files) {
if(!Fm::renameFile(info, nullptr)) {
break;
}
}
}
}
QString DataSourceSelectorDialog::selectedDataSource() {
return selectedFiles().first();
}
void MultiQFileDialog::onSelectionChanged(const QItemSelection &, const QItemSelection &)
{
QString actionString = QCoreApplication::translate("ShellExtension", "Upload to MEGA");
QStringList files = selectedFiles();
int numFiles = 0;
int numFolders = 0;
for (int i = 0; i < files.size(); i++)
{
if (files[i] != directory().absolutePath())
{
QFileInfo fi(files[i]);
if (fi.exists())
{
if (fi.isDir())
{
numFolders++;
}
else
{
numFiles++;
}
}
}
}
if (!numFiles && !numFolders)
{
le->setText(actionString);
return;
}
QString sNumFiles;
if (numFiles == 1)
{
sNumFiles = QCoreApplication::translate("ShellExtension", "1 file");
}
else if (numFiles > 1)
{
sNumFiles = QCoreApplication::translate("ShellExtension", "%1 files")
.arg(numFiles);
}
QString sNumFolders;
if (numFolders == 1)
{
sNumFolders = QCoreApplication::translate("ShellExtension", "1 folder");
}
else if (numFolders > 1)
{
sNumFolders = QCoreApplication::translate("ShellExtension", "%1 folders")
.arg(numFolders);
}
QString fullString;
if (numFiles && numFolders)
{
fullString = QCoreApplication::translate("ShellExtension", "%1 (%2, %3)")
.arg(actionString).arg(sNumFiles).arg(sNumFolders);
}
else if (numFiles && !numFolders)
{
fullString = QCoreApplication::translate("ShellExtension", "%1 (%2)")
.arg(actionString).arg(sNumFiles);
}
else if (!numFiles && numFolders)
{
fullString = QCoreApplication::translate("ShellExtension", "%1 (%2)")
.arg(actionString).arg(sNumFolders);
}
le->setText(fullString);
}
void DesktopWindow::onFilePropertiesActivated() {
if(FmFileInfoList* files = selectedFiles()) {
Fm::FilePropsDialog::showForFiles(files);
fm_file_info_list_unref(files);
}
}
OLD_MAIN(QWidget* pParent = nullptr)
: QMainWindow(pParent)
{
Q_INIT_RESOURCE(Resources);
// Settings persistence
ReadSettings();
// Appearance LUT
PlayerApperances appearances;
// Build player table model from file
PlayerTableModel* playerTableModel = new PlayerTableModel(this);
playerTableModel->LoadHittingProjections(appearances);
playerTableModel->LoadPitchingProjections(appearances);
playerTableModel->CalculateHittingScores();
playerTableModel->CalculatePitchingScores();
playerTableModel->InitializeTargetValues();
// Draft delegate
DraftDelegate* draftDelegate = new DraftDelegate(playerTableModel);
LinkDelegate* linkDelegate = new LinkDelegate(this);
TagDelegate* tagDelegate = new TagDelegate(this);
// Hitter sort-model
PlayerSortFilterProxyModel* hitterSortFilterProxyModel = new PlayerSortFilterProxyModel(Player::Hitter);
hitterSortFilterProxyModel->setSourceModel(playerTableModel);
hitterSortFilterProxyModel->setSortRole(PlayerTableModel::RawDataRole);
// Hitter table view
QTableView* hitterTableView = MakeTableView(hitterSortFilterProxyModel, true, PlayerTableModel::COLUMN_Z);
hitterTableView->setItemDelegateForColumn(FindColumn(hitterSortFilterProxyModel, PlayerTableModel::COLUMN_DRAFT_BUTTON), draftDelegate);
hitterTableView->setItemDelegateForColumn(FindColumn(hitterSortFilterProxyModel, PlayerTableModel::COLUMN_ID_LINK), linkDelegate);
hitterTableView->setItemDelegateForColumn(FindColumn(hitterSortFilterProxyModel, PlayerTableModel::COLUMN_FLAG), tagDelegate);
hitterTableView->setEditTriggers(QAbstractItemView::DoubleClicked | QAbstractItemView::SelectedClicked);
// Context menu
QMenu* contextMenu = new QMenu();
contextMenu->addAction("&Remove Player");
// Apply to hitter table view
hitterTableView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(hitterTableView, &QWidget::customContextMenuRequested, [=](const QPoint& pos) {
QPoint globalPos = hitterTableView->mapToGlobal(pos);
QAction* selectedItem = contextMenu->exec(globalPos);
if (selectedItem) {
auto proxyIndex = hitterTableView->indexAt(pos);
auto srcIndex = hitterSortFilterProxyModel->mapToSource(proxyIndex);
playerTableModel->RemovePlayer(srcIndex.row());
}
});
// Pitcher sort-model
PlayerSortFilterProxyModel* pitcherSortFilterProxyModel = new PlayerSortFilterProxyModel(Player::Pitcher);
pitcherSortFilterProxyModel->setSourceModel(playerTableModel);
pitcherSortFilterProxyModel->setSortRole(PlayerTableModel::RawDataRole);
// Pitcher table view
QTableView* pitcherTableView = MakeTableView(pitcherSortFilterProxyModel, true, PlayerTableModel::COLUMN_Z);
pitcherTableView->setItemDelegateForColumn(FindColumn(pitcherSortFilterProxyModel, PlayerTableModel::COLUMN_DRAFT_BUTTON), draftDelegate);
pitcherTableView->setItemDelegateForColumn(FindColumn(pitcherSortFilterProxyModel, PlayerTableModel::COLUMN_ID_LINK), linkDelegate);
pitcherTableView->setItemDelegateForColumn(FindColumn(pitcherSortFilterProxyModel, PlayerTableModel::COLUMN_FLAG), tagDelegate);
pitcherTableView->setEditTriggers(QAbstractItemView::DoubleClicked | QAbstractItemView::SelectedClicked);
// Top/Bottom splitter
QSplitter* topBottomSplitter = new QSplitter(Qt::Vertical);
topBottomSplitter->setContentsMargins(5, 5, 5, 5);
// Hitter/Pitcher tab View
enum PlayerTableTabs { Hitters, Pitchers, Unknown };
QTabWidget* hitterPitcherTabs = new QTabWidget(this);
hitterPitcherTabs->insertTab(PlayerTableTabs::Hitters, hitterTableView, "Hitters");
hitterPitcherTabs->insertTab(PlayerTableTabs::Pitchers, pitcherTableView, "Pitchers");
topBottomSplitter->addWidget(hitterPitcherTabs);
// Tab lookup helper
auto CaterogyToTab = [](uint32_t catergory)
{
switch (catergory)
{
case Player::Hitter:
return PlayerTableTabs::Hitters;
case Player::Pitcher:
return PlayerTableTabs::Pitchers;
default:
return PlayerTableTabs::Unknown;
}
};
// Drafted filter action
QAction* filterDrafted = new QAction(this);
connect(filterDrafted, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterDrafted);
connect(filterDrafted, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterDrafted);
filterDrafted->setText(tr("Drafted"));
filterDrafted->setToolTip("Toggle Drafted Players");
filterDrafted->setCheckable(true);
filterDrafted->toggle();
QAction* filterReplacement = new QAction(this);
connect(filterReplacement, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterReplacement);
connect(filterReplacement, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterReplacement);
filterReplacement->setText(tr("($1)"));
filterReplacement->setToolTip("Toggle replacements players with value under $1");
filterReplacement->setCheckable(true);
filterReplacement->toggle();
// NL filter action
QAction* filterNL = new QAction(this);
connect(filterNL, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterNL);
connect(filterNL, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterNL);
filterNL->setText(tr("NL"));
filterNL->setToolTip("Toggle National Leauge");
filterNL->setCheckable(true);
filterNL->toggle();
// AL filter action
QAction* filterAL = new QAction(this);
connect(filterAL, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterAL);
connect(filterAL, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterAL);
filterAL->setText(tr("AL"));
filterAL->setToolTip("Toggle American Leauge");
filterAL->setCheckable(true);
filterAL->toggle();
// FA filter action
QAction* filterFA = new QAction(this);
connect(filterFA, &QAction::toggled, hitterSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterFA);
connect(filterFA, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterFA);
filterFA->setText(tr("FA"));
filterFA->setToolTip("Toggle Free Agents");
filterFA->setCheckable(true);
filterAL->toggle();
filterAL->toggle();
// General filter group
QActionGroup* generalFilters = new QActionGroup(this);
generalFilters->addAction(filterAL);
generalFilters->addAction(filterNL);
generalFilters->addAction(filterFA);
generalFilters->setExclusive(false);
// Starter filter action
QAction* filterStarter = new QAction(this);
connect(filterStarter, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterSP);
filterStarter->setText(tr("SP"));
filterStarter->setToolTip("Toggle Starting Pitchers");
filterStarter->setCheckable(true);
filterStarter->toggle();
// Relief filter action
QAction* filterRelief = new QAction(this);
connect(filterRelief, &QAction::toggled, pitcherSortFilterProxyModel, &PlayerSortFilterProxyModel::OnFilterRP);
filterRelief->setText(tr("RP"));
filterRelief->setToolTip("Toggle Relief Pitchers");
filterRelief->setCheckable(true);
filterRelief->toggle();
// Pitching filter group
QActionGroup* pitchingFilters = new QActionGroup(this);
pitchingFilters->addAction(filterStarter);
pitchingFilters->addAction(filterRelief);
pitchingFilters->setExclusive(false);
// Hitting filter group
QActionGroup* hittingFilters = new QActionGroup(this);
hittingFilters->setExclusive(false);
// Filter helper
auto MakeHitterFilter = [=](QString text, QString toolTip, const auto& onFilterFn) -> QAction*
{
QAction* action = new QAction(this);
connect(action, &QAction::toggled, hitterSortFilterProxyModel, onFilterFn);
action->setText(text);
action->setToolTip(toolTip);
action->setCheckable(true);
action->toggle();
hittingFilters->addAction(action);
return action;
};
// Hitter filters
QAction* filterC = MakeHitterFilter("C", "Filter Catchers", &PlayerSortFilterProxyModel::OnFilterC);
QAction* filter1B = MakeHitterFilter("1B", "Filter 1B", &PlayerSortFilterProxyModel::OnFilter1B);
QAction* filter2B = MakeHitterFilter("2B", "Filter 2B", &PlayerSortFilterProxyModel::OnFilter2B);
QAction* filterSS = MakeHitterFilter("SS", "Filter SS", &PlayerSortFilterProxyModel::OnFilterSS);
QAction* filter3B = MakeHitterFilter("3B", "Filter 3B", &PlayerSortFilterProxyModel::OnFilter3B);
QAction* filterOF = MakeHitterFilter("OF", "Filter Outfielders", &PlayerSortFilterProxyModel::OnFilterOF);
QAction* filterCI = MakeHitterFilter("CI", "Filter Corner Infielders", &PlayerSortFilterProxyModel::OnFilterCI);
QAction* filterMI = MakeHitterFilter("MI", "Filter Middle Infielders", &PlayerSortFilterProxyModel::OnFilterMI);
QAction* filterDH = MakeHitterFilter("DH", "Filter Designated Hitters", &PlayerSortFilterProxyModel::OnFilterDH);
QAction* filterU = MakeHitterFilter("U", "Filter Utility", &PlayerSortFilterProxyModel::OnFilterU);
// Menu spacer
QWidget* spacer = new QWidget(this);
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// Completion Widget
QCompleter* completer = new QCompleter(this);
completer->setModel(playerTableModel);
completer->setCompletionColumn(PlayerTableModel::COLUMN_NAME);
completer->setFilterMode(Qt::MatchContains);
completer->setCaseSensitivity(Qt::CaseInsensitive);
// Select
auto HighlightPlayerInTable = [=](const QModelIndex& srcIdx)
{
// Lookup catergory
auto catergoryIdx = srcIdx.model()->index(srcIdx.row(), PlayerTableModel::COLUMN_CATERGORY);
auto catergory = srcIdx.model()->data(catergoryIdx).toUInt();
// Change to tab
hitterPitcherTabs->setCurrentIndex(CaterogyToTab(catergory));
// Select row
if (catergory == Player::Catergory::Hitter) {
auto proxyModel = dynamic_cast<QSortFilterProxyModel*>(hitterTableView->model());
auto proxyIdx = proxyModel->mapFromSource(srcIdx);
hitterTableView->selectRow(proxyIdx.row());
hitterTableView->setFocus();
} else if (catergory == Player::Catergory::Pitcher) {
auto proxyModel = dynamic_cast<QSortFilterProxyModel*>(pitcherTableView->model());
auto proxyIdx = proxyModel->mapFromSource(srcIdx);
pitcherTableView->selectRow(proxyIdx.row());
pitcherTableView->setFocus();
}
};
// Select the target
connect(completer, static_cast<void (QCompleter::*)(const QModelIndex&)>(&QCompleter::activated), [=](const QModelIndex& index) {
// Get player index
QAbstractProxyModel* proxyModel = dynamic_cast<QAbstractProxyModel*>(completer->completionModel());
auto srcIdx = proxyModel->mapToSource(index);
// Highlight this player
HighlightPlayerInTable(srcIdx);
});
// Search widget
QLineEdit* playerSearch = new QLineEdit(this);
playerSearch->setCompleter(completer);
// Main toolbar
QToolBar* toolbar = new QToolBar("Toolbar");
toolbar->addWidget(new QLabel(" Status: ", this));
toolbar->addActions(QList<QAction*>{filterDrafted, filterReplacement});
toolbar->addSeparator();
toolbar->addWidget(new QLabel(" Leagues: ", this));
toolbar->addActions(QList<QAction*>{filterAL, filterNL, filterFA});
toolbar->addSeparator();
toolbar->addWidget(new QLabel(" Positions: ", this));
toolbar->addActions(QList<QAction*>{filterStarter, filterRelief});
toolbar->addActions(QList<QAction*>{filterC, filter1B, filter2B, filterSS, filter3B, filterOF, filterCI, filterMI, filterDH, filterU});
toolbar->addWidget(spacer);
toolbar->addWidget(new QLabel("Player Search: ", this));
toolbar->addWidget(playerSearch);
toolbar->setFloatable(false);
toolbar->setMovable(false);
QMainWindow::addToolBar(toolbar);
// Helper to adjust filters
auto ToggleFilterGroups = [=](int index)
{
switch (index)
{
case uint32_t(PlayerTableTabs::Hitters):
pitchingFilters->setVisible(false);
hittingFilters->setVisible(true);
break;
case uint32_t(PlayerTableTabs::Pitchers):
pitchingFilters->setVisible(true);
hittingFilters->setVisible(false);
break;
default:
break;
}
};
// Set default filter group
ToggleFilterGroups(hitterPitcherTabs->currentIndex());
//---------------------------------------------------------------------
// Bottom Section
//---------------------------------------------------------------------
// Owner widget
QHBoxLayout* ownersLayout = new QHBoxLayout(this);
ownersLayout->setSizeConstraint(QLayout::SetNoConstraint);
// Owner models
std::vector<OwnerSortFilterProxyModel*> vecOwnerSortFilterProxyModels;
// Owner labels
QList<QLabel*>* pVecOwnerLabels;
pVecOwnerLabels = new QList<QLabel*>();
pVecOwnerLabels->append(new QLabel("--"));
for (auto i = 1u; i <= DraftSettings::Get().OwnerCount; i++) {
pVecOwnerLabels->append(new QLabel(DraftSettings::Get().OwnerNames[i]));
}
// Update label helper
auto UpdateOwnerLabels = [=]() {
for (auto i = 1u; i <= DraftSettings::Get().OwnerCount; i++) {
pVecOwnerLabels->at(i)->setText(DraftSettings::Get().OwnerNames[i]);
}
};
// Initialize
UpdateOwnerLabels();
// Loop owners
for (uint32_t ownerId = 1; ownerId <= DraftSettings::Get().OwnerCount; ownerId++) {
// V-Layout per owner
QVBoxLayout* perOwnerLayout = new QVBoxLayout(this);
ownersLayout->addLayout(perOwnerLayout);
perOwnerLayout->setSizeConstraint(QLayout::SetNoConstraint);
// Proxy model for this owner
OwnerSortFilterProxyModel* ownerSortFilterProxyModel = new OwnerSortFilterProxyModel(ownerId, playerTableModel, this);
vecOwnerSortFilterProxyModels.push_back(ownerSortFilterProxyModel);
// Owner name label
pVecOwnerLabels->at(ownerId)->setAlignment(Qt::AlignCenter);
perOwnerLayout->addWidget(pVecOwnerLabels->at(ownerId));
// Per-owner roster table view
const uint32_t tableWidth = 225;
QTableView* ownerRosterTableView = MakeTableView(ownerSortFilterProxyModel, true, 0);
ownerRosterTableView->setMinimumSize(tableWidth, 65);
ownerRosterTableView->setMaximumSize(tableWidth, 4096);
ownerRosterTableView->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
perOwnerLayout->addWidget(ownerRosterTableView);
// XXX: This should be a form layout...
QGridLayout* ownerSummaryGridLayout = new QGridLayout(this);
ownerSummaryGridLayout->setSpacing(0);
ownerSummaryGridLayout->addWidget(MakeLabel("Budget: "), 0, 0);
ownerSummaryGridLayout->addWidget(MakeLabel("# Hitters: "), 1, 0);
ownerSummaryGridLayout->addWidget(MakeLabel("# Pitchers: "), 2, 0);
ownerSummaryGridLayout->addWidget(MakeLabel("Max Bid: "), 3, 0);
QLabel* budgetLabel = MakeLabel();
QLabel* numHittersLabel = MakeLabel();
QLabel* numPitchersLabel = MakeLabel();
QLabel* maxBidLabel = MakeLabel();
// Helper
auto UpdateLabels = [=]()
{
budgetLabel->setText(QString("$%1").arg(ownerSortFilterProxyModel->GetRemainingBudget()));
numHittersLabel->setText(QString("%1 / %2").arg(ownerSortFilterProxyModel->Count(Player::Hitter)).arg(DraftSettings::Get().HitterCount));
numPitchersLabel->setText(QString("%1 / %2").arg(ownerSortFilterProxyModel->Count(Player::Pitcher)).arg(DraftSettings::Get().PitcherCount));
maxBidLabel->setText(QString("$%1").arg(ownerSortFilterProxyModel->GetMaxBid()));
};
// Update labels when a draft event happens
connect(playerTableModel, &PlayerTableModel::DraftedEnd, [=]() {
UpdateLabels();
});
UpdateLabels();
ownerSummaryGridLayout->addWidget(budgetLabel, 0, 1);
ownerSummaryGridLayout->addWidget(numHittersLabel, 1, 1);
ownerSummaryGridLayout->addWidget(numPitchersLabel, 2, 1);
ownerSummaryGridLayout->addWidget(maxBidLabel, 3, 1);
QSpacerItem* spacer = new QSpacerItem(1, 1, QSizePolicy::Preferred, QSizePolicy::Preferred);
ownerSummaryGridLayout->addItem(spacer, 0, 2);
ownerSummaryGridLayout->addItem(spacer, 1, 2);
ownerSummaryGridLayout->addItem(spacer, 2, 2);
ownerSummaryGridLayout->addItem(spacer, 3, 2);
perOwnerLayout->addLayout(ownerSummaryGridLayout);
perOwnerLayout->addSpacerItem(spacer);
}
// Owner widget
QWidget* scrollAreaWidgetContents = new QWidget(this);
scrollAreaWidgetContents->setLayout(ownersLayout);
scrollAreaWidgetContents->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
// Owner scroll area
QScrollArea* ownerScrollArea = new QScrollArea(this);
ownerScrollArea->setWidget(scrollAreaWidgetContents);
ownerScrollArea->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
ownerScrollArea->setBackgroundRole(QPalette::Light);
ownerScrollArea->setFrameShape(QFrame::NoFrame);
ownerScrollArea->setWidgetResizable(true);
// Target value widget
QWidget* targetValueWidget = new QWidget(this);
QFormLayout* targetValueLayout = new QFormLayout(this);
targetValueWidget->setLayout(targetValueLayout);
auto values = {
PlayerTableModel::COLUMN_AVG,
PlayerTableModel::COLUMN_HR,
PlayerTableModel::COLUMN_R,
PlayerTableModel::COLUMN_RBI,
PlayerTableModel::COLUMN_SB,
PlayerTableModel::COLUMN_SO,
PlayerTableModel::COLUMN_ERA,
PlayerTableModel::COLUMN_WHIP,
PlayerTableModel::COLUMN_W,
PlayerTableModel::COLUMN_SV,
};
for (auto value : values) {
auto name = playerTableModel->headerData(value, Qt::Horizontal, Qt::DisplayRole).toString();
auto target = QString::number(playerTableModel->GetTargetValue(value), 'f', 3);
targetValueLayout->addRow(name, new QLabel(target));
}
// Player scatter plot
PlayerScatterPlotChart* chartView = new PlayerScatterPlotChart(playerTableModel, hitterSortFilterProxyModel, this);
connect(hitterSortFilterProxyModel, &QSortFilterProxyModel::layoutChanged, chartView, &PlayerScatterPlotChart::Update);
connect(pitcherSortFilterProxyModel, &QSortFilterProxyModel::layoutChanged, chartView, &PlayerScatterPlotChart::Update);
connect(playerTableModel, &QAbstractItemModel::dataChanged, chartView, &PlayerScatterPlotChart::Update);
// Summary view
SummaryWidget* summary = new SummaryWidget(playerTableModel, vecOwnerSortFilterProxyModels, this);
// Bottom tabs
enum BottomSectionTabs { Rosters, Summary, Targets, ChartView, Log };
QTabWidget* bottomTabs = new QTabWidget(this);
topBottomSplitter->addWidget(bottomTabs);
bottomTabs->insertTab(BottomSectionTabs::Rosters, ownerScrollArea, "Rosters");
bottomTabs->insertTab(BottomSectionTabs::Summary, summary, "Summary");
bottomTabs->insertTab(BottomSectionTabs::Targets, targetValueWidget, "Targets");
bottomTabs->insertTab(BottomSectionTabs::ChartView, chartView, "Scatter Chart");
bottomTabs->insertTab(BottomSectionTabs::Log, GlobalLogger::Get(), "Log");
// Make top section 3x the size of the bottom
topBottomSplitter->setStretchFactor(0, 3);
topBottomSplitter->setStretchFactor(1, 1);
//----------------------------------------------------------------------
// Connections
//----------------------------------------------------------------------
// Connect tab filters
connect(hitterPitcherTabs, &QTabWidget::currentChanged, this, [=](int index) {
// Update filters
ToggleFilterGroups(index);
// Update chart view
switch (index)
{
case PlayerTableTabs::Hitters:
chartView->SetProxyModel(hitterSortFilterProxyModel);
break;
case PlayerTableTabs::Pitchers:
chartView->SetProxyModel(pitcherSortFilterProxyModel);
break;
default:
break;
}
});
// Connect chart click
connect(chartView, &PlayerScatterPlotChart::PlayerClicked, this, [=](const QModelIndex& index) {
HighlightPlayerInTable(index);
});
// Connect summary model
connect(playerTableModel, &PlayerTableModel::DraftedEnd, summary, &SummaryWidget::OnDraftedEnd);
//----------------------------------------------------------------------
// Main
//----------------------------------------------------------------------
// Set as main window
QMainWindow::setCentralWidget(topBottomSplitter);
// Create main menu bar
QMenuBar* mainMenuBar = new QMenuBar();
QMainWindow::setMenuBar(mainMenuBar);
// Main Menu > File menu
QMenu* fileMenu = mainMenuBar->addMenu("&File");
// File dialog helper
auto GetFileDialog = [&](QFileDialog::AcceptMode mode) -> QFileDialog*
{
QFileDialog* dialog = new QFileDialog(this);
dialog->setWindowModality(Qt::WindowModal);
dialog->setAcceptMode(mode);
dialog->setNameFilter("CSV files (*.csv)");
return dialog;
};
// Ask for the save location
auto SetSaveAsFile = [=]()
{
QStringList files;
auto dialog = GetFileDialog(QFileDialog::AcceptSave);
if (dialog->exec()) {
files = dialog->selectedFiles();
} else {
return false;
}
m_currentFile = files.at(0);
return true;
};
// Update title bar
auto UpdateApplicationName = [this]()
{
auto name = QString("fbb -- %1").arg(QFileInfo(m_currentFile).fileName());
QCoreApplication::setApplicationName(name);
setWindowTitle(name);
};
// Main Menu > File menu > Save action
QAction* saveResultsAction = new QAction("&Save Results", this);
connect(saveResultsAction, &QAction::triggered, [=](bool checked) {
if (m_currentFile.isEmpty()) {
SetSaveAsFile();
}
GlobalLogger::AppendMessage(QString("Saving file: %1...").arg(m_currentFile));
UpdateApplicationName();
return playerTableModel->SaveDraftStatus(m_currentFile);
});
fileMenu->addAction(saveResultsAction);
// Main Menu > File menu > Save As action
QAction* saveResultsAsAction = new QAction("Save Results &As...", this);
connect(saveResultsAsAction, &QAction::triggered, [=](bool checked) {
SetSaveAsFile();
GlobalLogger::AppendMessage(QString("Saving file: %1...").arg(m_currentFile));
UpdateApplicationName();
return playerTableModel->SaveDraftStatus(m_currentFile);
});
fileMenu->addAction(saveResultsAsAction);
// Main Menu > File menu > Load action
QAction* loadResultsAction = new QAction("&Load Results...", this);
connect(loadResultsAction, &QAction::triggered, [=](bool checked) {
auto dialog = GetFileDialog(QFileDialog::AcceptOpen);
QStringList files;
if (dialog->exec()) {
files = dialog->selectedFiles();
} else {
return false;
}
m_currentFile = files.at(0);
GlobalLogger::AppendMessage(QString("Loading file: %1...").arg(m_currentFile));
UpdateApplicationName();
return playerTableModel->LoadDraftStatus(m_currentFile);
});
fileMenu->addAction(loadResultsAction);
// Main Menu > File menu
QMenu* settingsMenu = mainMenuBar->addMenu("&Settings");
// Main Menu > Settings menu > Options action
QAction* settingsAction = new QAction("&Settings...", this);
connect(settingsAction, &QAction::triggered, [=](bool checked) {
DraftSettingsDialog draftSettingsDialog;
if (draftSettingsDialog.exec()) {
UpdateOwnerLabels();
}
});
settingsMenu->addAction(settingsAction);
// Main Menu > Settings menu > Options action
QAction* demoDataAction = new QAction("&DemoData...", this);
connect(demoDataAction, &QAction::triggered, [=](bool checked) {
playerTableModel->DraftRandom();
});
settingsMenu->addAction(demoDataAction);
// show me
QMainWindow::show();
}
QString QG_FileDialog::getSaveFile(RS2::FormatType* type){
setAcceptMode ( QFileDialog::AcceptSave );
// read default settings:
RS_SETTINGS->beginGroup("/Paths");
QString defDir = RS_SETTINGS->readEntry("/Save",
RS_SYSTEM->getHomeDir());
/* QString defFilter = RS_SETTINGS->readEntry("/SaveFilter",
"Drawing Exchange DXF 2000 (*.dxf)");*/
RS_SETTINGS->endGroup();
if(!defDir.endsWith("/") && !defDir.endsWith("\\"))
defDir += QDir::separator();
RS_DEBUG->print("defDir: %s", defDir.toLatin1().data());
// setup filters
QStringList filters;
filters << fDxfrw2007 << fDxfrw2004 << fDxfrw2000 << fDxfrw14 << fDxfrw12 << fLff << fCxf << fJww;
ftype = RS2::FormatDXFRW;
RS_DEBUG->print("defFilter: %s", fDxfrw2007.toLatin1().data());
// when defFilter is added the below should use the default extension.
// generate an untitled name
QString fn = "Untitled";
if(QFile::exists( defDir + fn + getExtension( ftype ) ))
{
int fileCount = 1;
while(QFile::exists( defDir + fn + QString("%1").arg(fileCount) +
getExtension(ftype)) )
++fileCount;
fn += QString("%1").arg(fileCount);
}
// initialize dialog properties
setWindowTitle(tr("Save %1 As").arg(name));
setFileMode(QFileDialog::AnyFile);
setDirectory(defDir);
setFilters(filters);
selectNameFilter(fDxfrw2007);
selectFile(fn);
auto&& ext=getExtension(ftype);
if(ext.size()==4){
if(ext[0]=='.') ext.remove(0,1);
}
if(ext.size()==3) setDefaultSuffix (ext);
// only return non empty string when we have a complete, user approved, file name.
if (exec()!=QDialog::Accepted)
return QString("");
QStringList fl = selectedFiles();
if (fl.isEmpty())
return QString("");
QFileInfo fi = QFileInfo( fl[0] );
fn = QDir::toNativeSeparators( fi.absoluteFilePath() );
getType(selectedFilter());
if (type!=NULL)
*type = ftype;
// append default extension:
if (fi.fileName().endsWith(".dxf",Qt::CaseInsensitive)==-1)
fn += getExtension(ftype);
// store new default settings:
RS_SETTINGS->beginGroup("/Paths");
RS_SETTINGS->writeEntry("/Save", fi.absolutePath());
//RS_SETTINGS->writeEntry("/SaveFilter", fileDlg->selectedFilter());
RS_SETTINGS->endGroup();
return fn;
}
void DesktopWindow::onBulkRenameActivated() {
BulkRenamer(selectedFiles(), this);
}
int ExportDissectionDialog::exec()
{
#if !defined(Q_OS_WIN)
int retval;
if (!cap_file_) return QDialog::Rejected;
retval = QFileDialog::exec();
if (retval == QDialog::Accepted && selectedFiles().length() > 0) {
cf_print_status_t status;
QString file_name = selectedFiles()[0];
/* Fill in our print (and export) args */
print_args_.file = file_name.toUtf8().data();
print_args_.format = PR_FMT_TEXT;
print_args_.to_file = TRUE;
print_args_.cmd = NULL;
print_args_.print_summary = TRUE;
print_args_.print_dissections = print_dissections_as_displayed;
print_args_.print_hex = FALSE;
print_args_.print_formfeed = FALSE;
switch (export_type_) {
case export_type_text: /* Text */
print_args_.print_summary = packet_format_group_box_.summaryEnabled();
print_args_.print_dissections = print_dissections_none;
if (packet_format_group_box_.detailsEnabled()) {
if (packet_format_group_box_.allCollapsedEnabled())
print_args_.print_dissections = print_dissections_collapsed;
else if (packet_format_group_box_.asDisplayedEnabled())
print_args_.print_dissections = print_dissections_as_displayed;
else if (packet_format_group_box_.allExpandedEnabled())
print_args_.print_dissections = print_dissections_expanded;
}
print_args_.print_hex = packet_format_group_box_.bytesEnabled();
print_args_.stream = print_stream_text_new(TRUE, print_args_.file);
if (print_args_.stream == NULL) {
open_failure_alert_box(print_args_.file, errno, TRUE);
return QDialog::Rejected;
}
status = cf_print_packets(cap_file_, &print_args_);
break;
case export_type_csv: /* CSV */
status = cf_write_csv_packets(cap_file_, &print_args_);
break;
case export_type_carrays: /* C Arrays */
status = cf_write_carrays_packets(cap_file_, &print_args_);
break;
case export_type_psml: /* PSML */
status = cf_write_psml_packets(cap_file_, &print_args_);
break;
case export_type_pdml: /* PDML */
status = cf_write_pdml_packets(cap_file_, &print_args_);
break;
default:
return QDialog::Rejected;
}
switch (status) {
case CF_PRINT_OK:
break;
case CF_PRINT_OPEN_ERROR:
open_failure_alert_box(print_args_.file, errno, TRUE);
break;
case CF_PRINT_WRITE_ERROR:
write_failure_alert_box(print_args_.file, errno);
break;
}
if (selectedFiles().length() > 0) {
gchar *dirname;
/* Save the directory name for future file dialogs. */
dirname = get_dirname(print_args_.file); /* Overwrites file_name data */
set_last_open_dir(dirname);
}
}
return retval;
#else // Q_OS_WIN
win32_export_file(parentWidget()->effectiveWinId(), cap_file_, export_type_);
return QDialog::Accepted;
#endif // Q_OS_WIN
}
void DesktopWindow::onFilePropertiesActivated() {
auto files = selectedFiles();
if(!files.empty()) {
Fm::FilePropsDialog::showForFiles(std::move(files));
}
}
