pdf/document_layout.h - chromium/src - Git at Google

 // Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef PDF_DOCUMENT_LAYOUT_H_
 #define PDF_DOCUMENT_LAYOUT_H_

 #include <cstddef>
 #include <vector>

 #include "base/check_op.h"
 #include "base/i18n/rtl.h"
 #include "base/values.h"
 #include "pdf/draw_utils/coordinates.h"
 #include "pdf/page_orientation.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"

 namespace chrome_pdf {

 // Layout of pages within a PDF document. Pages are placed as rectangles
 // (possibly rotated) in a non-overlapping vertical sequence.
 //
 // All layout units are pixels.
 //
 // The `Options` class controls the behavior of the layout, such as the default
 // orientation of pages.
 class DocumentLayout final {
  public:
   // TODO(crbug.com/1144505): Add `kTwoUpEven` page spread support.
   enum class PageSpread {
     kOneUp = 0,     // One page per spread.
     kTwoUpOdd = 1,  // Two pages per spread, with odd pages first.
   };

   // Options controlling layout behavior.
   class Options final {
    public:
     Options();

     Options(const Options& other);
     Options& operator=(const Options& other);

     ~Options();

     friend bool operator==(const Options& lhs, const Options& rhs) {
       return lhs.direction() == rhs.direction() &&
              lhs.default_page_orientation() == rhs.default_page_orientation() &&
              lhs.page_spread() == rhs.page_spread();
     }

     friend bool operator!=(const Options& lhs, const Options& rhs) {
       return !(lhs == rhs);
     }

     // Serializes layout options to a base::Value::Dict.
     base::Value::Dict ToValue() const;

     // Deserializes layout options from a base::Value::Dict.
     void FromValue(const base::Value::Dict& value);

     // Page layout direction. This is tied to the direction of the user's UI,
     // rather than the direction of individual pages.
     base::i18n::TextDirection direction() const { return direction_; }

     void set_direction(base::i18n::TextDirection direction) {
       direction_ = direction;
     }

     PageOrientation default_page_orientation() const {
       return default_page_orientation_;
     }

     // Rotates default page orientation 90 degrees clockwise.
     void RotatePagesClockwise();

     // Rotates default page orientation 90 degrees counterclockwise.
     void RotatePagesCounterclockwise();

     PageSpread page_spread() const { return page_spread_; }

     // Changes two-up view status.
     void set_page_spread(PageSpread spread) { page_spread_ = spread; }

    private:
     base::i18n::TextDirection direction_ = base::i18n::UNKNOWN_DIRECTION;
     PageOrientation default_page_orientation_ = PageOrientation::kOriginal;
     PageSpread page_spread_ = PageSpread::kOneUp;
   };

   static const draw_utils::PageInsetSizes kSingleViewInsets;
   static constexpr int32_t kBottomSeparator = 4;
   static constexpr int32_t kHorizontalSeparator = 1;

   DocumentLayout();

   DocumentLayout(const DocumentLayout& other) = delete;
   DocumentLayout& operator=(const DocumentLayout& other) = delete;

   ~DocumentLayout();

   // Returns the layout options.
   const Options& options() const { return options_; }

   // Sets the layout options. If certain options with immediate effect change
   // (such as the default page orientation), the layout will be marked dirty.
   //
   // TODO(kmoon): We shouldn't have layout options that take effect immediately.
   void SetOptions(const Options& options);

   // Returns true if the layout has been modified since the last call to
   // clear_dirty(). The initial state is false (clean), which assumes
   // appropriate default behavior for an initially empty layout.
   bool dirty() const { return dirty_; }

   // Clears the dirty() state of the layout. This should be called after any
   // layout changes have been applied.
   void clear_dirty() { dirty_ = false; }

   // Returns the layout's total size.
   const gfx::Size& size() const { return size_; }

   size_t page_count() const { return page_layouts_.size(); }

   // Gets the layout rectangle for a page. Only valid after computing a layout.
   const gfx::Rect& page_rect(size_t page_index) const {
     DCHECK_LT(page_index, page_count());
     return page_layouts_[page_index].outer_rect;
   }

   // Gets the layout rectangle for a page's bounds (which excludes additional
   // regions like page shadows). Only valid after computing a layout.
   const gfx::Rect& page_bounds_rect(size_t page_index) const {
     DCHECK_LT(page_index, page_count());
     return page_layouts_[page_index].inner_rect;
   }

   // Computes the layout for a given list of `page_sizes` based on `options_`.
   void ComputeLayout(const std::vector<gfx::Size>& page_sizes);

  private:
   // Layout of a single page.
   struct PageLayout {
     // Bounding rectangle for the page with decorations.
     gfx::Rect outer_rect;

     // Bounding rectangle for the page without decorations.
     gfx::Rect inner_rect;
   };

   // Helpers for ComputeLayout() handling different page spreads.
   void ComputeOneUpLayout(const std::vector<gfx::Size>& page_sizes);
   void ComputeTwoUpOddLayout(const std::vector<gfx::Size>& page_sizes);

   // Copies `source_rect` to `destination_rect`, setting `dirty_` to true if
   // `destination_rect` is modified as a result.
   void CopyRectIfModified(const gfx::Rect& source_rect,
                           gfx::Rect& destination_rect);

   Options options_;

   // Indicates if the layout has changed in an externally-observable way,
   // usually as a result of calling `ComputeLayout()` with different inputs.
   //
   // Some operations that may trigger layout changes:
   // * Changing page sizes
   // * Adding or removing pages
   // * Changing page orientations
   bool dirty_ = false;

   // Layout's total size.
   gfx::Size size_;

   std::vector<PageLayout> page_layouts_;
 };

 }  // namespace chrome_pdf

 #endif  // PDF_DOCUMENT_LAYOUT_H_
	// Copyright 2019 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef PDF_DOCUMENT_LAYOUT_H_
	#define PDF_DOCUMENT_LAYOUT_H_

	#include <cstddef>
	#include <vector>

	#include "base/check_op.h"
	#include "base/i18n/rtl.h"
	#include "base/values.h"
	#include "pdf/draw_utils/coordinates.h"
	#include "pdf/page_orientation.h"
	#include "ui/gfx/geometry/rect.h"
	#include "ui/gfx/geometry/size.h"

	namespace chrome_pdf {

	// Layout of pages within a PDF document. Pages are placed as rectangles
	// (possibly rotated) in a non-overlapping vertical sequence.
	//
	// All layout units are pixels.
	//
	// The `Options` class controls the behavior of the layout, such as the default
	// orientation of pages.
	class DocumentLayout final {
	public:
	// TODO(crbug.com/1144505): Add `kTwoUpEven` page spread support.
	enum class PageSpread {
	kOneUp = 0, // One page per spread.
	kTwoUpOdd = 1, // Two pages per spread, with odd pages first.
	};

	// Options controlling layout behavior.
	class Options final {
	public:
	Options();

	Options(const Options& other);
	Options& operator=(const Options& other);

	~Options();

	friend bool operator==(const Options& lhs, const Options& rhs) {
	return lhs.direction() == rhs.direction() &&
	lhs.default_page_orientation() == rhs.default_page_orientation() &&
	lhs.page_spread() == rhs.page_spread();
	}

	friend bool operator!=(const Options& lhs, const Options& rhs) {
	return !(lhs == rhs);
	}

	// Serializes layout options to a base::Value::Dict.
	base::Value::Dict ToValue() const;

	// Deserializes layout options from a base::Value::Dict.
	void FromValue(const base::Value::Dict& value);

	// Page layout direction. This is tied to the direction of the user's UI,
	// rather than the direction of individual pages.
	base::i18n::TextDirection direction() const { return direction_; }

	void set_direction(base::i18n::TextDirection direction) {
	direction_ = direction;
	}

	PageOrientation default_page_orientation() const {
	return default_page_orientation_;
	}

	// Rotates default page orientation 90 degrees clockwise.
	void RotatePagesClockwise();

	// Rotates default page orientation 90 degrees counterclockwise.
	void RotatePagesCounterclockwise();

	PageSpread page_spread() const { return page_spread_; }

	// Changes two-up view status.
	void set_page_spread(PageSpread spread) { page_spread_ = spread; }

	private:
	base::i18n::TextDirection direction_ = base::i18n::UNKNOWN_DIRECTION;
	PageOrientation default_page_orientation_ = PageOrientation::kOriginal;
	PageSpread page_spread_ = PageSpread::kOneUp;
	};

	static const draw_utils::PageInsetSizes kSingleViewInsets;
	static constexpr int32_t kBottomSeparator = 4;
	static constexpr int32_t kHorizontalSeparator = 1;

	DocumentLayout();

	DocumentLayout(const DocumentLayout& other) = delete;
	DocumentLayout& operator=(const DocumentLayout& other) = delete;

	~DocumentLayout();

	// Returns the layout options.
	const Options& options() const { return options_; }

	// Sets the layout options. If certain options with immediate effect change
	// (such as the default page orientation), the layout will be marked dirty.
	//
	// TODO(kmoon): We shouldn't have layout options that take effect immediately.
	void SetOptions(const Options& options);

	// Returns true if the layout has been modified since the last call to
	// clear_dirty(). The initial state is false (clean), which assumes
	// appropriate default behavior for an initially empty layout.
	bool dirty() const { return dirty_; }

	// Clears the dirty() state of the layout. This should be called after any
	// layout changes have been applied.
	void clear_dirty() { dirty_ = false; }

	// Returns the layout's total size.
	const gfx::Size& size() const { return size_; }

	size_t page_count() const { return page_layouts_.size(); }

	// Gets the layout rectangle for a page. Only valid after computing a layout.
	const gfx::Rect& page_rect(size_t page_index) const {
	DCHECK_LT(page_index, page_count());
	return page_layouts_[page_index].outer_rect;
	}

	// Gets the layout rectangle for a page's bounds (which excludes additional
	// regions like page shadows). Only valid after computing a layout.
	const gfx::Rect& page_bounds_rect(size_t page_index) const {
	DCHECK_LT(page_index, page_count());
	return page_layouts_[page_index].inner_rect;
	}

	// Computes the layout for a given list of `page_sizes` based on `options_`.
	void ComputeLayout(const std::vector<gfx::Size>& page_sizes);

	private:
	// Layout of a single page.
	struct PageLayout {
	// Bounding rectangle for the page with decorations.
	gfx::Rect outer_rect;

	// Bounding rectangle for the page without decorations.
	gfx::Rect inner_rect;
	};

	// Helpers for ComputeLayout() handling different page spreads.
	void ComputeOneUpLayout(const std::vector<gfx::Size>& page_sizes);
	void ComputeTwoUpOddLayout(const std::vector<gfx::Size>& page_sizes);

	// Copies `source_rect` to `destination_rect`, setting `dirty_` to true if
	// `destination_rect` is modified as a result.
	void CopyRectIfModified(const gfx::Rect& source_rect,
	gfx::Rect& destination_rect);

	Options options_;

	// Indicates if the layout has changed in an externally-observable way,
	// usually as a result of calling `ComputeLayout()` with different inputs.
	//
	// Some operations that may trigger layout changes:
	// * Changing page sizes
	// * Adding or removing pages
	// * Changing page orientations
	bool dirty_ = false;

	// Layout's total size.
	gfx::Size size_;

	std::vector<PageLayout> page_layouts_;
	};

	} // namespace chrome_pdf

	#endif // PDF_DOCUMENT_LAYOUT_H_