native_widget_types.h revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7
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/gfx/gfx_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) 46class SkRegion; 47namespace aura { 48class Window; 49} 50namespace ui { 51class Cursor; 52class Event; 53} 54#endif // defined(USE_AURA) 55 56#if defined(OS_WIN) 57#include <windows.h> // NOLINT 58typedef struct HFONT__* HFONT; 59struct IAccessible; 60#elif defined(OS_IOS) 61struct CGContext; 62#ifdef __OBJC__ 63@class UIEvent; 64@class UIFont; 65@class UIImage; 66@class UIView; 67@class UIWindow; 68@class UITextField; 69#else 70class UIEvent; 71class UIFont; 72class UIImage; 73class UIView; 74class UIWindow; 75class UITextField; 76#endif // __OBJC__ 77#elif defined(OS_MACOSX) 78struct CGContext; 79#ifdef __OBJC__ 80@class NSCursor; 81@class NSEvent; 82@class NSFont; 83@class NSImage; 84@class NSView; 85@class NSWindow; 86@class NSTextField; 87#else 88class NSCursor; 89class NSEvent; 90class NSFont; 91class NSImage; 92struct NSView; 93class NSWindow; 94class NSTextField; 95#endif // __OBJC__ 96#elif defined(OS_POSIX) 97typedef struct _PangoFontDescription PangoFontDescription; 98typedef struct _cairo cairo_t; 99#endif 100 101#if defined(TOOLKIT_GTK) 102typedef struct _GdkCursor GdkCursor; 103typedef union _GdkEvent GdkEvent; 104typedef struct _GdkPixbuf GdkPixbuf; 105typedef struct _GdkRegion GdkRegion; 106typedef struct _GtkWidget GtkWidget; 107typedef struct _GtkWindow GtkWindow; 108#elif defined(OS_ANDROID) 109struct ANativeWindow; 110namespace ui { 111class WindowAndroid; 112class ViewAndroid; 113} 114#endif 115class SkBitmap; 116 117namespace gfx { 118 119#if defined(USE_AURA) 120typedef ui::Cursor NativeCursor; 121typedef aura::Window* NativeView; 122typedef aura::Window* NativeWindow; 123typedef SkRegion* NativeRegion; 124typedef ui::Event* NativeEvent; 125#elif defined(OS_WIN) 126typedef HCURSOR NativeCursor; 127typedef HWND NativeView; 128typedef HWND NativeWindow; 129typedef HRGN NativeRegion; 130typedef MSG NativeEvent; 131#elif defined(OS_IOS) 132typedef void* NativeCursor; 133typedef UIView* NativeView; 134typedef UIWindow* NativeWindow; 135typedef UIEvent* NativeEvent; 136#elif defined(OS_MACOSX) 137typedef NSCursor* NativeCursor; 138typedef NSView* NativeView; 139typedef NSWindow* NativeWindow; 140typedef NSEvent* NativeEvent; 141#elif defined(TOOLKIT_GTK) 142typedef GdkCursor* NativeCursor; 143typedef GtkWidget* NativeView; 144typedef GtkWindow* NativeWindow; 145typedef GdkRegion* NativeRegion; 146typedef GdkEvent* NativeEvent; 147#elif defined(OS_ANDROID) 148typedef void* NativeCursor; 149typedef ui::ViewAndroid* NativeView; 150typedef ui::WindowAndroid* NativeWindow; 151typedef void* NativeRegion; 152typedef jobject NativeEvent; 153#endif 154 155#if defined(OS_WIN) 156typedef HFONT NativeFont; 157typedef HWND NativeEditView; 158typedef HDC NativeDrawingContext; 159typedef IAccessible* NativeViewAccessible; 160#elif defined(OS_IOS) 161typedef UIFont* NativeFont; 162typedef UITextField* NativeEditView; 163typedef CGContext* NativeDrawingContext; 164#elif defined(OS_MACOSX) 165typedef NSFont* NativeFont; 166typedef NSTextField* NativeEditView; 167typedef CGContext* NativeDrawingContext; 168typedef void* NativeViewAccessible; 169#elif defined(TOOLKIT_GTK) 170typedef PangoFontDescription* NativeFont; 171typedef GtkWidget* NativeEditView; 172typedef cairo_t* NativeDrawingContext; 173typedef void* NativeViewAccessible; 174#elif defined(USE_CAIRO) 175typedef PangoFontDescription* NativeFont; 176typedef void* NativeEditView; 177typedef cairo_t* NativeDrawingContext; 178typedef void* NativeViewAccessible; 179#else 180typedef void* NativeFont; 181typedef void* NativeEditView; 182typedef void* NativeDrawingContext; 183typedef void* NativeViewAccessible; 184#endif 185 186// A constant value to indicate that gfx::NativeCursor refers to no cursor. 187#if defined(USE_AURA) 188const int kNullCursor = 0; 189#else 190const gfx::NativeCursor kNullCursor = static_cast<gfx::NativeCursor>(NULL); 191#endif 192 193#if defined(OS_IOS) 194typedef UIImage NativeImageType; 195#elif defined(OS_MACOSX) 196typedef NSImage NativeImageType; 197#elif defined(TOOLKIT_GTK) 198typedef GdkPixbuf NativeImageType; 199#else 200typedef SkBitmap NativeImageType; 201#endif 202typedef NativeImageType* NativeImage; 203 204// Note: for test_shell we're packing a pointer into the NativeViewId. So, if 205// you make it a type which is smaller than a pointer, you have to fix 206// test_shell. 207// 208// See comment at the top of the file for usage. 209typedef intptr_t NativeViewId; 210 211#if defined(OS_WIN) && !defined(USE_AURA) 212// Convert a NativeViewId to a NativeView. 213// 214// On Windows, we pass an HWND into the renderer. As stated above, the renderer 215// should not be performing operations on the view. 216static inline NativeView NativeViewFromId(NativeViewId id) { 217 return reinterpret_cast<NativeView>(id); 218} 219#define NativeViewFromIdInBrowser(x) NativeViewFromId(x) 220#elif defined(OS_POSIX) || defined(USE_AURA) 221// On Mac, Linux and USE_AURA, a NativeView is a pointer to an object, and is 222// useless outside the process in which it was created. NativeViewFromId should 223// only be used inside the appropriate platform ifdef outside of the browser. 224// (NativeViewFromIdInBrowser can be used everywhere in the browser.) If your 225// cross-platform design involves a call to NativeViewFromId from outside the 226// browser it will never work on Mac or Linux and is fundamentally broken. 227 228// Please do not call this from outside the browser. It won't work; the name 229// should give you a subtle hint. 230static inline NativeView NativeViewFromIdInBrowser(NativeViewId id) { 231 return reinterpret_cast<NativeView>(id); 232} 233#endif // defined(OS_POSIX) 234 235// PluginWindowHandle is an abstraction wrapping "the types of windows 236// used by NPAPI plugins". On Windows it's an HWND, on X it's an X 237// window id. 238#if defined(OS_WIN) 239 typedef HWND PluginWindowHandle; 240 const PluginWindowHandle kNullPluginWindow = NULL; 241#elif defined(USE_X11) 242 typedef unsigned long PluginWindowHandle; 243 const PluginWindowHandle kNullPluginWindow = 0; 244#elif defined(OS_ANDROID) 245 typedef uint64 PluginWindowHandle; 246 const PluginWindowHandle kNullPluginWindow = 0; 247#elif defined(USE_OZONE) 248 typedef intptr_t PluginWindowHandle; 249 const PluginWindowHandle kNullPluginWindow = 0; 250#else 251 // On Mac we don't have windowed plugins. We use a NULL/0 PluginWindowHandle 252 // in shared code to indicate there is no window present. 253 typedef bool PluginWindowHandle; 254 const PluginWindowHandle kNullPluginWindow = 0; 255#endif 256 257enum SurfaceType { 258 EMPTY, 259 NATIVE_DIRECT, 260 NATIVE_TRANSPORT, 261 TEXTURE_TRANSPORT, 262 SURFACE_TYPE_LAST = TEXTURE_TRANSPORT 263}; 264 265struct GLSurfaceHandle { 266 GLSurfaceHandle() 267 : handle(kNullPluginWindow), 268 transport_type(EMPTY), 269 parent_client_id(0) { 270 } 271 GLSurfaceHandle(PluginWindowHandle handle_, SurfaceType transport_) 272 : handle(handle_), 273 transport_type(transport_), 274 parent_client_id(0) { 275 DCHECK(!is_null() || handle == kNullPluginWindow); 276 DCHECK(transport_type != TEXTURE_TRANSPORT || 277 handle == kNullPluginWindow); 278 } 279 bool is_null() const { return transport_type == EMPTY; } 280 bool is_transport() const { 281 return transport_type == NATIVE_TRANSPORT || 282 transport_type == TEXTURE_TRANSPORT; 283 } 284 PluginWindowHandle handle; 285 SurfaceType transport_type; 286 uint32 parent_client_id; 287}; 288 289// AcceleratedWidget provides a surface to compositors to paint pixels. 290#if defined(OS_WIN) 291typedef HWND AcceleratedWidget; 292const AcceleratedWidget kNullAcceleratedWidget = NULL; 293#elif defined(USE_X11) 294typedef unsigned long AcceleratedWidget; 295const AcceleratedWidget kNullAcceleratedWidget = 0; 296#elif defined(OS_IOS) 297typedef UIView* AcceleratedWidget; 298const AcceleratedWidget kNullAcceleratedWidget = 0; 299#elif defined(OS_MACOSX) 300typedef NSView* AcceleratedWidget; 301const AcceleratedWidget kNullAcceleratedWidget = 0; 302#elif defined(OS_ANDROID) 303typedef ANativeWindow* AcceleratedWidget; 304const AcceleratedWidget kNullAcceleratedWidget = 0; 305#elif defined(USE_OZONE) 306typedef intptr_t AcceleratedWidget; 307const AcceleratedWidget kNullAcceleratedWidget = 0; 308#else 309#error unknown platform 310#endif 311 312} // namespace gfx 313 314#endif // UI_GFX_NATIVE_WIDGET_TYPES_H_ 315