2x Cursor support.

ui/aura/root_window_host_linux.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 "ui/aura/root_window_host_linux.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xcursor/Xcursor.h>
 #include <X11/Xlib.h>
 #include <X11/cursorfont.h>
@@ skipping 15 matching lines @@
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/x/x11_atom_cache.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia.h"
 
 using ui::X11AtomCache;
 using std::max;
 using std::min;
 
 namespace aura {
 
 namespace {
 
 // Standard Linux mouse buttons for going back and forward.
@@ skipping 243 matching lines @@
       return false;
   }
 }
 
 }  // namespace
 
 // A utility class that provides X Cursor for NativeCursors for which we have
 // image resources.
 class RootWindowHostLinux::ImageCursors {
  public:
-  ImageCursors() {
-    LoadImageCursor(ui::kCursorNoDrop, IDR_AURA_CURSOR_NO_DROP);
-    LoadImageCursor(ui::kCursorCopy, IDR_AURA_CURSOR_COPY);
+  ImageCursors() : scale_factor_(0.0) {
+  }
+
+  void Reload(float scale_factor) {
+    if (scale_factor_ == scale_factor)
+      return;
+    scale_factor_ = scale_factor;
+    UnloadAll();
+    // The cursor's hot points are defined in chromeos's
+    // src/platforms/assets/cursors/*.cfg files.
+    LoadImageCursor(ui::kCursorNull, IDR_AURA_CURSOR_PTR, 9, 5);
+    LoadImageCursor(ui::kCursorPointer, IDR_AURA_CURSOR_PTR, 9, 5);
+    LoadImageCursor(ui::kCursorNoDrop, IDR_AURA_CURSOR_NO_DROP, 9, 5);
+    LoadImageCursor(ui::kCursorCopy, IDR_AURA_CURSOR_COPY, 9, 5);
+    LoadImageCursor(ui::kCursorHand, IDR_AURA_CURSOR_HAND, 9, 4);
+    LoadImageCursor(ui::kCursorMove, IDR_AURA_CURSOR_MOVE, 12, 12);
+    LoadImageCursor(ui::kCursorNorthEastResize,
+                    IDR_AURA_CURSOR_NORTH_EAST_RESIZE, 12, 11);
+    LoadImageCursor(ui::kCursorSouthWestResize,
+                    IDR_AURA_CURSOR_SOUTH_WEST_RESIZE, 12, 11);
+    LoadImageCursor(ui::kCursorSouthEastResize,
+                    IDR_AURA_CURSOR_SOUTH_EAST_RESIZE, 11, 11);
+    LoadImageCursor(ui::kCursorNorthWestResize,
+                    IDR_AURA_CURSOR_NORTH_WEST_RESIZE, 11, 11);
+    LoadImageCursor(ui::kCursorNorthResize,
+                    IDR_AURA_CURSOR_NORTH_RESIZE, 11, 10);
+    LoadImageCursor(ui::kCursorSouthResize,
+                    IDR_AURA_CURSOR_SOUTH_RESIZE, 11, 10);
+    LoadImageCursor(ui::kCursorEastResize, IDR_AURA_CURSOR_EAST_RESIZE, 11, 11);
+    LoadImageCursor(ui::kCursorWestResize, IDR_AURA_CURSOR_WEST_RESIZE, 11, 11);
+    LoadImageCursor(ui::kCursorIBeam, IDR_AURA_CURSOR_IBEAM, 12, 11);
+
     // TODO (varunjain): add more cursors once we have assets.
   }
 
   ~ImageCursors() {
+    UnloadAll();
+  }
+
+  void UnloadAll() {
     std::map<int, Cursor>::const_iterator it;
     for (it = cursors_.begin(); it != cursors_.end(); ++it)
       ui::UnrefCustomXCursor(it->second);
   }
 
   // Returns true if we have an image resource loaded for the |native_cursor|.
   bool IsImageCursor(gfx::NativeCursor native_cursor) {
     return cursors_.find(native_cursor.native_type()) != cursors_.end();
   }
 
   // Gets the X Cursor corresponding to the |native_cursor|.
   ::Cursor ImageCursorFromNative(gfx::NativeCursor native_cursor) {
     DCHECK(cursors_.find(native_cursor.native_type()) != cursors_.end());
     return cursors_[native_cursor.native_type()];
   }
 
  private:
   // Creates an X Cursor from an image resource and puts it in the cursor map.
-  void LoadImageCursor(int id, int resource_id) {
-    const SkBitmap* bitmap =
-        ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-            resource_id).ToSkBitmap();
-
-    XcursorImage* image = ui::SkBitmapToXcursorImage(bitmap, gfx::Point(0, 0));
-    cursors_[id] = ui::CreateReffedCustomXCursor(image);
+  void LoadImageCursor(int id, int resource_id, int hot_x, int hot_y) {
+    const gfx::ImageSkia* image =
+        ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
+    float actual_scale = 0;
+    const SkBitmap& bitmap =  image->GetBitmapForScale(scale_factor_,

[sky, 2012/05/22 19:49:12]

nit: you have two spaces here.

[oshima, 2012/05/22 19:53:08]

oops, fixed. Thanks

+                                                       scale_factor_,
+                                                       &actual_scale);
+    // We never use scaled cursor, but the following DCHECK fails
+    // because the method above coputes the actual scale from the image
+    // size instead of obtaining from the resource data, and the some
+    // of cursors are indeed not 2x size of the 2x images.
+    // TODO(oshima): Fix this and enable the following DCHECK.
+    // DCHECK_EQ(actual_scale, scale_factor_);
+    XcursorImage* x_image =
+        ui::SkBitmapToXcursorImage(&bitmap, gfx::Point(0, 0));
+    x_image->xhot = hot_x * actual_scale;
+    x_image->yhot = hot_y * actual_scale;
+    cursors_[id] = ui::CreateReffedCustomXCursor(x_image);
     // |bitmap| is owned by the resource bundle. So we do not need to free it.
   }
 
   // A map to hold all image cursors. It maps the cursor ID to the X Cursor.
   std::map<int, Cursor> cursors_;
 
+  float scale_factor_;
+
   DISALLOW_COPY_AND_ASSIGN(ImageCursors);
 };
 
 RootWindowHostLinux::RootWindowHostLinux(const gfx::Rect& bounds)
     : root_window_(NULL),
       xdisplay_(base::MessagePumpX::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       cursor_shown_(true),
@@ skipping 286 matching lines @@
       MouseEvent mouseev(xev);
       root_window_->DispatchMouseEvent(&mouseev);
       break;
     }
   }
   return true;
 }
 
 void RootWindowHostLinux::SetRootWindow(RootWindow* root_window) {
   root_window_ = root_window;
+  // The device scale factor is now accessible, so load cursors now.
+  image_cursors_->Reload(root_window_->layer()->device_scale_factor());
 }
 
 RootWindow* RootWindowHostLinux::GetRootWindow() {
   return root_window_;
 }
 
 gfx::AcceleratedWidget RootWindowHostLinux::GetAcceleratedWidget() {
   return xwindow_;
 }
 
