Handle long press in PDF documents.

pdf/pdfium/pdfium_engine.cc

 // Copyright (c) 2012 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 "pdf/pdfium/pdfium_engine.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 70 matching lines @@
 const int32_t kHighlightColorG = 193;
 const int32_t kHighlightColorB = 218;
 
 const uint32_t kPendingPageColor = 0xFFEEEEEE;
 
 const uint32_t kFormHighlightColor = 0xFFE4DD;
 const int32_t kFormHighlightAlpha = 100;
 
 const int32_t kMaxPasswordTries = 3;
 
+const int32_t kTouchLongPressTimeoutMs = 300;
+
 // See Table 3.20 in
 // http://www.adobe.com/devnet/acrobat/pdfs/pdf_reference_1-7.pdf
 const uint32_t kPDFPermissionPrintLowQualityMask = 1 << 2;
 const uint32_t kPDFPermissionPrintHighQualityMask = 1 << 11;
 const uint32_t kPDFPermissionCopyMask = 1 << 4;
 const uint32_t kPDFPermissionCopyAccessibleMask = 1 << 9;
 
 const int32_t kLoadingTextVerticalOffset = 50;
 
 // The maximum amount of time we'll spend doing a paint before we give back
@@ skipping 587 matching lines @@
       defer_page_unload_(false),
       selecting_(false),
       mouse_down_state_(PDFiumPage::NONSELECTABLE_AREA,
                         PDFiumPage::LinkTarget()),
       next_page_to_search_(-1),
       last_page_to_search_(-1),
       last_character_index_to_search_(-1),
       permissions_(0),
       permissions_handler_revision_(-1),
       fpdf_availability_(nullptr),
-      next_timer_id_(0),
+      next_formfill_timer_id_(0),
       last_page_mouse_down_(-1),
       most_visible_page_(-1),
       called_do_document_action_(false),
       render_grayscale_(false),
       render_annots_(true),
       progressive_paint_timeout_(0),
       getting_password_(false) {
   find_factory_.Initialize(this);
   password_factory_.Initialize(this);
 
@@ skipping 637 matching lines @@
       break;
     case PP_INPUTEVENT_TYPE_KEYDOWN:
       rv = OnKeyDown(pp::KeyboardInputEvent(event));
       break;
     case PP_INPUTEVENT_TYPE_KEYUP:
       rv = OnKeyUp(pp::KeyboardInputEvent(event));
       break;
     case PP_INPUTEVENT_TYPE_CHAR:
       rv = OnChar(pp::KeyboardInputEvent(event));
       break;
+    case PP_INPUTEVENT_TYPE_TOUCHSTART: {
+      KillTouchTimer(next_touch_timer_id_);
+
+      pp::TouchInputEvent touch_event(event);
+      if (touch_event.GetTouchCount(PP_TOUCHLIST_TYPE_TARGETTOUCHES) == 1)
+        ScheduleTouchTimer(touch_event);
+      break;
+    }
+    case PP_INPUTEVENT_TYPE_TOUCHEND:
+      KillTouchTimer(next_touch_timer_id_);
+      break;
+    case PP_INPUTEVENT_TYPE_TOUCHMOVE:
+      // TODO(dsinclair): This should allow a little bit of movement (up to the
+      // touch radii) to account for finger jiggle.
+      KillTouchTimer(next_touch_timer_id_);
     default:
       break;
   }
 
   DCHECK(defer_page_unload_);
   defer_page_unload_ = false;
   for (int page_index : deferred_page_unloads_)
     pages_[page_index]->Unload();
   deferred_page_unloads_.clear();
   return rv;
@@ skipping 1146 matching lines @@
 
 int PDFiumEngine::GetVerticalScrollbarYPosition() {
   return position_.y();
 }
 
 void PDFiumEngine::SetGrayscale(bool grayscale) {
   render_grayscale_ = grayscale;
 }
 
 void PDFiumEngine::OnCallback(int id) {
-  if (!timers_.count(id))
+  if (!formfill_timers_.count(id))
     return;
 
-  timers_[id].second(id);
-  if (timers_.count(id))  // The callback might delete the timer.
-    client_->ScheduleCallback(id, timers_[id].first);
+  formfill_timers_[id].second(id);
+  if (formfill_timers_.count(id))  // The callback might delete the timer.
+    client_->ScheduleCallback(id, formfill_timers_[id].first);
+}
+
+void PDFiumEngine::OnTouchTimerCallback(int id) {
+  if (!touch_timers_.count(id))
+    return;
+
+  HandleLongPress(touch_timers_[id]);
+  KillTouchTimer(id);
+}
+
+void PDFiumEngine::HandleLongPress(const pp::TouchInputEvent& event) {
+  pp::FloatPoint fp =
+      event.GetTouchByIndex(PP_TOUCHLIST_TYPE_TARGETTOUCHES, 0).position();
+  pp::Point point;
+  point.set_x(fp.x());
+  point.set_y(fp.y());
+
+  // Send a fake mouse down to trigger the multi-click selection code.
+  pp::MouseInputEvent mouse_event(
+      client_->GetPluginInstance(), PP_INPUTEVENT_TYPE_MOUSEDOWN,
+      event.GetTimeStamp(), event.GetModifiers(),
+      PP_INPUTEVENT_MOUSEBUTTON_LEFT, point, 2, point);
+
+  OnMouseDown(mouse_event);
 }
 
 int PDFiumEngine::GetCharCount(int page_index) {
   DCHECK(PageIndexInBounds(page_index));
   return pages_[page_index]->GetCharCount();
 }
 
 pp::FloatRect PDFiumEngine::GetCharBounds(int page_index, int char_index) {
   DCHECK(PageIndexInBounds(page_index));
   return pages_[page_index]->GetCharBounds(char_index);
@@ skipping 1067 matching lines @@
   client_->ScrollToPage(most_visible_page);
 }
 
 void PDFiumEngine::SetSelecting(bool selecting) {
   bool was_selecting = selecting_;
   selecting_ = selecting;
   if (selecting_ != was_selecting)
     client_->IsSelectingChanged(selecting);
 }
 
+void PDFiumEngine::ScheduleTouchTimer(const pp::TouchInputEvent& evt) {
+  touch_timers_[++next_touch_timer_id_] = evt;
+  client_->ScheduleTouchTimerCallback(next_touch_timer_id_,
+                                      kTouchLongPressTimeoutMs);
+}
+
+void PDFiumEngine::KillTouchTimer(int timer_id) {
+  touch_timers_.erase(timer_id);
+}
+
 bool PDFiumEngine::PageIndexInBounds(int index) const {
   return index >= 0 && index < static_cast<int>(pages_.size());
 }
 
 void PDFiumEngine::Form_Invalidate(FPDF_FORMFILLINFO* param,
                                    FPDF_PAGE page,
                                    double left,
                                    double top,
                                    double right,
                                    double bottom) {
@@ skipping 31 matching lines @@
 
 void PDFiumEngine::Form_SetCursor(FPDF_FORMFILLINFO* param, int cursor_type) {
   // We don't need this since it's not enough to change the cursor in all
   // scenarios.  Instead, we check which form field we're under in OnMouseMove.
 }
 
 int PDFiumEngine::Form_SetTimer(FPDF_FORMFILLINFO* param,
                                 int elapse,
                                 TimerCallback timer_func) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
-  engine->timers_[++engine->next_timer_id_] =
+  engine->formfill_timers_[++engine->next_formfill_timer_id_] =
       std::pair<int, TimerCallback>(elapse, timer_func);
-  engine->client_->ScheduleCallback(engine->next_timer_id_, elapse);
-  return engine->next_timer_id_;
+  engine->client_->ScheduleCallback(engine->next_formfill_timer_id_, elapse);
+  return engine->next_formfill_timer_id_;
 }
 
 void PDFiumEngine::Form_KillTimer(FPDF_FORMFILLINFO* param, int timer_id) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
-  engine->timers_.erase(timer_id);
+  engine->formfill_timers_.erase(timer_id);
 }
 
 FPDF_SYSTEMTIME PDFiumEngine::Form_GetLocalTime(FPDF_FORMFILLINFO* param) {
   base::Time time = base::Time::Now();
   base::Time::Exploded exploded;
   time.LocalExplode(&exploded);
 
   FPDF_SYSTEMTIME rv;
   rv.wYear = exploded.year;
   rv.wMonth = exploded.month;
@@ skipping 514 matching lines @@
   FPDF_DOCUMENT doc =
       FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf