Initial implementation of Pointer Actions

This finishes off the work that was done for the Python key actions
and adds Pointer actions.

It also completes the work to get ActionChains to work with ActionBuilder
so that old test suites can start working straight away and give
people the opportunity to move over to the new API.

Author: AutomatedTester

py/selenium/webdriver/common/action_chains.py

@@ -83,7 +83,10 @@ def reset_actions(self):
         """
             Clears actions that are already stored on the remote end.
         """
-        self._driver.execute(Command.W3C_CLEAR_ACTIONS)
+        if self._driver.w3c:
+            self._driver.execute(Command.W3C_CLEAR_ACTIONS)
+        else:
+            self._actions = []
 
     def click(self, on_element=None):
         """
@@ -93,10 +96,15 @@ def click(self, on_element=None):
          - on_element: The element to click.
            If None, clicks on current mouse position.
         """
-        if on_element:
-            self.move_to_element(on_element)
-        self._actions.append(lambda: self._driver.execute(
-            Command.CLICK, {'button': 0}))
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.click(on_element)
+            self.w3c_actions.key_action.pause()
+            self.w3c_actions.key_action.pause()
+        else:
+            if on_element:
+                self.move_to_element(on_element)
+            self._actions.append(lambda: self._driver.execute(
+                                 Command.CLICK, {'button': 0}))
         return self
 
     def click_and_hold(self, on_element=None):
@@ -107,10 +115,16 @@ def click_and_hold(self, on_element=None):
          - on_element: The element to mouse down.
            If None, clicks on current mouse position.
         """
-        if on_element:
-            self.move_to_element(on_element)
-        self._actions.append(lambda: self._driver.execute(
-            Command.MOUSE_DOWN, {}))
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.click_and_hold(on_element)
+            self.w3c_actions.key_action.pause()
+            if on_element:
+                self.w3c_actions.key_action.pause()
+        else:
+            if on_element:
+                self.move_to_element(on_element)
+            self._actions.append(lambda: self._driver.execute(
+                                 Command.MOUSE_DOWN, {}))
         return self
 
     def context_click(self, on_element=None):
@@ -121,10 +135,14 @@ def context_click(self, on_element=None):
          - on_element: The element to context-click.
            If None, clicks on current mouse position.
         """
-        if on_element:
-            self.move_to_element(on_element)
-        self._actions.append(lambda: self._driver.execute(
-            Command.CLICK, {'button': 2}))
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.context_click(on_element)
+            self.w3c_actions.key_action.pause()
+        else:
+            if on_element:
+                self.move_to_element(on_element)
+            self._actions.append(lambda: self._driver.execute(
+                                 Command.CLICK, {'button': 2}))
         return self
 
     def double_click(self, on_element=None):
@@ -135,10 +153,15 @@ def double_click(self, on_element=None):
          - on_element: The element to double-click.
            If None, clicks on current mouse position.
         """
-        if on_element:
-            self.move_to_element(on_element)
-        self._actions.append(lambda: self._driver.execute(
-            Command.DOUBLE_CLICK, {}))
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.double_click(on_element)
+            for _ in range(4):
+                self.w3c_actions.key_action.pause()
+        else:
+            if on_element:
+                self.move_to_element(on_element)
+                self._actions.append(lambda: self._driver.execute(
+                                     Command.DOUBLE_CLICK, {}))
         return self
 
     def drag_and_drop(self, source, target):
@@ -150,8 +173,15 @@ def drag_and_drop(self, source, target):
          - source: The element to mouse down.
          - target: The element to mouse up.
         """
-        self.click_and_hold(source)
-        self.release(target)
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.click_and_hold(source) \
+                                           .move_to(target) \
+                                           .release()
+            for _ in range(3):
+                self.w3c_actions.key_action.pause()
+        else:
+            self.click_and_hold(source)
+            self.release(target)
         return self
 
     def drag_and_drop_by_offset(self, source, xoffset, yoffset):
