rndk 0.0.1

data/lib/rndk/core/display.rb

@@ -0,0 +1,63 @@
+module RNDK
+  module Display
+    # Given a string, returns the equivalent display type
+    def Display.char2DisplayType(string)
+      table = {
+        "CHAR"     => :CHAR,
+        "HCHAR"    => :HCHAR,
+        "INT"      => :INT,
+        "HINT"     => :HINT,
+        "UCHAR"    => :UCHAR,
+        "LCHAR"    => :LCHAR,
+        "UHCHAR"   => :UHCHAR,
+        "LHCHAR"   => :LHCHAR,
+        "MIXED"    => :MIXED,
+        "HMIXED"   => :HMIXED,
+        "UMIXED"   => :UMIXED,
+        "LMIXED"   => :LMIXED,
+        "UHMIXED"  => :UHMIXED,
+        "LHMIXED"  => :LHMIXED,
+        "VIEWONLY" => :VIEWONLY,
+        0          => :INVALID
+      }
+
+      if table.include?(string)
+        table[string]
+      else
+        :INVALID
+      end
+    end
+
+    # Tell if a display type is "hidden"
+    def Display.isHiddenDisplayType(type)
+      case type
+      when :HCHAR, :HINT, :HMIXED, :LHCHAR, :LHMIXED, :UHCHAR, :UHMIXED
+        true
+      when :CHAR, :INT, :INVALID, :LCHAR, :LMIXED, :MIXED, :UCHAR,
+          :UMIXED, :VIEWONLY
+        false
+      end
+    end
+
+    # Given a character input, check if it is allowed by the display type
+    # and return the character to apply to the display, or ERR if not
+    def Display.filterByDisplayType(type, input)
+      result = input
+      if !RNDK.isChar(input)
+        result = Ncurses::ERR
+      elsif [:INT, :HINT].include?(type) && !RNDK.digit?(result.chr)
+        result = Ncurses::ERR
+      elsif [:CHAR, :UCHAR, :LCHAR, :UHCHAR, :LHCHAR].include?(type) && RNDK.digit?(result.chr)
+        result = Ncurses::ERR
+      elsif type == :VIEWONLY
+        result = ERR
+      elsif [:UCHAR, :UHCHAR, :UMIXED, :UHMIXED].include?(type) && RNDK.alpha?(result.chr)
+        result = result.chr.upcase.ord
+      elsif [:LCHAR, :LHCHAR, :LMIXED, :LHMIXED].include?(type) && RNDK.alpha?(result.chr)
+        result = result.chr.downcase.ord
+      end
+
+      return result
+    end
+  end
+end

data/lib/rndk/core/draw.rb

@@ -0,0 +1,238 @@
+module RNDK
+  module Draw
+    # This sets up a basic set of color pairs. These can be redefined if wanted
+    def Draw.initRNDKColor
+      color = [Ncurses::COLOR_WHITE,
+               Ncurses::COLOR_RED,
+               Ncurses::COLOR_GREEN,
+               Ncurses::COLOR_YELLOW,
+               Ncurses::COLOR_BLUE,
+               Ncurses::COLOR_MAGENTA,
+               Ncurses::COLOR_CYAN,
+               Ncurses::COLOR_BLACK]
+      pair = 1
+
+      if Ncurses.has_colors
+        # XXX: Only checks if terminal has colours not if colours are started
+        Ncurses.start_color
+        limit = if Ncurses.COLORS < 8 then Ncurses.COLORS else 8 end
+
+        # Create the color pairs
+        (0...limit).each do |fg|
+          (0...limit).each do |bg|
+            Ncurses.init_pair(pair, color[fg], color[bg])
+            pair += 1
+          end
+        end
+      end
+    end
+
+    # This prints out a box around a window with attributes
+    def Draw.boxWindow(window, attr)
+      tlx = 0
+      tly = 0
+      brx = Ncurses.getmaxx(window) - 1
+      bry = Ncurses.getmaxy(window) - 1
+
+      # Draw horizontal lines.
+      Ncurses.mvwhline(window, tly, 0, Ncurses::ACS_HLINE | attr, Ncurses.getmaxx(window))
+      Ncurses.mvwhline(window, bry, 0, Ncurses::ACS_HLINE | attr, Ncurses.getmaxx(window))
+
+      # Draw horizontal lines.
+      Ncurses.mvwvline(window, 0, tlx, Ncurses::ACS_VLINE | attr, Ncurses.getmaxy(window))
+      Ncurses.mvwvline(window, 0, brx, Ncurses::ACS_VLINE | attr, Ncurses.getmaxy(window))
+
+      # Draw in the corners.
+      Ncurses.mvwaddch(window, tly, tlx, Ncurses::ACS_ULCORNER | attr)
+      Ncurses.mvwaddch(window, tly, brx, Ncurses::ACS_URCORNER | attr)
+      Ncurses.mvwaddch(window, bry, tlx, Ncurses::ACS_LLCORNER | attr)
+      Ncurses.mvwaddch(window, bry, brx, Ncurses::ACS_LRCORNER | attr)
+      Ncurses.wrefresh(window)
+    end
+
+    # This draws a box with attributes and lets the user define each
+    # element of the box
+    def Draw.attrbox(win, tlc, trc, blc, brc, horz, vert, attr)
+      x1 = 0
+      y1 = 0
+      y2 = Ncurses.getmaxy(win) - 1
+      x2 = Ncurses.getmaxx(win) - 1
+      count = 0
+
+      # Draw horizontal lines
+      if horz != 0
+        Ncurses.mvwhline(win, y1, 0, horz | attr, Ncurses.getmaxx(win))
+        Ncurses.mvwhline(win, y2, 0, horz | attr, Ncurses.getmaxx(win))
+        count += 1
+      end
+
+      # Draw vertical lines
+      if vert != 0
+        Ncurses.mvwvline(win, 0, x1, vert | attr, Ncurses.getmaxy(win))
+        Ncurses.mvwvline(win, 0, x2, vert | attr, Ncurses.getmaxy(win))
+        count += 1
+      end
+
+      # Draw in the corners.
+      if tlc != 0
+        Ncurses.mvwaddch(win, y1, x1, tlc | attr)
+        count += 1
+      end
+      if trc != 0
+        Ncurses.mvwaddch(win, y1, x2, trc | attr)
+        count += 1
+      end
+      if blc != 0
+        Ncurses.mvwaddch(win, y2, x1, blc | attr)
+        count += 1
+      end
+      if brc != 0
+        Ncurses.mvwaddch(win, y2, x2, brc | attr)
+        count += 1
+      end
+      if count != 0
+        Ncurses.wrefresh win
+      end
+    end
+
+    # Draw a box around the given window using the object's defined
+    # line-drawing characters
+    def Draw.drawObjBox(win, object)
+      Draw.attrbox(win,
+          object.ULChar, object.URChar, object.LLChar, object.LRChar,
+          object.HZChar, object.VTChar, object.BXAttr)
+    end
+
+    # This draws a line on the given window. (odd angle lines not working yet)
+    def Draw.drawLine(window, startx, starty, endx, endy, line)
+      xdiff = endx - startx
+      ydiff = endy - starty
+      x = 0
+      y = 0
+
+      # Determine if we're drawing a horizontal or vertical line.
+      if ydiff == 0
+        if xdiff > 0
+          Ncurses.mvwhline(window, starty, startx, line, xdiff)
+        end
+      elsif xdiff == 0
+        if ydiff > 0
+          Ncurses.mvwvline(window, starty, startx, line, ydiff)
+        end
+      else
+        # We need to determine the angle of the line.
+        height = xdiff
+        width = ydiff
+        xratio = if height > width then 1 else width / height end
+        yration = if width > height then width / height else 1 end
+        xadj = 0
+        yadj = 0
+
+        # Set the vars
+        x = startx
+        y = starty
+        while x!= endx && y != endy
+          # Add the char to the window
+          Ncurses.mvwaddch(window, y, x, line)
+
+          # Make the x and y adjustments.
+          if xadj != xratio
+            x = if xdiff < 0 then x - 1 else x + 1 end
+            xadj += 1
+          else
+            xadj = 0
+          end
+          if yadj != yratio
+            y = if ydiff < 0 then y - 1 else y + 1 end
+            yadj += 1
+          else
+            yadj = 0
+          end
+        end
+      end
+    end
+
+    # This draws a shadow around a window.
+    def Draw.drawShadow(shadow_win)
+      unless shadow_win.nil?
+        x_hi = Ncurses.getmaxx(shadow_win) - 1
+        y_hi = Ncurses.getmaxy(shadow_win) - 1
+
+        # Draw the line on the bottom.
+        Ncurses.mvwhline(shadow_win, y_hi, 1, Ncurses::ACS_HLINE | Ncurses::A_DIM, x_hi)
+
+        # Draw the line on teh right.
+        Ncurses.mvwvline(shadow_win, 0, x_hi, Ncurses::ACS_VLINE | Ncurses::A_DIM, y_hi)
+
+        Ncurses.mvwaddch(shadow_win, 0, x_hi, Ncurses::ACS_URCORNER | Ncurses::A_DIM)
+        Ncurses.mvwaddch(shadow_win, y_hi, 0, Ncurses::ACS_LLCORNER | Ncurses::A_DIM)
+        Ncurses.mvwaddch(shadow_win, y_hi, x_hi, Ncurses::ACS_LRCORNER | Ncurses::A_DIM)
+        Ncurses.wrefresh shadow_win
+      end
+    end
+
+    # Write a string of blanks using writeChar()
+    def Draw.writeBlanks(window, xpos, ypos, align, start, endn)
+      if start < endn
+        want = (endn - start) + 1000
+        blanks = ''
+
+        RNDK.cleanChar(blanks, want - 1, ' ')
+        Draw.writeChar(window, xpos, ypos, blanks, align, start, endn)
+      end
+    end
+
+    # This writes out a char string with no attributes
+    def Draw.writeChar(window, xpos, ypos, string, align, start, endn)
+      Draw.writeCharAttrib(window, xpos, ypos, string, Ncurses::A_NORMAL,
+          align, start, endn)
+    end
+
+    # This writes out a char string with attributes
+    def Draw.writeCharAttrib(window, xpos, ypos, string, attr, align,
+        start, endn)
+      display = endn - start
+
+      if align == RNDK::HORIZONTAL
+        # Draw the message on a horizontal axis
+        display = [display, Ncurses.getmaxx(window) - 1].min
+        (0...display).each do |x|
+          Ncurses.mvwaddch(window, ypos, xpos + x, string[x + start].ord | attr)
+        end
+      else
+        # Draw the message on a vertical axis
+        display = [display, Ncurses.getmaxy(window) - 1].min
+        (0...display).each do |x|
+          Ncurses.mvwaddch(window, ypos + x, xpos, string[x + start].ord | attr)
+        end
+      end
+    end
+
+    # This writes out a chtype string
+    def Draw.writeChtype (window, xpos, ypos, string, align, start, endn)
+      Draw.writeChtypeAttrib(window, xpos, ypos, string, Ncurses::A_NORMAL,
+          align, start, endn)
+    end
+
+    # This writes out a chtype string with the given attributes added.
+    def Draw.writeChtypeAttrib(window, xpos, ypos, string, attr,
+        align, start, endn)
+      diff = endn - start
+      display = 0
+      x = 0
+      if align == RNDK::HORIZONTAL
+        # Draw the message on a horizontal axis.
+        display = [diff, Ncurses.getmaxx(window) - xpos].min
+        (0...display).each do |x|
+          Ncurses.mvwaddch(window, ypos, xpos + x, string[x + start].ord | attr)
+        end
+      else
+        # Draw the message on a vertical axis.
+        display = [diff, Ncurses.getmaxy(window) - ypos].min
+        (0...display).each do |x|
+          Ncurses.mvwaddch(window, ypos + x, xpos, string[x + start].ord | attr)
+        end
+      end
+    end
+  end
+end

