rabbit-qt 0.1.0

data/lib/rabbit/gem-pusher.rb

@@ -0,0 +1,89 @@
+# Copyright (C) 2016-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require "rake"
+require "open-uri"
+
+require_relative "gettext"
+require_relative "password-reader"
+require_relative "yaml-loader"
+
+module Rabbit
+  class GemPusher
+    include GetText
+    include Rake::DSL
+
+    def initialize(gem_path, user)
+      @gem_path = gem_path
+      @user = user
+    end
+
+    def push
+      credentials_path = File.expand_path("~/.gem/credentials")
+      credentials_path_exist = File.exist?(credentials_path)
+      if credentials_path_exist
+        credentials = YAMLLoader.load(File.read(credentials_path))
+      else
+        credentials = {}
+      end
+      unless credentials.key?(@user.to_sym)
+        credentials[@user.to_sym] = retrieve_api_key
+        FileUtils.mkdir_p(File.dirname(credentials_path))
+        File.open(credentials_path, "w") do |credentials_file|
+          credentials_file.print(credentials.to_yaml)
+        end
+        unless credentials_path_exist
+          File.chmod(0600, credentials_path)
+        end
+      end
+      ruby("-S", "gem", "push", @gem_path,
+           "--key", @user)
+    end
+
+    private
+    def retrieve_api_key
+      prompt = _("Enter password on RubyGems.org [%{user}]: ") % {:user => @user}
+      reader = PasswordReader.new(prompt)
+      password = reader.read
+      begin
+        URI.open("https://rubygems.org/api/v1/api_key.yaml",
+                 :http_basic_authentication => [@user, password]) do |response|
+          YAMLLoader.load(response.read)[:rubygems_api_key]
+        end
+      rescue OpenURI::HTTPError => error
+        if mfa_error?(error)
+          prompt = _("Enter OTP on RubyGems.org [%{user}]: ") % {:user => @user}
+          # TODO: We don't need to hide input.
+          reader = PasswordReader.new(prompt)
+          otp = reader.read
+          URI.open("https://rubygems.org/api/v1/api_key.yaml",
+                   :http_basic_authentication => [@user, password],
+                   "OTP" => otp) do |response|
+            YAMLLoader.load(response.read)[:rubygems_api_key]
+          end
+        else
+          raise
+        end
+      end
+    end
+
+    def mfa_error?(error)
+      return false unless error.message.start_with?("401 ")
+      body = error.io.read
+      body.start_with?("You have enabled multifactor authentication")
+    end
+  end
+end

data/lib/rabbit/gesture/handler.rb

