Sandboxie/SandboxiePlus/MiscHelpers/Common/IconExtreactor.cpp

307 lines
11 KiB
C++

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtWinExtras module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** 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 The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** BSD License Usage
** Alternatively, you may use this file under the terms of the BSD license
** as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of The Qt Company Ltd nor the names of its
** contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "stdafx.h"
#include "IconExtreactor.h"
#include <QtWin>
//#include <iostream>
#include <shellapi.h>
#include <comdef.h>
#include <commctrl.h>
#include <objbase.h>
#include <commoncontrols.h>
/* This example demonstrates the Windows-specific image conversion
* functions. */
/*struct PixmapEntry {
QString name;
QPixmap pixmap;
};
typedef QVector<PixmapEntry> PixmapEntryList;*/
/*std::wostream &operator<<(std::wostream &str, const QString &s)
{
#ifdef Q_OS_WIN
str << reinterpret_cast<const wchar_t *>(s.utf16());
#else
str << s.toStdWString();
#endif
return str;
}*/
QString formatSize(const QSize &size)
{
return QString::number(size.width()) + u'x' + QString::number(size.height());
}
// Extract icons contained in executable or DLL using the Win32 API ExtractIconEx()
PixmapEntryList extractIcons(const QString &sourceFile, bool large)
{
const QString nativeName = QDir::toNativeSeparators(sourceFile);
const auto *sourceFileC = reinterpret_cast<const wchar_t *>(nativeName.utf16());
const UINT iconCount = ExtractIconEx(sourceFileC, -1, nullptr, nullptr, 0);
if (!iconCount) {
//std::wcerr << sourceFile << " does not appear to contain icons.\n";
return PixmapEntryList();
}
QScopedArrayPointer<HICON> icons(new HICON[iconCount]);
const UINT extractedIconCount = large ?
ExtractIconEx(sourceFileC, 0, icons.data(), nullptr, iconCount) :
ExtractIconEx(sourceFileC, 0, nullptr, icons.data(), iconCount);
if (!extractedIconCount) {
qErrnoWarning("Failed to extract icons from %s", qPrintable(sourceFile));
return PixmapEntryList();
}
PixmapEntryList result;
result.reserve(int(extractedIconCount));
//std::wcout << sourceFile << " contains " << extractedIconCount << " icon(s).\n";
for (UINT i = 0; i < extractedIconCount; ++i) {
PixmapEntry entry;
entry.pixmap = QtWin::fromHICON(icons[i]);
if (entry.pixmap.isNull()) {
//std::wcerr << "Error converting icons.\n";
return PixmapEntryList();
}
entry.name = QString::fromLatin1("%1_%2x%3").arg(i, 3, 10, QLatin1Char('0'))
.arg(entry.pixmap.width()).arg(entry.pixmap.height());
result.append(entry);
}
return result;
}
// Helper for extracting large/jumbo icons available from Windows Vista onwards
// via SHGetImageList().
QPixmap pixmapFromShellImageList(int iImageList, const SHFILEINFO &info)
{
QPixmap result;
// For MinGW:
const IID iID_IImageList = { 0x46eb5926, 0x582e, 0x4017, {0x9f, 0xdf, 0xe8, 0x99, 0x8d, 0xaa, 0x9, 0x50} };
IImageList *imageList = nullptr;
if (FAILED(SHGetImageList(iImageList, iID_IImageList, reinterpret_cast<void **>(&imageList))))
return result;
HICON hIcon = nullptr;
if (SUCCEEDED(imageList->GetIcon(info.iIcon, ILD_TRANSPARENT, &hIcon))) {
result = QtWin::fromHICON(hIcon);
DestroyIcon(hIcon);
}
return result;
}
// Extract icons that would be displayed by the Explorer (shell)
PixmapEntryList extractShellIcons(const QString &sourceFile, bool addOverlays)
{
enum { // Shell image list ids
sHIL_EXTRALARGE = 0x2, // 48x48 or user-defined
sHIL_JUMBO = 0x4 // 256x256 (Vista or later)
};
struct FlagEntry {
const char *name;
unsigned flags;
};
const FlagEntry modeEntries[] =
{
{"", 0},
{"open", SHGFI_OPENICON},
{"sel", SHGFI_SELECTED},
};
const FlagEntry standardSizeEntries[] =
{
{"s", SHGFI_SMALLICON},
{"l", SHGFI_LARGEICON},
{"sh", SHGFI_SHELLICONSIZE},
};
const QString nativeName = QDir::toNativeSeparators(sourceFile);
const auto *sourceFileC = reinterpret_cast<const wchar_t *>(nativeName.utf16());
SHFILEINFO info;
unsigned int baseFlags = SHGFI_ICON | SHGFI_SYSICONINDEX | SHGFI_ICONLOCATION;
if (addOverlays)
baseFlags |= SHGFI_ADDOVERLAYS | SHGFI_OVERLAYINDEX;
if (!QFileInfo(sourceFile).isDir())
baseFlags |= SHGFI_USEFILEATTRIBUTES;
PixmapEntryList result;
for (auto modeEntry : modeEntries) {
const unsigned modeFlags = baseFlags | modeEntry.flags;
QString modePrefix = QLatin1String("_shell_");
if (modeEntry.name[0])
modePrefix += QLatin1String(modeEntry.name) + u'_';
for (auto standardSizeEntry : standardSizeEntries) {
const unsigned flags = modeFlags | standardSizeEntry.flags;
const QString prefix = modePrefix + QLatin1String(standardSizeEntry.name)
+ u'_';
ZeroMemory(&info, sizeof(SHFILEINFO));
const HRESULT hr = SHGetFileInfo(sourceFileC, 0, &info, sizeof(SHFILEINFO), flags);
if (FAILED(hr)) {
_com_error error(hr);
//std::wcerr << "SHGetFileInfo() failed for \"" << nativeName << "\", "
// << std::hex << std::showbase << flags << std::dec << std::noshowbase
// << " (" << prefix << "): " << error.ErrorMessage() << '\n';
continue;
}
if (info.hIcon) {
PixmapEntry entry;
entry.pixmap = QtWin::fromHICON(info.hIcon);
DestroyIcon(info.hIcon);
if (entry.pixmap.isNull()) {
//std::wcerr << "Error converting icons.\n";
return PixmapEntryList();
}
entry.name = prefix + formatSize(entry.pixmap.size());
const int iconIndex = info.iIcon & 0xFFFFFF;
const int overlayIconIndex = info.iIcon >> 24;
//std::wcout << "Obtained icon #" << iconIndex;
//if (addOverlays)
// std::wcout << " (overlay #" << overlayIconIndex << ')';
//if (info.szDisplayName[0])
// std::wcout << " from " << QString::fromWCharArray(info.szDisplayName);
//std::wcout << " (" << entry.pixmap.width() << 'x'
// << entry.pixmap.height() << ") for " << std::hex << std::showbase << flags
// << std::dec << std::noshowbase << '\n';
result.append(entry);
}
} // for standardSizeEntryCount
// Windows Vista onwards: extract large/jumbo icons
if (info.hIcon) {
const QPixmap extraLarge = pixmapFromShellImageList(sHIL_EXTRALARGE, info);
if (!extraLarge.isNull()) {
PixmapEntry entry;
entry.pixmap = extraLarge;
entry.name = modePrefix + QLatin1String("xl_") + formatSize(extraLarge.size());
result.append(entry);
}
const QPixmap jumbo = pixmapFromShellImageList(sHIL_JUMBO, info);
if (!jumbo.isNull()) {
PixmapEntry entry;
entry.pixmap = jumbo;
entry.name = modePrefix + QLatin1String("jumbo_") + formatSize(extraLarge.size());
result.append(entry);
}
}
} // for modes
return result;
}
/*
const char description[] =
"\nExtracts Windows icons from executables, DLL or icon files and writes them\n"
"out as numbered .png-files.\n"
"When passing the --shell option, the icons displayed by Explorer are extracted.\n";
#include <QCommandLineParser>
#include <QCommandLineOption>
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QCoreApplication::setApplicationName(QStringLiteral("Icon Extractor"));
QCoreApplication::setOrganizationName(QStringLiteral("QtProject"));
QCoreApplication::setApplicationVersion(QLatin1String(QT_VERSION_STR));
QCommandLineParser parser;
parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsCompactedShortOptions);
parser.setApplicationDescription(QLatin1String(description));
parser.addHelpOption();
parser.addVersionOption();
const QCommandLineOption largeIconOption(QStringLiteral("large"), QStringLiteral("Extract large icons"));
parser.addOption(largeIconOption);
const QCommandLineOption shellIconOption(QStringLiteral("shell"), QStringLiteral("Extract shell icons using SHGetFileInfo()"));
parser.addOption(shellIconOption);
const QCommandLineOption shellOverlayOption(QStringLiteral("overlay"), QStringLiteral("Extract shell overlay icons"));
parser.addOption(shellOverlayOption);
parser.addPositionalArgument(QStringLiteral("file"), QStringLiteral("The file to open."));
parser.addPositionalArgument(QStringLiteral("image_file_folder"), QStringLiteral("The folder to store the images."));
parser.process(app);
const QStringList &positionalArguments = parser.positionalArguments();
if (positionalArguments.isEmpty())
parser.showHelp(0);
QString imageFileRoot = positionalArguments.size() > 1 ? positionalArguments.at(1) : QDir::currentPath();
const QFileInfo imageFileRootInfo(imageFileRoot);
if (!imageFileRootInfo.isDir()) {
std::wcerr << imageFileRoot << " is not a directory.\n";
return 1;
}
const QString &sourceFile = positionalArguments.constFirst();
imageFileRoot = imageFileRootInfo.absoluteFilePath() + u'/' + QFileInfo(sourceFile).baseName();
const PixmapEntryList pixmaps = parser.isSet(shellIconOption)
? extractShellIcons(sourceFile, parser.isSet(shellOverlayOption))
: extractIcons(sourceFile, parser.isSet(largeIconOption));
for (const auto &entry : pixmaps) {
const QString fileName = imageFileRoot + entry.name + QLatin1String(".png");
if (!entry.pixmap.save(fileName)) {
std::wcerr << "Error writing image file " << fileName << ".\n";
return 1;
}
std::wcout << "Wrote " << QDir::toNativeSeparators(fileName) << ".\n";
}
return 0;
}*/