class TheFox::TermKit::View

Base View class.

A View is an abstraction of any view object.

Attributes

grid[RW]

Holds the content points for this View. A single point content is an instance of ViewContent class.

grid_cache[RW]

Will be used for the actual rendering.
The @grid_cache variable can hold foreign content points (see ViewContent) as well as own content points. Foreign content points are owned by subviews that are shown on this View as well. If a View has subviews but no own content on the @grid the @grid_cache variable holds only content points from its subviews. The View not just holds the content points of the subviews but also the content points of the subviews of subviews and so on. Through the deepest level of subviews. If you draw a point on a View calling draw_point() the point will also be drawn on the parent view through the top view. @grid holds only ViewContents of its own View. Not so the @grid_cache variable that also holds foreign content points.

is_init_position[R]
name[RW]

The name variable is FOR DEBUGGING ONLY.

parent_view[RW]
position[R]
size[R]

Defines a maximum width and height (see Size) for a View to be rendered.

subviews[RW]
zindex[R]

Defines the stack order. This variable will only be used when the View has a parent view. The subview on the parent view with the highest zindex will be shown on the parent view. See redraw_point_zindex() method for details.

Public Class Methods

new(name = nil) click to toggle source
# File lib/termkit/view/view.rb, line 36
def initialize(name = nil)
    #puts 'View->initialize'
    
    @name = name # FOR DEBUG ONLY
    @parent_view = nil
    @subviews = Set.new
    
    # @grid = Hash.new
    @grid = ViewGrid.new
    # @grid_cache = Hash.new
    @grid_cache = ViewGrid.new
    
    @is_visible = false
    @position = Point.new(0, 0)
    @is_init_position = true
    @size = nil
    @zindex = 1
end

Public Instance Methods

add_subview(subview) click to toggle source
# File lib/termkit/view/view.rb, line 282
def add_subview(subview)
    if subview == self
        raise ArgumentError, 'self given'
    end
    if !subview.is_a?(View)
        raise ArgumentError, "Argument is not a View -- #{subview.class} given"
    end
    
    return unless @subviews.add?(subview)
    
    subview.parent_view = self
    @subviews.add(subview)
    
    subview.grid_cache.each do |y_pos, row|
        row.each do |x_pos, content|
            point = Point.new(x_pos + subview.position.x, y_pos + subview.position.y)
            
            # puts "#{@name} -- add_subview, redraw_point_zindex #{point.x}:#{point.y}"
            
            redraw_point_zindex(point)
        end
    end
    
    subview
end
draw_point(point, content) click to toggle source

Draw a single Point to the current view.

# File lib/termkit/view/view.rb, line 345
def draw_point(point, content)
    case point
    when Array, Hash
        point = Point.new(point)
    when Point
    else
        raise NotImplementedError, "#{content.class} class not implemented"
    end
    
    case content
    when String
        content = ViewContent.new(content, self)
    when ViewContent
    else
        raise NotImplementedError, "#{content.class} class not implemented"
    end
    
    is_foreign_point = content.view != self
    
    x_pos = point.x
    y_pos = point.y
    
    
    if is_foreign_point
    else
        if !@grid[y_pos]
            @grid[y_pos] = {}
        end
        
        @grid[y_pos][x_pos] = content
        content.origin = point
    end
    
    # puts "#{@name} -- draw #{point} #{content.inspect}"
    
    new_point = Point.new(x_pos, y_pos)
    
    # puts "#{@name} -- draw '#{content}' #{x_pos}:#{y_pos} foreign=#{is_foreign_point ? 'Y' : 'N'} from=#{content.view}"
    # puts "#{@name} -- subviews: #{@subviews.count}"
    
    changed = nil
    
    if @subviews.count == 0
        changed = set_grid_cache(new_point, content)
    else
        # puts "#{@name} -- has subviews"
        
        if @grid_cache[y_pos] && @grid_cache[y_pos][x_pos]
            # puts "#{@name} -- found something on cached grid"
            
            redraw_point_zindex(new_point)
        else
            # puts "#{@name} -- draw free point"
            changed = set_grid_cache(new_point, content)
        end
    end
    
    if changed
        parent_draw_point(new_point, content)
    end
    
    changed
