autogui 1.0.0

data/lib/autogui/tween.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module AutoGUI
+  module Tween
+    module_function
+
+    def check(n)
+      n = n.to_f
+      unless n.between?(0.0, 1.0)
+        raise AutoGUIException, "Argument must be between 0.0 and 1.0."
+      end
+
+      n
+    end
+
+    def linear(n)
+      check(n)
+    end
+
+    def easeInQuad(n)
+      n = check(n)
+      n * n
+    end
+
+    def easeOutQuad(n)
+      n = check(n)
+      -n * (n - 2)
+    end
+
+    def easeInOutQuad(n)
+      n = check(n)
+      if n < 0.5
+        2 * n * n
+      else
+        n = n * 2 - 1
+        -0.5 * (n * (n - 2) - 1)
+      end
+    end
+
+    def easeInCubic(n)
+      n = check(n)
+      n**3
+    end
+
+    def easeOutCubic(n)
+      n = check(n)
+      n -= 1
+      n**3 + 1
+    end
+
+    def easeInOutCubic(n)
+      n = check(n)
+      n *= 2
+      if n < 1
+        0.5 * n**3
+      else
+        n -= 2
+        0.5 * (n**3 + 2)
+      end
+    end
+
+    def easeInQuart(n)
+      n = check(n)
+      n**4
+    end
+
+    def easeOutQuart(n)
+      n = check(n)
+      n -= 1
+      -(n**4 - 1)
+    end
+
+    def easeInOutQuart(n)
+      n = check(n)
+      n *= 2
+      if n < 1
+        0.5 * n**4
+      else
+        n -= 2
+        -0.5 * (n**4 - 2)
+      end
+    end
+
+    def easeInQuint(n)
+      n = check(n)
+      n**5
+    end
+
+    def easeOutQuint(n)
+      n = check(n)
+      n -= 1
+      n**5 + 1
+    end
+
+    def easeInOutQuint(n)
+      n = check(n)
+      n *= 2
+      if n < 1
+        0.5 * n**5
+      else
+        n -= 2
+        0.5 * (n**5 + 2)
+      end
+    end
+
+    def easeInSine(n)
+      n = check(n)
+      -Math.cos(n * Math::PI / 2) + 1
+    end
+
+    def easeOutSine(n)
+      n = check(n)
+      Math.sin(n * Math::PI / 2)
+    end
+
+    def easeInOutSine(n)
+      n = check(n)
+      -0.5 * (Math.cos(Math::PI * n) - 1)
+    end
+
+    def easeInExpo(n)
+      n = check(n)
+      n == 0 ? 0 : 2**(10 * (n - 1))
+    end
+
+    def easeOutExpo(n)
+      n = check(n)
+      n == 1 ? 1 : -(2**(-10 * n)) + 1
+    end
+
+    def easeInOutExpo(n)
+      n = check(n)
+      return 0 if n.zero?
+      return 1 if n == 1
+
+      n *= 2
+      if n < 1
+        0.5 * (2**(10 * (n - 1)))
+      else
+        0.5 * (-(2**(-10 * (n - 1))) + 2)
+      end
+    end
+
+    def easeInCirc(n)
+      n = check(n)
+      -(Math.sqrt(1 - n * n) - 1)
+    end
+
+    def easeOutCirc(n)
+      n = check(n)
+      n -= 1
+      Math.sqrt(1 - n * n)
+    end
+
+    def easeInOutCirc(n)
+      n = check(n)
+      n *= 2
+      if n < 1
+        -0.5 * (Math.sqrt(1 - n * n) - 1)
+      else
+        n -= 2
+        0.5 * (Math.sqrt(1 - n * n) + 1)
+      end
+    end
+
+    def easeInElastic(n, amplitude = 1, period = 0.3)
+      n = check(n)
+      return 0 if n.zero?
+      return 1 if n == 1
+
+      s = period / (2 * Math::PI) * Math.asin(1.0 / amplitude)
+      n -= 1
+      -(amplitude * (2**(10 * n)) * Math.sin((n - s) * (2 * Math::PI) / period))
+    end
+
+    def easeOutElastic(n, amplitude = 1, period = 0.3)
+      n = check(n)
+      return 0 if n.zero?
+      return 1 if n == 1
+
+      s = period / (2 * Math::PI) * Math.asin(1.0 / amplitude)
+      amplitude * (2**(-10 * n)) * Math.sin((n - s) * (2 * Math::PI) / period) + 1
+    end
+
+    def easeInOutElastic(n, amplitude = 1, period = 0.45)
+      n = check(n)
+      return 0 if n.zero?
+      return 1 if n == 1
+
+      s = period / (2 * Math::PI) * Math.asin(1.0 / amplitude)
+      n *= 2
+      if n < 1
+        n -= 1
+        -0.5 * (amplitude * (2**(10 * n)) * Math.sin((n - s) * (2 * Math::PI) / period))
+      else
+        n -= 1
+        amplitude * (2**(-10 * n)) * Math.sin((n - s) * (2 * Math::PI) / period) * 0.5 + 1
+      end
+    end
+
+    def easeInBack(n, s = 1.70158)
+      n = check(n)
+      n * n * ((s + 1) * n - s)
+    end
+
+    def easeOutBack(n, s = 1.70158)
+      n = check(n)
+      n -= 1
+      n * n * ((s + 1) * n + s) + 1
+    end
+
+    def easeInOutBack(n, s = 1.70158)
+      n = check(n)
+      s *= 1.525
+      n *= 2
+      if n < 1
+        0.5 * (n * n * ((s + 1) * n - s))
+      else
+        n -= 2
+        0.5 * (n * n * ((s + 1) * n + s) + 2)
+      end
+    end
+
+    def easeInBounce(n)
+      n = check(n)
+      1 - easeOutBounce(1 - n)
+    end
+
+    def easeOutBounce(n)
+      n = check(n)
+      if n < 1 / 2.75
+        7.5625 * n * n
+      elsif n < 2 / 2.75
+        n -= 1.5 / 2.75
+        7.5625 * n * n + 0.75
+      elsif n < 2.5 / 2.75
+        n -= 2.25 / 2.75
+        7.5625 * n * n + 0.9375
+      else
+        n -= 2.625 / 2.75
+        7.5625 * n * n + 0.984375
+      end
+    end
+
+    def easeInOutBounce(n)
+      n = check(n)
+      if n < 0.5
+        easeInBounce(n * 2) * 0.5
+      else
+        easeOutBounce(n * 2 - 1) * 0.5 + 0.5
+      end
+    end
+  end
+end