@@ skipping 212 matching lines @@
       root_window_->ConvertPointToNativeScreen(&point);
       xevent.xmotion.x_root = point.x();
       xevent.xmotion.y_root = point.y();
     }
     default:
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
+void RootWindowHostLinux::OnDeviceScaleFactorChanged(
+    float device_scale_factor) {
+  image_cursors_->Reload(device_scale_factor);
+}
+
 bool RootWindowHostLinux::IsWindowManagerPresent() {
   // Per ICCCM 2.8, "Manager Selections", window managers should take ownership
   // of WM_Sn selections (where n is a screen number).
   return XGetSelectionOwner(
       xdisplay_,
       X11AtomCache::GetInstance()->GetAtom(ui::ATOM_WM_S0)) != None;
 }
 
 void RootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
   ::Cursor xcursor =
       image_cursors_->IsImageCursor(cursor) ?
       image_cursors_->ImageCursorFromNative(cursor) :
-      cursor == ui::kCursorNone ?
-      invisible_cursor_ :
-      cursor == ui::kCursorCustom ?
-      cursor.platform() :
-      ui::GetXCursor(CursorShapeFromNative(cursor));
+      (cursor == ui::kCursorNone ? invisible_cursor_ :
+       (cursor == ui::kCursorCustom ? cursor.platform() :
+        ui::GetXCursor(CursorShapeFromNative(cursor))));
   XDefineCursor(xdisplay_, xwindow_, xcursor);
 }
 
 // static
 RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
   return new RootWindowHostLinux(bounds);
 }
 
 // static
 RootWindowHost* RootWindowHost::GetForAcceleratedWidget(
     gfx::AcceleratedWidget accelerated_widget) {
   return reinterpret_cast<RootWindowHost*>(
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura