pdf/pdf_engine.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef PDF_PDF_ENGINE_H_
   6 #define PDF_PDF_ENGINE_H_
   7
   8 #include "build/build_config.h"
   9
  10 #if defined(OS_WIN)
  11 #include <windows.h>
  12 #endif
  13
  14 #include <string>
  15 #include <vector>
  16
  17 #include "base/strings/string16.h"
  18
  19 #include "ppapi/c/dev/pp_cursor_type_dev.h"
  20 #include "ppapi/c/dev/ppp_printing_dev.h"
  21 #include "ppapi/c/ppb_input_event.h"
  22 #include "ppapi/cpp/completion_callback.h"
  23 #include "ppapi/cpp/image_data.h"
  24 #include "ppapi/cpp/rect.h"
  25 #include "ppapi/cpp/size.h"
  26 #include "ppapi/cpp/url_loader.h"
  27 #include "ppapi/cpp/var_array.h"
  28
  29 namespace pp {
  30 class InputEvent;
  31 class VarDictionary;
  32 }
  33
  34 namespace chrome_pdf {
  35
  36 class Stream;
  37
  38 #if defined(OS_MACOSX)
  39 const uint32 kDefaultKeyModifier = PP_INPUTEVENT_MODIFIER_METAKEY;
  40 #else  // !OS_MACOSX
  41 const uint32 kDefaultKeyModifier = PP_INPUTEVENT_MODIFIER_CONTROLKEY;
  42 #endif  // OS_MACOSX
  43
  44 // Do one time initialization of the SDK.
  45 bool InitializeSDK();
  46 // Tells the SDK that we're shutting down.
  47 void ShutdownSDK();
  48
  49 // This class encapsulates a PDF rendering engine.
  50 class PDFEngine {
  51  public:
  52   enum DocumentPermission {
  53     PERMISSION_COPY,
  54     PERMISSION_COPY_ACCESSIBLE,
  55     PERMISSION_PRINT_LOW_QUALITY,
  56     PERMISSION_PRINT_HIGH_QUALITY,
  57   };
  58
  59   // The interface that's provided to the rendering engine.
  60   class Client {
  61    public:
  62     // Informs the client about the document's size in pixels.
  63     virtual void DocumentSizeUpdated(const pp::Size& size) = 0;
  64
  65     // Informs the client that the given rect needs to be repainted.
  66     virtual void Invalidate(const pp::Rect& rect) = 0;
  67
  68     // Informs the client to scroll the plugin area by the given offset.
  69     virtual void Scroll(const pp::Point& point) = 0;
  70
  71     // Scroll the horizontal/vertical scrollbars to a given position.
  72     virtual void ScrollToX(int position) = 0;
  73     virtual void ScrollToY(int position) = 0;
  74
  75     // Scroll to the specified page.
  76     virtual void ScrollToPage(int page) = 0;
  77
  78     // Navigate to the given url.
  79     virtual void NavigateTo(const std::string& url, bool open_in_new_tab) = 0;
  80
  81     // Updates the cursor.
  82     virtual void UpdateCursor(PP_CursorType_Dev cursor) = 0;
  83
  84     // Updates the tick marks in the vertical scrollbar.
  85     virtual void UpdateTickMarks(const std::vector<pp::Rect>& tickmarks) = 0;
  86
  87     // Updates the number of find results for the current search term.  If
  88     // there are no matches 0 should be passed in.  Only when the plugin has
  89     // finished searching should it pass in the final count with final_result
  90     // set to true.
  91     virtual void NotifyNumberOfFindResultsChanged(int total,
  92                                                   bool final_result) = 0;
  93
  94     // Updates the index of the currently selected search item.
  95     virtual void NotifySelectedFindResultChanged(int current_find_index) = 0;
  96
  97     // Prompts the user for a password to open this document. The callback is
  98     // called when the password is retrieved.
  99     virtual void GetDocumentPassword(
 100         pp::CompletionCallbackWithOutput<pp::Var> callback) = 0;
 101
 102     // Puts up an alert with the given message.
 103     virtual void Alert(const std::string& message) = 0;
 104
 105     // Puts up a confirm with the given message, and returns true if the user
 106     // presses OK, or false if they press cancel.
 107     virtual bool Confirm(const std::string& message) = 0;
 108
 109     // Puts up a prompt with the given message and default answer and returns
 110     // the answer.
 111     virtual std::string Prompt(const std::string& question,
 112                                const std::string& default_answer) = 0;
 113
 114     // Returns the url of the pdf.
 115     virtual std::string GetURL() = 0;
 116
 117     // Send an email.
 118     virtual void Email(const std::string& to,
 119                        const std::string& cc,
 120                        const std::string& bcc,
 121                        const std::string& subject,
 122                        const std::string& body) = 0;
 123
 124     // Put up the print dialog.
 125     virtual void Print() = 0;
 126
 127     // Submit the data using HTTP POST.
 128     virtual void SubmitForm(const std::string& url,
 129                             const void* data,
 130                             int length) = 0;
 131
 132     // Pops up a file selection dialog and returns the result.
 133     virtual std::string ShowFileSelectionDialog() = 0;
 134
 135     // Creates and returns new URL loader for partial document requests.
 136     virtual pp::URLLoader CreateURLLoader() = 0;
 137
 138     // Calls the client's OnCallback() function in delay_in_ms with the given
 139     // id.
 140     virtual void ScheduleCallback(int id, int delay_in_ms) = 0;
 141
 142     // Searches the given string for "term" and returns the results.  Unicode-
 143     // aware.
 144     struct SearchStringResult {
 145       int start_index;
 146       int length;
 147     };
 148     virtual void SearchString(const base::char16* string,
 149                               const base::char16* term,
 150                               bool case_sensitive,
 151                               std::vector<SearchStringResult>* results) = 0;
 152
 153     // Notifies the client that the engine has painted a page from the document.
 154     virtual void DocumentPaintOccurred() = 0;
 155
 156     // Notifies the client that the document has finished loading.
 157     virtual void DocumentLoadComplete(int page_count) = 0;
 158
 159     // Notifies the client that the document has failed to load.
 160     virtual void DocumentLoadFailed() = 0;
 161
 162     virtual pp::Instance* GetPluginInstance() = 0;
 163
 164     // Notifies that an unsupported feature in the PDF was encountered.
 165     virtual void DocumentHasUnsupportedFeature(const std::string& feature) = 0;
 166
 167     // Notifies the client about document load progress.
 168     virtual void DocumentLoadProgress(uint32 available, uint32 doc_size) = 0;
 169
 170     // Notifies the client about focus changes for form text fields.
 171     virtual void FormTextFieldFocusChange(bool in_focus) = 0;
 172
 173     // Returns true if the plugin has been opened within print preview.
 174     virtual bool IsPrintPreview() = 0;
 175
 176     // Get the background color of the PDF.
 177     virtual uint32 GetBackgroundColor() = 0;
 178
 179     // Sets selection status.
 180     virtual void IsSelectingChanged(bool is_selecting) {}
 181   };
 182
 183   // Factory method to create an instance of the PDF Engine.
 184   static PDFEngine* Create(Client* client);
 185
 186   virtual ~PDFEngine() {}
 187
 188   // Most of these functions are similar to the Pepper functions of the same
 189   // name, so not repeating the description here unless it's different.
 190   virtual bool New(const char* url, const char* headers) = 0;
 191   virtual void PageOffsetUpdated(const pp::Point& page_offset) = 0;
 192   virtual void PluginSizeUpdated(const pp::Size& size) = 0;
 193   virtual void ScrolledToXPosition(int position) = 0;
 194   virtual void ScrolledToYPosition(int position) = 0;
 195   // Paint is called a series of times. Before these n calls are made, PrePaint
 196   // is called once. After Paint is called n times, PostPaint is called once.
 197   virtual void PrePaint() = 0;
 198   virtual void Paint(const pp::Rect& rect,
 199                      pp::ImageData* image_data,
 200                      std::vector<pp::Rect>* ready,
 201                      std::vector<pp::Rect>* pending) = 0;
 202   virtual void PostPaint() = 0;
 203   virtual bool HandleDocumentLoad(const pp::URLLoader& loader) = 0;
 204   virtual bool HandleEvent(const pp::InputEvent& event) = 0;
 205   virtual uint32_t QuerySupportedPrintOutputFormats() = 0;
 206   virtual void PrintBegin() = 0;
 207   virtual pp::Resource PrintPages(
 208       const PP_PrintPageNumberRange_Dev* page_ranges,
 209       uint32_t page_range_count,
 210       const PP_PrintSettings_Dev& print_settings) = 0;
 211   virtual void PrintEnd() = 0;
 212   virtual void StartFind(const char* text, bool case_sensitive) = 0;
 213   virtual bool SelectFindResult(bool forward) = 0;
 214   virtual void StopFind() = 0;
 215   virtual void ZoomUpdated(double new_zoom_level) = 0;
 216   virtual void RotateClockwise() = 0;
 217   virtual void RotateCounterclockwise() = 0;
 218   virtual std::string GetSelectedText() = 0;
 219   virtual std::string GetLinkAtPosition(const pp::Point& point) = 0;
 220   virtual bool IsSelecting() = 0;
 221   // Checks the permissions associated with this document.
 222   virtual bool HasPermission(DocumentPermission permission) const = 0;
 223   virtual void SelectAll() = 0;
 224   // Gets the number of pages in the document.
 225   virtual int GetNumberOfPages() = 0;
 226   // Gets the 0-based page number of |destination|, or -1 if it does not exist.
 227   virtual int GetNamedDestinationPage(const std::string& destination) = 0;
 228   // Gets the index of the first visible page, or -1 if none are visible.
 229   virtual int GetFirstVisiblePage() = 0;
 230   // Gets the index of the most visible page, or -1 if none are visible.
 231   virtual int GetMostVisiblePage() = 0;
 232   // Gets the rectangle of the page including shadow.
 233   virtual pp::Rect GetPageRect(int index) = 0;
 234   // Gets the rectangle of the page excluding any additional areas.
 235   virtual pp::Rect GetPageContentsRect(int index) = 0;
 236   // Gets the offset of the vertical scrollbar from the top in document
 237   // coordinates.
 238   virtual int GetVerticalScrollbarYPosition() = 0;
 239   // Paints page thumbnail to the ImageData.
 240   virtual void PaintThumbnail(pp::ImageData* image_data, int index) = 0;
 241   // Set color / grayscale rendering modes.
 242   virtual void SetGrayscale(bool grayscale) = 0;
 243   // Callback for timer that's set with ScheduleCallback().
 244   virtual void OnCallback(int id) = 0;
 245   // Gets the JSON representation of the PDF file
 246   virtual std::string GetPageAsJSON(int index) = 0;
 247   // Gets the PDF document's print scaling preference. True if the document can
 248   // be scaled to fit.
 249   virtual bool GetPrintScaling() = 0;
 250   // Returns number of copies to be printed.
 251   virtual int GetCopiesToPrint() = 0;
 252   // Returns the duplex setting.
 253   virtual int GetDuplexType() = 0;
 254   // Returns true if all the pages are the same size.
 255   virtual bool GetPageSizeAndUniformity(pp::Size* size) = 0;
 256
 257   // Returns a VarArray of Bookmarks, each a VarDictionary containing the
 258   // following key/values:
 259   // - "title" - a string Var.
 260   // - "page" - an int Var.
 261   // - "children" - a VarArray(), with each entry containing a VarDictionary of
 262   //   the same structure.
 263   virtual pp::VarArray GetBookmarks() = 0;
 264
 265   // Append blank pages to make a 1-page document to a |num_pages| document.
 266   // Always retain the first page data.
 267   virtual void AppendBlankPages(int num_pages) = 0;
 268   // Append the first page of the document loaded with the |engine| to this
 269   // document at page |index|.
 270   virtual void AppendPage(PDFEngine* engine, int index) = 0;
 271
 272   // Allow client to query and reset scroll positions in document coordinates.
 273   // Note that this is meant for cases where the device scale factor changes,
 274   // and not for general scrolling - the engine will not repaint due to this.
 275   virtual pp::Point GetScrollPosition() = 0;
 276   virtual void SetScrollPosition(const pp::Point& position) = 0;
 277
 278   virtual bool IsProgressiveLoad() = 0;
 279 };
 280
 281 // Interface for exports that wrap the PDF engine.
 282 class PDFEngineExports {
 283  public:
 284   struct RenderingSettings {
 285     RenderingSettings(int dpi_x,
 286                       int dpi_y,
 287                       const pp::Rect& bounds,
 288                       bool fit_to_bounds,
 289                       bool stretch_to_bounds,
 290                       bool keep_aspect_ratio,
 291                       bool center_in_bounds,
 292                       bool autorotate)
 293         : dpi_x(dpi_x), dpi_y(dpi_y), bounds(bounds),
 294         fit_to_bounds(fit_to_bounds), stretch_to_bounds(stretch_to_bounds),
 295         keep_aspect_ratio(keep_aspect_ratio),
 296         center_in_bounds(center_in_bounds), autorotate(autorotate) {
 297     }
 298     int dpi_x;
 299     int dpi_y;
 300     pp::Rect bounds;
 301     bool fit_to_bounds;
 302     bool stretch_to_bounds;
 303     bool keep_aspect_ratio;
 304     bool center_in_bounds;
 305     bool autorotate;
 306   };
 307
 308   PDFEngineExports() {}
 309   virtual ~PDFEngineExports() {}
 310   static PDFEngineExports* Create();
 311 #if defined(OS_WIN)
 312   // See the definition of RenderPDFPageToDC in pdf.cc for details.
 313   virtual bool RenderPDFPageToDC(const void* pdf_buffer,
 314                                  int buffer_size,
 315                                  int page_number,
 316                                  const RenderingSettings& settings,
 317                                  HDC dc) = 0;
 318 #endif  // OS_WIN
 319   // See the definition of RenderPDFPageToBitmap in pdf.cc for details.
 320   virtual bool RenderPDFPageToBitmap(const void* pdf_buffer,
 321                                      int pdf_buffer_size,
 322                                      int page_number,
 323                                      const RenderingSettings& settings,
 324                                      void* bitmap_buffer) = 0;
 325
 326   virtual bool GetPDFDocInfo(const void* pdf_buffer,
 327                              int buffer_size,
 328                              int* page_count,
 329                              double* max_page_width) = 0;
 330
 331   // See the definition of GetPDFPageSizeByIndex in pdf.cc for details.
 332   virtual bool GetPDFPageSizeByIndex(const void* pdf_buffer,
 333                                      int pdf_buffer_size, int page_number,
 334                                      double* width, double* height) = 0;
 335 };
 336
 337 }  // namespace chrome_pdf
 338
 339 #endif  // PDF_PDF_ENGINE_H_