OLD | NEW |
| (Empty) |
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 NPNEx
tensions. | |
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_ */ | |
OLD | NEW |