sketchup-api-stubs 0.1.0

data/SketchUp/Sketchup/Console.rb

@@ -0,0 +1,78 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# The Console class is used by SketchUp to direct $stdout and $stderr to the
+# Ruby Console. It is a singleton class that only has one instance available.
+# This instance is accessible via the SKETCHUP_CONSOLE constant.
+#
+# In SketchUp 2014 methods were added to allow developers to control the
+# visibility of the Ruby Console.
+#
+# Also note that in SketchUp 2014, writing to the console does not work from
+# within Ruby threads other than the main thread. So the following code will
+# not produce any output.
+#
+# @example
+#   t = Thread.new { puts 'This will not be written to the console.' }
+#   t.join
+#
+# @example
+#   # By default $stdout is directed to SKETCHUP_CONSOLE.
+#   p $stdout
+#
+#   # $stdout can however be redirected so the safe way to access the
+#   # SketchUp console is by using the SKETCHUP_CONSOLE constant.
+#   p SKETCHUP_CONSOLE
+#
+# @version SketchUp 2014
+class Sketchup::Console
+
+  # Instance Methods
+
+  # Clears the contents of SketchUp's Ruby Console.
+  #
+  # @example
+  #   SKETCHUP_CONSOLE.clear
+  #
+  # @return true.
+  #
+  # @version SketchUp 2014
+  def clear
+  end
+
+  # Hides the SketchUp Ruby Console.
+  #
+  # @example
+  #   SKETCHUP_CONSOLE.hide
+  #
+  # @return true.
+  #
+  # @version SketchUp 2014
+  def hide
+  end
+
+  # Displays the SketchUp Ruby Console.
+  #
+  # @example
+  #   SKETCHUP_CONSOLE.show
+  #
+  # @return true.
+  #
+  # @version SketchUp 2014
+  def show
+  end
+
+  # Returns the visibility state of the SketchUp Ruby Console.
+  #
+  # @example
+  #   puts SKETCHUP_CONSOLE.visible?
+  #
+  # @return true if visible, false if not.
+  #
+  # @return [Boolean]
+  #
+  # @version SketchUp 2014
+  def visible?
+  end
+
+end

data/SketchUp/Sketchup/ConstructionLine.rb

