shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/dimensions.rb

@@ -1,194 +0,0 @@
-# Dimensions is a central class that most Shoes classes use to represent their
-# dimensions, e.g. where they are and how much space they are taking up there.
-# All the different position types might be confusing. So here is a little list:
-#
-# Position (left, top, right, bottom)
-# plain (left, top, right, bottom)
-#   An offset relative to the parent (parents mostly are slots e.g. 
-#   flows/stacks), e.g it isn't fully positioned/doesn't flow anymore when set
-#
-# absolute (absolute_left, absolute_top, absolute_right, absolute_bottom)
-#   The absolute position of an element in the app, set by positioning code (in 
-#   slot.rb). Might not be the beginning of the element as it also takes margins
-#   into account, so it could be the beginning of the margin. Is also used in
-#   the positioning code.
-#
-# element_* (element_left, element_top, element_right, element_bottom)
-# Derived from absolute_* but shows the real position of the object, e.g. it
-# adds the margins to absolute_* (mostly used by backend drawing code).
-#
-# Space taken up (width/height)
-# plain (width, height)
-#   The whole space taken up by this element with margins and everything. Used
-#   for positioning/by the user.
-#
-# element_* (element_width, element_height)
-#   Just the space taken up by the element itself without margins.
-#   Used by drawing.
-#
-# Note that this is NOT how margins work in the CSS box model. We derive for
-# reasons mentioned in this comment/thread: 
-# https://github.com/shoes/shoes4/pull/467#issuecomment-27655355
-
-class Shoes
-  class Dimensions
-    extend RenamedDelegate
-
-    attr_writer   :width, :height, :margin_left, :margin_right, :margin_top,
-                  :margin_bottom, :top, :left, :right, :bottom
-    attr_reader   :parent, :x_dimension, :y_dimension
-    attr_accessor :absolute_left, :absolute_top,
-                  :displace_left, :displace_top
-    protected :parent # we shall not mess with parent,see #495
-
-
-    # in case you wonder about the -1... it is used to adjust the right and
-    # bottom values. Because right is not left + width but rather left + width -1
-    # Let me give you an example:
-    # Say left is 20 and we have a width of 100 then the right must be 119,
-    # because you have to take pixel number 20 into account so 20..119 is 100
-    # while 20..120 is 101. E.g.:
-    # (20..119).size => 100
-    PIXEL_COUNTING_ADJUSTMENT = -1
-
-    def initialize(parent, left_or_hash = nil, top = nil, width = nil,
-                   height = nil, opts = {})
-      @parent = parent
-      if hash_as_argument?(left_or_hash)
-        init_with_hash(left_or_hash)
-      else
-        init_with_arguments(left_or_hash, top, width, height, opts)
-      end
-    end
-
-    def absolute_x_position?
-      x_dimension.absolute_position?
-    end
-
-    def absolute_y_position?
-      y_dimension.absolute_position?
-    end
-
-    def absolutely_positioned?
-      absolute_x_position? || absolute_y_position?
-    end
-
-    def positioned?
-      x_dimension.positioned? && y_dimension.positioned?
-    end
-
-    def in_bounds?(x, y)
-      x_dimension.in_bounds?(x) && y_dimension.in_bounds?(y)
-    end
-
-    def margin
-      [margin_left, margin_top, margin_right, margin_bottom]
-    end
-
-    def margin=(margin)
-      margin = [margin, margin, margin, margin] unless margin.is_a? Array
-      self.margin_left, self.margin_top,
-      self.margin_right, self.margin_bottom =  margin
-    end
-
-    # used by positioning code in slot and there to be overwritten if something
-    # does not need to be positioned like a background or so
-    def needs_to_be_positioned?
-      true
-    end
-
-    def takes_up_space?
-      true
-    end
-
-    def self.setup_delegations
-      methods_to_rename = Dimension.public_instance_methods false
-      renamed_delegate_to :x_dimension, methods_to_rename, 'start'  => 'left',
-                                                           'end'    => 'right',
-                                                           'extent' => 'width'
-      renamed_delegate_to :y_dimension, methods_to_rename, 'start'  => 'top',
-                                                           'end'    => 'bottom',
-                                                           'extent' => 'height'
-    end
-
-    setup_delegations
-
-    private
-    def hash_as_argument?(left)
-      left.respond_to? :fetch
-    end
-
-    def init_with_hash(hash)
-      init_with_arguments hash.fetch(:left, nil), hash.fetch(:top, nil),
-                          hash.fetch(:width, nil), hash.fetch(:height, nil),
-                          hash
-    end
-
-    def init_with_arguments(left, top, width, height, opts)
-      @left_top_as_center = opts.fetch(:center, false)
-      init_x_and_y_dimensions
-      general_options opts # order important for redrawing
-      self.displace_left = opts.fetch(:displace_left, nil)
-      self.displace_top  = opts.fetch(:displace_top, nil)
-      self.left          = left
-      self.top           = top
-      self.width         = width
-      self.height        = height
-    end
-
-    def init_x_and_y_dimensions
-      parent_x_dimension = @parent? @parent.x_dimension : nil
-      parent_y_dimension = @parent? @parent.y_dimension : nil
-      @x_dimension = Dimension.new parent_x_dimension, @left_top_as_center
-      @y_dimension = Dimension.new parent_y_dimension, @left_top_as_center
-    end
-
-    def general_options(opts)
-      self.right =  opts[:right]
-      self.bottom = opts[:bottom]
-      init_margins opts
-    end
-
-    def init_margins(opts)
-      self.margin        = opts[:margin]
-      self.margin_left   = opts.fetch(:margin_left, margin_left)
-      self.margin_top    = opts.fetch(:margin_top, margin_top)
-      self.margin_right  = opts.fetch(:margin_right, margin_right)
-      self.margin_bottom = opts.fetch(:margin_bottom, margin_bottom)
-    end
-  end
-
-  # for objects that do not depend on their parent (get 1.04 as real values)
-  class AbsoluteDimensions < Dimensions
-    def initialize(*args)
-      super(nil, *args)
-    end
-  end
-
-  # for objects that are more defined by their parents, delegates method calls
-  # to crucial methods to the parent if the instance variable isn't set
-  class ParentDimensions < Dimensions
-    def init_x_and_y_dimensions
-      @x_dimension = ParentDimension.new @parent.x_dimension,
-                                         @left_top_as_center
-      @y_dimension = ParentDimension.new @parent.y_dimension,
-                                         @left_top_as_center
-    end
-  end
-
-  # depends on a #dimensions method being present that returns a Dimensions object
-  module DimensionsDelegations
-    extend Forwardable
-
-    DELEGATED_METHODS = Dimensions.public_instance_methods false
-
-    def_delegators :dimensions, *DELEGATED_METHODS
-  end
-
-  # depends on a #dsl method to forward to (e.g. for backend objects)
-  module BackendDimensionsDelegations
-    extend Forwardable
-
-    def_delegators :dsl, *DimensionsDelegations::DELEGATED_METHODS
-  end
-end

