Util.h

/*
 * Copyright (C) 2014 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef UTIL_H
#define UTIL_H

#include <QPointF>
#include <QQmlListProperty>
#include <QRectF>
#include <QTouchEvent>
#include <QVariantList>
#include <algorithm>
#include <cstdlib>
#include "VariantConverter.h"

class QSGTexture;
class QUrl;
class QWindow;

namespace Util {

template <typename T>
QVariantList toVariantList(const QList<T>& list) {
    QVariantList newList;
    newList.reserve(list.size());
    VariantConverter<T> converter;
    for (const T& item : list) {
        newList.append(converter.toVariant(item));
    }
    return newList;
}

template <typename T>
QList<T> toList(const QVariantList& list) {
    QList<T> convertedList;
    convertedList.reserve(list.size());
    VariantConverter<T> converter;
    for (const QVariant& v : list) {
        convertedList.append(converter.fromVariant(v));
    }
    return convertedList;
}

template <typename T>
QVariantMap toVariantMap(const QMap<QString, T> map) {
    QVariantMap convertedMap;
    VariantConverter<T> converter;
    for (auto it = map.cbegin(); it != map.cend(); ++it) {
        convertedMap.insert(it.key(), converter.toVariant(it.value()));
    }
    return convertedMap;
}

template <typename T>
QMap<QString, T> toMap(const QVariantMap& map) {
    QMap<QString, T> convertedMap;
    VariantConverter<T> converter;
    for (auto it = map.cbegin(); it != map.cend(); ++it) {
        convertedMap.insert(it.key(), converter.fromVariant(it.value()));
    }
    return convertedMap;
}

template <typename TObject, typename TData, typename TListType, TListType TObject::* TObjectField,
        void (TObject::* TChangeFunc)() = nullptr>
class QQmlListPropertyOnQList {
public:

    static QQmlListProperty<TData> createList(TObject* owner) {
        return QQmlListProperty<TData>(
                owner,
                nullptr,
                &QQmlListPropertyOnQList::appendFunc,
                &QQmlListPropertyOnQList::countFunc,
                &QQmlListPropertyOnQList::atFunc,
                &QQmlListPropertyOnQList::clearFunc);
    }

private:
    static void appendFunc(QQmlListProperty<TData>* property, TData* value) {
        TObject* owner = static_cast<TObject*>(property->object);
        TListType& list = (owner->*TObjectField);
        list.append(value);
        callChangeFunc(property);
    }

    static int countFunc(QQmlListProperty<TData>* property) {
        TObject* owner = static_cast<TObject*>(property->object);
        TListType& list = (owner->*TObjectField);
        return list.size();
    }

    static TData* atFunc(QQmlListProperty<TData>* property, int index) {
        TObject* owner = static_cast<TObject*>(property->object);
        TListType& list = (owner->*TObjectField);
        return list.at(index);
    }

    static void clearFunc(QQmlListProperty<TData>* property) {
        TObject* owner = static_cast<TObject*>(property->object);
        TListType& list = (owner->*TObjectField);
        list.clear();
        callChangeFunc(property);
    }

    static void callChangeFunc(QQmlListProperty<TData>* property) {
        TObject* owner = static_cast<TObject*>(property->object);
        if (TChangeFunc) {
            (owner->*TChangeFunc)();
        }
    }
};

template <typename T>
inline const T& clamp(const T& a, const T& min, const T& max) {
    return std::max<T>(min, std::min<T>(max, a));
}

static inline float smoothstep(float t) {
    float t2 = t * t;
    float t3 = t * t2;
    float t4 = t2 * t2;
    float t5 = t2 * t3;
    return 6 * t5 - 15 * t4 + 10 * t3;
}

static inline float qrandF() {
    return qrand() / ((float) RAND_MAX + 1);
}


template <typename TObject>
TObject* findParentOfType(QObject* node) {
    node = node->parent();
    while (node) {
        TObject* obj = qobject_cast<TObject*>(node);
        if (obj) {
            return obj;
        }
        node = node->parent();
    }
    return nullptr;
}

QString getPathToAsset(const QString& assetPath);

QUrl getUrlPathToAsset(const QString& assetPath);

QString getPathToFont(const QString& fontPath);

QString getPathToImage(const QString& imagePath);

QString getPathToMovie(const QString& moviePath);

QString getPathToLevel(const QString& levelPath);

QString getPathToSound(const QString& soundPath);

QString getPathToData(const QString& dataPath);

QString readFileAsQString(const QString& path);

std::string readFileAsStdString(const QString& path);

QRectF united(const QRectF& rect, const QPointF& point);

bool javaScriptFuncExists(QObject* object, const char* method);

bool deviceHasTouchScreen();

int getDeviceTouchScreenDeviceId();

} // namespace Util

#endif // UTIL_H