Did some more work in Python and started officially learning Java

1 files changed, 232 insertions, 0 deletions

diff --git a/Python/venv1/Lib/site-packages/keyboard/mouse.py b/Python/venv1/Lib/site-packages/keyboard/mouse.py
new file mode 100644
index 0000000..315199e
--- /dev/null
+++ b/Python/venv1/Lib/site-packages/keyboard/mouse.py
@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*-
+import warnings
+warnings.simplefilter('always', DeprecationWarning)
+warnings.warn('The mouse sub-library is deprecated and will be removed in future versions. Please use the standalone package `mouse`.', DeprecationWarning, stacklevel=2)
+
+import time as _time
+
+import platform as _platform
+if _platform.system() == 'Windows':
+    from. import _winmouse as _os_mouse
+elif _platform.system() == 'Linux':
+    from. import _nixmouse as _os_mouse
+elif _platform.system() == 'Darwin':
+    from. import _darwinmouse as _os_mouse
+else:
+    raise OSError("Unsupported platform '{}'".format(_platform.system()))
+
+from ._mouse_event import ButtonEvent, MoveEvent, WheelEvent, LEFT, RIGHT, MIDDLE, X, X2, UP, DOWN, DOUBLE
+from ._generic import GenericListener as _GenericListener
+
+_pressed_events = set()
+class _MouseListener(_GenericListener):
+    def init(self):
+        _os_mouse.init()
+    def pre_process_event(self, event):
+        if isinstance(event, ButtonEvent):
+            if event.event_type in (UP, DOUBLE):
+                _pressed_events.discard(event.button)
+            else:
+                _pressed_events.add(event.button)
+        return True
+
+    def listen(self):
+        _os_mouse.listen(self.queue)
+
+_listener = _MouseListener()
+
+def is_pressed(button=LEFT):
+    """ Returns True if the given button is currently pressed. """
+    _listener.start_if_necessary()
+    return button in _pressed_events
+
+def press(button=LEFT):
+    """ Presses the given button (but doesn't release). """
+    _os_mouse.press(button)
+
+def release(button=LEFT):
+    """ Releases the given button. """
+    _os_mouse.release(button)
+
+def click(button=LEFT):
+    """ Sends a click with the given button. """
+    _os_mouse.press(button)
+    _os_mouse.release(button)
+
+def double_click(button=LEFT):
+    """ Sends a double click with the given button. """
+    click(button)
+    click(button)
+
+def right_click():
+    """ Sends a right click with the given button. """
+    click(RIGHT)
+
+def wheel(delta=1):
+    """ Scrolls the wheel `delta` clicks. Sign indicates direction. """
+    _os_mouse.wheel(delta)
+
+def move(x, y, absolute=True, duration=0):
+    """
+    Moves the mouse. If `absolute`, to position (x, y), otherwise move relative
+    to the current position. If `duration` is non-zero, animates the movement.
+    """
+    x = int(x)
+    y = int(y)
+
+    # Requires an extra system call on Linux, but `move_relative` is measured
+    # in millimiters so we would lose precision.
+    position_x, position_y = get_position()
+
+    if not absolute:
+        x = position_x + x
+        y = position_y + y
+
+    if duration:
+        start_x = position_x
+        start_y = position_y
+        dx = x - start_x
+        dy = y - start_y
+
+        if dx == 0 and dy == 0:
+            _time.sleep(duration)
+        else:
+            # 120 movements per second.
+            # Round and keep float to ensure float division in Python 2
+            steps = max(1.0, float(int(duration * 120.0)))
+            for i in range(int(steps)+1):
+                move(start_x + dx*i/steps, start_y + dy*i/steps)
+                _time.sleep(duration/steps)
+    else:
+        _os_mouse.move_to(x, y)
+
+def drag(start_x, start_y, end_x, end_y, absolute=True, duration=0):
+    """
+    Holds the left mouse button, moving from start to end position, then
+    releases. `absolute` and `duration` are parameters regarding the mouse
+    movement.
+    """
+    if is_pressed():
+        release()
+    move(start_x, start_y, absolute, 0)
+    press()
+    move(end_x, end_y, absolute, duration)
+    release()
+
+def on_button(callback, args=(), buttons=(LEFT, MIDDLE, RIGHT, X, X2), types=(UP, DOWN, DOUBLE)):
+    """ Invokes `callback` with `args` when the specified event happens. """
+    if not isinstance(buttons, (tuple, list)):
+        buttons = (buttons,)
+    if not isinstance(types, (tuple, list)):
+        types = (types,)
+
+    def handler(event):
+        if isinstance(event, ButtonEvent):
+            if event.event_type in types and event.button in buttons:
+                callback(*args)
+    _listener.add_handler(handler)
+    return handler
+
+def on_click(callback, args=()):
+    """ Invokes `callback` with `args` when the left button is clicked. """
+    return on_button(callback, args, [LEFT], [UP])
+
+def on_double_click(callback, args=()):
+    """
+    Invokes `callback` with `args` when the left button is double clicked.
+    """
+    return on_button(callback, args, [LEFT], [DOUBLE])
+
+def on_right_click(callback, args=()):
+    """ Invokes `callback` with `args` when the right button is clicked. """
+    return on_button(callback, args, [RIGHT], [UP])
+
+def on_middle_click(callback, args=()):
+    """ Invokes `callback` with `args` when the middle button is clicked. """
+    return on_button(callback, args, [MIDDLE], [UP])
+
+def wait(button=LEFT, target_types=(UP, DOWN, DOUBLE)):
+    """
+    Blocks program execution until the given button performs an event.
+    """
+    from threading import Lock
+    lock = Lock()
+    lock.acquire()
+    handler = on_button(lock.release, (), [button], target_types)
+    lock.acquire()
+    _listener.remove_handler(handler)
+
+def get_position():
+    """ Returns the (x, y) mouse position. """
+    return _os_mouse.get_position()
+
+def hook(callback):
+    """
+    Installs a global listener on all available mouses, invoking `callback`
+    each time it is moved, a key status changes or the wheel is spun. A mouse
+    event is passed as argument, with type either `mouse.ButtonEvent`,
+    `mouse.WheelEvent` or `mouse.MoveEvent`.
+    
+    Returns the given callback for easier development.
+    """
+    _listener.add_handler(callback)
+    return callback
+
+def unhook(callback):
+    """
+    Removes a previously installed hook.
+    """
+    _listener.remove_handler(callback)
+
+def unhook_all():
+    """
+    Removes all hooks registered by this application. Note this may include
+    hooks installed by high level functions, such as `record`.
+    """
+    del _listener.handlers[:]
+
+def record(button=RIGHT, target_types=(DOWN,)):
+    """
+    Records all mouse events until the user presses the given button.
+    Then returns the list of events recorded. Pairs well with `play(events)`.
+
+    Note: this is a blocking function.
+    Note: for more details on the mouse hook and events see `hook`.
+    """
+    recorded = []
+    hook(recorded.append)
+    wait(button=button, target_types=target_types)
+    unhook(recorded.append)
+    return recorded
+
+def play(events, speed_factor=1.0, include_clicks=True, include_moves=True, include_wheel=True):
+    """
+    Plays a sequence of recorded events, maintaining the relative time
+    intervals. If speed_factor is <= 0 then the actions are replayed as fast
+    as the OS allows. Pairs well with `record()`.
+
+    The parameters `include_*` define if events of that type should be inluded
+    in the replay or ignored.
+    """
+    last_time = None
+    for event in events:
+        if speed_factor > 0 and last_time is not None:
+            _time.sleep((event.time - last_time) / speed_factor)
+        last_time = event.time
+
+        if isinstance(event, ButtonEvent) and include_clicks:
+            if event.event_type == UP:
+                _os_mouse.release(event.button)
+            else:
+                _os_mouse.press(event.button)
+        elif isinstance(event, MoveEvent) and include_moves:
+            _os_mouse.move_to(event.x, event.y)
+        elif isinstance(event, WheelEvent) and include_wheel:
+            _os_mouse.wheel(event.delta)
+
+replay = play
+hold = press
+
+if __name__ == '__main__':
+    print('Recording... Double click to stop and replay.')
+    play(record())