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
25typedef void NPDeviceConfig;
26typedef void NPDeviceContext;
27typedef void NPUserData;
28
29/* unique id for each device interface */
30typedef int32_t NPDeviceID;
31
32/* Events -------------------------------------------------------------------*/
33
34typedef enum {
35  NPMouseButton_None    = -1,
36  NPMouseButton_Left    = 0,
37  NPMouseButton_Middle  = 1,
38  NPMouseButton_Right   = 2
39} NPMouseButtons;
40
41typedef 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
58typedef 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
70typedef struct _NPKeyEvent
71{
72  uint32_t modifier;
73  uint32_t normalizedKeyCode;
74} NPKeyEvent;
75
76typedef struct _NPCharacterEvent
77{
78  uint32_t modifier;
79  uint16_t text[4];
80  uint16_t unmodifiedText[4];
81} NPCharacterEvent;
82
83typedef 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
92typedef 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
102typedef struct _NPDeviceEvent {
103  uint32_t device_uid;
104  uint32_t subtype;
105  /* uint8_t generic[0]; */
106} NPDeviceEvent;
107
108typedef struct _NPMinimizeEvent {
109  int32_t value;
110} NPMinimizeEvent;
111
112typedef struct _NPFocusEvent {
113  int32_t value;
114} NPFocusEvent;
115
116typedef 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
136typedef struct _NPDeviceContext2DConfig {
137} NPDeviceContext2DConfig;
138
139typedef 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
169typedef struct _NPDeviceBuffer {
170  void* ptr;
171  size_t size;
172} NPDeviceBuffer;
173
174/* completion callback for flush device */
175typedef void (*NPDeviceFlushContextCallbackPtr)(
176    NPP instance,
177    NPDeviceContext* context,
178    NPError err,
179    NPUserData* userData);
180
181/* query single capabilities of device */
182typedef NPError (
183    *NPDeviceQueryCapabilityPtr)(NPP instance,
184    int32_t capability,
185    int32_t *value);
186/* query config (configuration == a set of capabilities) */
187typedef NPError (
188    *NPDeviceQueryConfigPtr)(NPP instance,
189    const NPDeviceConfig* request,
190    NPDeviceConfig* obtain);
191/* device initialization */
192typedef NPError (*NPDeviceInitializeContextPtr)(
193    NPP instance,
194    const NPDeviceConfig* config,
195    NPDeviceContext* context);
196/* peek at device state */
197typedef NPError (*NPDeviceGetStateContextPtr) (
198    NPP instance,
199    NPDeviceContext* context,
200    int32_t state,
201    intptr_t* value);
202/* poke device state */
203typedef 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 */
210typedef 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 */
217typedef 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. */
223typedef 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. */
229typedef NPError (*NPDeviceDestroyBufferPtr)(
230    NPP instance,
231    NPDeviceContext* context,
232    int32_t id);
233/* Map a buffer id to its address. */
234typedef NPError (*NPDeviceMapBufferPtr)(
235    NPP instance,
236    NPDeviceContext* context,
237    int32_t id,
238    NPDeviceBuffer* buffer);
239
240
241/* forward decl typdef structs */
242typedef struct NPDevice NPDevice;
243typedef 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.
247typedef struct NPNExtensions NPExtensions;
248
249
250/* New experimental device API. */
251
252/* Mode for calls to NPDeviceSynchronizeContext. */
253typedef 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. */
268typedef 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.                                                    */
283typedef 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.                                             */
295typedef 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 */
308typedef 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.                            */
321typedef 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.                                         */
335typedef 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.                 */
362typedef 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.                                                        */
374enum {
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 */
384struct 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 */
409typedef 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. */
417typedef void (*NPNumberOfFindResultsChangedPtr)(
418    NPP instance,
419    int total,
420    bool finalResult);
421
422 /* Updates the index of the currently selected search item. */
423typedef void (*NPSelectedFindResultChangedPtr)(
424    NPP instance,
425    int index);
426
427/* Theming -----------------------------------------------------------------*/
428typedef int32_t NPWidgetID;
429
430typedef enum {
431  NPWidgetTypeScrollbar = 0
432} NPWidgetType;
433
434typedef struct _NPScrollbarCreateParams {
435  bool vertical;
436} NPScrollbarCreateParams;
437
438typedef struct _NPRect32
439{
440  uint32_t top;
441  uint32_t left;
442  uint32_t bottom;
443  uint32_t right;
444} NPRect32;
445
446typedef struct _NPScrollbarTickMarks {
447  uint32_t count;
448  NPRect32* tickmarks;
449} NPScrollbarTickMarks;
450
451typedef 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.
471typedef NPError (*NPCreateWidgetPtr) (
472    NPP instance,
473    NPWidgetType type,
474    void* params,  // Widget specific.
475    NPWidgetID* id);
476
477// Destroys a widget.
478typedef NPError (*NPDestroyWidgetPtr) (
479    NPP instance,
480    NPWidgetID id);
481
482// Paint the dirty rectangle of the given widget into context.
483typedef 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.
490typedef 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.
496typedef NPError (*NPGetWidgetPropertyPtr) (
497    NPP instance,
498    NPWidgetID id,
499    NPWidgetProperty property,
500    void* value);
501
502// Sets a property of the widget.
503typedef NPError (*NPSetWidgetPropertyPtr) (
504    NPP instance,
505    NPWidgetID id,
506    NPWidgetProperty property,
507    void* value);
508
509typedef struct _NPWidgetExtensions {
510  NPCreateWidgetPtr createWidget;
511  NPDestroyWidgetPtr destroyWidget;
512  NPPaintWidgetPtr paintWidget;
513  NPHandleWidgetEventPtr handleWidgetEvent;
514  NPGetWidgetPropertyPtr getWidgetProperty;
515  NPSetWidgetPropertyPtr setWidgetProperty;
516} NPWidgetExtensions;
517
518typedef 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 * */
564typedef enum {
565  NPChooseFile_Open = 1,
566  NPChooseFile_OpenMultiple = 2,
567  NPChooseFile_Save = 3
568} NPChooseFileMode;
569typedef void (*NPChooseFileCallback)(const char** filePaths,
570                                     uint32_t pathCount,
571                                     void* userData);
572typedef NPError (*NPChooseFilePtr)(
573    NPP instance,
574    const char* mimeTypes,
575    NPChooseFileMode mode,
576    NPChooseFileCallback callback,
577    void* userData);
578
579typedef 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.
624typedef NPError (*NPSetCursorPtr)(
625    NPP instance,
626    NPCursorType type);
627
628/* unique id for each font */
629typedef int NPFontID;
630
631typedef 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
653typedef enum {
654  NPPitchDefault,
655  NPPitchFixed
656} NPPitch;
657
658typedef enum {
659  NPFamilyDefault,
660  NPFamilyRoman,
661  NPFamilyScript
662} NPFamily;
663
664typedef 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.
674typedef 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.
684typedef 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.
692typedef NPError (*NPDestroyFontPtr) (
693    NPP instance,
694    NPFontID id);
695
696typedef struct _NPFontExtensions {
697  NPMatchFontWithFallbackPtr matchFontWithFallback;
698  GetFontTablePtr getFontTable;
699  NPDestroyFontPtr destroyFont;
700} NPFontExtensions;
701
702typedef NPFontExtensions* (*NPGetFontExtensionsPtr)(
703    NPP instance);
704
705/* Pepper extensions */
706struct 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
726typedef struct _NPDeviceContext3DConfig {
727  int32_t commandBufferSize;
728} NPDeviceContext3DConfig;
729
730typedef 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
754typedef struct _NPDeviceContext3D NPDeviceContext3D;
755
756typedef 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.
761typedef 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 */
801enum {
802  NP3DCommandBufferId = 0
803};
804
805/* 3D attributes */
806enum {
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 */
841enum {
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 */
849enum {
850  NP3DSurfaceType_MultisampleResolveBox = 0x0200,
851  NP3DSurfaceType_SwapBehaviorPreserved = 0x0400
852};
853
854/* Values for NPConfig3DInAttrib_SwapBehavior */
855enum {
856  NP3DSwapBehavior_Preserved            = 0x3094,
857  NP3DSwapBehavior_Destroyed            = 0x3095
858};
859
860/* Values for NPConfig3DInAttrib_MultisampleResolve */
861enum {
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 */
873typedef enum {
874  NPAudioMinSampleFrameCount = 64,
875  NPAudioMaxSampleFrameCount = 32768
876} NPAudioSampleFrameCounts;
877
878/* supported sample rates */
879typedef enum {
880  NPAudioSampleRate44100Hz = 44100,
881  NPAudioSampleRate48000Hz = 48000,
882  NPAudioSampleRate96000Hz = 96000
883} NPAudioSampleRates;
884
885/* supported sample formats */
886typedef 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 */
893typedef 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 */
906typedef enum {
907  NPAudioContextStateCallback = 0,
908  NPAudioContextStateUnderrunCounter = 1
909} NPAudioContextStates;
910
911/* audio context state values */
912typedef enum {
913  NPAudioCallbackStop = 0,
914  NPAudioCallbackStart = 1
915} NPAudioContextStateValues;
916
917/* audio query capabilities */
918typedef 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
929typedef struct _NPDeviceContextAudio NPDeviceContextAudio;
930
931/* user supplied callback function */
932typedef void (*NPAudioCallback)(NPDeviceContextAudio *context);
933
934typedef 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
946struct _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. */
957typedef 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. */
967typedef 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. */
973typedef 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. */
979typedef NPError (*NPPPrintPageRasterPtr) (
980    NPP instance,
981    int32_t pageNumber,
982    NPDeviceContext2D* printSurface);
983/* Ends the print operation */
984typedef 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.*/
988typedef 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
999typedef 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 */
1008typedef 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. */
1016typedef NPError (*NPPStartFindPtr) (
1017    NPP instance,
1018    const char* text,
1019    bool caseSensitive);
1020
1021/* Go to the next/previous result. */
1022typedef 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. */
1028typedef NPError (*NPPStopFindPtr) (
1029    NPP instance);
1030
1031typedef 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. */
1038typedef 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. */
1042typedef NPError (*NPPZoomPtr) (
1043    NPP instance,
1044    float factor,
1045    bool text_only);
1046
1047typedef NPError (*NPPWidgetPropertyChangedPtr) (
1048    NPP instance,
1049    NPWidgetID id,
1050    NPWidgetProperty property);
1051
1052/* type of selection */
1053typedef 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. */
1066typedef NPError (*NPPGetSelectionPtr) (
1067    NPP instance,
1068    NPSelectionType* type,
1069    void** data);
1070
1071typedef 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