| // Copyright (c) 2010 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef PDF_PDF_H_ |
| #define PDF_PDF_H_ |
| |
| #include <vector> |
| |
| #include "base/containers/span.h" |
| #include "base/optional.h" |
| #include "base/values.h" |
| #include "build/build_config.h" |
| #include "build/chromeos_buildflags.h" |
| |
| #if defined(OS_WIN) |
| #include <windows.h> |
| #endif |
| |
| #if defined(OS_WIN) |
| typedef void (*PDFEnsureTypefaceCharactersAccessible)(const LOGFONT* font, |
| const wchar_t* text, |
| size_t text_length); |
| #endif |
| |
| namespace gfx { |
| class Rect; |
| class Size; |
| class SizeF; |
| } // namespace gfx |
| |
| namespace chrome_pdf { |
| |
| #if BUILDFLAG(IS_ASH) |
| // Create a flattened PDF document from an existing PDF document. |
| // |input_buffer| is the buffer that contains the entire PDF document to be |
| // flattened. |
| std::vector<uint8_t> CreateFlattenedPdf(base::span<const uint8_t> input_buffer); |
| #endif // BUILDFLAG(IS_ASH) |
| |
| #if defined(OS_WIN) |
| // Printing modes - type to convert PDF to for printing. See PDFium's |
| // FPDF_SetPrintMode() for details. |
| enum PrintingMode { |
| kEmf = 0, |
| kTextOnly = 1, |
| kPostScript2 = 2, |
| kPostScript3 = 3, |
| // Values 4 and 5 are similar to |kPostScript2| and |kPostScript3|, but are |
| // not intended for use in sandboxed environments like Chromium's. |
| kEmfWithReducedRasterization = 6, |
| }; |
| |
| // |pdf_buffer| is the buffer that contains the entire PDF document to be |
| // rendered. |
| // |page_number| is the 0-based index of the page to be rendered. |
| // |dc| is the device context to render into. |
| // |dpi_x| and |dpi_y| is the resolution. |
| // |bounds_origin_x|, |bounds_origin_y|, |bounds_width| and |bounds_height| |
| // specify a bounds rectangle within the DC in which to render the PDF |
| // page. |
| // |fit_to_bounds| specifies whether the output should be shrunk to fit the |
| // supplied bounds if the page size is larger than the bounds in any |
| // dimension. If this is false, parts of the PDF page that lie outside |
| // the bounds will be clipped. |
| // |stretch_to_bounds| specifies whether the output should be stretched to fit |
| // the supplied bounds if the page size is smaller than the bounds in any |
| // dimension. |
| // If both |fit_to_bounds| and |stretch_to_bounds| are true, then |
| // |fit_to_bounds| is honored first. |
| // |keep_aspect_ratio| If any scaling is to be done is true, this flag |
| // specifies whether the original aspect ratio of the page should be |
| // preserved while scaling. |
| // |center_in_bounds| specifies whether the final image (after any scaling is |
| // done) should be centered within the given bounds. |
| // |autorotate| specifies whether the final image should be rotated to match |
| // the output bound. |
| // |use_color| specifies color or grayscale. |
| // Returns false if the document or the page number are not valid. |
| bool RenderPDFPageToDC(base::span<const uint8_t> pdf_buffer, |
| int page_number, |
| HDC dc, |
| int dpi_x, |
| int dpi_y, |
| int bounds_origin_x, |
| int bounds_origin_y, |
| int bounds_width, |
| int bounds_height, |
| bool fit_to_bounds, |
| bool stretch_to_bounds, |
| bool keep_aspect_ratio, |
| bool center_in_bounds, |
| bool autorotate, |
| bool use_color); |
| |
| void SetPDFEnsureTypefaceCharactersAccessible( |
| PDFEnsureTypefaceCharactersAccessible func); |
| |
| void SetPDFUseGDIPrinting(bool enable); |
| |
| void SetPDFUsePrintMode(int mode); |
| #endif // defined(OS_WIN) |
| |
| // |page_count| and |max_page_width| are optional and can be NULL. |
| // Returns false if the document is not valid. |
| bool GetPDFDocInfo(base::span<const uint8_t> pdf_buffer, |
| int* page_count, |
| float* max_page_width); |
| |
| // Whether the PDF is Tagged (see 10.7 "Tagged PDF" in PDF Reference 1.7). |
| // Returns true if it's a tagged (accessible) PDF, false if it's a valid |
| // PDF but untagged, and nullopt if the PDF can't be parsed. |
| base::Optional<bool> IsPDFDocTagged(base::span<const uint8_t> pdf_buffer); |
| |
| // Given a tagged PDF (see IsPDFDocTagged, above), return the portion of |
| // the structure tree for a given page as a hierarchical tree of base::Values. |
| base::Value GetPDFStructTreeForPage(base::span<const uint8_t> pdf_buffer, |
| int page_index); |
| |
| // Gets the dimensions of a specific page in a document. |
| // |pdf_buffer| is the buffer that contains the entire PDF document to be |
| // rendered. |
| // |page_number| is the page number that the function will get the dimensions |
| // of. |
| // Returns the size of the page in points, or nullopt if the document or the |
| // page number are not valid. |
| base::Optional<gfx::SizeF> GetPDFPageSizeByIndex( |
| base::span<const uint8_t> pdf_buffer, |
| int page_number); |
| |
| enum class RenderDeviceType { |
| kDisplay, |
| kPrinter, |
| }; |
| |
| struct RenderOptions { |
| // Whether the output should be stretched to fit the supplied bitmap. |
| bool stretch_to_bounds; |
| // If any scaling is needed, whether the original aspect ratio of the page is |
| // preserved while scaling. |
| bool keep_aspect_ratio; |
| // Whether the final image should be rotated to match the output bound. |
| bool autorotate; |
| // Specifies color or grayscale. |
| bool use_color; |
| // What type of device to render for. |
| RenderDeviceType render_device_type; |
| }; |
| |
| // Renders PDF page into 4-byte per pixel BGRA color bitmap. |
| // |pdf_buffer| is the buffer that contains the entire PDF document to be |
| // rendered. |
| // |page_number| is the 0-based index of the page to be rendered. |
| // |bitmap_buffer| is the output buffer for bitmap. |
| // |bitmap_size| is the size of the output bitmap. |
| // |dpi| is the 2D resolution. |
| // |options| is the options to render with. |
| // Returns false if the document or the page number are not valid. |
| bool RenderPDFPageToBitmap(base::span<const uint8_t> pdf_buffer, |
| int page_number, |
| void* bitmap_buffer, |
| const gfx::Size& bitmap_size, |
| const gfx::Size& dpi, |
| const RenderOptions& options); |
| |
| // Convert multiple PDF pages into a N-up PDF. |
| // |input_buffers| is the vector of buffers with each buffer contains a PDF. |
| // If any of the PDFs contains multiple pages, only the first page of the |
| // document is used. |
| // |pages_per_sheet| is the number of pages to put on one sheet. |
| // |page_size| is the output page size, measured in PDF "user space" units. |
| // |printable_area| is the output page printable area, measured in PDF |
| // "user space" units. Should be smaller than |page_size|. |
| // |
| // |page_size| is the print media size. The page size of the output N-up PDF is |
| // determined by the |pages_per_sheet|, the orientation of the PDF pages |
| // contained in the |input_buffers|, and the media page size |page_size|. For |
| // example, when |page_size| = 512x792, |pages_per_sheet| = 2, and the |
| // orientation of |input_buffers| = portrait, the output N-up PDF will be |
| // 792x512. |
| // See printing::NupParameters for more details on how the output page |
| // orientation is determined, to understand why |page_size| may be swapped in |
| // some cases. |
| std::vector<uint8_t> ConvertPdfPagesToNupPdf( |
| std::vector<base::span<const uint8_t>> input_buffers, |
| size_t pages_per_sheet, |
| const gfx::Size& page_size, |
| const gfx::Rect& printable_area); |
| |
| // Convert a PDF document to a N-up PDF document. |
| // |input_buffer| is the buffer that contains the entire PDF document to be |
| // converted to a N-up PDF document. |
| // |pages_per_sheet| is the number of pages to put on one sheet. |
| // |page_size| is the output page size, measured in PDF "user space" units. |
| // |printable_area| is the output page printable area, measured in PDF |
| // "user space" units. Should be smaller than |page_size|. |
| // |
| // Refer to the description of ConvertPdfPagesToNupPdf to understand how the |
| // output page size will be calculated. |
| // The algorithm used to determine the output page size is the same. |
| std::vector<uint8_t> ConvertPdfDocumentToNupPdf( |
| base::span<const uint8_t> input_buffer, |
| size_t pages_per_sheet, |
| const gfx::Size& page_size, |
| const gfx::Rect& printable_area); |
| |
| } // namespace chrome_pdf |
| |
| #endif // PDF_PDF_H_ |