| 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 |
|---|
Chromium Code Reviews
Issue 1860753002:
Remove third_party/npapi (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@remove_03_content_child_npapi