end
grid_cache_erase_point(point) click to toggle source

Erase a single Point of the cached Grid (@grid_cache).

First call redraw_point_zindex(point) to redraw the point. If the point didn't change use a new ClearViewContent instance and set it only on @grid_cache. Not on @grid because this clearing point instance will be removed by render().

# File lib/termkit/view/view.rb, line 515
def grid_cache_erase_point(point)
    x_pos, y_pos = point.to_a
    
    # puts "#{@name} -- erase point #{point}"
    
    changed = nil
    if @grid_cache[y_pos] && @grid_cache[y_pos][x_pos] && !@grid_cache[y_pos][x_pos].is_a?(ClearViewContent)
        # puts "#{@name} -- erase point #{point}, ok found & delete"
        @grid_cache[y_pos].delete(x_pos)
        if @grid_cache[y_pos].count == 0
            @grid_cache.delete(y_pos)
        end
        
        # puts "#{@name} -- erase point #{point}, redraw point zindex"
        changed = redraw_point_zindex(point)
        
        # puts "#{@name} -- erase point #{point}, changed=#{changed ? 'Y' : 'N'}  #{changed.inspect}"
        
        # When nothing has changed.
        unless changed
            # puts "#{@name} -- erase point #{point}, nothing changed"
            
            content = ClearViewContent.new(nil, self, point)
            
            # puts "#{@name} -- erase point #{point}, set ClearViewContent"
            changed = set_grid_cache(point, content)
            # puts "#{@name} -- erase point #{point}, set ClearViewContent: #{changed.inspect}"
            
            #changed = content
        else
            # puts "#{@name} -- erase point #{point}, CHANGED #{changed.inspect}"
            #set_grid_cache(point, changed)
        end
    else
        # puts "#{@name} -- erase point #{point}, not found"
    end
    changed
end
grid_cache_remove_point(point, cls = nil) click to toggle source
# File lib/termkit/view/view.rb, line 554
def grid_cache_remove_point(point, cls = nil)
    # puts "#{@name} -- remove point #{point}"
    
    x_pos, y_pos = point.to_a
    if @grid_cache[y_pos] && @grid_cache[y_pos][x_pos]
        # puts "#{@name} -- cls=#{cls.inspect} #{@grid_cache[y_pos][x_pos].class}"
        if cls.nil? || @grid_cache[y_pos][x_pos].is_a?(cls)
            # puts "#{@name} -- remove point #{point}, ok"
            @grid_cache[y_pos].delete(x_pos)
            
            if @grid_cache[y_pos].count == 0
                @grid_cache.delete(y_pos)
            end
        end
    else
        # puts "#{@name} -- remove point #{point}, not found"
    end
end
grid_erase() click to toggle source
# File lib/termkit/view/view.rb, line 493
def grid_erase
    @grid.each do |y_pos, row|
        row.each do |x_pos, content|
            #puts "clean #{x_pos}:#{y_pos} '#{content}'"
            point = Point.new(x_pos, y_pos)
            
            grid_erase_point(point)
        end
    end
end
grid_erase_point(point) click to toggle source
# File lib/termkit/view/view.rb, line 504
def grid_erase_point(point)
    x_pos, y_pos = point.to_a
    
    @grid[y_pos][x_pos] = ClearViewContent.new(nil, self, point)
    grid_cache_erase_point(point)
end
height() click to toggle source
# File lib/termkit/view/view.rb, line 254
def height
    keys = @grid_cache.keys
    # pp keys
    
    min = keys.min.to_i
    max = keys.max.to_i
    
    # puts "min '#{min}'"
    # puts "max '#{max}'"
    # puts
    
    if keys.count > 0
        max - min + 1
    else
        0
    end
end
inspect() click to toggle source
# File lib/termkit/view/view.rb, line 818
def inspect
    "#<View name=#{@name} w=#{width}>"
