lacci 0.2.1 → 0.3.0

data/lib/scarpe/libui/para.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  SIZES = {
-    inscription: 10,
-    ins: 10,
-    para: 12,
-    caption: 14,
-    tagline: 18,
-    subtitle: 26,
-    title: 34,
-    banner: 48,
-  }.freeze
-  class << self
-    # Sure we can showcase the defaults here so folks can avoid the insanity.
-    def para(text, size: 12.0, stroke: black, weight: nil, fill: nil, underline: nil, italic: nil)
-      Para.new(
-        text,
-        size: size,
-        stroke: stroke,
-        weight: weight,
-        fill: fill,
-        underline: underline,
-        italic: italic,
-      )
-    end
-  end
-
-  class Para
-    def initialize(text, size:, stroke:, weight:, fill:, underline:, italic:)
-      # old flow for label
-      # UI.box_append($vbox, UI.new_label(text), 0)
-      @handler = UI::FFI::AreaHandler.malloc
-      @handler.to_ptr.free = Fiddle::RUBY_FREE
-      @area = UI.new_area(@handler)
-
-      str = ""
-      @attr_str = UI.new_attributed_string(str)
-
-      font_weight = case weight
-      when "ultralight"
-        UI::TextWeightUltraLight
-      when "light"
-        UI::TextWeightLight
-      when "book"
-        UI::TextWeightBook
-      when "strong"
-        UI::TextWeightBold
-      when "bold"
-        UI::TextWeightBold
-      when "ultrabold"
-        UI::TextWeightUltraBold
-      else
-        nil
-      end
-      stroke2 = stroke.dup
-      attr_builder = []
-      attr_builder << UI.new_weight_attribute(font_weight) if font_weight
-      attr_builder << UI.new_size_attribute(size) if size
-      attr_builder << UI.new_color_attribute(
-        stroke[0].to_f / 255.0, stroke[1].to_f / 255.0, stroke[2].to_f / 255.0, stroke[3].to_f || 1.0
-      ) if stroke
-      attr_builder << UI.new_background_attribute(
-        fill[0].to_f / 255.0, fill[1].to_f / 255.0, fill[2].to_f / 255.0, fill[3].to_f || 1.0
-      ) if fill
-      attr_builder << UI.new_underline_attribute(UI::UnderlineSingle) if underline == "single"
-      attr_builder << UI.new_underline_attribute(UI::UnderlineDouble) if underline == "double"
-      # NOTE- this is a boolean, not a string. and not part of core scarpe api. we set this internally.
-      attr_builder << UI.new_italic_attribute(UI::TextItalicNormal) if italic == true
-      attr_builder << UI.new_italic_attribute(UI::TextItalicItalic) if italic == "double"
-      attr_builder << UI.new_underline_color_attribute(
-        UI::UnderlineColorCustom,
-        stroke2[0].to_f / 255.0,
-        stroke2[1].to_f / 255.0,
-        stroke2[2].to_f / 255.0,
-        stroke2[3].to_f || 1.0,
-      ) if underline == "single" && stroke
-      # # UI.new_stretch_attribute(UI::TextStretchCondensed),stretch not implemented
-      append_with_attribute(
-        text,
-        *attr_builder,
-      )
-      attach_text
-    end
-
-    private
-
-    def draw_text
-      Fiddle::Closure::BlockCaller.new(0, [1, 1, 1]) do |_, _, adp|
-        area_draw_params = UI::FFI::AreaDrawParams.new(adp)
-        default_font = UI::FFI::FontDescriptor.malloc
-        default_font.to_ptr.free = Fiddle::RUBY_FREE
-        default_font.Family = "Georgia"
-        default_font.Size = 13
-        # default_font.Weight = 500
-        default_font.Italic = 0
-        default_font.Stretch = 4
-        params = UI::FFI::DrawTextLayoutParams.malloc
-        params.to_ptr.free = Fiddle::RUBY_FREE
-
-        # UI.font_button_font(font_button, default_font)
-        params.String = @attr_str
-        params.DefaultFont = default_font
-        params.Width = area_draw_params.AreaWidth
-        params.Align = 0
-        text_layout = UI.draw_new_text_layout(params)
-        UI.draw_text(area_draw_params.Context, text_layout, 0, 0)
-        UI.draw_free_text_layout(text_layout)
-      end
-    end
-
-    def attach_text
-      @handler.Draw = draw_text
-
-      # Assigning to local variables
-      # This is intended to protect Fiddle::Closure from garbage collection.
-      do_nothing = Fiddle::Closure::BlockCaller.new(0, [0]) {}
-      key_event  = Fiddle::Closure::BlockCaller.new(1, [0]) { 0 }
-      @handler.MouseEvent   = do_nothing
-      @handler.MouseCrossed = do_nothing
-      @handler.DragBroken   = do_nothing
-      @handler.KeyEvent     = key_event
-
-      # do i shove it in vbox or para_box?
-      # @para_box = UI.new_vertical_box
-      # UI.box_set_padded(@para_box, 1)
-      # debugger
-      hbox = $parent_box ? $parent_box : $vbox
-      UI.box_append(hbox, @area, 1)
-
-      # I have absolutely no idea what is going on with boxes so need to look into this next
-      # probably with stacks and flows
-      # UI.window_set_margined($main_window, 1)
-      # if $parent_box
-      # UI.window_set_child($main_window, hbox)
-      # else
-      #   UI.window_set_child($main_window, $vbox)
-      # end
-    end
-
-    def append_with_attribute(what, *args)
-      start_pos = UI.attributed_string_len(@attr_str)
-      end_pos = start_pos + what.length
-      UI.attributed_string_append_unattributed(@attr_str, what)
-      args.each do |attr|
-        # puts "*" * 80
-        # puts "attr: #{attr}"
-        # puts "*" * 80
-        # sleep 1
-        UI.attributed_string_set_attribute(@attr_str, attr, start_pos, end_pos)
-      end
-    end
-  end
-end

