Allow pdfium_test to send simple events to each page.

samples/pdfium_test.cc

 // 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.
 
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <list>
@@ skipping 36 matching lines @@
 #ifdef _WIN32
   OUTPUT_BMP,
   OUTPUT_EMF,
 #endif
 #ifdef PDF_ENABLE_SKIA
   OUTPUT_SKP,
 #endif
 };
 
 struct Options {
-  Options() : show_config(false), output_format(OUTPUT_NONE) {}
+  Options()
+      : show_config(false), send_events(false), output_format(OUTPUT_NONE) {}
 
   bool show_config;
+  bool send_events;
   OutputFormat output_format;
   std::string scale_factor_as_string;
   std::string exe_path;
   std::string bin_directory;
   std::string font_directory;
 };
 
 static bool CheckDimensions(int stride, int width, int height) {
   if (stride < 0 || width < 0 || height < 0)
     return false;
@@ skipping 261 matching lines @@
                       Options* options, std::list<std::string>* files) {
   if (args.empty()) {
     return false;
   }
   options->exe_path = args[0];
   size_t cur_idx = 1;
   for (; cur_idx < args.size(); ++cur_idx) {
     const std::string& cur_arg = args[cur_idx];
     if (cur_arg == "--show-config") {
       options->show_config = true;
+    } else if (cur_arg == "--send-events") {
+      options->send_events = true;
     } else if (cur_arg == "--ppm") {
       if (options->output_format != OUTPUT_NONE) {
         fprintf(stderr, "Duplicate or conflicting --ppm argument\n");
         return false;
       }
       options->output_format = OUTPUT_PPM;
     } else if (cur_arg == "--png") {
       if (options->output_format != OUTPUT_NONE) {
         fprintf(stderr, "Duplicate or conflicting --png argument\n");
         return false;
@@ skipping 60 matching lines @@
   return true;
 }
 
 FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
   return true;
 }
 
 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
 }
 
+void SendPageEvents(const FPDF_FORMHANDLE& form,
+                    const FPDF_PAGE& page,
+                    const std::string& events) {
+  auto lines = StringSplit(events, '\n');
+  for (auto line : lines) {
+    auto command = StringSplit(line, '#');
+    if (command[0].empty())
+      continue;
+    auto tokens = StringSplit(command[0], ',');
+    if (tokens[0] == "keycode") {
+      if (tokens.size() == 2) {
+        int keycode = atoi(tokens[1].c_str());
+        FORM_OnKeyDown(form, page, keycode, 0);
+        FORM_OnKeyUp(form, page, keycode, 0);
+      } else {
+        fprintf(stderr, "keycode: bad args\n");
+      }
+    } else if (tokens[0] == "mousedown") {
+      if (tokens.size() == 4) {
+        int x = atoi(tokens[2].c_str());
+        int y = atoi(tokens[3].c_str());
+        if (tokens[1] == "left")
+          FORM_OnLButtonDown(form, page, 0, x, y);
+        else if (tokens[1] == "right")
+          FORM_OnRButtonDown(form, page, 0, x, y);
+        else
+          fprintf(stderr, "mousedown: bad button name\n");
+      } else {
+        fprintf(stderr, "mousedown: bad args\n");
+      }
+    } else if (tokens[0] == "mouseup") {
+      if (tokens.size() == 4) {
+        int x = atoi(tokens[2].c_str());
+        int y = atoi(tokens[3].c_str());
+        if (tokens[1] == "left")
+          FORM_OnLButtonUp(form, page, 0, x, y);
+        else if (tokens[1] == "right")
+          FORM_OnRButtonUp(form, page, 0, x, y);
+        else
+          fprintf(stderr, "mouseup: bad button name\n");
+      } else {
+        fprintf(stderr, "mouseup: bad args\n");
+      }
+    } else if (tokens[0] == "mousemove") {
+      if (tokens.size() == 3) {
+        int x = atoi(tokens[1].c_str());
+        int y = atoi(tokens[2].c_str());
+        FORM_OnMouseMove(form, page, 0, x, y);
+      } else {
+        fprintf(stderr, "mousemove: bad args\n");
+      }
+    } else {
+      fprintf(stderr, "Unrecognined event: %s\n", tokens[0].c_str());

[Lei Zhang, 2016/04/18 22:49:10]

typo

[Tom Sepez, 2016/04/18 23:02:11]

Done.

+    }
+  }
+}
+
 bool RenderPage(const std::string& name,
                 const FPDF_DOCUMENT& doc,
                 const FPDF_FORMHANDLE& form,
                 const int page_index,
-                const Options& options) {
+                const Options& options,
+                const std::string& events) {
   FPDF_PAGE page = FPDF_LoadPage(doc, page_index);
   if (!page) {
     return false;
   }
   FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
   FORM_OnAfterLoadPage(page, form);
   FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
 
+  if (options.send_events)
+    SendPageEvents(doc, form, events);
+
   double scale = 1.0;
   if (!options.scale_factor_as_string.empty()) {
     std::stringstream(options.scale_factor_as_string) >> scale;
   }
   int width = static_cast<int>(FPDF_GetPageWidth(page) * scale);
   int height = static_cast<int>(FPDF_GetPageHeight(page) * scale);
   int alpha = FPDFPage_HasTransparency(page) ? 1 : 0;
   FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, alpha);
   if (!bitmap) {
     fprintf(stderr, "Page was too large to be rendered.\n");
@@ skipping 39 matching lines @@
   }
 
   FPDFBitmap_Destroy(bitmap);
   FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
   FORM_OnBeforeClosePage(page, form);
   FPDFText_ClosePage(text_page);
   FPDF_ClosePage(page);
   return true;
 }
 
-void RenderPdf(const std::string& name, const char* pBuf, size_t len,
-               const Options& options) {
+void RenderPdf(const std::string& name,
+               const char* pBuf,
+               size_t len,
+               const Options& options,
+               const std::string& events) {
   fprintf(stderr, "Rendering PDF file %s.\n", name.c_str());
 
   IPDF_JSPLATFORM platform_callbacks;
   memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
   platform_callbacks.version = 3;
   platform_callbacks.app_alert = ExampleAppAlert;
   platform_callbacks.app_response = ExampleAppResponse;
   platform_callbacks.Doc_gotoPage = ExampleDocGotoPage;
   platform_callbacks.Doc_mail = ExampleDocMail;
 
@@ skipping 111 matching lines @@
       nRet = PDF_DATA_NOTAVAIL;
       while (nRet == PDF_DATA_NOTAVAIL) {
         nRet = FPDFAvail_IsPageAvail(pdf_avail, i, &hints);
       }
       if (nRet == PDF_DATA_ERROR) {
         fprintf(stderr, "Unknown error in checking if page %d is available.\n",
                 i);
         return;
       }
     }
-    if (RenderPage(name, doc, form, i, options)) {
+    if (RenderPage(name, doc, form, i, options, events)) {
       ++rendered_pages;
     } else {
       ++bad_pages;
     }
   }
 
   FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
 
 #ifdef PDF_ENABLE_XFA
   // Note: The shut down order here is the reverse of the non-XFA branch order.
@@ skipping 100 matching lines @@
   unsuppored_info.FSDK_UnSupport_Handler = ExampleUnsupportedHandler;
 
   FSDK_SetUnSpObjProcessHandler(&unsuppored_info);
 
   while (!files.empty()) {
     std::string filename = files.front();
     files.pop_front();
     size_t file_length = 0;
     std::unique_ptr<char, pdfium::FreeDeleter> file_contents =
         GetFileContents(filename.c_str(), &file_length);
-    if (file_contents)
-      RenderPdf(filename, file_contents.get(), file_length, options);
+    if (!file_contents)
+      continue;
+    std::string events;
+    if (options.send_events) {
+      std::string event_filename = filename;
+      size_t event_length = 0;
+      size_t extension_pos = event_filename.find(".pdf");
+      if (extension_pos != std::string::npos) {
+        event_filename.replace(extension_pos, 4, ".evt");
+        std::unique_ptr<char, pdfium::FreeDeleter> event_contents =
+            GetFileContents(event_filename.c_str(), &event_length);
+        if (event_contents)
+          events = std::string(event_contents.get(), event_length);
+        else

[Lei Zhang, 2016/04/18 22:49:10]

braces

+          fprintf(stderr, "Warning: no event file: %s\n",
+                  event_filename.c_str());
+      }
+    }
+    RenderPdf(filename, file_contents.get(), file_length, options, events);
   }
 
   FPDF_DestroyLibrary();
 #ifdef PDF_ENABLE_V8
   v8::V8::ShutdownPlatform();
   delete platform;
 #endif  // PDF_ENABLE_V8
 
   return 0;
 }