sketchup-api-stubs 0.1.2 → 0.2.0

data/SketchUp/Layout/Table.rb

@@ -0,0 +1,290 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# A {Layout::Table} is a series of rows and columns that holds data.
+#
+# @example
+#   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+#   rows = 4
+#   columns = 4
+#   table = Layout::Table.new(bounds, rows, columns)
+#   doc = Layout::Document.open("C:/path/to/document.layout")
+#   doc.add_entity(table, doc.layers.first, doc.pages.first)
+#   anchor_type = Layout::FormattedText::ANCHOR_TYPE_TOP_LEFT
+#   start_point = Geom::Point2d.new(1, 1)
+#   text = Layout::FormattedText.new("Hello LayOut", start_point, anchor_type)
+#   table[1, 1].data = text
+#
+# @version LayOut 2018
+class Layout::Table < Layout::Entity
+
+  # Includes
+
+  include Enumerable
+
+  # Instance Methods
+
+  # The {#[]} method returns the {Layout::TableCell} at the specified row and
+  # column.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   cell = table[1, 2]
+  #
+  # @param [Integer] row_index
+  #
+  # @param [Integer] column_index
+  #
+  # @raise [IndexError] if row_index or column_index are not a valid indices
+  #   for the {Layout::Table}
+  #
+  # @return [Layout::TableCell]
+  #
+  # @version LayOut 2018
+  def [](row_index, column_index)
+  end
+
+  # The {#dimensions} method returns the number of rows and columns in a
+  # {Layout::Table}.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   r, c = table.dimensions
+  #
+  # @return [Array(Integer, Integer)] The first value is the number of rows; the
+  #   second, the number of columns.
+  #
+  # @version LayOut 2018
+  def dimensions
+  end
+
+  # The {#each} method iterates in column major order through all of the cells
+  # in the {Layout::Table}.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table.each { |cell|
+  #     puts cell.data.plain_text
+  #   }
+  #
+  # @version LayOut 2018
+  #
+  # @yieldparam [Layout::TableCell] cell
+  def each
+  end
+
+  # The {#entities} method creates and returns the {Layout::Entities} that
+  # represent the {Layout::Table} in its exploded form.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   entities = table.entities
+  #
+  # @return [Layout::Entities]
+  #
+  # @version LayOut 2018
+  def entities
+  end
+
+  # The {#get_column} method returns the {Layout::TableColumn} at the specified
+  # index.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table_column = table.get_column(2)
+  #
+  # @param [Integer] index
+  #
+  # @raise [IndexError] if index is not a valid index for the {Layout::Table}
+  #
+  # @return [Layout::TableColumn]
+  #
+  # @version LayOut 2018
+  def get_column(index)
+  end
+
+  # The {#get_row} method returns the {Layout::TableRow} at the specified index.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table_row = table.get_row(2)
+  #
+  # @param [Integer] index
+  #
+  # @raise [IndexError] if index is not a valid index for the {Layout::Table}
+  #
+  # @return [Layout::TableRow]
+  #
+  # @version LayOut 2018
+  def get_row(index)
+  end
+
+  # The {#initialize} method creates a {Layout::Table} with a specified size, and
+  # a specified number of rows and columns.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #
+  # @param [Geom::Bounds2d] bounds
+  #
+  # @param [Integer] rows
+  #
+  # @param [Integer] columns
+  #
+  # @raise [ArgumentError] if bounds is zero size
+  #
+  # @raise [ArgumentError] if rows is less than 1
+  #
+  # @raise [ArgumentError] if columns is less than 1
+  #
+  # @return [Layout::Table]
+  #
+  # @version LayOut 2018
+  def initialize(bounds, rows, columns)
+  end
+
+  # The {#insert_column} method inserts a new column at the specified index.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table.insert_column(2)
+  #
+  # @param [Integer] index
+  #
+  # @raise [IndexError] if index is not a valid index for the {Layout::Table}
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def insert_column(index)
+  end
+
+  # The {#insert_row} method inserts a new row at the specified index.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table.insert_row(2)
+  #
+  # @param [Integer] index
+  #
+  # @raise [IndexError] if index is not a valid index for the {Layout::Table}
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def insert_row(index)
+  end
+
+  # The {#merge} method merges a range of cells within a {Layout::Table}. Only
+  # cells which are not already merged can be merged.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table.merge(1, 1, 2, 2)
+  #
+  # @param [Integer] start_row
+  #
+  # @param [Integer] start_column
+  #
+  # @param [Integer] end_row
+  #
+  # @param [Integer] end_column
+  #
+  # @raise [ArgumentError] if the specified range of cells contains a merged cell
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [ArgumentError] if the specified range of cells only spans a single
+  #   cell
+  #
+  # @raise [IndexError] if the passed in indices are not a valid for the
+  #   {Layout::Table}
+  #
+  # @version LayOut 2018
+  def merge(start_row, start_column, end_row, end_column)
+  end
+
+  # The {#remove_column} method removes the column at the specified index.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table.remove_column(2)
+  #
+  # @param [Integer] index
+  #
+  # @raise [IndexError] if index is not a valid index for the {Layout::Table}
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def remove_column(index)
+  end
+
+  # The {#remove_row} method removes the row at the specified index.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table.remove_row(2)
+  #
+  # @param [Integer] index
+  #
+  # @raise [IndexError] if index is not a valid index for the {Layout::Table}
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def remove_row(index)
+  end
+
+end

