fenix/PDF4QT
1
0
Fork 0
mirror of https://github.com/JakubMelka/PDF4QT.git synced 2025-03-20 05:10:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

Font information

Browse Source
This commit is contained in:
Jakub Melka 2019-12-21 18:10:54 +01:00
parent f2f398e82b
commit f48709c8c5
6 changed files with 460 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

216
PdfForQtLib/sources/pdffont.cpp
View File

@ -31,6 +31,7 @@
#include <QMutex>
#include <QPainterPath>
#include <QDataStream>
#include <QTreeWidgetItem>
#ifdef Q_OS_WIN
#include "Windows.h"
@ -350,6 +351,9 @@ public:
/// Returns true, if font has horizontal writing system
virtual bool isHorizontalWritingSystem() const = 0;
/// Dumps information about the font
virtual void dumpFontToTreeItem(QTreeWidgetItem* item) const { Q_UNUSED(item); }
};
/// Implementation of the PDFRealizedFont class using PIMPL pattern for Type 3 fonts
@ -379,6 +383,7 @@ public:
virtual void fillTextSequence(const QByteArray& byteArray, TextSequence& textSequence, PDFRenderErrorReporter* reporter) override;
virtual bool isHorizontalWritingSystem() const override { return !m_isVertical; }
virtual void dumpFontToTreeItem(QTreeWidgetItem* item) const override;
static constexpr const PDFReal PIXEL_SIZE_MULTIPLIER = 100.0;
@ -553,6 +558,107 @@ void PDFRealizedFontImpl::fillTextSequence(const QByteArray& byteArray, TextSequ
}
}
void PDFRealizedFontImpl::dumpFontToTreeItem(QTreeWidgetItem* item) const
{
QTreeWidgetItem* root = new QTreeWidgetItem(item, { PDFTranslationContext::tr("Details") });
if (m_face->family_name)
{
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Font"), QString::fromLatin1(m_face->family_name) });
}
if (m_face->style_name)
{
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Style"), QString::fromLatin1(m_face->style_name) });
}
QString yesString = PDFTranslationContext::tr("Yes");
QString noString = PDFTranslationContext::tr("No");
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Glyph count"), QString::number(m_face->num_glyphs) });
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Is CID keyed"), (m_face->face_flags & FT_FACE_FLAG_CID_KEYED) ? yesString : noString });
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Is bold"), (m_face->style_flags & FT_STYLE_FLAG_BOLD) ? yesString : noString });
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Is italics"), (m_face->style_flags & FT_STYLE_FLAG_ITALIC) ? yesString : noString });
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Has vertical writing system"), (m_face->face_flags & FT_FACE_FLAG_VERTICAL) ? yesString : noString });
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Has SFNT storage scheme"), (m_face->face_flags & FT_FACE_FLAG_SFNT) ? yesString : noString });
new QTreeWidgetItem(root, { PDFTranslationContext::tr("Has glyph names"), (m_face->face_flags & FT_FACE_FLAG_GLYPH_NAMES) ? yesString : noString });
if (m_face->num_charmaps > 0)
{
QTreeWidgetItem* encodingRoot = new QTreeWidgetItem(item, { PDFTranslationContext::tr("Encoding") });
for (FT_Int i = 0; i < m_face->num_charmaps; ++i)
{
FT_CharMap charMap = m_face->charmaps[i];
const FT_Encoding encoding = charMap->encoding;
QString encodingName;
switch (encoding)
{
case FT_ENCODING_NONE:
encodingName = PDFTranslationContext::tr("None");
break;
case FT_ENCODING_UNICODE:
encodingName = PDFTranslationContext::tr("Unicode");
break;
case FT_ENCODING_MS_SYMBOL:
encodingName = PDFTranslationContext::tr("MS Symbol");
break;
case FT_ENCODING_SJIS:
encodingName = PDFTranslationContext::tr("Japanese Shift JIS");
break;
case FT_ENCODING_PRC:
encodingName = PDFTranslationContext::tr("PRC - Simplified Chinese");
break;
case FT_ENCODING_BIG5:
encodingName = PDFTranslationContext::tr("Traditional Chinese");
break;
case FT_ENCODING_WANSUNG:
encodingName = PDFTranslationContext::tr("Korean Extended Wansung");
break;
case FT_ENCODING_JOHAB:
encodingName = PDFTranslationContext::tr("Korean Standard");
break;
case FT_ENCODING_ADOBE_STANDARD:
encodingName = PDFTranslationContext::tr("Adobe Standard");
break;
case FT_ENCODING_ADOBE_EXPERT:
encodingName = PDFTranslationContext::tr("Adobe Expert");
break;
case FT_ENCODING_ADOBE_CUSTOM:
encodingName = PDFTranslationContext::tr("Adobe Custom");
break;
case FT_ENCODING_ADOBE_LATIN_1:
encodingName = PDFTranslationContext::tr("Adobe Latin 1");
break;
case FT_ENCODING_OLD_LATIN_2:
encodingName = PDFTranslationContext::tr("Old Latin 1");
break;
case FT_ENCODING_APPLE_ROMAN:
encodingName = PDFTranslationContext::tr("Apple Roman");
break;
default:
encodingName = PDFTranslationContext::tr("Unknown");
break;
}
QString encodingString = PDFTranslationContext::tr("Platform/Encoding = %1 %2").arg(charMap->platform_id).arg(charMap->encoding_id);
new QTreeWidgetItem(encodingRoot, { encodingName, encodingString });
}
}
}
int PDFRealizedFontImpl::outlineMoveTo(const FT_Vector* to, void* user)
{
Glyph* glyph = reinterpret_cast<Glyph*>(user);
@ -647,6 +753,11 @@ bool PDFRealizedFont::isHorizontalWritingSystem() const
return m_impl->isHorizontalWritingSystem();
}
void PDFRealizedFont::dumpFontToTreeItem(QTreeWidgetItem* item) const
{
m_impl->dumpFontToTreeItem(item);
}
PDFRealizedFontPointer PDFRealizedFont::createRealizedFont(PDFFontPointer font, PDFReal pixelSize, PDFRenderErrorReporter* reporter)
{
PDFRealizedFontPointer result;
@ -1347,6 +1458,59 @@ PDFInteger PDFSimpleFont::getGlyphAdvance(size_t index) const
return 0;
}
void PDFSimpleFont::dumpFontToTreeItem(QTreeWidgetItem* item) const
{
BaseClass::dumpFontToTreeItem(item);
QString encodingTypeString;
switch (m_encodingType)
{
case PDFEncoding::Encoding::Standard:
encodingTypeString = PDFTranslationContext::tr("Standard");
break;
case PDFEncoding::Encoding::MacRoman:
encodingTypeString = PDFTranslationContext::tr("Mac Roman");
break;
case PDFEncoding::Encoding::WinAnsi:
encodingTypeString = PDFTranslationContext::tr("Win Ansi");
break;
case PDFEncoding::Encoding::PDFDoc:
encodingTypeString = PDFTranslationContext::tr("PDF Doc");
break;
case PDFEncoding::Encoding::MacExpert:
encodingTypeString = PDFTranslationContext::tr("Mac Expert");
break;
case PDFEncoding::Encoding::Symbol:
encodingTypeString = PDFTranslationContext::tr("Symbol");
break;
case PDFEncoding::Encoding::ZapfDingbats:
encodingTypeString = PDFTranslationContext::tr("Zapf Dingbats");
break;
case PDFEncoding::Encoding::MacOsRoman:
encodingTypeString = PDFTranslationContext::tr("Mac OS Roman");
break;
case PDFEncoding::Encoding::Custom:
encodingTypeString = PDFTranslationContext::tr("Custom");
break;
default:
{
Q_ASSERT(false);
break;
}
}
new QTreeWidgetItem(item, { PDFTranslationContext::tr("Encoding"), encodingTypeString });
}
PDFType1Font::PDFType1Font(FontDescriptor fontDescriptor,
QByteArray name,
QByteArray baseFont,
@ -1368,6 +1532,53 @@ FontType PDFType1Font::getFontType() const
return FontType::Type1;
}
void PDFType1Font::dumpFontToTreeItem(QTreeWidgetItem* item) const
{
BaseClass::dumpFontToTreeItem(item);
if (m_standardFontType != StandardFontType::Invalid)
{
QString standardFontTypeString;
switch (m_standardFontType)
{
case StandardFontType::TimesRoman:
case StandardFontType::TimesRomanBold:
case StandardFontType::TimesRomanItalics:
case StandardFontType::TimesRomanBoldItalics:
standardFontTypeString = PDFTranslationContext::tr("Times Roman");
break;
case StandardFontType::Helvetica:
case StandardFontType::HelveticaBold:
case StandardFontType::HelveticaOblique:
case StandardFontType::HelveticaBoldOblique:
standardFontTypeString = PDFTranslationContext::tr("Helvetica");
break;
case StandardFontType::Courier:
case StandardFontType::CourierBold:
case StandardFontType::CourierOblique:
case StandardFontType::CourierBoldOblique:
standardFontTypeString = PDFTranslationContext::tr("Courier");
break;
case StandardFontType::Symbol:
standardFontTypeString = PDFTranslationContext::tr("Symbol");
break;
case StandardFontType::ZapfDingbats:
standardFontTypeString = PDFTranslationContext::tr("Zapf Dingbats");
break;
default:
Q_ASSERT(false);
break;
}
new QTreeWidgetItem(item, { PDFTranslationContext::tr("Standard font"), standardFontTypeString });
}
}
FontType PDFTrueTypeFont::getFontType() const
{
return FontType::TrueType;
@ -1920,6 +2131,11 @@ FontType PDFType3Font::getFontType() const
return FontType::Type3;
}
void PDFType3Font::dumpFontToTreeItem(QTreeWidgetItem* item) const
{
new QTreeWidgetItem(item, { PDFTranslationContext::tr("Character count"), QString::number(m_characterContentStreams.size()) });
}
double PDFType3Font::getWidth(int characterIndex) const
{
if (characterIndex >= m_firstCharacterIndex && characterIndex <= m_lastCharacterIndex)

21
PdfForQtLib/sources/pdffont.h
View File

@ -25,6 +25,7 @@
#include <QFont>
#include <QMatrix>
#include <QSharedPointer>
#include <QTreeWidgetItem>
#include <unordered_map>
@ -166,7 +167,7 @@ static constexpr PDFEncoding::Encoding getEncodingForStandardFont(StandardFontTy
}
}
struct FontDescriptor
struct PDFFORQTLIBSHARED_EXPORT FontDescriptor
{
bool isEmbedded() const { return !fontFile.isEmpty() || !fontFile2.isEmpty() || !fontFile3.isEmpty(); }
@ -216,7 +217,7 @@ using PDFRealizedFontPointer = QSharedPointer<PDFRealizedFont>;
/// Font, which has fixed pixel size. It is programmed as PIMPL, because we need
/// to remove FreeType types from the interface (so we do not include FreeType in the interface).
class PDFRealizedFont
class PDFFORQTLIBSHARED_EXPORT PDFRealizedFont
{
public:
~PDFRealizedFont();
@ -231,6 +232,9 @@ public:
/// Return true, if we have horizontal writing system
bool isHorizontalWritingSystem() const;
/// Adds information about the font into tree item
void dumpFontToTreeItem(QTreeWidgetItem* item) const;
/// Creates new realized font from the standard font. If font can't be created,
/// then exception is thrown.
static PDFRealizedFontPointer createRealizedFont(PDFFontPointer font, PDFReal pixelSize, PDFRenderErrorReporter* reporter);
@ -243,7 +247,7 @@ private:
};
/// Base class representing font in the PDF file
class PDFFont
class PDFFORQTLIBSHARED_EXPORT PDFFont
{
public:
explicit PDFFont(FontDescriptor fontDescriptor);
@ -255,6 +259,9 @@ public:
/// Returns font descriptor
const FontDescriptor* getFontDescriptor() const { return &m_fontDescriptor; }
/// Adds information about the font into tree item
virtual void dumpFontToTreeItem(QTreeWidgetItem* item) const { Q_UNUSED(item); }
/// Creates font from the object. If font can't be created, exception is thrown.
/// \param object Font dictionary
/// \param document Document
@ -274,6 +281,8 @@ private:
/// which maps single-byte character to the glyph in the font.
class PDFSimpleFont : public PDFFont
{
using BaseClass = PDFFont;
public:
explicit PDFSimpleFont(FontDescriptor fontDescriptor,
QByteArray name,
@ -292,6 +301,8 @@ public:
/// Returns the glyph advance (or zero, if glyph advance is invalid)
PDFInteger getGlyphAdvance(size_t index) const;
virtual void dumpFontToTreeItem(QTreeWidgetItem* item) const override;
protected:
QByteArray m_name;
QByteArray m_baseFont;
@ -305,6 +316,8 @@ protected:
class PDFType1Font : public PDFSimpleFont
{
using BaseClass = PDFSimpleFont;
public:
explicit PDFType1Font(FontDescriptor fontDescriptor,
QByteArray name,
@ -319,6 +332,7 @@ public:
virtual ~PDFType1Font() override = default;
virtual FontType getFontType() const override;
virtual void dumpFontToTreeItem(QTreeWidgetItem*item) const override;
/// Returns the assigned standard font (or invalid, if font is not standard)
StandardFontType getStandardFontType() const { return m_standardFontType; }
@ -347,6 +361,7 @@ public:
const PDFObject& resources);
virtual FontType getFontType() const override;
virtual void dumpFontToTreeItem(QTreeWidgetItem*item) const override;
/// Returns width of the character. If character doesn't exist, then zero is returned.
double getWidth(int characterIndex) const;

2
PdfForQtLib/sources/pdfobject.h
View File

@ -226,7 +226,7 @@ private:
/// an array of pairs key-value, where key is name object and value is any
/// PDF object. For this reason, we use QByteArray for key. We do not use
/// map, because dictionaries are usually small.
class PDFDictionary : public PDFObjectContent
class PDFFORQTLIBSHARED_EXPORT PDFDictionary : public PDFObjectContent
{
public:
using DictionaryEntry = std::pair<QByteArray, PDFObject>;

168
PdfForQtViewer/pdfdocumentpropertiesdialog.cpp
View File

@ -20,9 +20,15 @@
#include "pdfdocument.h"
#include "pdfwidgetutils.h"
#include "pdffont.h"
#include "pdfutils.h"
#include "pdfexception.h"
#include <QLocale>
#include <QPageSize>
#include <QtConcurrent/QtConcurrent>
#include <execution>
namespace pdfviewer
{
@ -38,6 +44,7 @@ PDFDocumentPropertiesDialog::PDFDocumentPropertiesDialog(const pdf::PDFDocument*
initializeProperties(document);
initializeFileInfoProperties(fileInfo);
initializeSecurity(document);
initializeFonts(document);
const int defaultWidth = PDFWidgetUtils::getPixelSize(this, 240.0);
const int defaultHeight = PDFWidgetUtils::getPixelSize(this, 200.0);
@ -46,6 +53,7 @@ PDFDocumentPropertiesDialog::PDFDocumentPropertiesDialog(const pdf::PDFDocument*
PDFDocumentPropertiesDialog::~PDFDocumentPropertiesDialog()
{
Q_ASSERT(m_fontTreeWidgetItems.empty());
delete ui;
}
@ -228,4 +236,164 @@ void PDFDocumentPropertiesDialog::initializeSecurity(const pdf::PDFDocument* doc
ui->securityTreeWidget->resizeColumnToContents(0);
}
void PDFDocumentPropertiesDialog::initializeFonts(const pdf::PDFDocument* document)
{
auto createFontInfo = [this, document]()
{
pdf::PDFInteger pageCount = document->getCatalog()->getPageCount();
QMutex fontTreeItemMutex;
QMutex usedFontReferencesMutex;
std::set<pdf::PDFObjectReference> usedFontReferences;
auto processPage = [&](pdf::PDFInteger pageIndex)
{
try
{
const pdf::PDFPage* page = document->getCatalog()->getPage(pageIndex);
if (const pdf::PDFDictionary* resourcesDictionary = document->getDictionaryFromObject(page->getResources()))
{
if (const pdf::PDFDictionary* fontsDictionary = document->getDictionaryFromObject(resourcesDictionary->get("Font")))
{
// Iterate trough each font
const size_t fontsCount = fontsDictionary->getCount();
for (size_t i = 0; i < fontsCount; ++i)
{
pdf::PDFObject object = fontsDictionary->getValue(i);
if (object.isReference())
{
// Check, if we have not processed the object. If we have it processed,
// then do nothing, otherwise insert it into the processed objects.
// We must also use mutex, because we use multithreading.
QMutexLocker lock(&usedFontReferencesMutex);
if (usedFontReferences.count(object.getReference()))
{
continue;
}
else
{
usedFontReferences.insert(object.getReference());
}
}
try
{
if (pdf::PDFFontPointer font = pdf::PDFFont::createFont(object, document))
{
pdf::PDFRealizedFontPointer realizedFont = pdf::PDFRealizedFont::createRealizedFont(font, 8.0, nullptr);
if (realizedFont)
{
const pdf::FontType fontType = font->getFontType();
const pdf::FontDescriptor* fontDescriptor = font->getFontDescriptor();
QString fontName = fontDescriptor->fontName;
// Try to remove characters from +, if we have font name 'SDFDSF+ValidFontName'
int plusPos = fontName.lastIndexOf('+');
if (plusPos != -1 && plusPos < fontName.size() - 1)
{
fontName = fontName.mid(plusPos + 1);
}
if (fontName.isEmpty())
{
fontName = QString::fromLatin1(fontsDictionary->getKey(i));
}
std::unique_ptr<QTreeWidgetItem> fontRootItemPtr = std::make_unique<QTreeWidgetItem>(QStringList({ fontName }));
QTreeWidgetItem* fontRootItem = fontRootItemPtr.get();
QString fontTypeString;
switch (fontType)
{
case pdf::FontType::TrueType:
fontTypeString = tr("TrueType");
break;
case pdf::FontType::Type0:
fontTypeString = tr("Type0 (CID keyed)");
break;
case pdf::FontType::Type1:
fontTypeString = tr("Type1 (8 bit keyed)");
break;
case pdf::FontType::Type3:
fontTypeString = tr("Type3 (content streams for font glyphs)");
break;
default:
Q_ASSERT(false);
break;
}
new QTreeWidgetItem(fontRootItem, { tr("Type"), fontTypeString });
if (!fontDescriptor->fontFamily.isEmpty())
{
new QTreeWidgetItem(fontRootItem, { tr("Font family"), fontDescriptor->fontFamily });
}
new QTreeWidgetItem(fontRootItem, { tr("Embedded subset"), fontDescriptor->getEmbeddedFontData() ? tr("Yes") : tr("No") });
font->dumpFontToTreeItem(fontRootItem);
realizedFont->dumpFontToTreeItem(fontRootItem);
// Separator item
new QTreeWidgetItem(fontRootItem, QStringList());
// Finally add the tree item
QMutexLocker lock(&fontTreeItemMutex);
m_fontTreeWidgetItems.push_back(fontRootItemPtr.release());
}
}
}
catch (pdf::PDFException)
{
// Do nothing, some error occured, continue with next font
continue;
}
}
}
}
}
catch (pdf::PDFException)
{
// Do nothing, some error occured
}
};
pdf::PDFIntegerRange<pdf::PDFInteger> indices(pdf::PDFInteger(0), pageCount);
std::for_each(std::execution::parallel_policy(), indices.begin(), indices.end(), processPage);
};
m_future = QtConcurrent::run(createFontInfo);
connect(&m_futureWatcher, &QFutureWatcher<void>::finished, this, &PDFDocumentPropertiesDialog::onFontsFinished);
m_futureWatcher.setFuture(m_future);
}
void PDFDocumentPropertiesDialog::onFontsFinished()
{
if (!m_fontTreeWidgetItems.empty())
{
std::sort(m_fontTreeWidgetItems.begin(), m_fontTreeWidgetItems.end(), [](QTreeWidgetItem* left, QTreeWidgetItem* right) { return left->data(0, Qt::DisplayRole) < right->data(0, Qt::DisplayRole); });
for (QTreeWidgetItem* item : m_fontTreeWidgetItems)
{
ui->fontsTreeWidget->addTopLevelItem(item);
}
m_fontTreeWidgetItems.clear();
ui->fontsTreeWidget->collapseAll();
ui->fontsTreeWidget->expandToDepth(0);
ui->fontsTreeWidget->resizeColumnToContents(0);
}
}
void PDFDocumentPropertiesDialog::closeEvent(QCloseEvent* event)
{
// We must wait for finishing of font loading;
m_futureWatcher.waitForFinished();
// We must delete all font tree items, because of asynchronous signal sent
qDeleteAll(m_fontTreeWidgetItems);
m_fontTreeWidgetItems.clear();
BaseClass::closeEvent(event);
}
} // namespace pdfviewer

17
PdfForQtViewer/pdfdocumentpropertiesdialog.h
View File

@ -21,6 +21,10 @@
#include "pdfglobal.h"
#include <QDialog>
#include <QFuture>
#include <QFutureWatcher>
class QTreeWidgetItem;
namespace Ui
{
@ -50,18 +54,31 @@ class PDFDocumentPropertiesDialog : public QDialog
{
Q_OBJECT
private:
using BaseClass = QDialog;
public:
explicit PDFDocumentPropertiesDialog(const pdf::PDFDocument* document,
const PDFFileInfo* fileInfo,
QWidget* parent);
virtual ~PDFDocumentPropertiesDialog() override;
protected:
virtual void closeEvent(QCloseEvent* event) override;
private:
Ui::PDFDocumentPropertiesDialog* ui;
void initializeProperties(const pdf::PDFDocument* document);
void initializeFileInfoProperties(const PDFFileInfo* fileInfo);
void initializeSecurity(const pdf::PDFDocument* document);
void initializeFonts(const pdf::PDFDocument* document);
void onFontsFinished();
std::vector<QTreeWidgetItem*> m_fontTreeWidgetItems;
QFuture<void> m_future;
QFutureWatcher<void> m_futureWatcher;
};
} // namespace pdfviewer

44
PdfForQtViewer/pdfdocumentpropertiesdialog.ui
View File

@ -25,11 +25,11 @@
</attribute>
<layout class="QVBoxLayout" name="propertiesLayout" stretch="3,2">
<item>
<widget class="QGroupBox" name="documentPropertiesGroupBox">
<widget class="QGroupBox" name="propertiesGroupBox">
<property name="title">
<string>Properties</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<layout class="QVBoxLayout" name="propertiesGroupBoxLayout">
<item>
<widget class="QTreeWidget" name="propertiesTreeWidget">
<property name="columnCount">
@ -58,7 +58,7 @@
<property name="title">
<string>File Information</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<layout class="QVBoxLayout" name="fileInfoGroupBoxLayout">
<item>
<widget class="QTreeWidget" name="fileInfoTreeWidget">
<property name="columnCount">
@ -88,7 +88,7 @@
<attribute name="title">
<string>Security</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_4">
<layout class="QVBoxLayout" name="securityTabLayout">
<item>
<widget class="QGroupBox" name="securityGroupBox">
<property name="title">
@ -120,6 +120,42 @@
</item>
</layout>
</widget>
<widget class="QWidget" name="fontsTab">
<attribute name="title">
<string>Fonts</string>
</attribute>
<layout class="QVBoxLayout" name="fontsTabLayout">
<item>
<widget class="QGroupBox" name="fontsGroupBox">
<property name="title">
<string>Fonts</string>
</property>
<layout class="QVBoxLayout" name="fontsGroupBoxLayout">
<item>
<widget class="QTreeWidget" name="fontsTreeWidget">
<property name="columnCount">
<number>2</number>
</property>
<attribute name="headerVisible">
<bool>false</bool>
</attribute>
<column>
<property name="text">
<string notr="true">1</string>
</property>
</column>
<column>
<property name="text">
<string notr="true">2</string>
</property>
</column>
</widget>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
</widget>
</item>
<item>