@@ -0,0 +1,257 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# The ConstructionLine class contains methods for modifying construction
+# lines.  Construction lines can be infinite in length, semi-infinite (i.e.
+# infinite in one direction) or finite.
+#
+# @version SketchUp 6.0
+class Sketchup::ConstructionLine < Sketchup::Drawingelement
+
+  # Instance Methods
+
+  # The direction method retrieves a 3D vector in the direction of the
+  # construction line.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   constline = entities.add_cline(point1, point2)
+  #   vector = constline.direction
+  #   if (vector)
+  #     UI.messagebox(vector)
+  #   else
+  #     UI.messagebox("Failure")
+  #   end
+  #
+  # @return vector - a Vector3d object if successful
+  #
+  # @version SketchUp 6.0
+  def direction
+  end
+
+  # The direction= method is used to set the direction of the construction line
+  # to a 3D vector.
+  #
+  # @example
+  #   # Draw a construction line that points diagonally.
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   constline = entities.add_cline([10,10,10], [200,200,200])
+  #
+  #   # Create a new direction that is straight up, and redirect the line.
+  #   new_direction = [0, 0, 1]
+  #   constline.direction = new_direction
+  #
+  # @param vector
+  #   The Vector3d whose direction will be used to set the
+  #   direction of the construction line.
+  #
+  # @return vector - the new Vector3d object if successful
+  #
+  # @version SketchUp 6.0
+  def direction=(vector)
+  end
+
+  # The end method retrieves the end point of a construction line in the form of
+  # a 3D point.
+  #
+  # If the construction line is infinite at the end, this returns nil.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   constline = entities.add_cline(point1, point2)
+  #   endofline = constline.end
+  #
+  # @return point - a Point3d object representing the end of the
+  #   construction line
+  #
+  # @version SketchUp 6.0
+  def end
+  end
+
+  # The end= method is used to set the end point of the construction line. This
+  # method will make the length finite at the end.
+  #
+  # Set the end to nil to make the construction line infinite at the end.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   point3 = Geom::Point3d.new(10,10,10)
+  #   constline = entities.add_cline(point1, point2)
+  #   UI.messagebox(constline.end)
+  #   # Will display point2
+  #
+  # @overload end=(point)
+  #
+  #   @param [Geom::Point3d] point The Point3d object to set for the end point
+  #     of the construction line.
+  #   @return              point - a Point3d object if successful or nil
+  #
+  # @overload end=(nil)
+  #
+  #   @param [nil] nil Sets the end point to infinite.
+  #   @return              point - a Point3d object if successful or nil
+  #
+  # @version SketchUp 6.0
+  def end=(arg)
+  end
+
+  # The position method is used to retrieve a 3D point used to create a
+  # construction line on an infinite construction line.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   vector = Geom::Vector3d.new(10,10,10)
+  #   constline = entities.add_cline(point1, vector)
+  #   # Returns point1 or 0,0,0
+  #   position = constline.position
+  #
+  # @return point - the Point3d object used to create the line (if
+  #   successful)
+  #
+  # @version SketchUp 6.0
+  def position
+  end
+
+  # The position= method is used to set a 3D point that the construction passes
+  # through
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   point3 = Geom::Point3d.new(0,20,20)
+  #   constline = entities.add_cline(point1, point2)
+  #   position = constline.position = point3
+  #
+  # @param point
+  #   The Point3d object for the construction line to pass
+  #   through.
+  #
+  # @return point - the new Point3d object that the construction
+  #   line will pass through (if successful)
+  #
+  # @version SketchUp 6.0
+  def position=(point)
+  end
+
+  # The reverse! method is used to reverse the direction of the construction
+  # line.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   constline = entities.add_cline(point1, point2)
+  #   status = constline.reverse!
+  #
+  # @return status
+  #
+  # @version SketchUp 6.0
+  def reverse!
+  end
+
+  # The start method is used to retrieve the starting point of a construction
+  # line.
+  #
+  # If the construction line is infinite at the start, this returns nil.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   constline = entities.add_cline(point1, point2)
+  #   startofline = constline.start
+  #
+  # @return point - the Poin3d object representing the starting
+  #   point of the construction line (if successful)
+  #
+  # @version SketchUp 6.0
+  def start
+  end
+
+  # The start= method is used to set the start point of a construction line
+  # making the line's length finite at the start.
+  #
+  # Setting the start to nil will make the construction line infinite at the
+  # start.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   point3 = Geom::Point3d.new(5,5,5)
+  #   constline = entities.add_cline(point1, point2)
+  #   startofline = constline.start = point3
+  #
+  # @overload start=(point)
+  #
+  #   @param [Geom::Point3d] point The Point3d object to set for the start point
+  #     of the construction line.
+  #   @return              point - a Point3d object if successful or nil
+  #
+  # @overload start=(nil)
+  #
+  #   @param [nil] nil Sets the start point to infinite.
+  #   @return              point - a Point3d object if successful or nil
+  #
+  # @version SketchUp 6.0
+  def start=(arg)
+  end
+
+  # The stipple method is used to retrieve the stipple pattern used to display
+  # the construction line.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   constline = entities.add_cline(point1, point2)
+  #   UI.messagebox(constline.stipple)
+  #
+  # @return pattern - the stipple pattern being used
+  #
+  # @version SketchUp 6.0
+  def stipple
+  end
+
+  # The stipple= method is used to set the stipple pattern used to display
+  # the construction line. The stipple pattern is given as a string.
+  # Valid strings are:
+  # - <code>"."</code> (Dotted Line),
+  # - <code>"-"</code> (Short Dashes Line),
+  # - <code>"_"</code> (Long Dashes Line),
+  # - <code>"-.-"</code> (Dash Dot Dash Line).
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(0,0,0)
+  #   point2 = Geom::Point3d.new(20,20,20)
+  #   constline = entities.add_cline(point1, point2)
+  #   constline.stipple = "-.-"
+  #
+  # @param pattern
+  #   - the stipple pattern to use
+  #
+  # @version SketchUp 6.0
+  def stipple=(pattern)
+  end
+
+end

data/SketchUp/Sketchup/ConstructionPoint.rb

@@ -0,0 +1,32 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# A construction point represents a point in the model that can be used to aid
+# in other modeling operations. For example, you may put a construction point
+# at the center of a circle to make it easier to locate that point for
+# performing other operations.
+#
+# @version SketchUp 6.0
+class Sketchup::ConstructionPoint < Sketchup::Drawingelement
+
+  # Instance Methods
+
+  # The position method is used to retrieve a Point3d used to create a
+  # construction point.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   entities = model.active_entities
+  #   point1 = Geom::Point3d.new(10,0,0)
+  #   constpoint = entities.add_cpoint point1
+  #   # Returns 10,0,0
+  #   position = constpoint.position
+  #
+  # @return point - the Point3d object used to create the
+  #   ConstructionPoint
+  #
+  # @version SketchUp 6.0
+  def position
+  end
+
+end

data/SketchUp/Sketchup/Curve.rb

