PPB_CursorControl_Dev.SetCursor: Add support for custom cursor.

ppapi/example/example.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 <math.h>
 #include <stdio.h>  // FIXME(brettw) erase me.
 #ifndef _WIN32
 #include <sys/time.h>
 #endif
 #include <time.h>
 
 #include <algorithm>
 
 #include "ppapi/c/dev/ppb_console_dev.h"
+#include "ppapi/c/dev/ppb_cursor_control_dev.h"
 #include "ppapi/c/dev/ppp_printing_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/scriptable_object_deprecated.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
@@ skipping 131 matching lines @@
 
 class MyInstance : public pp::Instance, public MyFetcherClient {
  public:
   MyInstance(PP_Instance instance)
       : pp::Instance(instance),
         time_at_last_check_(0.0),
         fetcher_(NULL),
         width_(0),
         height_(0),
         animation_counter_(0),
-        print_settings_valid_(false) {}
+        print_settings_valid_(false),
+        showing_custom_cursor_(false) {}
 
   virtual ~MyInstance() {
     if (fetcher_) {
       delete fetcher_;
       fetcher_ = NULL;
     }
   }
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
@@ skipping 10 matching lines @@
   virtual bool HandleDocumentLoad(const pp::URLLoader& loader) {
     fetcher_ = new MyFetcher();
     fetcher_->StartWithOpenedLoader(loader, this);
     return true;
   }
 
   virtual bool HandleInputEvent(const PP_InputEvent& event) {
     switch (event.type) {
       case PP_INPUTEVENT_TYPE_MOUSEDOWN:
         SayHello();
+        ToggleCursor();
         return true;
       case PP_INPUTEVENT_TYPE_MOUSEMOVE:
         return true;
       case PP_INPUTEVENT_TYPE_KEYDOWN:
         return true;
       default:
         return false;
     }
   }
 
@@ skipping 181 matching lines @@
     Log(PP_LOGLEVEL_LOG, "Downloaded location.href:");
     if (success) {
       Log(PP_LOGLEVEL_LOG, data);
     } else {
       Log(PP_LOGLEVEL_ERROR, "Failed to download.");
     }
     delete fetcher_;
     fetcher_ = NULL;
   }
 
+  void ToggleCursor() {
+    const PPB_CursorControl_Dev* cursor_control =
+        reinterpret_cast<const PPB_CursorControl_Dev*>(
+            pp::Module::Get()->GetBrowserInterface(
+                PPB_CURSOR_CONTROL_DEV_INTERFACE));
+    if (!cursor_control)
+      return;
+
+    if (showing_custom_cursor_) {
+      cursor_control->SetCursor(pp_instance(), PP_CURSORTYPE_POINTER, 0, NULL);
+    } else {
+      pp::ImageData image_data(this, pp::ImageData::GetNativeImageDataFormat(),
+                               pp::Size(50, 50), false);
+      FillRect(&image_data, 0, 0, 50, 50,
+               image_data.format() == PP_IMAGEDATAFORMAT_BGRA_PREMUL ?
+                   0x80800000 : 0x80000080);
+      pp::Point hot_spot(0, 0);
+      cursor_control->SetCursor(pp_instance(), PP_CURSORTYPE_CUSTOM,
+                                image_data.pp_resource(), &hot_spot.pp_point());
+    }
+
+    showing_custom_cursor_ = !showing_custom_cursor_;
+  }
+
   pp::Var console_;
   pp::Graphics2D device_context_;
 
   double time_at_last_check_;
 
   MyFetcher* fetcher_;
 
   int width_;
   int height_;
 
   // Incremented for each flush we get.
   int animation_counter_;
   bool print_settings_valid_;
   PP_PrintSettings_Dev print_settings_;
+
+  bool showing_custom_cursor_;
 };
 
 void FlushCallback(void* data, int32_t result) {
   static_cast<MyInstance*>(data)->OnFlush();
 }
 
 class MyModule : public pp::Module {
  public:
   MyModule() : pp::Module() {}
   virtual ~MyModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new MyInstance(instance);
   }
 };
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp