Add 'meshmc/' from commit 'fad6a1066616b69d7f5fef01178efdf014c59537'

git-subtree-dir: meshmc
git-subtree-mainline: 934382c8a1ce738589dee9ee0f14e1cec812770e
git-subtree-split: fad6a1066616b69d7f5fef01178efdf014c59537

3 files changed, 954 insertions, 0 deletions

diff --git a/meshmc/libraries/iconfix/internal/qhexstring_p.h b/meshmc/libraries/iconfix/internal/qhexstring_p.h
new file mode 100644
index 0000000000..3da8468ceb
--- /dev/null
+++ b/meshmc/libraries/iconfix/internal/qhexstring_p.h
@@ -0,0 +1,92 @@
+/****************************************************************************
+** SPDX-License-Identifier: LGPL-2.1-or-later
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qpoint.h>
+#include <QtCore/qstring.h>
+#include <QtGui/qpolygon.h>
+#include <QtCore/qstringbuilder.h>
+
+#pragma once
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+// internal helper. Converts an integer value to an unique string token
+template <typename T> struct HexString {
+	inline HexString(const T t) : val(t) {}
+
+	inline void write(QChar*& dest) const
+	{
+		const ushort hexChars[] = {'0', '1', '2', '3', '4', '5', '6', '7',
+								   '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+		const char* c = reinterpret_cast<const char*>(&val);
+		for (uint i = 0; i < sizeof(T); ++i) {
+			*dest++ = hexChars[*c & 0xf];
+			*dest++ = hexChars[(*c & 0xf0) >> 4];
+			++c;
+		}
+	}
+	const T val;
+};
+
+// specialization to enable fast concatenating of our string tokens to a string
+template <typename T> struct QConcatenable<HexString<T>> {
+	typedef HexString<T> type;
+	enum { ExactSize = true };
+	static int size(const HexString<T>&)
+	{
+		return sizeof(T) * 2;
+	}
+	static inline void appendTo(const HexString<T>& str, QChar*& out)
+	{
+		str.write(out);
+	}
+	typedef QString ConvertTo;
+};
diff --git a/meshmc/libraries/iconfix/internal/qiconloader.cpp b/meshmc/libraries/iconfix/internal/qiconloader.cpp
new file mode 100644
index 0000000000..38ca549ade
--- /dev/null
+++ b/meshmc/libraries/iconfix/internal/qiconloader.cpp
@@ -0,0 +1,646 @@
+/****************************************************************************
+** SPDX-License-Identifier: LGPL-2.1-or-later
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights. These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qiconloader_p.h"
+
+#include <QtGui/QIconEnginePlugin>
+#include <QtGui/QPixmapCache>
+#include <QtGui/QIconEngine>
+#include <QtGui/QPalette>
+#include <QtCore/QList>
+#include <QtCore/QHash>
+#include <QtCore/QDir>
+#include <QtCore/QSettings>
+#include <QtGui/QPainter>
+#include <QApplication>
+#include <QString>
+
+#include "qhexstring_p.h"
+
+namespace QtXdg
+{
+
+	Q_GLOBAL_STATIC(QIconLoader, iconLoaderInstance)
+
+	/* Theme to use in last resort, if the theme does not have the icon, neither
+	 * the parents  */
+
+	static QString fallbackTheme()
+	{
+		return QString("hicolor");
+	}
+
+	QIconLoader::QIconLoader()
+		: m_themeKey(1), m_supportsSvg(false), m_initialized(false)
+	{
+	}
+
+	// We lazily initialize the loader to make static icons
+	// work. Though we do not officially support this.
+
+	static inline QString systemThemeName()
+	{
+		return QIcon::themeName();
+	}
+
+	static inline QStringList systemIconSearchPaths()
+	{
+		auto paths = QIcon::themeSearchPaths();
+		paths.push_front(":/icons");
+		return paths;
+	}
+
+	void QIconLoader::ensureInitialized()
+	{
+		if (!m_initialized) {
+			m_initialized = true;
+
+			Q_ASSERT(qApp);
+
+			m_systemTheme = QIcon::themeName();
+
+			if (m_systemTheme.isEmpty())
+				m_systemTheme = fallbackTheme();
+			m_supportsSvg = true;
+		}
+	}
+
+	QIconLoader* QIconLoader::instance()
+	{
+		iconLoaderInstance()->ensureInitialized();
+		return iconLoaderInstance();
+	}
+
+	// Queries the system theme and invalidates existing
+	// icons if the theme has changed.
+	void QIconLoader::updateSystemTheme()
+	{
+		// Only change if this is not explicitly set by the user
+		if (m_userTheme.isEmpty()) {
+			QString theme = systemThemeName();
+			if (theme.isEmpty())
+				theme = fallbackTheme();
+			if (theme != m_systemTheme) {
+				m_systemTheme = theme;
+				invalidateKey();
+			}
+		}
+	}
+
+	void QIconLoader::setThemeName(const QString& themeName)
+	{
+		m_userTheme = themeName;
+		invalidateKey();
+	}
+
+	void QIconLoader::setThemeSearchPath(const QStringList& searchPaths)
+	{
+		m_iconDirs = searchPaths;
+		themeList.clear();
+		invalidateKey();
+	}
+
+	QStringList QIconLoader::themeSearchPaths() const
+	{
+		if (m_iconDirs.isEmpty()) {
+			m_iconDirs = systemIconSearchPaths();
+		}
+		return m_iconDirs;
+	}
+
+	QIconTheme::QIconTheme(const QString& themeName) : m_valid(false)
+	{
+		QFile themeIndex;
+
+		QStringList iconDirs = systemIconSearchPaths();
+		for (int i = 0; i < iconDirs.size(); ++i) {
+			QDir iconDir(iconDirs[i]);
+			QString themeDir = iconDir.path() + QLatin1Char('/') + themeName;
+			themeIndex.setFileName(themeDir + QLatin1String("/index.theme"));
+			if (themeIndex.exists()) {
+				m_contentDir = themeDir;
+				m_valid = true;
+
+				foreach (QString path, iconDirs) {
+					if (QFileInfo(path).isDir())
+						m_contentDirs.append(path + QLatin1Char('/') +
+											 themeName);
+				}
+
+				break;
+			}
+		}
+
+		// if there is no index file, abscond.
+		if (!themeIndex.exists())
+			return;
+
+		// otherwise continue reading index file
+		const QSettings indexReader(themeIndex.fileName(),
+									QSettings::IniFormat);
+		QStringListIterator keyIterator(indexReader.allKeys());
+		while (keyIterator.hasNext()) {
+			const QString key = keyIterator.next();
+			if (!key.endsWith(QLatin1String("/Size")))
+				continue;
+
+			// Note the QSettings ini-format does not accept
+			// slashes in key names, hence we have to cheat
+			int size = indexReader.value(key).toInt();
+			if (!size)
+				continue;
+
+			QString directoryKey = key.left(key.size() - 5);
+			QIconDirInfo dirInfo(directoryKey);
+			dirInfo.size = size;
+			QString type =
+				indexReader.value(directoryKey + QLatin1String("/Type"))
+					.toString();
+
+			if (type == QLatin1String("Fixed"))
+				dirInfo.type = QIconDirInfo::Fixed;
+			else if (type == QLatin1String("Scalable"))
+				dirInfo.type = QIconDirInfo::Scalable;
+			else
+				dirInfo.type = QIconDirInfo::Threshold;
+
+			dirInfo.threshold =
+				indexReader.value(directoryKey + QLatin1String("/Threshold"), 2)
+					.toInt();
+
+			dirInfo.minSize =
+				indexReader
+					.value(directoryKey + QLatin1String("/MinSize"), size)
+					.toInt();
+
+			dirInfo.maxSize =
+				indexReader
+					.value(directoryKey + QLatin1String("/MaxSize"), size)
+					.toInt();
+			m_keyList.append(dirInfo);
+		}
+
+		// Parent themes provide fallbacks for missing icons
+		m_parents = indexReader.value(QLatin1String("Icon Theme/Inherits"))
+						.toStringList();
+		m_parents.removeAll(QString());
+
+		// Ensure a default platform fallback for all themes
+		if (m_parents.isEmpty()) {
+			const QString fallback = fallbackTheme();
+			if (!fallback.isEmpty())
+				m_parents.append(fallback);
+		}
+
+		// Ensure that all themes fall back to hicolor
+		if (!m_parents.contains(QLatin1String("hicolor")))
+			m_parents.append(QLatin1String("hicolor"));
+	}
+
+	QThemeIconEntries QIconLoader::findIconHelper(const QString& themeName,
+												  const QString& iconName,
+												  QStringList& visited) const
+	{
+		QThemeIconEntries entries;
+		Q_ASSERT(!themeName.isEmpty());
+
+		QPixmap pixmap;
+
+		// Used to protect against potential recursions
+		visited << themeName;
+
+		QIconTheme theme = themeList.value(themeName);
+		if (!theme.isValid()) {
+			theme = QIconTheme(themeName);
+			if (!theme.isValid())
+				theme = QIconTheme(fallbackTheme());
+
+			themeList.insert(themeName, theme);
+		}
+
+		QStringList contentDirs = theme.contentDirs();
+		const QVector<QIconDirInfo> subDirs = theme.keyList();
+
+		const QString svgext(QLatin1String(".svg"));
+		const QString pngext(QLatin1String(".png"));
+		const QString xpmext(QLatin1String(".xpm"));
+
+		// Add all relevant files
+		for (int i = 0; i < subDirs.size(); ++i) {
+			const QIconDirInfo& dirInfo = subDirs.at(i);
+			QString subdir = dirInfo.path;
+
+			foreach (QString contentDir, contentDirs) {
+				QDir currentDir(contentDir + '/' + subdir);
+
+				if (currentDir.exists(iconName + pngext)) {
+					PixmapEntry* iconEntry = new PixmapEntry;
+					iconEntry->dir = dirInfo;
+					iconEntry->filename =
+						currentDir.filePath(iconName + pngext);
+					// Notice we ensure that pixmap entries always come before
+					// scalable to preserve search order afterwards
+					entries.prepend(iconEntry);
+				} else if (m_supportsSvg &&
+						   currentDir.exists(iconName + svgext)) {
+					ScalableEntry* iconEntry = new ScalableEntry;
+					iconEntry->dir = dirInfo;
+					iconEntry->filename =
+						currentDir.filePath(iconName + svgext);
+					entries.append(iconEntry);
+					break;
+				} else if (currentDir.exists(iconName + xpmext)) {
+					PixmapEntry* iconEntry = new PixmapEntry;
+					iconEntry->dir = dirInfo;
+					iconEntry->filename =
+						currentDir.filePath(iconName + xpmext);
+					// Notice we ensure that pixmap entries always come before
+					// scalable to preserve search order afterwards
+					entries.append(iconEntry);
+					break;
+				}
+			}
+		}
+
+		if (entries.isEmpty()) {
+			const QStringList parents = theme.parents();
+			// Search recursively through inherited themes
+			for (int i = 0; i < parents.size(); ++i) {
+
+				const QString parentTheme = parents.at(i).trimmed();
+
+				if (!visited.contains(parentTheme)) // guard against recursion
+					entries = findIconHelper(parentTheme, iconName, visited);
+
+				if (!entries.isEmpty()) // success
+					break;
+			}
+		}
+
+/*********************************************************************
+Author: Kaitlin Rupert <kaitlin.rupert@intel.com>
+Date: Aug 12, 2010
+Description: Make it so that the QIcon loader honors /usr/share/pixmaps
+			 directory.  This is a valid directory per the Freedesktop.org
+			 icon theme specification.
+Bug: https://bugreports.qt.nokia.com/browse/QTBUG-12874
+ *********************************************************************/
+#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
+		/* Freedesktop standard says to look in /usr/share/pixmaps last */
+		if (entries.isEmpty()) {
+			const QString pixmaps(QLatin1String("/usr/share/pixmaps"));
+
+			QDir currentDir(pixmaps);
+			QIconDirInfo dirInfo(pixmaps);
+			if (currentDir.exists(iconName + pngext)) {
+				PixmapEntry* iconEntry = new PixmapEntry;
+				iconEntry->dir = dirInfo;
+				iconEntry->filename = currentDir.filePath(iconName + pngext);
+				// Notice we ensure that pixmap entries always come before
+				// scalable to preserve search order afterwards
+				entries.prepend(iconEntry);
+			} else if (m_supportsSvg && currentDir.exists(iconName + svgext)) {
+				ScalableEntry* iconEntry = new ScalableEntry;
+				iconEntry->dir = dirInfo;
+				iconEntry->filename = currentDir.filePath(iconName + svgext);
+				entries.append(iconEntry);
+			} else if (currentDir.exists(iconName + xpmext)) {
+				PixmapEntry* iconEntry = new PixmapEntry;
+				iconEntry->dir = dirInfo;
+				iconEntry->filename = currentDir.filePath(iconName + xpmext);
+				// Notice we ensure that pixmap entries always come before
+				// scalable to preserve search order afterwards
+				entries.append(iconEntry);
+			}
+		}
+#endif
+
+		if (entries.isEmpty()) {
+			// Search for unthemed icons in main dir of search paths
+			QStringList themeSearchPaths = QIcon::themeSearchPaths();
+			foreach (QString contentDir, themeSearchPaths) {
+				QDir currentDir(contentDir);
+
+				if (currentDir.exists(iconName + pngext)) {
+					PixmapEntry* iconEntry = new PixmapEntry;
+					iconEntry->filename =
+						currentDir.filePath(iconName + pngext);
+					// Notice we ensure that pixmap entries always come before
+					// scalable to preserve search order afterwards
+					entries.prepend(iconEntry);
+				} else if (m_supportsSvg &&
+						   currentDir.exists(iconName + svgext)) {
+					ScalableEntry* iconEntry = new ScalableEntry;
+					iconEntry->filename =
+						currentDir.filePath(iconName + svgext);
+					entries.append(iconEntry);
+					break;
+				} else if (currentDir.exists(iconName + xpmext)) {
+					PixmapEntry* iconEntry = new PixmapEntry;
+					iconEntry->filename =
+						currentDir.filePath(iconName + xpmext);
+					// Notice we ensure that pixmap entries always come before
+					// scalable to preserve search order afterwards
+					entries.append(iconEntry);
+					break;
+				}
+			}
+		}
+		return entries;
+	}
+
+	QThemeIconEntries QIconLoader::loadIcon(const QString& name) const
+	{
+		if (!themeName().isEmpty()) {
+			QStringList visited;
+			return findIconHelper(themeName(), name, visited);
+		}
+
+		return QThemeIconEntries();
+	}
+
+	// -------- Icon Loader Engine -------- //
+
+	QIconLoaderEngineFixed::QIconLoaderEngineFixed(const QString& iconName)
+		: m_iconName(iconName), m_key(0)
+	{
+	}
+
+	QIconLoaderEngineFixed::~QIconLoaderEngineFixed()
+	{
+		qDeleteAll(m_entries);
+	}
+
+	QIconLoaderEngineFixed::QIconLoaderEngineFixed(
+		const QIconLoaderEngineFixed& other)
+		: QIconEngine(other), m_iconName(other.m_iconName), m_key(0)
+	{
+	}
+
+	QIconEngine* QIconLoaderEngineFixed::clone() const
+	{
+		return new QIconLoaderEngineFixed(*this);
+	}
+
+	bool QIconLoaderEngineFixed::read(QDataStream& in)
+	{
+		in >> m_iconName;
+		return true;
+	}
+
+	bool QIconLoaderEngineFixed::write(QDataStream& out) const
+	{
+		out << m_iconName;
+		return true;
+	}
+
+	bool QIconLoaderEngineFixed::hasIcon() const
+	{
+		return !(m_entries.isEmpty());
+	}
+
+	// Lazily load the icon
+	void QIconLoaderEngineFixed::ensureLoaded()
+	{
+		if (!(QIconLoader::instance()->themeKey() == m_key)) {
+
+			qDeleteAll(m_entries);
+
+			m_entries = QIconLoader::instance()->loadIcon(m_iconName);
+			m_key = QIconLoader::instance()->themeKey();
+		}
+	}
+
+	void QIconLoaderEngineFixed::paint(QPainter* painter, const QRect& rect,
+									   QIcon::Mode mode, QIcon::State state)
+	{
+		QSize pixmapSize = rect.size();
+#if defined(Q_WS_MAC)
+		pixmapSize *= qt_mac_get_scalefactor();
+#endif
+		painter->drawPixmap(rect, pixmap(pixmapSize, mode, state));
+	}
+
+	/*
+	 * This algorithm is defined by the freedesktop spec:
+	 * http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
+	 */
+	static bool directoryMatchesSize(const QIconDirInfo& dir, int iconsize)
+	{
+		if (dir.type == QIconDirInfo::Fixed) {
+			return dir.size == iconsize;
+		} else if (dir.type == QIconDirInfo::Scalable) {
+			return dir.size <= dir.maxSize && iconsize >= dir.minSize;
+		} else if (dir.type == QIconDirInfo::Threshold) {
+			return iconsize >= dir.size - dir.threshold &&
+				   iconsize <= dir.size + dir.threshold;
+		}
+
+		Q_ASSERT(1); // Not a valid value
+		return false;
+	}
+
+	/*
+	 * This algorithm is defined by the freedesktop spec:
+	 * http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
+	 */
+	static int directorySizeDistance(const QIconDirInfo& dir, int iconsize)
+	{
+		if (dir.type == QIconDirInfo::Fixed) {
+			return qAbs(dir.size - iconsize);
+		} else if (dir.type == QIconDirInfo::Scalable) {
+			if (iconsize < dir.minSize)
+				return dir.minSize - iconsize;
+			else if (iconsize > dir.maxSize)
+				return iconsize - dir.maxSize;
+			else
+				return 0;
+		} else if (dir.type == QIconDirInfo::Threshold) {
+			if (iconsize < dir.size - dir.threshold)
+				return dir.minSize - iconsize;
+			else if (iconsize > dir.size + dir.threshold)
+				return iconsize - dir.maxSize;
+			else
+				return 0;
+		}
+
+		Q_ASSERT(1); // Not a valid value
+		return INT_MAX;
+	}
+
+	QIconLoaderEngineEntry*
+	QIconLoaderEngineFixed::entryForSize(const QSize& size)
+	{
+		int iconsize = qMin(size.width(), size.height());
+
+		// Note that m_entries are sorted so that png-files
+		// come first
+
+		const int numEntries = m_entries.size();
+
+		// Search for exact matches first
+		for (int i = 0; i < numEntries; ++i) {
+			QIconLoaderEngineEntry* entry = m_entries.at(i);
+			if (directoryMatchesSize(entry->dir, iconsize)) {
+				return entry;
+			}
+		}
+
+		// Find the minimum distance icon
+		int minimalSize = INT_MAX;
+		QIconLoaderEngineEntry* closestMatch = 0;
+		for (int i = 0; i < numEntries; ++i) {
+			QIconLoaderEngineEntry* entry = m_entries.at(i);
+			int distance = directorySizeDistance(entry->dir, iconsize);
+			if (distance < minimalSize) {
+				minimalSize = distance;
+				closestMatch = entry;
+			}
+		}
+		return closestMatch;
+	}
+
+	/*
+	 * Returns the actual icon size. For scalable svg's this is equivalent
+	 * to the requested size. Otherwise the closest match is returned but
+	 * we can never return a bigger size than the requested size.
+	 *
+	 */
+	QSize QIconLoaderEngineFixed::actualSize(const QSize& size,
+											 QIcon::Mode mode,
+											 QIcon::State state)
+	{
+		ensureLoaded();
+
+		QIconLoaderEngineEntry* entry = entryForSize(size);
+		if (entry) {
+			const QIconDirInfo& dir = entry->dir;
+			if (dir.type == QIconDirInfo::Scalable)
+				return size;
+			else {
+				int result =
+					qMin<int>(dir.size, qMin(size.width(), size.height()));
+				return QSize(result, result);
+			}
+		}
+		return QIconEngine::actualSize(size, mode, state);
+	}
+
+	QPixmap PixmapEntry::pixmap(const QSize& size, QIcon::Mode mode,
+								QIcon::State state)
+	{
+		Q_UNUSED(state);
+
+		// Ensure that basePixmap is lazily initialized before generating the
+		// key, otherwise the cache key is not unique
+		if (basePixmap.isNull())
+			basePixmap.load(filename);
+
+		QSize actualSize = basePixmap.size();
+		if (!actualSize.isNull() && (actualSize.width() > size.width() ||
+									 actualSize.height() > size.height()))
+			actualSize.scale(size, Qt::KeepAspectRatio);
+
+		QString key = QLatin1String("$qt_theme_") %
+					  HexString<qint64>(basePixmap.cacheKey()) %
+					  HexString<int>(mode) %
+					  HexString<qint64>(QGuiApplication::palette().cacheKey()) %
+					  HexString<int>(actualSize.width()) %
+					  HexString<int>(actualSize.height());
+
+		QPixmap cachedPixmap;
+		if (QPixmapCache::find(key, &cachedPixmap)) {
+			return cachedPixmap;
+		} else {
+			if (basePixmap.size() != actualSize) {
+				cachedPixmap =
+					basePixmap.scaled(actualSize, Qt::IgnoreAspectRatio,
+									  Qt::SmoothTransformation);
+			} else {
+				cachedPixmap = basePixmap;
+			}
+			QPixmapCache::insert(key, cachedPixmap);
+		}
+		return cachedPixmap;
+	}
+
+	QPixmap ScalableEntry::pixmap(const QSize& size, QIcon::Mode mode,
+								  QIcon::State state)
+	{
+		if (svgIcon.isNull()) {
+			svgIcon = QIcon(filename);
+		}
+
+		// Simply reuse svg icon engine
+		return svgIcon.pixmap(size, mode, state);
+	}
+
+	QPixmap QIconLoaderEngineFixed::pixmap(const QSize& size, QIcon::Mode mode,
+										   QIcon::State state)
+	{
+		ensureLoaded();
+
+		QIconLoaderEngineEntry* entry = entryForSize(size);
+		if (entry) {
+			return entry->pixmap(size, mode, state);
+		}
+
+		return QPixmap();
+	}
+
+	QString QIconLoaderEngineFixed::key() const
+	{
+		return QLatin1String("QIconLoaderEngineFixed");
+	}
+
+	QList<QSize> QIconLoaderEngineFixed::availableSizes(QIcon::Mode mode,
+														QIcon::State state)
+	{
+		ensureLoaded();
+
+		const int N = m_entries.size();
+		QList<QSize> sizes;
+		sizes.reserve(N);
+
+		for (int i = 0; i < N; ++i) {
+			int size = m_entries.at(i)->dir.size;
+			sizes.append(QSize(size, size));
+		}
+		return sizes;
+	}
+
+	QString QIconLoaderEngineFixed::iconName()
+	{
+		return m_iconName;
+	}
+
+} // namespace QtXdg
diff --git a/meshmc/libraries/iconfix/internal/qiconloader_p.h b/meshmc/libraries/iconfix/internal/qiconloader_p.h
new file mode 100644
index 0000000000..89f2c1656b
--- /dev/null
+++ b/meshmc/libraries/iconfix/internal/qiconloader_p.h
@@ -0,0 +1,216 @@
+/****************************************************************************
+** SPDX-License-Identifier: LGPL-2.1-or-later
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights. These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#pragma once
+
+#include <QtCore/qglobal.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtGui/QIcon>
+#include <QtGui/QIconEngine>
+#include <QtGui/QPixmapCache>
+#include <QtCore/QHash>
+#include <QtCore/QVector>
+#include <QtCore/QTypeInfo>
+
+namespace QtXdg
+{
+
+	class QIconLoader;
+
+	struct QIconDirInfo {
+		enum Type { Fixed, Scalable, Threshold };
+		QIconDirInfo(const QString& _path = QString())
+			: path(_path), size(0), maxSize(0), minSize(0), threshold(0),
+			  type(Threshold)
+		{
+		}
+		QString path;
+		short size;
+		short maxSize;
+		short minSize;
+		short threshold;
+		Type type : 4;
+	};
+
+	class QIconLoaderEngineEntry
+	{
+	  public:
+		virtual ~QIconLoaderEngineEntry() {}
+		virtual QPixmap pixmap(const QSize& size, QIcon::Mode mode,
+							   QIcon::State state) = 0;
+		QString filename;
+		QIconDirInfo dir;
+		static int count;
+	};
+
+	struct ScalableEntry : public QIconLoaderEngineEntry {
+		QPixmap pixmap(const QSize& size, QIcon::Mode mode,
+					   QIcon::State state) Q_DECL_OVERRIDE;
+		QIcon svgIcon;
+	};
+
+	struct PixmapEntry : public QIconLoaderEngineEntry {
+		QPixmap pixmap(const QSize& size, QIcon::Mode mode,
+					   QIcon::State state) Q_DECL_OVERRIDE;
+		QPixmap basePixmap;
+	};
+
+	typedef QList<QIconLoaderEngineEntry*> QThemeIconEntries;
+
+	// class QIconLoaderEngine : public QIconEngine
+	class QIconLoaderEngineFixed : public QIconEngine
+	{
+	  public:
+		QIconLoaderEngineFixed(const QString& iconName = QString());
+		~QIconLoaderEngineFixed();
+
+		void paint(QPainter* painter, const QRect& rect, QIcon::Mode mode,
+				   QIcon::State state) override;
+		QPixmap pixmap(const QSize& size, QIcon::Mode mode,
+					   QIcon::State state) override;
+		QSize actualSize(const QSize& size, QIcon::Mode mode,
+						 QIcon::State state) override;
+		QIconEngine* clone() const override;
+		bool read(QDataStream& in) override;
+		bool write(QDataStream& out) const override;
+
+	  private:
+		QString key() const override;
+		bool hasIcon() const;
+		void ensureLoaded();
+		QList<QSize> availableSizes(QIcon::Mode mode = QIcon::Normal,
+									QIcon::State state = QIcon::Off) override;
+		QString iconName() override;
+		QIconLoaderEngineEntry* entryForSize(const QSize& size);
+		QIconLoaderEngineFixed(const QIconLoaderEngineFixed& other);
+		QThemeIconEntries m_entries;
+		QString m_iconName;
+		uint m_key;
+
+		friend class QIconLoader;
+	};
+
+	class QIconTheme
+	{
+	  public:
+		QIconTheme(const QString& name);
+		QIconTheme() : m_valid(false) {}
+		QStringList parents()
+		{
+			return m_parents;
+		}
+		QVector<QIconDirInfo> keyList()
+		{
+			return m_keyList;
+		}
+		QString contentDir()
+		{
+			return m_contentDir;
+		}
+		QStringList contentDirs()
+		{
+			return m_contentDirs;
+		}
+		bool isValid()
+		{
+			return m_valid;
+		}
+
+	  private:
+		QString m_contentDir;
+		QStringList m_contentDirs;
+		QVector<QIconDirInfo> m_keyList;
+		QStringList m_parents;
+		bool m_valid;
+	};
+
+	class QIconLoader
+	{
+	  public:
+		QIconLoader();
+		QThemeIconEntries loadIcon(const QString& iconName) const;
+		uint themeKey() const
+		{
+			return m_themeKey;
+		}
+
+		QString themeName() const
+		{
+			return m_userTheme.isEmpty() ? m_systemTheme : m_userTheme;
+		}
+		void setThemeName(const QString& themeName);
+		QIconTheme theme()
+		{
+			return themeList.value(themeName());
+		}
+		void setThemeSearchPath(const QStringList& searchPaths);
+		QStringList themeSearchPaths() const;
+		QIconDirInfo dirInfo(int dirindex);
+		static QIconLoader* instance();
+		void updateSystemTheme();
+		void invalidateKey()
+		{
+			m_themeKey++;
+		}
+		void ensureInitialized();
+
+	  private:
+		QThemeIconEntries findIconHelper(const QString& themeName,
+										 const QString& iconName,
+										 QStringList& visited) const;
+		uint m_themeKey;
+		bool m_supportsSvg;
+		bool m_initialized;
+
+		mutable QString m_userTheme;
+		mutable QString m_systemTheme;
+		mutable QStringList m_iconDirs;
+		mutable QHash<QString, QIconTheme> themeList;
+	};
+
+} // namespace QtXdg
+
+// Note: class template specialization of 'QTypeInfo' must occur at
+//       global scope
+Q_DECLARE_TYPEINFO(QtXdg::QIconDirInfo, Q_MOVABLE_TYPE);