xlsx images

Author: andiwand

src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_document.cpp

@@ -577,7 +577,16 @@ class ElementAdapter final : public abstract::ElementAdapter,
   [[nodiscard]] std::string
   image_href(const ElementIdentifier element_id) const override {
     const pugi::xml_node node = get_node(element_id);
-    return node.attribute("xlink:href").value();
+    if (const pugi::xml_attribute ref = node.attribute("r:embed"); ref) {
+      if (const auto [relations, origin] = get_relations_and_origin(element_id);
+          relations != nullptr) {
+        if (const auto rel = relations->find(ref.value());
+            rel != std::end(*relations)) {
+          return origin.parent().join(RelPath(rel->second)).string();
+        }
+      }
+    }
+    return ""; // TODO
   }
 
 private:
@@ -595,6 +604,21 @@ class ElementAdapter final : public abstract::ElementAdapter,
     return {};
   }
 
+  [[nodiscard]] std::pair<const Relations *, AbsPath>
+  get_relations_and_origin(const ElementIdentifier element_id) const {
+    if (const ElementRegistry::Element *element =
+            m_registry->element(element_id);
+        element == nullptr) {
+      return {nullptr, {}};
+    }
+    if (const ElementRegistry::ElementRelations *element_relations =
+            m_registry->element_relations(element_id);
+        element_relations != nullptr) {
+      return {element_relations->relations, element_relations->origin};
+    }
+    return get_relations_and_origin(element_parent(element_id));
+  }
+
   [[nodiscard]] static std::string get_text(const pugi::xml_node node) {
     if (const std::string name = node.name(); name == "t" || name == "v") {
       return node.text().get();

src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.cpp

@@ -55,6 +55,21 @@ ElementRegistry::create_sheet_cell_element(const pugi::xml_node node,
   return {element_id, element, it->second};
 }
 
+ElementRegistry::ElementRelations &
+ElementRegistry::attach_element_relations(const ElementIdentifier id,
+                                          const Relations &relations,
+                                          const AbsPath &origin) {
+  check_element_id(id);
+  if (m_element_relations.contains(id)) {
+    throw std::runtime_error("DocumentElementRegistry::attach_element_"
+                             "relations: relations already attached");
+  }
+  ElementRelations &result = m_element_relations[id];
+  result.relations = &relations;
+  result.origin = origin;
+  return result;
+}
+
 ElementRegistry::Element &
 ElementRegistry::element_at(const ElementIdentifier id) {
   check_element_id(id);
@@ -102,6 +117,15 @@ ElementRegistry::element(const ElementIdentifier id) const {
   return &m_elements.at(id - 1);
 }
 
+const ElementRegistry::ElementRelations *
+ElementRegistry::element_relations(const ElementIdentifier id) const {
+  if (const auto it = m_element_relations.find(id);
+      it != m_element_relations.end()) {
+    return &it->second;
+  }
+  return nullptr;
+}
+
 const ElementRegistry::Text *
 ElementRegistry::text_element(const ElementIdentifier id) const {
   if (const auto it = m_texts.find(id); it != m_texts.end()) {

src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_element_registry.hpp

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <odr/internal/common/path.hpp>
+
+#include <odr/internal/ooxml/ooxml_util.hpp>
+
 #include <odr/definitions.hpp>
 #include <odr/document_element.hpp>
 #include <odr/table_dimension.hpp>
@@ -26,6 +30,11 @@ class ElementRegistry final {
     bool is_editable{false};
   };
 
+  struct ElementRelations final {
+    const Relations *relations{nullptr};
+    AbsPath origin;
+  };
+
   struct Text final {
     pugi::xml_node last;
   };
@@ -87,6 +96,10 @@ class ElementRegistry final {
   std::tuple<ElementIdentifier, Element &, SheetCell &>
   create_sheet_cell_element(pugi::xml_node node, const TablePosition &position);
 
+  ElementRelations &attach_element_relations(ElementIdentifier id,
+                                             const Relations &relations,
+                                             const AbsPath &origin);
+
   [[nodiscard]] Element &element_at(ElementIdentifier id);
   [[nodiscard]] Sheet &sheet_element_at(ElementIdentifier id);
 
@@ -97,6 +110,8 @@ class ElementRegistry final {
   [[nodiscard]] Text *text_element(ElementIdentifier id);
 
   [[nodiscard]] const Element *element(ElementIdentifier id) const;
+  [[nodiscard]] const ElementRelations *
+  element_relations(ElementIdentifier id) const;
   [[nodiscard]] const Text *text_element(ElementIdentifier id) const;
   [[nodiscard]] const Sheet *sheet_element(ElementIdentifier id) const;
   [[nodiscard]] const SheetCell *sheet_cell_element(ElementIdentifier id) const;
@@ -107,6 +122,7 @@ class ElementRegistry final {
 
 private:
   std::vector<Element> m_elements;
+  std::unordered_map<ElementIdentifier, ElementRelations> m_element_relations;
   std::unordered_map<ElementIdentifier, Text> m_texts;
   std::unordered_map<ElementIdentifier, Sheet> m_sheets;
   std::unordered_map<ElementIdentifier, SheetCell> m_sheet_cells;

src/odr/internal/ooxml/spreadsheet/ooxml_spreadsheet_parser.cpp

@@ -90,22 +90,6 @@ void parse_sheet_cell_children(ElementRegistry &registry,
   parse_any_element_children(registry, context, parent_id, node);
 }
 
-void parse_frame_children(ElementRegistry &registry,
-                          const ParseContext &context,
-                          const ElementIdentifier parent_id,
-                          const pugi::xml_node node) {
-  (void)registry;
-  (void)context;
-  (void)parent_id;
-  if (const pugi::xml_node image_node =
-          node.child("xdr:pic").child("xdr:blipFill").child("a:blip")) {
-    (void)image_node;
-    // TODO
-    // auto [image, _] = parse_any_element_tree(registry, context, image_node);
-    // registry.append_child(parent_id, image);
-  }
-}
-
 std::tuple<ElementIdentifier, pugi::xml_node>
 parse_sheet_element(ElementRegistry &registry, const ParseContext &context,
                     const pugi::xml_node node) {
@@ -114,6 +98,9 @@ parse_sheet_element(ElementRegistry &registry, const ParseContext &context,
   }
 
   const auto &[element_id, _, sheet] = registry.create_sheet_element(node);
+  registry.attach_element_relations(element_id,
+                                    context.get_document_relations(),
+                                    context.get_document_path());
 
   for (const pugi::xml_node col_node : node.child("cols").children("col")) {
     const std::uint32_t min = col_node.attribute("min").as_uint() - 1;
@@ -158,9 +145,14 @@ parse_sheet_element(ElementRegistry &registry, const ParseContext &context,
     const auto &[drawing_xml, drawing_relations] =
         context.get_documents_and_relations().at(drawing_path);
 
+    const ParseContext drawing_context(drawing_path, drawing_relations,
+                                       context.get_documents_and_relations(),
+                                       context.get_shared_strings());
+
     for (const pugi::xml_node shape_node :
          drawing_xml.document_element().children()) {
-      auto [shape, _] = parse_any_element_tree(registry, context, shape_node);
+      const auto [shape, _] =
+          parse_any_element_tree(registry, drawing_context, shape_node);
       if (shape == null_element_id) {
         continue;
       }
@@ -207,6 +199,30 @@ parse_text_element(ElementRegistry &registry, const ParseContext &context,
   return {element_id, last.next_sibling()};
 }
 
+std::tuple<ElementIdentifier, pugi::xml_node>
+parse_frame_element(ElementRegistry &registry, const ParseContext &context,
+                    const pugi::xml_node node) {
+  if (!node) {
+    return {null_element_id, pugi::xml_node()};
+  }
+
+  const auto &[element_id, _] =
+      registry.create_element(ElementType::frame, node);
+  registry.attach_element_relations(element_id,
+                                    context.get_document_relations(),
+                                    context.get_document_path());
+
+  if (const pugi::xml_node image_node =
+          node.child("xdr:pic").child("xdr:blipFill").child("a:blip")) {
+    auto [image, _] =
+        parse_element_tree(registry, context, ElementType::image, image_node,
+                           parse_any_element_children);
+    registry.append_child(element_id, image);
+  }
+
+  return {element_id, node.next_sibling()};
+}
+
 std::tuple<ElementIdentifier, pugi::xml_node>
 parse_any_element_tree(ElementRegistry &registry, const ParseContext &context,
                        const pugi::xml_node node) {
@@ -229,9 +245,7 @@ parse_any_element_tree(ElementRegistry &registry, const ParseContext &context,
       {"r", create_default_tree_parser(ElementType::span)},
       {"t", parse_text_element},
       {"v", parse_text_element},
-      {"xdr:twoCellAnchor",
-       create_default_tree_parser(ElementType::frame, parse_frame_children)},
-  };
+      {"xdr:twoCellAnchor", parse_frame_element}};
 
   if (const auto constructor_it = parser_table.find(node.name());
       constructor_it != std::end(parser_table)) {