Improved Pinch-Zoom for PDF.

pdf/paint_manager.h

 // 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_PAINT_MANAGER_H_
 #define PDF_PAINT_MANAGER_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 128 matching lines @@
   // The given rect should be scrolled by the given amounts.
   void ScrollRect(const pp::Rect& clip_rect, const pp::Point& amount);
 
   // Returns the size of the graphics context for the next paint operation.
   // This is the pending size if a resize is pending (the plugin has called
   // SetSize but we haven't actually painted it yet), or the current size of
   // no resize is pending.
   pp::Size GetEffectiveSize() const;
   float GetEffectiveDeviceScale() const;
 
+  // Set the transform for the graphics layer.
+  // If |schedule_flush| is true, it ensures a flush will be scheduled for
+  // this change. If |schedule_flush| is false, then the change will not take
+  // effect until another change causes a flush.
+  void SetTransform(float scale,
+                    const pp::Point& origin,
+                    const pp::Point& translate,
+                    bool schedule_flush);
+  // Resets any transform for the graphics layer.
+  // This does not schedule a flush.
+  void ClearTransform();
+
  private:
   // Disallow copy and assign (these are unimplemented).
   PaintManager(const PaintManager&);
   PaintManager& operator=(const PaintManager&);
 
   // Makes sure there is a callback that will trigger a paint at a later time.
   // This will be either a Flush callback telling us we're allowed to generate
   // more data, or, if there's no flush callback pending, a manual call back
   // to the message loop via ExecuteOnMainThread.
   void EnsureCallbackPending();
 
   // Does the client paint and executes a Flush if necessary.
   void DoPaint();
 
+  // Executes a Flush.
+  void Flush();
+
   // Callback for asynchronous completion of Flush.
   void OnFlushComplete(int32_t);
 
   // Callback for manual scheduling of paints when there is no flush callback
   // pending.
   void OnManualCallbackComplete(int32_t);
 
   pp::Instance* instance_;
 
   // Non-owning pointer. See the constructor.
   Client* client_;
 
   bool is_always_opaque_;
 
   pp::CompletionCallbackFactory<PaintManager> callback_factory_;
 
   // This graphics device will be is_null() if no graphics has been manually
   // set yet.
   pp::Graphics2D graphics_;
 
   PaintAggregator aggregator_;
 
   // See comment for EnsureCallbackPending for more on how these work.
   bool manual_callback_pending_;
   bool flush_pending_;
+  bool flush_requested_;
 
   // When we get a resize, we don't bind right away (see SetSize). The
   // has_pending_resize_ tells us that we need to do a resize for the next
   // paint operation. When true, the new size is in pending_size_.
   bool has_pending_resize_;
   bool graphics_need_to_be_bound_;
   pp::Size pending_size_;
   pp::Size plugin_size_;
   float pending_device_scale_;
   float device_scale_;
 
   // True iff we're in the middle of a paint.
   bool in_paint_;
 
   // True if we haven't painted the plugin viewport yet.
   bool first_paint_;
 
   // True when the view size just changed and we're waiting for a paint.
   bool view_size_changed_waiting_for_paint_;
 };
 
 #endif  // PDF_PAINT_MANAGER_H_