From 9c116b1efd19c1ccefa802dcbe448c262e531b94 Mon Sep 17 00:00:00 2001
From: jmsgrogan <grogan.ox@gmail.com>
Date: Sat, 1 Jan 2022 18:46:31 +0000
Subject: [PATCH] Add PDF writer.

---
 apps/CMakeLists.txt                       |  11 +-
 apps/xml-practice.cpp                     |  38 -------
 src/CMakeLists.txt                        |   3 +
 src/core/CMakeLists.txt                   |   2 +
 src/core/Dictionary.cpp                   |  56 ++++++++++
 src/core/Dictionary.h                     |  35 +++++++
 src/core/StringUtils.cpp                  |   9 ++
 src/core/StringUtils.h                    |   1 +
 src/database/DatabaseManager.cpp          |   5 +
 src/database/DatabaseManager.h            |  10 +-
 src/image/CMakeLists.txt                  |  21 ++++
 src/image/Image.cpp                       |  69 ++++++++++++
 src/image/Image.h                         |  35 +++++++
 src/image/PngWriter.cpp                   |  74 +++++++++++++
 src/image/PngWriter.h                     |  22 ++++
 src/network/NetworkManager.h              |   7 +-
 src/network/sockets/Socket.h              |   2 +-
 src/publishing/CMakeLists.txt             |  36 +++++++
 src/publishing/pdf/PdfDictionary.cpp      |  45 ++++++++
 src/publishing/pdf/PdfDictionary.h        |  10 ++
 src/publishing/pdf/PdfDocument.cpp        |  73 +++++++++++++
 src/publishing/pdf/PdfDocument.h          |  44 ++++++++
 src/publishing/pdf/PdfDocumentCatalog.cpp |  44 ++++++++
 src/publishing/pdf/PdfDocumentCatalog.h   |  23 ++++
 src/publishing/pdf/PdfObject.cpp          |  58 +++++++++++
 src/publishing/pdf/PdfObject.h            |  40 +++++++
 src/publishing/pdf/PdfOutline.cpp         |  40 +++++++
 src/publishing/pdf/PdfOutline.h           |  26 +++++
 src/publishing/pdf/PdfPage.cpp            |   0
 src/publishing/pdf/PdfPage.h              | 121 ++++++++++++++++++++++
 src/publishing/pdf/PdfPageTree.cpp        |  37 +++++++
 src/publishing/pdf/PdfPageTree.h          |  23 ++++
 src/publishing/pdf/PdfStream.cpp          |  36 +++++++
 src/publishing/pdf/PdfStream.h            |  19 ++++
 src/publishing/pdf/PdfWriter.cpp          |  12 +++
 src/publishing/pdf/PdfWriter.h            |  13 +++
 src/publishing/pdf/PdfXRefTable.cpp       |  68 ++++++++++++
 src/publishing/pdf/PdfXRefTable.h         |  37 +++++++
 src/video/CMakeLists.txt                  |  30 ++++++
 src/video/FfmegInterface.cpp              | 118 +++++++++++++++++++++
 src/video/FfmpegInterface.h               |  15 +++
 src/video/Video.cpp                       |  16 +++
 src/video/Video.h                         |  18 ++++
 src/web/CMakeLists.txt                    |   4 +
 src/web/html/HtmlDocument.cpp             |  16 ++-
 src/web/html/HtmlDocument.h               |   5 +-
 src/web/html/HtmlDomManager.h             |  15 +++
 src/web/html/HtmlElement.cpp              |   2 +-
 src/web/html/HtmlElement.h                |   7 +-
 src/web/html/HtmlWriter.cpp               |  53 +++++++++-
 src/web/html/HtmlWriter.h                 |   7 +-
 src/web/html/elements/HtmlBodyElement.h   |  12 +++
 src/web/html/elements/HtmlHeadElement.h   |  12 +++
 src/web/markdown/MarkdownParser.cpp       |  19 +++-
 src/web/markdown/MarkdownParser.h         |  22 +++-
 src/web/xml/XmlParser.cpp                 |  40 ++++---
 src/web/xml/XmlParser.h                   |   4 +-
 src/web/xml/XmlWriter.cpp                 |  66 +++++++++++-
 src/web/xml/XmlWriter.h                   |   7 +-
 src/web/xml/xml-elements/XmlElement.cpp   |  10 ++
 src/web/xml/xml-elements/XmlElement.h     |  20 ++--
 src/web/xml/xml-elements/XmlProlog.h      |   3 +-
 test/CMakeLists.txt                       |  27 ++++-
 test/audio/TestAudioWriter.cpp            |  10 +-
 test/data/sample_markdown.md              |  20 ++++
 test/database/TestDatabase.cpp            |  12 +++
 test/image/TestPngWriter.cpp              |  31 ++++++
 test/ipc/TestDbus.cpp                     |   8 ++
 test/publishing/TestPdfWriter.cpp         |  18 ++++
 test/video/TestVideoDecoder.cpp           |  25 +++++
 test/web/TestMarkdownParser.cpp           |  25 +++++
 test/web/TestXmlParser.cpp                |  31 ++++++
 72 files changed, 1819 insertions(+), 114 deletions(-)
 delete mode 100644 apps/xml-practice.cpp
 create mode 100644 src/core/Dictionary.cpp
 create mode 100644 src/core/Dictionary.h
 create mode 100644 src/image/CMakeLists.txt
 create mode 100644 src/image/Image.cpp
 create mode 100644 src/image/Image.h
 create mode 100644 src/image/PngWriter.cpp
 create mode 100644 src/image/PngWriter.h
 create mode 100644 src/publishing/CMakeLists.txt
 create mode 100644 src/publishing/pdf/PdfDictionary.cpp
 create mode 100644 src/publishing/pdf/PdfDictionary.h
 create mode 100644 src/publishing/pdf/PdfDocument.cpp
 create mode 100644 src/publishing/pdf/PdfDocument.h
 create mode 100644 src/publishing/pdf/PdfDocumentCatalog.cpp
 create mode 100644 src/publishing/pdf/PdfDocumentCatalog.h
 create mode 100644 src/publishing/pdf/PdfObject.cpp
 create mode 100644 src/publishing/pdf/PdfObject.h
 create mode 100644 src/publishing/pdf/PdfOutline.cpp
 create mode 100644 src/publishing/pdf/PdfOutline.h
 create mode 100644 src/publishing/pdf/PdfPage.cpp
 create mode 100644 src/publishing/pdf/PdfPage.h
 create mode 100644 src/publishing/pdf/PdfPageTree.cpp
 create mode 100644 src/publishing/pdf/PdfPageTree.h
 create mode 100644 src/publishing/pdf/PdfStream.cpp
 create mode 100644 src/publishing/pdf/PdfStream.h
 create mode 100644 src/publishing/pdf/PdfWriter.cpp
 create mode 100644 src/publishing/pdf/PdfWriter.h
 create mode 100644 src/publishing/pdf/PdfXRefTable.cpp
 create mode 100644 src/publishing/pdf/PdfXRefTable.h
 create mode 100644 src/video/CMakeLists.txt
 create mode 100644 src/video/FfmegInterface.cpp
 create mode 100644 src/video/FfmpegInterface.h
 create mode 100644 src/video/Video.cpp
 create mode 100644 src/video/Video.h
 create mode 100644 test/data/sample_markdown.md
 create mode 100644 test/database/TestDatabase.cpp
 create mode 100644 test/image/TestPngWriter.cpp
 create mode 100644 test/ipc/TestDbus.cpp
 create mode 100644 test/publishing/TestPdfWriter.cpp
 create mode 100644 test/video/TestVideoDecoder.cpp
 create mode 100644 test/web/TestMarkdownParser.cpp
 create mode 100644 test/web/TestXmlParser.cpp

diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt
index 8c335f3..2b2fc4a 100644
--- a/apps/CMakeLists.txt
+++ b/apps/CMakeLists.txt
@@ -25,15 +25,6 @@ target_include_directories(sample_console PUBLIC
                           )
 target_link_libraries(sample_console PUBLIC console core network 
     database geometry audio web)
-    
-# Xml practice
-add_executable(xml_practice xml-practice.cpp)
-target_include_directories(xml_practice PUBLIC
-                          "${PROJECT_SOURCE_DIR}/src/core"
-                          "${PROJECT_SOURCE_DIR}/src/web/xml"
-                          )
-target_link_libraries(xml_practice PUBLIC core web)
 
 set_property(TARGET sample_console PROPERTY FOLDER apps)
-set_property(TARGET sample_gui PROPERTY FOLDER apps)
-set_property(TARGET xml_practice PROPERTY FOLDER apps)
\ No newline at end of file
+set_property(TARGET sample_gui PROPERTY FOLDER apps)
\ No newline at end of file
diff --git a/apps/xml-practice.cpp b/apps/xml-practice.cpp
deleted file mode 100644
index 913510d..0000000
--- a/apps/xml-practice.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <filesystem>
-#include <iostream>
-#include <fstream>
-#include "CommandLineArgs.h"
-#include "XmlParser.h"
-
-int main(int argc, char *argv[])
-{
-    CommandLineArgs command_line_args;
-    command_line_args.Process(argc, argv);
-
-    if(command_line_args.GetNumberOfArgs() < 2)
-    {
-        std::cerr << "Expected a filepath argument" << std::endl;
-        return -1;
-    }
-
-    XmlParser parser;
-    const auto filepath = command_line_args.GetArg(1);
-
-    if(!std::filesystem::exists(filepath))
-    {
-        std::cerr << "Couldn't find file: " << filepath << std::endl;
-        return -1;
-    }
-
-    std::ifstream xml_file;
-    xml_file.open(filepath, std::ifstream::in);
-    while(xml_file.good())
-    {
-        std::string line;
-        std::getline(xml_file, line);
-        parser.ProcessLine(line);
-    }
-    xml_file.close();
-
-    return 0;
-}
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 294fd2f..f6e0469 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -3,9 +3,12 @@ add_subdirectory(database)
 add_subdirectory(network)
 add_subdirectory(geometry)
 add_subdirectory(audio)
+add_subdirectory(image)
 add_subdirectory(console)
 add_subdirectory(client)
 add_subdirectory(graphics)