data/lib/rndk/core/quick_widgets.rb

@@ -0,0 +1,106 @@
+# Provides easy ways to do things with Widgets, without
+# all that hassle of initializing values and whatnot.
+#
+# ## Usage
+#
+# They're all methods to the RNDK::Screen class.
+# For example:
+#
+#     curses_win = Ncurses.initscr
+#     rndkscreen = RNDK::Screen.new(curses_win)
+#     message = ["awesome quick label!"]
+#     rndkscreen.popupLabel message
+#
+require 'rndk/label'
+require 'rndk/dialog'
+
+module RNDK
+  class Screen
+
+    # Executes a block of code without modifying the
+    # screen state.
+    #
+    # See usage right below.
+    def cleanly &block
+      prev_state = Ncurses.curs_set 0
+
+      yield
+
+      Ncurses.curs_set prev_state
+      self.erase
+      self.refresh
+    end
+
+    # Quickly pops up a `message`.
+    #
+    # Creates a centered pop-up Label Widget that
+    # waits until the user hits a character.
+    #
+    # @note: `message` must be an array of strings.
+    def popupLabel message
+      return if message.class != Array or message.empty?
+
+      self.cleanly do
+        count = message.size
+
+        popup = RNDK::LABEL.new(self, CENTER, CENTER, message, count, true, false)
+        popup.draw(true)
+
+        # Wait for some input.
+        Ncurses.keypad(popup.win, true)
+        popup.getch([])
+        popup.destroy
+      end
+    end
+
+    # Quickly pops up a `message`, using `attrib` for
+    # the background of the dialog.
+    #
+    # @note: `message` must be an array of strings.
+    def popupLabelAttrib(message, attrib)
+      return if message.class != Array or message.empty?
+
+      self.cleanly do
+        popup = RNDK::LABEL.new(self, CENTER, CENTER, message, message.size, true, false)
+        popup.setBackgroundAttrib attrib
+        popup.draw(true)
+
+        # Wait for some input
+        Ncurses.keypad(popup.win, true)
+        popup.getch([])
+
+        popup.destroy
+      end
+    end
+
+    # Shows a centered pop-up Dialog box with `message` label and
+    # each button label on `buttons`.
+    #
+    # @returns The user choice or `nil` if wrong parameters
+    #          were given.
+    #
+    # @note: `message` and `buttons` must be Arrays of Strings.
+    def popupDialog(message, buttons)
+      return nil if message.class != Array or message.empty?
+      return nil if buttons.class != Array or buttons.empty?
+
+      self.cleanly do
+        popup = RNDK::DIALOG.new(self,
+                                 RNDK::CENTER,
+                                 RNDK::CENTER,
+                                 message,
+                                 message.size,
+                                 buttons,
+                                 buttons.size,
+                                 Ncurses::A_REVERSE,
+                                 true, true, false)
+        popup.draw(true)
+        choice = popup.activate('')
+        popup.destroy
+      end
+      choice
+    end
+
+  end
+end
+

