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