/* Copyright 2012 The Chromium Authors
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
/**
* This file defines the Input Event interfaces.
*/
label Chrome {
M13 = 1.0,
M14 = 1.1,
M34 = 1.2,
M55 = 1.3,
M60 = 1.4
};
/**
* This enumeration contains the types of input events.
*/
[assert_size(4)]
enum PP_InputEvent_Type {
PP_INPUTEVENT_TYPE_UNDEFINED = -1,
PP_INPUTEVENT_TYPE_FIRST = PP_INPUTEVENT_TYPE_UNDEFINED,
/**
* Notification that a mouse button was pressed.
*
* Register for this event using the PP_INPUTEVENT_CLASS_MOUSE class.
*/
PP_INPUTEVENT_TYPE_MOUSEDOWN = 0,
/**
* Notification that a mouse button was released.
*
* Register for this event using the PP_INPUTEVENT_CLASS_MOUSE class.
*/
PP_INPUTEVENT_TYPE_MOUSEUP = 1,
/**
* Notification that a mouse button was moved when it is over the instance
* or dragged out of it.
*
* Register for this event using the PP_INPUTEVENT_CLASS_MOUSE class.
*/
PP_INPUTEVENT_TYPE_MOUSEMOVE = 2,
/**
* Notification that the mouse entered the instance's bounds.
*
* Register for this event using the PP_INPUTEVENT_CLASS_MOUSE class.
*/
PP_INPUTEVENT_TYPE_MOUSEENTER = 3,
/**
* Notification that a mouse left the instance's bounds.
*
* Register for this event using the PP_INPUTEVENT_CLASS_MOUSE class.
*/
PP_INPUTEVENT_TYPE_MOUSELEAVE = 4,
/**
* Notification that the scroll wheel was used.
*
* Register for this event using the PP_INPUTEVENT_CLASS_WHEEL class.
*/
PP_INPUTEVENT_TYPE_WHEEL = 5,
/**
* Notification that a key transitioned from "up" to "down".
*
* Register for this event using the PP_INPUTEVENT_CLASS_KEYBOARD class.
*/
PP_INPUTEVENT_TYPE_RAWKEYDOWN = 6,
/**
* Notification that a key was pressed. This does not necessarily correspond
* to a character depending on the key and language. Use the
* PP_INPUTEVENT_TYPE_CHAR for character input.
*
* Register for this event using the PP_INPUTEVENT_CLASS_KEYBOARD class.
*/
PP_INPUTEVENT_TYPE_KEYDOWN = 7,
/**
* Notification that a key was released.
*
* Register for this event using the PP_INPUTEVENT_CLASS_KEYBOARD class.
*/
PP_INPUTEVENT_TYPE_KEYUP = 8,
/**
* Notification that a character was typed. Use this for text input. Key
* down events may generate 0, 1, or more than one character event depending
* on the key, locale, and operating system.
*
* Register for this event using the PP_INPUTEVENT_CLASS_KEYBOARD class.
*/
PP_INPUTEVENT_TYPE_CHAR = 9,
/**
* Notification that a context menu should be shown.
*
* This message will be sent when the user right-clicks or performs another
* OS-specific mouse command that should open a context menu. When this event
* is delivered depends on the system, on some systems (Mac) it will
* delivered after the mouse down event, and on others (Windows) it will be
* delivered after the mouse up event.
*
* You will always get the normal mouse events. For example, you may see
* MOUSEDOWN,CONTEXTMENU,MOUSEUP or MOUSEDOWN,MOUSEUP,CONTEXTMENU.
*
* The return value from the event handler determines if the context menu
* event will be passed to the page when you are using filtered input events
* (via RequestFilteringInputEvents()). In non-filtering mode the event will
* never be propagated and no context menu will be displayed. If you are
* handling mouse events in filtering mode, you may want to return true from
* this event even if you do not support a context menu to suppress the
* default one.
*
* Register for this event using the PP_INPUTEVENT_CLASS_MOUSE class.
*/
PP_INPUTEVENT_TYPE_CONTEXTMENU = 10,
/**
* Notification that an input method composition process has just started.
*
* Register for this event using the PP_INPUTEVENT_CLASS_IME class.
*/
PP_INPUTEVENT_TYPE_IME_COMPOSITION_START = 11,
/**
* Notification that the input method composition string is updated.
*
* Register for this event using the PP_INPUTEVENT_CLASS_IME class.
*/
PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE = 12,
/**
* Notification that an input method composition process has completed.
*
* Register for this event using the PP_INPUTEVENT_CLASS_IME class.
*/
PP_INPUTEVENT_TYPE_IME_COMPOSITION_END = 13,
/**
* Notification that an input method committed a string.
*
* Register for this event using the PP_INPUTEVENT_CLASS_IME class.
*/
PP_INPUTEVENT_TYPE_IME_TEXT = 14,
/**
* Notification that a finger was placed on a touch-enabled device.
*
* Register for this event using the PP_INPUTEVENT_CLASS_TOUCH class.
*/
PP_INPUTEVENT_TYPE_TOUCHSTART = 15,
/**
* Notification that a finger was moved on a touch-enabled device.
*
* Register for this event using the PP_INPUTEVENT_CLASS_TOUCH class.
*/
PP_INPUTEVENT_TYPE_TOUCHMOVE = 16,
/**
* Notification that a finger was released on a touch-enabled device.
*
* Register for this event using the PP_INPUTEVENT_CLASS_TOUCH class.
*/
PP_INPUTEVENT_TYPE_TOUCHEND = 17,
/**
* Notification that a touch event was canceled.
*
* Register for this event using the PP_INPUTEVENT_CLASS_TOUCH class.
*/
PP_INPUTEVENT_TYPE_TOUCHCANCEL = 18,
PP_INPUTEVENT_TYPE_LAST = PP_INPUTEVENT_TYPE_TOUCHCANCEL
};
/**
* This enumeration contains event modifier constants. Each modifier is one
* bit. Retrieve the modifiers from an input event using the GetEventModifiers
* function on PPB_InputEvent.
*/
[assert_size(4)]
enum PP_InputEvent_Modifier {
PP_INPUTEVENT_MODIFIER_SHIFTKEY = 1 << 0,
PP_INPUTEVENT_MODIFIER_CONTROLKEY = 1 << 1,
PP_INPUTEVENT_MODIFIER_ALTKEY = 1 << 2,
PP_INPUTEVENT_MODIFIER_METAKEY = 1 << 3,
PP_INPUTEVENT_MODIFIER_ISKEYPAD = 1 << 4,
PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT = 1 << 5,
PP_INPUTEVENT_MODIFIER_LEFTBUTTONDOWN = 1 << 6,
PP_INPUTEVENT_MODIFIER_MIDDLEBUTTONDOWN = 1 << 7,
PP_INPUTEVENT_MODIFIER_RIGHTBUTTONDOWN = 1 << 8,
PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY = 1 << 9,
PP_INPUTEVENT_MODIFIER_NUMLOCKKEY = 1 << 10,
PP_INPUTEVENT_MODIFIER_ISLEFT = 1 << 11,
PP_INPUTEVENT_MODIFIER_ISRIGHT = 1 << 12,
[version=1.3]
PP_INPUTEVENT_MODIFIER_ISPEN = 1 << 13,
[version=1.3]
PP_INPUTEVENT_MODIFIER_ISERASER = 1 << 14
};
/**
* This enumeration contains constants representing each mouse button. To get
* the mouse button for a mouse down or up event, use GetMouseButton on
* PPB_InputEvent.
*/
[assert_size(4)]
enum PP_InputEvent_MouseButton {
PP_INPUTEVENT_MOUSEBUTTON_NONE = -1,
PP_INPUTEVENT_MOUSEBUTTON_FIRST = PP_INPUTEVENT_MOUSEBUTTON_NONE,
PP_INPUTEVENT_MOUSEBUTTON_LEFT = 0,
PP_INPUTEVENT_MOUSEBUTTON_MIDDLE = 1,
PP_INPUTEVENT_MOUSEBUTTON_RIGHT = 2,
PP_INPUTEVENT_MOUSEBUTTON_LAST = PP_INPUTEVENT_MOUSEBUTTON_RIGHT
};
[assert_size(4)]
enum PP_InputEvent_Class {
/**
* Request mouse input events.
*
* Normally you will request mouse events by calling RequestInputEvents().
* The only use case for filtered events (via RequestFilteringInputEvents())
* is for instances that have irregular outlines and you want to perform hit
* testing, which is very uncommon. Requesting non-filtered mouse events will
* lead to higher performance.
*/
PP_INPUTEVENT_CLASS_MOUSE = 1 << 0,
/**
* Requests keyboard events. Often you will want to request filtered mode
* (via RequestFilteringInputEvents) for keyboard events so you can pass on
* events (by returning false) that you don't handle. For example, if you
* don't request filtered mode and the user pressed "Page Down" when your
* instance has focus, the page won't scroll which will be a poor experience.
*
* A small number of tab and window management commands like Alt-F4 are never
* sent to the page. You can not request these keyboard commands since it
* would allow pages to trap users on a page.
*/
PP_INPUTEVENT_CLASS_KEYBOARD = 1 << 1,
/**
* Identifies scroll wheel input event. Wheel events must be requested in
* filtering mode via RequestFilteringInputEvents(). This is because many
* wheel commands should be forwarded to the page.
*
* Most instances will not need this event. Consuming wheel events by
* returning true from your filtered event handler will prevent the user from
* scrolling the page when the mouse is over the instance which can be very
* annoying.
*
* If you handle wheel events (for example, you have a document viewer which
* the user can scroll), the recommended behavior is to return false only if
* the wheel event actually causes your document to scroll. When the user
* reaches the end of the document, return false to indicating that the event
* was not handled. This will then forward the event to the containing page
* for scrolling, producing the nested scrolling behavior users expect from
* frames in a page.
*/
PP_INPUTEVENT_CLASS_WHEEL = 1 << 2,
/**
* Identifies touch input events.
*
* Request touch events only if you intend to handle them. If the browser
* knows you do not need to handle touch events, it can handle them at a
* higher level and achieve higher performance. If the plugin does not
* register for touch-events, then it will receive synthetic mouse events that
* are generated from the touch events (e.g. mouse-down for touch-start,
* mouse-move for touch-move (with left-button down), and mouse-up for
* touch-end. If the plugin does register for touch events, then the synthetic
* mouse events are not created.
*/
PP_INPUTEVENT_CLASS_TOUCH = 1 << 3,
/**
* Identifies IME composition input events.
*
* Request this input event class if you allow on-the-spot IME input.
*/
PP_INPUTEVENT_CLASS_IME = 1 << 4,
/**
* Identifies coalesced touch input events.
*
* Touch events are coalesced for each frame. By default, the coalesced touch
* events will be dropped. Request this input event class if you intend to
* handle all the touch events.
*/
PP_INPUTEVENT_CLASS_COALESCED_TOUCH = 1 << 5
};
/**
* The <code>PPB_InputEvent</code> interface contains pointers to several
* functions related to generic input events on the browser.
*/
[version=1.0, macro="PPB_INPUT_EVENT_INTERFACE"]
interface PPB_InputEvent {
/**
* RequestInputEvent() requests that input events corresponding to the given
* input events are delivered to the instance.
*
* It's recommended that you use RequestFilteringInputEvents() for keyboard
* events instead of this function so that you don't interfere with normal
* browser accelerators.
*
* By default, no input events are delivered. Call this function with the
* classes of events you are interested in to have them be delivered to
* the instance. Calling this function will override any previous setting for
* each specified class of input events (for example, if you previously
* called RequestFilteringInputEvents(), this function will set those events
* to non-filtering mode).
*
* Input events may have high overhead, so you should only request input
* events that your plugin will actually handle. For example, the browser may
* do optimizations for scroll or touch events that can be processed
* substantially faster if it knows there are no non-default receivers for
* that message. Requesting that such messages be delivered, even if they are
* processed very quickly, may have a noticeable effect on the performance of
* the page.
*
* Note that synthetic mouse events will be generated from touch events if
* (and only if) you do not request touch events.
*
* When requesting input events through this function, the events will be
* delivered and <i>not</i> bubbled to the default handlers.
*
* <strong>Example:</strong>
* @code
* RequestInputEvents(instance, PP_INPUTEVENT_CLASS_MOUSE);
* RequestFilteringInputEvents(instance,
* PP_INPUTEVENT_CLASS_WHEEL | PP_INPUTEVENT_CLASS_KEYBOARD);
* @endcode
*
* @param instance The <code>PP_Instance</code> of the instance requesting
* the given events.
*
* @param event_classes A combination of flags from
* <code>PP_InputEvent_Class</code> that identifies the classes of events the
* instance is requesting. The flags are combined by logically ORing their
* values.
*
* @return <code>PP_OK</code> if the operation succeeded,
* <code>PP_ERROR_BADARGUMENT</code> if instance is invalid, or
* <code>PP_ERROR_NOTSUPPORTED</code> if one of the event class bits were
* illegal. In the case of an invalid bit, all valid bits will be applied
* and only the illegal bits will be ignored. The most common cause of a
* <code>PP_ERROR_NOTSUPPORTED</code> return value is requesting keyboard
* events, these must use RequestFilteringInputEvents().
*/
int32_t RequestInputEvents([in] PP_Instance instance,
[in] uint32_t event_classes);
/**
* RequestFilteringInputEvents() requests that input events corresponding to
* the given input events are delivered to the instance for filtering.
*
* By default, no input events are delivered. In most cases you would
* register to receive events by calling RequestInputEvents(). In some cases,
* however, you may wish to filter events such that they can be bubbled up
* to the default handlers. In this case, register for those classes of
* events using this function instead of RequestInputEvents().
*
* Filtering input events requires significantly more overhead than just
* delivering them to the instance. As such, you should only request
* filtering in those cases where it's absolutely necessary. The reason is
* that it requires the browser to stop and block for the instance to handle
* the input event, rather than sending the input event asynchronously. This
* can have significant overhead.
*
* <strong>Example:</strong>
* @code
* RequestInputEvents(instance, PP_INPUTEVENT_CLASS_MOUSE);
* RequestFilteringInputEvents(instance,
* PP_INPUTEVENT_CLASS_WHEEL | PP_INPUTEVENT_CLASS_KEYBOARD);
* @endcode
*
* @return <code>PP_OK</code> if the operation succeeded,
* <code>PP_ERROR_BADARGUMENT</code> if instance is invalid, or
* <code>PP_ERROR_NOTSUPPORTED</code> if one of the event class bits were
* illegal. In the case of an invalid bit, all valid bits will be applied
* and only the illegal bits will be ignored.
*/
int32_t RequestFilteringInputEvents([in] PP_Instance instance,
[in] uint32_t event_classes);
/**
* ClearInputEventRequest() requests that input events corresponding to the
* given input classes no longer be delivered to the instance.
*
* By default, no input events are delivered. If you have previously
* requested input events via RequestInputEvents() or
* RequestFilteringInputEvents(), this function will unregister handling
* for the given instance. This will allow greater browser performance for
* those events.
*
* Note that you may still get some input events after clearing the flag if
* they were dispatched before the request was cleared. For example, if
* there are 3 mouse move events waiting to be delivered, and you clear the
* mouse event class during the processing of the first one, you'll still
* receive the next two. You just won't get more events generated.
*
* @param instance The <code>PP_Instance</code> of the instance requesting
* to no longer receive the given events.
*
* @param event_classes A combination of flags from
* <code>PP_InputEvent_Class</code> that identify the classes of events the
* instance is no longer interested in.
*/
void ClearInputEventRequest([in] PP_Instance instance,
[in] uint32_t event_classes);
/**
* IsInputEvent() returns true if the given resource is a valid input event
* resource.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to a generic
* resource.
*
* @return <code>PP_TRUE</code> if the given resource is a valid input event
* resource.
*/
PP_Bool IsInputEvent([in] PP_Resource resource);
/**
* GetType() returns the type of input event for the given input event
* resource.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to an input
* event.
*
* @return A <code>PP_InputEvent_Type</code> if its a valid input event or
* <code>PP_INPUTEVENT_TYPE_UNDEFINED</code> if the resource is invalid.
*/
PP_InputEvent_Type GetType([in] PP_Resource event);
/**
* GetTimeStamp() Returns the time that the event was generated. This will be
* before the current time since processing and dispatching the event has
* some overhead. Use this value to compare the times the user generated two
* events without being sensitive to variable processing time.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to the event.
*
* @return The return value is in time ticks, which is a monotonically
* increasing clock not related to the wall clock time. It will not change
* if the user changes their clock or daylight savings time starts, so can
* be reliably used to compare events. This means, however, that you can't
* correlate event times to a particular time of day on the system clock.
*/
PP_TimeTicks GetTimeStamp([in] PP_Resource event);
/**
* GetModifiers() returns a bitfield indicating which modifiers were down
* at the time of the event. This is a combination of the flags in the
* <code>PP_InputEvent_Modifier</code> enum.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to an input
* event.
*
* @return The modifiers associated with the event, or 0 if the given
* resource is not a valid event resource.
*/
uint32_t GetModifiers([in] PP_Resource event);
};
/**
* The <code>PPB_MouseInputEvent</code> interface contains pointers to several
* functions related to mouse input events.
*/
[macro="PPB_MOUSE_INPUT_EVENT_INTERFACE"]
interface PPB_MouseInputEvent {
/**
* Create() creates a mouse input event with the given parameters. Normally
* you will get a mouse event passed through the
* <code>HandleInputEvent</code> and will not need to create them, but some
* applications may want to create their own for internal use. The type must
* be one of the mouse event types.
*
* @param[in] instance The instance for which this event occurred.
*
* @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
* input event.
*
* @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
* when the event occurred.
*
* @param[in] modifiers A bit field combination of the
* <code>PP_InputEvent_Modifier</code> flags.
*
* @param[in] mouse_button The button that changed for mouse down or up
* events. This value will be <code>PP_EVENT_MOUSEBUTTON_NONE</code> for
* mouse move, enter, and leave events.
*
* @param[in] mouse_position A <code>Point</code> containing the x and y
* position of the mouse when the event occurred.
*
* @return A <code>PP_Resource</code> containing the new mouse input event.
*/
PP_Resource Create([in] PP_Instance instance,
[in] PP_InputEvent_Type type,
[in] PP_TimeTicks time_stamp,
[in] uint32_t modifiers,
[in] PP_InputEvent_MouseButton mouse_button,
[in] PP_Point mouse_position,
[in] int32_t click_count);
/**
* Create() creates a mouse input event with the given parameters. Normally
* you will get a mouse event passed through the
* <code>HandleInputEvent</code> and will not need to create them, but some
* applications may want to create their own for internal use. The type must
* be one of the mouse event types.
*
* @param[in] instance The instance for which this event occurred.
*
* @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
* input event.
*
* @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
* when the event occurred.
*
* @param[in] modifiers A bit field combination of the
* <code>PP_InputEvent_Modifier</code> flags.
*
* @param[in] mouse_button The button that changed for mouse down or up
* events. This value will be <code>PP_EVENT_MOUSEBUTTON_NONE</code> for
* mouse move, enter, and leave events.
*
* @param[in] mouse_position A <code>Point</code> containing the x and y
* position of the mouse when the event occurred.
*
* @param[in] mouse_movement The change in position of the mouse.
*
* @return A <code>PP_Resource</code> containing the new mouse input event.
*/
[version=1.1]
PP_Resource Create([in] PP_Instance instance,
[in] PP_InputEvent_Type type,
[in] PP_TimeTicks time_stamp,
[in] uint32_t modifiers,
[in] PP_InputEvent_MouseButton mouse_button,
[in] PP_Point mouse_position,
[in] int32_t click_count,
[in] PP_Point mouse_movement);
/**
* IsMouseInputEvent() determines if a resource is a mouse event.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to an event.
*
* @return <code>PP_TRUE</code> if the given resource is a valid mouse input
* event, otherwise <code>PP_FALSE</code>.
*/
PP_Bool IsMouseInputEvent([in] PP_Resource resource);
/**
* GetButton() returns the mouse button that generated a mouse down or up
* event.
*
* @param[in] mouse_event A <code>PP_Resource</code> corresponding to a
* mouse event.
*
* @return The mouse button associated with mouse down and up events. This
* value will be <code>PP_EVENT_MOUSEBUTTON_NONE</code> for mouse move,
* enter, and leave events, and for all non-mouse events.
*/
PP_InputEvent_MouseButton GetButton([in] PP_Resource mouse_event);
/**
* GetPosition() returns the pixel location of a mouse input event. When
* the mouse is locked, it returns the last known mouse position just as
* mouse lock was entered.
*
* @param[in] mouse_event A <code>PP_Resource</code> corresponding to a
* mouse event.
*
* @return The point associated with the mouse event, relative to the upper-
* left of the instance receiving the event. These values can be negative for
* mouse drags. The return value will be (0, 0) for non-mouse events.
*/
[returnByValue] PP_Point GetPosition([in] PP_Resource mouse_event);
int32_t GetClickCount([in] PP_Resource mouse_event);
/**
* Returns the change in position of the mouse. When the mouse is locked,
* although the mouse position doesn't actually change, this function
* still provides movement information, which indicates what the change in
* position would be had the mouse not been locked.
*
* @param[in] mouse_event A <code>PP_Resource</code> corresponding to a
* mouse event.
*
* @return The change in position of the mouse, relative to the previous
* position.
*/
[version=1.1]
PP_Point GetMovement([in] PP_Resource mouse_event);
};
/**
* The <code>PPB_WheelIputEvent</code> interface contains pointers to several
* functions related to wheel input events.
*/
[version=1.0, macro="PPB_WHEEL_INPUT_EVENT_INTERFACE"]
interface PPB_WheelInputEvent {
/**
* Create() creates a wheel input event with the given parameters. Normally
* you will get a wheel event passed through the
* <code>HandleInputEvent</code> and will not need to create them, but some
* applications may want to create their own for internal use.
*
* @param[in] instance The instance for which this event occurred.
*
* @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
* when the event occurred.
*
* @param[in] modifiers A bit field combination of the
* <code>PP_InputEvent_Modifier</code> flags.
*
* @param[in] wheel_delta The scroll wheel's horizontal and vertical scroll
* amounts.
*
* @param[in] wheel_ticks The number of "clicks" of the scroll wheel that
* have produced the event.
*
* @param[in] scroll_by_page When true, the user is requesting to scroll
* by pages. When false, the user is requesting to scroll by lines.
*
* @return A <code>PP_Resource</code> containing the new wheel input event.
*/
PP_Resource Create([in] PP_Instance instance,
[in] PP_TimeTicks time_stamp,
[in] uint32_t modifiers,
[in] PP_FloatPoint wheel_delta,
[in] PP_FloatPoint wheel_ticks,
[in] PP_Bool scroll_by_page);
/**
* IsWheelInputEvent() determines if a resource is a wheel event.
*
* @param[in] wheel_event A <code>PP_Resource</code> corresponding to an
* event.
*
* @return <code>PP_TRUE</code> if the given resource is a valid wheel input
* event.
*/
PP_Bool IsWheelInputEvent([in] PP_Resource resource);
/**
* GetDelta() returns the amount vertically and horizontally the user has
* requested to scroll by with their mouse wheel. A scroll down or to the
* right (where the content moves up or left) is represented as positive
* values, and a scroll up or to the left (where the content moves down or
* right) is represented as negative values.
*
* This amount is system dependent and will take into account the user's
* preferred scroll sensitivity and potentially also nonlinear acceleration
* based on the speed of the scrolling.
*
* Devices will be of varying resolution. Some mice with large detents will
* only generate integer scroll amounts. But fractional values are also
* possible, for example, on some trackpads and newer mice that don't have
* "clicks".
*
* @param[in] wheel_event A <code>PP_Resource</code> corresponding to a wheel
* event.
*
* @return The vertical and horizontal scroll values. The units are either in
* pixels (when scroll_by_page is false) or pages (when scroll_by_page is
* true). For example, y = -3 means scroll up 3 pixels when scroll_by_page
* is false, and scroll up 3 pages when scroll_by_page is true.
*/
PP_FloatPoint GetDelta([in] PP_Resource wheel_event);
/**
* GetTicks() returns the number of "clicks" of the scroll wheel
* that have produced the event. The value may have system-specific
* acceleration applied to it, depending on the device. The positive and
* negative meanings are the same as for GetDelta().
*
* If you are scrolling, you probably want to use the delta values. These
* tick events can be useful if you aren't doing actual scrolling and don't
* want or pixel values. An example may be cycling between different items in
* a game.
*
* @param[in] wheel_event A <code>PP_Resource</code> corresponding to a wheel
* event.
*
* @return The number of "clicks" of the scroll wheel. You may receive
* fractional values for the wheel ticks if the mouse wheel is high
* resolution or doesn't have "clicks". If your program wants discrete
* events (as in the "picking items" example) you should accumulate
* fractional click values from multiple messages until the total value
* reaches positive or negative one. This should represent a similar amount
* of scrolling as for a mouse that has a discrete mouse wheel.
*/
PP_FloatPoint GetTicks([in] PP_Resource wheel_event);
/**
* GetScrollByPage() indicates if the scroll delta x/y indicates pages or
* lines to scroll by.
*
* @param[in] wheel_event A <code>PP_Resource</code> corresponding to a wheel
* event.
*
* @return <code>PP_TRUE</code> if the event is a wheel event and the user is
* scrolling by pages. <code>PP_FALSE</code> if not or if the resource is not
* a wheel event.
*/
PP_Bool GetScrollByPage([in] PP_Resource wheel_event);
};
/**
* The <code>PPB_KeyboardInputEvent</code> interface contains pointers to
* several functions related to keyboard input events.
*/
[version=1.0, macro="PPB_KEYBOARD_INPUT_EVENT_INTERFACE"]
interface PPB_KeyboardInputEvent {
/**
* Creates a keyboard input event with the given parameters. Normally you
* will get a keyboard event passed through the HandleInputEvent and will not
* need to create them, but some applications may want to create their own
* for internal use. The type must be one of the keyboard event types.
*
* @param[in] instance The instance for which this event occurred.
*
* @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
* input event.
*
* @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
* when the event occurred.
*
* @param[in] modifiers A bit field combination of the
* <code>PP_InputEvent_Modifier</code> flags.
*
* @param[in] key_code This value reflects the DOM KeyboardEvent
* <code>keyCode</code> field, which is the Windows-style Virtual Key
* code of the key.
*
* @param[in] character_text This value represents the typed character as a
* UTF-8 string.
*
* @return A <code>PP_Resource</code> containing the new keyboard input
* event.
*/
[deprecate=1.2]
PP_Resource Create([in] PP_Instance instance,
[in] PP_InputEvent_Type type,
[in] PP_TimeTicks time_stamp,
[in] uint32_t modifiers,
[in] uint32_t key_code,
[in] PP_Var character_text);
/**
* Creates a keyboard input event with the given parameters. Normally you
* will get a keyboard event passed through the HandleInputEvent and will not
* need to create them, but some applications may want to create their own
* for internal use. The type must be one of the keyboard event types.
*
* @param[in] instance The instance for which this event occurred.
*
* @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
* input event.
*
* @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
* when the event occurred.
*
* @param[in] modifiers A bit field combination of the
* <code>PP_InputEvent_Modifier</code> flags.
*
* @param[in] key_code This value reflects the DOM KeyboardEvent
* <code>keyCode</code> field, which is the Windows-style Virtual Key
* code of the key.
*
* @param[in] character_text This value represents the typed character as a
* UTF-8 string.
*
* @param[in] code This value represents the DOM3 |code| string that
* corresponds to the physical key being pressed.
*
* @return A <code>PP_Resource</code> containing the new keyboard input
* event.
*/
[version=1.2]
PP_Resource Create([in] PP_Instance instance,
[in] PP_InputEvent_Type type,
[in] PP_TimeTicks time_stamp,
[in] uint32_t modifiers,
[in] uint32_t key_code,
[in] PP_Var character_text,
[in] PP_Var code);
/**
* IsKeyboardInputEvent() determines if a resource is a keyboard event.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to an event.
*
* @return <code>PP_TRUE</code> if the given resource is a valid input event.
*/
PP_Bool IsKeyboardInputEvent([in] PP_Resource resource);
/**
* GetKeyCode() returns the DOM keyCode field for the keyboard event.
* Chrome populates this with the Windows-style Virtual Key code of the key.
*
* @param[in] key_event A <code>PP_Resource</code> corresponding to a
* keyboard event.
*
* @return The DOM keyCode field for the keyboard event.
*/
uint32_t GetKeyCode([in] PP_Resource key_event);
/**
* GetCharacterText() returns the typed character as a UTF-8 string for the
* given character event.
*
* @param[in] character_event A <code>PP_Resource</code> corresponding to a
* keyboard event.
*
* @return A string var representing a single typed character for character
* input events. For non-character input events the return value will be an
* undefined var.
*/
PP_Var GetCharacterText([in] PP_Resource character_event);
/**
* GetCode() returns the DOM |code| field for this keyboard event, as
* defined in the DOM3 Events spec:
* http://www.w3.org/TR/DOM-Level-3-Events/
*
* @param[in] key_event The key event for which to return the key code.
*
* @return The string that contains the DOM |code| for the keyboard event.
*/
[version=1.2]
PP_Var GetCode([in] PP_Resource key_event);
};
[assert_size(4)]
enum PP_TouchListType {
/**
* The list of all TouchPoints which are currently down.
*/
PP_TOUCHLIST_TYPE_TOUCHES = 0,
/**
* The list of all TouchPoints whose state has changed since the last
* TouchInputEvent.
*/
PP_TOUCHLIST_TYPE_CHANGEDTOUCHES = 1,
/**
* The list of all TouchPoints which are targeting this plugin. This is a
* subset of Touches.
*/
PP_TOUCHLIST_TYPE_TARGETTOUCHES = 2
};
/**
* The <code>PPB_TouchInputEvent</code> interface contains pointers to several
* functions related to touch events.
*/
[version=1.0, macro="PPB_TOUCH_INPUT_EVENT_INTERFACE"]
interface PPB_TouchInputEvent {
/**
* Creates a touch input event with the given parameters. Normally you
* will get a touch event passed through the HandleInputEvent and will not
* need to create them, but some applications may want to create their own
* for internal use. The type must be one of the touch event types.
* This newly created touch input event does not have any touch point in any
* of the touch-point lists. <code>AddTouchPoint</code> should be called to
* add the touch-points.
*
* @param[in] instance The instance for which this event occurred.
*
* @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
* input event.
*
* @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
* when the event occurred.
*
* @param[in] modifiers A bit field combination of the
* <code>PP_InputEvent_Modifier</code> flags.
*
* @return A <code>PP_Resource</code> containing the new touch input event.
*/
PP_Resource Create([in] PP_Instance instance,
[in] PP_InputEvent_Type type,
[in] PP_TimeTicks time_stamp,
[in] uint32_t modifiers);
/**
* Adds a touch point to the touch event in the specified touch-list.
*
* @param[in] touch_event A <code>PP_Resource</code> corresponding to a touch
* event.
*
* @param[in] list The list to add the touch point to.
*
* @param[in] point The point to add to the list.
*/
void AddTouchPoint([in] PP_Resource touch_event,
[in] PP_TouchListType list,
[in] PP_TouchPoint point);
/**
* IsTouchInputEvent() determines if a resource is a touch event.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to an event.
*
* @return <code>PP_TRUE</code> if the given resource is a valid touch input
* event, otherwise <code>PP_FALSE</code>.
*/
PP_Bool IsTouchInputEvent([in] PP_Resource resource);
/**
* Returns the number of touch-points in the specified list.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to a touch
* event.
*
* @param[in] list The list.
*
* @return The number of touch-points in the specified list.
*/
uint32_t GetTouchCount([in] PP_Resource resource,
[in] PP_TouchListType list);
/**
* Returns the touch-point at the specified index from the specified list.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to a touch
* event.
*
* @param[in] list The list.
*
* @param[in] index The index.
*
* @return A <code>PP_TouchPoint</code> representing the touch-point.
*/
PP_TouchPoint GetTouchByIndex([in] PP_Resource resource,
[in] PP_TouchListType list,
[in] uint32_t index);
/**
* Returns the touch-point with the specified touch-id in the specified list.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to a touch
* event.
*
* @param[in] list The list.
*
* @param[in] touch_id The id of the touch-point.
*
* @return A <code>PP_TouchPoint</code> representing the touch-point.
*/
PP_TouchPoint GetTouchById([in] PP_Resource resource,
[in] PP_TouchListType list,
[in] uint32_t touch_id);
/**
* Returns the touch-tilt with the specified index in the specified list.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to a touch
* event.
*
* @param[in] list The list.
*
* @param[in] index The index.
*
* @return A <code>PP_FloatPoint</code> representing the tilt of the
* touch-point.
*/
[version=1.4]
PP_FloatPoint GetTouchTiltByIndex([in] PP_Resource resource,
[in] PP_TouchListType list,
[in] uint32_t index);
/**
* Returns the touch-tilt with the specified touch-id in the specified list.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to a touch
* event.
*
* @param[in] list The list.
*
* @param[in] touch_id The id of the touch-point.
*
* @return A <code>PP_FloatPoint</code> representing the tilt of the
* touch-point.
*/
[version=1.4]
PP_FloatPoint GetTouchTiltById([in] PP_Resource resource,
[in] PP_TouchListType list,
[in] uint32_t touch_id);
};
[macro="PPB_IME_INPUT_EVENT_INTERFACE"]
interface PPB_IMEInputEvent {
/**
* Create() creates an IME input event with the given parameters. Normally
* you will get an IME event passed through the <code>HandleInputEvent</code>
* and will not need to create them, but some applications may want to create
* their own for internal use.
*
* @param[in] instance The instance for which this event occurred.
*
* @param[in] type A <code>PP_InputEvent_Type</code> identifying the type of
* input event. The type must be one of the IME event types.
*
* @param[in] time_stamp A <code>PP_TimeTicks</code> indicating the time
* when the event occurred.
*
* @param[in] text The string returned by <code>GetText</code>.
*
* @param[in] segment_number The number returned by
* <code>GetSegmentNumber</code>.
*
* @param[in] segment_offsets The array of numbers returned by
* <code>GetSegmentOffset</code>. If <code>segment_number</code> is zero,
* the number of elements of the array should be zero. If
* <code>segment_number</code> is non-zero, the length of the array must be
* <code>segment_number</code> + 1.
*
* @param[in] target_segment The number returned by
* <code>GetTargetSegment</code>.
*
* @param[in] selection_start The start index returned by
* <code>GetSelection</code>.
*
* @param[in] selection_end The end index returned by
* <code>GetSelection</code>.
*
* @return A <code>PP_Resource</code> containing the new IME input event.
*/
PP_Resource Create([in] PP_Instance instance,
[in] PP_InputEvent_Type type,
[in] PP_TimeTicks time_stamp,
[in] PP_Var text,
[in] uint32_t segment_number,
[in] uint32_t[] segment_offsets,
[in] int32_t target_segment,
[in] uint32_t selection_start,
[in] uint32_t selection_end);
/**
* IsIMEInputEvent() determines if a resource is an IME event.
*
* @param[in] resource A <code>PP_Resource</code> corresponding to an event.
*
* @return <code>PP_TRUE</code> if the given resource is a valid input event.
*/
PP_Bool IsIMEInputEvent([in] PP_Resource resource);
/**
* GetText() returns the composition text as a UTF-8 string for the given IME
* event.
*
* @param[in] ime_event A <code>PP_Resource</code> corresponding to an IME
* event.
*
* @return A string var representing the composition text. For non-IME input
* events the return value will be an undefined var.
*/
PP_Var GetText([in] PP_Resource ime_event);
/**
* GetSegmentNumber() returns the number of segments in the composition text.
*
* @param[in] ime_event A <code>PP_Resource</code> corresponding to an IME
* event.
*
* @return The number of segments. For events other than COMPOSITION_UPDATE,
* returns 0.
*/
uint32_t GetSegmentNumber([in] PP_Resource ime_event);
/**
* GetSegmentOffset() returns the position of the index-th segmentation point
* in the composition text. The position is given by a byte-offset (not a
* character-offset) of the string returned by GetText(). It always satisfies
* 0=GetSegmentOffset(0) < ... < GetSegmentOffset(i) < GetSegmentOffset(i+1)
* < ... < GetSegmentOffset(GetSegmentNumber())=(byte-length of GetText()).
* Note that [GetSegmentOffset(i), GetSegmentOffset(i+1)) represents the range
* of the i-th segment, and hence GetSegmentNumber() can be a valid argument
* to this function instead of an off-by-1 error.
*
* @param[in] ime_event A <code>PP_Resource</code> corresponding to an IME
* event.
*
* @param[in] index An integer indicating a segment.
*
* @return The byte-offset of the segmentation point. If the event is not
* COMPOSITION_UPDATE or index is out of range, returns 0.
*/
uint32_t GetSegmentOffset([in] PP_Resource ime_event,
[in] uint32_t index);
/**
* GetTargetSegment() returns the index of the current target segment of
* composition.
*
* @param[in] ime_event A <code>PP_Resource</code> corresponding to an IME
* event.
*
* @return An integer indicating the index of the target segment. When there
* is no active target segment, or the event is not COMPOSITION_UPDATE,
* returns -1.
*/
int32_t GetTargetSegment([in] PP_Resource ime_event);
/**
* GetSelection() returns the range selected by caret in the composition text.
*
* @param[in] ime_event A <code>PP_Resource</code> corresponding to an IME
* event.
*
* @param[out] start The start position of the current selection.
*
* @param[out] end The end position of the current selection.
*/
void GetSelection([in] PP_Resource ime_event,
[out] uint32_t start,
[out] uint32_t end);
};
Codebase Browser
chromium