+add_subdirectory(publishing)
+add_subdirectory(video)
 add_subdirectory(windows)
 add_subdirectory(web)
 add_subdirectory(ui_elements)
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index c19faf8..c6d3a5e 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -1,5 +1,6 @@
 list(APPEND core_HEADERS
     AbstractApp.h
+    Dictionary.h
     Event.h
     Color.h
     CommandLineArgs.h
@@ -12,6 +13,7 @@ list(APPEND core_HEADERS
 
 list(APPEND core_LIB_INCLUDES 
     Event.cpp
+    Dictionary.cpp
     Color.cpp
     CommandLineArgs.cpp
     loggers/FileLogger.cpp
diff --git a/src/core/Dictionary.cpp b/src/core/Dictionary.cpp
new file mode 100644
index 0000000..720a75a
--- /dev/null
+++ b/src/core/Dictionary.cpp
@@ -0,0 +1,56 @@
+#include "Dictionary.h"
+
+bool Dictionary::HasKey(const std::string& key) const
+{
+    return HasStringKey(key) || HasDictKey(key);
+}
+
+bool Dictionary::HasStringKey(const std::string& key) const
+{
+    return mStringData.count(key) > 0;
+}
+
+bool Dictionary::HasDictKey(const std::string& key) const
+{
+    return mDictData.count(key) > 0;
+}
+
+std::vector<std::string> Dictionary::GetStringKeys() const
+{
+    std::vector<std::string> keys;
+    for (const auto& item : mStringData)
+    {
+        keys.push_back(item.first);
+    }
+    return keys;
+}
+
+std::vector<std::string> Dictionary::GetDictKeys() const
+{
+    std::vector<std::string> keys;
+    for (const auto& item : mDictData)
+    {
+        keys.push_back(item.first);
+    }
+    return keys;
+}
+
+Dictionary* Dictionary::GetDict(const std::string& key) const
+{
+    return mDictData.at(key).get();
+}
+
+std::string Dictionary::GetItem(const std::string& key) const
+{
+    return mStringData.at(key);
+}
+
+void Dictionary::AddStringItem(const std::string& key, const std::string& item)
+{
+    mStringData[key] = item;
+}
+
+void Dictionary::AddDictItem(const std::string& key, std::unique_ptr<Dictionary> dict)
+{
+    mDictData[key] = std::move(dict);
+}
diff --git a/src/core/Dictionary.h b/src/core/Dictionary.h
new file mode 100644
index 0000000..8399608
--- /dev/null
+++ b/src/core/Dictionary.h
@@ -0,0 +1,35 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+
+class Dictionary
+{
+public:
+    Dictionary() = default;
+    virtual ~Dictionary() = default;
+
+    bool HasKey(const std::string& key) const;
+
+    bool HasStringKey(const std::string& key) const;
+
+    bool HasDictKey(const std::string& key) const;
+
+    Dictionary* GetDict(const std::string& key) const;
+
+    std::vector<std::string> GetDictKeys() const;
+
+    std::vector<std::string> GetStringKeys() const;
+
+    std::string GetItem(const std::string& key) const;
+
+    void AddStringItem(const std::string& key, const std::string& item);
+
+    void AddDictItem(const std::string& key, std::unique_ptr<Dictionary> dict);
+
+protected:
+
+    std::map<std::string, std::string> mStringData;
+    std::map<std::string, std::unique_ptr<Dictionary> > mDictData;
+};
diff --git a/src/core/StringUtils.cpp b/src/core/StringUtils.cpp
index 547f2a7..da21622 100644
--- a/src/core/StringUtils.cpp
+++ b/src/core/StringUtils.cpp
@@ -1,6 +1,8 @@
 #include "StringUtils.h"
 #include <locale>
 #include <algorithm>
+#include <sstream>
+#include <iomanip>
 
 #ifdef _WIN32
 #include "Windows.h"
@@ -45,3 +47,10 @@ std::string StringUtils::convert(const std::wstring& input)
     throw std::logic_error("Not implemented");
 #endif
 }
+
+std::string StringUtils::ToPaddedString(unsigned numBytes, unsigned entry)
+{
+    std::stringstream sstr;
+    sstr << std::setfill('0') << std::setw(numBytes) << entry;
+    return sstr.str();
+}
diff --git a/src/core/StringUtils.h b/src/core/StringUtils.h
index 2a70f79..fff9b36 100644
--- a/src/core/StringUtils.h
+++ b/src/core/StringUtils.h
@@ -18,4 +18,5 @@ public:
     static bool IsSpace(char c);
     static std::string ToLower(const std::string& s);
     static std::string convert(const std::wstring& input);
+    static std::string ToPaddedString(unsigned numBytes, unsigned entry);
 };
diff --git a/src/database/DatabaseManager.cpp b/src/database/DatabaseManager.cpp
index e89653b..025f790 100644
--- a/src/database/DatabaseManager.cpp
+++ b/src/database/DatabaseManager.cpp
@@ -27,6 +27,11 @@ void DatabaseManager::CreateDatabase(const std::string& path)
     mDatabaseInterface->Open(mDatabase);
 }
 
