NaCl SDK: Demonstrate use of pp::Graphics2D::SetScale()

native_client_sdk/src/examples/api/graphics_2d/graphics_2d.cc

 // Copyright (c) 2013 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 <stdio.h>
 #include <stdlib.h>
 
 #include "ppapi/c/ppb_image_data.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
@@ skipping 30 matching lines @@
 }
 
 }  // namespace
 
 class Graphics2DInstance : public pp::Instance {
  public:
   explicit Graphics2DInstance(PP_Instance instance)
       : pp::Instance(instance),
         callback_factory_(this),
         mouse_down_(false),
-        buffer_(NULL) {}
+        buffer_(NULL),
+        device_scale_(1.0f) {}
 
   ~Graphics2DInstance() { delete[] buffer_; }
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
 
     unsigned int seed = 1;
     srand(seed);
     CreatePalette();
     return true;
   }
 
   virtual void DidChangeView(const pp::View& view) {
-    pp::Size new_size = view.GetRect().size();
+    device_scale_ = view.GetDeviceScale();
+    pp::Size new_size = pp::Size(view.GetRect().width() * device_scale_,
+                                 view.GetRect().height() * device_scale_);
 
     if (!CreateContext(new_size))
       return;
 
     // When flush_context_ is null, it means there is no Flush callback in
     // flight. This may have happened if the context was not created
     // successfully, or if this is the first call to DidChangeView (when the
     // module first starts). In either case, start the main loop.
     if (flush_context_.is_null())
       MainLoop(0);
   }
 
   virtual bool HandleInputEvent(const pp::InputEvent& event) {
     if (!buffer_)
       return true;
 
     if (event.GetType() == PP_INPUTEVENT_TYPE_MOUSEDOWN ||
         event.GetType() == PP_INPUTEVENT_TYPE_MOUSEMOVE) {
       pp::MouseInputEvent mouse_event(event);
 
       if (mouse_event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_NONE)
         return true;
 
-      mouse_ = mouse_event.GetPosition();
+      mouse_ = pp::Point(mouse_event.GetPosition().x() * device_scale_,
+                         mouse_event.GetPosition().y() * device_scale_);
       mouse_down_ = true;
     }
 
     if (event.GetType() == PP_INPUTEVENT_TYPE_MOUSEUP)
       mouse_down_ = false;
 
     return true;
   }
 
  private:
   void CreatePalette() {
     for (int i = 0; i < 64; ++i) {
       // Black -> Red
       palette_[i] = MakeColor(i * 2, 0, 0);
       palette_[i + 64] = MakeColor(128 + i * 2, 0, 0);
       // Red -> Yellow
       palette_[i + 128] = MakeColor(255, i * 4, 0);
       // Yellow -> White
       palette_[i + 192] = MakeColor(255, 255, i * 4);
     }
   }
 
   bool CreateContext(const pp::Size& new_size) {
     const bool kIsAlwaysOpaque = true;
     context_ = pp::Graphics2D(this, new_size, kIsAlwaysOpaque);
+    // Call SetScale before BindGraphics so the image is scaled correctly on
+    // HiDPI displays.
+    context_.SetScale(1.0f / device_scale_);
     if (!BindGraphics(context_)) {
       fprintf(stderr, "Unable to bind 2d context!\n");
       context_ = pp::Graphics2D();
       return false;
     }
 
     // Allocate a buffer of palette entries of the same size as the new context.
     buffer_ = new uint8_t[new_size.width() * new_size.height()];
     size_ = new_size;
 
@@ skipping 50 matching lines @@
   }
 
   void DrawMouse() {
     if (!mouse_down_)
       return;
 
     int width = size_.width();
     int height = size_.height();
 
     // Draw a circle at the mouse position.
-    int radius = kMouseRadius;
+    int radius = kMouseRadius * device_scale_;

[binji, 2014/07/17 00:11:38]

no warning here about truncating from float to int?

[Josh Horwich, 2014/07/17 00:20:58]

I haven't seen any (here, and the pp::Size / pp::Point constructors that take
int's/int32_t's).

     int cx = mouse_.x();
     int cy = mouse_.y();
     int minx = cx - radius <= 0 ? 1 : cx - radius;
     int maxx = cx + radius >= width ? width - 1 : cx + radius;
     int miny = cy - radius <= 0 ? 1 : cy - radius;
     int maxy = cy + radius >= height ? height - 1 : cy + radius;
     for (int y = miny; y < maxy; ++y) {
       for (int x = minx; x < maxx; ++x) {
         if ((x - cx) * (x - cx) + (y - cy) * (y - cy) < radius * radius)
           buffer_[y * width + x] = RandUint8(192, 255);
@@ skipping 58 matching lines @@
   }
 
   pp::CompletionCallbackFactory<Graphics2DInstance> callback_factory_;
   pp::Graphics2D context_;
   pp::Graphics2D flush_context_;
   pp::Size size_;
   pp::Point mouse_;
   bool mouse_down_;
   uint8_t* buffer_;
   uint32_t palette_[256];
+  float device_scale_;
 };
 
 class Graphics2DModule : public pp::Module {
  public:
   Graphics2DModule() : pp::Module() {}
   virtual ~Graphics2DModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new Graphics2DInstance(instance);
   }
 };
 
 namespace pp {
 Module* CreateModule() { return new Graphics2DModule(); }
 }  // namespace pp