data/lib/shoes/download.rb

@@ -1,117 +0,0 @@
-class Shoes
-  class HttpResponse
-    # Struct might be better?
-    attr_accessor :headers, :body, :status
-    def initalize
-      @headers = {}
-      @body = ''
-      @status = []
-    end
-  end
-
-  class Download
-
-    attr_reader :progress, :response, :content_length, :gui, :transferred
-    UPDATE_STEPS = 100
-
-    def initialize(app, parent, url, opts = {}, &blk)
-      @opts = opts
-      @blk = blk
-      @gui = Shoes.configuration.backend_for(self)
-
-      @response = HttpResponse.new
-      @finished = false
-      @transferred = 0
-      @content_length = 1 # non zero initialized to avoid Zero Div Errors
-      start_download url
-    end
-
-    def started?
-      @started
-    end
-
-    def finished?
-      @finished
-    end
-
-    # needed for the specs (jay multi threading and specs)
-    def join_thread
-      @thread.join
-    end
-
-    def percent
-      @transferred * 100 / @content_length
-    end
-
-    def abort
-      @thread.exit if @thread
-    end
-
-    # shoes 3 compatibility
-    def length
-      @content_length
-    end
-
-    private
-    def start_download(url)
-      require 'open-uri'
-      @thread = Thread.new do
-        uri_opts = {}
-        uri_opts[:content_length_proc] = content_length_proc
-        uri_opts[:progress_proc] = progress_proc if @opts[:progress]
-
-        open url, uri_opts do |download_data|
-          @response.body = download_data.read
-          @response.status = download_data.status
-          @response.headers = download_data.meta
-          save_to_file(@opts[:save]) if @opts[:save]
-          finish_download download_data
-        end
-      end
-    end
-
-    def content_length_proc
-      lambda do |content_length|
-        download_started(content_length)
-        eval_block(@opts[:progress], self) if @opts[:progress]
-      end
-    end
-
-    def progress_proc
-      lambda do |size|
-        if !content_length.nil? &&
-          (size - self.transferred) > (content_length / UPDATE_STEPS) &&
-          !@gui.busy?
-            @gui.busy = true
-            eval_block(@opts[:progress], self)
-            @transferred = size
-        end
-      end
-    end
-
-    def finish_download(download_data)
-      @finished = true
-
-      #In case backend didn't catch the 100%
-      @transferred = @content_length
-      eval_block(@opts[:progress], self) if @opts[:progress]
-
-      #:finish and block are the same
-      eval_block(@blk, self) if @blk
-      eval_block(@opts[:finish], self) if @opts[:finish]
-    end
-
-    def eval_block(blk, result)
-      @gui.eval_block(blk, result)
-    end
-
-    def save_to_file(file_path)
-      open(file_path, 'wb') { |fw| fw.print @response.body }
-    end
-
-    def download_started(content_length)
-      @content_length = content_length
-      @started        = true
-    end
-  end
-end

data/lib/shoes/dsl.rb

@@ -1,478 +0,0 @@
-class Shoes
-  # Methods for creating and manipulating Shoes elements
-  #
-  # Requirements
-  #
-  # Including classes must provide:
-  #
-  #   @__app__
-  #
-  #   which provides
-  #     #style:          a hash of styles
-  #     #element_styles: a hash of {Class => styles}, where styles is
-  #                      a hash of default styles for elements of Class,
-  module DSL
-    include Common::Style
-    include Color::DSLHelpers
-
-    # Set default style for elements of a particular class, or for all
-    # elements, or return the current defaults for all elements
-    #
-    # @overload style(klass, styles)
-    #   Set default style for elements of a particular class
-    #   @param [Class] klass a Shoes element class
-    #   @param [Hash] styles default styles for elements of klass
-    #   @example
-    #     style Para, :text_size => 42, :stroke => green
-    #
-    # @overload style(styles)
-    # Set default style for all elements
-    #   @param [Hash] styles default style for all elements
-    #   @example
-    #     style :stroke => alicewhite, :fill => black
-    #
-    # @overload style()
-    #   @return [Hash] the default style for all elements
-    def style(klass_or_styles = nil, styles = {})
-      if klass_or_styles.kind_of? Class
-        klass = klass_or_styles
-        @__app__.element_styles[klass] = styles
-      else
-        @__app__.style(klass_or_styles)
-      end
-    end
-
-    private
-
-    def style_normalizer
-      @style_normalizer ||= Common::StyleNormalizer.new
-    end
-
-    def pop_style(opts)
-      opts.last.class == Hash ? opts.pop : {}
-    end
-
-    # Default styles for elements of klass
-    def style_for_element(klass, styles = {})
-      @__app__.element_styles.fetch(klass, {}).merge(styles)
-    end
-
-    def normalize_style_for_element(clazz, texts)
-      style = style_normalizer.normalize(pop_style(texts))
-      style_for_element(clazz, style)
-    end
-
-    def create(element, *args, &blk)
-      element.new(@__app__, @__app__.current_slot, *args, &blk)
-    end
-
-    public
-
-    def image(path, opts={}, &blk)
-      create Shoes::Image, path, opts, blk
-    end
-
-    def border(color, opts = {}, &blk)
-      create Shoes::Border, pattern(color), opts, blk
-    end
-
-    def background(color, opts = {}, &blk)
-      create Shoes::Background, pattern(color), style_normalizer.normalize(opts), blk
-    end
-
-    def edit_line(*args, &blk)
-      style = pop_style(args)
-      text  = args.first || ''
-      create Shoes::EditLine, text, style, blk
-    end
-
-    def edit_box(*args, &blk)
-      style = pop_style(args)
-      text  = args.first || ''
-      create Shoes::EditBox, text, style, blk
-    end
-
-    def progress(opts = {}, &blk)
-      create Shoes::Progress, opts, blk
-    end
-
-    def check(opts = {}, &blk)
-      create Shoes::Check, opts, blk
-    end
-
-    def radio(*args, &blk)
-      style = pop_style(args)
-      group = args.first
-      create Shoes::Radio, group, style, blk
-    end
-
-    def list_box(opts = {}, &blk)
-      create Shoes::ListBox, opts, blk
-    end
-
-    def flow(opts = {}, &blk)
-      create Shoes::Flow, opts, &blk
-    end
-
-    def stack(opts = {}, &blk)
-      create Shoes::Stack, opts, &blk
-    end
-
-    def button(text, opts={}, &blk)
-      create Shoes::Button, text, opts, blk
-    end
-
-    # Creates an animation that runs the given block of code.
-    #
-    # @overload animate &blk
-    #   @param [Proc] blk Code to run for each animation frame
-    #   @return [Shoes::Animation]
-    #   Defaults to framerate of 24 frames per second
-    #   @example
-    #     # 24 frames per second
-    #     animate do
-    #       # animation code
-    #     end
-    # @overload animate(framerate, &blk)
-    #   @param [Integer] framerate Frames per second
-    #   @param [Proc] blk Code to run for each animation frame
-    #   @return [Shoes::Animation]
-    #   @example
-    #     # 10 frames per second
-    #     animate 10 do
-    #       # animation code
-    #     end
-    # @overload animate(opts = {}, &blk)
-    #   @param [Hash] opts Animation options
-    #   @param [Proc] blk Code to run for each animation frame
-    #   @option opts [Integer] :framerate Frames per second
-    #   @return [Shoes::Animation]
-    #   @example
-    #     # 10 frames per second
-    #     animate :framerate => 10 do
-    #       # animation code
-    #     end
-    #
-    def animate(opts = {}, &blk)
-      opts = {:framerate => opts} unless opts.is_a? Hash
-      Shoes::Animation.new @__app__, opts, blk
-    end
-
-    def every(n=1, &blk)
-      animate 1.0/n, &blk
-    end
-
-    def timer(n=1, &blk)
-      n *= 1000
-      Timer.new @__app__, n, &blk
-    end
-
-    # similar controls as Shoes::Video (#video)
-    def sound(soundfile, opts = {}, &blk)
-      Shoes::Sound.new @__app__, soundfile, opts, &blk
-    end
-
-    # Creates an arc at (left, top)
-    #
-    # @param [Integer] left the x-coordinate of the top-left corner
-    # @param [Integer] top the y-coordinate of the top-left corner
-    # @param [Integer] width width of the arc's ellipse
-    # @param [Integer] height height of the arc's ellipse
-    # @param [Float] angle1 angle in radians marking the beginning of the arc segment
-    # @param [Float] angle2 angle in radians marking the end of the arc segment
-    # @param [Hash] opts Arc style options
-    # @option opts [Boolean] wedge (false)
-    # @option opts [Boolean] center (false) is (left, top) the center of the rectangle?
-    def arc(left, top, width, height, angle1, angle2, opts = {})
-      arc_style = style_normalizer.normalize(opts)
-      create Shoes::Arc, left, top, width, height, angle1, angle2, style.merge(arc_style)
-    end
-
-    # Draws a line from point A (x1,y1) to point B (x2,y2)
-    #
-    # @param [Integer] x1 The x-value of point A
-    # @param [Integer] y1 The y-value of point A
-    # @param [Integer] x2 The x-value of point B
-    # @param [Integer] y2 The y-value of point B
-    # @param [Hash] opts Style options
-    def line(x1, y1, x2, y2, opts = {})
-      create Shoes::Line, Shoes::Point.new(x1, y1), Shoes::Point.new(x2, y2), style.merge(opts)
-    end
-
-    # Creates an oval at (left, top)
-    #
-    # @overload oval(left, top, diameter)
-    #   Creates a circle at (left, top), with the given diameter
-    #   @param [Integer] left the x-coordinate of the top-left corner
-    #   @param [Integer] top the y-coordinate of the top-left corner
-    #   @param [Integer] diameter the diameter
-    # @overload oval(left, top, width, height)
-    #   Creates an oval at (left, top), with the given width and height
-    #   @param [Integer] left the x-coordinate of the top-left corner
-    #   @param [Integer] top the y-coordinate of the top-left corner
-    #   @param [Integer] width the width
-    #   @param [Integer] height the height
-    # @overload oval(styles)
-    #   Creates an oval using values from the styles Hash.
-    #   @param [Hash] styles
-    #   @option styles [Integer] left (0) the x-coordinate of the top-left corner
-    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
-    #   @option styles [Integer] width (0) the width
-    #   @option styles [Integer] height (0) the height
-    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
-    #   @option styles [Boolean] center (false) is (left, top) the center of the oval
-    def oval(*opts, &blk)
-      oval_style = style_normalizer.normalize pop_style(opts)
-      case opts.length
-        when 3
-          left, top, width = opts
-          height = width
-        when 4
-          left, top, width, height = opts
-        when 0
-          left = oval_style[:left] || 0
-          top = oval_style[:top] || 0
-          width = oval_style[:diameter] || oval_style[:width] ||
-                  (oval_style[:radius] || 0) * 2
-          height = oval_style[:height] || width
-        else
-          message = <<EOS
-Wrong number of arguments. Must be one of:
-  - oval(left, top, diameter, [opts])
-  - oval(left, top, width, height, [opts])
-  - oval(styles)
-EOS
-          raise ArgumentError, message
-      end
-      create Shoes::Oval, left, top, width, height, style.merge(oval_style), &blk
-    end
-
-    # Creates a rectangle
-    #
-    # @overload rect(left, top, side, styles)
-    #   Creates a square at (left, top), with sides of the given length
-    #   @param [Integer] left the x-coordinate of the top-left corner
-    #   @param [Integer] top the y-coordinate of the top-left corner
-    #   @param [Integer] side the length of a side
-    # @overload rect(left, top, width, height, rounded = 0, styles)
-    #   Creates a rectangle at (left, top), with the given width and height
-    #   @param [Integer] left the x-coordinate of the top-left corner
-    #   @param [Integer] top the y-coordinate of the top-left corner
-    #   @param [Integer] width the width
-    #   @param [Integer] height the height
-    # @overload rect(styles)
-    #   Creates a rectangle using values from the styles Hash.
-    #   @param [Hash] styles
-    #   @option styles [Integer] left (0) the x-coordinate of the top-left corner
-    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
-    #   @option styles [Integer] width (0) the width
-    #   @option styles [Integer] height (0) the height
-    #   @option styles [Integer] top (0) the y-coordinate of the top-left corner
-    #   @option styles [Boolean] center (false) is (left, top) the center of the rectangle?
-    def rect(*args, &blk)
-      opts = style_normalizer.normalize pop_style(args)
-      case args.length
-      when 3
-        left, top, width = args
-        height = width
-        opts[:curve] ||= 0
-      when 4
-        left, top, width, height = args
-        opts[:curve] ||= 0
-      when 5
-        left, top, width, height, opts[:curve] = args
-      when 0
-        left = opts[:left] || 0
-        top = opts[:top] || 0
-        width = opts[:width] || 0
-        height = opts[:height] || width
-        opts[:curve] ||= 0
-      else
-        message = <<EOS
-Wrong number of arguments. Must be one of:
-  - rect(left, top, side, [opts])
-  - rect(left, top, width, height, [opts])
-  - rect(left, top, width, height, curve, [opts])
-  - rect(styles)
-EOS
-        raise ArgumentError, message
-      end
-      create Shoes::Rect, left, top, width, height, style.merge(opts), &blk
-    end
-
-    def star(left, top, points = 10, outer = 100.0, inner = 50.0, opts = {}, &blk)
-      opts = style_normalizer.normalize opts
-      create Shoes::Star, left, top, points, outer, inner, opts, &blk
-    end
-
-    # Creates a new Shoes::Shape object
-    def shape(shape_style = {}, &blk)
-      Shoes::Shape.new(@__app__, @__app__.style.merge(shape_style), blk)
-    end
-
-    # Sets the current stroke color
-    #
-    # Arguments
-    #
-    # color - a Shoes::Color
-    def stroke(color)
-      @__app__.style[:stroke] = pattern(color)
-    end
-
-    def nostroke
-      @__app__.style[:stroke] = nil
-    end
-
-    # Sets the stroke width, in pixels
-    def strokewidth(width)
-      @__app__.style[:strokewidth] = width
-    end
-
-    # Sets the current fill color
-    #
-    # @param [Shoes::Color,Shoes::Gradient] pattern the pattern to set as fill
-    def fill(pattern)
-      @__app__.style[:fill] = pattern(pattern)
-    end
-
-    def nofill
-      @__app__.style[:fill] = nil
-    end
-
-    # Sets the current line cap style
-    def cap(line_cap)
-      @__app__.style[:cap] = line_cap
-    end
-
-
-
-    # Text blocks
-    # normally constants belong to the top, I put them here because they are
-    # only used here.
-    FONT_SIZES = {
-      banner:       48,
-      title:        34,
-      subtitle:     26,
-      tagline:      18,
-      caption:      14,
-      para:         12,
-      inscription:  10
-    }.freeze
-
-    %w[banner title subtitle tagline caption para inscription].each do |method|
-      define_method method do |*texts|
-        opts = texts.last.class == Hash ? texts.pop : {}
-        klass = Shoes.const_get(method.capitalize)
-        create klass, texts, FONT_SIZES[method.to_sym], style_for_element(klass, opts)
-      end
-    end
-
-    TEXT_STYLES = {
-      code: { font: "Lucida Console" },
-      del: { strikethrough: true },
-      em: { emphasis: true },
-      ins: { underline: true },
-      sub: { rise: -10, size_modifier: 0.8 },
-      sup: { rise: 10, size_modifier: 0.8 },
-      strong: { weight: true },
-    }
-
-    TEXT_STYLES.keys.each do |method|
-      define_method method do |*texts|
-        style = style_normalizer.normalize(pop_style(texts))
-        opts = TEXT_STYLES[method].merge(style)
-        Shoes::Span.new texts, opts
-      end
-    end
-
-    def fg(*texts, color)
-      Shoes::Span.new texts, { stroke: pattern(color) }
-    end
-
-    def bg(*texts, color)
-      Shoes::Span.new texts, { fill: pattern(color) }
-    end
-
-    def link(*texts, &blk)
-      opts = normalize_style_for_element(Shoes::Link, texts)
-      create Shoes::Link, texts, opts, &blk
-    end
-
-    def span(*texts)
-      opts = normalize_style_for_element(Shoes::Span, texts)
-      Shoes::Span.new texts, opts
-    end
-
-    def mouse
-      [@__app__.mouse_button, @__app__.mouse_pos[0], @__app__.mouse_pos[1]]
-    end
-
-    def motion(&blk)
-      @__app__.mouse_motion << blk
-    end
-
-    def resize(&blk)
-      @__app__.add_resize_callback blk
-    end
-
-    # hover and leave just delegate to the current slot as hover and leave
-    # are just defined for slots but self is always the app.
-    def hover(&blk)
-      @__app__.current_slot.hover(blk)
-    end
-
-    def leave(&blk)
-      @__app__.current_slot.leave(blk)
-    end
-
-    def keypress(&blk)
-      Shoes::Keypress.new @__app__, &blk
-    end
-
-    def keyrelease(&blk)
-      Shoes::Keyrelease.new @__app__, &blk
-    end
-
-    def append(&blk)
-      blk.call if blk
-    end
-
-    def visit(url)
-      match_data = nil
-      url_data = Shoes::URL.urls.find {|page, _| match_data = page.match url}
-      if url_data
-        action_proc = url_data[1]
-        url_argument = match_data[1]
-        clear do
-          @__app__.location = url
-          action_proc.call self, url_argument
-        end
-      end
-      timer(0.01) { @__app__.top_slot.contents_alignment }
-    end
-
-    def scroll_top
-      @__app__.scroll_top
-    end
-
-    def scroll_top=(n)
-      @__app__.scroll_top = n
-    end
-
-    def clipboard
-      @__app__.clipboard
-    end
-
-    def clipboard=(str)
-      @__app__.clipboard = str
-    end
-
-    def download(name, args={}, &blk)
-      create Shoes::Download, name, args, &blk
-    end
-
-    def gutter
-      @__app__.gutter
-    end
-  end
-end