data/lib/scarpe/libui/stack.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  def parent_caller
-    caller[0].match(/`(.*)'/)[1]
-  end
-
-  def all_callers
-    caller.map { |x| x.match(/`(.*)'/)[1] if self.respond_to? x.match(/`(.*)'/)[1].to_sym }.compact
-  end
-
-  def caller_key
-    caller[0].hash
-  end
-end
-
-def global_stack
-  @global_stack ||= {}
-end
-
-class Scarpe
-  # STARTING SINGLY, APPENDING TO TOP LEVEL BOX. later will do nested
-  class << self
-    # Width means nothing right now, but we'll get there
-    def stack(width: 1.0)
-      hbox = UI.new_horizontal_box
-      old_parent = $parent_box ? $parent_box : $vbox
-      $parent_box = hbox
-      yield
-      UI.box_append(old_parent, hbox, 1)
-      $parent_box = nil
-    end
-  end
-end

data/lib/scarpe/line.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "wv/shape_helper"
-
-class Scarpe
-  class Line < Shoes::Widget
-    include ShapeHelper
-
-    display_properties :left, :top, :x2, :y2, :color
-
-    def initialize(left, top, x2, y2)
-      validate_coordinates(x2, y2)
-      @left = left
-      @top = top
-      @x2 = x2
-      @y2 = y2
-      @color = color_for_fill
-
-      # validate_coordinates(x2, y2)
-
-      super()
-      create_display_widget
-    end
-  end
-end

data/lib/scarpe/link.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  class Link < Shoes::TextWidget
-    display_properties :text, :click, :has_block
-
-    def initialize(text, click: nil, &block)
-      @text = text
-      @block = block
-      # We can't send a block to the display widget, but we can send a boolean
-      @has_block = !block.nil?
-
-      super
-
-      # The click property should be changed before it gets sent to the display widget
-      @click ||= "#"
-
-      bind_self_event("click") do
-        @block&.call
-      end
-
-      create_display_widget
-    end
-  end
-end

