sketchup-api-stubs 0.1.0

data/SketchUp/Sketchup/Animation.rb

@@ -0,0 +1,137 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# The {Sketchup::Animation} interface is implemented to create animations
+# inside SketchUp. At any given time, a single animation can be active on a
+# {Sketchup::View}. To make your own, build a Ruby class that contains the
+# methods described below:
+#
+#   # This is an example of a simple animation that floats the camera up to
+#   # a z position of 200". The only required method for an animation is
+#   # nextFrame. It is called whenever you need to show the next frame of
+#   # the animation. If nextFrame returns false, the animation will stop.
+#   class FloatUpAnimation
+#     def nextFrame(view)
+#       new_eye = view.camera.eye
+#       new_eye.z = new_eye.z + 1.0
+#       view.camera.set(new_eye, view.camera.target, view.camera.up)
+#       view.show_frame
+#       return new_eye.z < 500.0
+#     end
+#   end
+#
+#   # This adds an item to the Camera menu to activate our custom animation.
+#   UI.menu("Camera").add_item("Run Float Up Animation") {
+#     Sketchup.active_model.active_view.animation = FloatUpAnimation.new
+#   }
+#
+# {Sketchup::Animation} objects are activated by using the
+# {Sketchup::View#animation=} method on a {Sketchup::View}
+# object. To stop an animation set the view's animation object to +nil+, like
+# so:
+#
+#   Sketchup.active_model.active_view.animation = nil
+#
+# @version SketchUp 6.0
+class Sketchup::Animation
+
+  # Instance Methods
+
+  # The {#nextFrame} method is invoked by SketchUp to tell the animation to
+  # display its next frame. This method should set up the camera and then call
+  # {Sketchup::View#show_frame}.
+  #
+  # The {#nextFrame} method is the only required method of the
+  # {Sketchup::Animation} interface that you must implement.
+  #
+  # @example
+  #   def nextFrame(view)
+  #     # Insert your handler code for updating the camera or other entities.
+  #     view.show_frame
+  #     return true
+  #   end
+  #
+  # @param [Sketchup::View] view
+  #   The view for the animation.
+  #
+  # @return [Boolean] continue - +true+ if you want the animation to continue
+  #   on to the next frame, +false+ if you want the animation
+  #   to stop after this frame.
+  #
+  # @version SketchUp 6.0
+  #
+  # @version SketchUp 6.0
+  def nextFrame(view)
+  end
+
+  # The {#pause} method is invoked by SketchUp when the animation is paused.
+  #
+  # This method is optional (you do not need to implement this method unless you
+  # want to perform some specialized function when the animation is paused). You
+  # cannot call this method in your code explicitly and expect an animation to
+  # pause, only certain SketchUp events cause the method to be called.
+  #
+  # @example
+  #   def pause
+  #     # Insert handler code for whatever you need to do when it is paused.
+  #   end
+  #
+  # @note The user interface for pausing and resuming animations isn't integrated
+  #   with the Ruby API in the current version, so this method is probably not
+  #   useful to you.
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 6.0
+  def pause
+  end
+
+  # The {#resume} method is invoked by SketchUp when the animation is resumed
+  # after being paused.
+  #
+  # This method is optional (you do not need to implement this method unless you
+  # want to perform some specialized function when the animation is resumed).
+  # You cannot call this method in your code explicitly and expect an animation
+  # to stop, only certain SketchUp events cause the method to be called.
+  #
+  # @example
+  #   def resume
+  #     # Insert your handler code for whatever you need to do as you resume.
+  #   end
+  #
+  # @note The user interface for pausing and resuming animations isn't integrated
+  #   with the Ruby API in the current version, so this method is probably not
+  #   useful to you.
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 6.0
+  def resume
+  end
+
+  # The {#stop} method is invoked by SketchUp when the animation is stopped.
+  #
+  # This method is optional (you do not need to implement this method unless you
+  # want to perform some specialized function when the animation is stopped). You
+  # cannot call this method in your code explicitly and expect an animation to
+  # stop, only certain SketchUp events cause the method to be called.
+  #
+  # Perhaps the most common way for this method to be called is when your Ruby
+  # code sets {Sketchup::View#animation=} to +nil+. See the class comments for
+  # an example of this.
+  #
+  # @example
+  #   def stop
+  #     # Insert your handler code for cleaning up after your animation.
+  #   end
+  #
+  # @note Do not call +view.animation = nil+ within this method! This will cause
+  #   a recursive loop and crash SketchUp.
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 6.0
+  def stop
+  end
+
+end

data/SketchUp/Sketchup/AppObserver.rb

