qt_utils.h

Go to the documentation of this file.

#pragma once
#include <QAbstractProxyModel>
#include <QComboBox>
#include <QDialogButtonBox>
#include <QFileDialog>
#include <QFormLayout>
#include <QMetaEnum>
#include <QPalette>
#include <QPoint>
#include <QRect>
#include <QSettings>
#include <QSize>
#include <QString>
#include <QTreeView>
#include <misc/global.h>
 
inline std::ostream& operator<<(std::ostream& os, const QString& qs)
{
  // return os << qs.toStdString();
  return os << qs.toUtf8().constData();
}
 
inline QPoint operator-(const QPoint& pt, const QSize& sz)
{
  return {pt.x() - sz.width(), pt.y() - sz.height()};
}
 
inline QPoint operator+(const QPoint& pt, const QSize& sz)
{
  return {pt.x() + sz.width(), pt.y() + sz.height()};
}
 
inline QRect operator+(const QRect& rc, const QSize& sz)
{
  return {rc.topLeft(), rc.size() + sz};
}
 
inline QRect operator-(const QRect& rc, const QSize& sz)
{
  return {rc.topLeft(), rc.size() - sz};
}
 
inline QRect operator+(const QRect& rc, const QPoint& pt)
{
  return {rc.topLeft() + pt, rc.size()};
}
 
inline QRect operator+=(QRect& rc, const QPoint& pt)
{
  rc = {rc.topLeft() + pt, rc.size()};
  return rc;
}
 
inline QRect operator-(const QRect& rc, const QPoint& pt)
{
  return {rc.topLeft() - pt, rc.size()};
}
 
inline QRect operator-=(QRect& rc, const QPoint& pt)
{
  rc = {rc.topLeft() - pt, rc.size()};
  return rc;
}
 
inline QRect& inflate(QRect& r, int sz)
{
  r.adjust(-sz, -sz, sz, sz);
  return r;
}
 
constexpr QRect inflated(const QRect& r, int sz)
{
  return r.adjusted(-sz, -sz, sz, sz);
}
 
inline QSize asQSize(const QPoint& pt)
{
  return {pt.x(), pt.y()};
}
 
inline QSizeF asQSizeF(const QPointF& pt)
{
  return {pt.x(), pt.y()};
}
 
namespace sf
{
 
_MISC_FUNC std::string toString(const QRect& rect);
 
_MISC_FUNC QRect moveRectWithinRect(const QRect& outer, const QRect& inner);
 
class _MISC_CLASS PaletteColors
{
  public:
    explicit PaletteColors() = default;
 
    explicit PaletteColors(const QPalette& palette);
 
    QPalette getPalette() const;
 
    void setColors(const QPalette& palette);
 
    bool isEmpty() const;
 
    void styleFileDialog(QFileDialog& fd) const;
 
  private:
    typedef QPair<QPalette::ColorRole, QColor> Pair;
    QList<Pair> _colors;
};
 
template<typename T, typename F>
QMetaEnum flagsMetaEnum()
{
  static_assert(std::is_base_of_v<QObject, T>, "Type T must be a QObject-derived class!");
  return T::staticMetaObject.enumerator(T::staticMetaObject.indexOfEnumerator(QMetaEnum::fromType<F>().name()));
}
 
template<typename QObjectType, typename FlagsType>
class FlagsIterator
{
  public:
    using EnumType = typename FlagsType::enum_type;
 
    class Iterator
    {
      public:
        Iterator(const QMetaEnum& metaEnum, const FlagsType& flags, int index)
          : metaEnum(metaEnum)
          , flags(flags)
          , index(index)
        {
          next();
        }
 
        EnumType operator*() const
        {
          return static_cast<EnumType>(metaEnum.value(index));
        }
 
        Iterator& operator++()
        {
          ++index;
          next();
          return *this;
        }
 
        bool operator!=(const Iterator& other) const
        {
          return index != other.index;
        }
 
      private:
        void next()
        {
          while (index < metaEnum.keyCount() && !flags.testFlag(static_cast<EnumType>(metaEnum.value(index))))
            ++index;
        }
 