data/lib/scarpe/list_box.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  class ListBox < Shoes::Widget
-    display_properties :selected_item, :items, :height, :width
-
-    def initialize(args = {}, &block)
-      @items = args[:items] || []
-      @selected_item = args[:selected_item]
-      super()
-
-      bind_self_event("change") do |new_item|
-        self.selected_item = new_item
-        @callback&.call(new_item)
-      end
-
-      create_display_widget
-    end
-
-    def change(&block)
-      @callback = block
-      self # Allow chaining calls
-    end
-  end
-end

data/lib/scarpe/logger.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-require "logging"
-require "json"
-
-class Scarpe
-  LOG_LEVELS = [:debug, :info, :warning, :error, :fatal].freeze
-
-  # Include this module to get a @log instance variable to log as your
-  # configured component.
-  module Log
-    DEFAULT_LOG_CONFIG = {
-      "default" => "info",
-    }
-    DEFAULT_DEBUG_LOG_CONFIG = {
-      "default" => "debug",
-    }
-
-    def log_init(component = self)
-      @log = Logging.logger[component]
-    end
-  end
-
-  class Logger
-    DEFAULT_COMPONENT = "default"
-
-    class << self
-      attr_reader :current_log_config
-
-      def logger(component = self)
-        Logging.logger[component]
-      end
-
-      private
-
-      def name_to_severity(data)
-        case data
-        when "debug"
-          :debug
-        when "info"
-          :info
-        when "warn", "warning"
-          :warn
-        when "err", "error"
-          :error
-        when "fatal"
-          :fatal
-        else
-          raise "Don't know how to treat #{data.inspect} as a logger severity!"
-        end
-      end
-
-      def json_to_appender(data)
-        case data.downcase
-        when "stdout"
-          Logging.appenders.stdout layout: @custom_log_layout
-        when "stderr"
-          Logging.appenders.stderr layout: @custom_log_layout
-        when String
-          Logging.appenders.file data, layout: @custom_log_layout
-        else
-          raise "Don't know how to convert #{data.inspect} to an appender!"
-        end
-      end
-
-      def json_configure_logger(logger, data)
-        case data
-        in String
-          sev = name_to_severity(data)
-          logger.level = sev
-        in [level, *locations]
-          if logger.name != "root"
-            # The Logging gem doesn't have an additive property on the root logger
-            logger.additive = false # Don't also log to parent/root loggers
-          end
-
-          logger.appenders = locations.map { |where| json_to_appender(where) }
-
-          logger.level = name_to_severity(level)
-        else
-          raise "Don't know how to use #{data.inspect} to specify a logger!"
-        end
-      end
-
-      def freeze_log_config(log_config)
-        log_config.each do |k, v|
-          k.freeze
-          v.freeze
-          v.each(&:freeze) if v.is_a?(Array)
-        end
-        log_config.freeze
-      end
-
-      public
-
-      def configure_logger(log_config)
-        # TODO: custom coloring? https://github.com/TwP/logging/blob/master/examples/colorization.rb
-        @custom_log_layout = Logging.layouts.pattern pattern: '[%r] %-5l %c: %m\n'
-
-        if log_config.is_a?(String) && File.exist?(log_config)
-          log_config = JSON.load_file(log_config)
-        end
-
-        log_config = freeze_log_config(log_config) unless log_config.nil?
-        @current_log_config = log_config # Save a copy for later
-
-        Logging.reset # Reset all Logging settings to defaults
-        Logging.reopen # For log-reconfig (e.g. test failures), often important to *not* store an open handle to a moved file
-        return if log_config.nil?
-
-        Logging.logger.root.appenders = [Logging.appenders.stdout]
-
-        default_logger = log_config[DEFAULT_COMPONENT] || "info"
-        json_configure_logger(Logging.logger.root, default_logger)
-
-        log_config.each do |component, logger_data|
-          next if component == DEFAULT_COMPONENT
-
-          sublogger = Logging.logger[component]
-          json_configure_logger(sublogger, logger_data)
-        end
-      end
-    end
-  end
-
-  class LoggedWrapper
-    include ::Scarpe::Log
-    def initialize(instance, component = instance)
-      log_init(component)
-
-      @instance = instance
-    end
-
-    def method_missing(method, ...)
-      self.singleton_class.define_method(method) do |*args, **kwargs, &block|
-        ret = @instance.send(method, *args, **kwargs, &block)
-        @log.info("Method: #{method} Args: #{args.inspect} KWargs: #{kwargs.inspect} Block: #{block ? "y" : "n"} Return: #{ret.inspect}")
-        ret
-      end
-      send(method, ...)
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      @instance.respond_to_missing?(method_name, include_private)
-    end
-  end
-end
-
-class Logging::Logger
-  alias_method :warning, :warn
-end
-
-log_config = if ENV["SCARPE_LOG_CONFIG"]
-  JSON.load_file(ENV["SCARPE_LOG_CONFIG"])
-else
-  ENV["SCARPE_DEBUG"] ? Scarpe::Log::DEFAULT_DEBUG_LOG_CONFIG : Scarpe::Log::DEFAULT_LOG_CONFIG
-end
-
-Scarpe::Logger.configure_logger(log_config)