@@ -0,0 +1,157 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# This observer interface is implemented to react to application events.
+# This interface is often used to attach other observers to models as they
+# are opened or started.
+# This ensures that your observers are watching all open models.
+#
+# For example, when one attaches a {Sketchup::SelectionObserver}, it is only
+# attached to the {Sketchup::Selection} collection of a given model. If a 2nd
+# model is opened, the new model's selection changes will not fire selection
+# callbacks unless you've attached a {Sketchup::SelectionObserver} to the new
+# model as well. By watching for {#onNewModel}, you can be sure to do so.
+#
+# To implement this observer, create a Ruby class of this type, override the
+# desired methods, and add an instance of the observer to the
+# application class.
+#
+# @example
+#   # This is an example of an observer that watches the application for
+#   # new models and shows a messagebox.
+#   class MyAppObserver < Sketchup::AppObserver
+#     def onNewModel(model)
+#       puts "onNewModel: #{model}"
+#
+#       # Here is where one might attach other observers to the new model.
+#       model.selection.add_observer(MySelectionObserver.new)
+#     end
+#   end
+#
+#   # Attach the observer
+#   Sketchup.add_observer(MyAppObserver.new)
+#
+# @version SketchUp 6.0
+class Sketchup::AppObserver
+
+  # Instance Methods
+
+  # The {#expectsStartupModelNotifications} method is called to determine if the
+  # observer expects to receive {#onNewModel} and {#onOpenModel} calls for the
+  # models that are created or opened at SketchUp startup. This includes the
+  # empty initial model, a model opened via command line arguments, or
+  # auto-restored models on Mac OS X.
+  #
+  # @example
+  #   def expectsStartupModelNotifications
+  #     return true
+  #   end
+  #
+  # @note Prior to SketchUp 2014, {#onNewModel} and {#onOpenModel} were
+  #   not being called for the startup models. This issue is now fixed but
+  #   observers still need to express their intent to receive these calls. This is
+  #   for back-compatibility with existing scripts which worked around these
+  #   missing calls by other means. For new code, this method should be implemented
+  #   and should return +true+.
+  #
+  # @return [Boolean] +true+ to receive {#onNewModel} and {#onOpenModel} calls
+  #   for startup models. Return +false+ or simply not
+  #   implement the method in order to not receive these calls
+  #   (which was the behavior prior to SketchUp 2014).
+  #
+  # @version SketchUp 2014
+  def expectsStartupModelNotifications
+  end
+
+  # The {#onActivateModel} method is called when an open model is activated. This
+  # is relevant on Mac only which supports multiple documents to be opened
+  # simultaneously.
+  #
+  # @example
+  #   def onActivateModel(model)
+  #     puts "onActivateModel: #{model}"
+  #   end
+  #
+  # @param [Sketchup::Model] model
+  #   The newly-activated model object.
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 2015
+  def onActivateModel(model)
+  end
+
+  # The {#onNewModel} method is called when the application creates a new, empty
+  # model.
+  #
+  # @example
+  #   def onNewModel(model)
+  #     puts "onNewModel: #{model}"
+  #   end
+  #
+  # @param [Sketchup::Model] model
+  #   The active model object.
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 6.0
+  def onNewModel(model)
+  end
+
+  # The {#onOpenModel} method is called when the application opens an existing
+  # model.
+  #
+  # @example
+  #   def onOpenModel(model)
+  #     puts "onOpenModel: #{model}"
+  #   end
+  #
+  # @note If a skp file is loaded via the command line or double-clicking on
+  #   a skp in explorer (which is also is the command line) then this
+  #   observer will not be called.  The Ruby interpreter in SketchUp is
+  #   initialized after command line processing so the observer won't
+  #   be added in time to get the notification.
+  #
+  # @param [Sketchup::Model] model
+  #   The active model object.
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 6.0
+  def onOpenModel(model)
+  end
+
+  # The {#onQuit} method is called when SketchUp closes. This is useful if you
+  # need to clean up anything or store your application state upon close.
+  #
+  # @example
+  #   def onQuit()
+  #     puts "onQuit"
+  #   end
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 6.0
+  def onQuit
+  end
+
+  # The {#onUnloadExtension} method is called when the user turns off a Ruby
+  # extension. This is useful for detecting if the user is deactivating
+  # some critical set of observers, for example, so you can warn them
+  # or cache your extension state.
+  #
+  # @example
+  #   def onUnloadExtension(extension_name)
+  #     puts "onUnloadExtension: #{extension_name}"
+  #   end
+  #
+  # @param [String] extension_name
+  #   The name of the extension just unloaded.
+  #
+  # @return [nil]
+  #
+  # @version SketchUp 7.0
+  def onUnloadExtension(extension_name)
+  end
+
+end

data/SketchUp/Sketchup/ArcCurve.rb

