@react-native-ohos/react-native-pdf 6.7.7-rc.1

package/windows/RCTPdf/RCTPdfControl.cpp

@@ -0,0 +1,667 @@
+#include "pch.h"
+#include "RCTPdfControl.h"
+#if __has_include("RCTPdfControl.g.cpp")
+#include "RCTPdfControl.g.cpp"
+#endif
+
+using namespace winrt;
+using namespace Windows::UI::Xaml;
+using namespace Microsoft::ReactNative;
+using namespace Windows::Data::Json;
+using namespace Windows::Data::Pdf;
+using namespace Windows::Foundation;
+using namespace Windows::Storage;
+using namespace Windows::Storage::Streams;
+using namespace Windows::Storage::Pickers;
+using namespace Windows::UI;
+using namespace Windows::UI::Core;
+using namespace Windows::UI::Popups;
+using namespace Windows::UI::Xaml;
+using namespace Windows::UI::Xaml::Controls;
+using namespace Windows::UI::Xaml::Input;
+using namespace Windows::UI::Xaml::Media;
+using namespace Windows::UI::Xaml::Media::Imaging;
+
+namespace winrt::RCTPdf::implementation
+{
+  PDFPageInfo::PDFPageInfo(winrt::Windows::UI::Xaml::Controls::Image image, winrt::Windows::Data::Pdf::PdfPage page, double imageScale, double renderScale) :
+    image(image), page(page), imageScale(imageScale), renderScale(renderScale), scaledTopOffset(0), scaledLeftOffset(0) {
+    auto dims = page.Size();
+    height = (unsigned)dims.Height;
+    width = (unsigned)dims.Width;
+    scaledHeight = (unsigned)(height * imageScale);
+    scaledWidth = (unsigned)(width * imageScale);
+  }
+  PDFPageInfo::PDFPageInfo(const PDFPageInfo& rhs) :
+    height(rhs.height), width(rhs.width), scaledHeight(rhs.scaledHeight), scaledWidth(rhs.scaledWidth),
+    scaledTopOffset(rhs.scaledTopOffset), scaledLeftOffset(rhs.scaledTopOffset), imageScale(rhs.imageScale),
+    renderScale((double)rhs.renderScale), image(rhs.image), page(rhs.page)
+  { }
+  PDFPageInfo::PDFPageInfo(PDFPageInfo&& rhs) :
+    height(rhs.height), width(rhs.width), scaledHeight(rhs.scaledHeight), scaledWidth(rhs.scaledWidth),
+    scaledTopOffset(rhs.scaledTopOffset), scaledLeftOffset(rhs.scaledTopOffset), imageScale(rhs.imageScale),
+    renderScale((double)rhs.renderScale), image(std::move(rhs.image)), page(std::move(rhs.page))
+  { }
+  unsigned PDFPageInfo::pageVisiblePixels(bool horizontal, double viewportStart, double viewportEnd) const {
+    if (viewportEnd < viewportStart)
+      std::swap(viewportStart, viewportEnd);
+    auto pageStart = horizontal ? scaledLeftOffset : scaledTopOffset;
+    auto pageSize = PDFPageInfo::pageSize(horizontal);
+    auto pageEnd = pageStart + pageSize;
+    auto uViewportStart = (unsigned)viewportStart;
+    auto uViewportEnd = (unsigned)viewportEnd;
+    if (pageStart >= uViewportStart && pageStart <= uViewportEnd) { // we see the top edge
+      return (std::min)(pageEnd, uViewportEnd) - pageStart;
+    }
+    if (pageEnd >= uViewportStart && pageEnd <= uViewportEnd) { // we see the bottom edge
+      return pageEnd - (std::max)(pageStart, uViewportStart);
+    }
+    if (pageStart <= uViewportStart && pageEnd >= uViewportEnd) {// we see the entire page
+      return uViewportEnd - uViewportStart;
+    }
+    return 0;
+  }
+  unsigned PDFPageInfo::pageSize(bool horizontal) const {
+    return horizontal ? scaledWidth : scaledHeight;
+  }
+  bool PDFPageInfo::needsRender() const {
+    double currentRenderScale = renderScale;
+    return currentRenderScale < imageScale || currentRenderScale > imageScale * m_downscaleTreshold;
+  }
+  winrt::Windows::Foundation::IAsyncAction PDFPageInfo::render() {
+    return render(imageScale);
+  }
+  winrt::Windows::Foundation::IAsyncAction PDFPageInfo::render(double useScale) {
+    double currentRenderScale;
+    while (true) {
+      currentRenderScale = renderScale;
+      if (!(currentRenderScale < imageScale || currentRenderScale > imageScale * m_downscaleTreshold))
+        co_return;
+      if (renderScale.compare_exchange_weak(currentRenderScale, useScale))
+        break;
+      if (renderScale > useScale)
+        co_return;
+    }
+    PdfPageRenderOptions renderOptions;
+    auto dims = page.Size();
+    renderOptions.DestinationHeight(static_cast<uint32_t>(dims.Height * useScale));
+    renderOptions.DestinationWidth(static_cast<uint32_t>(dims.Width * useScale));
+    InMemoryRandomAccessStream stream;
+    co_await page.RenderToStreamAsync(stream, renderOptions);
+    BitmapImage bitmap;
+    co_await bitmap.SetSourceAsync(stream);
+    if (renderScale == useScale)
+      image.Source(bitmap);
+  }
+  
+  RCTPdfControl::RCTPdfControl(IReactContext const& reactContext) : m_reactContext(reactContext) {
+    InitializeComponent();
+  }
+
+  winrt::Windows::Foundation::Collections::IMapView<winrt::hstring, winrt::Microsoft::ReactNative::ViewManagerPropertyType> RCTPdfControl::NativeProps() noexcept {
+    auto nativeProps = winrt::single_threaded_map<hstring, ViewManagerPropertyType>();
+    nativeProps.Insert(L"path", ViewManagerPropertyType::String);
+    nativeProps.Insert(L"page", ViewManagerPropertyType::Number);
+    nativeProps.Insert(L"scale", ViewManagerPropertyType::Number);
+    nativeProps.Insert(L"minScale", ViewManagerPropertyType::Number);
+    nativeProps.Insert(L"maxScale", ViewManagerPropertyType::Number);
+    nativeProps.Insert(L"horizontal", ViewManagerPropertyType::Boolean);
+    nativeProps.Insert(L"fitWidth", ViewManagerPropertyType::Boolean);
+    nativeProps.Insert(L"fitPolicy", ViewManagerPropertyType::Number);
+    nativeProps.Insert(L"spacing", ViewManagerPropertyType::Number);
+    nativeProps.Insert(L"password", ViewManagerPropertyType::String);
+    nativeProps.Insert(L"background", ViewManagerPropertyType::Color);
+    nativeProps.Insert(L"enablePaging", ViewManagerPropertyType::Boolean);
+    nativeProps.Insert(L"enableRTL", ViewManagerPropertyType::Boolean);
+    nativeProps.Insert(L"singlePage", ViewManagerPropertyType::Boolean);
+
+    return nativeProps.GetView();
+  }
+
+  void RCTPdfControl::UpdateProperties(winrt::Microsoft::ReactNative::IJSValueReader const& propertyMapReader) noexcept {    
+    const JSValueObject& propertyMap = JSValue::ReadObjectFrom(propertyMapReader);
+    std::optional<std::string> pdfURI;
+    std::optional<std::string> pdfPassword;
+    std::optional<int> setPage;
+    std::optional<double> minScale, maxScale, scale;
+    std::optional<bool> horizontal;
+    std::optional<bool> fitWidth;
+    std::optional<int> fitPolicy;
+    std::optional<int> spacing;
+    std::optional<bool> reverse;
+    std::optional<bool> singlePage;
+    std::optional<bool> enablePaging;
+    for (auto const& pair : propertyMap) {
+      auto const& propertyName = pair.first;
+      auto const& propertyValue = pair.second;
+      if (propertyName == "path") {
+        pdfURI = propertyValue != nullptr ? propertyValue.AsString() : "";
+      }
+      else if (propertyName == "password") {
+        pdfPassword = propertyValue != nullptr ? propertyValue.AsString() : "";
+      }
+      else if (propertyName == "page" && propertyValue != nullptr) {
+        setPage = propertyValue.AsInt32() - 1;
+      }
+      else if (propertyName == "scale" && propertyValue != nullptr) {
+        scale = propertyValue.AsDouble();
+      }
+      else if (propertyName == "minScale" && propertyValue != nullptr) {
+        minScale = propertyValue.AsDouble();
+      }
+      else if (propertyName == "maxScale" && propertyValue != nullptr) {
+        maxScale = propertyValue.AsDouble();
+      }
+      else if (propertyName == "horizontal" && propertyValue != nullptr) {
+        horizontal = propertyValue.AsBoolean();
+      }
+      else if (propertyName == "enablePaging" && propertyValue != nullptr) {
+        enablePaging = propertyValue.AsBoolean();
+      }
+      else if (propertyName == "fitWidth" && propertyValue != nullptr) {
+        fitWidth = propertyValue.AsBoolean();
+      }
+      else if (propertyName == "fitPolicy" && propertyValue != nullptr) {
+        fitPolicy = propertyValue.AsInt32();
+      }
+      else if (propertyName == "spacing" && propertyValue != nullptr) {
+        maxScale = propertyValue.AsInt32();
+      }
+      else if (propertyName == "enableRTL" && propertyValue != nullptr) {
+        reverse = propertyValue.AsBoolean();
+      }
+      else if (propertyName == "singlePage" && propertyValue != nullptr) {
+        singlePage = propertyValue.AsBoolean();
+      }
+      else if (propertyName == "backgroundColor" && propertyValue != nullptr) {
+        auto color = propertyValue.AsInt32();
+        winrt::Windows::UI::Color brushColor;
+        brushColor.A = (color >> 24) & 0xff;
+        brushColor.R = (color >> 16) & 0xff;
+        brushColor.G = (color >> 8) & 0xff;
+        brushColor.B = color & 0xff;
+        PagesContainer().Background(SolidColorBrush(brushColor));
+      }
+    }
+    // If we are loading a new PDF:
+    std::shared_lock lock(m_rwlock);
+    if (pdfURI && *pdfURI != m_pdfURI ||
+        pdfPassword && *pdfPassword != m_pdfPassword ||
+        (reverse && *reverse != m_reverse) ||
+        (enablePaging && *enablePaging != m_enablePaging) ||
+        (singlePage && (m_pages.empty() || *singlePage && m_pages.size() != 1 || !*singlePage && m_pages.size() == 1)) ) {
+      lock.unlock();
+      std::unique_lock write_lock(m_rwlock);
+      m_pdfURI = pdfURI.value_or("");
+      m_pdfPassword = pdfPassword.value_or("");
+      m_currentPage = setPage.value_or(0);
+      m_scale = scale.value_or(m_defualtZoom);
+      m_minScale = minScale.value_or(m_defaultMinZoom);
+      m_maxScale = maxScale.value_or(m_defaultMaxZoom);
+      m_horizontal = horizontal.value_or(false);
+      m_enablePaging = enablePaging.value_or(false);
+      int useFitPolicy = 2;
+      if (fitWidth)
+        useFitPolicy = 0;
+      if (fitPolicy)
+        useFitPolicy = *fitPolicy;
+      m_margins = spacing.value_or(m_defaultMargins);
+      m_reverse = reverse.value_or(false);
+      LoadPDF(std::move(write_lock), useFitPolicy, singlePage.value_or(false));
+    } else {
+      // If we are updating the pdf:
+      m_minScale = minScale.value_or(m_minScale);
+      m_maxScale = maxScale.value_or(m_maxScale);
+      bool needScroll = false;
+      if (horizontal && *horizontal != m_horizontal) {
+        SetOrientation(*horizontal);
+        needScroll = true;
+      }
+      if (setPage) {
+        m_currentPage = *setPage;
+        needScroll = true;
+      }
+      if ((scale && *scale != m_scale) || (spacing && *spacing != m_margins)) {
+        Rescale(scale.value_or(m_scale), spacing.value_or(m_margins), !needScroll);
+      }
+      if (needScroll) {
+        GoToPage(m_currentPage);
+      }
+    }
+  }
+
+  winrt::Microsoft::ReactNative::ConstantProviderDelegate RCTPdfControl::ExportedCustomBubblingEventTypeConstants() noexcept {
+    return [](IJSValueWriter const& constantWriter) {
+      WriteCustomDirectEventTypeConstant(constantWriter, "Change");
+    };
+  }
+  winrt::Microsoft::ReactNative::ConstantProviderDelegate RCTPdfControl::ExportedCustomDirectEventTypeConstants() noexcept {
+    return nullptr;
+  }
+  
+  winrt::Windows::Foundation::Collections::IVectorView<winrt::hstring> RCTPdfControl::Commands() noexcept {
+    auto commands = winrt::single_threaded_vector<hstring>();
+    commands.Append(L"setPage");
+    return commands.GetView();
+  }
+
+  void RCTPdfControl::DispatchCommand(winrt::hstring const& commandId, winrt::Microsoft::ReactNative::IJSValueReader const& commandArgsReader) noexcept {
+    auto commandArgs = JSValue::ReadArrayFrom(commandArgsReader);
+    if (commandId == L"setPage" && commandArgs.size() > 0) {
+      std::shared_lock lock(m_rwlock);
+      auto page = commandArgs[0].AsInt32() - 1;
+      GoToPage(page);
+    }
+  }
+
+  void RCTPdfControl::PagesContainer_PointerWheelChanged(winrt::Windows::Foundation::IInspectable const&, winrt::Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e) {
+    winrt::Windows::System::VirtualKeyModifiers modifiers = e.KeyModifiers();
+    if ((modifiers & winrt::Windows::System::VirtualKeyModifiers::Control) != winrt::Windows::System::VirtualKeyModifiers::Control)
+      return;
+    double delta = (e.GetCurrentPoint(*this).Properties().MouseWheelDelta() / WHEEL_DELTA);
+    std::shared_lock lock(m_rwlock);
+    auto newScale = (std::max)((std::min)(m_scale * pow(m_zoomMultiplier, delta), m_maxScale), m_minScale);
+    Rescale(newScale, m_margins, true);
+    e.Handled(true);
+  }
+
+  void RCTPdfControl::Pages_SizeChanged(winrt::Windows::Foundation::IInspectable const&, winrt::Windows::UI::Xaml::SizeChangedEventArgs const&) {
+    if (m_targetHorizontalOffset || m_targetVerticalOffset) {
+      auto container = PagesContainer();
+      PagesContainer().ChangeView(m_targetHorizontalOffset.value_or(container.HorizontalOffset()),
+        m_targetVerticalOffset.value_or(container.VerticalOffset()),
+        nullptr,
+        true);
+      m_targetHorizontalOffset.reset();
+      m_targetVerticalOffset.reset();
+    }
+  }
+
+  winrt::fire_and_forget RCTPdfControl::PagesContainer_ViewChanged(winrt::Windows::Foundation::IInspectable const&, winrt::Windows::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs const& args)
+  {
+    auto lifetime = get_strong();
+    auto container = PagesContainer();
+    auto currentHorizontalOffset = container.HorizontalOffset();
+    auto currentVerticalOffset = container.VerticalOffset();
+    double offsetStart = m_horizontal ? currentHorizontalOffset : currentVerticalOffset;
+    double viewSize = m_horizontal ? container.ViewportWidth() : container.ViewportHeight();
+    double offsetEnd = offsetStart + viewSize;
+    std::shared_lock lock(m_rwlock, std::defer_lock);
+    if (args.IsIntermediate() || !lock.try_lock() || viewSize == 0 || m_pages.empty())
+      return;
+    // Go through pages until we reach a visible page
+    int page = 0;
+    double visiblePagePixels = 0;
+    for (; page < (int)m_pages.size(); ++page) {
+      visiblePagePixels = m_pages[page].pageVisiblePixels(m_horizontal, offsetStart, offsetEnd);
+      if (visiblePagePixels > 0)
+        break;
+    }
+    if (page == (int)m_pages.size()) {
+      --page;
+    }
+    else {
+      double pagePixels = m_pages[page].pageSize(m_horizontal);
+      // #"page" is the first visible page. Check how much of the view port this page covers...
+      double viewCoveredByPage = visiblePagePixels / viewSize;
+      // ...and how much of the page is visible:
+      double pageVisiblePart = visiblePagePixels / pagePixels;
+      // If:
+      //  - less than 50% of the screen is covered by the page
+      //  - less than 50% of the page is visible (important if more than one page fits the screen)
+      //  - there is a next page
+      // move the indicator to that page:
+      if (viewCoveredByPage < 0.5 && pageVisiblePart < 0.5 && page + 1 < (int)m_pages.size()) {
+        ++page;
+      }
+    }
+    // Render all visible pages - first the current one, then the next visible ones and one
+    // more, then the one before that might be partly visible, then one more before
+    co_await RenderVisiblePages(page);
+    if (page != m_currentPage) {
+      m_currentPage = page;
+      SignalPageChange(m_currentPage + 1, m_pages.size());
+    }
+  }
+
+  void RCTPdfControl::PagesContainer_Tapped(winrt::Windows::Foundation::IInspectable const&, winrt::Windows::UI::Xaml::Input::TappedRoutedEventArgs const& args) {
+    auto position = args.GetPosition(*this);
+    std::shared_lock lock(m_rwlock);
+    int scaledDoubleMargin = (int)(m_scale * m_margins * 2);
+    int page = 0;
+    int xPosition = (int)(position.X + PagesContainer().HorizontalOffset());
+    int yPosition = (int)(position.Y + PagesContainer().VerticalOffset());
+    for (; page < (int)m_pages.size(); ++page) {
+      if (m_horizontal) {
+        if (xPosition >= (int)m_pages[page].scaledLeftOffset &&
+            xPosition <= (int)(m_pages[page].scaledLeftOffset + m_pages[page].scaledWidth + scaledDoubleMargin))
+          break;   
+      } else {
+        if (yPosition >= (int)m_pages[page].scaledTopOffset &&
+            yPosition <= (int)(m_pages[page].scaledTopOffset + m_pages[page].scaledHeight + scaledDoubleMargin))
+          break;
+      }
+    }
+    if (page == (int)m_pages.size()) {
+      page = m_currentPage;
+    }
+    SignalPageTapped(page, (int)position.X, (int)position.Y);
+    PagesContainer().Focus(FocusState::Pointer);
+    args.Handled(true);
+  }
+
+
+  void RCTPdfControl::PagesContainer_DoubleTapped(winrt::Windows::Foundation::IInspectable const&, winrt::Windows::UI::Xaml::Input::DoubleTappedRoutedEventArgs const& args)
+  {
+    std::shared_lock lock(m_rwlock);
+    double newScale = (std::min)(m_scale * m_zoomMultiplier, m_maxScale);
+    Rescale(newScale, m_margins, true);
+    PagesContainer().Focus(FocusState::Pointer);
+    args.Handled(true);
+  }
+
+  void RCTPdfControl::ChangeScroll(double targetHorizontalOffset, double targetVerticalOffset) {
+    auto container = PagesContainer();
+    auto maxHorizontalOffset = container.ScrollableWidth();
+    auto maxVerticalOffset = container.ScrollableHeight();
+    // If viewport is bigger than a page, it is possible that target offset is
+    // smaller than max offset. Take that into account:
+    if (targetHorizontalOffset <= maxHorizontalOffset + container.ViewportWidth() &&
+      targetVerticalOffset <= maxVerticalOffset + container.ViewportHeight()) {
+      PagesContainer().ChangeView((std::min)(targetHorizontalOffset, maxHorizontalOffset),
+        (std::min)(targetVerticalOffset, maxVerticalOffset),
+        nullptr, true);
+    }
+    else {
+      m_targetHorizontalOffset = targetHorizontalOffset;
+      m_targetVerticalOffset = targetVerticalOffset;
+    }
+  }
+
+  void RCTPdfControl::UpdatePagesInfoMarginOrScale() {
+    unsigned scaledMargin = (unsigned)(m_scale * m_margins);
+    for (auto& page : m_pages) {
+      page.imageScale = m_scale;
+      page.scaledWidth = (unsigned)(page.width * m_scale);
+      page.scaledHeight = (unsigned)(page.height * m_scale);
+      page.image.Margin(ThicknessHelper::FromUniformLength(scaledMargin));
+      page.image.Width(page.scaledWidth);
+      page.image.Height(page.scaledHeight);
+    }
+    unsigned totalTopOffset = 0;
+    unsigned totalLeftOffset = 0;
+    unsigned doubleScaledMargin = scaledMargin * 2;
+    if (m_reverse) {
+      for (int page = m_pages.size() - 1; page >= 0; --page) {
+        m_pages[page].scaledTopOffset = totalTopOffset;
+        totalTopOffset += m_pages[page].scaledHeight + doubleScaledMargin;
+        m_pages[page].scaledLeftOffset = totalLeftOffset;
+        totalLeftOffset += m_pages[page].scaledWidth + doubleScaledMargin;
+      }
+    }
+    else {
+      for (int page = 0; page < (int)m_pages.size(); ++page) {
+        m_pages[page].scaledTopOffset = totalTopOffset;
+        totalTopOffset += m_pages[page].scaledHeight + doubleScaledMargin;
+        m_pages[page].scaledLeftOffset = totalLeftOffset;
+        totalLeftOffset += m_pages[page].scaledWidth + doubleScaledMargin;
+      }
+    }
+  }
+
+  void RCTPdfControl::GoToPage(int page) {
+    if (page < 0 || page >= (int)m_pages.size()) {
+      return;
+    }
+    if (m_enablePaging) {
+      [&](int page) -> winrt::fire_and_forget {
+        auto lifetime = get_strong();
+        co_await m_pages[page].render();
+      }(page);
+      Pages().Items().ReplaceAll({ &m_pages[page].image, &m_pages[page].image + 1 });
+    } else {
+      auto neededOffset = m_horizontal ? m_pages[page].scaledLeftOffset : m_pages[page].scaledTopOffset;
+      double horizontalOffset = m_horizontal ? neededOffset : PagesContainer().HorizontalOffset();
+      double verticalOffset = m_horizontal ? PagesContainer().VerticalOffset() : neededOffset;
+      ChangeScroll(horizontalOffset, verticalOffset);
+    }
+    SignalPageChange(page + 1, m_pages.size());
+  }
+
+  winrt::fire_and_forget RCTPdfControl::LoadPDF(std::unique_lock<std::shared_mutex> lock, int fitPolicy, bool singlePage) {
+    auto lifetime = get_strong();
+    auto pdfURI = m_pdfURI;
+    auto uri = Uri(winrt::to_hstring(pdfURI));
+    auto scheme = uri.SchemeName();
+    if (scheme == L"file") {
+      // backslashes only on Windows
+      std::replace(begin(pdfURI), end(pdfURI), '/', '\\');
+    }
+    PdfDocument document = nullptr;
+    try {
+      auto file = scheme == L"file"
+                  ? co_await StorageFile::GetFileFromPathAsync(winrt::to_hstring(pdfURI))
+                  : co_await StorageFile::GetFileFromApplicationUriAsync(uri);
+      document = co_await PdfDocument::LoadFromFileAsync(file, winrt::to_hstring(m_pdfPassword));
+    }
+    catch (winrt::hresult_error const& ex) {
+      switch (ex.to_abi()) {
+      case __HRESULT_FROM_WIN32(ERROR_WRONG_PASSWORD):
+        SignalError("Password required or incorrect password.");
+        co_return;
+      case E_FAIL:
+        SignalError("Document is not a valid PDF.");
+        co_return;
+      default:
+        SignalError(winrt::to_string(ex.message()));
+        co_return;
+      }
+    }
+    if (!document) {
+      SignalError("Could not load PDF.");
+      co_return;
+    }
+    auto items = Pages().Items();
+    items.Clear();
+    m_pages.clear();
+    SetOrientation(m_horizontal);
+    if (document.PageCount() == 0) {
+      if (fitPolicy != -1)
+        m_scale = 1;
+    }
+    else {
+      auto firstPageSize = document.GetPage(0).Size();
+      auto viewWidth = PagesContainer().ViewportWidth();
+      auto viewHeight = PagesContainer().ViewportHeight();
+      switch (fitPolicy) {
+      case 0:
+        m_scale = viewWidth / (firstPageSize.Width + 2 * (double)m_margins);
+        break;
+      case 1:
+        m_scale = viewHeight / (firstPageSize.Height + 2 * (double)m_margins);
+        break;
+      case 2:
+        m_scale = (std::min)(viewWidth / (firstPageSize.Width + 2 * (double)m_margins), viewHeight / (firstPageSize.Height + 2 * (double)m_margins));
+        break;
+      default:
+        break;
+      }
+    }
+    unsigned pagesCount = document.PageCount();
+    if (singlePage && pagesCount > 0)
+      pagesCount = 1;
+    for (unsigned pageIdx = 0; pageIdx < pagesCount; ++pageIdx) {
+      auto page = document.GetPage(pageIdx);
+      auto dims = page.Size();
+      Image pageImage;
+      pageImage.HorizontalAlignment(HorizontalAlignment::Center);
+      pageImage.AllowFocusOnInteraction(false);
+      Automation::AutomationProperties::SetName(pageImage, winrt::to_hstring("PDF Page " + std::to_string(pageIdx + 1)));
+      m_pages.emplace_back(pageImage, page, m_scale, 0);
+    }
+    if (m_enablePaging) {
+      items.Append(m_pages[m_currentPage].image);
+    } else {
+      if (m_reverse) {
+        for (int page = m_pages.size() - 1; page >= 0; --page)
+          items.Append(m_pages[page].image);
+      }
+      else {
+        for (int page = 0; page < (int)m_pages.size(); ++page)
+          items.Append(m_pages[page].image);
+      }
+    }
+    UpdatePagesInfoMarginOrScale();
+    lock.unlock();
+    std::shared_lock shared_lock(m_rwlock);
+    if (m_currentPage < 0)
+      m_currentPage = 0;
+    if (m_currentPage < (int)m_pages.size()) {
+      co_await m_pages[m_currentPage].render();
+      GoToPage(m_currentPage);
+    }
+    if (m_pages.empty()) {
+      SignalLoadComplete(0, 0, 0);
+    }
+    else {
+      SignalLoadComplete(m_pages.size(), m_pages.front().width, m_pages.front().height);
+    }
+    // Render low-res preview of the pages
+    double useScale = (std::min)(m_scale, m_previewZoom);
+    for (unsigned page = 0; page < m_pages.size(); ++page) {
+      co_await m_pages[page].render(useScale);
+    }
+  }
+
+  void RCTPdfControl::Rescale(double newScale, double newMargin, bool goToNewPosition) {
+    if (newScale != m_scale || newMargin != m_margins) {
+      double rescale = newScale / m_scale;
+      double targetHorizontalOffset = PagesContainer().HorizontalOffset() * rescale;
+      double targetVerticalOffset = PagesContainer().VerticalOffset() * rescale;
+      if (newMargin != m_margins) {
+        if (m_horizontal) {
+          targetVerticalOffset += (double)m_currentPage * 2 * (newMargin - m_margins) * rescale;
+        }
+        else {
+          targetHorizontalOffset += (double)m_currentPage * 2 * (newMargin - m_margins) * rescale;
+        }
+      }
+      m_scale = newScale;
+      m_margins = (int)newMargin;
+      UpdatePagesInfoMarginOrScale();
+      if (goToNewPosition) {
+        ChangeScroll(targetHorizontalOffset, targetVerticalOffset);
+      }
+      SignalScaleChanged(m_scale);
+    }
+  }
+
+  void RCTPdfControl::SetOrientation(bool horizontal) {
+    m_horizontal = horizontal;
+    StackPanel orientationSelector;
+    if (FindName(winrt::to_hstring("OrientationSelector")).try_as<StackPanel>(orientationSelector))
+    {
+      orientationSelector.Orientation(m_horizontal ? Orientation::Horizontal : Orientation::Vertical);
+    }
+  }
+
+  winrt::Windows::Foundation::IAsyncAction RCTPdfControl::RenderVisiblePages(int page) {
+    auto lifetime = get_strong();
+    auto container = PagesContainer();
+    auto currentHorizontalOffset = container.HorizontalOffset();
+    auto currentVerticalOffset = container.VerticalOffset();
+    double offsetStart = m_horizontal ? currentHorizontalOffset : currentVerticalOffset;
+    double viewSize = m_horizontal ? container.ViewportWidth() : container.ViewportHeight();
+    double offsetEnd = offsetStart + viewSize;
+    if (m_pages[page].needsRender()) {
+      co_await m_pages[page].render();
+    }
+    auto pageToRender = page + 1;
+    while (pageToRender < (int)m_pages.size() &&
+      m_pages[pageToRender].pageVisiblePixels(m_horizontal, offsetStart, offsetEnd) > 0) {
+      if (m_pages[pageToRender].needsRender()) {
+        co_await m_pages[pageToRender].render();
+      }
+      ++pageToRender;
+    }
+    if (pageToRender < (int)m_pages.size() && m_pages[pageToRender].needsRender()) {
+      co_await m_pages[pageToRender].render();
+    }
+    if (page >= 1 && m_pages[page - 1].needsRender()) {
+      co_await m_pages[page - 1].render();
+    }
+    if (page >= 2 && m_pages[page - 2].needsRender()) {
+      co_await m_pages[page - 2].render();
+    }
+  }
+
+  void RCTPdfControl::SignalError(const std::string& error) {
+    m_reactContext.DispatchEvent(
+      *this,
+      L"topChange",
+      [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+        eventDataWriter.WriteObjectBegin();
+        {
+          WriteProperty(eventDataWriter, L"message", winrt::to_hstring("error|" + error));
+        }
+        eventDataWriter.WriteObjectEnd();
+      });
+  }
+  void RCTPdfControl::SignalLoadComplete(int totalPages, int width, int height) {
+    auto message = "loadComplete|" +
+                   std::to_string(totalPages) + "|" +
+                   std::to_string(width) + "|" +
+                   std::to_string(height) + "|";
+    m_reactContext.DispatchEvent(
+      *this,
+      L"topChange",
+      [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+        eventDataWriter.WriteObjectBegin();
+        {
+          WriteProperty(eventDataWriter, L"message", winrt::to_hstring(message));
+        }
+        eventDataWriter.WriteObjectEnd();
+      });
+  }
+  void RCTPdfControl::SignalPageChange(int page, int totalPages) {
+    auto message = "pageChanged|" + std::to_string(page) + "|" + std::to_string(totalPages);
+    m_reactContext.DispatchEvent(
+      *this,
+      L"topChange",
+      [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+        eventDataWriter.WriteObjectBegin();
+        {
+          WriteProperty(eventDataWriter, L"message", winrt::to_hstring(message));
+        }
+        eventDataWriter.WriteObjectEnd();
+      });
+  }
+  void RCTPdfControl::SignalScaleChanged(double scale) {
+    m_reactContext.DispatchEvent(
+      *this,
+      L"topChange",
+      [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+        eventDataWriter.WriteObjectBegin();
+        {
+          WriteProperty(eventDataWriter, L"message", winrt::to_hstring("scale|" + std::to_string(scale)));
+        }
+        eventDataWriter.WriteObjectEnd();
+      });
+  }
+  void RCTPdfControl::SignalPageTapped(int page, int x, int y) {
+    const std::string message = "pageSingleTap|" +
+                                std::to_string(page + 1) + "|" +
+                                std::to_string(x) + "|" +
+                                std::to_string(y);
+    m_reactContext.DispatchEvent(
+      *this,
+      L"topChange",
+      [&](winrt::Microsoft::ReactNative::IJSValueWriter const& eventDataWriter) noexcept {
+        eventDataWriter.WriteObjectBegin();
+        {
+          WriteProperty(eventDataWriter, L"message", winrt::to_hstring(message));
+        }
+        eventDataWriter.WriteObjectEnd();
+      });
+  }
+}