@@ -164,9 +194,16 @@ def drag_and_drop_by_offset(self, source, xoffset, yoffset):
          - xoffset: X offset to move to.
          - yoffset: Y offset to move to.
         """
-        self.click_and_hold(source)
-        self.move_by_offset(xoffset, yoffset)
-        self.release()
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.click_and_hold(source) \
+                                           .move_to_location(xoffset, yoffset) \
+                                           .release()
+            for _ in range(3):
+                self.w3c_actions.key_action.pause()
+        else:
+            self.click_and_hold(source)
+            self.move_by_offset(xoffset, yoffset)
+            self.release()
         return self
 
     def key_down(self, value, element=None):
@@ -188,6 +225,7 @@ def key_down(self, value, element=None):
             self.click(element)
         if self._driver.w3c:
             self.w3c_actions.key_action.key_down(value)
+            self.w3c_actions.pointer_action.pause()
         else:
             self._actions.append(lambda: self._driver.execute(
                 Command.SEND_KEYS_TO_ACTIVE_ELEMENT,
@@ -212,6 +250,7 @@ def key_up(self, value, element=None):
             self.click(element)
         if self._driver.w3c:
             self.w3c_actions.key_action.key_up(value)
+            self.w3c_actions.pointer_action.pause()
         else:
             self._actions.append(lambda: self._driver.execute(
                 Command.SEND_KEYS_TO_ACTIVE_ELEMENT,
@@ -239,8 +278,12 @@ def move_to_element(self, to_element):
         :Args:
          - to_element: The WebElement to move to.
         """
-        self._actions.append(lambda: self._driver.execute(
-            Command.MOVE_TO, {'element': to_element.id}))
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.move_to(to_element)
+            self.w3c_actions.key_action.pause()
+        else:
+            self._actions.append(lambda: self._driver.execute(
+                                 Command.MOVE_TO, {'element': to_element.id}))
         return self
 
     def move_to_element_with_offset(self, to_element, xoffset, yoffset):
@@ -253,11 +296,15 @@ def move_to_element_with_offset(self, to_element, xoffset, yoffset):
          - xoffset: X offset to move to.
          - yoffset: Y offset to move to.
         """
-        self._actions.append(
-            lambda: self._driver.execute(Command.MOVE_TO, {
-                'element': to_element.id,
-                'xoffset': int(xoffset),
-                'yoffset': int(yoffset)}))
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.move_to(to_element, xoffset, yoffset)
+            self.w3c_actions.key_action.pause()
+        else:
+            self._actions.append(
+                lambda: self._driver.execute(Command.MOVE_TO, {
+                    'element': to_element.id,
+                    'xoffset': int(xoffset),
+                    'yoffset': int(yoffset)}))
         return self
 
     def release(self, on_element=None):
@@ -268,9 +315,13 @@ def release(self, on_element=None):
          - on_element: The element to mouse up.
            If None, releases on current mouse position.
         """
-        if on_element:
-            self.move_to_element(on_element)
-        self._actions.append(lambda: self._driver.execute(Command.MOUSE_UP, {}))
+        if self._driver.w3c:
+            self.w3c_actions.pointer_action.release()
+            self.w3c_actions.key_action.pause()
+        else:
+            if on_element:
+                self.move_to_element(on_element)
+            self._actions.append(lambda: self._driver.execute(Command.MOUSE_UP, {}))
         return self
 
     def send_keys(self, *keys_to_send):

py/selenium/webdriver/common/actions/action_builder.py

@@ -26,10 +26,10 @@
 class ActionBuilder(object):
     def __init__(self, driver, mouse=None, keyboard=None):
         if mouse is None:
-            mouse = PointerInput("mouse", "mouse")
+            mouse = PointerInput(interaction.POINTER, "mouse")
         if keyboard is None:
-            keyboard = KeyInput("keyboard")
-        self.devices = [keyboard]
+            keyboard = KeyInput(interaction.KEY)
+        self.devices = [mouse, keyboard]
         self._key_action = KeyActions(keyboard)
         self._pointer_action = PointerActions(mouse)
         self.driver = driver
@@ -70,7 +70,9 @@ def add_pointer_input(self, type_, name):
     def perform(self):
         enc = {"actions": []}
         for device in self.devices:
-            enc["actions"].append(device.encode())
+            encoded = device.encode()
+            if encoded['actions']:
+                enc["actions"].append(encoded)
         self.driver.execute(Command.W3C_ACTIONS, enc)
 
     def clear_actions(self):

py/selenium/webdriver/common/actions/mouse_button.py

@@ -0,0 +1,5 @@
+class MouseButton(object):
+
+    LEFT = 0
+    MIDDLE = 1
+    RIGHT = 2

py/selenium/webdriver/common/actions/pointer_actions.py

@@ -14,29 +14,87 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+from . import interaction
+
 from .interaction import Interaction
+from .mouse_button import MouseButton
 from .pointer_input import PointerInput
 
+from selenium.webdriver.remote.webelement import WebElement
+
 
 class PointerActions(Interaction):
 
     def __init__(self, source=None):
         if source is None:
-            source = PointerInput("mouse", "mouse")
+            source = PointerInput(interaction.POINTER, "mouse")
         self.source = source
         super(PointerActions, self).__init__(source)
 
-    def pointer_down(self, button, device=None):
+    def pointer_down(self, button=MouseButton.LEFT):
         self._button_action("create_pointer_down", button=button)
 
-    def pointer_up(self):
-        self._button_action("create_pointer_up")
+    def pointer_up(self, button=MouseButton.LEFT):
+        self._button_action("create_pointer_up", button=button)
+
+    def move_to(self, element, x=None, y=None):
+        if not isinstance(element, WebElement):
+            raise AttributeError("move_to requires a WebElement")
+        if x is not None or y is not None:
+            el_rect = element.rect
+            left_offset = el_rect['width'] / 2
+            top_offset = el_rect['height'] / 2
+            left = -left_offset + (x or 0)
+            top = -top_offset + (y or 0)
+        else:
+            left = 0
+            top = 0
+        self.source.create_pointer_move(origin=element, x=int(left), y=int(top))
+        return self
+
+    def move_by(self, x, y):
+        self.source.create_pointer_move(origin=interaction.POINTER, x=int(x), y=int(y))
+        return self
+
+    def move_to_location(self, x, y):
+        self.source.create_pointer_move(origin='viewport', x=int(x), y=int(y))
+        return self
+
+    def click(self, element=None):
+        if element:
+            self.move_to(element)
+        self.pointer_down(MouseButton.LEFT)
+        self.pointer_up(MouseButton.LEFT)
+        return self
+
+    def context_click(self, element=None):
+        if element:
+            self.move_to(element)
+        self.pointer_down(MouseButton.RIGHT)
+        self.pointer_up(MouseButton.RIGHT)
+        return self
+
+    def click_and_hold(self, element=None):
+        if element:
+            self.move_to(element)
+        self.pointer_down()
+        return self
+
+    def release(self):
+        self.pointer_up()
+        return self
+
+    def double_click(self, element=None):
+        if element:
+            self.move_to(element)
+        self.click()
+        self.click()
 
     def pause(self, duration=0):
         self.source.create_pause(duration)
         return self
 
-    def _button_action(self, action, button=None):
+    def _button_action(self, action, button=MouseButton.LEFT):
         meth = getattr(self.source, action)
         meth(button)
         return self

py/selenium/webdriver/common/actions/pointer_input.py

@@ -15,30 +15,44 @@
 # specific language governing permissions and limitations
 # under the License.
 from .input_device import InputDevice
-from .interaction import Pause
+
+from selenium.webdriver.remote.webelement import WebElement
 
 
 class PointerInput(InputDevice):
 
+    DEFAULT_MOVE_DURATION = 250
+
     def __init__(self, type_, name):
         super(PointerInput, self).__init__()
         self.type = type_
         self.name = name
 
-    def create_pointer_move(self, duration=0, x=0, y=0, element=None, origin=None):
-        self.add_action({"type": "pointerMove", "duration": duration, "x": x, "y": y})
+    def create_pointer_move(self, duration=DEFAULT_MOVE_DURATION, x=None, y=None, origin=None):
+        action = {"type": "pointerMove","duration": duration}
+        action["x"] = x
+        action["y"] = y
+        if isinstance(origin, WebElement):
+            action["origin"] = {"element-6066-11e4-a52e-4f735466cecf": origin.id}
+        elif origin is not None:
+            action["origin"] = origin
+
+        self.add_action(action)
 
     def create_pointer_down(self, button):
-        self.add_action({"type": "pointerDown", "duration": 0})
+        self.add_action({"type": "pointerDown", "duration": 0, "button":button})
 
     def create_pointer_up(self, button):
-        self.add_action({"type": "pointerUp", "duration": 0})
+        self.add_action({"type": "pointerUp", "duration": 0, "button":button})
 
     def create_pointer_cancel(self):
         self.add_action({"type": "pointerCancel"})
 
     def create_pause(self, pause_duration):
-        self.add_action(Pause(self, pause_duration))
+        self.add_action({"type": "pause", "duration": pause_duration * 1000})
 
     def encode(self):
-        return {"type": self.type, "id": self.name, "actions": [acts.encode() for acts in self.actions]}
+        return {"type": self.type,
+                "parameters": {"pointerType": self.name},
+                "id": self.name,
+                "actions": [acts for acts in self.actions]}