Skip to content
Extraits de code Groupes Projets
Sélectionner une révision Git
  • 3ab21d4d8db264bb7707027ca279ef458cc0d52e
  • master par défaut
  • script
  • new-devel
  • devel
  • timingView-edit
  • fix-mpv
7 résultats

Utils.cc

Blame
  • Utils.cc 7,81 Kio
    #include "Utils.hh"
    
    using namespace Vivy;
    
    std::string &
    Utils::ltrim(std::string &s, const char *t)
    {
        s.erase(0, s.find_first_not_of(t));
        return s;
    }
    
    std::string &
    Utils::rtrim(std::string &s, const char *t)
    {
        s.erase(s.find_last_not_of(t) + 1);
        return s;
    }
    
    std::string &
    Utils::trim(std::string &s, const char *t)
    {
        return Utils::ltrim(Utils::rtrim(s, t), t);
    }
    
    QString
    Utils::OsSpecificAspects::withExecutableSuffix(OsType osType, const QString &executable)
    {
        QString finalName = executable;
        if (osType == OsTypeWindows)
            finalName += QLatin1String(VIVY_WIN_EXE_SUFFIX);
        return finalName;
    }
    
    Qt::CaseSensitivity
    Utils::OsSpecificAspects::fileNameCaseSensitivity(OsType osType)
    {
        return osType == OsTypeWindows || osType == OsTypeMac ? Qt::CaseInsensitive : Qt::CaseSensitive;
    }
    
    Qt::CaseSensitivity
    Utils::OsSpecificAspects::envVarCaseSensitivity(OsType osType)
    {
        return fileNameCaseSensitivity(osType);
    }
    
    QChar
    Utils::OsSpecificAspects::pathListSeparator(OsType osType)
    {
        return QLatin1Char(osType == OsTypeWindows ? ';' : ':');
    }
    
    Qt::KeyboardModifier
    Utils::OsSpecificAspects::controlModifier(OsType osType)
    {
        return osType == OsTypeMac ? Qt::MetaModifier : Qt::ControlModifier;
    }
    
    QString
    Utils::OsSpecificAspects::pathWithNativeSeparators(OsType osType, const QString &pathName)
    {
        if (osType == OsTypeWindows) {
            const int pos = pathName.indexOf('/');
            if (pos >= 0) {
                QString n = pathName;
                std::replace(std::begin(n) + pos, std::end(n), '/', '\\');
                return n;
            }
        }
        return pathName;
    }
    
    bool
    Utils::detectDocumentType(const QFileInfo &file, DocumentType *const type)
    {
        const QString suffix = file.suffix();
    
        if (Utils::audioFileSuffix.contains(suffix, Qt::CaseInsensitive)) {
            *type = DocumentType::Audio;
            return true;
        }
    
        else if (Utils::videoFileSuffix.contains(suffix, Qt::CaseInsensitive)) {
            *type = DocumentType::Video;
            return true;
        }
    
        else if (Utils::assFileSuffix.contains(suffix, Qt::CaseInsensitive)) {
            *type = DocumentType::ASS;
            return true;
        }
    
        else if (Utils::vivyFileSuffix.contains(suffix, Qt::CaseInsensitive)) {
            *type = DocumentType::Vivy;
            return true;
        }
    
        else if (Utils::scriptFileSuffix.contains(suffix, Qt::CaseInsensitive)) {
            *type = DocumentType::VivyScript;
            return true;
        }
    
        return false;
    }
    
    bool
    Utils::decodeLineToBoolean(const QString &item, const QString &error)
    {
        return Utils::decodeLineToInteger(item, error) >= 1;
    }
    
    int
    Utils::decodeLineToInteger(const QString &item, const QString &error)
    {
        bool conversion = false;
        int ret         = item.toInt(&conversion);
        if (!conversion)
            throw std::runtime_error(("invalid line content: " + error).toStdString());
        return ret;
    }
    
    float
    Utils::decodeLineToFloating(const QString &item, const QString &error)
    {
        bool conversion = false;
        float ret       = item.toFloat(&conversion);
        if (!conversion)
            throw std::runtime_error(("invalid line content: " + error).toStdString());
        return ret;
    }
    
    // The string must be of the form: `H:MM:SS.cs`
    Utils::Time
    Utils::Time::fromString(const QString &str)
    {
        QRegExp re("^(\\d+):(\\d\\d):(\\d\\d)\\.(\\d\\d)$");
    
        // Here the toUint is safe because the RegExp is OK
        if (re.indexIn(str) != -1)
            return { .hour        = re.cap(1).toUInt(),
                     .minute      = re.cap(2).toUInt(),
                     .second      = re.cap(3).toUInt(),
                     .centisecond = re.cap(4).toUInt() };
    
        else
            throw std::runtime_error("The string is not of the format `H:MM:SS.cs`");
    }
    
    quint64
    Utils::Time::toUInt() const noexcept
    {
        return ((hour * 3600) + (minute * 60) + second) * 100 + centisecond;
    }
    
    // Get a string from a time
    QString
    Utils::Time::toString() const noexcept
    {
        return QString::number(hour) + ":" + QString::number(minute) + ":" + QString::number(second) +
               "." + QString::number(centisecond);
    }
    
    QString
    Utils::getBaseName(const QString &file) noexcept
    {
        QFileInfo info(file);
        return info.baseName();
    }
    
    const QString &
    Utils::getAudioFileSuffixFilter() noexcept
    {
        static bool isInitialized = false;
        static QString ret        = QStringLiteral("Audio Sub Documents (*.");
    
        if (isInitialized)
            return ret;
    
        ret.append(audioFileSuffix.join(" *."));
        ret.append(')');
        isInitialized = true;
        return ret;
    }
    
    const QString &
    Utils::getVideoFileSuffixFilter() noexcept
    {
        static bool isInitialized = false;
        static QString ret        = QStringLiteral("Video Sub Documents (*.");
    
        if (isInitialized)
            return ret;
    
        ret.append(videoFileSuffix.join(" *."));
        ret.append(')');
        isInitialized = true;
        return ret;
    }
    
    const QString &
    Utils::getVivyDocumentFileSuffixFilter() noexcept
    {
        static bool isInitialized = false;
        static QString ret        = QStringLiteral("Vivy Documents (*.");
    
        if (isInitialized)
            return ret;
    
        ret.append(vivyFileSuffix.join(" *."));
        ret.append(')');
        isInitialized = true;
        return ret;
    }
    
    const QString &
    Utils::getScriptFileSuffixFilter() noexcept
    {
        static bool isInitialized = false;
        static QString ret        = QStringLiteral("Vivy Script Documents (*.");
    
        if (isInitialized)
            return ret;
    
        ret.append(scriptFileSuffix.join(" *."));
        ret.append(')');
        isInitialized = true;
        return ret;
    }
    
    const QString &
    Utils::getAssFileSuffixFilter() noexcept
    {
        static bool isInitialized = false;
        static QString ret        = QStringLiteral("ASS Sub Documents (*.");
    
        if (isInitialized)
            return ret;
    
        ret.append(assFileSuffix.join(" *."));
        ret.append(')');
        isInitialized = true;
        return ret;
    }
    
    const QString &
    Utils::getAnyDocumentFileSuffixFilter() noexcept
    {
        static bool isInitialized = false;
        static QString ret        = QStringLiteral("");
        static QString anyFilter  = QStringLiteral("Any Vivy File (*.");
    
        if (isInitialized)
            return ret;
    
        anyFilter.append(assFileSuffix.join(" *."));
        anyFilter.append(QStringLiteral(" *."));
        anyFilter.append(scriptFileSuffix.join(" *."));
        anyFilter.append(QStringLiteral(" *."));
        anyFilter.append(vivyFileSuffix.join(" *."));
        anyFilter.append(QStringLiteral(" *."));
        anyFilter.append(videoFileSuffix.join(" *."));
        anyFilter.append(QStringLiteral(" *."));
        anyFilter.append(audioFileSuffix.join(" *."));
        anyFilter.append(QStringLiteral(")"));
    
        const QString separator = QStringLiteral(";;");
        isInitialized           = true;
        ret = anyFilter + separator + getVivyDocumentFileSuffixFilter() + separator +
              getScriptFileSuffixFilter() + separator + getAudioFileSuffixFilter() + separator +
              getVideoFileSuffixFilter() + separator + getAssFileSuffixFilter();
        return ret;
    }
    
    const QString &
    Utils::getAnyTopLevelDocumentFileSuffixFilter() noexcept
    {
        static bool isInitialized = false;
        static QString ret        = QStringLiteral("");
        static QString anyFilter  = QStringLiteral("Any Top Level Vivy File (*.");
    
        if (isInitialized)
            return ret;
    
        anyFilter.append(scriptFileSuffix.join(" *."));
        anyFilter.append(QStringLiteral(" *."));
        anyFilter.append(vivyFileSuffix.join(" *."));
        anyFilter.append(QStringLiteral(")"));
    
        const QString separator = QStringLiteral(";;");
        isInitialized           = true;
        ret = anyFilter + separator + getVivyDocumentFileSuffixFilter() + separator +
              getScriptFileSuffixFilter();
        return ret;
    }
    
    void
    Utils::writeAssertLocation(const char *msg)
    {
        qFatal("ASSERT: %s", msg);
    }
    
    QDebug &
    operator<<(QDebug &stream, const std::string str) noexcept
    {
        stream << str.c_str();
        return stream;
    }
    
    QDebug &
    operator<<(QDebug &stream, const std::string_view strv) noexcept
    {
        stream << std::string(strv);
        return stream;
    }