text: // 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.
  
  #ifndef UI_GFX_NATIVE_WIDGET_TYPES_H_
  #define UI_GFX_NATIVE_WIDGET_TYPES_H_
  
  #include "build/build_config.h"
  
  #if defined(OS_ANDROID)
  #include <jni.h>
  #endif
  
  #include "base/basictypes.h"
  #include "base/logging.h"
  #include "ui/gfx/gfx_export.h"
  
  // This file provides cross platform typedefs for native widget types.
  //   NativeWindow: this is a handle to a native, top-level window
  //   NativeView: this is a handle to a native UI element. It may be the
  //     same type as a NativeWindow on some platforms.
  //   NativeViewId: Often, in our cross process model, we need to pass around a
  //     reference to a "window". This reference will, say, be echoed back from a
  //     renderer to the browser when it wishes to query its size. On Windows we
  //     use an HWND for this.
  //
  //     As a rule of thumb - if you're in the renderer, you should be dealing
  //     with NativeViewIds. This should remind you that you shouldn't be doing
  //     direct operations on platform widgets from the renderer process.
  //
  //     If you're in the browser, you're probably dealing with NativeViews,
  //     unless you're in the IPC layer, which will be translating between
  //     NativeViewIds from the renderer and NativeViews.
  //
  //   NativeEditView: a handle to a native edit-box. The Mac folks wanted this
  //     specific typedef.
  //
  //   NativeImage: The platform-specific image type used for drawing UI elements
  //     in the browser.
  //
  // The name 'View' here meshes with OS X where the UI elements are called
  // 'views' and with our Chrome UI code where the elements are also called
  // 'views'.
  
  class SkRegion;
  namespace ui {
  class Event;
  }
  
  #if defined(OS_POSIX)
  typedef struct _PangoFontDescription PangoFontDescription;
  typedef struct _cairo cairo_t;
  #endif
  
  #if defined(OS_ANDROID)
  struct ANativeWindow;
  namespace ui {
  class WindowAndroid;
  class ViewAndroid;
  }
  #endif
  class SkBitmap;
  
  namespace gfx {
  
  #if defined(OS_LINUX)
  typedef SkRegion* NativeRegion;
  typedef ui::Event* NativeEvent;
  #elif defined(OS_ANDROID)
  typedef void* NativeRegion;
  typedef jobject NativeEvent;
  #endif
  
  #if defined(USE_CAIRO)
  typedef PangoFontDescription* NativeFont;
  typedef void* NativeEditView;
  typedef cairo_t* NativeDrawingContext;
  typedef void* NativeViewAccessible;
  #else
  typedef void* NativeFont;
  typedef void* NativeEditView;
  typedef void* NativeDrawingContext;
  typedef void* NativeViewAccessible;
  #endif
  
  // A constant value to indicate that gfx::NativeCursor refers to no cursor.
  #if defined(OS_LINUX)
  const int kNullCursor = 0;
  #endif
  
  typedef SkBitmap NativeImageType;
  typedef NativeImageType* NativeImage;
  
  // Note: for test_shell we're packing a pointer into the NativeViewId. So, if
  // you make it a type which is smaller than a pointer, you have to fix
  // test_shell.
  //
  // See comment at the top of the file for usage.
  typedef intptr_t NativeViewId;
  
  // PluginWindowHandle is an abstraction wrapping "the types of windows
  // used by NPAPI plugins". On Windows it's an HWND, on X it's an X
  // window id.
  #if defined(USE_X11)
    typedef unsigned long PluginWindowHandle;
    const PluginWindowHandle kNullPluginWindow = 0;
  #elif defined(OS_ANDROID)
    typedef uint64 PluginWindowHandle;
    const PluginWindowHandle kNullPluginWindow = 0;
  #elif defined(USE_OZONE)
    typedef intptr_t PluginWindowHandle;
    const PluginWindowHandle kNullPluginWindow = 0;
  #else
    // On Mac we don't have windowed plugins. We use a NULL/0 PluginWindowHandle
    // in shared code to indicate there is no window present.
    typedef bool PluginWindowHandle;
    const PluginWindowHandle kNullPluginWindow = 0;
  #endif
  
  enum SurfaceType {
    EMPTY,
    NATIVE_DIRECT,
    NULL_TRANSPORT,
    SURFACE_TYPE_LAST = NULL_TRANSPORT
  };
  
  struct GLSurfaceHandle {
    GLSurfaceHandle()
        : handle(kNullPluginWindow),
          transport_type(EMPTY),
          parent_client_id(0) {
    }
    GLSurfaceHandle(PluginWindowHandle handle_, SurfaceType transport_)
        : handle(handle_),
          transport_type(transport_),
          parent_client_id(0) {
      DCHECK(!is_null() || handle == kNullPluginWindow);
      DCHECK(transport_type != NULL_TRANSPORT ||
             handle == kNullPluginWindow);
    }
    bool is_null() const { return transport_type == EMPTY; }
    bool is_transport() const {
      return transport_type == NULL_TRANSPORT;
    }
    PluginWindowHandle handle;
    SurfaceType transport_type;
    uint32 parent_client_id;
  };
  
  // AcceleratedWidget provides a surface to compositors to paint pixels.
  #if defined(USE_X11)
  typedef unsigned long AcceleratedWidget;
  const AcceleratedWidget kNullAcceleratedWidget = 0;
  #elif defined(OS_ANDROID)
  typedef ANativeWindow* AcceleratedWidget;
  const AcceleratedWidget kNullAcceleratedWidget = 0;
  #elif defined(USE_OZONE)
  typedef intptr_t AcceleratedWidget;
  const AcceleratedWidget kNullAcceleratedWidget = 0;
  #elif defined(OS_IOS)
  typedef uintptr_t AcceleratedWidget;
  const AcceleratedWidget kNullAcceleratedWidget = 0;
  #elif defined(OS_MACOSX)
  typedef uintptr_t AcceleratedWidget;
  const AcceleratedWidget kNullAcceleratedWidget = 0;
  #else
  #error unknown platform
  #endif
  
  }  // namespace gfx
  
  #endif  // UI_GFX_NATIVE_WIDGET_TYPES_H_
  