end
is_subview?(subview) click to toggle source
# File lib/termkit/view/view.rb, line 308
def is_subview?(subview)
    @subviews.include?(subview)
end
is_visible=(is_visible) click to toggle source

:nocov:

# File lib/termkit/view/view.rb, line 78
def is_visible=(is_visible)
    # puts "#{@name} -- is_visible= #{is_visible}"
    
    trend = 0
    
    if @is_visible && !is_visible
        trend = -1
    elsif !@is_visible && is_visible
        trend = 1
    end
    
    @is_visible = is_visible
    
    redraw_parent(trend)
end
is_visible?() click to toggle source
# File lib/termkit/view/view.rb, line 94
def is_visible?
    @is_visible
end
needs_rendering?() click to toggle source
# File lib/termkit/view/view.rb, line 807
def needs_rendering?
    @grid_cache
        .map{ |y_pos, row| row.values.map{ |content| content.needs_rendering ? 1 : 0 } }
        .flatten
        .inject(:+) > 0
end
parent_draw_point(point, content) click to toggle source

Draw a point on the parent View (@parent_view).

# File lib/termkit/view/view.rb, line 410
def parent_draw_point(point, content)
    if !@parent_view.nil? && is_visible?
        
        new_point = Point.new(point.x + @position.x, point.y + @position.y)
        
        # puts "#{@name} -- draw parent: #{@parent_view} #{new_point.x}:#{new_point.y} (#{point.x}:#{point.y})"
        @parent_view.draw_point(new_point, content)
    end
end
position=(new_position) click to toggle source
# File lib/termkit/view/view.rb, line 98
def position=(new_position)
    if !new_position.is_a?(Point)
        raise ArgumentError, "Argument is not a Point -- #{new_position.class} given"
    end
    
    # puts "#{@name} -- position= old=#{@position} new=#{new_position}"
    
    if @position != new_position
        # puts "#{@name} -- position= diff"
        
        if @parent_view.nil?
            @position = new_position
        else
            # Keep old position.
            old_position = @position
            
            # Move it.
            @position = new_position
            
            x_max_i = x_max.to_i + 1
            y_max_i = y_max.to_i + 1
            
            # puts "x_max '#{x_max_i}'"
            # puts "y_max '#{y_max_i}'"
            
            new_area = Rect.new(nil, nil, x_max_i, y_max_i)
            new_area.origin = new_position
            new_area_points = new_area.to_points
            
            old_area = Rect.new(nil, nil, x_max_i, y_max_i)
            old_area.origin = old_position
            
            # puts "#{@name} -- plain area a=#{area.inspect}"
            
            # Redraw new position.
            # puts "#{@name} -- new area #{new_area.inspect}"
            # changes_new = {}
            # changes_new = @parent_view.redraw_area_zindex(new_area)
            @parent_view.redraw_area_zindex(new_area)
            # puts "#{@name} -- redraw_area_zindex OK #{new_area.inspect}"
            # STDIN.gets
            
            # changes_new.each do |y_pos, row|
            #     row.each do |x_pos, content|
            #         new_point = Point.new(x_pos, y_pos)
            #         puts "#{@name} -- new content #{new_point} c=#{content.inspect}"
            #     end
            # end
            
            # puts
            # puts "#{@name} -- @is_init_position = #{@is_init_position}"
            # puts
            
            # Redraw old position.
            if !@is_init_position
                parent_view = @parent_view
                parent_level = 0
                point_offset = Point.new(0, 0)
                while parent_view
                    # puts "#{@name} -- l=#{parent_level} '#{parent_view}' -- old area #{old_area.inspect} #{point_offset}"
                    old_points = old_area.to_points
                    old_points_s = old_points.map{ |point| point.to_s }
                    
                    new_points = new_area_points.map{ |point| (point + point_offset) }
                    new_points_s = new_points.map{ |point| point.to_s }
                    #bottom_points = old_points.map{ |point| (point - point_offset).to_s }
                    # rest_points = bottom_points - new_area_points
                    rest_points_s = old_points_s - new_points_s
                    rest_points = rest_points_s.map{ |point| Point.from_s(point) }
                    #rest_points = old_points - new_points
                    
                    # puts "#{@name} -- old  points     #{old_points_s}"
                    # puts "#{@name} -- new  points     #{new_points_s}"
                    # puts "#{@name} -- bottom   points #{bottom_points}"
                    # puts "#{@name} -- new      points #{new_area_points}"
                    # puts "#{@name} -- rest points     #{rest_points_s}"
                    
                    rest_points.each do |point|
                        # puts "#{@name} -- #{parent_view} -- old content #{point}"
                        # changed = false
                        # changed = parent_view.grid_cache_erase_point(point)
                        parent_view.grid_cache_erase_point(point)
                        # puts "#{@name} -- #{parent_view} -- old content #{point} c=#{changed.inspect}"
                    end
                    
                    old_area.origin += parent_view.position
                    point_offset += parent_view.position
                    # puts "#{@name} -- #{parent_view} -- pos parent #{parent_view.position} -> #{old_area.inspect} #{point_offset.inspect}"
                    # puts
                    
                    parent_view = parent_view.parent_view
                    parent_level += 1
                    
                    # puts
                    
                end
                
            end
            
        end
    end
    
    @is_init_position = false
