1 /******************************************************************************
2 Copyright (C) 2019 by Dillon Pentz <dillon@vodbox.io>
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>.
16 ******************************************************************************/
17
18 #include "window-missing-files.hpp"
19 #include "window-basic-main.hpp"
20
21 #include "obs-app.hpp"
22
23 #include <QLineEdit>
24 #include <QToolButton>
25 #include <QFileDialog>
26
27 #include "qt-wrappers.hpp"
28
29 enum MissingFilesColumn {
30 Source,
31 OriginalPath,
32 NewPath,
33 State,
34
35 Count
36 };
37
38 enum MissingFilesRole { EntryStateRole = Qt::UserRole, NewPathsToProcessRole };
39
40 /**********************************************************
41 Delegate - Presents cells in the grid.
42 **********************************************************/
43
MissingFilesPathItemDelegate(bool isOutput,const QString & defaultPath)44 MissingFilesPathItemDelegate::MissingFilesPathItemDelegate(
45 bool isOutput, const QString &defaultPath)
46 : QStyledItemDelegate(), isOutput(isOutput), defaultPath(defaultPath)
47 {
48 }
49
createEditor(QWidget * parent,const QStyleOptionViewItem &,const QModelIndex & index) const50 QWidget *MissingFilesPathItemDelegate::createEditor(
51 QWidget *parent, const QStyleOptionViewItem & /* option */,
52 const QModelIndex &index) const
53 {
54 QSizePolicy buttonSizePolicy(QSizePolicy::Policy::Minimum,
55 QSizePolicy::Policy::Expanding,
56 QSizePolicy::ControlType::PushButton);
57
58 QWidget *container = new QWidget(parent);
59
60 auto browseCallback = [this, container]() {
61 const_cast<MissingFilesPathItemDelegate *>(this)->handleBrowse(
62 container);
63 };
64
65 auto clearCallback = [this, container]() {
66 const_cast<MissingFilesPathItemDelegate *>(this)->handleClear(
67 container);
68 };
69
70 QHBoxLayout *layout = new QHBoxLayout();
71 layout->setContentsMargins(0, 0, 0, 0);
72 layout->setSpacing(0);
73
74 QLineEdit *text = new QLineEdit();
75 text->setObjectName(QStringLiteral("text"));
76 text->setSizePolicy(QSizePolicy(QSizePolicy::Policy::Expanding,
77 QSizePolicy::Policy::Expanding,
78 QSizePolicy::ControlType::LineEdit));
79 layout->addWidget(text);
80
81 QToolButton *browseButton = new QToolButton();
82 browseButton->setText("...");
83 browseButton->setSizePolicy(buttonSizePolicy);
84 layout->addWidget(browseButton);
85
86 container->connect(browseButton, &QToolButton::clicked, browseCallback);
87
88 // The "clear" button is not shown in input cells
89 if (isOutput) {
90 QToolButton *clearButton = new QToolButton();
91 clearButton->setText("X");
92 clearButton->setSizePolicy(buttonSizePolicy);
93 layout->addWidget(clearButton);
94
95 container->connect(clearButton, &QToolButton::clicked,
96 clearCallback);
97 }
98
99 container->setLayout(layout);
100 container->setFocusProxy(text);
101
102 UNUSED_PARAMETER(index);
103
104 return container;
105 }
106
setEditorData(QWidget * editor,const QModelIndex & index) const107 void MissingFilesPathItemDelegate::setEditorData(QWidget *editor,
108 const QModelIndex &index) const
109 {
110 QLineEdit *text = editor->findChild<QLineEdit *>();
111 text->setText(index.data().toString());
112
113 editor->setProperty(PATH_LIST_PROP, QVariant());
114 }
115
setModelData(QWidget * editor,QAbstractItemModel * model,const QModelIndex & index) const116 void MissingFilesPathItemDelegate::setModelData(QWidget *editor,
117 QAbstractItemModel *model,
118 const QModelIndex &index) const
119 {
120 // We use the PATH_LIST_PROP property to pass a list of
121 // path strings from the editor widget into the model's
122 // NewPathsToProcessRole. This is only used when paths
123 // are selected through the "browse" or "delete" buttons
124 // in the editor. If the user enters new text in the
125 // text box, we simply pass that text on to the model
126 // as normal text data in the default role.
127 QVariant pathListProp = editor->property(PATH_LIST_PROP);
128 if (pathListProp.isValid()) {
129 QStringList list =
130 editor->property(PATH_LIST_PROP).toStringList();
131 if (isOutput) {
132 model->setData(index, list);
133 } else
134 model->setData(index, list,
135 MissingFilesRole::NewPathsToProcessRole);
136 } else {
137 QLineEdit *lineEdit = editor->findChild<QLineEdit *>();
138 model->setData(index, lineEdit->text(), 0);
139 }
140 }
141
paint(QPainter * painter,const QStyleOptionViewItem & option,const QModelIndex & index) const142 void MissingFilesPathItemDelegate::paint(QPainter *painter,
143 const QStyleOptionViewItem &option,
144 const QModelIndex &index) const
145 {
146 QStyleOptionViewItem localOption = option;
147 initStyleOption(&localOption, index);
148
149 QApplication::style()->drawControl(QStyle::CE_ItemViewItem,
150 &localOption, painter);
151 }
152
handleBrowse(QWidget * container)153 void MissingFilesPathItemDelegate::handleBrowse(QWidget *container)
154 {
155
156 QLineEdit *text = container->findChild<QLineEdit *>();
157
158 QString currentPath = text->text();
159 if (currentPath.isEmpty() ||
160 currentPath.compare(QTStr("MissingFiles.Clear")) == 0)
161 currentPath = defaultPath;
162
163 bool isSet = false;
164 if (isOutput) {
165 QString newPath = QFileDialog::getOpenFileName(
166 container, QTStr("MissingFiles.SelectFile"),
167 currentPath, nullptr);
168
169 if (!newPath.isEmpty()) {
170 container->setProperty(PATH_LIST_PROP,
171 QStringList() << newPath);
172 isSet = true;
173 }
174 }
175
176 if (isSet)
177 emit commitData(container);
178 }
179
handleClear(QWidget * container)180 void MissingFilesPathItemDelegate::handleClear(QWidget *container)
181 {
182 // An empty string list will indicate that the entry is being
183 // blanked and should be deleted.
184 container->setProperty(PATH_LIST_PROP,
185 QStringList() << QTStr("MissingFiles.Clear"));
186 container->findChild<QLineEdit *>()->clearFocus();
187 ((QWidget *)container->parent())->setFocus();
188 emit commitData(container);
189 }
190
191 /**
192 Model
193 **/
194
MissingFilesModel(QObject * parent)195 MissingFilesModel::MissingFilesModel(QObject *parent)
196 : QAbstractTableModel(parent)
197 {
198 QStyle *style = QApplication::style();
199
200 warningIcon = style->standardIcon(QStyle::SP_MessageBoxWarning);
201 }
202
rowCount(const QModelIndex &) const203 int MissingFilesModel::rowCount(const QModelIndex &) const
204 {
205 return files.length();
206 }
207
columnCount(const QModelIndex &) const208 int MissingFilesModel::columnCount(const QModelIndex &) const
209 {
210 return MissingFilesColumn::Count;
211 }
212
found() const213 int MissingFilesModel::found() const
214 {
215 int res = 0;
216
217 for (int i = 0; i < files.length(); i++) {
218 if (files[i].state != Missing && files[i].state != Cleared)
219 res++;
220 }
221
222 return res;
223 }
224
data(const QModelIndex & index,int role) const225 QVariant MissingFilesModel::data(const QModelIndex &index, int role) const
226 {
227 QVariant result = QVariant();
228
229 if (index.row() >= files.length()) {
230 return QVariant();
231 } else if (role == Qt::DisplayRole) {
232 QFileInfo fi(files[index.row()].originalPath);
233
234 switch (index.column()) {
235 case MissingFilesColumn::Source:
236 result = files[index.row()].source;
237 break;
238 case MissingFilesColumn::OriginalPath:
239 result = fi.fileName();
240 break;
241 case MissingFilesColumn::NewPath:
242 result = files[index.row()].newPath;
243 break;
244 case MissingFilesColumn::State:
245 switch (files[index.row()].state) {
246 case MissingFilesState::Missing:
247 result = QTStr("MissingFiles.Missing");
248 break;
249
250 case MissingFilesState::Replaced:
251 result = QTStr("MissingFiles.Replaced");
252 break;
253
254 case MissingFilesState::Found:
255 result = QTStr("MissingFiles.Found");
256 break;
257
258 case MissingFilesState::Cleared:
259 result = QTStr("MissingFiles.Cleared");
260 break;
261 }
262 break;
263 }
264 } else if (role == Qt::DecorationRole &&
265 index.column() == MissingFilesColumn::Source) {
266 OBSBasic *main =
267 reinterpret_cast<OBSBasic *>(App()->GetMainWindow());
268 obs_source_t *source = obs_get_source_by_name(
269 files[index.row()].source.toStdString().c_str());
270
271 if (source) {
272 result = main->GetSourceIcon(obs_source_get_id(source));
273
274 obs_source_release(source);
275 }
276 } else if (role == Qt::FontRole &&
277 index.column() == MissingFilesColumn::State) {
278 QFont font = QFont();
279 font.setBold(true);
280
281 result = font;
282 } else if (role == Qt::ToolTipRole &&
283 index.column() == MissingFilesColumn::State) {
284 switch (files[index.row()].state) {
285 case MissingFilesState::Missing:
286 result = QTStr("MissingFiles.Missing");
287 break;
288
289 case MissingFilesState::Replaced:
290 result = QTStr("MissingFiles.Replaced");
291 break;
292
293 case MissingFilesState::Found:
294 result = QTStr("MissingFiles.Found");
295 break;
296
297 case MissingFilesState::Cleared:
298 result = QTStr("MissingFiles.Cleared");
299 break;
300
301 default:
302 break;
303 }
304 } else if (role == Qt::ToolTipRole) {
305 switch (index.column()) {
306 case MissingFilesColumn::OriginalPath:
307 result = files[index.row()].originalPath;
308 break;
309 case MissingFilesColumn::NewPath:
310 result = files[index.row()].newPath;
311 break;
312 default:
313 break;
314 }
315 }
316
317 return result;
318 }
319
flags(const QModelIndex & index) const320 Qt::ItemFlags MissingFilesModel::flags(const QModelIndex &index) const
321 {
322 Qt::ItemFlags flags = QAbstractTableModel::flags(index);
323
324 if (index.column() == MissingFilesColumn::OriginalPath) {
325 flags &= ~Qt::ItemIsEditable;
326 } else if (index.column() == MissingFilesColumn::NewPath &&
327 index.row() != files.length()) {
328 flags |= Qt::ItemIsEditable;
329 }
330
331 return flags;
332 }
333
fileCheckLoop(QList<MissingFileEntry> files,QString path,bool skipPrompt)334 void MissingFilesModel::fileCheckLoop(QList<MissingFileEntry> files,
335 QString path, bool skipPrompt)
336 {
337 loop = false;
338 QUrl url = QUrl().fromLocalFile(path);
339 QString dir =
340 url.toDisplayString(QUrl::RemoveScheme | QUrl::RemoveFilename |
341 QUrl::PreferLocalFile);
342
343 bool prompted = skipPrompt;
344
345 for (int i = 0; i < files.length(); i++) {
346 if (files[i].state != MissingFilesState::Missing)
347 continue;
348
349 QUrl origFile = QUrl().fromLocalFile(files[i].originalPath);
350 QString filename = origFile.fileName();
351 QString testFile = dir + filename;
352
353 if (os_file_exists(testFile.toStdString().c_str())) {
354 if (!prompted) {
355 QMessageBox::StandardButton button =
356 QMessageBox::question(
357 nullptr,
358 QTStr("MissingFiles.AutoSearch"),
359 QTStr("MissingFiles.AutoSearchText"));
360
361 if (button == QMessageBox::No)
362 break;
363
364 prompted = true;
365 }
366 QModelIndex in = index(i, MissingFilesColumn::NewPath);
367 setData(in, testFile, 0);
368 }
369 }
370 loop = true;
371 }
372
setData(const QModelIndex & index,const QVariant & value,int role)373 bool MissingFilesModel::setData(const QModelIndex &index, const QVariant &value,
374 int role)
375 {
376 bool success = false;
377
378 if (role == MissingFilesRole::NewPathsToProcessRole) {
379 QStringList list = value.toStringList();
380
381 int row = index.row() + 1;
382 beginInsertRows(QModelIndex(), row, row);
383
384 MissingFileEntry entry;
385 entry.originalPath = list[0].replace("\\", "/");
386 entry.source = list[1];
387
388 files.insert(row, entry);
389 row++;
390
391 endInsertRows();
392
393 success = true;
394 } else {
395 QString path = value.toString();
396 if (index.column() == MissingFilesColumn::NewPath) {
397 files[index.row()].newPath = value.toString();
398 QString fileName = QUrl(path).fileName();
399 QString origFileName =
400 QUrl(files[index.row()].originalPath).fileName();
401
402 if (path.isEmpty()) {
403 files[index.row()].state =
404 MissingFilesState::Missing;
405 } else if (path.compare(QTStr("MissingFiles.Clear")) ==
406 0) {
407 files[index.row()].state =
408 MissingFilesState::Cleared;
409 } else if (fileName.compare(origFileName) == 0) {
410 files[index.row()].state =
411 MissingFilesState::Found;
412
413 if (loop)
414 fileCheckLoop(files, path, false);
415 } else {
416 files[index.row()].state =
417 MissingFilesState::Replaced;
418
419 if (loop)
420 fileCheckLoop(files, path, false);
421 }
422
423 emit dataChanged(index, index);
424 success = true;
425 }
426 }
427
428 return success;
429 }
430
headerData(int section,Qt::Orientation orientation,int role) const431 QVariant MissingFilesModel::headerData(int section, Qt::Orientation orientation,
432 int role) const
433 {
434 QVariant result = QVariant();
435
436 if (role == Qt::DisplayRole &&
437 orientation == Qt::Orientation::Horizontal) {
438 switch (section) {
439 case MissingFilesColumn::State:
440 result = QTStr("MissingFiles.State");
441 break;
442 case MissingFilesColumn::Source:
443 result = QTStr("Basic.Main.Source");
444 break;
445 case MissingFilesColumn::OriginalPath:
446 result = QTStr("MissingFiles.MissingFile");
447 break;
448 case MissingFilesColumn::NewPath:
449 result = QTStr("MissingFiles.NewFile");
450 break;
451 }
452 }
453
454 return result;
455 }
456
OBSMissingFiles(obs_missing_files_t * files,QWidget * parent)457 OBSMissingFiles::OBSMissingFiles(obs_missing_files_t *files, QWidget *parent)
458 : QDialog(parent),
459 filesModel(new MissingFilesModel),
460 ui(new Ui::OBSMissingFiles)
461 {
462 setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
463
464 ui->setupUi(this);
465
466 ui->tableView->setModel(filesModel);
467 ui->tableView->setItemDelegateForColumn(
468 MissingFilesColumn::OriginalPath,
469 new MissingFilesPathItemDelegate(false, ""));
470 ui->tableView->setItemDelegateForColumn(
471 MissingFilesColumn::NewPath,
472 new MissingFilesPathItemDelegate(true, ""));
473 ui->tableView->horizontalHeader()->setSectionResizeMode(
474 QHeaderView::ResizeMode::Stretch);
475 ui->tableView->horizontalHeader()->setSectionResizeMode(
476 MissingFilesColumn::Source,
477 QHeaderView::ResizeMode::ResizeToContents);
478 ui->tableView->horizontalHeader()->setMaximumSectionSize(width() / 3);
479 ui->tableView->horizontalHeader()->setSectionResizeMode(
480 MissingFilesColumn::State,
481 QHeaderView::ResizeMode::ResizeToContents);
482 ui->tableView->setEditTriggers(
483 QAbstractItemView::EditTrigger::CurrentChanged);
484
485 ui->warningIcon->setPixmap(
486 filesModel->warningIcon.pixmap(QSize(32, 32)));
487
488 for (size_t i = 0; i < obs_missing_files_count(files); i++) {
489 obs_missing_file_t *f =
490 obs_missing_files_get_file(files, (int)i);
491
492 const char *oldPath = obs_missing_file_get_path(f);
493 const char *name = obs_missing_file_get_source_name(f);
494
495 addMissingFile(oldPath, name);
496 }
497
498 QString found = QTStr("MissingFiles.NumFound");
499 found.replace("$1", "0");
500 found.replace("$2", QString::number(obs_missing_files_count(files)));
501
502 ui->found->setText(found);
503
504 fileStore = files;
505
506 connect(ui->doneButton, &QPushButton::clicked, this,
507 &OBSMissingFiles::saveFiles);
508 connect(ui->browseButton, &QPushButton::clicked, this,
509 &OBSMissingFiles::browseFolders);
510 connect(ui->cancelButton, &QPushButton::clicked, this,
511 &OBSMissingFiles::close);
512 connect(filesModel, SIGNAL(dataChanged(QModelIndex, QModelIndex)), this,
513 SLOT(dataChanged()));
514
515 QModelIndex index = filesModel->createIndex(0, 1);
516 QMetaObject::invokeMethod(ui->tableView, "setCurrentIndex",
517 Qt::QueuedConnection,
518 Q_ARG(const QModelIndex &, index));
519 }
520
~OBSMissingFiles()521 OBSMissingFiles::~OBSMissingFiles()
522 {
523 obs_missing_files_destroy(fileStore);
524 }
525
addMissingFile(const char * originalPath,const char * sourceName)526 void OBSMissingFiles::addMissingFile(const char *originalPath,
527 const char *sourceName)
528 {
529 QStringList list;
530
531 list.append(originalPath);
532 list.append(sourceName);
533
534 QModelIndex insertIndex = filesModel->index(filesModel->rowCount() - 1,
535 MissingFilesColumn::Source);
536
537 filesModel->setData(insertIndex, list,
538 MissingFilesRole::NewPathsToProcessRole);
539 }
540
saveFiles()541 void OBSMissingFiles::saveFiles()
542 {
543 for (int i = 0; i < filesModel->files.length(); i++) {
544 MissingFilesState state = filesModel->files[i].state;
545 if (state != MissingFilesState::Missing) {
546 obs_missing_file_t *f =
547 obs_missing_files_get_file(fileStore, i);
548
549 QString path = filesModel->files[i].newPath;
550
551 if (state == MissingFilesState::Cleared) {
552 obs_missing_file_issue_callback(f, "");
553 } else {
554 char *p = bstrdup(path.toStdString().c_str());
555 obs_missing_file_issue_callback(f, p);
556 bfree(p);
557 }
558 }
559 }
560
561 QDialog::accept();
562 }
563
browseFolders()564 void OBSMissingFiles::browseFolders()
565 {
566 QString dir = QFileDialog::getExistingDirectory(
567 this, QTStr("MissingFiles.SelectDir"), "",
568 QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
569
570 if (dir != "") {
571 dir += "/";
572 filesModel->fileCheckLoop(filesModel->files, dir, true);
573 }
574 }
575
dataChanged()576 void OBSMissingFiles::dataChanged()
577 {
578 QString found = QTStr("MissingFiles.NumFound");
579 found.replace("$1", QString::number(filesModel->found()));
580 found.replace("$2",
581 QString::number(obs_missing_files_count(fileStore)));
582
583 ui->found->setText(found);
584
585 ui->tableView->resizeColumnToContents(MissingFilesColumn::State);
586 ui->tableView->resizeColumnToContents(MissingFilesColumn::Source);
587 }
588
GetWarningIcon()589 QIcon OBSMissingFiles::GetWarningIcon()
590 {
591 return filesModel->warningIcon;
592 }
593
SetWarningIcon(const QIcon & icon)594 void OBSMissingFiles::SetWarningIcon(const QIcon &icon)
595 {
596 ui->warningIcon->setPixmap(icon.pixmap(QSize(32, 32)));
597 filesModel->warningIcon = icon;
598 }
599