Fixed spelling errors and changed all references to PP_Resource to be the

ppapi/c/ppb_input_event.h

 /* Copyright (c) 2011 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-/* From ppb_input_event.idl modified Wed Aug 17 11:16:34 2011. */
+/* From ppb_input_event.idl modified Wed Aug 24 09:43:38 2011. */
 
 #ifndef PPAPI_C_PPB_INPUT_EVENT_H_
 #define PPAPI_C_PPB_INPUT_EVENT_H_
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_macros.h"
 #include "ppapi/c/pp_point.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_stdint.h"
@@ skipping 312 matching lines @@
    *
    * @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)(PP_Instance instance, 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>.
+   * @param[in] resource A <code>PP_Resource</code> corresponding to a generic
+   * resource.
    *
-   * @return True if the given resource is a valid input event
+   * @return <code>PP_TRUE</code> if the given resource is a valid input event
    * resource.
    */
   PP_Bool (*IsInputEvent)(PP_Resource resource);
   /**
    * GetType() returns the type of input event for the given input event
    * resource.
    *
-   * @param[in] resource A <code>PP_Resource</code> containing the input event.
+   * @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)(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> containing the event.
+   * @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)(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> containing the input event.
+   * @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)(PP_Resource event);
 };
 
 /**
  * The <code>PPB_MouseInputEvent</code> interface contains pointers to several
  * functions related to mouse input events.
@@ skipping 29 matching lines @@
   PP_Resource (*Create)(PP_Instance instance,
                         PP_InputEvent_Type type,
                         PP_TimeTicks time_stamp,
                         uint32_t modifiers,
                         PP_InputEvent_MouseButton mouse_button,
                         const struct PP_Point* mouse_position,
                         int32_t click_count);
   /**
    * IsMouseInputEvent() determines if a resource is a mouse event.
    *
-   * @param[in] resource A <code>PP_Resource</code> containing the 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)(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> containing the mouse
-   * 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)(PP_Resource mouse_event);
   /**
    * GetPosition() returns the pixel location of a mouse input event.
    *
-   * @param[in] mouse_event A <code>PP_Resource</code> containing the mouse
-   * event.
+   * @param[in] mouse_event A <code>PP_Resource</code> corresponding to an
+   * 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.
    */
   struct PP_Point (*GetPosition)(PP_Resource mouse_event);
   /**
    * TODO(brettw) figure out exactly what this means.
    */
   int32_t (*GetClickCount)(PP_Resource mouse_event);
@@ skipping 31 matching lines @@
    */
   PP_Resource (*Create)(PP_Instance instance,
                         PP_TimeTicks time_stamp,
                         uint32_t modifiers,
                         const struct PP_FloatPoint* wheel_delta,
                         const struct PP_FloatPoint* wheel_ticks,
                         PP_Bool scroll_by_page);
   /**
    * IsWheelInputEvent() determines if a resource is a wheel event.
    *
-   * @param[in] wheel_event A <code>PP_Resource</code> containing the 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)(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> containing the wheel
+   * @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.
    */
   struct PP_FloatPoint (*GetDelta)(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> containing the wheel
+   * @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.
    */
   struct PP_FloatPoint (*GetTicks)(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> containing the wheel
+   * @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)(PP_Resource wheel_event);
 };
 
 /**
@@ skipping 30 matching lines @@
    */
   PP_Resource (*Create)(PP_Instance instance,
                         PP_InputEvent_Type type,
                         PP_TimeTicks time_stamp,
                         uint32_t modifiers,
                         uint32_t key_code,
                         struct PP_Var character_text);
   /**
    * IsKeyboardInputEvent() determines if a resource is a keyboard event.
    *
-   * @param[in] resource A <code>PP_Resource</code> containing the 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)(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> containing the keyboard
-   * event.
+   * @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)(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> containing the
+   * @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.
    */
   struct PP_Var (*GetCharacterText)(PP_Resource character_event);
 };
 /**
  * @}
  */
 
 #endif  /* PPAPI_C_PPB_INPUT_EVENT_H_ */