view/ncurses/ncurses_window.rb

# ncurses_window.rb: the class definition of Edmaru::Ncurses::NcursesWindow
#
# Copyright (C) 2007 Takashi Nakamoto
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# 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 "window.rb"

module Edmaru::Ncurses
  class NcursesWindow
    include Edmaru::Window

    #Nothing to do.
    def init_ui
    end

    #Allocate memory for this window.
    #
    #=== Arguments
    #
    #_x_ :: The left edge position in the parent view.
    #_y_ :: The top edge position in the parent view.
    #_col_ :: The max column size allocated for this window.
    #_row_ :: The max line size allocated for this window excluding
    #ModeLine's line size (usually 1).
    def init_ncurses_window(x, y, col, row)
      @win = Ncurses::newwin(row - 1, col, y, x)
      @max_row = @allocated_row = row - 1
      @allocated_column = col
      @p_start_row = 0 # The row of physical position that becomes
                       # the first line in screen.

      #The right edge is reserved for an arrow mark that indicates whether
      #the line is wrapped.
      @max_column = col - 1

      @modeline.init_ncurses_modeline(0, y + row - 1, col)
      @modeline.refresh
    end

    def ncurses_move_resize(x, y, col, row)
      return if @win == nil
      
      @win.delwin

      @modeline.terminate

      init_ncurses_window(x, y, col, row)
      refresh
    end

    def cursor_logical_to_physical(l_cursor)
      p_cursor = Edmaru::Cursor.new
      
      if l_cursor.row == 0
        if l_cursor.column == 0
          p_cursor.row = p_cursor.column = 0
        elsif (l_cursor.column % @max_column) == 0 &&
            l_cursor.column == @buffer.lines[0].size
          p_cursor.row = l_cursor.column / @max_column - 1
          p_cursor.column = @max_column
        else
          p_cursor.row = l_cursor.column / @max_column
          p_cursor.column = l_cursor.column % @max_column
        end
      else
        p_cursor.row = 0

        l_cursor.row.times{ |n|
          if @buffer.lines[n].size == 0
            p_cursor.row += 1
          elsif (@buffer.lines[n].size % @max_column) == 0
            p_cursor.row += (@buffer.lines[n].size / @max_column)
          else
            p_cursor.row += (@buffer.lines[n].size / @max_column + 1)
          end
        }

        if l_cursor.column == 0
          p_cursor.column = 0
        elsif (l_cursor.column & @max_column) == 0 &&
            l_cursor.column == @buffer.lines[l_cursor.row].size
          p_cursor.row += (l_cursor.column / @max_column - 1)
          p_cursor.column = @max_column
        else
          p_cursor.row += (l_cursor.column / @max_column)
          p_cursor.column = l_cursor.column % @max_column
        end
      end

      return p_cursor
    end

    def cursor_physical_to_logical(p_cursor)
      l_cursor = Edmaru::Cursor.new

      line_num = @buffer.lines.size

      for n in 0...line_num
        l_cursor.row = n
        l_cursor.column = 0
        start_p_cursor = cursor_logical_to_physical(l_cursor)

        l_cursor.column = @buffer.lines[n].size
        end_p_cursor = cursor_logical_to_physical(l_cursor)

        if start_p_cursor.row <= p_cursor.row &&
          end_p_cursor.row >= p_cursor.row
          l_cursor.column = 0
          l_cursor.column +=
            (p_cursor.row - start_p_cursor.row) * @max_column
          l_cursor.column += p_cursor.column
          return l_cursor
        end
      end

      return nil
    end

    #Refresh hte cursor. Move the cursor to the correct position.
    def refresh_cursor
      return if @offscreen == nil

      #There is no need to update cursor if this window is not
      #focused.
      return if !@focused

      p_cursor = cursor_logical_to_physical(@cursor)

      if (p_cursor.row - @p_start_row) >= @max_row
        #ToDo: scroll to the appropriate position at once
        scroll_down
      elsif (p_cursor.row - @p_start_row) < 0 && @p_start_row > 0
        #ToDo: scroll to the appropriate position at once
        scroll_up
      end

      @win.move(p_cursor.row - @p_start_row, p_cursor.column)
                                   
      @modeline.set_element_text("cursor-position",
                                 "(#{@cursor.row},#{@cursor.column})")

      @win.refresh
    end

    #Redraw this window.
    def refresh
      @offscreen = Array.new
      @p_start_row = 0 if @p_start_row == nil

      @buffer.lines.each{ |line|
        line = line.clone

        while(true)
          if line.size == 0
            @offscreen.push("")
            break
          elsif line.size > @max_column
            @offscreen.push(line.slice!(0 ... @max_column) + "\\")
          else
            @offscreen.push(line)
            break
          end
        end
      }

      for window_row in 0...@max_row
        row = @p_start_row + window_row

        if row >= @offscreen.size || @offscreen[row].size == 0
          @win.mvaddstr(window_row, 0, " " * @allocated_column)
        else
          @win.mvaddstr(window_row, 0, @offscreen[row])
          if @offscreen[row].size < @allocated_column
            @win.addstr(" " * (@allocated_column - @offscreen[row].size))
          end
        end
      end

      @win.refresh

      @view.focused_window.refresh_cursor
    end

    #Move the cursor to the beginning of the buffer.
    def cursor_goto_beginning
      @view.hide_alert

      @cursor.row = @cursor.column = 0
      @p_start_row = 0
      refresh
    end

    #Move the cursor to the end of the buffer.
    def cursor_goto_end
      @view.hide_alert

      @cursor.row = @buffer.lines.size - 1
      @cursor.column = @buffer.lines[@cursor.row].size
      p_cursor = cursor_logical_to_physical(@cursor)

      @p_start_row = p_cursor.row - @max_row + 2
      @p_start_row = 0 if @p_start_row < 0
      refresh
    end

    #Scroll down this window.
    def scroll_down
      @view.hide_alert

      end_l_cursor = Edmaru::Cursor.new
      end_l_cursor.row = @buffer.lines.size - 1
      end_l_cursor.column = @buffer.lines[end_l_cursor.row].size

      end_p_cursor = cursor_logical_to_physical(end_l_cursor)
      end_p_row = end_p_cursor.row

      if @p_start_row + @max_row > end_p_row
        @view.show_alert("End of buffer")
        return
      end

      prev_p_start_row = @p_start_row
      if @max_row != 1
        @p_start_row += (@max_row / 2).to_i
      else
        @p_start_row += 1
      end

      if @p_start_row > end_p_row
        @p_start_row = prev_p_start_row
      end

      p_cursor = cursor_logical_to_physical(@cursor)
      if p_cursor.row < @p_start_row
        if @max_row != 1
          p_cursor.row += (@max_row / 2).to_i
        else
          p_cursor.row += 1
        end
        p_cursor.column = 0
        l_cursor = cursor_physical_to_logical(p_cursor)
        if l_cursor != nil
          @cursor = l_cursor
        else
          @cursor = end_l_cursor
        end
      end

      refresh
    end

    #Scroll up this window
    def scroll_up
      @view.hide_alert

      if @p_start_row == 0
        @view.show_alert("Beginning of buffer")
        return
      end

      if @max_row != 1
        @p_start_row -= (@max_row / 2)
      else
        @p_start_row -= 1
      end
      @p_start_row = 0 if @p_start_row < 0

      p_cursor = cursor_logical_to_physical(@cursor)
      if p_cursor.row >= @p_start_row + @max_row
        if @max_row != 1
          p_cursor.row -= (@max_row / 2).to_i
        else
          p_cursor.row -= 1
        end
        p_cursor.column = 0
        l_cursor = cursor_physical_to_logical(p_cursor)
        if l_cursor != nil
          @cursor = l_cursor
        else
          @cursor.row = @cursor.column = 0
        end
      end

      refresh
    end

    def ncurses_allocated_row
      @allocated_row
    end

    def ncurses_allocated_column
      @allocated_column
    end

    #Free allocated memory for this window.
    def terminate_ui
      @win.delwin
    end
  end
end