        QMetaEnum metaEnum;
        FlagsType flags;
        int index;
    };
 
    explicit FlagsIterator(FlagsType flags)
      : flags(flags)
      , metaEnum(flagsMetaEnum<QObjectType, FlagsType>())
    {}
 
    Iterator begin() const
    {
      return Iterator(metaEnum, flags, 0);
    }
 
    Iterator end() const
    {
      return Iterator(metaEnum, flags, metaEnum.keyCount());
    }
 
  private:
    FlagsType flags;
    QMetaEnum metaEnum;
};
 
_MISC_FUNC QMetaObject::Connection connectByName(
  const QWidget* widget, const QString& sender_name, const char* signal_name, const QObject* receiver, const char* method_name,
  Qt::ConnectionType ct = Qt::AutoConnection
);
 
_MISC_FUNC QStringList getObjectNamePath(const QObject* object, bool use_rtti = false);
 
_MISC_FUNC QLayout* getWidgetLayout(const QWidget* widget);
 
template<typename T>
static const char* enumToKey(const T value)
{
  return QMetaEnum::fromType<T>().valueToKey(value);
}
 
template<typename T>
static T keyToEnum(const char* key, bool* ok = nullptr)
{
  return static_cast<T>(QMetaEnum::fromType<T>().keyToValue(key, ok));
}
 
template<typename T>
static const char* enumName()
{
  return QMetaEnum::fromType<T>().enumName();
}
 
template<typename T>
static T keyToEnum(QString key)
{
  return QMetaEnum::fromType<T>().keyToValue(key);
}
 
_MISC_FUNC int indexFromComboBox(const QComboBox* comboBox, const QVariant& value, int default_index = -1);
 
_MISC_FUNC QPair<QLayout*, int> getTopLayoutAndIndex(const QObject* object);
 
_MISC_FUNC QPair<int, QFormLayout::ItemRole> getLayoutPosition(const QFormLayout* layout, QObject* target);
 
_MISC_FUNC int getLayoutIndex(const QBoxLayout* layout, QObject* target);
 
inline void resizeColumnsToContents(QTreeView* treeView)
{
  const auto count = treeView->model()->columnCount({}) - 1;
  for (int i = 0; i < count; i++)
  {
    treeView->resizeColumnToContents(i);
  }
}
 
_MISC_FUNC void dumpObjectProperties(const QObject* obj);
 
template<typename T>
T* getSourceModel(const QAbstractItemModel* am)
{
  // First check if the passed abstract model is the model we look for.
  if (auto m = dynamic_cast<const T*>(am))
  {
    return const_cast<T*>(m);
  }
  // Secondly, when a proxy is used.
  if (const auto apm = dynamic_cast<const QAbstractProxyModel*>(am))
  {
    if (auto m = dynamic_cast<T*>(apm->sourceModel()))
    {
      return const_cast<T*>(m);
    }
  }
  return nullptr;
}
 
_MISC_FUNC QModelIndex getSourceModelIndex(const QModelIndex& index);
 
_MISC_FUNC void expandTreeView(QTreeView* tv, bool expand = true, const QModelIndex& index = {});
 
_MISC_FUNC bool isGuiApplication();
 
_MISC_FUNC QString trimRight(const QString& str, const QString& chars = " ");
 
_MISC_FUNC QString trimLeft(const QString& str, const QString& chars = " ");
 
_MISC_FUNC QString trim(const QString& str, const QString& chars = " ");
 
_MISC_FUNC bool isValidFilePath(const QString& path);
 
_MISC_FUNC bool isValidDirectoryPath(const QString& path);
 
_MISC_FUNC void storeWindowState(QSettings& settings, QAnyStringView name, QWidget* widget, bool read);
 
_MISC_FUNC void storeTreeViewState(QSettings& settings, QAnyStringView name, const QTreeView* tv, bool read);
 
}// namespace sf
 
inline std::ostream& operator<<(std::ostream& os, const QRect& rect)
{
  return os << sf::toString(rect);
}