data/lib/scarpe/para.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-class Scarpe
-  class Para < Shoes::Widget
-    class << self
-      def inherited(subclass)
-        Scarpe::Widget.widget_classes ||= []
-        Scarpe::Widget.widget_classes << subclass
-        super
-      end
-    end
-
-    display_properties :text_items, :stroke, :size, :font, :html_attributes, :hidden
-
-    def initialize(*args, stroke: nil, size: :para, font: nil, hidden: false, **html_attributes)
-      @text_children = args || []
-      if hidden
-        @hidden_text_items = text_children_to_items(@text_children)
-        @text_items = []
-      else
-        # Text_children alternates strings and TextWidgets, so we can't just pass
-        # it as a display property. It won't serialize.
-        @text_items = text_children_to_items(@text_children)
-        @hidden_text_items = []
-      end
-      stroke = to_rgb(stroke)
-
-      @html_attributes = html_attributes || {}
-
-      super
-
-      create_display_widget
-    end
-
-    def text_children_to_items(text_children)
-      text_children.map { |arg| arg.is_a?(String) ? arg : arg.linkable_id }
-    end
-
-    def replace(*children)
-      @text_children = children
-
-      # This should signal the display widget to change
-      self.text_items = text_children_to_items(@text_children)
-    end
-
-    def hide
-      # idempotent
-      return unless @hidden_text_items.empty?
-
-      @hidden_text_items = self.text_items
-      self.text_items = []
-    end
-
-    def show
-      # idempotent
-      return unless self.text_items.empty?
-
-      self.text_items = @hidden_text_items
-      @hidden_text_items = []
-    end
-  end
-end
-
-module Shoes
-  class Widget
-    def banner(*args, **kwargs)
-      para(*args, **{ size: :banner }.merge(kwargs))
-    end
-
-    def title(*args, **kwargs)
-      para(*args, **{ size: :title }.merge(kwargs))
-    end
-
-    def subtitle(*args, **kwargs)
-      para(*args, **{ size: :subtitle }.merge(kwargs))
-    end
-
-    def tagline(*args, **kwargs)
-      para(*args, **{ size: :tagline }.merge(kwargs))
-    end
-
-    def caption(*args, **kwargs)
-      para(*args, **{ size: :caption }.merge(kwargs))
-    end
-
-    def inscription(*args, **kwargs)
-      para(*args, **{ size: :inscription }.merge(kwargs))
-    end
-
-    alias_method :ins, :inscription
-  end
-end