autogui 1.0.0

data/lib/autogui/image.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
+
+module AutoGUI
+  # Packed RGB bitmap used by screenshot and locate* functions.
+  # +data+ is a binary string of 3-byte RGB pixels, row-major, top-down.
+  class Image
+    attr_reader :width, :height, :data
+
+    def initialize(width, height, data = nil)
+      @width = width.to_i
+      @height = height.to_i
+      expected = @width * @height * 3
+      @data =
+        if data.nil?
+          "\x00".b * expected
+        else
+          d = data.dup.force_encoding(Encoding::BINARY)
+          raise AutoGUIException, "image data size mismatch" unless d.bytesize == expected
+
+          d
+        end
+    end
+
+    def size
+      [@width, @height]
+    end
+
+    def [](x, y = nil)
+      if y.nil? && x.is_a?(Array)
+        y = x[1]
+        x = x[0]
+      end
+      getpixel(x, y)
+    end
+
+    def getpixel(x, y)
+      x = x.to_i
+      y = y.to_i
+      raise ArgumentError, "pixel out of bounds" unless x.between?(0, @width - 1) && y.between?(0, @height - 1)
+
+      i = (y * @width + x) * 3
+      [@data.getbyte(i), @data.getbyte(i + 1), @data.getbyte(i + 2)]
+    end
+
+    def putpixel(x, y, rgb)
+      x = x.to_i
+      y = y.to_i
+      raise ArgumentError, "pixel out of bounds" unless x.between?(0, @width - 1) && y.between?(0, @height - 1)
+
+      i = (y * @width + x) * 3
+      @data.setbyte(i, rgb[0].to_i)
+      @data.setbyte(i + 1, rgb[1].to_i)
+      @data.setbyte(i + 2, rgb[2].to_i)
+    end
+
+    def grayscale
+      out = String.new(capacity: @width * @height * 3, encoding: Encoding::BINARY)
+      i = 0
+      while i < @data.bytesize
+        r = @data.getbyte(i)
+        g = @data.getbyte(i + 1)
+        b = @data.getbyte(i + 2)
+        y = ((r * 299) + (g * 587) + (b * 114)) / 1000
+        out << y.chr << y.chr << y.chr
+        i += 3
+      end
+      Image.new(@width, @height, out)
+    end
+
+    def crop(left, top, width, height)
+      left = left.to_i
+      top = top.to_i
+      width = width.to_i
+      height = height.to_i
+      raise ArgumentError, "invalid crop" if width <= 0 || height <= 0
+      raise ArgumentError, "crop out of bounds" unless left >= 0 && top >= 0 && left + width <= @width && top + height <= @height
+
+      out = String.new(capacity: width * height * 3, encoding: Encoding::BINARY)
+      height.times do |row|
+        src = ((top + row) * @width + left) * 3
+        out << @data.byteslice(src, width * 3)
+      end
+      Image.new(width, height, out)
+    end
+
+    def save(path)
+      path = path.to_s
+      ext = File.extname(path).downcase
+      File.binwrite(path, ext == ".bmp" ? to_bmp : to_png)
+      self
+    end
+
+    def to_png
+      raw = String.new(capacity: @height * (1 + @width * 3), encoding: Encoding::BINARY)
+      @height.times do |y|
+        raw << "\x00"
+        raw << @data.byteslice(y * @width * 3, @width * 3)
+      end
+      compressed = Zlib::Deflate.deflate(raw, Zlib::BEST_SPEED)
+      png = "\x89PNG\r\n\x1a\n".b
+      png << png_chunk("IHDR", [@width, @height, 8, 2, 0, 0, 0].pack("NNC5"))
+      png << png_chunk("IDAT", compressed)
+      png << png_chunk("IEND", "".b)
+      png
+    end
+
+    def to_bmp
+      row_stride = ((@width * 3 + 3) / 4) * 4
+      pixel_size = row_stride * @height
+      file_size = 54 + pixel_size
+      file_header = ["BM", file_size, 0, 0, 54].pack("a2VvvV")
+      info_header = [40, @width, @height, 1, 24, 0, pixel_size, 0, 0, 0, 0].pack("VllvvVVllVV")
+      pixels = String.new(capacity: pixel_size, encoding: Encoding::BINARY)
+      pad = "\x00".b * (row_stride - @width * 3)
+      (@height - 1).downto(0) do |y|
+        row = @data.byteslice(y * @width * 3, @width * 3).dup
+        i = 0
+        while i < row.bytesize
+          r = row.getbyte(i)
+          b = row.getbyte(i + 2)
+          row.setbyte(i, b)
+          row.setbyte(i + 2, r)
+          i += 3
+        end
+        pixels << row << pad
+      end
+      file_header + info_header + pixels
+    end
+
+    def self.open(path_or_image)
+      return path_or_image if path_or_image.is_a?(Image)
+
+      path = path_or_image.to_s
+      bytes = File.binread(path)
+      if bytes.start_with?("\x89PNG".b)
+        from_png(bytes)
+      elsif bytes.start_with?("BM")
+        from_bmp(bytes)
+      else
+        raise AutoGUIException, "unsupported image format: #{path} (use PNG or BMP)"
+      end
+    end
+
+    def self.from_png(bytes)
+      raise AutoGUIException, "invalid PNG signature" unless bytes.start_with?("\x89PNG\r\n\x1a\n".b)
+
+      offset = 8
+      width = height = nil
+      bit_depth = color_type = nil
+      idat = String.new(encoding: Encoding::BINARY)
+      palette = nil
+      until offset >= bytes.bytesize
+        length = bytes.byteslice(offset, 4).unpack1("N")
+        type = bytes.byteslice(offset + 4, 4)
+        data = bytes.byteslice(offset + 8, length)
+        offset += 12 + length
+        case type
+        when "IHDR"
+          width, height, bit_depth, color_type = data.unpack("NNC2")
+        when "PLTE"
+          palette = data
+        when "IDAT"
+          idat << data
+        when "IEND"
+          break
+        end
+      end
+      raise AutoGUIException, "PNG missing IHDR" if width.nil?
+      raise AutoGUIException, "only 8-bit PNG is supported" unless bit_depth == 8
+
+      inflated = Zlib::Inflate.inflate(idat)
+      channels =
+        case color_type
+        when 0 then 1
+        when 2 then 3
+        when 3 then 1
+        when 4 then 2
+        when 6 then 4
+        else
+          raise AutoGUIException, "unsupported PNG color type #{color_type}"
+        end
+      rgb = unfilter_png(inflated, width, height, channels, color_type, palette)
+      new(width, height, rgb)
+    end
+
+    def self.from_bmp(bytes)
+      _magic, _file_size, _res1, _res2, offset = bytes.unpack("a2VvvV")
+      header_size, width, height, _planes, bits, compression =
+        bytes.byteslice(14, 24).unpack("VllvvV")
+      raise AutoGUIException, "compressed BMP is not supported" unless compression.to_i.zero?
+      raise AutoGUIException, "unsupported BMP bit depth" unless [24, 32].include?(bits)
+
+      top_down = height.negative?
+      height = height.abs
+      bytes_pp = bits / 8
+      row_stride = ((width * bytes_pp + 3) / 4) * 4
+      rgb = String.new(capacity: width * height * 3, encoding: Encoding::BINARY)
+      height.times do |row|
+        src_row = top_down ? row : (height - 1 - row)
+        src = offset + src_row * row_stride
+        width.times do |x|
+          i = src + x * bytes_pp
+          b = bytes.getbyte(i)
+          g = bytes.getbyte(i + 1)
+          r = bytes.getbyte(i + 2)
+          rgb << r.chr << g.chr << b.chr
+        end
+      end
+      new(width, height, rgb)
+    end
+
+    def self.from_bgra(width, height, bgra, stride = nil)
+      stride ||= width * 4
+      rgb = String.new(capacity: width * height * 3, encoding: Encoding::BINARY)
+      height.times do |y|
+        row = y * stride
+        width.times do |x|
+          i = row + x * 4
+          rgb << bgra.getbyte(i + 2).chr << bgra.getbyte(i + 1).chr << bgra.getbyte(i).chr
+        end
+      end
+      new(width, height, rgb)
+    end
+
+    def self.from_pixels(width, height, pixels)
+      data = String.new(capacity: width * height * 3, encoding: Encoding::BINARY)
+      pixels.each do |r, g, b|
+        data << r.chr << g.chr << b.chr
+      end
+      new(width, height, data)
+    end
+
+    class << self
+      private
+
+      def png_chunk_crc(type, data)
+        Zlib.crc32(type + data)
+      end
+
+      def unfilter_png(inflated, width, height, channels, color_type, palette)
+        bpp = channels
+        stride = width * bpp
+        prev = "\x00".b * stride
+        rgb = String.new(capacity: width * height * 3, encoding: Encoding::BINARY)
+        pos = 0
+        height.times do
+          filter = inflated.getbyte(pos)
+          pos += 1
+          raw = inflated.byteslice(pos, stride).dup
+          pos += stride
+          recon = apply_filter(filter, raw, prev, bpp)
+          prev = recon
+          case color_type
+          when 2
+            rgb << recon
+          when 0
+            recon.bytesize.times { |i| rgb << recon[i] << recon[i] << recon[i] }
+          when 4
+            (width).times do |x|
+              g = recon.getbyte(x * 2)
+              a = recon.getbyte(x * 2 + 1)
+              v = composite_white(g, a)
+              rgb << v.chr << v.chr << v.chr
+            end
+          when 6
+            width.times do |x|
+              i = x * 4
+              a = recon.getbyte(i + 3)
+              rgb << composite_white(recon.getbyte(i), a).chr
+              rgb << composite_white(recon.getbyte(i + 1), a).chr
+              rgb << composite_white(recon.getbyte(i + 2), a).chr
+            end
+          when 3
+            raise AutoGUIException, "PNG palette missing" if palette.nil?
+
+            width.times do |x|
+              idx = recon.getbyte(x) * 3
+              rgb << palette.getbyte(idx).chr << palette.getbyte(idx + 1).chr << palette.getbyte(idx + 2).chr
+            end
+          end
+        end
+        rgb
+      end
+
+      def apply_filter(filter, raw, prev, bpp)
+        recon = raw.dup
+        case filter
+        when 0
+          recon
+        when 1
+          recon.bytesize.times do |i|
+            left = i >= bpp ? recon.getbyte(i - bpp) : 0
+            recon.setbyte(i, (raw.getbyte(i) + left) & 255)
+          end
+          recon
+        when 2
+          recon.bytesize.times do |i|
+            recon.setbyte(i, (raw.getbyte(i) + prev.getbyte(i)) & 255)
+          end
+          recon
+        when 3
+          recon.bytesize.times do |i|
+            left = i >= bpp ? recon.getbyte(i - bpp) : 0
+            up = prev.getbyte(i)
+            recon.setbyte(i, (raw.getbyte(i) + ((left + up) / 2)) & 255)
+          end
+          recon
+        when 4
+          recon.bytesize.times do |i|
+            a = i >= bpp ? recon.getbyte(i - bpp) : 0
+            b = prev.getbyte(i)
+            c = i >= bpp ? prev.getbyte(i - bpp) : 0
+            recon.setbyte(i, (raw.getbyte(i) + paeth(a, b, c)) & 255)
+          end
+          recon
+        else
+          raise AutoGUIException, "unsupported PNG filter #{filter}"
+        end
+      end
+
+      def paeth(a, b, c)
+        p = a + b - c
+        pa = (p - a).abs
+        pb = (p - b).abs
+        pc = (p - c).abs
+        return a if pa <= pb && pa <= pc
+        return b if pb <= pc
+
+        c
+      end
+
+      def composite_white(value, alpha)
+        ((value * alpha) + (255 * (255 - alpha))) / 255
+      end
+    end
+
+    def png_chunk(type, data)
+      [data.bytesize].pack("N") + type + data + [Zlib.crc32(type + data)].pack("N")
+    end
+  end
+end