data/SketchUp/Layout/TableCell.rb

@@ -0,0 +1,149 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# A {Layout::TableCell} is a single cell from a table that contains data.
+#
+# @example
+#   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+#   rows = 4
+#   columns = 4
+#   table = Layout::Table.new(bounds, rows, columns)
+#   table.each { |cell|
+#     puts cell.data.plain_text
+#   }
+#
+# @version LayOut 2018
+class Layout::TableCell
+
+  # Constants
+
+  ROTATION_0 = nil # Stub value.
+  ROTATION_180 = nil # Stub value.
+  ROTATION_270 = nil # Stub value.
+  ROTATION_90 = nil # Stub value.
+
+  # Instance Methods
+
+  # The {#data} method creates a copy of the {Layout::FormattedText} for the
+  # {Layout::TableCell}.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   cell_entity = table[1, 2].data
+  #
+  # @raise [ArgumentError] if the cell {Layout::Entity} is not a
+  #   {Layout::FormattedText}
+  #
+  # @version LayOut 2018
+  def data
+  end
+
+  # The {#data=} method sets the {Layout::Entity} of a {Layout::TableCell}.
+  # The text content and fill {Layout::Style} settings will be kept. The bounds
+  # and other {Layout::Style} settings are controlled by the {Layout::Table}. If
+  # the specified row and column is within a merged cell, then the merged cell
+  # itself will be affected.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   anchor = Geom::Point2d.new(1, 1)
+  #   text_anchor_type = Layout::FormattedText::ANCHOR_TYPE_TOP_LEFT
+  #   text = Layout::FormattedText.new("Test", anchor, text_anchor_type)
+  #   table[1, 2].data = text
+  #
+  # @note At the moment, this only works for {Layout::Entity}s that are
+  #   {Layout::FormattedText}s. However, future versions of LayOut may support
+  #   other types of {Layout::Entity}s for {Layout::TableCell}s, so this method
+  #   cannot be assumed to always fail with inputs of other {Layout::Entity}
+  #   types.
+  #
+  # @param [Layout::Entity] entity
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def data=(entity)
+  end
+
+  # The {#rotation} method returns the rotation of a {Layout::TableCell}.
+  #
+  # The rotation type can be one of the following values:
+  # [+Layout::TableCell::ROTATION_0+]
+  # [+Layout::TableCell::ROTATION_90+]
+  # [+Layout::TableCell::ROTATION_180+]
+  # [+Layout::TableCell::ROTATION_270+]
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   rotation = table[1, 1].rotation
+  #
+  # @raise [ArgumentError] if the cell is invalid due to residing within a
+  #   merged cell
+  #
+  # @return [Integer]
+  #
+  # @version LayOut 2018
+  def rotation
+  end
+
+  # The {#rotation=} method sets the rotation of a {Layout::TableCell}.
+  #
+  # The rotation type can be one of the following values:
+  # [+Layout::TableCell::ROTATION_0+]
+  # [+Layout::TableCell::ROTATION_90+]
+  # [+Layout::TableCell::ROTATION_180+]
+  # [+Layout::TableCell::ROTATION_270+]
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table[1, 1].rotation = Layout::TableCell::ROTATION_180
+  #
+  # @param [Integer] cell_rotation
+  #
+  # @raise [ArgumentError] if the cell is invalid due to residing within a
+  #   merged cell
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def rotation=(cell_rotation)
+  end
+
+  # The {#span} method returns the row and column span of a {Layout::TableCell}.
+  # If the values returned are both 1, then it is a normal, non-merged cell. If
+  # either of the values are greater than 1, then it is a merged cell. If the
+  # values are both 0, then it is an unused cell that resides within the inner
+  # portion of another merged cell.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   row_span, column_span = table[1, 1].span
+  #
+  # @return [Array(Integer, Integer)] Row span and column span.
+  #
+  # @version LayOut 2018
+  def span
+  end
+
+end