+void DatabaseManager::Run(const std::string& statement)
+{
+    mDatabaseInterface->Run(statement);
+}
+
 void DatabaseManager::OnShutDown()
 {
     if(mDatabaseInterface)
diff --git a/src/database/DatabaseManager.h b/src/database/DatabaseManager.h
index fa156fa..239763e 100644
--- a/src/database/DatabaseManager.h
+++ b/src/database/DatabaseManager.h
@@ -7,10 +7,6 @@
 
 class DatabaseManager
 {
-
-    DatabasePtr mDatabase;
-    SqliteInterfacePtr mDatabaseInterface;
-
 public:
 
     DatabaseManager();
@@ -21,7 +17,13 @@ public:
 
     void CreateDatabase(const std::string& path);
 
+    void Run(const std::string& statement);
+
     void OnShutDown();
+
+private:
+    DatabasePtr mDatabase;
+    SqliteInterfacePtr mDatabaseInterface;
 };
 
 using DatabaseManagerPtr = std::unique_ptr<DatabaseManager>;
diff --git a/src/image/CMakeLists.txt b/src/image/CMakeLists.txt
new file mode 100644
index 0000000..d9b9bd4
--- /dev/null
+++ b/src/image/CMakeLists.txt
@@ -0,0 +1,21 @@
+list(APPEND image_HEADERS 
+    Image.h
+    PngWriter.h
+    )
+
+list(APPEND image_LIB_INCLUDES 
+    Image.cpp
+    PngWriter.cpp
+    )
+
+add_library(image SHARED ${image_LIB_INCLUDES} ${image_HEADERS})
+
+target_include_directories(image PUBLIC
+                          "${CMAKE_CURRENT_SOURCE_DIR}"
+                          )
+set_target_properties( image PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )   
+
+find_package(PNG REQUIRED)                       
+target_link_libraries( image PUBLIC PNG::PNG)
+
+set_property(TARGET image PROPERTY FOLDER src)
\ No newline at end of file
diff --git a/src/image/Image.cpp b/src/image/Image.cpp
new file mode 100644
index 0000000..68a821d
--- /dev/null
+++ b/src/image/Image.cpp
@@ -0,0 +1,69 @@
+#include "Image.h"
+
+Image::Image(unsigned width, unsigned height)
+    : mWidth(width),
+      mHeight(height)
+{
+
+}
+
+std::unique_ptr<Image> Image::Create(unsigned width, unsigned height)
+{
+    return std::make_unique<Image>(width, height);
+}
+
+unsigned Image::GetBytesPerRow() const
+{
+    const auto bitsPerEntry = mBitDepth <= 8 ? 1 : 2;
+    return mWidth * mNumChannels *bitsPerEntry;
+}
+
+unsigned Image::GetWidth() const
+{
+    return mWidth;
+}
+
+unsigned Image::GetHeight() const
+{
+    return mHeight;
+}
+
+unsigned Image::GetBitDepth() const
+{
+    return mBitDepth;
+}
+
+unsigned char Image::GetByte(unsigned idx, unsigned jdx) const
+{
+    return mData[jdx*GetBytesPerRow() + idx];
+}
+
+unsigned Image::GetNumChannels() const
+{
+    return mNumChannels;
+}
+
+void Image::SetData(const std::vector<unsigned char>& data)
+{
+    mData = data;
+}
+
+void Image::SetWidth(unsigned width)
+{
+    mWidth = width;
+}
+
+void Image::SetHeight(unsigned height)
+{
+    mHeight = height;
+}
+
+void Image::SetBitDepth(unsigned bitDepth)
+{
+    mBitDepth = bitDepth;
+}
+
+void Image::SetNumChannels(unsigned numChannels)
+{
+    mNumChannels = numChannels;
+}
diff --git a/src/image/Image.h b/src/image/Image.h
new file mode 100644
index 0000000..a19241f
--- /dev/null
+++ b/src/image/Image.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+
+class Image
+{
+public:
+
+    Image(unsigned width, unsigned height);
+    static std::unique_ptr<Image> Create(unsigned width, unsigned height);
+
+    unsigned GetBytesPerRow() const;
+    unsigned GetWidth() const;
+    unsigned GetHeight() const;
+    unsigned GetBitDepth() const;
+    unsigned GetNumChannels() const;
+    unsigned char GetByte(unsigned idx, unsigned jdx) const;
+
+    void SetData(const std::vector<unsigned char>& data);
+    void SetWidth(unsigned width);
+    void SetHeight(unsigned height);
+    void SetBitDepth(unsigned bitDepth);
+    void SetNumChannels(unsigned numChannels);
+
+private:
+    unsigned mWidth{1};
+    unsigned mHeight{1};
+    unsigned mBitDepth{8};
+    unsigned mNumChannels{1};
+    std::vector<unsigned char> mData;
+};
+
+using ImagePtr = std::unique_ptr<Image>;
diff --git a/src/image/PngWriter.cpp b/src/image/PngWriter.cpp
new file mode 100644
index 0000000..5650573
--- /dev/null
+++ b/src/image/PngWriter.cpp
@@ -0,0 +1,74 @@
+#include "PngWriter.h"
+
+#include "Image.h"
+
+#include <png.h>
+#include <stdio.h>
+
+std::unique_ptr<PngWriter> PngWriter::Create()
+{
+    return std::make_unique<PngWriter>();
+}
+
+void PngWriter::SetPath(const std::string& path)
+{
+    mPath = path;
+}
+
+void PngWriter::Write(const std::unique_ptr<Image>& image) const
+{
+    auto fp = fopen(mPath.c_str(), "wb");
+
+    auto png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+    auto info_ptr = png_create_info_struct(png_ptr);
+
+    if (setjmp(png_jmpbuf(png_ptr)))
+    {
+        return;
+    }
+    png_init_io(png_ptr, fp);
+
+
+    if (setjmp(png_jmpbuf(png_ptr)))
+    {
+        return;
+    }
+    auto color_type = PNG_COLOR_TYPE_RGB;
+    png_set_IHDR(png_ptr, info_ptr, image->GetWidth(), image->GetHeight(),
+                 image->GetBitDepth(), color_type, PNG_INTERLACE_NONE,
+                 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+    png_write_info(png_ptr, info_ptr);
+
+    if (setjmp(png_jmpbuf(png_ptr)))
+    {
+        return;
+    }
+
+    png_bytep* row_pointers = (png_bytep*)malloc(sizeof(png_bytep) * image->GetHeight());
+    auto row_size = image->GetBytesPerRow();
+    for(unsigned jdx=0;jdx<image->GetHeight();jdx++)
+    {
+        row_pointers[jdx]=(png_byte*)malloc(sizeof(png_byte)*row_size);
+        for(unsigned idx=0;idx<row_size;idx++)
+        {
+            row_pointers[jdx][idx] = image->GetByte(idx, jdx);
+        }
+    }
+    png_write_image(png_ptr, row_pointers);
+    if (setjmp(png_jmpbuf(png_ptr)))
+    {
+        return;
+    }
+
+    png_write_end(png_ptr, nullptr);
+
+    for (unsigned y=0; y<image->GetHeight(); y++)
+    {
+        free(row_pointers[y]);
+    }
+    free(row_pointers);
+
+    fclose(fp);
+    return;
+}
diff --git a/src/image/PngWriter.h b/src/image/PngWriter.h
new file mode 100644
index 0000000..a31752d
--- /dev/null
+++ b/src/image/PngWriter.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+class Image;
+
+class PngWriter
+{
+public:
+    static std::unique_ptr<PngWriter> Create();
+
+    void SetPath(const std::string& path);
+
+    void Write(const std::unique_ptr<Image>& image) const;
+
+private:
+
+    std::string mPath;
+};
+
+using PngWriterPtr = std::unique_ptr<PngWriter>;
diff --git a/src/network/NetworkManager.h b/src/network/NetworkManager.h
index 0e6c99d..bd4e05d 100644
--- a/src/network/NetworkManager.h
+++ b/src/network/NetworkManager.h
@@ -8,9 +8,6 @@
 
 class NetworkManager
 {
-    std::vector<SocketPtr> mActiveSockets;
-    ISocketInterfaceUPtr mSocketInterface;
-
 public:
 
     NetworkManager();
@@ -24,6 +21,10 @@ public:
     void RunHttpServer();
 
     void ShutDown();
+
+private:
+    std::vector<SocketPtr> mActiveSockets;
+    ISocketInterfaceUPtr mSocketInterface;
 };
 
 using NetworkManagerUPtr = std::unique_ptr<NetworkManager>;
diff --git a/src/network/sockets/Socket.h b/src/network/sockets/Socket.h
index 9bc421b..f6756e1 100644
--- a/src/network/sockets/Socket.h
+++ b/src/network/sockets/Socket.h
@@ -29,7 +29,7 @@ public:
 private:
 
     SocketHandle mHandle;
-    unsigned mPort;
+    unsigned mPort{0};
     std::string mMessage;
 };
 
diff --git a/src/publishing/CMakeLists.txt b/src/publishing/CMakeLists.txt
new file mode 100644
index 0000000..a962bab
--- /dev/null
+++ b/src/publishing/CMakeLists.txt
@@ -0,0 +1,36 @@
+list(APPEND publishing_HEADERS 
+    pdf/PdfDocument.h
+    pdf/PdfDocumentCatalog.h
+    pdf/PdfDictionary.h
+    pdf/PdfObject.h
+    pdf/PdfOutline.h
+    pdf/PdfPageTree.h
+    pdf/PdfPage.h
+    pdf/PdfStream.h
+    pdf/PdfXRefTable.h
+    pdf/PdfWriter.h
+    )
+
+list(APPEND publishing_LIB_INCLUDES 
+    pdf/PdfDocument.cpp
+    pdf/PdfDocumentCatalog.cpp
+    pdf/PdfDictionary.cpp
+    pdf/PdfObject.cpp
+    pdf/PdfOutline.cpp
+    pdf/PdfPageTree.cpp
+    pdf/PdfPage.cpp
+    pdf/PdfStream.cpp
+    pdf/PdfXRefTable.cpp
+    pdf/PdfWriter.cpp
+    )
+
+add_library(publishing SHARED ${publishing_LIB_INCLUDES} ${publishing_INCLUDES} ${publishing_HEADERS})
+
+target_include_directories(publishing PUBLIC
+                          "${CMAKE_CURRENT_SOURCE_DIR}"
+                          "${CMAKE_CURRENT_SOURCE_DIR}/pdf"
+                          )
+set_target_properties( publishing PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )                          
+target_link_libraries( publishing PUBLIC core)
+
+set_property(TARGET publishing PROPERTY FOLDER src)
\ No newline at end of file
diff --git a/src/publishing/pdf/PdfDictionary.cpp b/src/publishing/pdf/PdfDictionary.cpp
new file mode 100644
index 0000000..d5da237
--- /dev/null
+++ b/src/publishing/pdf/PdfDictionary.cpp
@@ -0,0 +1,45 @@
+#include "PdfDictionary.h"
+
+std::string PdfDictionary::ToString() const
+{
+    const auto keys = GetStringKeys();
+    if (keys.empty())
+    {
+        return "";
+    }
+
+    std::string content = "  <<";
+    bool first = true;
+    auto ending = keys.size() == 1 ? "" : "\n";
+    for (const auto& key : keys)
+    {
+        if (first)
+        {
+            content += " /" + key + " " + GetItem(key) + ending;
+            first = false;
+        }
+        else
+        {
+            content += "     /" + key + " " + GetItem(key) + ending;
+        }
+    }
+
+    const auto dictKeys = GetDictKeys();
+    ending = dictKeys.size() == 1 ? "" : "\n";
+    for (const auto& key : GetDictKeys())
+    {
+        auto pdfDict = dynamic_cast<PdfDictionary*>(GetDict(key));
+        if (first)
+        {
+            content += " /" + key + " " + pdfDict->ToString() + ending;
+            first = false;
+        }
+        else
+        {
+            content += "     /" + key + " " + pdfDict->ToString() + ending;
+        }
+    }
+
+    content += "  >>\n";
+    return content;
+}
diff --git a/src/publishing/pdf/PdfDictionary.h b/src/publishing/pdf/PdfDictionary.h
new file mode 100644
index 0000000..9987ac8
--- /dev/null
+++ b/src/publishing/pdf/PdfDictionary.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "Dictionary.h"
+
+class PdfDictionary : public Dictionary
+{
+public:
+
+    std::string ToString() const;
+};
diff --git a/src/publishing/pdf/PdfDocument.cpp b/src/publishing/pdf/PdfDocument.cpp
new file mode 100644
index 0000000..eb18bea
--- /dev/null
+++ b/src/publishing/pdf/PdfDocument.cpp
@@ -0,0 +1,73 @@
+#include "PdfDocument.h"
+
+#include "PdfObject.h"
+#include "PdfDocumentCatalog.h"
+#include "PdfPageTree.h"
+#include "PdfPage.h"
+#include "PdfOutline.h"
+#include "PdfXRefTable.h"
+
+PdfDocument::PdfDocument()
+{
+    mXRefTable = std::make_unique<PdfXRefTable>();
+    mCatalog = std::make_unique<PdfDocumentCatalog>();
+}
+
+PdfDocument::~PdfDocument()
+{
+
+}
+
+std::string PdfDocument::ToString()
+{
+    IndexObjects();
+    auto content = GetHeaderString();
+    content += GetBodyString();
+
+    content += GetXRefString();
+
+    content += GetTrailerString();
+
+    content += "%%EOF\n";
+    return content;
+}
+
+std::string PdfDocument::GetHeaderString()
+{
+    auto content = "%PDF-" + mVersion + "\n";
+    mXRefOffset = content.size();
+    mXRefTable->AddRecord(content.size(), 65535, true);
+    return content;
+}
+
+std::string PdfDocument::GetBodyString()
+{
+    const auto content = mCatalog->ToString(mXRefTable.get());
+    mXRefOffset += content.size();
+    return content;
+}
+
+std::string PdfDocument::GetXRefString()
+{
+    return mXRefTable->ToString();
+}
+
+std::string PdfDocument::GetTrailerString()
+{
+    const auto numObjects = mXRefTable->GetNumEntries();
+    mTrailer.AddStringItem("Size", std::to_string(numObjects));
+    mTrailer.AddStringItem("Root", mCatalog->GetRefString());
+
+    std::string content = "trailer\n";
+    content += mTrailer.ToString();
+
+    content += "startxref\n";
+    content += std::to_string(mXRefOffset) + "\n";
+    return content;
+}
+
+void PdfDocument::IndexObjects()
+{
+    mCatalog->IndexObjects(0);
+}
+
diff --git a/src/publishing/pdf/PdfDocument.h b/src/publishing/pdf/PdfDocument.h
new file mode 100644
index 0000000..5139c0d
--- /dev/null
+++ b/src/publishing/pdf/PdfDocument.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "PdfDictionary.h"
+#include "StringUtils.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class PdfDocumentCatalog;
+using PdfDocumentCatalogPtr = std::unique_ptr<PdfDocumentCatalog>;
+
+class PdfXRefTable;
+using PdfXRefTablePtr = std::unique_ptr<PdfXRefTable>;
+
+class PdfDocument
+{
+
+public:
+    PdfDocument();
+    ~PdfDocument();
+
+    std::string ToString();
+
+private:
+    std::string GetHeaderString();
+
+    std::string GetTrailerString();
+
+    std::string GetBodyString();
+
+    std::string GetXRefString();
+
+    void IndexObjects();
+
+private:
+    PdfDictionary mTrailer;
+    std::string mVersion {"1.7"};
+    PdfXRefTablePtr mXRefTable;
+    unsigned mXRefOffset{0};
+    PdfDocumentCatalogPtr mCatalog;
+};
+
+using PdfDocumentPtr = std::unique_ptr<PdfDocument>;
diff --git a/src/publishing/pdf/PdfDocumentCatalog.cpp b/src/publishing/pdf/PdfDocumentCatalog.cpp
new file mode 100644
index 0000000..6a9bdd3
--- /dev/null
+++ b/src/publishing/pdf/PdfDocumentCatalog.cpp
@@ -0,0 +1,44 @@
+#include "PdfDocumentCatalog.h"
+
+#include "PdfOutline.h"
+#include "PdfPageTree.h"
+#include "PdfPage.h"
+#include "PdfXRefTable.h"
+
+PdfDocumentCatalog::PdfDocumentCatalog()
+    : PdfObject()
+{
+    mOutlines = std::make_unique<PdfOutlineCollection>();
+    mPages = std::make_unique<PdfPageTree>();
+}
+
+unsigned PdfDocumentCatalog::IndexObjects(unsigned count)
+{
+    auto newCount = count + 1;
+    mObjectNumber = newCount;
+    auto objectCount = mOutlines->IndexObjects(mObjectNumber);
+    objectCount = mPages->IndexObjects(objectCount);
+    return objectCount;
+}
+
+std::string PdfDocumentCatalog::ToString(PdfXRefTable* xRefTable)
+{
+    UpdateDictionary();
+    auto content = GetStringPrefix();
+    content += mDictionary.ToString();
+    content += GetStringSuffix();
+    xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+
+    content += mOutlines->ToString(xRefTable);
+
+    content += mPages->ToString(xRefTable);
+
+    return content;
+}
+
+void PdfDocumentCatalog::UpdateDictionary()
+{
+    mDictionary.AddStringItem("Type", "/Catalog");
+    mDictionary.AddStringItem("Outlines", mOutlines->GetRefString());
+    mDictionary.AddStringItem("Pages", mPages->GetRefString());
+}
diff --git a/src/publishing/pdf/PdfDocumentCatalog.h b/src/publishing/pdf/PdfDocumentCatalog.h
new file mode 100644
index 0000000..d2665d6
--- /dev/null
+++ b/src/publishing/pdf/PdfDocumentCatalog.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "PdfObject.h"
+
+class PdfPageTree;
+class PdfOutlineCollection;
+
+class PdfDocumentCatalog : public PdfObject
+{
+public:
+
+    PdfDocumentCatalog();
+
+    unsigned IndexObjects(unsigned count) override;
+
+    std::string ToString(PdfXRefTable* xRefTable) override;
+
+private:
+    void UpdateDictionary() override;
+
+    std::unique_ptr<PdfOutlineCollection> mOutlines;
+    std::unique_ptr<PdfPageTree> mPages;
+};
diff --git a/src/publishing/pdf/PdfObject.cpp b/src/publishing/pdf/PdfObject.cpp
new file mode 100644
index 0000000..26ba0ca
--- /dev/null
+++ b/src/publishing/pdf/PdfObject.cpp
@@ -0,0 +1,58 @@
+#include "PdfObject.h"
+
+#include "PdfDictionary.h"
+#include "PdfXRefTable.h"
+
+std::string PdfObject::ToString(PdfXRefTable* xRefTable)
+{
+    UpdateDictionary();
+
+    auto content = GetStringPrefix();
+    content += mDictionary.ToString();
+    content += GetStringSuffix();
+
+    xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+    return content;
+}
+
+void PdfObject::UpdateDictionary()
+{
+
+}
+
+std::string PdfObject::GetStringSuffix() const
+{
+    return "endobj\n\n";
+}
+
+unsigned PdfObject::IndexObjects(unsigned count)
+{
+    const auto newCount = count + 1;
+    mObjectNumber = newCount;
+    return newCount;
+}
+
+void PdfObject::SetObjectNumber(unsigned num)
+{
+    mObjectNumber = num;
+}
+
+void PdfObject::SetGenerationNumber(unsigned num)
+{
+    mGenerationNumber = num;
+}
+
+std::string PdfObject::GetStringPrefix() const
+{
+    return std::to_string(mObjectNumber) + " " + std::to_string(mGenerationNumber) + " obj\n";
+}
+
+std::string PdfObject::GetRefString() const
+{
+    return std::to_string(mObjectNumber) + " " + std::to_string(mGenerationNumber) + " R";
+}
+
+bool PdfObject::IsFree() const
+{
+    return mIsFree;
+}
diff --git a/src/publishing/pdf/PdfObject.h b/src/publishing/pdf/PdfObject.h
new file mode 100644
index 0000000..67be2c6
--- /dev/null
+++ b/src/publishing/pdf/PdfObject.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "PdfDictionary.h"
+
+#include <memory>
+#include <string>
+
+class PdfXRefTable;
+
+class PdfObject
+{
+public:
+    virtual ~PdfObject() = default;
+
+    std::string GetStringPrefix() const;
+
+    std::string GetStringSuffix() const;
+
+    std::string GetRefString() const;
+
+    virtual unsigned IndexObjects(unsigned count);
+
+    bool IsFree() const;
+
+    virtual std::string ToString(PdfXRefTable* xRefTable);
+
+    void SetObjectNumber(unsigned num);
+
+    void SetGenerationNumber(unsigned num);
+
+protected:
+
+    virtual void UpdateDictionary();
+
+    unsigned mObjectNumber{0};
+    unsigned mGenerationNumber{0};
+    PdfDictionary mDictionary;
+    bool mIsFree {false};
+};
+using PdfObjectPtr = std::unique_ptr<PdfObject>;
diff --git a/src/publishing/pdf/PdfOutline.cpp b/src/publishing/pdf/PdfOutline.cpp
new file mode 100644
index 0000000..5b83595
--- /dev/null
+++ b/src/publishing/pdf/PdfOutline.cpp
@@ -0,0 +1,40 @@
+#include "PdfOutline.h"
+
+#include "PdfXRefTable.h"
+
+std::string PdfOutline::ToString(PdfXRefTable* xRefTable)
+{
+    mDictionary.AddStringItem("Type", "/Outline");
+    auto content = GetStringPrefix();
+    content += mDictionary.ToString();
+    content += GetStringSuffix();
+    xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+    return content;
+}
+
+unsigned PdfOutlineCollection::IndexObjects(unsigned count)
+{
+    auto newCount = count + 1;
+    mObjectNumber = newCount;
+    for (const auto& outline : mOutlines)
+    {
+        newCount = outline->IndexObjects(newCount);
+    }
+    return newCount;
+}
+
+std::string PdfOutlineCollection::ToString(PdfXRefTable* xRefTable)
+{
+    UpdateDictionary();
+    std::string content = GetStringPrefix();
+    content += mDictionary.ToString();
+    content += GetStringSuffix();
+    xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+    return content;
+}
+
+void PdfOutlineCollection::UpdateDictionary()
+{
+    mDictionary.AddStringItem("Type", "/Outlines");
+    mDictionary.AddStringItem("Count", std::to_string(mOutlines.size()));
+}
diff --git a/src/publishing/pdf/PdfOutline.h b/src/publishing/pdf/PdfOutline.h
new file mode 100644
index 0000000..1d5e257
--- /dev/null
+++ b/src/publishing/pdf/PdfOutline.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "PdfObject.h"
+
+#include <vector>
+
+class PdfOutline : public PdfObject
+{
+public:
+    std::string ToString(PdfXRefTable* xRefTable) override;
+};
+using PdfOutlinePtr = std::unique_ptr<PdfOutline>;
+
+class PdfOutlineCollection : public PdfObject
+{
+public:
+
+    unsigned IndexObjects(unsigned count) override;
+
+    std::string ToString(PdfXRefTable* xRefTable) override;
+
+    void UpdateDictionary();
+
+private:
+    std::vector<PdfOutlinePtr> mOutlines;
+};
diff --git a/src/publishing/pdf/PdfPage.cpp b/src/publishing/pdf/PdfPage.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/src/publishing/pdf/PdfPage.h b/src/publishing/pdf/PdfPage.h
new file mode 100644
index 0000000..e022c76
--- /dev/null
+++ b/src/publishing/pdf/PdfPage.h
@@ -0,0 +1,121 @@
+#pragma once
+
+#include "PdfObject.h"
+#include "PdfStream.h"
+#include "PdfXRefTable.h"
+
+class PdfPageTree;
+
+class PdfProcSet : public PdfObject
+{
+public:
+    std::string ToString(PdfXRefTable* xRefTable) override
+    {
+        UpdateDictionary();
+        auto content = GetStringPrefix();
+        content += mDictionary.ToString();
+        content += "[/PDF]\n";
+        content += GetStringSuffix();
+        xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+
+        return content;
+    }
+};
+
+class PdfFont : public PdfObject
+{
+public:
+    std::string ToString(PdfXRefTable* xRefTable) override
+    {
+        UpdateDictionary();
+        auto content = GetStringPrefix();
+        content += mDictionary.ToString();
+        content += GetStringSuffix();
+        xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+        return content;
+    }
+
+    void UpdateDictionary()
+    {
+        mDictionary.AddStringItem("Type", "/Font");
+        mDictionary.AddStringItem("Subtype", "/Type1");
+        mDictionary.AddStringItem("Name", "/F1");
+        mDictionary.AddStringItem("BaseFont", "/Helvetica");
+        mDictionary.AddStringItem("Encoding", "/MacRomanEncoding");
+    }
+};
+
+class PdfPage : public PdfObject
+{
+public:
+    PdfPage(PdfPageTree* parent)
+        : mParent(parent)
+    {
+        mContent = std::make_unique<PdfStream>();
+
+        std::string pageContent = "BT\n";
+        pageContent += "/F1 24 Tf\n";
+        pageContent += "100 100 Td\n";
+        pageContent += "(Hello World) Tj\n";
+        pageContent += "ET";
+
+        mContent->SetContent(pageContent);
+        mProcSet = std::make_unique<PdfProcSet>();
+
+        mDefaultFont = std::make_unique<PdfFont>();
+    }
+
+    unsigned IndexObjects(unsigned count)
+    {
+        auto newCount = count + 1;
+        mObjectNumber = newCount;
+        newCount = mContent->IndexObjects(newCount);
+        newCount = mProcSet->IndexObjects(newCount);
+        newCount = mDefaultFont->IndexObjects(newCount);
+        return newCount;
+    }
+
+    std::string ToString(PdfXRefTable* xRefTable) override
+    {
+        UpdateDictionary();
+        auto content = GetStringPrefix();
+        content += mDictionary.ToString();
+        content += GetStringSuffix();
+        xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+
+        content += mContent->ToString(xRefTable);
+
+        content += mProcSet->ToString(xRefTable);
+
+        content += mDefaultFont->ToString(xRefTable);
+
+        return content;
+    }
+
+    void UpdateDictionary()
+    {
+        std::string mediaBox = "[0 0 " + std::to_string(mWidth) + " " + std::to_string(mHeight) + "]";
+        mDictionary.AddStringItem("Type", "/Page");
+        mDictionary.AddStringItem("MediaBox", mediaBox);
+        mDictionary.AddStringItem("Parent", mParent->GetRefString());
+        mDictionary.AddStringItem("Contents", mContent->GetRefString());
+
+        auto resourcesDict = std::make_unique<PdfDictionary>();
+        resourcesDict->AddStringItem("ProcSet", mProcSet->GetRefString());
+
+        auto fontDict = std::make_unique<PdfDictionary>();
+        fontDict->AddStringItem("F1", mDefaultFont->GetRefString());
+        resourcesDict->AddDictItem("Font", std::move(fontDict));
+
+        mDictionary.AddDictItem("Resources", std::move(resourcesDict));
+    }
+
+private:
+    unsigned mWidth{612};
+    unsigned mHeight{792};
+    std::unique_ptr<PdfStream> mContent;
+    std::unique_ptr<PdfFont> mDefaultFont;
+    PdfObjectPtr mProcSet;
+    PdfPageTree* mParent;
+
+};
diff --git a/src/publishing/pdf/PdfPageTree.cpp b/src/publishing/pdf/PdfPageTree.cpp
new file mode 100644
index 0000000..c62b946
--- /dev/null
+++ b/src/publishing/pdf/PdfPageTree.cpp
@@ -0,0 +1,37 @@
+#include "PdfPageTree.h"
+
+#include "PdfXRefTable.h"
+#include "PdfPage.h"
+
+PdfPageTree::PdfPageTree()
+{
+    mRootPage = std::make_unique<PdfPage>(this);
+}
+
+unsigned PdfPageTree::IndexObjects(unsigned count)
+{
+    auto newCount = count + 1;
+    mObjectNumber = newCount;
+    newCount = mRootPage->IndexObjects(newCount);
+    return newCount;
+}
+
+std::string PdfPageTree::ToString(PdfXRefTable* xRefTable)
+{
+    UpdateDictionary();
+    std::string content = GetStringPrefix();
+    content += mDictionary.ToString();
+    content += GetStringSuffix();
+    xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+
+    content += mRootPage->ToString(xRefTable);
+    return content;
+}
+
+void PdfPageTree::UpdateDictionary()
+{
+    mDictionary.AddStringItem("Type", "/Pages");
+    std::string kids = "[" + mRootPage->GetRefString() + "]";
+    mDictionary.AddStringItem("Kids", kids);
+    mDictionary.AddStringItem("Count", "1");
+}
diff --git a/src/publishing/pdf/PdfPageTree.h b/src/publishing/pdf/PdfPageTree.h
new file mode 100644
index 0000000..897db9b
--- /dev/null
+++ b/src/publishing/pdf/PdfPageTree.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "PdfObject.h"
+
+class PdfPage;
+using PdfPagePtr = std::unique_ptr<PdfPage>;
+
+class PdfPageTree : public PdfObject
+{
+public:
+
+    PdfPageTree();
+
+    unsigned IndexObjects(unsigned count) override;
+
+    std::string ToString(PdfXRefTable* xRefTable) override;
+
+    void UpdateDictionary() override;
+
+private:
+
+    PdfPagePtr mRootPage;
+};
diff --git a/src/publishing/pdf/PdfStream.cpp b/src/publishing/pdf/PdfStream.cpp
new file mode 100644
index 0000000..0fc34f7
--- /dev/null
+++ b/src/publishing/pdf/PdfStream.cpp
@@ -0,0 +1,36 @@
+#include "PdfStream.h"
+
+#include "PdfDictionary.h"
+#include "PdfXRefTable.h"
+
+PdfStream::PdfStream()
+{
+    mDictionary.AddStringItem("Length", "0");
+}
+
+void PdfStream::SetContent(const std::string& content)
+{
+    mContent = content;
+    Update();
+}
+
+void PdfStream::Update()
+{
+    auto length = mContent.size();
+    mDictionary.AddStringItem("Length", std::to_string(length));
+}
+
+std::string PdfStream::ToString(PdfXRefTable* xRefTable)
+{
+    std::string content = GetStringPrefix();
+
+    content += mDictionary.ToString();
+
+    content += "stream\n";
+    content += mContent;
+    content += "\nendstream\n";
+    content += "endobj\n\n";
+
+    xRefTable->AddRecord(content.size(), mGenerationNumber, mIsFree);
+    return content;
+}
diff --git a/src/publishing/pdf/PdfStream.h b/src/publishing/pdf/PdfStream.h
new file mode 100644
index 0000000..595dc5a
--- /dev/null
+++ b/src/publishing/pdf/PdfStream.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "PdfObject.h"
+
+class PdfStream : public PdfObject
+{
+public:
+
+    PdfStream();
+
+    void Update();
+
+    void SetContent(const std::string& content);
+
+    std::string ToString(PdfXRefTable* xRefTable) override;
+
+private:
+    std::string mContent;
+};
diff --git a/src/publishing/pdf/PdfWriter.cpp b/src/publishing/pdf/PdfWriter.cpp
new file mode 100644
index 0000000..2735658
--- /dev/null
+++ b/src/publishing/pdf/PdfWriter.cpp
@@ -0,0 +1,12 @@
+#include "PdfWriter.h"
+
+#include "PdfDocument.h"
+
+std::string PdfWriter::ToString(const std::unique_ptr<PdfDocument>& document) const
+{
+    std::string content;
+
+    content += document->ToString();
+
+    return content;
+}
diff --git a/src/publishing/pdf/PdfWriter.h b/src/publishing/pdf/PdfWriter.h
new file mode 100644
index 0000000..0b03765
--- /dev/null
+++ b/src/publishing/pdf/PdfWriter.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+class PdfDocument;
+
+class PdfWriter
+{
+public:
+
+    std::string ToString(const std::unique_ptr<PdfDocument>& document) const;
+};
diff --git a/src/publishing/pdf/PdfXRefTable.cpp b/src/publishing/pdf/PdfXRefTable.cpp
new file mode 100644
index 0000000..827ce62
--- /dev/null
+++ b/src/publishing/pdf/PdfXRefTable.cpp
@@ -0,0 +1,68 @@
+#include "PdfXRefTable.h"
+
+#include "StringUtils.h"
+
+PdfXRefTable::PdfXRefTable()
+{
+    mSections.push_back(TableSubSection());
+}
+
+std::string PdfXRefTable::ToString()
+{
+    std::string content;
+    for (const auto& section : mSections)
+    {
+        content += "xref\n" + std::to_string(section.mStartIndex) + " " + std::to_string(section.mRecords.size());
+        content += "\n";
+        for (const auto& record : section.mRecords)
+        {
+            auto offsetString = StringUtils::ToPaddedString(10, record.mOffsetBytes);
+            auto generationString = StringUtils::ToPaddedString(5, record.mGenerationNumber);
+            auto freeString = record.mIsFree ? "f" : "n";
+
+            content += offsetString + " " + generationString + " " + freeString + "\n";
+        }
+        content += "\n";
+    }
+    return content;
+}
+
+unsigned PdfXRefTable::GetNextOffset()
+{
+    auto lastNumRecords = mSections[mSections.size() - 1].mRecords.size();
+    if (lastNumRecords > 0)
+    {
+        return mSections[mSections.size() - 1].mRecords[lastNumRecords -1].mOffsetBytes + mLastAddedBytes;
+    }
+    else if (mSections.size() > 1)
+    {
+        lastNumRecords = mSections[mSections.size() - 2].mRecords.size();
+        return mSections[mSections.size() - 2].mRecords[lastNumRecords -1].mOffsetBytes + mLastAddedBytes;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+void PdfXRefTable::AddRecord(unsigned numBytes, unsigned generation, unsigned isFree)
+{
+    XRefRecord record;
+
+    record.mOffsetBytes = GetNextOffset();
+    record.mGenerationNumber = generation;
+    record.mIsFree = isFree;
+    mSections[mSections.size()-1].mRecords.push_back(record);
+    mLastAddedBytes = numBytes;
+}
+
+unsigned PdfXRefTable::GetNumEntries()
+{
+    unsigned count = 0;
+    for (const auto& section : mSections)
+    {
+        count += section.mRecords.size();
+    }
+    return count;
+}
+
diff --git a/src/publishing/pdf/PdfXRefTable.h b/src/publishing/pdf/PdfXRefTable.h
new file mode 100644
index 0000000..9bd8a51
--- /dev/null
+++ b/src/publishing/pdf/PdfXRefTable.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <vector>
+
+struct XRefRecord
+{
+    unsigned mOffsetBytes{0};
+    unsigned mGenerationNumber{0};
+    bool mIsFree{false};
+};
+
+struct TableSubSection
+{
+    unsigned mStartIndex{0};
+    std::vector<XRefRecord> mRecords;
+};
+
+class PdfXRefTable
+{
+public:
+
+    PdfXRefTable();
+
+    std::string ToString();
+
+    unsigned GetNextOffset();
+
+    void AddRecord(unsigned numBytes, unsigned generation, unsigned isFree);
+
+    unsigned GetNumEntries();
+
+private:
+    unsigned mLastAddedBytes{0};
+    std::vector<TableSubSection> mSections;
+};
diff --git a/src/video/CMakeLists.txt b/src/video/CMakeLists.txt
new file mode 100644
index 0000000..d1683d0
--- /dev/null
+++ b/src/video/CMakeLists.txt
@@ -0,0 +1,30 @@
+list(APPEND video_HEADERS 
+    Video.h
+    FfmpegInterface.h
+    )
+
+list(APPEND video_LIB_INCLUDES 
+    Video.cpp
+    FfmegInterface.cpp
+    )
+
+add_library(video SHARED ${video_LIB_INCLUDES} ${video_HEADERS})
+
+target_include_directories(video PUBLIC
+                          "${CMAKE_CURRENT_SOURCE_DIR}"
+                          )
+set_target_properties( video PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON )   
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(LIBAV REQUIRED IMPORTED_TARGET
+    libavdevice
+    libavfilter
+    libavformat
+    libavcodec
+    libswresample
+    libswscale
+    libavutil
+)                    
+target_link_libraries( video PUBLIC image PkgConfig::LIBAV)
+
+set_property(TARGET image PROPERTY FOLDER src)
\ No newline at end of file
diff --git a/src/video/FfmegInterface.cpp b/src/video/FfmegInterface.cpp
new file mode 100644
index 0000000..3356300
--- /dev/null
+++ b/src/video/FfmegInterface.cpp
@@ -0,0 +1,118 @@
+#include "FfmpegInterface.h"
+
+#include "Image.h"
+#include "Video.h"
+#include <iostream>
+
+extern "C" {
+#include <libavformat/avformat.h>
+#include <libavutil/dict.h>
+#include <libavutil/opt.h>
+#include <libavutil/imgutils.h>
+#include <libswscale/swscale.h>
+}
+
+std::vector<std::unique_ptr<Image> > FfmpegInterface::decodeToImages(const std::unique_ptr<Video>& video, unsigned maxImages)
+{
+    std::vector<std::unique_ptr<Image> > images;
+
+    AVFormatContext* fmt_ctx{nullptr};
+
+    auto ret = avformat_open_input(&fmt_ctx, video->GetPath().c_str(), nullptr, nullptr);
+    if (ret)
+    {
+        return images;
+    }
+
+    //AVDictionaryEntry* tag{nullptr};
+    //while ((tag = av_dict_get(fmt_ctx->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
+    //{
+      //  std::cout << "key: " << tag->key << " value: " << tag->value << std::endl;
+    //}
+
+    ret = avformat_find_stream_info(fmt_ctx, nullptr);
+
+    AVCodec* decoder;
+    const auto bestStreamIdx = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
+
+    //std::cout << "Best stream idx = " << std::to_string(bestStreamIdx) << std::endl;
+    //std::cout << "Codec is: " << decoder->name << " |" << decoder->long_name << std::endl;
+
+    AVCodecContext* decoder_context = avcodec_alloc_context3(decoder);
+
+    avcodec_parameters_to_context(decoder_context, fmt_ctx->streams[bestStreamIdx]->codecpar);
+    av_opt_set_int(decoder_context, "refcounted_frames", 1, 0);
+
+    avcodec_open2(decoder_context, decoder, nullptr);
+
+    AVPacket packet;
+    AVFrame* frame = av_frame_alloc();
+    AVFrame* scaled_frame = av_frame_alloc();
+
+    int w = decoder_context->width;
+    int h = decoder_context->height;
+
+    scaled_frame->width = w;
+    scaled_frame->height = h;
+    scaled_frame->format = AV_PIX_FMT_RGB24;
+
+    av_image_alloc(scaled_frame->data, scaled_frame->linesize, w, h, AV_PIX_FMT_RGB24, 32);
+
+
+    auto img_convert_ctx = sws_getContext(w, h,
+            decoder_context->pix_fmt,
+                      w, h, AV_PIX_FMT_RGB24, SWS_BICUBIC,
+                      NULL, NULL, NULL);
+
+
+    for (unsigned idx=0; idx<100; idx++)
+    {
+        auto frame_ret = av_read_frame(fmt_ctx, &packet);
+        if (frame_ret)
+        {
+            break;
+        }
+
+        if (packet.stream_index == bestStreamIdx)
+        {
+            avcodec_send_packet(decoder_context, &packet);
+            ret = 0;
+            while(ret >= 0)
+            {
+                ret = avcodec_receive_frame(decoder_context, frame);
+
+                if (ret >= 0)
+                {
+                    frame->pts = frame->best_effort_timestamp;
+
+                    sws_scale(img_convert_ctx, frame->data,
+                             frame->linesize, 0,
+                             decoder_context->height,
+                             scaled_frame->data, scaled_frame->linesize);
+
+                    auto image = Image::Create(frame->width, frame->height);
+                    image->SetNumChannels(3);
+
+                    auto bufferSize = av_image_get_buffer_size(AV_PIX_FMT_RGB24, frame->width, frame->height, 32);
+                    std::vector<unsigned char> data(bufferSize, 0);
+
+                    auto copyRet = av_image_copy_to_buffer(data.data(), bufferSize,
+                            scaled_frame->data, scaled_frame->linesize,
+                            AV_PIX_FMT_RGB24, frame->width, frame->height, 32);
+
+                    image->SetData(data);
+                    images.push_back(std::move(image));
+                }
+                av_frame_unref(frame);
+                //av_frame_unref(scaled_frame);
+            }
+        }
+        av_packet_unref(&packet);
+    }
+
+    avcodec_free_context(&decoder_context);
+    avformat_close_input(&fmt_ctx);
+    av_frame_free(&frame);
+
+    return images;
+}
diff --git a/src/video/FfmpegInterface.h b/src/video/FfmpegInterface.h
new file mode 100644
index 0000000..6fe6146
--- /dev/null
+++ b/src/video/FfmpegInterface.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+class Image;
+class Video;
+
+class FfmpegInterface
+{
+public:
+
+    std::vector<std::unique_ptr<Image> > decodeToImages(const std::unique_ptr<Video>& video, unsigned maxImages=0);
+
+};
diff --git a/src/video/Video.cpp b/src/video/Video.cpp
new file mode 100644
index 0000000..aacf58b
--- /dev/null
+++ b/src/video/Video.cpp
@@ -0,0 +1,16 @@
+#include "Video.h"
+
+std::unique_ptr<Video> Video::Create()
+{
+    return std::make_unique<Video>();
+}
+
+void Video::SetPath(const std::string& path)
+{
+    mPath = path;
+}
+
+std::string Video::GetPath() const
+{
+    return mPath;
+}
diff --git a/src/video/Video.h b/src/video/Video.h
new file mode 100644
index 0000000..a9b8c40
--- /dev/null
+++ b/src/video/Video.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+class Video
+{
+public:
+    static std::unique_ptr<Video> Create();
+    void SetPath(const std::string& path);
+    std::string GetPath() const;
+
+private:
+
+    std::string mPath;
+};
+
+using VideoPtr = std::unique_ptr<Video>;
diff --git a/src/web/CMakeLists.txt b/src/web/CMakeLists.txt
index 8b68912..9b061d9 100644
--- a/src/web/CMakeLists.txt
+++ b/src/web/CMakeLists.txt
@@ -8,6 +8,9 @@ list(APPEND web_LIB_INCLUDES
     markdown/MarkdownParser.cpp
     html/HtmlWriter.cpp
     html/HtmlDocument.cpp
+    html/HtmlElement.cpp
+    html/elements/HtmlHeadElement.cpp
+    html/elements/HtmlBodyElement.cpp
     DocumentConverter.cpp)
 
 # add the executable
@@ -21,6 +24,7 @@ target_include_directories(web PUBLIC
                           "${CMAKE_CURRENT_SOURCE_DIR}/xml"
                           "${CMAKE_CURRENT_SOURCE_DIR}/xml/xml-elements"
                           "${CMAKE_CURRENT_SOURCE_DIR}/html"
+                          "${CMAKE_CURRENT_SOURCE_DIR}/html/elements"
                           "${CMAKE_CURRENT_SOURCE_DIR}/markdown"
                           )
 set_property(TARGET web PROPERTY FOLDER src)
diff --git a/src/web/html/HtmlDocument.cpp b/src/web/html/HtmlDocument.cpp
index 9125351..a5ccc1c 100644
--- a/src/web/html/HtmlDocument.cpp
+++ b/src/web/html/HtmlDocument.cpp
@@ -1,9 +1,19 @@
 #include "HtmlDocument.h"
 
-HtmlDocument::HtmlDocument()
-	: XmlDocument()
-{
+#include "HtmlHeadElement.h"
+#include "HtmlBodyElement.h"
 
+HtmlDocument::HtmlDocument()
+    : XmlDocument()
+{
+    auto root = XmlElement::Create("html");
+    SetRoot(std::move(root));
+
+    auto header = std::make_unique<HtmlHeadElement>();
+    GetRoot()->AddChild(std::move(header));
+
+    auto body = std::make_unique<HtmlBodyElement>();
+    GetRoot()->AddChild(std::move(body));
 }
 
 std::shared_ptr<HtmlDocument> HtmlDocument::Create()
diff --git a/src/web/html/HtmlDocument.h b/src/web/html/HtmlDocument.h
index 5f0362c..60b4ddc 100644
--- a/src/web/html/HtmlDocument.h
+++ b/src/web/html/HtmlDocument.h
@@ -6,9 +6,10 @@ class HtmlDocument : public XmlDocument
 {
 public:
 
-	HtmlDocument();
+    HtmlDocument();
+
+    static std::shared_ptr<HtmlDocument> Create();
 
-	static std::shared_ptr<HtmlDocument> Create();
 };
 
 using HtmlDocumentPtr = std::shared_ptr<HtmlDocument>;
diff --git a/src/web/html/HtmlDomManager.h b/src/web/html/HtmlDomManager.h
index e69de29..abdb6ca 100644
--- a/src/web/html/HtmlDomManager.h
+++ b/src/web/html/HtmlDomManager.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "HtmlDocument.h";
+
+class HtmlDomManager
+{
+public:
+
+    HtmlDomManager();
+
+    HtmlDocument* GetDocument();
+
+private:
+    HtmlDocumentPtr mDocument;
+};
diff --git a/src/web/html/HtmlElement.cpp b/src/web/html/HtmlElement.cpp
index 2c766c0..b2d5dc6 100644
--- a/src/web/html/HtmlElement.cpp
+++ b/src/web/html/HtmlElement.cpp
@@ -6,7 +6,7 @@ HtmlElement::HtmlElement(const std::string& tagName)
 
 }
 
-static std::unique_ptr<HtmlElement> HtmlElement::CreateUnique(const std::string& tagName)
+std::unique_ptr<HtmlElement> HtmlElement::CreateUnique(const std::string& tagName)
 {
     return std::make_unique<HtmlElement>(tagName);
 }
diff --git a/src/web/html/HtmlElement.h b/src/web/html/HtmlElement.h
index f44c201..b804582 100644
--- a/src/web/html/HtmlElement.h
+++ b/src/web/html/HtmlElement.h
@@ -1,13 +1,14 @@
 #pragma once
 #include <memory>
 
-#include "../xml/xml-elements/XmlElement.h"
+#include "XmlElement.h"
 
 class HtmlElement : public XmlElement
 {
-	HtmlElement(const std::string& tagName);
+public:
+    HtmlElement(const std::string& tagName);
 
-	static std::unique_ptr<HtmlElement> CreateUnique(const std::string& tagName);
+    static std::unique_ptr<HtmlElement> CreateUnique(const std::string& tagName);
 };
 
 using HtmlElementUPtr = std::unique_ptr<HtmlElement>;
diff --git a/src/web/html/HtmlWriter.cpp b/src/web/html/HtmlWriter.cpp
index be4f4a6..2bca4a6 100644
--- a/src/web/html/HtmlWriter.cpp
+++ b/src/web/html/HtmlWriter.cpp
@@ -5,7 +5,58 @@ HtmlWriter::HtmlWriter()
 
 }
 
+std::string HtmlWriter::ToString(XmlElement* element, unsigned depth)
+{
+    const auto prefix = std::string(2*depth, ' ');
+
+    auto content = prefix + "<" + element->GetTagName();
+    for (std::size_t idx=0; idx< element->GetNumAttributes(); idx++)
+    {
+        auto attribute = element->GetAttribute(idx);
+        content += " " + attribute->GetName() + "=\"" + attribute->GetValue() + "\"";
+    }
+
+    const auto num_children = element->GetNumChildren();
+    if (num_children == 0 && element->GetText().empty())
+    {
+        content += "/>\n";
+        return content;
+    }
+    else
+    {
+        content += ">";
+    }
+
+    if (!element->GetText().empty())
+    {
+        content += element->GetText();
+    }
+
+    if (num_children>0)
+    {
+        content += "\n";
+    }
+    for (std::size_t idx=0; idx< element->GetNumChildren(); idx++)
+    {
+        auto child = element->GetChild(idx);
+        content += ToString(child, depth+1);
+    }
+    if (num_children>0)
+    {
+        content += prefix;
+    }
+
+    content += "</" + element->GetTagName() + ">\n";
+    return content;
+}
+
 std::string HtmlWriter::ToString(HtmlDocumentPtr document)
 {
-	return "<html>Uh oh!!!!</html>";
+    std::string content = "<!DOCTYPE html>\n";
+
+    if (auto root = document->GetRoot())
+    {
+        content += ToString(root);
+    }
+    return content;
 }
diff --git a/src/web/html/HtmlWriter.h b/src/web/html/HtmlWriter.h
index 38fa63e..4ef2cff 100644
--- a/src/web/html/HtmlWriter.h
+++ b/src/web/html/HtmlWriter.h
@@ -6,7 +6,10 @@ class HtmlWriter
 {
 public:
 
-	HtmlWriter();
+    HtmlWriter();
 
-	std::string ToString(HtmlDocumentPtr document);
+    std::string ToString(HtmlDocumentPtr document);
+
+private:
+    std::string ToString(XmlElement* element, unsigned depth=0);
 };
diff --git a/src/web/html/elements/HtmlBodyElement.h b/src/web/html/elements/HtmlBodyElement.h
index e69de29..ebef2bc 100644
--- a/src/web/html/elements/HtmlBodyElement.h
+++ b/src/web/html/elements/HtmlBodyElement.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "HtmlElement.h"
+
+class HtmlBodyElement : public HtmlElement
+{
+public:
+    HtmlBodyElement() : HtmlElement("body")
+    {
+
+    }
+};
diff --git a/src/web/html/elements/HtmlHeadElement.h b/src/web/html/elements/HtmlHeadElement.h
index e69de29..fa012df 100644
--- a/src/web/html/elements/HtmlHeadElement.h
+++ b/src/web/html/elements/HtmlHeadElement.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "HtmlElement.h"
+
+class HtmlHeadElement : public HtmlElement
+{
+public:
+    HtmlHeadElement() : HtmlElement("head")
+    {
+
+    }
+};
diff --git a/src/web/markdown/MarkdownParser.cpp b/src/web/markdown/MarkdownParser.cpp
index 048e087..295a25e 100644
--- a/src/web/markdown/MarkdownParser.cpp
+++ b/src/web/markdown/MarkdownParser.cpp
@@ -1,17 +1,30 @@
 #include "MarkdownParser.h"
 
+#include <sstream>
+#include <iostream>
+
 MarkdownParser::MarkdownParser()
-	: mHtmlDocument(HtmlDocument::Create())
+    : mHtmlDocument(HtmlDocument::Create())
 {
 
 }
 
-void MarkdownParser::ProcessLine(const std::string)
+void MarkdownParser::ProcessLine(const std::string& line)
 {
 
 }
 
+void MarkdownParser::Run(const std::string& content)
+{
+    std::stringstream ss(content);
+    std::string line;
+    while (std::getline(ss, line, '\n'))
+    {
+        ProcessLine(line);
+    }
+}
+
 HtmlDocumentPtr MarkdownParser::GetHtml()
 {
-	return mHtmlDocument;
+    return mHtmlDocument;
 }
diff --git a/src/web/markdown/MarkdownParser.h b/src/web/markdown/MarkdownParser.h
index 5250393..762847a 100644
--- a/src/web/markdown/MarkdownParser.h
+++ b/src/web/markdown/MarkdownParser.h
@@ -4,13 +4,27 @@
 
 class MarkdownParser
 {
-	HtmlDocumentPtr mHtmlDocument;
+    enum class DocumentState
+    {
+        None
+    };
+
+    enum class LineState
+    {
+        None
+    };
+
+
+    DocumentState mDocumentState {DocumentState::None};
+    HtmlDocumentPtr mHtmlDocument;
 
 public:
 
-	MarkdownParser();
+    MarkdownParser();
 
-	void ProcessLine(const std::string);
+    HtmlDocumentPtr GetHtml();
 
-	HtmlDocumentPtr GetHtml();
+    void ProcessLine(const std::string& line);
+
+    void Run(const std::string& content);
 };
diff --git a/src/web/xml/XmlParser.cpp b/src/web/xml/XmlParser.cpp
index cdccf67..bc022e6 100644
--- a/src/web/xml/XmlParser.cpp
+++ b/src/web/xml/XmlParser.cpp
@@ -9,15 +9,14 @@ XmlParser::XmlParser()
     : mDocument(XmlDocument::Create()),
       mDocumentState(XmlParser::DocumentState::Await_Prolog),
       mLineState(XmlParser::LineState::Await_Tag_Open),
-      mParentElement(nullptr),
-      mWorkingElement(nullptr)
+      mWorkingElements()
 {
 
 }
 
 void XmlParser::ProcessLine(const std::string& input)
 {
-    for(std::size_t idx=0; idx<input.size(); idx++)
+    for (std::size_t idx=0; idx<input.size(); idx++)
     {
         switch (input[idx])
         {
@@ -269,14 +268,11 @@ void XmlParser::OnTagClose()
     }
     else if(mDocumentState == DS::Close_Element)
     {
-        if(mWorkingElement->GetTagName() == mWorkingTagName)
+        mDocumentState = DS::Await_Element;
+        mLineState = LS::Await_Tag_Open;
+        if (!mWorkingElements.empty())
         {
-            mDocumentState = DS::Await_Element;
-            mLineState = LS::Await_Tag_Open;
-            if(mParentElement)
-            {
-                mWorkingElement = mParentElement;
-            }
+            mWorkingElements.pop();
         }
     }
 }
@@ -289,7 +285,7 @@ void XmlParser::OnTextStart(char c)
 
 void XmlParser::OnTextEnd()
 {
-    mWorkingElement->SetText(mWorkingText);
+    mWorkingElements.top()->SetText(mWorkingText);
 }
 
 void XmlParser::onElementTagEnd()
@@ -318,14 +314,17 @@ void XmlParser::OnTagNameEnd()
     else if(mDocumentState == DS::Build_Element)
     {
         auto new_element = XmlElement::Create(mWorkingTagName);
+        auto working_element = new_element.get();
 
-        mParentElement = mWorkingElement;
-        mWorkingElement = new_element.get();
-
-        if(!mDocument->GetRoot())
+        if (!mDocument->GetRoot())
         {
             mDocument->SetRoot(std::move(new_element));
         }
+        else
+        {
+            mWorkingElements.top()->AddChild(std::move(new_element));
+        }
+        mWorkingElements.push(working_element);
         mLineState = LS::Await_Attribute_Name;
     }
 }
@@ -345,7 +344,7 @@ void XmlParser::OnAttributeNameEnd()
     }
     else if(mDocumentState == DS::Build_Element)
     {
-        mWorkingElement->AddAttribute(std::move(attribute));
+        mWorkingElements.top()->AddAttribute(std::move(attribute));
     }
     mLineState = LS::Await_Attribute_Value;
 }
@@ -358,7 +357,14 @@ void XmlParser::OnAttributeValueStart()
 
 void XmlParser::OnAttributeValueEnd()
 {
-    mWorkingElement->GetAttribute(mWorkingAttributeName)->SetValue(mWorkingAttributeValue);
+    if(mDocumentState == DS::Build_Prolog)
+    {
+        mDocument->GetProlog()->GetAttribute(mWorkingAttributeName)->SetValue(mWorkingAttributeValue);
+    }
+    else if(mDocumentState == DS::Build_Element)
+    {
+        mWorkingElements.top()->GetAttribute(mWorkingAttributeName)->SetValue(mWorkingAttributeValue);
+    }
     mLineState = LS::Await_Attribute_Name;
 }
 
diff --git a/src/web/xml/XmlParser.h b/src/web/xml/XmlParser.h
index 289de2e..d50ab91 100644
--- a/src/web/xml/XmlParser.h
+++ b/src/web/xml/XmlParser.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <stack>
 #include "XmlDocument.h"
 
 class XmlParser
@@ -33,8 +34,7 @@ private:
     DocumentState mDocumentState;
     LineState mLineState;
     XmlDocumentPtr mDocument;
-    XmlElement* mParentElement;
-    XmlElement* mWorkingElement;
+    std::stack<XmlElement*> mWorkingElements;
     std::string mWorkingAttributeName;
     std::string mWorkingTagName;
     std::string mWorkingAttributeValue;
