class Rabbit::Theme::ElementContainer

Public Class Methods

new(applier, ary) click to toggle source
Calls superclass method
# File lib/rabbit/theme/applier.rb, line 14
def initialize(applier, ary)
  @applier = applier
  super(ary)
end

Public Instance Methods

[](*args) click to toggle source
Calls superclass method
# File lib/rabbit/theme/applier.rb, line 27
def [](*args)
  result = super
  if result.is_a?(Array)
    @applier.make_container(result)
  else
    result
  end
end
collect(*args, &block) click to toggle source
Calls superclass method
# File lib/rabbit/theme/applier.rb, line 19
def collect(*args, &block)
  @applier.make_container(super)
end
draw_frame(params={}) { |target, canvas, x, y, w, h| ... } click to toggle source
# File lib/rabbit/theme/applier.rb, line 161
def draw_frame(params={}, &block)
  proc_name = params[:proc_name] || "draw_frame"
  frame_color = params[:frame_color]
  fill_color = params[:fill_color]
  shadow_color = params[:shadow_color]
  shadow_offset = params[:shadow_offset] || 2
  shadow_width = params[:shadow_width] || 4
  frame_width = params[:frame_width] || 1

  add_pre_draw_proc(proc_name) do |target, canvas, x, y, w, h, simulation|
    unless simulation
      if block_given?
        fx, fy, fw, fh = yield(target, canvas, x, y, w, h)
      end
      fx ||= target.x
      fy ||= target.y + target.centering_adjusted_height
      fw ||= target.width
      fh ||= target.height
      if shadow_color
        fh -= shadow_width
      end
      size = [fx, fy, fw, fh]

      if fill_color
        args = size + [fill_color]
        canvas.draw_rectangle(true, *args)
      end

      if frame_color
        args = size + [frame_color, {:line_width => frame_width}]
        canvas.draw_rectangle(false, *args)
      end

      if shadow_color
        # Under Shadow
        usx = fx + shadow_offset
        usy = fy + fh + frame_width
        usw = fw + shadow_width - shadow_offset
        ush = shadow_width
        canvas.draw_rectangle(true, usx, usy, usw, ush, shadow_color)

        # Right Shadow
        rsx = fx + fw + frame_width
        rsy = fy + shadow_offset
        rsw = shadow_width
        rsh = fh + shadow_width - shadow_offset
        canvas.draw_rectangle(true, rsx, rsy, rsw, rsh, shadow_color)
      end
    end
    [x, y, w, h]
  end
end
draw_image_mark(image_name, name=nil, options={}) click to toggle source
# File lib/rabbit/theme/applier.rb, line 104
def draw_image_mark(image_name, name=nil, options={})
  return if empty?

  loader = ImageLoader.new(image_name)

  width_proc = Proc.new {loader.width}
  height_proc = Proc.new {loader.height}
  custom_indent = options[:indent]
  indent_proc = Proc.new do |item, simulation|
    text_height = item.elements.first.original_height
    if text_height < loader.height
      loader.resize(nil, (text_height * 2.0 / 3.0).ceil)
    end
    if custom_indent.nil?
      loader.width * 2.5
    elsif custom_indent.respond_to?(:call)
      custom_indent.call(item, loader)
    else
      custom_indent
    end
  end

  draw_mark(indent_proc,
            width_proc, height_proc,
            name) do  |item, canvas, x, y, w, h|
    x -= loader.width * 0.5
    loader.draw(canvas, x, y)
  end
end
draw_mark(indent_width, width_or_proc, height_or_proc, name=nil) { |item, canvas, indent_base_x, indent_base_y, width, height| ... } click to toggle source
# File lib/rabbit/theme/applier.rb, line 66
def draw_mark(indent_width, width_or_proc, height_or_proc, name=nil)
  indent(indent_width, name) do |item, canvas, x, y, w, h|
    first_element = item.elements.first
    case first_element
    when Element::TextRenderer
      first_text = first_element
      text_height = first_text.first_line_height
      text_height += first_text.padding_top + first_text.padding_bottom
    when Element::EnumList, Element::ItemList
      first_item = first_element.elements.first
      text_height = first_item.height
      text_height += first_item.padding_top + first_item.padding_bottom
    else
      text_height = item.height
    end

    if width_or_proc.respond_to?(:call)
      mark_width = width_or_proc.call(item, canvas)
    else
      mark_width = width_or_proc
    end
    if height_or_proc.respond_to?(:call)
      mark_height = height_or_proc.call(item, canvas)
    else
      mark_height = height_or_proc
    end

    adjust_y = ((text_height / 2.0) - (mark_height / 2.0)).ceil

    indent_base_x = item.x - mark_width
    indent_base_y = item.base_y + adjust_y
    indent_base_y += first_text.margin_top if first_text
    width = mark_width
    height = mark_height
    yield(item, canvas, indent_base_x, indent_base_y, width, height)
  end
end
draw_order(indent_width, name=nil, &block) click to toggle source
# File lib/rabbit/theme/applier.rb, line 134
def draw_order(indent_width, name=nil, &block)
  layouts = {}
  make_order_layout = Proc.new do |item, simulation|
    layout = layouts[item]
    if layout.nil?
      str = block.call(item)
      layout = @applier.make_layout(str)
      layouts[item] = layout
    end
    tw, th = layout.pixel_size
    [tw + indent_width, tw, th, layout]
  end

  draw_order = Proc.new do |item, canvas, x, y, w, h, tw, th, layout|
    first_text = item.elements.first
    text_height = first_text.first_line_height
    text_height += first_text.padding_top + first_text.padding_bottom
    adjust_y = ((text_height / 2.0) - (th / 2.0)).ceil

    new_x = item.base_x + indent_width
    new_y = item.base_y + first_text.margin_top + adjust_y
    canvas.draw_layout(layout, new_x, new_y)
  end

  indent(make_order_layout, name, &draw_order)
end
indent(size_or_proc, name=nil) { |element, canvas, x, y, w, h, *other_infos| ... } click to toggle source
# File lib/rabbit/theme/applier.rb, line 36
def indent(size_or_proc, name=nil)
  each do |element|
    element.delete_pre_draw_proc_by_name(name)
    element.delete_post_draw_proc_by_name(name)

    other_infos = []
    element.add_pre_draw_proc(name) do |canvas, x, y, w, h, simulation|
      if simulation
        if size_or_proc.respond_to?(:call)
          result = size_or_proc.call(element, simulation)
          indent_size, *other_infos = result
        else
          indent_size = size_or_proc
        end
        element.margin_left = indent_size
      end
      [x, y, w, h]
    end

    if block_given?
      element.add_post_draw_proc(name) do |canvas, x, y, w, h, simulation|
        unless simulation
          yield(element, canvas, x, y, w, h, *other_infos)
        end
        [x, y, w, h]
      end
    end
  end
end
map(*args, &block) click to toggle source
Calls superclass method
# File lib/rabbit/theme/applier.rb, line 23
def map(*args, &block)
  @applier.make_container(super)
end
method_missing(meth, *args, &block) click to toggle source
# File lib/rabbit/theme/applier.rb, line 214
def method_missing(meth, *args, &block)
  collect do |elem|
    if block
      proxy_block = Proc.new do |*block_args|
        block.call(elem, *block_args)
      end
    else
      proxy_block = nil
    end
    elem.__send__(meth, *args, &proxy_block)
  end
end