data/SketchUp/Layout/TableColumn.rb

@@ -0,0 +1,139 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# A {Layout::TableColumn} is a single column from a table.
+#
+# @example
+#   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+#   rows = 4
+#   columns = 4
+#   table = Layout::Table.new(bounds, rows, columns)
+#   columns.times { |index|
+#     column = table.column(index)
+#   }
+#
+# @version LayOut 2018
+class Layout::TableColumn
+
+  # Instance Methods
+
+  # The {#left_edge_style} method returns the {Layout::Style} of a
+  # {Layout::TableColumn}'s left edge. If this is the first column of the table,
+  # this method will return the style of the table border.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   style = table.get_column(1).edge_style
+  #
+  # @return [Layout::Style]
+  #
+  # @version LayOut 2018
+  def left_edge_style
+  end
+
+  # The {#left_edge_style=} method sets the {Layout::Style} of a
+  # {Layout::TableColumn}'s left edge. If this is the first column of the table,
+  # this method will set the style for the table border.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   style = Layout::Style.new
+  #   style.stroke_width = 2.0
+  #   table.get_column(1).edge_style = style
+  #
+  # @param [Layout::Style] style
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def left_edge_style=(style)
+  end
+
+  # The {#right_edge_style} method returns the {Layout::Style} of a
+  # {Layout::TableColumn}'s right edge. If this is the last column of the table,
+  # this method will return the style of the table border.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   style = table.get_column(1).edge_style
+  #
+  # @return [Layout::Style]
+  #
+  # @version LayOut 2018
+  def right_edge_style
+  end
+
+  # The {#right_edge_style=} method sets the {Layout::Style} of a
+  # {Layout::TableColumn}'s right edge. If this is the last column of the table,
+  # this method will set the style for the table border.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   style = Layout::Style.new
+  #   style.stroke_width = 2.0
+  #   table.get_column(1).edge_style = style
+  #
+  # @param [Layout::Style] style
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def right_edge_style=(style)
+  end
+
+  # The {#width} method returns the width of the {Layout::TableColumn}.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   width = table.get_column(1).width
+  #
+  # @return [Float]
+  #
+  # @version LayOut 2018
+  def width
+  end
+
+  # The {#width=} method sets the width of the {Layout::TableColumn}.
+  #
+  # @example
+  #   bounds = Geom::Bounds2d.new(1, 1, 4, 4)
+  #   rows = 4
+  #   columns = 4
+  #   table = Layout::Table.new(bounds, rows, columns)
+  #   table.get_column(1).width = 6.0
+  #
+  # @param [Float] width
+  #
+  # @raise [ArgumentError] if width is not a valid width
+  #
+  # @raise [LockedEntityError] if the {Layout::Table} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Table} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def width=(width)
+  end
+
+end