data/lib/autogui/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AutoGUI
+  VERSION = "1.0.0"
+end

data/lib/autogui/window.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module AutoGUI
+  class Window
+    SW_HIDE = 0
+    SW_SHOWNORMAL = 1
+    SW_SHOWMINIMIZED = 2
+    SW_SHOWMAXIMIZED = 3
+    SW_RESTORE = 9
+
+    attr_reader :hwnd
+
+    def initialize(hwnd)
+      @hwnd = hwnd
+    end
+
+    def title
+      Platform.current.window_title(@hwnd)
+    end
+
+    def box
+      left, top, width, height = Platform.current.window_rect(@hwnd)
+      Box.new(left, top, width, height)
+    end
+
+    def left
+      box.left
+    end
+
+    def top
+      box.top
+    end
+
+    def width
+      box.width
+    end
+
+    def height
+      box.height
+    end
+
+    def right
+      left + width
+    end
+
+    def bottom
+      top + height
+    end
+
+    def visible?
+      Platform.current.window_visible?(@hwnd)
+    end
+
+    def minimized?
+      Platform.current.window_minimized?(@hwnd)
+    end
+
+    def maximized?
+      Platform.current.window_maximized?(@hwnd)
+    end
+
+    def activate
+      Platform.current.activate_window(@hwnd)
+      self
+    end
+
+    def minimize
+      Platform.current.show_window(@hwnd, SW_SHOWMINIMIZED)
+      self
+    end
+
+    def maximize
+      Platform.current.show_window(@hwnd, SW_SHOWMAXIMIZED)
+      self
+    end
+
+    def restore
+      Platform.current.show_window(@hwnd, SW_RESTORE)
+      self
+    end
+
+    def hide
+      Platform.current.show_window(@hwnd, SW_HIDE)
+      self
+    end
+
+    def close
+      Platform.current.close_window(@hwnd)
+      self
+    end
+
+    def moveTo(x, y)
+      Platform.current.move_window(@hwnd, x.to_i, y.to_i, width, height)
+      self
+    end
+    alias move_to moveTo
+
+    def resizeTo(w, h)
+      Platform.current.move_window(@hwnd, left, top, w.to_i, h.to_i)
+      self
+    end
+    alias resize_to resizeTo
+
+    def to_s
+      "Window(title=#{title.inspect}, box=#{box})"
+    end
+    alias inspect to_s
+
+    def ==(other)
+      other.is_a?(Window) && other.hwnd.to_i == @hwnd.to_i
+    end
+  end
+
+  module WindowFunctions
+    module_function
+
+    def getAllWindows
+      windows = []
+      return windows unless Platform.current.respond_to?(:each_hwnd)
+
+      Platform.current.each_hwnd do |hwnd|
+        next unless Platform.current.window_visible?(hwnd)
+
+        title = Platform.current.window_title(hwnd)
+        next if title.nil? || title.empty?
+
+        windows << Window.new(hwnd)
+      end
+      windows
+    end
+    alias get_all_windows getAllWindows
+
+    def getAllTitles
+      getAllWindows.map(&:title)
+    end
+    alias get_all_titles getAllTitles
+
+    def getWindowsWithTitle(title)
+      re = title.is_a?(Regexp) ? title : /#{Regexp.escape(title.to_s)}/i
+      getAllWindows.select { |w| w.title.match?(re) }
+    end
+    alias get_windows_with_title getWindowsWithTitle
+
+    def getWindowsAt(x, y)
+      getAllWindows.select do |w|
+        b = w.box
+        x >= b.left && x < b.left + b.width && y >= b.top && y < b.top + b.height
+      end
+    end
+    alias get_windows_at getWindowsAt
+
+    def getActiveWindow
+      return nil unless Platform.current.respond_to?(:GetForegroundWindow)
+
+      hwnd = Platform.current.GetForegroundWindow()
+      return nil unless Platform.current.valid_window?(hwnd)
+
+      Window.new(hwnd)
+    rescue StandardError
+      nil
+    end
+    alias get_active_window getActiveWindow
+
+    def getActiveWindowTitle
+      w = getActiveWindow
+      w&.title
+    end
+    alias get_active_window_title getActiveWindowTitle
+  end
+end