data/lib/rndk/core/screen.rb

@@ -0,0 +1,269 @@
+
+module RNDK
+
+  # Placeholder for RNDK Widgets.
+  #
+  # Since all Widgets are bonded to a Screen, you pretty much
+  # won't need to call any of the methods here.
+  #
+  # The only methods you should worry about are:
+  #
+  # * #initialize
+  # * #end_rndk
+  # * #draw or #refresh
+  # * #erase
+  #
+  # ## Developer Notes
+  #
+  # If you want to create your own Widget, you'll need to
+  # call some methods in here to register/unregister it
+  # to a Screen.
+  #
+  class Screen
+    attr_accessor :object_focus, :object_count, :object_limit, :object, :window
+    attr_accessor :exit_status
+
+    NOEXIT     = 0
+    EXITOK     = 1
+    EXITCANCEL = 2
+
+    # Takes a Ncurses `WINDOW*` pointer and creates a CDKScreen.
+    #
+    # This also starts Ncurses, if it wasn't started before or
+    # no `WINDOW*` were provided
+    #
+    def initialize(ncurses_window=nil)
+
+      # If the user didn't start Ncurses for us,
+      # we'll do it anyway.
+      if RNDK::ALL_SCREENS.size == 0 or ncurses_window.nil?
+
+        ## Why is this here?
+        # Set up basic curses settings.
+        # #ifdef HAVE_SETLOCALE
+        # setlocale (LC_ALL, "");
+        # #endif
+
+        ncurses_window = Ncurses.initscr
+        Ncurses.noecho
+        Ncurses.cbreak
+      end
+
+      RNDK::ALL_SCREENS << self
+      @object_count = 0
+      @object_limit = 2
+      @object = Array.new(@object_limit, nil)
+      @window = ncurses_window
+      @object_focus = 0
+    end
+
+    # Shuts down RNDK and Ncurses.
+    def self.end_rndk
+      Ncurses.echo
+      Ncurses.nocbreak
+      Ncurses.endwin
+    end
+
+    # Adds a Widget to this Screen.
+    #
+    # @note This is called automatically when a widget is created.
+    #
+    # `rndktype` states what RNDK Widget type this object is.
+    # `object` is a pointer to the Widget itself.
+    #
+    def register(rndktype, object)
+      if @object_count + 1 >= @object_limit
+        @object_limit += 2
+        @object_limit *= 2
+        @object.concat Array.new(@object_limit - @object.size, nil)
+      end
+
+      if object.validObjType(rndktype)
+        self.setScreenIndex(@object_count, object)
+        @object_count += 1
+      end
+    end
+
+    # Removes a Widget from the Screen.
+    #
+    # @note This is called automatically when a widget is destroyed.
+    #
+    # This does NOT destroy the object, it removes the Widget
+    # from any further refreshes by Screen#refresh.
+    #
+    # `rndktype` states what RNDK Widget type this object is.
+    # `object` is a pointer to the Widget itself.
+    #
+    def self.unregister(rndktype, object)
+      return if not (object.validObjType(rndktype) && object.screen_index >= 0)
+
+      screen = object.screen
+      return if screen.nil?
+
+      index = object.screen_index
+      object.screen_index = -1
+
+      # Resequence the objects
+      (index...screen.object_count - 1).each do |x|
+        screen.setScreenIndex(x, screen.object[x+1])
+      end
+
+      if screen.object_count <= 1
+        # if no more objects, remove the array
+        screen.object = []
+        screen.object_count = 0
+        screen.object_limit = 0
+      else
+        screen.object[screen.object_count] = nil
+        screen.object_count -= 1
+
+        # Update the object-focus
+        if screen.object_focus == index
+          screen.object_focus -= 1
+          Traverse.setRNDKFocusNext(screen)
+
+        elsif screen.object_focus > index
+          screen.object_focus -= 1
+        end
+      end
+    end
+
+    def setScreenIndex(number, obj)
+      obj.screen_index = number
+      obj.screen = self
+      @object[number] = obj
+    end
+
+    def validIndex(n)
+      n >= 0 && n < @object_count
+    end
+
+    def swapRNDKIndices(n1, n2)
+      if n1 != n2 && self.validIndex(n1) && self.validIndex(n2)
+        o1 = @object[n1]
+        o2 = @object[n2]
+        self.setScreenIndex(n1, o2)
+        self.setScreenIndex(n2, o1)
+
+        if @object_focus == n1
+          @object_focus = n2
+        elsif @object_focus == n2
+          @object_focus = n1
+        end
+      end
+    end
+
+    # Raises the Widget to the top of the screen.
+    # It will now overlap any other obstructing Widgets.
+    #
+    # `rndktype` states what RNDK Widget type this object is.
+    # `object` is a pointer to the Widget itself.
+    #
+    def self.raise_widget(rndktype, object)
+      if object.validObjType(rndktype)
+        screen = object.screen
+        screen.swapRNDKIndices(object.screen_index, screen.object_count - 1)
+      end
+    end
+
+    # Has the opposite effect of #raise_widget.
+    def self.lower_widget(rndktype, object)
+      if object.validObjType(rndktype)
+        object.screen.swapRNDKIndices(object.screen_index, 0)
+      end
+    end
+
+    # Refresh a raw Ncurses window.
+    #
+    # FIXME(original): this should be rewritten to use the panel library, so
+    # it would not be necessary to touch the window to ensure that it covers
+    # other windows.
+    def self.refresh_window win
+      Ncurses.touchwin win
+      Ncurses.wrefresh win
+    end
+
+    # Redraws all Widgets inside this Screen.
+    def draw
+      self.refresh
+    end
+
+    # Redraws all Widgets inside this Screen.
+    def refresh
+      focused = -1
+      visible = -1
+
+      RNDK::Screen.refresh_window(@window)
+
+      # We erase all the invisible objects, then only draw it all back, so
+      # that the objects can overlap, and the visible ones will always be
+      # drawn after all the invisible ones are erased
+      (0...@object_count).each do |x|
+        obj = @object[x]
+        if obj.validObjType(obj.object_type)
+          if obj.is_visible
+            if visible < 0
+              visible = x
+            end
+            if obj.has_focus && focused < 0
+              focused = x
+            end
+          else
+            obj.erase
+          end
+        end
+      end
+
+      (0...@object_count).each do |x|
+        obj = @object[x]
+
+        if obj.validObjType(obj.object_type)
+          obj.has_focus = (x == focused)
+
+          if obj.is_visible
+            obj.draw(obj.box)
+          end
+        end
+      end
+    end
+
+    # Erases all Widgets inside this Screen.
+    #
+    # @note Erase in the sense of clearing the actual
+    #       characters on the terminal screen.
+    #       This does NOT destroy any widgets.
+    def erase
+      (0...@object_count).each do |x|
+        obj = @object[x]
+        obj.erase if obj.validObjType obj.object_type
+      end
+      Ncurses.wrefresh(@window)
+    end
+
+    # Destroys all the Widgets inside this Screen.
+    def destroy_widgets
+      (0...@object_count).each do |x|
+        obj    = @object[x]
+        before = @object_count
+
+        if obj.validObjType(obj.object_type)
+          obj.erase
+          obj.destroy
+          x -= (@object_count - before)
+        end
+      end
+    end
+
+    # Destroys this Screen.
+    # @note It does nothing to the widgets inside it.
+    #       You must either destroy them separatedly
+    #       or call #destroy_widgets before.
+    def destroy
+      RNDK::ALL_SCREENS.delete self
+    end
+
+  end
+end
+
+require 'rndk/core/quick_widgets'
+