end
pp_grid() click to toggle source

FOR DEBUG ONLY :nocov:

# File lib/termkit/view/view.rb, line 58
def pp_grid
    @grid.map{ |y_pos, row|
        [y_pos, row.map{ |x_pos, content| [x_pos, content.char] }.to_h]
    }.to_h
end
pp_grid_cache() click to toggle source

FOR DEBUG ONLY

# File lib/termkit/view/view.rb, line 66
def pp_grid_cache
    @grid_cache.map{ |y_pos, row|
        [y_pos,
            row.map{ |x_pos, content|
                # [x_pos, {'c' => content.char, 'v' => content.view.name}]
                [x_pos, content.char]
            }.to_h,
        ]
    }.to_h
end
redraw_area_zindex(area) click to toggle source
# File lib/termkit/view/view.rb, line 653
def redraw_area_zindex(area)
    if !area.is_a?(Rect)
        raise ArgumentError, "Argument is not a Rect -- #{area.class} given"
    end
    
    # puts "#{@name} -- redraw area  zindex #{area}"
    
    changes = {}
    area.y_range.each do |y_pos|
        area.x_range.each do |x_pos|
            point = Point.new(x_pos, y_pos)
            
            unless changes[y_pos]
                changes[y_pos] = {}
            end
            
            changes[y_pos][x_pos] = redraw_point_zindex(point)
        end
    end
    changes
end
redraw_parent(visibility_trend) click to toggle source

Redraw to Parent View based on the visibility trend.
The visibility trend is 0 for unchanged, -1 will hide, 1 will appear.

  • -1 means is_visible was set from true to false.

  • 1 means is_visible was set from false to true.