@@ -0,0 +1,196 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# The Curve class is used by SketchUp to unite a series of Edge objects into
+# one conceptual entity. Since SketchUp is a surface modeler, all circles,
+# arcs, and arbitrary curves are really just edges that are bound together in
+# sequence.
+#
+# There is a subclass of Curve called ArcCurve, which is any curve that makes
+# up part of a circle. You can think of ArcCurves as entities that were created
+# with SketchUp's Arc or Circle drawing tools and Curves as entities that were
+# created with the Freehand drawing tool.
+#
+# @version SketchUp 6.0
+class Sketchup::Curve < Sketchup::Entity
+
+  # Instance Methods
+
+  # The count_edges method is used to retrieve the number of Edge objects that
+  # make up the Curve.
+  #
+  # @example
+  #   centerpoint = Geom::Point3d.new
+  #   # Create a circle perpendicular to the normal or Z axis
+  #   vector = Geom::Vector3d.new 0,0,1
+  #   vector2 = vector.normalize!
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_circle centerpoint, vector2, 10
+  #   edge = edgearray[0]
+  #   curve = edge.curve
+  #   number = curve.count_edges
+  #
+  # @return num_edges - the number of edges in the curve
+  #
+  # @version SketchUp 6.0
+  def count_edges
+  end
+
+  # The each_edge method is used to iterate through all of the Edge objects in
+  # the curve.
+  #
+  # @example
+  #   centerpoint = Geom::Point3d.new
+  #   # Create a circle perpendicular to the normal or Z axis
+  #   vector = Geom::Vector3d.new 0,0,1
+  #   vector2 = vector.normalize!
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_circle centerpoint, vector2, 10
+  #   edge = edgearray[0]
+  #   curve = edge.curve
+  #   curve.each_edge {|e| UI.messagebox e}
+  #
+  # @return edge - a variable that will hold each Edge object as
+  #   they are found.
+  #
+  # @version SketchUp 6.0
+  def each_edge
+  end
+
+  # The edges method is used to retrieve an array of Edge objects that make up
+  # the Curve.
+  #
+  # @example
+  #   centerpoint = Geom::Point3d.new
+  #   # Create a circle perpendicular to the normal or Z axis
+  #   vector = Geom::Vector3d.new 0,0,1
+  #   vector2 = vector.normalize!
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_circle centerpoint, vector2, 10
+  #   edge = edgearray[0]
+  #   curve = edge.curve
+  #   edges = curve.edges
+  #
+  # @return edges - an array of Edge objects if successful
+  #
+  # @version SketchUp 6.0
+  def edges
+  end
+
+  # The first_edge method is used to retrieve the first edge of the curve.
+  #
+  # @example
+  #   centerpoint = Geom::Point3d.new
+  #   # Create a circle perpendicular to the normal or Z axis
+  #   vector = Geom::Vector3d.new 0,0,1
+  #   vector2 = vector.normalize!
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_circle centerpoint, vector2, 10
+  #   edge = edgearray[0]
+  #   curve = edge.curve
+  #   firstedge = curve.first_edge
+  #
+  # @return edge - the first Edge object in the curve if successful
+  #
+  # @version SketchUp 6.0
+  def first_edge
+  end
+
+  #
+  # @example
+  #   # Create a polygon and check its edge
+  #   ents = Sketchup.active_model.entities
+  #   ents.add_ngon [0, 0, 0], [0, 0, 1], 10, 6
+  #   curve = nil
+  #   ents.each { |e| curve = e.curve if e.is_a? Sketchup::Edge }
+  #   is_poly = curve.is_polygon?
+  #
+  # @return True if this edge was originally created by the polygon
+  #   tool, otherwise false.
+  #
+  # @return [Boolean]
+  #
+  # @version SketchUp 7.1 M1
+  def is_polygon?
+  end
+
+  # The last_edge method is used to retrieve the last edge of the curve.
+  #
+  # @example
+  #   centerpoint = Geom::Point3d.new
+  #   # Create a circle perpendicular to the normal or Z axis
+  #   vector = Geom::Vector3d.new 0,0,1
+  #   vector2 = vector.normalize!
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_circle centerpoint, vector2, 10
+  #   edge = edgearray[7]
+  #   curve = edge.curve
+  #   lastedge = curve.last_edge
+  #
+  # @return edge - the last Edge object in the curve if successful
+  #
+  # @version SketchUp 6.0
+  def last_edge
+  end
+
+  # The length method retrieves the length of the curve.
+  #
+  # @example
+  #   centerpoint = Geom::Point3d.new
+  #   # Create a circle perpendicular to the normal or Z axis
+  #   vector = Geom::Vector3d.new 0,0,1
+  #   vector2 = vector.normalize!
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_circle centerpoint, vector2, 10
+  #   edge = edgearray[7]
+  #   curve = edge.curve
+  #   length = curve.length
+  #
+  # @return length - the length of the curve in current units if
+  #   successful
+  #
+  # @version SketchUp 6.0
+  def length
+  end
+
+  # The vertices method retrieves a collection of all vertices in a curve.
+  #
+  # @example
+  #   # Need example ruby code here.
+  #
+  # @param point_array
+  #   Array of Point3d objects to move each vertex to match.
+  #
+  # @return success - true or false
+  #
+  # @version SketchUp 6.0
+  def move_vertices(point_array)
+  end
+
+  # The vertices method retrieves a collection of all vertices in a curve.
+  #
+  # @example
+  #   centerpoint = Geom::Point3d.new
+  #   # Create a circle perpendicular to the normal or Z axis
+  #   vector = Geom::Vector3d.new 0,0,1
+  #   vector2 = vector.normalize!
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_circle centerpoint, vector2, 10
+  #   edge = edgearray[7]
+  #   curve = edge.curve
+  #   vertices = curve.vertices
+  #
+  # @return vertices - a collection of the vertices
+  #
+  # @version SketchUp 6.0
+  def vertices
+  end
+
+end