@@ -0,0 +1,253 @@
+# Copyright (C) 2006-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "../qt"
+
+require_relative "../rabbit"
+require_relative "../renderer/engine"
+require_relative "processor"
+
+module Rabbit
+  module Gesture
+    class Handler
+      DEFAULT_BACK_COLOR = Renderer::Color.parse("#3333337f")
+      DEFAULT_LINE_COLOR = Renderer::Color.parse("#f00f")
+      DEFAULT_NEXT_COLOR = Renderer::Color.parse("#0f0c")
+      DEFAULT_CURRENT_COLOR = Renderer::Color.parse("#f0fc")
+
+      DEFAULT_LINE_WIDTH = 3
+      DEFAULT_NEXT_WIDTH = 10
+
+      attr_accessor :back_color, :line_color, :next_color, :current_color
+      attr_accessor :line_width, :next_width
+      def initialize(conf={})
+        super()
+        @icon_theme = nil
+        conf ||= {}
+        @back_color = conf[:back_color] || DEFAULT_BACK_COLOR
+        @line_color = conf[:line_color] || DEFAULT_LINE_COLOR
+        @next_color = conf[:next_color] || DEFAULT_NEXT_COLOR
+        @current_color = conf[:current_color] || DEFAULT_CURRENT_COLOR
+        @line_width = conf[:line_width] || DEFAULT_LINE_WIDTH
+        @next_width = conf[:next_width] || DEFAULT_NEXT_WIDTH
+        @processor = Processor.new(conf[:threshold],
+                                   conf[:skew_threshold_angle])
+        @actions = []
+        @locus = []
+      end
+
+      def processing?
+        @processor.started?
+      end
+
+      def clear_actions
+        @actions.clear
+      end
+
+      def add_action(sequence, action)
+        invalid_motion = sequence.find do |motion|
+          not @processor.available_motion?(motion)
+        end
+        raise InvalidMotionError.new(invalid_motion) if invalid_motion
+        @actions << [sequence, action]
+      end
+
+      def start(button, x, y, base_x, base_y)
+        @button = button
+        @processor.start(x, y)
+        @base_x = base_x
+        @base_y = base_y
+        @locus = [[x, y]]
+      end
+
+      def button_release(x, y, width, height)
+        perform_action
+      end
+
+      def button_motion(x, y, width, height)
+        new_x = @base_x + x
+        new_y = @base_y + y
+        @locus << [new_x, new_y]
+        @processor.update_position(new_x, new_y)
+      end
+
+      def draw_last_locus(renderer)
+        if @locus.size >= 2
+          x1, y1 = @locus[-2]
+          x2, y2 = @locus[-1]
+          args = [x1, y1, x2, y2, @line_color, {:line_width => @line_width}]
+          renderer.draw_line(*args)
+        end
+      end
+
+      def draw(renderer)
+        size = renderer.size
+        renderer.draw_rectangle(true,
+                                0, 0, size.real_width, size.real_height,
+                                @back_color)
+
+        draw_available_marks(renderer, next_available_motions)
+
+        act = action
+        draw_mark(renderer, act, *@processor.position) if act
+
+        draw_locus(renderer)
+      end
+
+      def draw_locus(renderer)
+        return if @locus.empty?
+        renderer.draw_lines(@locus, @line_color, {:line_width => @line_width})
+      end
+
+      def moved?
+        @locus.size >= 2
+      end
+
+      private
+      def perform_action
+        act = action
+        @processor.reset
+        @locus.clear
+        if act
+          act.trigger
+          true
+        else
+          false
+        end
+      end
+
+      def action
+        motions = @processor.motions
+        @actions.each do |sequence, act|
+          return act if sequence == motions and act.enabled?
+        end
+        nil
+      end
+
+      def available_motions
+        motions = @processor.motions
+        @actions.collect do |sequence, act|
+          if sequence == motions and act.enabled?
+            [sequence.last, act]
+          else
+            nil
+          end
+        end.compact.uniq
+      end
+
+      def next_available_motions
+        motions = @processor.motions
+        @actions.collect do |sequence, act|
+          if sequence[0..-2] == motions and act.enabled?
+            [sequence.last, act]
+          else
+            nil
+          end
+        end.compact.uniq
+      end
+
+      def match?
+        not action.nil?
+      end
+
+      def draw_mark(renderer, act, x=nil, y=nil, radius=nil)
+        x ||= @processor.position[0]
+        y ||= @processor.position[1]
+        radius ||= @processor.threshold / 2.0
+        renderer.draw_circle_by_radius(true, x, y, radius, @current_color)
+        draw_action_image(renderer, act, x, y)
+      end
+
+      def draw_action_image(renderer, act, x, y)
+        icon = act&.icon
+        if icon
+          if icon.respond_to?(:bytes)
+            loader = GdkPixbuf::PixbufLoader.new
+            loader.set_size(48, 48)
+            loader.last_write(icon.bytes.to_s)
+            pixbuf = loader.pixbuf
+          else
+            pixbuf = nil # Icon theme loading not available in Qt mode
+          end
+          x -= pixbuf.width / 2.0
+          y -= pixbuf.height / 2.0
+          renderer.draw_pixbuf(pixbuf, x, y)
+        elsif block_given?
+          yield
+        end
+      end
+
+      def draw_available_marks(renderer, infos)
+        infos.each do |motion, act|
+          args = [motion, %w(R), %w(L), %w(UR LR), %w(UL LL)]
+          adjust_x = calc_position_ratio(*args)
+          args = [motion, %w(D), %w(U), %w(LR LL), %w(UR UL)]
+          adjust_y = calc_position_ratio(*args)
+
+          threshold = @processor.threshold
+          x, y = @processor.position
+          center_x = x + threshold * adjust_x
+          center_y = y + threshold * adjust_y
+          draw_action_image(renderer, act, center_x, center_y) do
+            angle = @processor.skew_threshold_angle
+            base_angle = calc_position_angle(motion) - angle
+            args = [false, x, y, threshold, base_angle, angle * 2]
+            args.concat([@next_color, {:line_width => @next_width}])
+            renderer.draw_arc_by_radius(*args)
+          end
+        end
+      end
+
+      def calc_position_ratio(motion, inc, dec, inc_skew, dec_skew)
+        case motion
+        when *inc
+          1
+        when *inc_skew
+          1 / Math.sqrt(2)
+        when *dec
+          -1
+        when *dec_skew
+          -1 / Math.sqrt(2)
+        else
+          0
+        end
+      end
+
+      MOTION_TO_ANGLE = {
+        "R" => 0,
+        "UR" => 45,
+        "U" => 90,
+        "UL" => 135,
+        "L" => 180,
+        "LL" => 225,
+        "D" => 270,
+        "LR" => 315,
+      }
+      def calc_position_angle(motion)
+        MOTION_TO_ANGLE[motion]
+      end
+
+      def make_color(color)
+        color ||= @back_color
+        if color.is_a?(Renderer::Color)
+          color
+        else
+          Renderer::Color.parse(color)
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/gesture/processor.rb

@@ -0,0 +1,118 @@
+module Rabbit
+  module Gesture
+    class Processor
+      DEFAULT_THRESHOLD = 48
+      DEFAULT_SKEW_THRESHOLD_ANGLE = 90 / 4
+
+      attr_accessor :threshold, :skew_threshold_angle
+      attr_reader :motions
+
+      def initialize(threshold=nil, skew_threshold_angle=nil)
+        @threshold = threshold || DEFAULT_THRESHOLD
+        @skew_threshold_angle = skew_threshold_angle
+        @skew_threshold_angle ||= DEFAULT_SKEW_THRESHOLD_ANGLE
+        reset
+      end
+
+      def started?
+        @started
+      end
+
+      MOTIONS = %w(L R U D UL UR LL LR)
+
+      def available_motion?(motion)
+        MOTIONS.include?(motion)
+      end
+
+      def start(x, y)
+        @prev_x = @x = x
+        @prev_y = @y = y
+        @started = true
+        @motions = []
+      end
+
+      def update_position(x, y)
+        mx = x - @prev_x
+        my = y - @prev_y
+
+        motion = judge_motion(mx, my)
+        if motion
+          @prev_x = @x = x
+          @prev_y = @y = y
+          if @motions.last == motion
+            false
+          else
+            @motions << motion
+            true
+          end
+        else
+          false
+        end
+      end
+
+      def reset
+        @started = false
+        @x = @y = -1
+        @motions = []
+      end
+
+      def to_a
+        @motions
+      end
+
+      def position
+        [@x, @y]
+      end
+
+      private
+      def judge_motion(dx, dy)
+        dxa = dx.abs
+        dya = dy.abs
+        distance = Math.sqrt(dxa ** 2 + dya ** 2)
+        upper_theta = (45 + @skew_threshold_angle) * (Math::PI / 180.0)
+        lower_theta = (45 - @skew_threshold_angle) * (Math::PI / 180.0)
+        if distance > @threshold and
+            dya < Math.tan(upper_theta) * dxa and
+            dya > Math.tan(lower_theta) * dxa
+          judge_corner_motion(dx, dy)
+        elsif dxa > @threshold or dya > @threshold
+          judge_cross_motion(dx, dy)
+        else
+          nil
+        end
+      end
+
+      def judge_corner_motion(dx, dy)
+        if dx < 0
+          if dy < 0
+            "UL"
+          else
+            "LL"
+          end
+        else
+          if dy < 0
+            "UR"
+          else
+            "LR"
+          end
+        end
+      end
+
+      def judge_cross_motion(dx, dy)
+        if dx.abs > dy.abs
+          if dx < 0
+            "L"
+          else
+            "R"
+          end
+        else
+          if dy < 0
+            "U"
+          else
+            "D"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/gettext.rb