diff --git a/src/web/xml/XmlWriter.cpp b/src/web/xml/XmlWriter.cpp
index 7afe9fb..790ef9f 100644
--- a/src/web/xml/XmlWriter.cpp
+++ b/src/web/xml/XmlWriter.cpp
@@ -1,6 +1,68 @@
 #include "XmlWriter.h"
 
-void XmlWriter::Write(File* file, XmlDocument* document)
-{
 
+std::string XmlWriter::ToString(XmlElement* element, unsigned depth)
+{
+    const auto prefix = std::string(2*depth, ' ');
+
+    auto content = prefix + "<" + element->GetTagName();
+    for (std::size_t idx=0; idx< element->GetNumAttributes(); idx++)
+    {
+        auto attribute = element->GetAttribute(idx);
+        content += " " + attribute->GetName() + "=\"" + attribute->GetValue() + "\"";
+    }
+
+    const auto num_children = element->GetNumChildren();
+    if (num_children == 0 && element->GetText().empty())
+    {
+        content += "/>\n";
+        return content;
+    }
+    else
+    {
+        content += ">";
+    }
+
+    if (!element->GetText().empty())
+    {
+        content += element->GetText();
+    }
+
+    if (num_children>0)
+    {
+        content += "\n";
+    }
+    for (std::size_t idx=0; idx< element->GetNumChildren(); idx++)
+    {
+        auto child = element->GetChild(idx);
+        content += ToString(child, depth+1);
+    }
+    if (num_children>0)
+    {
+        content += prefix;
+    }
+
+    content += "</" + element->GetTagName() + ">\n";
+    return content;
+}
+
+std::string XmlWriter::ToString(XmlDocument* document)
+{
+    std::string content;
+    if (auto prolog = document->GetProlog())
+    {
+        content += "<?xml";
+        for (std::size_t idx=0; idx< prolog->GetNumAttributes(); idx++)
+        {
+            auto attribute = prolog->GetAttribute(idx);
+            content += " " + attribute->GetName() + "=\"" + attribute->GetValue() + "\"";
+        }
+        content += "?>\n";
+    }
+
+    if (auto root = document->GetRoot())
+    {
+        content += ToString(root);
+    }
+    return content;
 }
diff --git a/src/web/xml/XmlWriter.h b/src/web/xml/XmlWriter.h
index 320ea6c..8af9dab 100644
--- a/src/web/xml/XmlWriter.h
+++ b/src/web/xml/XmlWriter.h
@@ -1,12 +1,15 @@
 #pragma once
 
-#include "File.h"
 #include "XmlDocument.h"
+#include <string>
 
 class XmlWriter
 {
 public:
     XmlWriter() = default;
 
-    void Write(File* file, XmlDocument* document);
+    std::string ToString(XmlDocument* document);
+
+private:
+    std::string ToString(XmlElement* element, unsigned depth=0);
 };
diff --git a/src/web/xml/xml-elements/XmlElement.cpp b/src/web/xml/xml-elements/XmlElement.cpp
index ee27546..02246b9 100644
--- a/src/web/xml/xml-elements/XmlElement.cpp
+++ b/src/web/xml/xml-elements/XmlElement.cpp
@@ -68,3 +68,13 @@ std::size_t XmlElement::GetNumAttributes() const
 {
     return mAttributes.size();
 }
+
+std::size_t XmlElement::GetNumChildren() const
+{
+    return mChildren.size();
+}
+
+XmlElement* XmlElement::GetChild(std::size_t index) const
+{
+    return mChildren[index].get();
+}
diff --git a/src/web/xml/xml-elements/XmlElement.h b/src/web/xml/xml-elements/XmlElement.h
index bd34f41..cc30a9f 100644
--- a/src/web/xml/xml-elements/XmlElement.h
+++ b/src/web/xml/xml-elements/XmlElement.h
@@ -1,18 +1,13 @@
 #pragma once
+
+#include "XmlAttribute.h"
+
 #include <memory>
 #include <vector>
 #include <string>
 
-#include "xml-elements/XmlAttribute.h"
-
 class XmlElement
 {
-protected:
-    std::string mTagName;
-    std::vector<XmlAttributeUPtr> mAttributes;
-    std::vector<std::unique_ptr<XmlElement> > mChildren;
-    std::string mText;
-
 public:
     XmlElement(const std::string& tagName);
     virtual ~XmlElement() = default;
@@ -28,8 +23,17 @@ public:
     XmlAttribute* GetAttribute(std::size_t index) const;
     std::size_t GetNumAttributes() const;
 
+    std::size_t GetNumChildren() const;
+    XmlElement* GetChild(std::size_t index) const;
+
     void SetText(const std::string& text);
     void SetTagName(const std::string& tagName);
+
+protected:
+    std::string mTagName;
+    std::vector<XmlAttributeUPtr> mAttributes;
+    std::vector<std::unique_ptr<XmlElement> > mChildren;
+    std::string mText;
 };
 
 using XmlElementPtr = std::shared_ptr<XmlElement>;
diff --git a/src/web/xml/xml-elements/XmlProlog.h b/src/web/xml/xml-elements/XmlProlog.h
index 2898b9e..d516e36 100644
--- a/src/web/xml/xml-elements/XmlProlog.h
+++ b/src/web/xml/xml-elements/XmlProlog.h
@@ -2,12 +2,11 @@
 #include <memory>
 #include <vector>
 
-#include "xml-elements/XmlElement.h"
+#include "XmlElement.h"
 
 class XmlProlog : public XmlElement
 {
 public:
-
     enum class Version{
         V1_0
     };
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 111c845..2c5ae47 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -10,16 +10,35 @@ target_include_directories(test_utils PUBLIC
 list(APPEND TestFiles 
             audio/TestAudioWriter.cpp
             audio/TestMidiReader.cpp
-            graphics/TestOpenGlRendering.cpp)
+            database/TestDatabase.cpp
+            graphics/TestOpenGlRendering.cpp
+            ipc/TestDbus.cpp
+            image/TestPngWriter.cpp
+            publishing/TestPdfWriter.cpp
+            video/TestVideoDecoder.cpp
+            web/TestMarkdownParser.cpp
+            web/TestXmlParser.cpp)
             
 list(APPEND TestNames
             TestAudioWriter
             TestMidiReader
-            TestOpenGlRendering)          
-            
+            TestDatabase
+            TestOpenGlRendering
+            TestDbus
+            TestPngWriter
+            TestPdfWriter
+            TestVideoDecoder
+            TestMarkdownParser
+            TestXmlParser)          
+
+find_package(PkgConfig)            
+pkg_check_modules(DBUS REQUIRED dbus-1)
+include_directories(${DBUS_INCLUDE_DIRS})
+link_directories(${DBUS_LIBRARY_DIRS})
+
 foreach(TestFile TestName IN ZIP_LISTS TestFiles TestNames)
     add_executable(${TestName}  ${TestFile})
-    target_link_libraries(${TestName} PUBLIC core network database geometry audio graphics web client test_utils)
+    target_link_libraries(${TestName} PUBLIC core network image publishing video database geometry audio graphics web client test_utils ${DBUS_LIBRARIES})
 endforeach()
 
 
diff --git a/test/audio/TestAudioWriter.cpp b/test/audio/TestAudioWriter.cpp
index 12c8ba4..9907db5 100644
--- a/test/audio/TestAudioWriter.cpp
+++ b/test/audio/TestAudioWriter.cpp
@@ -8,7 +8,9 @@
 
 #include <memory>
 #include <string>
+#ifdef _WIN32
 #include <windows.h>
+#endif
 #include <iostream>
 
 class TestWriteWav : public TestCase
@@ -32,9 +34,11 @@ class TestAudioRender : public TestCase
 public:
     bool Run() override
     {
+#ifdef _WIN32
         WasapiInterface audio_interface;
         auto device = AudioDevice::Create();
         audio_interface.Play(device);
+#endif
         return true;
     }
 };
@@ -42,8 +46,9 @@ public:
 //int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow)
 int main()
 {
+#ifdef _WIN32
     CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
-
+#endif
     std::cout << "into entry point" << std::endl;
     TestCaseRunner runner;
     //runner.AddTestCase("TestWriteNav", std::make_unique<TestWriteWav>());
@@ -51,6 +56,7 @@ int main()
 
     const auto testsPassed = runner.Run();
     return testsPassed ? 0 : -1;
-
+#ifdef _WIN32
     CoUninitialize();
+#endif
 }
diff --git a/test/data/sample_markdown.md b/test/data/sample_markdown.md
new file mode 100644
index 0000000..f9f5166
--- /dev/null
+++ b/test/data/sample_markdown.md
@@ -0,0 +1,20 @@
+# I'm a level one header
+I'm some text under level one
+
+## I'm a level two header
+I'm some text under level two
+
+```
+I'm a code block
+```
+
+I'm a line under the code block, with some `inline code`.
+
+### I'm a level three header
+I'm a bullet point list:
+
+* First point
+* Second point
+* Third point
+
+With a [hyperlink](www.imahyperlink.com) embedded.
\ No newline at end of file
diff --git a/test/database/TestDatabase.cpp b/test/database/TestDatabase.cpp
new file mode 100644
index 0000000..a10be39
--- /dev/null
+++ b/test/database/TestDatabase.cpp
@@ -0,0 +1,12 @@
+#include "DatabaseManager.h"
+
+int main()
+{
+    DatabaseManager db_manager;
+    db_manager.CreateDatabase("test.db");
+
+    std::string statement = "CREATE TABLE corporation;";
+    db_manager.Run(statement);
+
+    return 0;
+}
diff --git a/test/image/TestPngWriter.cpp b/test/image/TestPngWriter.cpp
new file mode 100644
index 0000000..4dfbcb3
--- /dev/null
+++ b/test/image/TestPngWriter.cpp
@@ -0,0 +1,31 @@
+#include "Image.h"
+#include "PngWriter.h"
+
+int main()
+{
+    unsigned width = 200;
+    unsigned height = 200;
+    unsigned numChannels = 3;
+    auto image = Image::Create(width, height);
+    image->SetNumChannels(numChannels);
+
+    std::vector<unsigned char> data(image->GetBytesPerRow()*height, 0);
+    for(unsigned jdx=0;jdx<height;jdx++)
+    {
+        const auto heightOffset = jdx*image->GetBytesPerRow();
+        for(unsigned idx=0;idx<width*numChannels;idx+=numChannels)
+        {
+            const auto index = heightOffset + idx;
+            data[index] = (idx%2 == 0) ? 255*jdx/(height+1) : 0;
+            data[index+1] = 0;
+            data[index+2] = 0;
+        }
+    }
+    image->SetData(data);
+
+    PngWriter writer;
+    writer.SetPath("test.png");
+    writer.Write(image);
+
+    return 0;
+}
diff --git a/test/ipc/TestDbus.cpp b/test/ipc/TestDbus.cpp
new file mode 100644
index 0000000..f244d62
--- /dev/null
+++ b/test/ipc/TestDbus.cpp
@@ -0,0 +1,8 @@
+#include <dbus/dbus.h>
+
+int main()
+{
+    DBusError err;
+    DBusConnection* conn;
+    return 0;
+}
diff --git a/test/publishing/TestPdfWriter.cpp b/test/publishing/TestPdfWriter.cpp
new file mode 100644
index 0000000..97c6276
--- /dev/null
+++ b/test/publishing/TestPdfWriter.cpp
@@ -0,0 +1,18 @@
+#include "PdfDocument.h"
+#include "PdfWriter.h"
+#include "PdfObject.h"
+#include "File.h"
+
+int main()
+{
+    auto document = std::make_unique<PdfDocument>();
+
+    PdfWriter writer;
+    const auto output = writer.ToString(document);
+
+    File pdf_file("TestPdfWriter.pdf");
+    pdf_file.SetAccessMode(File::AccessMode::Write);
+    pdf_file.Open();
+    pdf_file.WriteText(output);
+    return 0;
+}
diff --git a/test/video/TestVideoDecoder.cpp b/test/video/TestVideoDecoder.cpp
new file mode 100644
index 0000000..30e3913
--- /dev/null
+++ b/test/video/TestVideoDecoder.cpp
@@ -0,0 +1,25 @@
+#include "Video.h"
+#include "Image.h"
+#include "FfmpegInterface.h"
+#include "PngWriter.h"
+#include <iostream>
+
+int main()
+{
+    auto video = Video::Create();
+    video->SetPath("/home/jmsgrogan/test.mp4");
+
+    FfmpegInterface decoder;
+    auto images = decoder.decodeToImages(video, 4);
+    std::cout << "Got " << std::to_string(images.size()) << std::endl;
+
+    PngWriter writer;
+    for(unsigned idx=0; idx<20; idx++)
+    {
+        auto filename = "test_out" + std::to_string(idx) + ".png";
+        writer.SetPath(filename);
+        writer.Write(images[idx]);
+    }
+
+    return 0;
+}
diff --git a/test/web/TestMarkdownParser.cpp b/test/web/TestMarkdownParser.cpp
new file mode 100644
index 0000000..71e84b0
--- /dev/null
+++ b/test/web/TestMarkdownParser.cpp
@@ -0,0 +1,25 @@
+#include "MarkdownParser.h"
+#include "File.h"
+#include "HtmlWriter.h"
+
+int main()
+{
+    File md_file("/home/jmsgrogan/code/MediaTool/test/data/sample_markdown.md");
+    md_file.Open();
+    const auto md_content = md_file.ReadText();
+
+    MarkdownParser parser;
+    parser.Run(md_content);
+
+    auto html = parser.GetHtml();
+
+    HtmlWriter writer;
+    const auto html_string = writer.ToString(html);
+
+    File html_file("TestMarkdownParserOut.html");
+    html_file.SetAccessMode(File::AccessMode::Write);
+    html_file.Open();
+    html_file.WriteText(html_string);
+    return 0;
+
+}
diff --git a/test/web/TestXmlParser.cpp b/test/web/TestXmlParser.cpp
new file mode 100644
index 0000000..14b2cec
--- /dev/null
+++ b/test/web/TestXmlParser.cpp
@@ -0,0 +1,31 @@
+#include <iostream>
+#include <fstream>
+
+#include "XmlParser.h"
+#include "XmlWriter.h"
+#include "File.h"
+
+int main(int argc, char *argv[])
+{
+    XmlParser parser;
+
+    std::ifstream xml_file;
+    xml_file.open("/home/jmsgrogan/test.xml", std::ifstream::in);
+    while(xml_file.good())
+    {
+        std::string line;
+        std::getline(xml_file, line);
+        parser.ProcessLine(line);
+    }
+    xml_file.close();
+
+    auto outFile = std::make_unique<File>("test_out.xml");
+    outFile->SetAccessMode(File::AccessMode::Write);
+    outFile->Open();
+
+    XmlWriter writer;
+    auto content = writer.ToString(parser.GetDocument().get());
+    outFile->WriteText(content);
+
+    return 0;
+}