vcl/inc/pdf/COSWriter.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #pragma once
  11
  12 #include <pdf/IPDFEncryptor.hxx>
  13 #include <vcl/pdfwriter.hxx>
  14
  15 namespace vcl::pdf
  16 {
  17 /** Writes the "Carousel" object structure (COS) to the string buffer.
  18  *
  19  * "Carousel" object structure (COS) is used by PDF.
  20  *
  21  * Structure elements like: objects, IDs, dictionaries, key/values, ...
  22  */
  23 class COSWriter
  24 {
  25     std::shared_ptr<IPDFEncryptor> mpPDFEncryptor;
  26     EncryptionParams maParams;
  27     OStringBuffer maLine;
  28     OStringBuffer& mrBuffer;
  29
  30     void appendLiteralString(const char* pStr, sal_Int32 nLength);
  31
  32 public:
  33     COSWriter(EncryptionParams aParams = EncryptionParams(),
  34               std::shared_ptr<IPDFEncryptor> const& pPDFEncryptor = nullptr)
  35         : mpPDFEncryptor(pPDFEncryptor)
  36         , maParams(std::move(aParams))
  37         , maLine(1024)
  38         , mrBuffer(maLine)
  39     {
  40     }
  41
  42     COSWriter(OStringBuffer& rBuffer, EncryptionParams aParams = EncryptionParams(),
  43               std::shared_ptr<IPDFEncryptor> const& pPDFEncryptor = nullptr)
  44         : mpPDFEncryptor(pPDFEncryptor)
  45         , maParams(std::move(aParams))
  46         , mrBuffer(rBuffer)
  47     {
  48     }
  49
  50     void startObject(sal_Int32 nObjectID)
  51     {
  52         mrBuffer.append(nObjectID);
  53         mrBuffer.append(" 0 obj\n");
  54     }
  55
  56     void endObject() { mrBuffer.append("endobj\n\n"); }
  57
  58     OStringBuffer& getLine() { return mrBuffer; }
  59
  60     void startDict() { mrBuffer.append("<<"); }
  61     void startDictWithKey(std::string_view key)
  62     {
  63         mrBuffer.append(key);
  64         mrBuffer.append("<<");
  65     }
  66     void endDict() { mrBuffer.append(">>\n"); }
  67
  68     void startStream() { mrBuffer.append("stream\n"); }
  69     void endStream() { mrBuffer.append("\nendstream\n"); }
  70
  71     void write(std::string_view key, std::string_view value)
  72     {
  73         mrBuffer.append(key);
  74         mrBuffer.append(value);
  75     }
  76
  77     void write(std::string_view key, sal_Int32 value)
  78     {
  79         mrBuffer.append(key);
  80         mrBuffer.append(" ");
  81         mrBuffer.append(value);
  82     }
  83
  84     void writeReference(sal_Int32 nObjectID)
  85     {
  86         mrBuffer.append(nObjectID);
  87         mrBuffer.append(" 0 R");
  88     }
  89
  90     void writeKeyAndReference(std::string_view key, sal_Int32 nObjectID)
  91     {
  92         mrBuffer.append(key);
  93         mrBuffer.append(" ");
  94         writeReference(nObjectID);
  95     }
  96
  97     void writeKeyAndUnicode(std::string_view key, OUString const& rString)
  98     {
  99         mrBuffer.append(key);
 100         writeUnicode(rString);
 101     }
 102
 103     void writeUnicode(OUString const& rString);
 104
 105     void writeKeyAndUnicodeEncrypt(std::string_view key, OUString const& rString, sal_Int32 nObject)
 106     {
 107         mrBuffer.append(key);
 108         writeUnicodeEncrypt(rString, nObject);
 109     }
 110
 111     void writeUnicodeEncrypt(OUString const& rString, sal_Int32 nObject);
 112
 113     void writeLiteral(std::string_view value)
 114     {
 115         mrBuffer.append("(");
 116         appendLiteralString(value.data(), value.size());
 117         mrBuffer.append(")");
 118     }
 119
 120     void writeKeyAndLiteral(std::string_view key, std::string_view value)
 121     {
 122         mrBuffer.append(key);
 123         writeLiteral(value);
 124     }
 125
 126     void writeLiteralEncrypt(std::u16string_view value, sal_Int32 nObject,
 127                              rtl_TextEncoding nEncoding = RTL_TEXTENCODING_ASCII_US);
 128
 129     void writeKeyAndLiteralEncrypt(std::string_view key, std::u16string_view value,
 130                                    sal_Int32 nObject,
 131                                    rtl_TextEncoding nEncoding = RTL_TEXTENCODING_ASCII_US)
 132     {
 133         mrBuffer.append(key);
 134         writeLiteralEncrypt(value, nObject, nEncoding);
 135     }
 136
 137     void writeLiteralEncrypt(std::string_view value, sal_Int32 nObject);
 138
 139     void writeKeyAndLiteralEncrypt(std::string_view key, std::string_view value, sal_Int32 nObject)
 140     {
 141         mrBuffer.append(key);
 142         writeLiteralEncrypt(value, nObject);
 143     }
 144
 145     void writeHexArray(std::string_view key, sal_uInt8* pData, size_t nSize)
 146     {
 147         mrBuffer.append(key);
 148         mrBuffer.append("<");
 149         COSWriter::appendHexArray(pData, nSize, mrBuffer);
 150         mrBuffer.append(">");
 151     }
 152
 153     template <typename T> static void appendHex(T nValue, OStringBuffer& rBuffer)
 154     {
 155         static constexpr const auto constHexDigits = std::to_array<char>(
 156             { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' });
 157         rBuffer.append(constHexDigits[(nValue >> 4) & 15]);
 158         rBuffer.append(constHexDigits[nValue & 15]);
 159     }
 160
 161     static void appendHexArray(sal_uInt8* pArray, size_t nSize, OStringBuffer& rBuffer)
 162     {
 163         for (size_t i = 0; i < nSize; i++)
 164             appendHex(pArray[i], rBuffer);
 165     }
 166
 167     static void appendUnicodeTextString(const OUString& rString, OStringBuffer& rBuffer);
 168     static void appendName(std::u16string_view rString, OStringBuffer& rBuffer);
 169     static void appendName(const char* pString, OStringBuffer& rBuffer);
 170 };
 171 }
 172
 173 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */