Adds margin setting and calibre web

Also made the menu items dynamic and capital case. Looks better from a design perspective but I suppose this is an optional thing to accept

lib/OpdsParser/OpdsParser.cpp

@@ -0,0 +1,198 @@
+#include "OpdsParser.h"
+
+#include <HardwareSerial.h>
+#include <cstring>
+
+OpdsParser::~OpdsParser() {
+  if (parser) {
+    XML_StopParser(parser, XML_FALSE);
+    XML_SetElementHandler(parser, nullptr, nullptr);
+    XML_SetCharacterDataHandler(parser, nullptr);
+    XML_ParserFree(parser);
+    parser = nullptr;
+  }
+}
+
+bool OpdsParser::parse(const char* xmlData, const size_t length) {
+  clear();
+
+  parser = XML_ParserCreate(nullptr);
+  if (!parser) {
+    Serial.printf("[%lu] [OPDS] Couldn't allocate memory for parser\n", millis());
+    return false;
+  }
+
+  XML_SetUserData(parser, this);
+  XML_SetElementHandler(parser, startElement, endElement);
+  XML_SetCharacterDataHandler(parser, characterData);
+
+  // Parse in chunks to avoid large buffer allocations
+  const char* currentPos = xmlData;
+  size_t remaining = length;
+  constexpr size_t chunkSize = 1024;
+
+  while (remaining > 0) {
+    void* const buf = XML_GetBuffer(parser, chunkSize);
+    if (!buf) {
+      Serial.printf("[%lu] [OPDS] Couldn't allocate memory for buffer\n", millis());
+      XML_ParserFree(parser);
+      parser = nullptr;
+      return false;
+    }
+
+    const size_t toRead = remaining < chunkSize ? remaining : chunkSize;
+    memcpy(buf, currentPos, toRead);
+
+    const bool isFinal = (remaining == toRead);
+    if (XML_ParseBuffer(parser, static_cast<int>(toRead), isFinal) == XML_STATUS_ERROR) {
+      Serial.printf("[%lu] [OPDS] Parse error at line %lu: %s\n", millis(), XML_GetCurrentLineNumber(parser),
+                    XML_ErrorString(XML_GetErrorCode(parser)));
+      XML_ParserFree(parser);
+      parser = nullptr;
+      return false;
+    }
+
+    currentPos += toRead;
+    remaining -= toRead;
+  }
+
+  // Clean up parser
+  XML_ParserFree(parser);
+  parser = nullptr;
+
+  Serial.printf("[%lu] [OPDS] Parsed %zu books\n", millis(), books.size());
+  return true;
+}
+
+void OpdsParser::clear() {
+  books.clear();
+  currentBook = OpdsBook{};
+  currentText.clear();
+  inEntry = false;
+  inTitle = false;
+  inAuthor = false;
+  inAuthorName = false;
+  inId = false;
+}
+
+const char* OpdsParser::findAttribute(const XML_Char** atts, const char* name) {
+  for (int i = 0; atts[i]; i += 2) {
+    if (strcmp(atts[i], name) == 0) {
+      return atts[i + 1];
+    }
+  }
+  return nullptr;
+}
+
+void XMLCALL OpdsParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+  auto* self = static_cast<OpdsParser*>(userData);
+
+  // Check for entry element (with or without namespace prefix)
+  if (strcmp(name, "entry") == 0 || strstr(name, ":entry") != nullptr) {
+    self->inEntry = true;
+    self->currentBook = OpdsBook{};
+    return;
+  }
+
+  if (!self->inEntry) return;
+
+  // Check for title element
+  if (strcmp(name, "title") == 0 || strstr(name, ":title") != nullptr) {
+    self->inTitle = true;
+    self->currentText.clear();
+    return;
+  }
+
+  // Check for author element
+  if (strcmp(name, "author") == 0 || strstr(name, ":author") != nullptr) {
+    self->inAuthor = true;
+    return;
+  }
+
+  // Check for author name element
+  if (self->inAuthor && (strcmp(name, "name") == 0 || strstr(name, ":name") != nullptr)) {
+    self->inAuthorName = true;
+    self->currentText.clear();
+    return;
+  }
+
+  // Check for id element
+  if (strcmp(name, "id") == 0 || strstr(name, ":id") != nullptr) {
+    self->inId = true;
+    self->currentText.clear();
+    return;
+  }
+
+  // Check for link element with acquisition rel and epub type
+  if (strcmp(name, "link") == 0 || strstr(name, ":link") != nullptr) {
+    const char* rel = findAttribute(atts, "rel");
+    const char* type = findAttribute(atts, "type");
+    const char* href = findAttribute(atts, "href");
+
+    // Look for acquisition link with epub type
+    if (rel && type && href) {
+      if (strstr(rel, "opds-spec.org/acquisition") != nullptr && strcmp(type, "application/epub+zip") == 0) {
+        self->currentBook.epubUrl = href;
+      }
+    }
+  }
+}
+
+void XMLCALL OpdsParser::endElement(void* userData, const XML_Char* name) {
+  auto* self = static_cast<OpdsParser*>(userData);
+
+  // Check for entry end
+  if (strcmp(name, "entry") == 0 || strstr(name, ":entry") != nullptr) {
+    // Only add book if it has required fields
+    if (!self->currentBook.title.empty() && !self->currentBook.epubUrl.empty()) {
+      self->books.push_back(self->currentBook);
+    }
+    self->inEntry = false;
+    self->currentBook = OpdsBook{};
+    return;
+  }
+
+  if (!self->inEntry) return;
+
+  // Check for title end
+  if (strcmp(name, "title") == 0 || strstr(name, ":title") != nullptr) {
+    if (self->inTitle) {
+      self->currentBook.title = self->currentText;
+    }
+    self->inTitle = false;
+    return;
+  }
+
+  // Check for author end
+  if (strcmp(name, "author") == 0 || strstr(name, ":author") != nullptr) {
+    self->inAuthor = false;
+    return;
+  }
+
+  // Check for author name end
+  if (self->inAuthor && (strcmp(name, "name") == 0 || strstr(name, ":name") != nullptr)) {
+    if (self->inAuthorName) {
+      self->currentBook.author = self->currentText;
+    }
+    self->inAuthorName = false;
+    return;
+  }
+
+  // Check for id end
+  if (strcmp(name, "id") == 0 || strstr(name, ":id") != nullptr) {
+    if (self->inId) {
+      self->currentBook.id = self->currentText;
+    }
+    self->inId = false;
+    return;
+  }
+}
+
+void XMLCALL OpdsParser::characterData(void* userData, const XML_Char* s, const int len) {
+  auto* self = static_cast<OpdsParser*>(userData);
+
+  // Only accumulate text when in a text element
+  if (self->inTitle || self->inAuthorName || self->inId) {
+    self->currentText.append(s, len);
+  }
+}

lib/OpdsParser/OpdsParser.h

@@ -0,0 +1,77 @@
+#pragma once
+#include <expat.h>
+
+#include <string>
+#include <vector>
+
+/**
+ * Represents a book entry from an OPDS feed.
+ */
+struct OpdsBook {
+  std::string title;
+  std::string author;
+  std::string epubUrl;  // Relative URL like "/books/get/epub/3/Calibre_Library"
+  std::string id;
+};
+
+/**
+ * Parser for OPDS (Open Publication Distribution System) Atom feeds.
+ * Uses the Expat XML parser to parse OPDS catalog entries.
+ *
+ * Usage:
+ *   OpdsParser parser;
+ *   if (parser.parse(xmlData, xmlLength)) {
+ *     for (const auto& book : parser.getBooks()) {
+ *       // Process book entries
+ *     }
+ *   }
+ */
+class OpdsParser {
+ public:
+  OpdsParser() = default;
+  ~OpdsParser();
+
+  // Disable copy
+  OpdsParser(const OpdsParser&) = delete;
+  OpdsParser& operator=(const OpdsParser&) = delete;
+
+  /**
+   * Parse an OPDS XML feed.
+   * @param xmlData Pointer to the XML data
+   * @param length Length of the XML data
+   * @return true if parsing succeeded, false on error
+   */
+  bool parse(const char* xmlData, size_t length);
+
+  /**
+   * Get the parsed books.
+   * @return Vector of OpdsBook entries
+   */
+  const std::vector<OpdsBook>& getBooks() const { return books; }
+
+  /**
+   * Clear all parsed books.
+   */
+  void clear();
+
+ private:
+  // Expat callbacks
+  static void XMLCALL startElement(void* userData, const XML_Char* name, const XML_Char** atts);
+  static void XMLCALL endElement(void* userData, const XML_Char* name);
+  static void XMLCALL characterData(void* userData, const XML_Char* s, int len);
+
+  // Helper to find attribute value
+  static const char* findAttribute(const XML_Char** atts, const char* name);
+
+  XML_Parser parser = nullptr;
+  std::vector<OpdsBook> books;
+  OpdsBook currentBook;
+  std::string currentText;
+
+  // Parser state
+  bool inEntry = false;
+  bool inTitle = false;
+  bool inAuthor = false;
+  bool inAuthorName = false;
+  bool inId = false;
+};