@@ -0,0 +1,14 @@
+require "gettext"
+
+module Rabbit
+  module GetText
+    DOMAIN = "rabbit"
+
+    class << self
+      def included(mod)
+        mod.send(:include, ::GetText)
+        mod.bindtextdomain(DOMAIN)
+      end
+    end
+  end
+end

data/lib/rabbit/graffiti/config-dialog.rb

@@ -0,0 +1,47 @@
+# Copyright (C) 2006-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "../qt"
+
+require_relative "../renderer/color"
+
+module Rabbit
+  module Graffiti
+    class ConfigDialog
+      include GetText
+
+      def initialize(color, line_width)
+        @original_color = color
+        @original_line_width = line_width
+      end
+
+      def run(&block)
+        @callback = block
+        qcolor = @original_color.to_qcolor
+        result_color = QColorDialog.get_color(qcolor)
+        if result_color.is_valid
+          r = result_color.red_f
+          g = result_color.green_f
+          b = result_color.blue_f
+          a = result_color.alpha_f
+          @callback.call(Renderer::Color.new(r, g, b, a), nil)
+        else
+          @callback.call(@original_color, @original_line_width)
+        end
+      end
+    end
+  end
+end

data/lib/rabbit/graffiti/processor.rb

@@ -0,0 +1,132 @@
+# Copyright (C) 2006-2025  Sutou Kouhei <kou@cozmixng.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+require_relative "../qt"
+
+require_relative "../renderer/engine"
+require_relative "config-dialog"
+
+module Rabbit
+  module Graffiti
+    class Processor
+      DEFAULT_COLOR = Renderer::Color.parse("black")
+      DEFAULT_LINE_WIDTH = 3
+
+      attr_accessor :color, :line_width
+      def initialize(default_config={})
+        @default_color = default_config["color"] || DEFAULT_COLOR
+        @default_line_width = default_config["line_width"] || DEFAULT_LINE_WIDTH
+        clear
+        clear_config
+      end
+
+      def have_graffiti?
+        not @segments.empty?
+      end
+
+      def can_undo?
+        not @undo_stack.empty?
+      end
+
+      def button_press(x, y, width, height)
+        @pressed = true
+        @undo_index = nil
+        @segments << [[x.to_f / width, y.to_f / height]]
+      end
+
+      def button_release(x, y, width, height)
+        @pressed = false
+        @undo_stack << [:push]
+      end
+
+      def button_motion(x, y, width, height)
+        if @pressed
+          @segments.last << [x.to_f / width, y.to_f / height]
+        end
+      end
+
+      def draw_last_segment(renderer)
+        points = @segments.last
+        if points.size >= 2
+          width = renderer.width
+          height = renderer.height
+          prev, current = points[-2..-1]
+          prev_x, prev_y = prev
+          x, y = current
+          renderer.draw_line(prev_x * width, prev_y * height,
+                             x * width, y * height,
+                             @color, {:line_width => @line_width})
+        end
+      end
+
+      def draw_all_segment(renderer)
+        return if @segments.empty?
+        args = [@color, {:line_width => @line_width, :opened => true}]
+        width = renderer.width
+        height = renderer.height
+        @segments.each do |points|
+          converted_points = points.collect do |x, y|
+            [x * width, y * height]
+          end
+          renderer.draw_lines(converted_points, *args)
+        end
+      end
+
+      def dragging?
+        @pressed
+      end
+
+      def clear
+        @pressed = false
+        @segments = []
+        @undo_stack = []
+        @undo_index = nil
+      end
+
+      def change_color(&block)
+        dialog = Graffiti::ConfigDialog.new(@color, @line_width)
+        dialog.run do |color, line_width|
+          @color = color if color
+          @line_width = line_width if line_width
+          block.call
+        end
+      end
+
+      def clear_config
+        @color = @default_color
+        @line_width = @default_line_width
+      end
+
+      def undo
+        @undo_index ||= @undo_stack.size - 1
+        command, segment = @undo_stack[@undo_index]
+        case command
+        when :push
+          @undo_stack << [:pop, @segments.pop]
+        when :pop
+          @segments << segment
+          @undo_stack << [:push]
+        end
+
+        if @undo_index > 0
+          @undo_index -= 1
+        else
+          @undo_index = nil
+        end
+      end
+    end
+  end
+end