ui/gfx/native_widget_types.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_GFX_NATIVE_WIDGET_TYPES_H_
   6 #define UI_GFX_NATIVE_WIDGET_TYPES_H_
   7
   8 #include "build/build_config.h"
   9
  10 #if defined(OS_ANDROID)
  11 #include <jni.h>
  12 #endif
  13
  14 #include "base/basictypes.h"
  15 #include "base/logging.h"
  16 #include "ui/base/ui_export.h"
  17
  18 // This file provides cross platform typedefs for native widget types.
  19 //   NativeWindow: this is a handle to a native, top-level window
  20 //   NativeView: this is a handle to a native UI element. It may be the
  21 //     same type as a NativeWindow on some platforms.
  22 //   NativeViewId: Often, in our cross process model, we need to pass around a
  23 //     reference to a "window". This reference will, say, be echoed back from a
  24 //     renderer to the browser when it wishes to query its size. On Windows we
  25 //     use an HWND for this.
  26 //
  27 //     As a rule of thumb - if you're in the renderer, you should be dealing
  28 //     with NativeViewIds. This should remind you that you shouldn't be doing
  29 //     direct operations on platform widgets from the renderer process.
  30 //
  31 //     If you're in the browser, you're probably dealing with NativeViews,
  32 //     unless you're in the IPC layer, which will be translating between
  33 //     NativeViewIds from the renderer and NativeViews.
  34 //
  35 //   NativeEditView: a handle to a native edit-box. The Mac folks wanted this
  36 //     specific typedef.
  37 //
  38 //   NativeImage: The platform-specific image type used for drawing UI elements
  39 //     in the browser.
  40 //
  41 // The name 'View' here meshes with OS X where the UI elements are called
  42 // 'views' and with our Chrome UI code where the elements are also called
  43 // 'views'.
  44
  45 #if defined(USE_AURA)
  46 #include "ui/base/cursor/cursor.h"
  47
  48 class SkRegion;
  49 namespace aura {
  50 class Window;
  51 }
  52 namespace ui {
  53 class Event;
  54 }
  55 #endif  // defined(USE_AURA)
  56
  57 #if defined(OS_WIN)
  58 #include <windows.h>  // NOLINT
  59 typedef struct HFONT__* HFONT;
  60 struct IAccessible;
  61 #elif defined(OS_IOS)
  62 struct CGContext;
  63 #ifdef __OBJC__
  64 @class UIEvent;
  65 @class UIFont;
  66 @class UIImage;
  67 @class UIView;
  68 @class UIWindow;
  69 @class UITextField;
  70 #else
  71 class UIEvent;
  72 class UIFont;
  73 class UIImage;
  74 class UIView;
  75 class UIWindow;
  76 class UITextField;
  77 #endif  // __OBJC__
  78 #elif defined(OS_MACOSX)
  79 struct CGContext;
  80 #ifdef __OBJC__
  81 @class NSCursor;
  82 @class NSEvent;
  83 @class NSFont;
  84 @class NSImage;
  85 @class NSView;
  86 @class NSWindow;
  87 @class NSTextField;
  88 #else
  89 class NSCursor;
  90 class NSEvent;
  91 class NSFont;
  92 class NSImage;
  93 struct NSView;
  94 class NSWindow;
  95 class NSTextField;
  96 #endif  // __OBJC__
  97 #elif defined(OS_POSIX)
  98 typedef struct _PangoFontDescription PangoFontDescription;
  99 typedef struct _cairo cairo_t;
 100 #endif
 101
 102 #if defined(TOOLKIT_GTK)
 103 typedef struct _GdkCursor GdkCursor;
 104 typedef union _GdkEvent GdkEvent;
 105 typedef struct _GdkPixbuf GdkPixbuf;
 106 typedef struct _GdkRegion GdkRegion;
 107 typedef struct _GtkWidget GtkWidget;
 108 typedef struct _GtkWindow GtkWindow;
 109 #elif defined(OS_ANDROID)
 110 struct ANativeWindow;
 111 namespace ui {
 112 class WindowAndroid;
 113 class ViewAndroid;
 114 }
 115 #endif
 116 class SkBitmap;
 117
 118 namespace gfx {
 119
 120 #if defined(USE_AURA)
 121 typedef ui::Cursor NativeCursor;
 122 typedef aura::Window* NativeView;
 123 typedef aura::Window* NativeWindow;
 124 typedef SkRegion* NativeRegion;
 125 typedef ui::Event* NativeEvent;
 126 #elif defined(OS_WIN)
 127 typedef HCURSOR NativeCursor;
 128 typedef HWND NativeView;
 129 typedef HWND NativeWindow;
 130 typedef HRGN NativeRegion;
 131 typedef MSG NativeEvent;
 132 #elif defined(OS_IOS)
 133 typedef void* NativeCursor;
 134 typedef UIView* NativeView;
 135 typedef UIWindow* NativeWindow;
 136 typedef UIEvent* NativeEvent;
 137 #elif defined(OS_MACOSX)
 138 typedef NSCursor* NativeCursor;
 139 typedef NSView* NativeView;
 140 typedef NSWindow* NativeWindow;
 141 typedef NSEvent* NativeEvent;
 142 #elif defined(TOOLKIT_GTK)
 143 typedef GdkCursor* NativeCursor;
 144 typedef GtkWidget* NativeView;
 145 typedef GtkWindow* NativeWindow;
 146 typedef GdkRegion* NativeRegion;
 147 typedef GdkEvent* NativeEvent;
 148 #elif defined(OS_ANDROID)
 149 typedef void* NativeCursor;
 150 typedef ui::ViewAndroid* NativeView;
 151 typedef ui::WindowAndroid* NativeWindow;
 152 typedef void* NativeRegion;
 153 typedef jobject NativeEvent;
 154 #endif
 155
 156 #if defined(OS_WIN)
 157 typedef HFONT NativeFont;
 158 typedef HWND NativeEditView;
 159 typedef HDC NativeDrawingContext;
 160 typedef IAccessible* NativeViewAccessible;
 161 #elif defined(OS_IOS)
 162 typedef UIFont* NativeFont;
 163 typedef UITextField* NativeEditView;
 164 typedef CGContext* NativeDrawingContext;
 165 #elif defined(OS_MACOSX)
 166 typedef NSFont* NativeFont;
 167 typedef NSTextField* NativeEditView;
 168 typedef CGContext* NativeDrawingContext;
 169 typedef void* NativeViewAccessible;
 170 #elif defined(TOOLKIT_GTK)
 171 typedef PangoFontDescription* NativeFont;
 172 typedef GtkWidget* NativeEditView;
 173 typedef cairo_t* NativeDrawingContext;
 174 typedef void* NativeViewAccessible;
 175 #elif defined(USE_AURA)
 176 typedef PangoFontDescription* NativeFont;
 177 typedef void* NativeEditView;
 178 typedef cairo_t* NativeDrawingContext;
 179 typedef void* NativeViewAccessible;
 180 #elif defined(OS_ANDROID)
 181 typedef void* NativeFont;
 182 typedef void* NativeEditView;
 183 typedef void* NativeDrawingContext;
 184 typedef void* NativeViewAccessible;
 185 #endif
 186
 187 // A constant value to indicate that gfx::NativeCursor refers to no cursor.
 188 #if defined(USE_AURA)
 189 const int kNullCursor = 0;
 190 #else
 191 const gfx::NativeCursor kNullCursor = static_cast<gfx::NativeCursor>(NULL);
 192 #endif
 193
 194 #if defined(OS_IOS)
 195 typedef UIImage NativeImageType;
 196 #elif defined(OS_MACOSX)
 197 typedef NSImage NativeImageType;
 198 #elif defined(TOOLKIT_GTK)
 199 typedef GdkPixbuf NativeImageType;
 200 #else
 201 typedef SkBitmap NativeImageType;
 202 #endif
 203 typedef NativeImageType* NativeImage;
 204
 205 // Note: for test_shell we're packing a pointer into the NativeViewId. So, if
 206 // you make it a type which is smaller than a pointer, you have to fix
 207 // test_shell.
 208 //
 209 // See comment at the top of the file for usage.
 210 typedef intptr_t NativeViewId;
 211
 212 #if defined(OS_WIN) && !defined(USE_AURA)
 213 // Convert a NativeViewId to a NativeView.
 214 //
 215 // On Windows, we pass an HWND into the renderer. As stated above, the renderer
 216 // should not be performing operations on the view.
 217 static inline NativeView NativeViewFromId(NativeViewId id) {
 218   return reinterpret_cast<NativeView>(id);
 219 }
 220 #define NativeViewFromIdInBrowser(x) NativeViewFromId(x)
 221 #elif defined(OS_POSIX) || defined(USE_AURA)
 222 // On Mac, Linux and USE_AURA, a NativeView is a pointer to an object, and is
 223 // useless outside the process in which it was created. NativeViewFromId should
 224 // only be used inside the appropriate platform ifdef outside of the browser.
 225 // (NativeViewFromIdInBrowser can be used everywhere in the browser.) If your
 226 // cross-platform design involves a call to NativeViewFromId from outside the
 227 // browser it will never work on Mac or Linux and is fundamentally broken.
 228
 229 // Please do not call this from outside the browser. It won't work; the name
 230 // should give you a subtle hint.
 231 static inline NativeView NativeViewFromIdInBrowser(NativeViewId id) {
 232   return reinterpret_cast<NativeView>(id);
 233 }
 234 #endif  // defined(OS_POSIX)
 235
 236 // PluginWindowHandle is an abstraction wrapping "the types of windows
 237 // used by NPAPI plugins".  On Windows it's an HWND, on X it's an X
 238 // window id.
 239 #if defined(OS_WIN)
 240   typedef HWND PluginWindowHandle;
 241   const PluginWindowHandle kNullPluginWindow = NULL;
 242 #elif defined(USE_X11)
 243   typedef unsigned long PluginWindowHandle;
 244   const PluginWindowHandle kNullPluginWindow = 0;
 245 #elif defined(USE_AURA) && defined(OS_MACOSX)
 246   // Mac-Aura uses NSView-backed GLSurface.  Regular Mac does not.
 247   // TODO(dhollowa): Rationalize these two definitions. http://crbug.com/104551.
 248   typedef NSView* PluginWindowHandle;
 249   const PluginWindowHandle kNullPluginWindow = 0;
 250 #elif defined(OS_ANDROID)
 251   typedef uint64 PluginWindowHandle;
 252   const PluginWindowHandle kNullPluginWindow = 0;
 253 #elif defined(USE_OZONE)
 254   typedef intptr_t PluginWindowHandle;
 255   const PluginWindowHandle kNullPluginWindow = 0;
 256 #else
 257   // On OS X we don't have windowed plugins.
 258   // We use a NULL/0 PluginWindowHandle in shared code to indicate there
 259   // is no window present, so mirror that behavior here.
 260   //
 261   // The GPU plugin is currently an exception to this rule. As of this
 262   // writing it uses some NPAPI infrastructure, and minimally we need
 263   // to identify the plugin instance via this window handle. When the
 264   // GPU plugin becomes a full-on GPU process, this typedef can be
 265   // returned to a bool. For now we use a type large enough to hold a
 266   // pointer on 64-bit architectures in case we need this capability.
 267   typedef uint64 PluginWindowHandle;
 268   const PluginWindowHandle kNullPluginWindow = 0;
 269 #endif
 270
 271 enum SurfaceType {
 272   EMPTY,
 273   NATIVE_DIRECT,
 274   NATIVE_TRANSPORT,
 275   TEXTURE_TRANSPORT
 276 };
 277
 278 struct GLSurfaceHandle {
 279   GLSurfaceHandle()
 280       : handle(kNullPluginWindow),
 281         transport_type(EMPTY),
 282         parent_gpu_process_id(0),
 283         parent_client_id(0) {
 284   }
 285   GLSurfaceHandle(PluginWindowHandle handle_, SurfaceType transport_)
 286       : handle(handle_),
 287         transport_type(transport_),
 288         parent_gpu_process_id(0),
 289         parent_client_id(0) {
 290     DCHECK(!is_null() || handle == kNullPluginWindow);
 291     DCHECK(transport_type != TEXTURE_TRANSPORT ||
 292            handle == kNullPluginWindow);
 293   }
 294   bool is_null() const { return transport_type == EMPTY; }
 295   bool is_transport() const {
 296     return transport_type == NATIVE_TRANSPORT ||
 297            transport_type == TEXTURE_TRANSPORT;
 298   }
 299   PluginWindowHandle handle;
 300   SurfaceType transport_type;
 301   int parent_gpu_process_id;
 302   uint32 parent_client_id;
 303 };
 304
 305 // AcceleratedWidget provides a surface to compositors to paint pixels.
 306 #if defined(OS_WIN)
 307 typedef HWND AcceleratedWidget;
 308 const AcceleratedWidget kNullAcceleratedWidget = NULL;
 309 #elif defined(USE_X11)
 310 typedef unsigned long AcceleratedWidget;
 311 const AcceleratedWidget kNullAcceleratedWidget = 0;
 312 #elif defined(OS_IOS)
 313 typedef UIView* AcceleratedWidget;
 314 const AcceleratedWidget kNullAcceleratedWidget = 0;
 315 #elif defined(OS_MACOSX)
 316 typedef NSView* AcceleratedWidget;
 317 const AcceleratedWidget kNullAcceleratedWidget = 0;
 318 #elif defined(OS_ANDROID)
 319 typedef ANativeWindow* AcceleratedWidget;
 320 const AcceleratedWidget kNullAcceleratedWidget = 0;
 321 #elif defined(USE_OZONE)
 322 typedef intptr_t AcceleratedWidget;
 323 const AcceleratedWidget kNullAcceleratedWidget = 0;
 324 #else
 325 #error unknown platform
 326 #endif
 327
 328 }  // namespace gfx
 329
 330 #endif  // UI_GFX_NATIVE_WIDGET_TYPES_H_