# File lib/termkit/view/view.rb, line 426
def redraw_parent(visibility_trend)
    # puts "#{@name} -- redraw parent, t=#{visibility_trend}"
    
    unless @parent_view.nil?
        if visibility_trend == 1
            
            @grid_cache.each do |y_pos, row|
                row.each do |x_pos, content|
                    point = Point.new(x_pos, y_pos)
                    
                    # puts "#{@name} -- redraw parent, draw, #{point}"
                    
                    parent_draw_point(point, content)
                end
            end
            
        elsif visibility_trend == -1
            
            @grid_cache.each do |y_pos, row|
                row.each do |x_pos, content|
                    # puts "#{@name} -- redraw parent, hide (#{@position.x}:#{@position.y}) #{x_pos}:#{y_pos}"
                    
                    view = @parent_view
                    view_x_pos = x_pos + @position.x
                    view_y_pos = y_pos + @position.y
                    
                    # Erase the content on all parent views.
                    while !view.nil?
                        # puts "#{@name} -- redraw parent, hide #{x_pos}:#{y_pos}, #{view}  #{view_x_pos}:#{view_y_pos}"
                        
                        view_content = view.grid_cache[view_y_pos] && view.grid_cache[view_y_pos][view_x_pos] ? view.grid_cache[view_y_pos][view_x_pos] : nil
                        # view_content = view.grid[view_y_pos] && view.grid[view_y_pos][view_x_pos] ? view.grid[view_y_pos][view_x_pos] : nil
                        
                        if view_content
                            
                            # puts "#{@name} -- redraw parent, hide #{x_pos}:#{y_pos}, #{view}  #{view_x_pos}:#{view_y_pos}, content '#{view_content}'"
                            
                            # Erase the content on the parent view only when the content is viewable on the parent view.
                            if view_content == content
                                # puts "#{@name} -- redraw parent, hide #{x_pos}:#{y_pos}, #{view}  #{view_x_pos}:#{view_y_pos}, same"
                                
                                view.grid_cache_erase_point(Point.new(view_x_pos, view_y_pos))
                            else
                                # puts "#{@name} -- redraw parent, hide #{x_pos}:#{y_pos}, #{view}  #{view_x_pos}:#{view_y_pos}, not same"
                                
                                # Break when reaching a foreign layer (view). This can happen when this view
                                # has a lower zindex and is concealed by another view.
                                break
                            end
                            
                        else
                            # puts "#{@name} -- redraw parent, hide #{x_pos}:#{y_pos}, #{view}  #{view_x_pos}:#{view_y_pos}, empty"
                        end
                        
                        
                        view_x_pos += view.position.x
                        view_y_pos += view.position.y
                        view = view.parent_view
                    end
                    
                end
            end
            
        end
    end
end
redraw_point_zindex(point) click to toggle source

Redraw a single Point based on the zindexes of the subviews.
Happens when a subview added, removed, hides, zindex changes, or draws.

The subview with the highest zindex will be selected to set the content for this point. When no subview exists or all subviews are hidden look-up the Point on the @grid variable to set the Point on @grid_cache.

# File lib/termkit/view/view.rb, line 578
def redraw_point_zindex(point)
    x_pos = point.x
    y_pos = point.y
    
    # puts "#{@name} -- redraw point zindex #{point}"
    
    views = @subviews
        .select{ |subview| subview.is_visible? && subview.zindex >= 1 }
        .select{ |subview|
            
            subview_x_pos = x_pos - subview.position.x
            subview_y_pos = y_pos - subview.position.y
            
            content = subview.grid_cache[subview_y_pos] && subview.grid_cache[subview_y_pos][subview_x_pos]
            
            # puts "#{@name} -- find '#{subview}' #{subview_x_pos}:#{subview_y_pos}, #{content.inspect}"
            
            !content.nil?
        }
        .sort{ |subview1, subview2| subview1.zindex <=> subview2.zindex }
    
    # pp views.map{ |subview| subview.name }
    
    view = views.last
    
    content = nil
    
    if view.nil?
        # When no subview was found, draw the current view
        # if a point on the current view's grid exist.
        
        # puts "#{@name} -- redraw point zindex #{point}, no view found"
        
        if @grid[y_pos] && @grid[y_pos][x_pos]
            # puts "#{@name} -- redraw point zindex #{point}, found something on the grid: '#{@grid[y_pos][x_pos]}'"
            content = @grid[y_pos][x_pos]
        else
            # puts "#{@name} -- redraw point zindex #{point}, nothing on grid @ #{x_pos}:#{y_pos}"
            
            if @grid_cache[y_pos] && @grid_cache[y_pos][x_pos]
                content = @grid_cache[y_pos][x_pos]
                
                unless content.is_a?(ClearViewContent)
                    # puts "#{@name} -- redraw point zindex #{point}, found something on the grid_cache: '#{@grid_cache[y_pos][x_pos]}', DELETE"
                    content = ClearViewContent.new(nil, self, point)
                end
            else
                # puts "#{@name} -- redraw point zindex #{point}, nothing on grid_cache @ #{x_pos}:#{y_pos}"
            end
        end
    else
        subview_x_pos = x_pos - view.position.x
        subview_y_pos = y_pos - view.position.y
        
        content = view.grid_cache[subview_y_pos][subview_x_pos]
        
        # puts "#{@name} -- redraw point zindex #{point}, last view: '#{view}' #{subview_x_pos}:#{subview_y_pos}  #{content.inspect}"
    end
    
    changed = nil
    unless content.nil?
        # puts "#{@name} -- redraw point zindex #{point}, set grid cache"
        changed = set_grid_cache(point, content)
    end
    
    if changed
        # puts "#{@name} -- redraw point zindex #{point}, changed #{content.inspect}"
        parent_draw_point(point, content)
    else
        # puts "#{@name} -- redraw point zindex #{point}, NOT changed"
    end
    
    changed
