ektoplayer 0.1.0

data/lib/ektoplayer/ui/colors.rb

@@ -0,0 +1,105 @@
+require 'curses'
+
+module UI
+   class ColorFader
+      def initialize(colors)
+         @colors = colors.map { |attrs| UI::Colors.set(nil, *attrs) }
+      end
+
+      def fade(size)   ColorFader._fade(@colors, size)   end
+      def fade2(size)  ColorFader._fade2(@colors, size)  end
+
+      def ColorFader._fade(colors, size)
+         return [] if size < 1
+
+         part_len = (size / colors.size)
+         diff = size - part_len * colors.size
+
+         (colors.size - 1).times.map do |color_i|
+            [colors[color_i]] * part_len
+         end.flatten.concat( [colors[-1]] * (part_len + diff) )
+      end
+
+      def ColorFader._fade2(colors, size)
+         half = size / 2
+         ColorFader._fade(colors, half) + ColorFader._fade(colors, size - half).reverse
+      end
+   end
+
+   class Colors
+      COLORS = {
+         none: -1, default: -1, nil => -1,
+         white:    Curses::COLOR_WHITE,
+         black:    Curses::COLOR_BLACK,
+         red:      Curses::COLOR_RED,
+         blue:     Curses::COLOR_BLUE,
+         cyan:     Curses::COLOR_CYAN,
+         green:    Curses::COLOR_GREEN,
+         yellow:   Curses::COLOR_YELLOW,
+         magenta:  Curses::COLOR_MAGENTA
+      }
+      COLORS.default_proc = proc do |h, key|
+         fail "Unknown color #{key}" unless key.is_a?Integer
+         key
+      end
+      COLORS.freeze
+
+      ATTRIBUTES = {
+         bold:  Curses::A_BOLD,  standout:  Curses::A_STANDOUT,
+         blink: Curses::A_BLINK, underline: Curses::A_UNDERLINE
+      }
+      ATTRIBUTES.default_proc = proc { |h,k| k }
+      ATTRIBUTES.freeze
+
+      def self.start
+         @@id           ||= 1
+         @@aliases      ||= {}
+         @@volatile     ||= {}
+         @@volatile_ids ||= {}
+         @@cached       ||= Hash.new { |h,k| h[k] = {} }
+      end
+      def self.reset; self.start end
+
+      def self.init_pair_cached(fg, bg)
+         fg, bg = COLORS[fg], COLORS[bg]
+
+         unless id = @@cached[fg][bg]
+            id = @@cached[fg][bg] = @@id
+            @@id += 1
+         end
+
+         Curses.init_pair(id, fg, bg) or fail
+         Curses.color_pair(id)
+      end
+
+      def self.add_attributes(*attrs)
+         flags = 0
+         attrs.each { |attr| flags |= ATTRIBUTES[attr] }
+         flags
+      end
+
+      def self.[](name)   @@aliases[name] || 0  end
+      def self.get(name)  @@aliases[name] || 0  end
+      
+      def self.set(name, fg, bg = -1, *attrs)
+         @@aliases[name] = self.init_pair_cached(fg, bg)
+         attrs.each { |attr| @@aliases[name] |= ATTRIBUTES[attr] }
+         @@aliases[name]
+      end
+
+      def self.get_volatile(name)
+         @@volatile[name] || 0
+      end
+
+      def self.set_volatile(name, fg, bg)
+         fg, bg = COLORS[fg], COLORS[bg]
+
+         unless id = @@volatile_ids[name]
+            id = @@volatile_ids[name] = @@id
+            @@id += 1
+         end
+
+         @@volatile[name] = Curses.init_pair(id, fg, bg)
+      end
+   end
+end

data/lib/ektoplayer/ui/widgets.rb