data/lib/autogui/keys.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AutoGUI
+  KEY_NAMES = [
+    "\t", "\n", "\r", " ", "!", "\"", "#", "$", "%", "&", "'", "(",
+    ")", "*", "+", ",", "-", ".", "/", "0", "1", "2", "3", "4", "5", "6", "7",
+    "8", "9", ":", ";", "<", "=", ">", "?", "@", "[", "\\", "]", "^", "_", "`",
+    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
+    "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~",
+    "accept", "add", "alt", "altleft", "altright", "apps", "backspace",
+    "browserback", "browserfavorites", "browserforward", "browserhome",
+    "browserrefresh", "browsersearch", "browserstop", "capslock", "clear",
+    "convert", "ctrl", "ctrlleft", "ctrlright", "decimal", "del", "delete",
+    "divide", "down", "end", "enter", "esc", "escape", "execute", "f1", "f10",
+    "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f2", "f20",
+    "f21", "f22", "f23", "f24", "f3", "f4", "f5", "f6", "f7", "f8", "f9",
+    "final", "fn", "hanguel", "hangul", "hanja", "help", "home", "insert",
+    "junja", "kana", "kanji", "launchapp1", "launchapp2", "launchmail",
+    "launchmediaselect", "left", "modechange", "multiply", "nexttrack",
+    "nonconvert", "num0", "num1", "num2", "num3", "num4", "num5", "num6",
+    "num7", "num8", "num9", "numlock", "pagedown", "pageup", "pause", "pgdn",
+    "pgup", "playpause", "prevtrack", "print", "printscreen", "prntscrn",
+    "prtsc", "prtscr", "return", "right", "scrolllock", "select", "separator",
+    "shift", "shiftleft", "shiftright", "sleep", "space", "stop", "subtract",
+    "tab", "up", "volumedown", "volumemute", "volumeup", "win", "winleft",
+    "winright", "yen", "command", "option", "optionleft", "optionright"
+  ].freeze
+
+  KEYBOARD_KEYS = KEY_NAMES
+
+  LEFT = "left"
+  MIDDLE = "middle"
+  RIGHT = "right"
+  PRIMARY = "primary"
+  SECONDARY = "secondary"
+
+  QWERTY = "`1234567890-=qwertyuiop[]\\asdfghjkl;'zxcvbnm,./~!@\#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>?".freeze
+  QWERTZ = "=1234567890/0qwertzuiop89-asdfghjkl,\\yxcvbnm,.7+!@\#$%^&*()?)QWERTZUIOP*(_ASDFGHJKL<|YXCVBNM<>&".freeze
+
+  SHIFT_CHARS = ['~', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', '{', '}', '|', ':', '"', '<', '>', '?'].freeze
+
+  def self.shift_character?(character)
+    return false if character.nil? || character.empty?
+
+    character != character.downcase || SHIFT_CHARS.include?(character)
+  end
+  class << self
+    alias isShiftCharacter shift_character?
+  end
+end

data/lib/autogui/message_box.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+
+module AutoGUI
+  module MessageBox
+    MB_OK = 0x00000000
+    MB_OKCANCEL = 0x00000001
+    MB_YESNOCANCEL = 0x00000003
+    MB_YESNO = 0x00000004
+    IDOK = 1
+    IDCANCEL = 2
+    IDYES = 6
+    IDNO = 7
+
+    module_function
+
+    def alert(text = "", title = "AutoGUI Alert", button = "OK")
+      if windows?
+        Platform.current.message_box(text.to_s, title.to_s, MB_OK)
+        button.to_s
+      else
+        dialog_alert(text, title, button)
+        button.to_s
+      end
+    end
+
+    def confirm(text = "", title = "AutoGUI Confirm", buttons = %w[OK Cancel])
+      buttons = Array(buttons)
+      if windows? && buttons.map(&:to_s) == %w[OK Cancel]
+        result = Platform.current.message_box(text.to_s, title.to_s, MB_OKCANCEL)
+        result == IDOK ? "OK" : "Cancel"
+      elsif windows? && buttons.map(&:to_s) == %w[Yes No]
+        result = Platform.current.message_box(text.to_s, title.to_s, MB_YESNO)
+        result == IDYES ? "Yes" : "No"
+      else
+        dialog_choice(text, title, buttons)
+      end
+    end
+
+    def prompt(text = "", title = "AutoGUI Prompt", default = "")
+      dialog_input(text, title, default, password: false)
+    end
+
+    def password(text = "", title = "AutoGUI Password", default = "", mask = "*")
+      dialog_input(text, title, default, password: true, mask: mask)
+    end
+
+    def windows?
+      RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/i
+    end
+
+    def dialog_alert(text, title, _button)
+      if windows?
+        Platform.current.message_box(text.to_s, title.to_s, MB_OK)
+      else
+        system("osascript", "-e", %(display dialog #{js(text)} with title #{js(title)} buttons {"OK"} default button 1)) ||
+          system("zenity", "--info", "--title=#{title}", "--text=#{text}")
+      end
+    end
+
+    def dialog_choice(text, title, buttons)
+      if windows?
+        vbs = <<~VBS
+          Set fso = CreateObject("Scripting.FileSystemObject")
+          Set stdout = fso.GetStandardStream(1)
+          r = MsgBox(#{vbs_str(text)}, vbYesNoCancel, #{vbs_str(title)})
+          If r = vbYes Then stdout.Write "Yes"
+          If r = vbNo Then stdout.Write "No"
+          If r = vbCancel Then stdout.Write "Cancel"
+        VBS
+        out = run_vbs(vbs)
+        mapped = { "Yes" => buttons[0], "No" => buttons[1], "Cancel" => buttons[2] || buttons[-1] }
+        mapped[out] || buttons[-1]
+      else
+        btns = buttons.map(&:to_s)
+        script = "set r to button returned of (display dialog #{js(text)} with title #{js(title)} buttons {#{btns.map { |b| js(b) }.join(',')}} default button 1)"
+        out, = Open3.capture2("osascript", "-e", script)
+        out.strip.empty? ? nil : out.strip
+      end
+    end
+
+    def dialog_input(text, title, default, password: false, mask: "*")
+      if windows?
+        vbs = <<~VBS
+          Set fso = CreateObject("Scripting.FileSystemObject")
+          Set stdout = fso.GetStandardStream(1)
+          r = InputBox(#{vbs_str(text)}, #{vbs_str(title)}, #{vbs_str(default)})
+          If IsEmpty(r) Then
+            stdout.Write Chr(0)
+          Else
+            stdout.Write r
+          End If
+        VBS
+        out = run_vbs(vbs)
+        return nil if out == "\u0000" || out.nil?
+
+        out
+      else
+        hidden = password ? " with hidden answer" : ""
+        script = "text returned of (display dialog #{js(text)} with title #{js(title)} default answer #{js(default)}#{hidden})"
+        out, status = Open3.capture2("osascript", "-e", script)
+        status.success? ? out.sub(/\r?\n\z/, "") : nil
+      end
+    end
+
+    def run_vbs(script)
+      file = Tempfile.new(["autogui", ".vbs"])
+      file.write(script)
+      file.close
+      out, = Open3.capture2("cscript", "//Nologo", file.path)
+      File.unlink(file.path) rescue nil
+      out
+    end
+
+    def vbs_str(s)
+      %("#{s.to_s.gsub('"', '""')}")
+    end
+
+    def js(s)
+      s.to_s.inspect
+    end
+  end
+end