end
remove_subview(subview) click to toggle source
# File lib/termkit/view/view.rb, line 312
def remove_subview(subview)
    if subview == self
        raise ArgumentError, 'self given'
    end
    if !subview.is_a?(View)
        raise ArgumentError, "Argument is not a View -- #{subview.class} given"
    end
    
    return unless @subviews.delete?(subview)
    
    @subviews.delete(subview)
    
    subview.grid_cache.each do |y_pos, row|
        row.each do |x_pos, content|
            point = Point.new(x_pos + subview.position.x, y_pos + subview.position.y)
            
            # puts "#{@name} -- remove_subview, grid cache erase point #{point.x}:#{point.y}"
            
            grid_cache_erase_point(point)
        end
    end
    
    subview
end
remove_subviews() click to toggle source
# File lib/termkit/view/view.rb, line 337
def remove_subviews
    @subviews.each do |subview|
        remove_subview(subview)
    end
end
render(area = nil) click to toggle source

Renders a View.

Only ViewContents that needs a rendering (see ViewContent, needs_rendering attribute) will be returned. needs_rendering attribute is set to false by render().

# File lib/termkit/view/view.rb, line 716
def render(area = nil)
    # puts "#{@name} -- render area=#{area ? 'Y' : 'N'}"
    
    if !@size.nil?
        if area.nil?
            area = Rect.new(0, 0)
            area.size = @size
        end
    end
    
    grid_filtered = @grid_cache
    
    grid_filtered = grid_filtered
        .map{ |y_pos, row|
            [y_pos, row.select{ |x_pos, content| content.needs_rendering }]
        }
        .to_h
        
    
    if area.nil? || area.has_default_values?
        
    else
        
        grid_filtered = grid_filtered
            .select{ |y_pos, row|
                y_pos >= area.y
            }
            .map{ |y_pos, row|
                [y_pos, row.select{ |x_pos, content| x_pos >= area.x }]
            }
            .to_h
        
        if area.height
            grid_filtered = grid_filtered
                .select{ |y_pos, row|
                    y_pos <= area.y_max
                }
        end
        
        if area.width
            grid_filtered = grid_filtered
                .map{ |y_pos, row|
                    [y_pos, row.select{ |x_pos, content| x_pos <= area.x_max }]
                }
                .to_h
        end
        
    end
    
    grid_filtered = grid_filtered.select{ |y_pos, row| row.count > 0 }
    
    grid_filtered.each do |y_pos, row|
        row.each do |x_pos, content|
            #point = Point.new(x_pos, y_pos)
            
            # puts "#{@name} -- render #{point}   #{content.inspect}"
            content.needs_rendering = false
            
            if content.is_a?(ClearViewContent)
                if @grid[y_pos] && @grid[y_pos][x_pos] && @grid[y_pos][x_pos].is_a?(ClearViewContent)
                    # puts "#{@name} -- render remove grid ClearViewContent"
                    @grid[y_pos].delete(x_pos)
                end
                
                parent_view = content.view
                parent_point = content.origin
                
                # puts "#{@name} -- render PARENT START '#{parent_point}'"
                while parent_view
                    # puts "#{@name} -- render PARENT '#{parent_view}' '#{parent_point}' (#{parent_view.position})"
                    
                    # puts "#{@name} -- render remove grid_cache ClearViewContent"
                    parent_view.grid_cache_remove_point(parent_point, ClearViewContent)
                    
                    parent_point += parent_view.position
                    parent_view = parent_view.parent_view
                    
                    # sleep 0.1
                end
            end
        end
    end
    
    # @grid.values.map{ |row| row.values }.flatten.select{ |content| content.needs_rendering }.each do |content|
        # puts "render '#{content}'"
    #   content.needs_rendering = false
    # end
    
    grid_filtered