@@ -0,0 +1,209 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# An ArcCurve is a Curve that makes up part of a circle. This is the
+# underlying class for circles as well.
+#
+# 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.
+#
+# However, keep in mind that all Curves in SketchUp are really edges with
+# some extra data attached to them. When you use the API to draw a Curve or
+# ArcCurve, you are really drawing edges.
+#
+# ArcCurve is a subclass of Curve, so all of the methods that are available
+# to Curves are also available to ArcCurves.
+#
+# @example
+#   # Draw a circle on the ground plane around the origin.
+#   center_point = Geom::Point3d.new(0,0,0)
+#   normal_vector = Geom::Vector3d.new(0,0,1)
+#   radius = 10
+#
+#   entities = Sketchup.active_model.entities
+#   edgearray = entities.add_circle center_point, normal_vector, radius
+#   first_edge = edgearray[0]
+#   arccurve = first_edge.curve
+#
+# @version SketchUp 6.0
+class Sketchup::ArcCurve < Sketchup::Curve
+
+  # Instance Methods
+
+  # The center method is used to retrieve the Point3d that is at the center of
+  # the circular arc.
+  #
+  # @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]
+  #   arccurve = edge.curve
+  #   point = arccurve.center
+  #
+  # @return point - a Point3d at the center of the arc if
+  #   successful
+  #
+  # @version SketchUp 6.0
+  def center
+  end
+
+  # The end_angle method is used to retrieve the angle of the end of the arc
+  # measured from the X axis in radians.
+  #
+  # @example
+  #   # Create a 1/2 circle, normal to the Z axis
+  #   center = Geom::Point3d.new
+  #   normal = Geom::Vector3d.new 0,0,1
+  #   xaxis = Geom::Vector3d.new 1,0,0
+  #   start_a = 0.0
+  #   end_a = Math::PI
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_arc center, xaxis, normal, 5, start_a, end_a
+  #   edge = edgearray[0]
+  #   arccurve = edge.curve
+  #   end_angle = arccurve.end_angle
+  #
+  # @return angle - the angle of the end of the arc if successful
+  #
+  # @version SketchUp 6.0
+  def end_angle
+  end
+
+  # The normal method retrieves a Vector3d that is perpendicular to the plane of
+  # the arc.
+  #
+  # @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]
+  #   arccurve = edge.curve
+  #   v = arccurve.normal
+  #
+  # @return vector - a Vector3d object if successful
+  #
+  # @version SketchUp 6.0
+  def normal
+  end
+
+  # The plane method is used to retrieve the plane of the arc.
+  #
+  # Refer to the Geom module for instructions to create a plane.
+  #
+  # @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]
+  #   arccurve = edge.curve
+  #   plane = arccurve.plane
+  #
+  # @return plane - the plane of the arc if successful
+  #
+  # @version SketchUp 6.0
+  def plane
+  end
+
+  # The radius method is used to retrieve the radius of the arc.
+  #
+  # @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]
+  #   arccurve = edge.curve
+  #   radius = arccurve.radius
+  #
+  # @return radius - the radius of the arc if successful
+  #
+  # @version SketchUp 6.0
+  def radius
+  end
+
+  # The start_angle method is used to retrieve the angle of the start of the
+  # arc, measured from the X axis in radians.
+  #
+  # @example
+  #   # Create a 1/4 circle, radius of 5, normal to the Z axis
+  #   center = Geom::Point3d.new 0, 0, -1
+  #   normal = Geom::Vector3d.new 0,0,1
+  #   xaxis = Geom::Vector3d.new 1,0,0
+  #   start_a = Math::PI/2
+  #   end_a = Math::PI
+  #   model = Sketchup.active_model
+  #   entities = model.entities
+  #   edgearray = entities.add_arc center, xaxis, normal, 5, start_a, end_a
+  #   edge = edgearray[0]
+  #   arccurve = edge.curve
+  #   start_angle = arccurve.start_angle
+  #
+  # @return angle - the angle of the start of the arc if successful
+  #
+  # @version SketchUp 6.0
+  def start_angle
+  end
+
+  # The xaxis method is used to retrieve the X axis of the coordinate system for
+  # the curve. Note that the length of the returned vector is equal to the radius
+  # of the underlying 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]
+  #   arccurve = edge.curve
+  #   v = arccurve.xaxis
+  #
+  # @return vector - a Vector3d object if successful
+  #
+  # @version SketchUp 6.0
+  def xaxis
+  end
+
+  # The yaxis method is used to retrieve the Y axis of the coordinate system for
+  # the curve. Note that the length of the returned vector is equal to the radius
+  # of the underlying 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]
+  #   arccurve = edge.curve
+  #   v = arccurve.yaxis
+  #
+  # @return vector - a Vector3d object if successful
+  #
+  # @version SketchUp 6.0
+  def yaxis
+  end
+
+end