654 lines
19 KiB
C++
654 lines
19 KiB
C++
/***
|
|
|
|
Olive - Non-Linear Video Editor
|
|
Copyright (C) 2019 Olive Team
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
#include "projectmodel.h"
|
|
|
|
#include "panels/panels.h"
|
|
#include "panels/viewer.h"
|
|
#include "ui/viewerwidget.h"
|
|
#include "project/media.h"
|
|
#include "global/debug.h"
|
|
|
|
ProjectModel olive::project_model;
|
|
|
|
ProjectModel::ProjectModel(QObject *parent) : QAbstractItemModel(parent), root_item_(nullptr) {
|
|
make_root();
|
|
}
|
|
|
|
ProjectModel::~ProjectModel() {
|
|
destroy_root();
|
|
}
|
|
|
|
int ProjectModel::PrepareToSave()
|
|
{
|
|
int element_count = 0;
|
|
|
|
PrepareToSaveInternal(element_count, get_root());
|
|
|
|
return element_count;
|
|
}
|
|
|
|
void ProjectModel::PrepareToSaveInternal(int& element_count, Media *root)
|
|
{
|
|
for (int i=0;i<root->childCount();i++) {
|
|
Media* child = root->child(i);
|
|
|
|
switch (child->get_type()) {
|
|
case MEDIA_TYPE_FOLDER:
|
|
child->temp_id = element_count;
|
|
break;
|
|
case MEDIA_TYPE_FOOTAGE:
|
|
child->to_footage()->save_id = element_count;
|
|
break;
|
|
case MEDIA_TYPE_SEQUENCE:
|
|
child->to_sequence()->save_id = element_count;
|
|
break;
|
|
}
|
|
|
|
element_count++;
|
|
|
|
if (child->childCount() > 0) {
|
|
PrepareToSaveInternal(element_count, child);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProjectModel::Save(QXmlStreamWriter &stream, Media* root)
|
|
{
|
|
if (root == nullptr) {
|
|
root = get_root();
|
|
}
|
|
|
|
for (int i=0;i<root->childCount();i++) {
|
|
Media* child = root->child(i);
|
|
|
|
child->Save(stream);
|
|
|
|
if (child->childCount() > 0) {
|
|
Save(stream, child);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProjectModel::make_root() {
|
|
root_item_ = std::make_shared<Media>();
|
|
root_item_->temp_id = 0;
|
|
root_item_->root = true;
|
|
}
|
|
|
|
void ProjectModel::destroy_root() {
|
|
if (panel_sequence_viewer != nullptr) {
|
|
panel_sequence_viewer->set_media(nullptr);
|
|
}
|
|
if (panel_footage_viewer != nullptr) {
|
|
panel_footage_viewer->set_media(nullptr);
|
|
}
|
|
|
|
root_item_ = nullptr;
|
|
}
|
|
|
|
void ProjectModel::clear() {
|
|
beginResetModel();
|
|
destroy_root();
|
|
make_root();
|
|
endResetModel();
|
|
}
|
|
|
|
Media *ProjectModel::get_root() const {
|
|
return root_item_.get();
|
|
}
|
|
|
|
QVariant ProjectModel::data(const QModelIndex &index, int role) const {
|
|
if (!index.isValid())
|
|
return QVariant();
|
|
|
|
Media* media = static_cast<Media*>(index.internalPointer());
|
|
|
|
return media->data(index.column(), role);
|
|
}
|
|
|
|
Qt::ItemFlags ProjectModel::flags(const QModelIndex &index) const {
|
|
if (!index.isValid())
|
|
return Qt::ItemIsDropEnabled;
|
|
|
|
return QAbstractItemModel::flags(index) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsEditable;
|
|
}
|
|
|
|
QVariant ProjectModel::headerData(int section, Qt::Orientation orientation, int role) const {
|
|
if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
|
|
return root_item_->data(section, role);
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
QModelIndex ProjectModel::index(int row, int column, const QModelIndex &parent) const {
|
|
if (!hasIndex(row, column, parent))
|
|
return QModelIndex();
|
|
|
|
Media *parentItem;
|
|
|
|
if (!parent.isValid()) {
|
|
parentItem = get_root();
|
|
} else {
|
|
parentItem = static_cast<Media*>(parent.internalPointer());
|
|
}
|
|
|
|
Media *childItem = parentItem->child(row);
|
|
if (childItem) {
|
|
return createIndex(row, column, childItem);
|
|
} else {
|
|
return QModelIndex();
|
|
}
|
|
}
|
|
|
|
QModelIndex ProjectModel::create_index(int arow, int acolumn, void* adata) {
|
|
return createIndex(arow, acolumn, adata);
|
|
}
|
|
|
|
QModelIndex ProjectModel::parent(const QModelIndex &index) const {
|
|
if (!index.isValid())
|
|
return QModelIndex();
|
|
|
|
Media *childItem = static_cast<Media*>(index.internalPointer());
|
|
Media *parentItem = childItem->parentItem();
|
|
|
|
if (parentItem == get_root())
|
|
return QModelIndex();
|
|
|
|
return createIndex(parentItem->row(), 0, parentItem);
|
|
}
|
|
|
|
bool ProjectModel::canFetchMore(const QModelIndex &parent) const
|
|
{
|
|
|
|
// Mostly implementing this because QSortFilterProxyModel will actually *ignore* a "true" result from hasChildren()
|
|
// and then query this value for a "true" result. So we need to override both this and hasChildren() to show a
|
|
// persistent childIndicator for folder items.
|
|
|
|
if (parent.isValid()
|
|
&& static_cast<Media*>(parent.internalPointer())->get_type() == MEDIA_TYPE_FOLDER) {
|
|
return true;
|
|
}
|
|
return QAbstractItemModel::canFetchMore(parent);
|
|
}
|
|
|
|
bool ProjectModel::hasChildren(const QModelIndex &parent) const
|
|
{
|
|
if (parent.isValid()
|
|
&& static_cast<Media*>(parent.internalPointer())->get_type() == MEDIA_TYPE_FOLDER) {
|
|
return true;
|
|
}
|
|
return QAbstractItemModel::hasChildren(parent);
|
|
}
|
|
|
|
bool ProjectModel::setData(const QModelIndex &index, const QVariant &value, int role) {
|
|
if (role != Qt::EditRole)
|
|
return false;
|
|
|
|
Media *item = static_cast<Media*>(index.internalPointer());
|
|
bool result = item->setData(index.column(), value);
|
|
|
|
if (result)
|
|
emit dataChanged(index, index);
|
|
|
|
return result;
|
|
}
|
|
|
|
int ProjectModel::rowCount(const QModelIndex &parent) const {
|
|
Media *parentItem;
|
|
if (parent.column() > 0)
|
|
return 0;
|
|
|
|
if (!parent.isValid()) {
|
|
parentItem = get_root();
|
|
} else {
|
|
parentItem = static_cast<Media*>(parent.internalPointer());
|
|
}
|
|
|
|
return parentItem->childCount();
|
|
}
|
|
|
|
int ProjectModel::columnCount(const QModelIndex &parent) const {
|
|
if (parent.isValid())
|
|
return static_cast<Media*>(parent.internalPointer())->columnCount();
|
|
else
|
|
return root_item_->columnCount();
|
|
}
|
|
|
|
Media *ProjectModel::getItem(const QModelIndex &index) const {
|
|
if (index.isValid()) {
|
|
Media *item = static_cast<Media*>(index.internalPointer());
|
|
if (item)
|
|
return item;
|
|
}
|
|
return get_root();
|
|
}
|
|
|
|
void ProjectModel::set_icon(Media* m, const QIcon &ico) {
|
|
QModelIndex index = createIndex(m->row(), 0, m);
|
|
m->set_icon(ico);
|
|
emit dataChanged(index, index);
|
|
}
|
|
|
|
QVector<Media *> ProjectModel::GetAllSequences()
|
|
{
|
|
return GetAllMediaOfType(MEDIA_TYPE_SEQUENCE);
|
|
}
|
|
|
|
QVector<Media *> ProjectModel::GetAllFootage()
|
|
{
|
|
return GetAllMediaOfType(MEDIA_TYPE_FOOTAGE);
|
|
}
|
|
|
|
QVector<Media *> ProjectModel::GetAllFolders()
|
|
{
|
|
return GetAllMediaOfType(MEDIA_TYPE_FOLDER);
|
|
}
|
|
|
|
QString ProjectModel::GetNextSequenceName(QString prepend)
|
|
{
|
|
if (prepend.isEmpty()) {
|
|
prepend = tr("Sequence %1");
|
|
}
|
|
|
|
int sequence_number = 1;
|
|
QString test;
|
|
QVector<Media*> all_sequences = GetAllSequences();
|
|
bool found;
|
|
|
|
do {
|
|
found = false;
|
|
test = prepend.arg(sequence_number);
|
|
for (int i=0;i<all_sequences.size();i++) {
|
|
if (all_sequences.at(i)->get_name() == test) {
|
|
found = true;
|
|
sequence_number++;
|
|
break;
|
|
}
|
|
}
|
|
} while (found);
|
|
|
|
return test;
|
|
}
|
|
|
|
MediaPtr ProjectModel::CreateSequence(ComboAction *ca, SequencePtr s, bool open, Media *parent)
|
|
{
|
|
MediaPtr item = std::make_shared<Media>();
|
|
item->set_sequence(s);
|
|
|
|
if (ca != nullptr) {
|
|
|
|
ca->append(new AddMediaCommand(item, parent));
|
|
|
|
if (open) {
|
|
ca->append(new ChangeSequenceAction(s));
|
|
}
|
|
|
|
} else {
|
|
|
|
appendChild(parent, item);
|
|
|
|
if (open) {
|
|
olive::Global->set_sequence(s);
|
|
}
|
|
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
QVector<Media *> ProjectModel::GetAllMediaOfType(int search_type)
|
|
{
|
|
QVector<Media*> media_list;
|
|
RecurseTree(root_item_.get(), media_list, search_type);
|
|
return media_list;
|
|
}
|
|
|
|
void ProjectModel::RecurseTree(Media* parent, QVector<Media*>& list, int search_type)
|
|
{
|
|
for (int i=0;i<parent->childCount();i++) {
|
|
|
|
Media* child = parent->child(i);
|
|
|
|
if (child->get_type() == search_type) {
|
|
list.append(child);
|
|
}
|
|
|
|
if (child->childCount() > 0) {
|
|
RecurseTree(child, list, search_type);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProjectModel::appendChild(Media* parent, MediaPtr child) {
|
|
QModelIndex row_start;
|
|
|
|
if (parent == nullptr) {
|
|
|
|
parent = get_root();
|
|
row_start = QModelIndex();
|
|
|
|
} else {
|
|
|
|
row_start = createIndex(parent->row(), 0, parent);
|
|
|
|
}
|
|
|
|
beginInsertRows(row_start, parent->childCount(), parent->childCount());
|
|
parent->appendChild(child);
|
|
endInsertRows();
|
|
}
|
|
|
|
void ProjectModel::moveChild(MediaPtr child, Media *to) {
|
|
if (to == nullptr) {
|
|
to = get_root();
|
|
}
|
|
|
|
Media* from = child->parentItem();
|
|
|
|
beginMoveRows(
|
|
from == get_root() ? QModelIndex() : createIndex(from->row(), 0, from),
|
|
child->row(),
|
|
child->row(),
|
|
to == get_root() ? QModelIndex() : createIndex(to->row(), 0, to),
|
|
to->childCount()
|
|
);
|
|
|
|
from->removeChild(child->row());
|
|
to->appendChild(child);
|
|
endMoveRows();
|
|
}
|
|
|
|
void ProjectModel::removeChild(Media* parent, Media* m) {
|
|
if (parent == nullptr) {
|
|
parent = get_root();
|
|
}
|
|
beginRemoveRows(parent == get_root() ?
|
|
QModelIndex() : createIndex(parent->row(), 0, parent), m->row(), m->row());
|
|
parent->removeChild(m->row());
|
|
endRemoveRows();
|
|
}
|
|
|
|
Media* ProjectModel::child(int i, Media* parent) {
|
|
if (parent == nullptr) {
|
|
parent = get_root();
|
|
}
|
|
return parent->child(i);
|
|
}
|
|
|
|
int ProjectModel::childCount(Media *parent) {
|
|
if (parent == nullptr) {
|
|
parent = get_root();
|
|
}
|
|
return parent->childCount();
|
|
}
|
|
|
|
void ProjectModel::process_file_list(QStringList& files, bool recursive, MediaPtr replace, Media* parent) {
|
|
bool imported = false;
|
|
|
|
// retrieve the array of image formats from the user's configuration
|
|
QStringList image_sequence_formats = olive::CurrentConfig.img_seq_formats.split("|");
|
|
|
|
// a cache of image sequence formatted URLS to assist the user in importing image sequences
|
|
QVector<QString> image_sequence_urls;
|
|
QVector<bool> image_sequence_importassequence;
|
|
|
|
if (!recursive) last_imported_media.clear();
|
|
|
|
bool create_undo_action = (!recursive && replace == nullptr);
|
|
ComboAction* ca = nullptr;
|
|
if (create_undo_action) ca = new ComboAction();
|
|
|
|
// Loop through received files
|
|
for (int i=0;i<files.size();i++) {
|
|
|
|
// If this file is a directory, we'll recursively call this function again to process the directory's contents
|
|
if (QFileInfo(files.at(i)).isDir()) {
|
|
|
|
QString folder_name = get_file_name_from_path(files.at(i));
|
|
MediaPtr folder = CreateFolder(folder_name);
|
|
|
|
QDir directory(files.at(i));
|
|
directory.setFilter(QDir::NoDotAndDotDot | QDir::AllEntries);
|
|
|
|
QFileInfoList subdir_files = directory.entryInfoList();
|
|
QStringList subdir_filenames;
|
|
|
|
for (int j=0;j<subdir_files.size();j++) {
|
|
subdir_filenames.append(subdir_files.at(j).filePath());
|
|
}
|
|
|
|
if (create_undo_action) {
|
|
ca->append(new AddMediaCommand(folder, parent));
|
|
} else {
|
|
appendChild(parent, folder);
|
|
}
|
|
|
|
process_file_list(subdir_filenames, true, nullptr, folder.get());
|
|
|
|
imported = true;
|
|
|
|
} else if (!files.at(i).isEmpty()) {
|
|
QString file = files.at(i);
|
|
|
|
// Check if the user is importing an Olive project file
|
|
if (file.endsWith(".ove", Qt::CaseInsensitive)) {
|
|
|
|
// This file is an Olive project file. Ask the user if they really want to import it.
|
|
if (QMessageBox::question(this,
|
|
tr("Import a Project"),
|
|
tr("\"%1\" is an Olive project file. It will merge with this project. "
|
|
"Do you wish to continue?").arg(file),
|
|
QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
|
|
|
|
// load the project without clearing the current one
|
|
olive::Global->ImportProject(file);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// This file is NOT an Olive project file
|
|
|
|
// Used later if this file is part of an already processed image sequence
|
|
bool skip = false;
|
|
|
|
/* Heuristic to determine whether file is part of an image sequence */
|
|
|
|
// Firstly, we run a heuristic on whether this file is an image by checking its file extension
|
|
|
|
bool file_is_an_image = false;
|
|
|
|
// Get the string position of the extension in the filename
|
|
int lastcharindex = file.lastIndexOf(".");
|
|
|
|
if (lastcharindex != -1 && lastcharindex > file.lastIndexOf('/')) {
|
|
|
|
QString ext = file.mid(lastcharindex+1);
|
|
|
|
// If the file extension is part of a predetermined list (from Config::img_seq_formats), we'll treat it
|
|
// as an image
|
|
if (image_sequence_formats.contains(ext, Qt::CaseInsensitive)) {
|
|
file_is_an_image = true;
|
|
}
|
|
|
|
} else {
|
|
|
|
// If we're here, the file has no extension, but we'll still check if its an image sequence just in case
|
|
lastcharindex = file.length();
|
|
file_is_an_image = true;
|
|
|
|
}
|
|
|
|
// Some image sequence's don't start at "0", if it is indeed an image sequence, we'll use this variable
|
|
// later to determine where it does start
|
|
int start_number = 0;
|
|
|
|
// Check if we passed the earlier heuristic to check whether this is a file, and whether the last number in
|
|
// the filename (before the extension) is a number
|
|
if (file_is_an_image && file[lastcharindex-1].isDigit()) {
|
|
|
|
// Check how many digits are at the end of this filename
|
|
int digit_count = 0;
|
|
int digit_test = lastcharindex-1;
|
|
while (file[digit_test].isDigit()) {
|
|
digit_count++;
|
|
digit_test--;
|
|
}
|
|
|
|
// Retrieve the integer represented at the end of this filename
|
|
digit_test++;
|
|
int file_number = file.mid(digit_test, digit_count).toInt();
|
|
|
|
// Check whether a file exists with the same format but one number higher or one number lower
|
|
if (QFileInfo::exists(QString(file.left(digit_test) + QString("%1").arg(file_number-1, digit_count, 10, QChar('0')) + file.mid(lastcharindex)))
|
|
|| QFileInfo::exists(QString(file.left(digit_test) + QString("%1").arg(file_number+1, digit_count, 10, QChar('0')) + file.mid(lastcharindex)))) {
|
|
|
|
//
|
|
// If so, it certainly looks like it *could* be an image sequence, but we'll ask the user just in case
|
|
//
|
|
|
|
// Firstly we should check if this file is part of a sequence the user has already confirmed as either a
|
|
// sequence or not a sequence (e.g. if the user happened to select a bunch of images that happen to increase
|
|
// consecutively). We format the filename with FFmpeg's '%Nd' (N = digits) formatting for reading image
|
|
// sequences
|
|
QString new_filename = file.left(digit_test) + "%" + QString::number(digit_count) + "d" + file.mid(lastcharindex);
|
|
|
|
int does_url_cache_already_contain_this = image_sequence_urls.indexOf(new_filename);
|
|
|
|
if (does_url_cache_already_contain_this > -1) {
|
|
|
|
// We've already processed an image with the same formatting
|
|
|
|
// Check if the last time we saw this formatting, the user chose to import as a sequence
|
|
if (image_sequence_importassequence.at(does_url_cache_already_contain_this)) {
|
|
|
|
// If so, no need to import this file too, so we signal to the rest of the function to skip this file
|
|
skip = true;
|
|
|
|
}
|
|
|
|
// If not, we can fall-through to the next step which is importing normally
|
|
|
|
} else {
|
|
|
|
// If we're here, we've never seen a file with this formatting before, so we'll ask whether to import
|
|
// as a sequence or not
|
|
|
|
// Add this file formatting file to the URL cache
|
|
image_sequence_urls.append(new_filename);
|
|
|
|
// This does look like an image sequence, let's ask the user if it'll indeed be an image sequence
|
|
if (QMessageBox::question(this,
|
|
tr("Image sequence detected"),
|
|
tr("The file '%1' appears to be part of an image sequence. "
|
|
"Would you like to import it as such?").arg(file),
|
|
QMessageBox::Yes | QMessageBox::No,
|
|
QMessageBox::Yes) == QMessageBox::Yes) {
|
|
|
|
// Proceed to the next step of this with the formatted filename
|
|
file = new_filename;
|
|
|
|
// Cache the user's answer alongside the image_sequence_urls value - in this case, YES, this will be an
|
|
// image sequence
|
|
image_sequence_importassequence.append(true);
|
|
|
|
|
|
// FFmpeg needs to know what file number to start at in the sequence. In case the image sequence doesn't
|
|
// start at a zero, we'll loop decreasing the number until it doesn't exist anymore
|
|
QString test_filename_format = QString("%1%2%3").arg(file.left(digit_test), "%1", file.mid(lastcharindex));
|
|
int test_file_number = file_number;
|
|
do {
|
|
test_file_number--;
|
|
} while (QFileInfo::exists(test_filename_format.arg(QString("%1").arg(test_file_number, digit_count, 10, QChar('0')))));
|
|
|
|
// set the image sequence's start number to the last that existed
|
|
start_number = test_file_number + 1;
|
|
|
|
} else {
|
|
|
|
// Cache the user's response to the image sequence question - i.e. none of the files imported with this
|
|
// formatting should be imported as an image sequence
|
|
image_sequence_importassequence.append(false);
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If we're not skipping this file, let's import it
|
|
if (!skip) {
|
|
MediaPtr item;
|
|
FootagePtr m;
|
|
|
|
if (replace != nullptr) {
|
|
item = replace;
|
|
} else {
|
|
item = std::make_shared<Media>();
|
|
}
|
|
|
|
m = std::make_shared<Footage>();
|
|
|
|
// Edge case for PNGs that standardized unassociated alpha
|
|
if (file.endsWith("png", Qt::CaseInsensitive)) {
|
|
m->alpha_is_associated = false;
|
|
}
|
|
|
|
m->using_inout = false;
|
|
m->url = file;
|
|
m->name = QFileInfo(files.at(i)).fileName();
|
|
m->start_number = start_number;
|
|
|
|
item->set_footage(m);
|
|
|
|
last_imported_media.append(item.get());
|
|
|
|
if (replace == nullptr) {
|
|
if (create_undo_action) {
|
|
ca->append(new AddMediaCommand(item, parent));
|
|
} else {
|
|
appendChild(parent, item);
|
|
}
|
|
}
|
|
|
|
imported = true;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
if (create_undo_action) {
|
|
if (imported) {
|
|
olive::UndoStack.push(ca);
|
|
|
|
for (int i=0;i<last_imported_media.size();i++) {
|
|
// generate waveform/thumbnail in another thread
|
|
PreviewGenerator::AnalyzeMedia(last_imported_media.at(i));
|
|
}
|
|
} else {
|
|
delete ca;
|
|
}
|
|
}
|
|
}
|