Home | History | Annotate | Download | only in bindings 
      1 /* Copyright (c) 2006-2009 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 
      6 #ifndef _NP_EXTENSIONS_H_
      7 #define _NP_EXTENSIONS_H_
      8 
      9 // Use the shorter include path here so that this file can be used in non-
     10 // Chromium projects, such as the Native Client SDK.
     11 #include "npapi.h"
     12 
     13 #include <stddef.h>         // For size_t
     14 
     15 /*
     16  * A fake "enum" value for getting browser-implemented Pepper extensions.
     17  * The variable returns a pointer to an NPNExtensions structure. */
     18 #define NPNVPepperExtensions ((NPNVariable) 4000)
     19 
     20 /*
     21  * A fake "enum" value for getting plugin-implemented Pepper extensions.
     22  * The variable returns a pointer to an NPPExtensions structure. */
     23 #define NPPVPepperExtensions ((NPPVariable) 4001)
     24 
     25 typedef void NPDeviceConfig;
     26 typedef void NPDeviceContext;
     27 typedef void NPUserData;
     28 
     29 /* unique id for each device interface */
     30 typedef int32_t NPDeviceID;
     31 
     32 /* Events -------------------------------------------------------------------*/
     33 
     34 typedef enum {
     35   NPMouseButton_None    = -1,
     36   NPMouseButton_Left    = 0,
     37   NPMouseButton_Middle  = 1,
     38   NPMouseButton_Right   = 2
     39 } NPMouseButtons;
     40 
     41 typedef enum {
     42   NPEventType_Undefined   = -1,
     43   NPEventType_MouseDown   = 0,
     44   NPEventType_MouseUp     = 1,
     45   NPEventType_MouseMove   = 2,
     46   NPEventType_MouseEnter  = 3,
     47   NPEventType_MouseLeave  = 4,
     48   NPEventType_MouseWheel  = 5,
     49   NPEventType_RawKeyDown  = 6,
     50   NPEventType_KeyDown     = 7,
     51   NPEventType_KeyUp       = 8,
     52   NPEventType_Char        = 9,
     53   NPEventType_Minimize    = 10,
     54   NPEventType_Focus       = 11,
     55   NPEventType_Device      = 12
     56 } NPEventTypes;
     57 
     58 typedef enum {
     59   NPEventModifier_ShiftKey         = 1 << 0,
     60   NPEventModifier_ControlKey       = 1 << 1,
     61   NPEventModifier_AltKey           = 1 << 2,
     62   NPEventModifier_MetaKey          = 1 << 3,
     63   NPEventModifier_IsKeyPad         = 1 << 4,
     64   NPEventModifier_IsAutoRepeat     = 1 << 5,
     65   NPEventModifier_LeftButtonDown   = 1 << 6,
     66   NPEventModifier_MiddleButtonDown = 1 << 7,
     67   NPEventModifier_RightButtonDown  = 1 << 8
     68 } NPEventModifiers;
     69 
     70 typedef struct _NPKeyEvent
     71 {
     72   uint32_t modifier;
     73   uint32_t normalizedKeyCode;
     74 } NPKeyEvent;
     75 
     76 typedef struct _NPCharacterEvent
     77 {
     78   uint32_t modifier;
     79   uint16_t text[4];
     80   uint16_t unmodifiedText[4];
     81 } NPCharacterEvent;
     82 
     83 typedef struct _NPMouseEvent
     84 {
     85   uint32_t modifier;
     86   int32_t button;
     87   int32_t x;
     88   int32_t y;
     89   int32_t clickCount;
     90 } NPMouseEvent;
     91 
     92 typedef struct _NPMouseWheelEvent
     93 {
     94   uint32_t modifier;
     95   float deltaX;
     96   float deltaY;
     97   float wheelTicksX;
     98   float wheelTicksY;
     99   uint32_t scrollByPage;
    100 } NPMouseWheelEvent;
    101 
    102 typedef struct _NPDeviceEvent {
    103   uint32_t device_uid;
    104   uint32_t subtype;
    105   /* uint8_t generic[0]; */
    106 } NPDeviceEvent;
    107 
    108 typedef struct _NPMinimizeEvent {
    109   int32_t value;
    110 } NPMinimizeEvent;
    111 
    112 typedef struct _NPFocusEvent {
    113   int32_t value;
    114 } NPFocusEvent;
    115 
    116 typedef struct _NPPepperEvent
    117 {
    118   uint32_t size;
    119   int32_t type;
    120   double timeStampSeconds;
    121   union {
    122     NPKeyEvent key;
    123     NPCharacterEvent character;
    124     NPMouseEvent mouse;
    125     NPMouseWheelEvent wheel;
    126     NPMinimizeEvent minimize;
    127     NPFocusEvent focus;
    128     NPDeviceEvent device;
    129   } u;
    130 } NPPepperEvent;
    131 
    132 /* 2D -----------------------------------------------------------------------*/
    133 
    134 #define NPPepper2DDevice 1
    135 
    136 typedef struct _NPDeviceContext2DConfig {
    137 } NPDeviceContext2DConfig;
    138 
    139 typedef struct _NPDeviceContext2D
    140 {
    141   /* Internal value used by the browser to identify this device. */
    142   void* reserved;
    143 
    144   /* A pointer to the pixel data. This data is 8-bit values in BGRA order in
    145    * memory. Each row will start |stride| bytes after the previous one.
    146    *
    147    * THIS DATA USES PREMULTIPLIED ALPHA. This means that each color channel has
    148    * been multiplied with the corresponding alpha, which makes compositing
    149    * easier. If any color channels have a value greater than the alpha value,
    150    * you'll likely get crazy colors and weird artifacts. */
    151   void* region;
    152 
    153   /* Length of each row of pixels in bytes. This may be larger than width * 4
    154    * if there is padding at the end of each row to help with alignment. */
    155   int32_t stride;
    156 
    157   /* The dirty region that the plugin has painted into the buffer. This
    158    * will be initialized to the size of the plugin image in
    159    * initializeContextPtr. The plugin can change the values to only
    160    * update portions of the image. */
    161   struct {
    162     int32_t left;
    163     int32_t top;
    164     int32_t right;
    165     int32_t bottom;
    166   } dirty;
    167 } NPDeviceContext2D;
    168 
    169 typedef struct _NPDeviceBuffer {
    170   void* ptr;
    171   size_t size;
    172 } NPDeviceBuffer;
    173 
    174 /* completion callback for flush device */
    175 typedef void (*NPDeviceFlushContextCallbackPtr)(
    176     NPP instance,
    177     NPDeviceContext* context,
    178     NPError err,
    179     NPUserData* userData);
    180 
    181 /* query single capabilities of device */
    182 typedef NPError (
    183     *NPDeviceQueryCapabilityPtr)(NPP instance,
    184     int32_t capability,
    185     int32_t *value);
    186 /* query config (configuration == a set of capabilities) */
    187 typedef NPError (
    188     *NPDeviceQueryConfigPtr)(NPP instance,
    189     const NPDeviceConfig* request,
    190     NPDeviceConfig* obtain);
    191 /* device initialization */
    192 typedef NPError (*NPDeviceInitializeContextPtr)(
    193     NPP instance,
    194     const NPDeviceConfig* config,
    195     NPDeviceContext* context);
    196 /* peek at device state */
    197 typedef NPError (*NPDeviceGetStateContextPtr) (
    198     NPP instance,
    199     NPDeviceContext* context,
    200     int32_t state,
    201     intptr_t* value);
    202 /* poke device state */
    203 typedef NPError (*NPDeviceSetStateContextPtr) (
    204     NPP instance,
    205     NPDeviceContext* context,
    206     int32_t state,
    207     intptr_t value);
    208 /* flush context, if callback, userData are NULL */
    209 /* this becomes a blocking call */
    210 typedef NPError (*NPDeviceFlushContextPtr)(
    211     NPP instance,
    212     NPDeviceContext* context,
    213     NPDeviceFlushContextCallbackPtr callback,
    214     void* userData);
    215 /* destroy device context.  Application responsible for */
    216 /* freeing context, if applicable */
    217 typedef NPError (*NPDeviceDestroyContextPtr)(
    218     NPP instance,
    219     NPDeviceContext* context);
    220 /* Create a buffer associated with a particular context. The usage of the */
    221 /* buffer is device specific. The lifetime of the buffer is scoped with the */
    222 /* lifetime of the context. */
    223 typedef NPError (*NPDeviceCreateBufferPtr)(
    224     NPP instance,
    225     NPDeviceContext* context,
    226     size_t size,
    227     int32_t* id);
    228 /* Destroy a buffer associated with a particular context. */
    229 typedef NPError (*NPDeviceDestroyBufferPtr)(
    230     NPP instance,
    231     NPDeviceContext* context,
    232     int32_t id);
    233 /* Map a buffer id to its address. */
    234 typedef NPError (*NPDeviceMapBufferPtr)(
    235     NPP instance,
    236     NPDeviceContext* context,
    237     int32_t id,
    238     NPDeviceBuffer* buffer);
    239 
    240 
    241 /* forward decl typdef structs */
    242 typedef struct NPDevice NPDevice;
    243 typedef struct NPNExtensions NPNExtensions;
    244 
    245 // DEPRECATED: this typedef is just for the NaCl code until they switch to NPNExtensions.
    246 // PLEASE REMOVE THIS WHEN THE NACL CODE IS UPDATED.
    247 typedef struct NPNExtensions NPExtensions;
    248 
    249 
    250 /* New experimental device API. */
    251 
    252 /* Mode for calls to NPDeviceSynchronizeContext. */
    253 typedef enum {
    254   /* Get or set locally cached state without synchronizing or communicating   */
    255   /* with the service process (or thread).                                    */
    256   NPDeviceSynchronizationMode_Cached,
    257 
    258   /* Exchanges state with service process (or thread). Does not wait for any  */
    259   /* progress before returning.                                               */
    260   NPDeviceSynchronizationMode_Immediate,
    261 
    262   /* Exchanges state with service process (or thread). Blocks caller until    */
    263   /* further progress can be made.                                            */
    264   NPDeviceSynchronizationMode_Flush
    265 } NPDeviceSynchronizationMode;
    266 
    267 /* Get the number of configs supported by a given device. */
    268 typedef NPError (*NPDeviceGetNumConfigsPtr)(NPP instance,
    269                                             int32_t* numConfigs);
    270 
    271 /* Get attribute values from a config. NPDeviceGetConfigs might return        */
    272 /* multiple configs. This function can be used to examine them to             */
    273 /* find the most suitable. For example, NPDeviceGetConfigs might return one   */
    274 /* config with antialiasing enabled and one without. This can be determined   */
    275 /* using this function.                                                       */
    276 /* Inputs:                                                                    */
    277 /*  config: The config index to extract the attributes from.                  */
    278 /*  attribList: Array of input config attribute / value pairs                 */
    279 /*              terminated with NPAttrib_End.                                 */
    280 /* Outputs:                                                                   */
    281 /*  attribList: The values paired up with each attribute are filled in        */
    282 /*              on return.                                                    */
    283 typedef NPError (*NPDeviceGetConfigAttribsPtr)(NPP instance,
    284                                                int32_t config,
    285                                                int32_t* attribList);
    286 
    287 /* Create a device context based on a particular device configuration and a   */
    288 /* list config input attributes.                                              */
    289 /* Inputs:                                                                    */
    290 /*  config: The device configuration to use.                                  */
    291 /*  attribList: NULL or an array of context specific attribute / value        */
    292 /*              pairs terminated with NPAttrib_End.                           */
    293 /* Outputs:                                                                   */
    294 /*  context: The created context.                                             */
    295 typedef NPError (*NPDeviceCreateContextPtr)(NPP instance,
    296                                             int32_t config,
    297                                             const int32_t* attribList,
    298                                             NPDeviceContext** context);
    299 
    300 /* Destroy a context.                                                         */
    301 /* Inputs:                                                                    */
    302 /*  context: The context to destroy.                                          */
    303 /*typedef NPError (*NPDestroyContext)(NPP instance,                           */
    304 /*                                    NPDeviceContext* context);              */
    305 
    306 /* This type should be cast to the type associated with the particular        */
    307 /* callback type */
    308 typedef void (*NPDeviceGenericCallbackPtr)(void);
    309 
    310 /* Register a callback with a context. Callbacks are never invoked after the  */
    311 /* associated context has been destroyed. The semantics of the particular     */
    312 /* callback type determine which thread the callback is invoked on. It might  */
    313 /* be the plugin thread, the thread RegisterCallback is invoked on or a       */
    314 /* special thread created for servicing callbacks, such as an audio thread    */
    315 /* Inputs:                                                                    */
    316 /*  callbackType: The device specific callback type                           */
    317 /*  callback: The callback to invoke. The signature varies by type. Use       */
    318 /*            NULL to unregister the callback for a particular type.          */
    319 /*  callbackData: A value that is passed to the callback function. Other      */
    320 /*                callback arguments vary by type.                            */
    321 typedef NPError (*NPDeviceRegisterCallbackPtr)(
    322     NPP instance,
    323     NPDeviceContext* context,
    324     int32_t callbackType,
    325     NPDeviceGenericCallbackPtr callback,
    326     void* callbackData);
    327 
    328 /* Callback for NPDeviceSynchronizeContext.                                   */
    329 /* Inputs:                                                                    */
    330 /*  instance: The associated plugin instance.                                 */
    331 /*  context: The context that was flushed.                                    */
    332 /*  error: Indicates success of flush operation.                              */
    333 /*  data: The completion callback data that was passed to                     */
    334 /*        NPDeviceSynchronizeContext.                                         */
    335 typedef void (*NPDeviceSynchronizeContextCallbackPtr)(
    336     NPP instance,
    337     NPDeviceContext* context,
    338     NPError error,
    339     void* data);
    340 
    341 /* Synchronize the state of a device context. Takes lists of input and output */
    342 /* attributes. Generally, the input attributes are copied into the context    */
    343 /* and the output attributes are filled in the state of the context either    */
    344 /* after (before) the synchronization depending on whether it is synchronous  */
    345 /* (asynchronous). The get the state of the context after an asynchronous     */
    346 /* synchronization, call this function a second time with Cached mode after   */
    347 /* the callback has been invoked.                                             */
    348 /* Inputs:                                                                    */
    349 /*  context: The context to synchronize.                                      */
    350 /*  mode: The type of synchronization to perform.                             */
    351 /*  inputAttribList: NULL or an array of input synchronization attribute /    */
    352 /*                   value pairs terminated with NPAttrib_End.                */
    353 /*  outputAttribList: NULL or an array of output synchronization              */
    354 /*                    attributes / uninitialized value pairs terminated       */
    355 /*                    with NPAttrib_End.                                      */
    356 /*  callback: NULL for synchronous operation or completion callback function  */
    357 /*            for asynchronous operation.                                     */
    358 /*  callbackData: Argument passed to callback function.                       */
    359 /* Outputs:                                                                   */
    360 /*  outputAttribList: The values paired up with each attribute are filled     */
    361 /*                    in on return for synchronous operation.                 */
    362 typedef NPError (*NPDeviceSynchronizeContextPtr)(
    363     NPP instance,
    364     NPDeviceContext* context,
    365     NPDeviceSynchronizationMode mode,
    366     const int32_t* inputAttribList,
    367     int32_t* outputAttribList,
    368     NPDeviceSynchronizeContextCallbackPtr callback,
    369     void* callbackData);
    370 
    371 /* All attributes shared between devices, with the exception of               */
    372 /* NPDeviceContextAttrib_End, have bit 31 set. Device specific attributes     */
    373 /* have the bit clear.                                                        */
    374 enum {
    375   /* Used to terminate arrays of attribute / value pairs. */
    376   NPAttrib_End   = 0,
    377 
    378   /* Error status of context. Non-zero means error. Shared by all devices,    */
    379   /* though error values are device specific.                                 */
    380   NPAttrib_Error = 0x80000000
    381 };
    382 
    383 /* generic device interface */
    384 struct NPDevice {
    385   NPDeviceQueryCapabilityPtr queryCapability;
    386   NPDeviceQueryConfigPtr queryConfig;
    387   NPDeviceInitializeContextPtr initializeContext;
    388   NPDeviceSetStateContextPtr setStateContext;
    389   NPDeviceGetStateContextPtr getStateContext;
    390   NPDeviceFlushContextPtr flushContext;
    391   NPDeviceDestroyContextPtr destroyContext;
    392   NPDeviceCreateBufferPtr createBuffer;
    393   NPDeviceDestroyBufferPtr destroyBuffer;
    394   NPDeviceMapBufferPtr mapBuffer;
    395 
    396   /* Experimental device API */
    397   NPDeviceGetNumConfigsPtr getNumConfigs;
    398   NPDeviceGetConfigAttribsPtr getConfigAttribs;
    399   NPDeviceCreateContextPtr createContext;
    400 /*  NPDeviceDestroyContextPtr destroyContext; */
    401   NPDeviceRegisterCallbackPtr registerCallback;
    402   NPDeviceSynchronizeContextPtr synchronizeContext;
    403 /*  NPDeviceCreateBufferPtr createBuffer; */
    404 /*  NPDeviceDestroyBufferPtr destroyBuffer; */
    405 /*  NPDeviceMapBufferPtr mapBuffer; */
    406 };
    407 
    408 /* returns NULL if deviceID unavailable / unrecognized */
    409 typedef NPDevice* (*NPAcquireDevicePtr)(
    410     NPP instance,
    411     NPDeviceID device);
    412 
    413 /* Updates the number of find results for the current search term.  If
    414  * there are no matches 0 should be passed in.  Only when the plugin has
    415  * finished searching should it pass in the final count with finalResult set to
    416  * true. */
    417 typedef void (*NPNumberOfFindResultsChangedPtr)(
    418     NPP instance,
    419     int total,
    420     bool finalResult);
    421 
    422  /* Updates the index of the currently selected search item. */
    423 typedef void (*NPSelectedFindResultChangedPtr)(
    424     NPP instance,
    425     int index);
    426 
    427 /* Theming -----------------------------------------------------------------*/
    428 typedef int32_t NPWidgetID;
    429 
    430 typedef enum {
    431   NPWidgetTypeScrollbar = 0
    432 } NPWidgetType;
    433 
    434 typedef struct _NPScrollbarCreateParams {
    435   bool vertical;
    436 } NPScrollbarCreateParams;
    437 
    438 typedef struct _NPRect32
    439 {
    440   uint32_t top;
    441   uint32_t left;
    442   uint32_t bottom;
    443   uint32_t right;
    444 } NPRect32;
    445 
    446 typedef struct _NPScrollbarTickMarks {
    447   uint32_t count;
    448   NPRect32* tickmarks;
    449 } NPScrollbarTickMarks;
    450 
    451 typedef enum {
    452   NPWidgetPropertyLocation = 0,  // variable is NPRect*.
    453   NPWidgetPropertyDirtyRect = 1,  // Get only.  variable is NPRec*.
    454   NPWidgetPropertyScrollbarThickness = 2,  // Get only.  variable is int32_t*.
    455   NPWidgetPropertyScrollbarValue = 3,  // variable is int32_t*.
    456   NPWidgetPropertyScrollbarDocumentSize = 4,  // Set only. variable is int32_t*.
    457   // Set only.  variable is NPScrollbarTickMarks*.
    458   NPWidgetPropertyScrollbarTickMarks = 5,
    459   // Set only.  variable is bool* (true for forward, false for backward).
    460   NPWidgetPropertyScrollbarScrollByLine = 6,
    461   // Set only.  variable is bool* (true for forward, false for backward).
    462   NPWidgetPropertyScrollbarScrollByPage = 7,
    463   // Set only.  variable is bool* (true for forward, false for backward).
    464   NPWidgetPropertyScrollbarScrollByDocument = 8,
    465   // Set only.  variable is int32_t* (positive forward, negative  backward).
    466   NPWidgetPropertyScrollbarScrollByPixels = 9
    467 } NPWidgetProperty;
    468 
    469 // Creates a widget.  If it returns NPERR_NO_ERROR then id will contain a unique
    470 // identifer for the widget that's used for the next functions.
    471 typedef NPError (*NPCreateWidgetPtr) (
    472     NPP instance,
    473     NPWidgetType type,
    474     void* params,  // Widget specific.
    475     NPWidgetID* id);
    476 
    477 // Destroys a widget.
    478 typedef NPError (*NPDestroyWidgetPtr) (
    479     NPP instance,
    480     NPWidgetID id);
    481 
    482 // Paint the dirty rectangle of the given widget into context.
    483 typedef NPError (*NPPaintWidgetPtr) (
    484     NPP instance,
    485     NPWidgetID id,
    486     NPDeviceContext2D* context,
    487     NPRect* dirty);
    488 
    489 // Pass in a pepper event to a plugin.  It'll return true iff it uses it.
    490 typedef bool (*NPHandleWidgetEventPtr) (
    491     NPP instance,
    492     NPWidgetID id,
    493     NPPepperEvent* event);
    494 
    495 // Gets a property of the widget.  "value" varies depending on the variable.
    496 typedef NPError (*NPGetWidgetPropertyPtr) (
    497     NPP instance,
    498     NPWidgetID id,
    499     NPWidgetProperty property,
    500     void* value);
    501 
    502 // Sets a property of the widget.
    503 typedef NPError (*NPSetWidgetPropertyPtr) (
    504     NPP instance,
    505     NPWidgetID id,
    506     NPWidgetProperty property,
    507     void* value);
    508 
    509 typedef struct _NPWidgetExtensions {
    510   NPCreateWidgetPtr createWidget;
    511   NPDestroyWidgetPtr destroyWidget;
    512   NPPaintWidgetPtr paintWidget;
    513   NPHandleWidgetEventPtr handleWidgetEvent;
    514   NPGetWidgetPropertyPtr getWidgetProperty;
    515   NPSetWidgetPropertyPtr setWidgetProperty;
    516 } NPWidgetExtensions;
    517 
    518 typedef NPWidgetExtensions* (*NPGetWidgetExtensionsPtr)(
    519     NPP instance);
    520 
    521 
    522 /* Supports opening files anywhere on the system after prompting the user to
    523  * pick one.
    524  *
    525  * This API is asynchronous. It will return immediately and the user will be
    526  * prompted in parallel to pick a file. The plugin may continue to receive
    527  * events while the open file dialog is up, and may continue to paint. Plugins
    528  * may want to ignore input events between the call and the callback to avoid
    529  * reentrant behavior. If the return value is not NPERR_NO_ERROR, the callback
    530  * will NOT be executed.
    531  *
    532  * It is an error to call BrowseForFile before a previous call has executed
    533  * the callback.
    534  *
    535  * Setting the flags to "Open" requires that the file exist to allow picking.
    536  * Setting the flags to "Save" allows selecting nonexistant files (which will
    537  * then be created), and will prompt the user if they want to overwrite an
    538  * existing file if it exists.
    539  *
    540  * The plugin may specify a comma-separated list of possible mime types in
    541  * the "extensions" parameter. If no extensions are specified, the dialog box
    542  * will default to allowing all extensions. The first extension in the list
    543  * will be the default.
    544  *
    545  * TODO(brettw) On Windows the extensions traditionally include a text
    546  * description with the extension in the popup, do we want to allow this?
    547  * We should probably also allow the ability to put "All files" in the
    548  * list on Windows.
    549  *
    550  * Once the user has picked a file or has canceled the dialog box, the given
    551  * callback will be called with the results of the operation and the passed in
    552  * "user data" pointer. If the user successfully picked a file, the filename
    553  * will be non-NULL and will contain a pointer to an array of strings, one for
    554  * each file picked (the first file will be file_paths[0]). This buffer will
    555  * become invalid as soon as the call completes, so it is the plugin's
    556  * responsibility to copy the filename(sp if it needs future access to them.
    557  * A NULL file_paths in the callback means the user canceled the dialog box.
    558  *
    559  * The filename will be in UTF-8. It may not actually correspond to the actual
    560  * file on disk on a Linux system, because we'll do our best to convert it from
    561  * the filesystem's locale to UTF-8. Instead, the string will be appropriate for
    562  * displaying to the user which file they picked.
    563  * */
    564 typedef enum {
    565   NPChooseFile_Open = 1,
    566   NPChooseFile_OpenMultiple = 2,
    567   NPChooseFile_Save = 3
    568 } NPChooseFileMode;
    569 typedef void (*NPChooseFileCallback)(const char** filePaths,
    570                                      uint32_t pathCount,
    571                                      void* userData);
    572 typedef NPError (*NPChooseFilePtr)(
    573     NPP instance,
    574     const char* mimeTypes,
    575     NPChooseFileMode mode,
    576     NPChooseFileCallback callback,
    577     void* userData);
    578 
    579 typedef enum {
    580   NPCursorTypePointer = 0,
    581   NPCursorTypeCross = 1,
    582   NPCursorTypeHand = 2,
    583   NPCursorTypeIBeam = 3,
    584   NPCursorTypeWait = 4,
    585   NPCursorTypeHelp = 5,
    586   NPCursorTypeEastResize = 6,
    587   NPCursorTypeNorthResize = 7,
    588   NPCursorTypeNorthEastResize = 8,
    589   NPCursorTypeNorthWestResize = 9,
    590   NPCursorTypeSouthResize = 10,
    591   NPCursorTypeSouthEastResize = 11,
    592   NPCursorTypeSouthWestResize = 12,
    593   NPCursorTypeWestResize = 13,
    594   NPCursorTypeNorthSouthResize = 14,
    595   NPCursorTypeEastWestResize = 15,
    596   NPCursorTypeNorthEastSouthWestResize = 16,
    597   NPCursorTypeNorthWestSouthEastResize = 17,
    598   NPCursorTypeColumnResize = 18,
    599   NPCursorTypeRowResize = 19,
    600   NPCursorTypeMiddlePanning = 20,
    601   NPCursorTypeEastPanning = 21,
    602   NPCursorTypeNorthPanning = 22,
    603   NPCursorTypeNorthEastPanning = 23,
    604   NPCursorTypeNorthWestPanning = 24,
    605   NPCursorTypeSouthPanning = 25,
    606   NPCursorTypeSouthEastPanning = 26,
    607   NPCursorTypeSouthWestPanning = 27,
    608   NPCursorTypeWestPanning = 28,
    609   NPCursorTypeMove = 29,
    610   NPCursorTypeVerticalText = 30,
    611   NPCursorTypeCell = 31,
    612   NPCursorTypeContextMenu = 32,
    613   NPCursorTypeAlias = 33,
    614   NPCursorTypeProgress = 34,
    615   NPCursorTypeNoDrop = 35,
    616   NPCursorTypeCopy = 36,
    617   NPCursorTypeNone = 37,
    618   NPCursorTypeNotAllowed = 38,
    619   NPCursorTypeZoomIn = 39,
    620   NPCursorTypeZoomOut = 40
    621 } NPCursorType;
    622 
    623 // Temporary SetCursor API.
    624 typedef NPError (*NPSetCursorPtr)(
    625     NPP instance,
    626     NPCursorType type);
    627 
    628 /* unique id for each font */
    629 typedef int NPFontID;
    630 
    631 typedef enum {
    632   NPCharsetAnsi = 0,
    633   NPCharsetDefault = 1,
    634   NPCharsetSymbol = 2,
    635   NPCharsetMac = 77,
    636   NPCharsetShiftJIS = 128,
    637   NPCharsetHangul = 129,
    638   NPCharsetJohab = 130,
    639   NPCharsetGB2312 =134,
    640   NPCharsetChineseBIG5 = 136,
    641   NPCharsetGreek = 161,
    642   NPCharsetTurkish = 162,
    643   NPCharsetVietnamese = 163,
    644   NPCharsetHebrew = 177,
    645   NPCharsetArabic = 178,
    646   NPCharsetBaltic = 186,
    647   NPCharsetRussian = 204,
    648   NPCharsetThai = 222,
    649   NPCharsetEastEurope = 238,
    650   NPCharsetOEM = 255
    651 } NPCharset;
    652 
    653 typedef enum {
    654   NPPitchDefault,
    655   NPPitchFixed
    656 } NPPitch;
    657 
    658 typedef enum {
    659   NPFamilyDefault,
    660   NPFamilyRoman,
    661   NPFamilyScript
    662 } NPFamily;
    663 
    664 typedef struct _NPFontDescription {
    665   const char* face;
    666   int weight;
    667   bool italic;
    668   NPPitch pitch;
    669   NPFamily family;
    670   NPCharset charset;
    671 } NPFontDescription;
    672 
    673 // Return a font which best matches the given properties.
    674 typedef NPError (*NPMatchFontWithFallbackPtr) (
    675     NPP instance,
    676     const NPFontDescription* description,
    677     NPFontID* id);
    678 
    679 // Loads a specified font table for the given font.
    680 //   table: the table in *big-endian* format, or 0 for the whole font file.
    681 //   output: a buffer of size output_length that gets the data.  can be 0, in
    682 //     which case output_length will be set to the required size in bytes.
    683 //   output_length: size of output, if it's not 0.
    684 typedef NPError (*GetFontTablePtr) (
    685     NPP instance,
    686     NPFontID id,
    687     uint32_t table,
    688     void* output,
    689     size_t* output_length);
    690 
    691 // Destroys a font.
    692 typedef NPError (*NPDestroyFontPtr) (
    693     NPP instance,
    694     NPFontID id);
    695 
    696 typedef struct _NPFontExtensions {
    697   NPMatchFontWithFallbackPtr matchFontWithFallback;
    698   GetFontTablePtr getFontTable;
    699   NPDestroyFontPtr destroyFont;
    700 } NPFontExtensions;
    701 
    702 typedef NPFontExtensions* (*NPGetFontExtensionsPtr)(
    703     NPP instance);
    704 
    705 /* Pepper extensions */
    706 struct NPNExtensions {
    707   /* Device interface acquisition */
    708   NPAcquireDevicePtr acquireDevice;
    709   /* Find */
    710   NPNumberOfFindResultsChangedPtr numberOfFindResultsChanged;
    711   NPSelectedFindResultChangedPtr selectedFindResultChanged;
    712   /* File I/O extensions */
    713   NPChooseFilePtr chooseFile;
    714   /* Widget */
    715   NPGetWidgetExtensionsPtr getWidgetExtensions;
    716   /* Cursor */
    717   NPSetCursorPtr setCursor;
    718   /* Font */
    719   NPGetFontExtensionsPtr getFontExtensions;
    720 };
    721 
    722 /* 3D -----------------------------------------------------------------------*/
    723 
    724 #define NPPepper3DDevice 2
    725 
    726 typedef struct _NPDeviceContext3DConfig {
    727   int32_t commandBufferSize;
    728 } NPDeviceContext3DConfig;
    729 
    730 typedef enum _NPDeviceContext3DError {
    731   // No error has ocurred.
    732   NPDeviceContext3DError_NoError,
    733 
    734   // The size of a command was invalid.
    735   NPDeviceContext3DError_InvalidSize,
    736 
    737   // An offset was out of bounds.
    738   NPDeviceContext3DError_OutOfBounds,
    739 
    740   // A command was not recognized.
    741   NPDeviceContext3DError_UnknownCommand,
    742 
    743   // The arguments to a command were invalid.
    744   NPDeviceContext3DError_InvalidArguments,
    745 
    746   // The 3D context was lost, for example due to a power management event. The
    747   // context must be destroyed and a new one created.
    748   NPDeviceContext3DError_LostContext,
    749 
    750   // Any other error.
    751   NPDeviceContext3DError_GenericError
    752 } NPDeviceContext3DError;
    753 
    754 typedef struct _NPDeviceContext3D NPDeviceContext3D;
    755 
    756 typedef void (*NPDeviceContext3DRepaintPtr)(NPP npp,
    757                                             NPDeviceContext3D* context);
    758 
    759 // TODO(apatrick): this need not be exposed when we switch over to the new
    760 // device API. It's layout can also be implementation dependent.
    761 typedef struct _NPDeviceContext3D
    762 {
    763   void* reserved;
    764 
    765   // If true, then a flush will only complete once the get offset has advanced
    766   // on the GPU thread. If false, then the get offset might have changed but
    767   // the GPU thread will respond as quickly as possible without guaranteeing
    768   // having made any progress in executing pending commands. Set to true
    769   // to ensure that progress is made or when flushing in a loop waiting for the
    770   // GPU to reach a certain state, for example in advancing beyond a particular
    771   // token. Set to false when flushing to query the current state, for example
    772   // whether an error has occurred.
    773   bool waitForProgress;
    774 
    775   // Buffer in which commands are stored.
    776   void* commandBuffer;
    777   int32_t commandBufferSize;
    778 
    779   // Offset in command buffer reader has reached. Synchronized on flush.
    780   int32_t getOffset;
    781 
    782   // Offset in command buffer writer has reached. Synchronized on flush.
    783   int32_t putOffset;
    784 
    785   // Last processed token. Synchronized on flush.
    786   int32_t token;
    787 
    788   // Callback invoked on the main thread when the context must be repainted.
    789   // TODO(apatrick): move this out of the context struct like the rest of the
    790   // fields.
    791   NPDeviceContext3DRepaintPtr repaintCallback;
    792 
    793   // Error status. Synchronized on flush.
    794   NPDeviceContext3DError error;
    795 } NPDeviceContext3D;
    796 
    797 
    798 /* Begin 3D specific portion of experimental device API */
    799 
    800 /* Device buffer ID reserved for command buffer */
    801 enum {
    802   NP3DCommandBufferId = 0
    803 };
    804 
    805 /* 3D attributes */
    806 enum {
    807   /* Example GetConfigAttribs attributes. See EGL 1.4 spec. */
    808   /* These may be passed to GetConfigAttribs. */
    809   NP3DAttrib_BufferSize        = 0x3020,
    810   NP3DAttrib_AlphaSize         = 0x3021,
    811   NP3DAttrib_BlueSize          = 0x3022,
    812   NP3DAttrib_GreenSize         = 0x3023,
    813   NP3DAttrib_RedSize           = 0x3024,
    814   NP3DAttrib_DepthSize         = 0x3025,
    815   NP3DAttrib_StencilSize       = 0x3026,
    816   NP3DAttrib_SurfaceType       = 0x3033,
    817 
    818   /* Example CreateContext attributes. See EGL 1.4 spec. */
    819   /* These may be passed to CreateContext. */
    820   NP3DAttrib_SwapBehavior       = 0x3093,
    821   NP3DAttrib_MultisampleResolve = 0x3099,
    822 
    823   /* Size of command buffer in 32-bit entries. */
    824   /* This may be passed to CreateContext as an input or SynchronizeContext as */
    825   /* an output. */
    826   NP3DAttrib_CommandBufferSize  = 0x10000000,
    827 
    828   /* These may be passed to SynchronizeContext. */
    829 
    830   /* Offset in command buffer writer has reached. In / out.*/
    831   NP3DAttrib_PutOffset,
    832 
    833   /* Offset in command buffer reader has reached. Out only. */
    834   NP3DAttrib_GetOffset,
    835 
    836   /* Last processed token. Out only. */
    837   NP3DAttrib_Token
    838 };
    839 
    840 /* 3D callbacks */
    841 enum {
    842   /* This callback is invoked whenever the plugin must repaint everything.    */
    843   /* This might be because the window manager must repaint a window or        */
    844   /* the context has been lost, for example a power management event.         */
    845   NP3DCallback_Repaint = 1
    846 };
    847 
    848 /* Flags for NPConfig3DOutAttrib_SurfaceType */
    849 enum {
    850   NP3DSurfaceType_MultisampleResolveBox = 0x0200,
    851   NP3DSurfaceType_SwapBehaviorPreserved = 0x0400
    852 };
    853 
    854 /* Values for NPConfig3DInAttrib_SwapBehavior */
    855 enum {
    856   NP3DSwapBehavior_Preserved            = 0x3094,
    857   NP3DSwapBehavior_Destroyed            = 0x3095
    858 };
    859 
    860 /* Values for NPConfig3DInAttrib_MultisampleResolve */
    861 enum {
    862   NP3DMultisampleResolve_Default        = 0x309A,
    863   NP3DMultisampleResolve_Box            = 0x309B
    864 };
    865 
    866 /* End 3D specific API */
    867 
    868 /* Audio --------------------------------------------------------------------*/
    869 
    870 #define NPPepperAudioDevice 3
    871 
    872 /* min & max sample frame count */
    873 typedef enum {
    874   NPAudioMinSampleFrameCount = 64,
    875   NPAudioMaxSampleFrameCount = 32768
    876 } NPAudioSampleFrameCounts;
    877 
    878 /* supported sample rates */
    879 typedef enum {
    880   NPAudioSampleRate44100Hz = 44100,
    881   NPAudioSampleRate48000Hz = 48000,
    882   NPAudioSampleRate96000Hz = 96000
    883 } NPAudioSampleRates;
    884 
    885 /* supported sample formats */
    886 typedef enum {
    887   NPAudioSampleTypeInt16   = 0,
    888   NPAudioSampleTypeFloat32 = 1
    889 } NPAudioSampleTypes;
    890 
    891 /* supported channel layouts */
    892 /* there is code that depends on these being the actual number of channels */
    893 typedef enum {
    894   NPAudioChannelNone     = 0,
    895   NPAudioChannelMono     = 1,
    896   NPAudioChannelStereo   = 2,
    897   NPAudioChannelThree    = 3,
    898   NPAudioChannelFour     = 4,
    899   NPAudioChannelFive     = 5,
    900   NPAudioChannelFiveOne  = 6,
    901   NPAudioChannelSeven    = 7,
    902   NPAudioChannelSevenOne = 8
    903 } NPAudioChannels;
    904 
    905 /* audio context states */
    906 typedef enum {
    907   NPAudioContextStateCallback = 0,
    908   NPAudioContextStateUnderrunCounter = 1
    909 } NPAudioContextStates;
    910 
    911 /* audio context state values */
    912 typedef enum {
    913   NPAudioCallbackStop = 0,
    914   NPAudioCallbackStart = 1
    915 } NPAudioContextStateValues;
    916 
    917 /* audio query capabilities */
    918 typedef enum {
    919   NPAudioCapabilitySampleRate              = 0,
    920   NPAudioCapabilitySampleType              = 1,
    921   NPAudioCapabilitySampleFrameCount        = 2,
    922   NPAudioCapabilitySampleFrameCount44100Hz = 3,
    923   NPAudioCapabilitySampleFrameCount48000Hz = 4,
    924   NPAudioCapabilitySampleFrameCount96000Hz = 5,
    925   NPAudioCapabilityOutputChannelMap        = 6,
    926   NPAudioCapabilityInputChannelMap         = 7
    927 } NPAudioCapabilities;
    928 
    929 typedef struct _NPDeviceContextAudio NPDeviceContextAudio;
    930 
    931 /* user supplied callback function */
    932 typedef void (*NPAudioCallback)(NPDeviceContextAudio *context);
    933 
    934 typedef struct _NPDeviceContextAudioConfig {
    935   int32_t sampleRate;
    936   int32_t sampleType;
    937   int32_t outputChannelMap;
    938   int32_t inputChannelMap;
    939   int32_t sampleFrameCount;
    940   uint32_t startThread;
    941   uint32_t flags;
    942   NPAudioCallback callback;
    943   void *userData;
    944 } NPDeviceContextAudioConfig;
    945 
    946 struct _NPDeviceContextAudio {
    947   NPDeviceContextAudioConfig config;
    948   void *outBuffer;
    949   void *inBuffer;
    950   void *reserved;
    951 };
    952 
    953 /* Printing related APIs ---------------------------------------------------*/
    954 
    955 /* Defines a contiguous range of pages to be printed. Page numbers use a
    956  * zero-based index. */
    957 typedef struct _NPPrintPageNumberRange {
    958   int32_t firstPageNumber;
    959   int32_t lastPageNumber;
    960 } NPPrintPageNumberRange;
    961 
    962 /* Being a print operation. Returns the total number of pages to print at the
    963  * given printableArea size and DPI. printableArea is in points (a point is 1/72
    964  * of an inch). The plugin is expected to remember the values of printableArea
    965  * and printerDPI for use in subsequent print interface calls. These values
    966  * should be cleared in printEnd. */
    967 typedef NPError (*NPPPrintBeginPtr) (
    968     NPP instance,
    969     NPRect* printableArea,
    970     int32_t printerDPI,
    971     int32_t* numPages);
    972 /* Returns the required raster dimensions for the given page. */
    973 typedef NPError (*NPPGetRasterDimensionsPtr) (
    974     NPP instance,
    975     int32_t pageNumber,
    976     int32_t* widthInPixels,
    977     int32_t* heightInPixels);
    978 /* Prints the specified page This allows the plugin to print a raster output. */
    979 typedef NPError (*NPPPrintPageRasterPtr) (
    980     NPP instance,
    981     int32_t pageNumber,
    982     NPDeviceContext2D* printSurface);
    983 /* Ends the print operation */
    984 typedef NPError (*NPPPrintEndPtr) (NPP instance);
    985 /* Prints the specified pages as PDF. The plugin allocates the output buffer
    986  * pointed to by pdf_output using the browser-supplied NPN_MemAlloc function.
    987  * The caller is expected to free the output buffer upon success.*/
    988 typedef NPError (*NPPrintPagesAsPDFPtr)(NPP instance,
    989                                         NPPrintPageNumberRange* page_ranges,
    990                                         int32_t page_range_count,
    991                                         unsigned char** pdf_output,
    992                                         int32_t* output_size);
    993 
    994 
    995 /* TODO(sanjeevr) : Provide a vector interface for printing. We need to decide
    996  * on a vector format that can support embedded fonts. A vector format will
    997  * greatly reduce the size of the required output buffer. */
    998 
    999 typedef struct _NPPPrintExtensions {
   1000   NPPPrintBeginPtr printBegin;
   1001   NPPGetRasterDimensionsPtr getRasterDimensions;
   1002   NPPPrintPageRasterPtr printPageRaster;
   1003   NPPPrintEndPtr printEnd;
   1004   NPPrintPagesAsPDFPtr printPagesAsPDF;
   1005 } NPPPrintExtensions;
   1006 
   1007 /* Returns NULL if the plugin does not support print extensions */
   1008 typedef NPPPrintExtensions* (*NPPGetPrintExtensionsPtr)(NPP instance);
   1009 
   1010 /* Find ---------------------------------------------------------------------*/
   1011 
   1012 /* Finds the given UTF-8 text starting at the current selection.  The number of
   1013  * results will be updated asynchronously via numberOfFindResultsChanged.  Note
   1014  * that multiple StartFind calls can happen before StopFind is called in the
   1015  * case of the search term changing. */
   1016 typedef NPError (*NPPStartFindPtr) (
   1017     NPP instance,
   1018     const char* text,
   1019     bool caseSensitive);
   1020 
   1021 /* Go to the next/previous result. */
   1022 typedef NPError (*NPPSelectFindResultPtr) (
   1023     NPP instance,
   1024     bool forward);
   1025 
   1026 /* Tells the plugin that the find operation has stopped, so it should clear
   1027  * any highlighting. */
   1028 typedef NPError (*NPPStopFindPtr) (
   1029     NPP instance);
   1030 
   1031 typedef struct _NPPFindExtensions {
   1032   NPPStartFindPtr startFind;
   1033   NPPSelectFindResultPtr selectFindResult;
   1034   NPPStopFindPtr stopFind;
   1035 } NPPFindExtensions;
   1036 
   1037 /* Returns NULL if the plugin does not support find extensions. */
   1038 typedef NPPFindExtensions* (*NPPGetFindExtensionsPtr)(NPP instance);
   1039 
   1040 /* Zooms a plugin to the given factor.  If text_only is true, then only the text
   1041  * should be zoomed. */
   1042 typedef NPError (*NPPZoomPtr) (
   1043     NPP instance,
   1044     float factor,
   1045     bool text_only);
   1046 
   1047 typedef NPError (*NPPWidgetPropertyChangedPtr) (
   1048     NPP instance,
   1049     NPWidgetID id,
   1050     NPWidgetProperty property);
   1051 
   1052 /* type of selection */
   1053 typedef enum {
   1054   NPSelectionTypeAny       = 0,
   1055   NPSelectionTypePlainText = 1,
   1056   NPSelectionTypeHTML      = 2
   1057 } NPSelectionType;
   1058 
   1059 /* Gets the selection.  NPERR_GENERIC_ERROR is returned if nothing is selected.
   1060  * 'type' is both an input and output parameter.  The caller can request a
   1061  * specific type, and if the plugin can't provide it, it will return
   1062  * NPERR_GENERIC_ERROR.  Or the caller can specify NPSelectionTypeAny to let the
   1063  * plugin pick the best format for the data.  The result is returned in a buffer
   1064  * that's owned by the caller and which is allocated using NPN_MemAlloc.  If no
   1065  * data is available, NPERR_GENERIC_ERROR is returned. */
   1066 typedef NPError (*NPPGetSelectionPtr) (
   1067     NPP instance,
   1068     NPSelectionType* type,
   1069     void** data);
   1070 
   1071 typedef struct _NPPExtensions {
   1072   NPPGetPrintExtensionsPtr getPrintExtensions;
   1073   NPPGetFindExtensionsPtr getFindExtensions;
   1074   NPPZoomPtr zoom;
   1075   NPPWidgetPropertyChangedPtr widgetPropertyChanged;
   1076   NPPGetSelectionPtr getSelection;
   1077 } NPPExtensions;
   1078 
   1079 #endif  /* _NP_EXTENSIONS_H_ */
   1080