@@ -0,0 +1,195 @@
+module UI
+   class Widget
+      WANT_REFRESH, WANT_REDRAW, WANT_LAYOUT = 1, 2, 4
+
+      attr_reader  :pos, :size
+      def keys;            @keys   ||= Events.new                      end
+      def events;          @events ||= Events.new                      end
+      def mouse;           @mouse  ||= MouseEvents.new                 end
+      def mouse_section;   @mouse_section ||= MouseSectionEvents.new   end
+
+      def initialize(parent: nil, size: nil, pos: nil, visible: true)
+         if !parent and (!size or !pos)
+            fail ArgumentError, "must provide 'size:' and 'pos:' if 'parent:' is nil"
+         end
+
+         @parent, @visible, = parent, visible
+         @size = (size or @parent.size.dup)
+         @pos  = (pos  or @parent.pos.dup)
+         @want, @lock = WANT_LAYOUT, Monitor.new
+      end
+
+      # Proxy method for creating a new widget object with the current
+      # object as parent.
+      def sub(class_type, **opts)
+         class_type.new(parent: self, **opts)
+      end
+
+      # This method should be used each time a widget may modify
+      # its window contents.
+      #
+      # It ensures that operations that modify the window (such
+      # as draw, layout and refresh) are executed once and only once at the
+      # end of this function.
+      def with_lock
+         held_locks = lock; yield
+      ensure
+         unlock
+      end
+
+      def lock
+         @lock.enter
+      end
+
+      def unlock
+         return unless (@lock.exit rescue nil) or not visible?
+
+         layout   if @want >= WANT_LAYOUT
+         draw     if @want >= WANT_REDRAW
+         if @want >= WANT_REFRESH
+            Canvas.update_screen
+         end
+
+         @want = 0
+      end
+
+      def display(force_refresh=false, force_redraw=false)
+         return   if not visible?
+         layout   if @want >= WANT_LAYOUT
+         draw     if @want >= WANT_REDRAW or force_redraw
+         refresh  if @want >= WANT_REFRESH or force_refresh
+      end
+
+      def want_redraw;  @want |= WANT_REDRAW   end
+      def want_layout;  @want |= WANT_LAYOUT   end
+      def want_refresh; @want |= WANT_REFRESH  end
+
+      def invisible?;  !visible?                                     end
+      def visible!;    self.visible=(true)                           end
+      def invisible!;  self.visible=(false)                          end
+      def visible?;    @visible and (!@parent or @parent.visible?)   end
+
+      def visible=(new)
+         return if @visible == new
+         with_lock { @visible = new; want_refresh }
+      end
+
+      def size=(size)
+         return if @size == size
+         with_lock { @size = size; want_layout }
+      end
+
+      def pos=(pos)
+         return if @pos == pos
+         with_lock { @pos = pos; want_layout }
+      end
+
+      def mouse_event_transform(mevent)
+         if mevent.y >= @pos.y and mevent.x >= @pos.x and
+               mevent.y < (@pos.y + @size.height) and
+               mevent.x < (@pos.x + @size.width)
+            new_mouse = mevent.to_fake
+            new_mouse.update!(y: mevent.y - @pos.y, x: mevent.x - @pos.x)
+            new_mouse
+         end
+      end
+
+      def key_press(key)        on_key_press(key)         end
+      def raise_widget(widget)  on_widget_raise(widget)   end
+      def on_key_press(key)     trigger(@keys, key)       end
+
+      def mouse_click(mevent)
+         if new_event = mouse_event_transform(mevent)
+            trigger(@mouse, new_event)
+            trigger(@mouse_event, new_event)
+         end
+      end
+
+      def draw;     fail NotImplementedError  end
+      def refresh;  fail NotImplementedError  end
+      def layout;   fail NotImplementedError  end
+
+      protected def trigger(event_obj, event_name, *event_args)
+         event_obj.trigger(event_name, *event_args) if event_obj
+      end
+
+      def on_widget_raise(widget)
+         fail 'unhandled widget raise' unless @parent
+         @parent.raise_widget(widget)
+      end
+   end
+
+   class Window < Widget
+      attr_reader :win
+
+      def initialize(**opts)
+         super(**opts)
+         @win = Curses::Window.new(@size.height, @size.width, @pos.y, @pos.x)
+         @win.keypad=(true)
+      end
+
+      def layout
+         fail WidgetSizeError if @size.height < 1 or @size.width < 1
+         @win.size=(@size)
+         @win.pos=(@pos)
+      end
+
+      def refresh
+         @win.noutrefresh
+      end
+   end
+
+   class Pad < Widget
+      attr_reader :win
+
+      def initialize(**opts)
+         super(**opts)
+         @win = Curses::Pad.new(@size.height, @size.width)
+         @pad_minrow = @pad_mincol = 0
+      end
+
+      def pad_minrow=(n)
+         return if @pad_minrow == n
+         with_lock { @pad_minrow = n; want_refresh }
+      end
+
+      def pad_mincol=(n)
+         return if @pad_mincol == n
+         with_lock { @pad_mincol = n; want_refresh }
+      end
+
+      def pad_size=(s)
+         @win.size=(s)
+      end
+
+      def layout
+         @win.pos=(@pos)
+      end
+
+      def top;         self.pad_minrow=(0)                 end
+      def page_up;     self.up(@size.height / 2)           end
+      def page_down;   self.down(@size.height / 2)         end
+
+      def bottom
+         self.pad_minrow=(@win.height - @size.height)
+      end
+
+      def up(n=1)
+         new_minrow = (@pad_minrow - n).clamp(0, @win.height)
+         self.pad_minrow=(new_minrow)
+      end
+
+      def down(n=1)
+         new_minrow = (@pad_minrow + n).clamp(0, (@win.height - @size.height)) rescue 0
+         self.pad_minrow=(new_minrow)
+      end
+
+      def refresh
+         @win.noutrefresh(
+            @pad_minrow, @pad_mincol,
+            @pos.y, @pos.x,
+            @pos.y + @size.height - 1, @pos.x + @size.width - 1
+         )
+      end
+   end
+end