end
set_grid_cache(point, new_content) click to toggle source

Set a single Point on the cached Grid (@grid_cache).
This method returns true only if the content of the point has changed.

# File lib/termkit/view/view.rb, line 678
def set_grid_cache(point, new_content)
    x_pos, y_pos = point.to_a
    
    if !@grid_cache[y_pos]
        @grid_cache[y_pos] = {}
    end
    
    changed =
        if @grid_cache[y_pos][x_pos]
            # puts "#{@name} -- set grid #{point}, x + y OK"
            
            old_content = @grid_cache[y_pos][x_pos]
            if old_content == new_content # && old_content.class == new_content.class
                # puts "#{@name} -- set grid #{point}, equals, #{old_content.inspect} == #{new_content.inspect}"
                false
            else
                # puts "#{@name} -- set grid #{point}, diff A #{@grid_cache[y_pos][x_pos].inspect}"
                
                true
            end
        else
            # puts "#{@name} -- set grid #{point}, x + y N/A"
            
            true
        end
    
    # puts "#{@name} -- set grid #{point} '#{new_content}' changed=#{changed ? 'Y' : 'N'}"
    
    if changed
        new_content.needs_rendering = true
        @grid_cache[y_pos][x_pos] = new_content
    end
end
size=(size) click to toggle source
# File lib/termkit/view/view.rb, line 211
def size=(size)
    if !size.is_a?(Size)
        raise ArgumentError, "Argument is not a Size -- #{size.class} given"
    end
    
    @size = size
end
to_s() click to toggle source
# File lib/termkit/view/view.rb, line 814
def to_s
    @name
end
top_position() click to toggle source
# File lib/termkit/view/view.rb, line 203
def top_position
    if @parent_view.nil?
        @position
    else
        @parent_view.top_position
    end
end
width() click to toggle source
# File lib/termkit/view/view.rb, line 237
def width
    keys = @grid_cache.map{ |y_pos, row| row.keys }.flatten
    # pp keys
    min = keys.min.to_i
    max = keys.max.to_i
    
    # puts "min '#{min}'"
    # puts "max '#{max}'"
    # puts
    
    if keys.count > 0
        max - min + 1
    else
        0
    end
end
x_max() click to toggle source
# File lib/termkit/view/view.rb, line 272
def x_max
    # puts 'x_max'
    # pp @grid_cache.map{ |y_pos, row| row.keys.max }.flatten.max
    @grid_cache.map{ |y_pos, row| row.keys.max }.flatten.max
end
y_max() click to toggle source
# File lib/termkit/view/view.rb, line 278
def y_max
    @grid_cache.keys.max
end
zindex=(zindex) click to toggle source
# File lib/termkit/view/view.rb, line 219
def zindex=(zindex)
    @zindex = zindex
    
    # puts "#{@name} -- set zindex #{zindex} p=#{@parent_view.nil? ? 'N' : 'Y'}"
    
    if !@parent_view.nil?
        @grid_cache.each do |y_pos, row|
            row.each do |x_pos, content|
                point = Point.new(x_pos + @position.x, y_pos + @position.y)
                
                # puts "#{@name} -- set zindex #{zindex}, #{point.x}:#{point.y}"
                
                @parent_view.redraw_point_zindex(point)
            end
        end
    end
end