data/lib/ektoplayer/ui/widgets/container.rb

@@ -0,0 +1,125 @@
+require_relative '../widgets'
+
+module UI
+   class GenericContainer < Widget
+      attr_reader :selected, :selected_index, :widgets
+
+      def initialize(widgets: [], **opts)
+         super(**opts)
+         @selected, @selected_index, @widgets = nil, nil, widgets
+      end
+
+      def visible_widgets
+         @widgets.select(&:visible?)
+      end
+
+      def selected_index=(index)
+         return if @selected_index == index
+
+         with_lock do
+            if index
+               unless @selected = @widgets[index]
+                  fail KeyError, "#{self.class}: #{@widgets.size} #{index}"
+               end
+            end
+
+            @selected_index = index
+            want_layout
+         end
+      end
+
+      def selected=(widget)
+         return if @selected.equal?(widget)
+
+         with_lock do
+            if widget
+               unless @selected_index = @widgets.index(widget)
+                  fail KeyError
+               end
+            end
+
+            @selected = widget
+            want_layout
+         end
+      end
+
+      def win
+         (@selected or UI::Canvas).win
+      end
+
+      def add(widget)
+         with_lock do
+            @widgets << widget
+            self.selected=(widget) unless @selected
+            want_layout # important: layout, not redraw
+         end
+      end
+
+      def remove(widget)
+         with_lock do
+            self.selected=(nil) if @selected.equal?(widget)
+            @widgets.delete widget
+            want_layout # important: layout, not redraw
+         end
+      end
+
+      def mouse_click(mevent)
+         visible_widgets.each { |w| w.mouse_click(mevent) }
+         super(mevent)
+      end
+
+      def draw;     visible_widgets.each(&:draw)     end
+      def refresh;  visible_widgets.each(&:refresh)  end
+      def layout;   visible_widgets.each(&:layout)   end
+
+      def on_key_press(key)
+         @selected.key_press(key) if @selected
+         super(key)
+      end
+
+      def next
+         return unless @selected
+         self.selected_index=((@selected_index + 1) % @widgets.size)
+      end
+
+      def prev
+         return unless @selected
+         return self.selected_index=(@widgets.size - 1) if @selected_index == 0
+         self.selected_index=(@selected_index - 1)
+      end
+   end
+
+   class HorizontalContainer < GenericContainer
+      def layout
+         xoff = 0
+         visible_widgets.each do |widget|
+            widget.with_lock do
+               fail WidgetSizeError if xoff + widget.size.width > @size.width
+               widget.size=(widget.size.update(height: @size.height))
+               widget.pos=(@pos.calc(x: xoff))
+               fail WidgetSizeError if widget.size.height > @size.height
+               xoff += (widget.size.width + (@pad or 0))
+            end
+         end
+
+         super
+      end
+   end
+
+   class VerticalContainer < GenericContainer
+      def layout
+         yoff = 0
+         visible_widgets.each do |widget|
+            widget.with_lock do
+               widget.size=(widget.size.update(width: @size.width))
+               widget.pos=(@pos.calc(y: yoff))
+               fail WidgetSizeError if widget.size.width > @size.width
+               fail WidgetSizeError if yoff + widget.size.height > @size.height
+               yoff += widget.size.height
+            end
+         end
+
+         super
+      end
+   end
+end

data/lib/ektoplayer/ui/widgets/labelwidget.rb

@@ -0,0 +1,43 @@
+require_relative '../widgets'
+
+module UI
+   class LabelWidget < Window
+      attr_reader :text, :pad, :attributes
+
+      def initialize(text: '', attributes: 0, pad: {}, **opts)
+         super(**opts)
+         @text, @attributes, @pad = text.to_s, attributes, Hash.new(0)
+         @pad.update pad
+      end
+
+      def attributes=(new)
+         return if @attributes == new
+         with_lock { @attributes = new; want_redraw }
+      end
+
+      def text=(new)
+         return if @text == new
+         with_lock { @text = new.to_s; want_redraw }
+      end
+
+      def pad=(new)
+         return if @pad == new
+         with_lock { @pad.update!(new); want_redraw }
+      end
+
+      def draw
+         @win.erase
+         @text.split(?\n).each_with_index do |l, i|
+            @win.setpos(@pad[:top] + i, @pad[:left])
+            @win.attron(@attributes) { @win << l }
+         end
+      end
+
+      def fit
+         self.size=(Size.new(
+            height: @pad[:top] + @pad[:bottom] + 1 + @text.count(?\n),
+            width:  @pad[:left] + @pad[:right] + @text.split(?\n).max.size
+         ))
+      end
+   end
+end