sketchup-api-stubs 0.1.0

data/SketchUp/Sketchup/Texture.rb

@@ -0,0 +1,211 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# The Texture class contains methods for obtaining information about textures
+# that are part of your materials in your model (within the In-Model section
+# of the Materials Browser). Remember, textures are repeatable images that
+# "tile" when painted on a surface.
+#
+# @version SketchUp 6.0
+class Sketchup::Texture < Sketchup::Entity
+
+  # Instance Methods
+
+  # The average_color method retrieves a color object with the average color
+  # found in the texture.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   materials=model.materials
+  #   # Adds a material as an in model material
+  #   m = materials.add "Test Color"
+  #   begin
+  #     # Returns nil if not successful, path if successful
+  #     m.texture = "c:\\Materials\\Carpet.jpg"
+  #   rescue
+  #     UI.messagebox $!.message
+  #   end
+  #   texture = m.texture
+  #   # Returns a color object
+  #   color = texture.average_color
+  #   if (color)
+  #     UI.messagebox color
+  #   else
+  #     UI.messagebox "Failure: No average color"
+  #   end
+  #
+  # @return color - a color object (if successful), nil if
+  #   unsuccessful.
+  #
+  # @version SketchUp 6.0
+  def average_color
+  end
+
+  # The filename method retrieves the entire path, including the file, for a
+  # texture object.
+  #
+  # @example
+  #   model = Sketchup.active_model
+  #   materials=model.materials
+  #   # Adds a material as an in model material
+  #   m = materials.add "Test Color"
+  #   begin
+  #     # Returns nil if not successful, path if successful
+  #     m.texture = "c:\\Materials\\Carpet.jpg"
+  #   rescue
+  #     UI.messagebox $!.message
+  #   end
+  #   texture = m.texture
+  #   filename = texture.filename
+  #   if (filename)
+  #     UI.messagebox filename
+  #   else
+  #     UI.messagebox "Failure"
+  #   end
+  #
+  # @return filename - a string representation of the path and
+  #   filename used for the texture.
+  #
+  # @version SketchUp 6.0
+  def filename
+  end
+
+  # The height method is used to get the height of a repeatable texture image,
+  # in inches.
+  #
+  # @example
+  #   height = texture.height
+  #
+  # @return height - the height, in inches, of the texture pattern
+  #
+  # @version SketchUp 6.0
+  def height
+  end
+
+  # The image_height method retrieves the height of the repeatable texture
+  # image, in pixels.
+  #
+  # @example
+  #   imageheight = texture.image_height
+  #   if (imageheight)
+  #     UI.messagebox imageheight
+  #   else
+  #     UI.messagebox "Failure"
+  #   end
+  #
+  # @return imageheight - the height, in pixels, of the texture
+  #   pattern
+  #
+  # @version SketchUp 6.0
+  def image_height
+  end
+
+  # The image_width method retrieves the width of the repeatable texture image,
+  # in pixels.
+  #
+  # @example
+  #   imagewidth = texture.image_width
+  #   if (imagewidth)
+  #     UI.messagebox imagewidth
+  #   else
+  #     UI.messagebox "Failure"
+  #   end
+  #
+  # @return imagewidth - the width, in pixels, of the texture
+  #   pattern
+  #
+  # @version SketchUp 6.0
+  def image_width
+  end
+
+  # The size= method allows you to set the size of the repeatable texture image,
+  # in inches,
+  #
+  # @example
+  #   size = texture.size = 60
+  #   imagewidth = texture.width
+  #
+  #   if (imagewidth)
+  #     UI.messagebox imagewidth
+  #   else
+  #     UI.messagebox "Failure"
+  #   end
+  #
+  #   # Using two values which will not preserve ratio
+  #   width_height = texture.size = [10,100]
+  #   if (width_height)
+  #     UI.messagebox width_height
+  #   else
+  #     UI.messagebox "Failure"
+  #   end
+  #
+  # @param size
+  #   The size, in inches, of the texture. This number will
+  #   apply to height and width to keep aspect ratio.
+  #   You can also pass as a parameter an array of two
+  #   numeric values which will set width and height
+  #   regardless of maintaining the height/width ratio.
+  #
+  # @return size - the size, in inches, of the texture. This number
+  #   will apply to height and width to keep aspect ratio.
+  #   If you have passed in an array of two numbers for width
+  #   and height, the same array will be returned if
+  #   successful.
+  #
+  # @version SketchUp 6.0
+  def size=(size)
+  end
+
+  # The valid? method ensures that a texture is valid.
+  #
+  # @example
+  #   status = texture.valid?
+  #   if (status)
+  #     UI.messagebox status
+  #   else
+  #     UI.messagebox status
+  #   end
+  #
+  # @return status - true if valid, false if invalid.
+  #
+  # @return [Boolean]
+  #
+  # @version SketchUp 6.0
+  def valid?
+  end
+
+  # The width method is used to get the width of a repeatable texture image,
+  # in inches.
+  #
+  # @example
+  #   width = texture.width
+  #
+  # @return width - the width, in inches, of the texture pattern
+  #
+  # @version SketchUp 6.0
+  def width
+  end
+
+  # Writes the texture to file with option to preserve the color adjustments made
+  # by the material.
+  #
+  # @example
+  #   material = Sketchup.active_model.materials[0]
+  #   basename = File.basename(material.texture.filename)
+  #   filename = File.join(Sketchup.temp_dir, basename)
+  #   material.texture.write(filename)
+  #
+  # @param filename
+  #   String - The filename to write the texture to.
+  #
+  # @param colorize
+  #   Boolean - Allows for the texture to
+  #   be exported with the color adjustments.
+  #
+  # @return Boolean - true if the method succeeded
+  #
+  # @version SketchUp 2016
+  def write(filename, colorize = false)
+  end
+
+end

data/SketchUp/Sketchup/TextureWriter.rb

@@ -0,0 +1,237 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# The TextureWriter class is used primarily for writing the textures used in a
+# SketchUp model out to files as part of an export for use in another
+# application. These methods are usually invoked in this order:
+#
+#   - 1. load - load one or more textures from a model into the TextureWriter.
+#   - 2. write_all or write - write the texture(s) to file.
+#
+# @example
+#   # This code snippet sets up a texture writer and some variables that are
+#   # used in the following texture writer examples.
+#   # Assumptions:
+#   # 1) The active model contains at least one entity at the root level of the
+#   #    following types: component instance, group, or image.
+#   # 2) The active model contains at least one face at the root level.
+#   model = Sketchup.active_model
+#   entities = model.entities
+#   faces = entities.grep(Sketchup::Face)
+#   texturable_entities = entities.select{ |ent|
+#       (ent.is_a?(Sketchup::ComponentInstance) ||
+#        ent.is_a?(Sketchup::Group) || ent.is_a?(Sketchup::Image)) }
+#   tw = Sketchup.create_texture_writer
+#
+# @version SketchUp 6.0
+class Sketchup::TextureWriter
+
+  # Instance Methods
+
+  # The {#length} method is used to determine the number of textures loaded into
+  # the texture writer.
+  #
+  # The {#count} method is an alias for {#length}.
+  #
+  # @example
+  #   length = tw.length
+  #   tw.load(texturable_entities[0])
+  #   if length < tw.length
+  #     puts("A new entity was successfully loaded into the writer.")
+  #   end
+  #
+  # @return [Integer] length - the number of textures loaded in the texture
+  #   writer
+  #
+  # @version SketchUp 6.0
+  def count
+  end
+
+  # The filename method is used to retrieve the original filename for a
+  # particular texture.
+  #
+  # @example
+  #   index = tw.load(texturable_entities[0])
+  #   filename = tw.filename(index)
+  #   puts("filename = #{filename}")
+  #
+  # @param [Integer] handle
+  #   The index or handle of the texture in the texture
+  #   writer.
+  #
+  # @return [String] filename - the filename of the texture on the file system.
+  #   Textures can be generated without filenames, so if the
+  #   texture doesn't have a name write_all will save the
+  #   texture to an image file named "i.png". Where i is the
+  #   first integer greater than zero which was not already used
+  #   for a png file name.
+  #
+  # @version SketchUp 6.0
+  def filename(handle)
+  end
+
+  # The handle method is used to retrieve a handle or index for a specific
+  # texture in the texture writer.
+  #
+  # @example
+  #   load_front_face = true
+  #   tw.load(faces[0], load_front_face)
+  #   handle = tw.handle(faces[0], load_front_face)
+  #
+  # @example
+  #   tw.load(texturable_entities[0])
+  #   handle = tw.handle(texturable_entities[0])
+  #
+  # @overload handle(entity)
+  #
+  #   @param [Sketchup::Entity] entity  A image, component instance, group, or
+  #                                     layer.
+  #   @return [Integer] the index for the entity in the texture writer.
+  #
+  # @overload handle(face, side)
+  #
+  #   @param [Sketchup::Face] face
+  #   @param [Boolean] side  Specifies one of the sides of the face
+  #                          (true if front, false if back.)
+  #   @return [Integer] the index for the entity in the texture writer.
+  #
+  # @version SketchUp 6.0
+  def handle(*args)
+  end
+
+  # The {#length} method is used to determine the number of textures loaded into
+  # the texture writer.
+  #
+  # The {#count} method is an alias for {#length}.
+  #
+  # @example
+  #   length = tw.length
+  #   tw.load(texturable_entities[0])
+  #   if length < tw.length
+  #     puts("A new entity was successfully loaded into the writer.")
+  #   end
+  #
+  # @return [Integer] length - the number of textures loaded in the texture
+  #   writer
+  #
+  # @version SketchUp 6.0
+  def length
+  end
+
+  # The load method is used to load one or more textures into the texture writer
+  # for writing out to a file.
+  #
+  # @example
+  #   index = tw.load(faces[0], true)
+  #
+  # @example
+  #   index = tw.load(texturable_entities[0])
+  #
+  # @note If you are passing a face in as the entity argument when loading a
+  #   texture you will have to specify the second boolean argument, side.
+  #   The argument side specifies which side of the face the texture will be
+  #   loaded from.
+  #
+  # @overload load(entity)
+  #
+  #   @param [Sketchup::Entity] entity Image, component instance, group, or layer
+  #                                      to load.
+  #   @return [Integer] handle - the index or handle of the entity that was
+  #                     loaded
+  #
+  # @overload load(face, side)
+  #
+  #   @param [Sketchup::Face] face A face to load.
+  #   @param [Boolean] side        A boolean used to indicate the side of the
+  #                                face being loaded (true if front, false if
+  #                                back).
+  #   @return [Integer] handle - the index or handle of the entity that was
+  #                     loaded
+  #
+  # @version SketchUp 6.0
+  def load(*args)
+  end
+
+  # The write method is used to write an individual textures, within the texture
+  # writer, to a file. An entity's texture must have been loaded into the texture
+  # writer before this method can be used to write it's texture.
+  #
+  # This method will return one of the following status messages. (These are
+  # constants that are defined by the API.)
+  #
+  #   - 0 = FILE_WRITE_OK
+  #   - 1 = FILE_WRITE_FAILED_INVALID_TIFF
+  #   - 2 = FILE_WRITE_FAILED_UNKNOWN
+  #
+  # @example
+  #   tw.load(faces[0], true)
+  #   if tw.write(faces[0], true, "C:\\textures\\Face.png") == FILE_WRITE_OK
+  #     puts("PNG file successfully written.")
+  #   end
+  #   if tw.write(faces[0], true, "C:\\textures\\Face.bmp") == FILE_WRITE_OK
+  #     puts("BMP file successfully written.")
+  #   end
+  #   if tw.write(faces[0], true, "C:\\textures\\Face.tif") == FILE_WRITE_OK
+  #     puts("TIFF file successfully written.")
+  #   end
+  #
+  # @example
+  #   tw.load(texturable_entities[0])
+  #   if tw.write(texturable_entities[0], "C:\\textures\\A.jpg") == FILE_WRITE_OK
+  #     puts("JPEG file successfully written.")
+  #   end
+  #
+  # @note If you are passing a face in as the entity argument when writing a
+  #   texture you will have to specify the boolean argument, side. The argument
+  #   side controls the side of the face from which the texture will be sampled
+  #   before writing it.
+  #
+  # @overload write(entity, filename)
+  #
+  #   @param [Sketchup::Entity] entity An image, component instance, group, or
+  #                                    layer to write.
+  #   @param [String] filename         The name of the file to contain the
+  #                                    texture.
+  #   @return [Integer] status - one of three status messages (see comments.)
+  #
+  # @overload write(entity, side, filename)
+  #
+  #   @param [Sketchup::Entity] entity A face to write.
+  #   @param [Boolean] side            A boolean used to indicate the side of the
+  #                                    face being written (true if front, false
+  #                                    if back).
+  #   @param [String] filename         The name of the file to contain the
+  #                                    texture.
+  #   @return [Integer] status - one of three status messages (see comments.)
+  #
+  # @version SketchUp 6.0
+  def write(*args)
+  end
+
+  # The write_all method is used to write all of the textures within the texture
+  # writer to files. It will return one of three status numbers:
+  #
+  #   - 0 = FILE_WRITE_OK
+  #   - 1 = FILE_WRITE_FAILED_INVALID_TIFF
+  #   - 2 = FILE_WRITE_FAILED_UNKNOWN
+  #
+  # @example
+  #   tw.load(texturable_entities[0]
+  #   tw.load(faces[0], false)
+  #   if tw.write_all("C:\\textures\\", true) == FILE_WRITE_OK
+  #     puts("Texture files were successfully written.")
+  #   end
+  #
+  # @param [String] dirname
+  #   The directory to write to.
+  #
+  # @param [Boolean] filename_format
+  #   true to use 8.3 DOS name format.
+  #
+  # @return [Integer] status - one of three status messages (see comments.)
+  #
+  # @version SketchUp 6.0
+  def write_all(dirname, filename_format)
+  end
+
+end

data/SketchUp/Sketchup/Tool.rb

@@ -0,0 +1,808 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# Tool is the interface that you implement to create a SketchUp tool.
+# See the file Plugins/Examples/linetool.rb (in your SketchUp install
+# directory) for an example of how to create a custom tool in Ruby.
+#
+# To create a new tool in Ruby, you must define a new class that implements
+# the methods for the events that you want to respond to. You do not have
+# to implement methods for every possible event that a Tool can respond to.
+#
+# Once you have defined a tool class, you select that tool by creating an
+# instance of it and passing it to {Sketchup::Model#select_tool}. For
+# example:
+#
+#   class MyTool
+#     def activate
+#       puts 'Your tool has been activated.'
+#     end
+#   end
+#
+#   my_tool = MyTool.new
+#   Sketchup.active_model.select_tool(my_tool)
+#
+# The following table contains several constants you can use when check for
+# certain key presses inside the keyboard handling callbacks:
+#
+# - +CONSTRAIN_MODIFIER_KEY+ = Shift Key
+# - +CONSTRAIN_MODIFIER_MASK+ = Shift Key
+# - +COPY_MODIFIER_KEY+ = Menu on Mac, Ctrl on PC
+# - +COPY_MODIFIER_MASK+ = Alt on Mac, Ctrl on PC
+# - +ALT_MODIFIER_KEY+ = Command on Mac, Menu on PC
+# - +ALT_MODIFIER_MASK+ = Command on Mac, Alt on PC
+#
+# @version SketchUp 6.0
+class Sketchup::Tool
+
+  # Instance Methods
+
+  # The activate method is called by SketchUp when the tool is selected.
+  # It is a good place to put most of your initialization, such as instance
+  # variables to track the state of the tool.
+  #
+  # @example
+  #   def activate
+  #     puts 'Your tool has been activated.'
+  #   end
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def activate
+  end
+
+  # The deactivate method is called when the tool is deactivated because a
+  # different tool was selected.
+  #
+  # @example
+  #   def deactivate(view)
+  #     puts "Your tool has been deactivated in view: #{view}"
+  #   end
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def deactivate(view)
+  end
+
+  # The {#draw} method is called by SketchUp whenever the view is refreshed to
+  # allow the tool to do its own drawing. If the tool has some temporary graphics
+  # that it wants displayed while it is active, it should implement this method
+  # and draw to the {Sketchup::View}.
+  #
+  # @example
+  #   def draw(view)
+  #     # Draw a square.
+  #     points = [
+  #       Geom::Point3d.new(0, 0, 0),
+  #       Geom::Point3d.new(9, 0, 0),
+  #       Geom::Point3d.new(9, 9, 0),
+  #       Geom::Point3d.new(0, 9, 0)
+  #     ]
+  #     # Fill
+  #     view.drawing_color = Sketchup::Color.new(255, 128, 128)
+  #     view.draw(GL_QUADS, points)
+  #     # Outline
+  #     view.line_stipple = '' # Solid line
+  #     view.drawing_color = Sketchup::Color.new(64, 0, 0)
+  #     view.draw(GL_LINE_LOOP, points)
+  #   end
+  #
+  # @note If you draw outside the model bounds you need to implement
+  #   {Tool#getExtents} which return a bounding box large enough to include the
+  #   points you draw. Otherwise your drawing will be clipped.
+  #
+  # @param [Sketchup::View] view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @see Sketchup::View#draw
+  #
+  # @see getExtents
+  #
+  # @version SketchUp 6.0
+  def draw(view)
+  end
+
+  # The enableVCB? method is used to tell SketchUp whether to allow the user to
+  # enter text into the VCB (value control box, aka the "measurements" panel).
+  # If you do not implement this method, then the vcb is disabled by default.
+  #
+  # @example
+  #   # For this tool, allow vcb text entry while the tool is active.
+  #   def enableVCB?
+  #     return true
+  #   end
+  #
+  # @return enable - true if you want the VCB enabled
+  #
+  # @return [Boolean]
+  #
+  # @version SketchUp 6.0
+  def enableVCB?
+  end
+
+  # In order to accurately draw things, SketchUp needs to know the extents of
+  # what it is drawing. If the tool is doing its own drawing, it may need to
+  # implement this method to tell SketchUp the extents of what it will be
+  # drawing. If you don't implement this method, you may find that part of what
+  # the tool is drawing gets clipped to the extents of the rest of the
+  # model.
+  #
+  # This must return a BoundingBox. In a typical implementation, you
+  # will create a new BoundingBox, add points to set the extents of the drawing
+  # that the tool will do and then return it.
+  #
+  # @example
+  #   def getExtents
+  #     bb = Sketchup.active_model.bounds
+  #     return bb
+  #   end
+  #
+  # @return BoundingBox - a BoundingBox object
+  #
+  # @version SketchUp 6.0
+  def getExtents
+  end
+
+  # The getInstructorContentDirectory method is used to tell SketchUp the
+  # directory containing your Tool's instructor content. To use this, create
+  # a custom instructor directory, put an index.html file inside of it, and then
+  # return that path via this method. If the SketchUp user has the Instructor
+  # window open when they activate your tool, they will see your html file.
+  #
+  # NOTE: Prior to SketchUp 2014 this method would assume the path was relative
+  # to the SketchUp resource folder. From 2014 and onwards you can specify the
+  # absolute path to an HTML file or the absolute path to a directory containing
+  # an index.html file.
+  #
+  # @example
+  #   def getInstructorContentDirectory
+  #     extension_path = Sketchup.extensions['MyExtension].extension_path
+  #     instructor_path = File.join(extension_path, 'MyExtension', 'instructor')
+  #     return instructor_path
+  #   end
+  #
+  # @return directory - the string directory where the Instructor
+  #   content exists.
+  #
+  # @version SketchUp 6.0
+  def getInstructorContentDirectory
+  end
+
+  # The getMenu method is called by SketchUp to let the tool provide its own
+  # context menu. Most tools will not want to implement this method and,
+  # instead, use the normal context menu found on all entities.
+  #
+  # If you do implement this method, the argument is a Menu. You should use the
+  # add_item method to build the context menu.
+  #
+  # Your tool will use a standard context menu by default if you do not
+  # implement this method. Implement this method if you want a context-click to
+  # display something other than this default context menu.
+  #
+  # In SketchUp 2015 the flags, x, y and view parameters were added. They are
+  # needed if you need to pick the entities under the mouse position. The new
+  # parameters are optional, but if you need to use one you must include them
+  # all.
+  #
+  # @example
+  #   if Sketchup.version.to_i < 15
+  #     # Compatible with SketchUp 2014 and older:
+  #     def getMenu(menu)
+  #       menu.add_item('Say Hello') {
+  #         UI.messagebox('Hello')
+  #       }
+  #     end
+  #   else
+  #     # Only works with SketchUp 2015 and newer:
+  #     def getMenu(menu, flags, x, y, view)
+  #       ph = view.pick_helper(x, y)
+  #       entity = ph.best_picked
+  #       if entity
+  #         view.model.selection.clear
+  #         view.model.selection.add(entity)
+  #         menu.add_item("Erase #{entity.typename}") {
+  #           entity.erase!
+  #         }
+  #      end
+  #    end
+  #   end
+  #
+  # @param [optional] flags
+  #   A bit mask that tells the state of the
+  #   modifier keys and other mouse buttons at the time.
+  #   Added in SU2015.
+  #
+  # @param menu
+  #   A Menu object.
+  #
+  # @param [optional] x
+  #   The X coordinate on the screen where the
+  #   event occurred. Added in SU2015.
+  #
+  # @param [optional] view
+  #   A View object where the method was invoked.
+  #   Added in SU2015.
+  #
+  # @param [optional] y
+  #   The Y coordinate on the screen where the
+  #   event occurred. Added in SU2015.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def getMenu(menu, flags, x, y, view)
+  end
+
+  # The onCancel method is called by SketchUp to cancel the current operation of
+  # the tool. The typical response will be to reset the tool to its initial
+  # state.
+  #
+  # The reason identifies the action that triggered the call. The reason can be
+  # one of the following values:
+  #
+  # - +0+: the user canceled the current operation by hitting the escape key.
+  # - +1+: the user re-selected the same tool from the toolbar or menu.
+  # - +2+: the user did an undo while the tool was active.
+  #
+  # @example
+  #   def onCancel(reason, view)
+  #     puts "MyTool was canceled for reason ##{reason} in view: #{view}"
+  #   end
+  #
+  # @param reason
+  #   A reason value (see comments).
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onCancel(reason, view)
+  end
+
+  # The onKeyDown method is called by SketchUp when the user presses a key on
+  # the keyboard. If you want to get input from the VCB, you should implement
+  # onUserText rather than this method.
+  #
+  # This method is can be used for special keys such as the Shift key, Ctrl key,
+  # and so on, or for just determining which key a user pressed. This method is
+  # actually called for all keys that are pressed.
+  #
+  # There are several
+  # "virtual keys" defined as constants you can use.  Their use is cross
+  # platform. They are:
+  #
+  # - +VK_ALT+
+  # - +VK_COMMAND+
+  # - +VK_CONTROL+
+  # - +VK_DELETE+
+  # - +VK_DOWN+
+  # - +VK_END+
+  # - +VK_HOME+
+  # - +VK_INSERT+
+  # - +VK_LEFT+
+  # - +VK_MENU+
+  # - +VK_NEXT+
+  # - +VK_PRIOR+
+  # - +VK_RIGHT+
+  # - +VK_SHIFT+
+  # - +VK_SPACE+
+  # - +VK_UP+
+  #
+  # V6: There is a bug on Windows where the typematic effect does
+  # not work. Typematic effects work fine on a Mac.
+  #
+  # @example
+  #   def onKeyDown(key, repeat, flags, view)
+  #     puts "onKeyDown: key = #{key}"
+  #     puts "        repeat = #{repeat}"
+  #     puts "         flags = #{flags}"
+  #     puts "          view = #{view}"
+  #   end
+  #
+  # @param key
+  #   The key that was pressed.
+  #
+  # @param repeat
+  #   A value of 1 for a single press of a key.  A value of 2
+  #   if the user has pressed a key and is holding it down.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys at
+  #   the time of the onKeyDown.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onKeyDown(key, repeat, flags, view)
+  end
+
+  # The onKeyUp method is called by SketchUp when the user releases a key on the
+  # keyboard.
+  #
+  # @example
+  #   def onKeyUp(key, repeat, flags, view)
+  #     puts "onKeyUp: key = #{key}"
+  #     puts "      repeat = #{repeat}"
+  #     puts "       flags = #{flags}"
+  #     puts "        view = #{view}"
+  #   end
+  #
+  # @param key
+  #   The key that was pressed.
+  #
+  # @param repeat
+  #   A value of 1 for a single press of a key.  A value of 2
+  #   if the user has pressed a key and is holding it down.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys at
+  #   the time of the onKeyUp.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onKeyUp(key, repeat, flags, view)
+  end
+
+  # The onLButtonDoubleClick is called by SketchUp when the user double clicks
+  # with the left mouse button.
+  #
+  # @example
+  #   def onLButtonDoubleClick(flags, x, y, view)
+  #     puts "onLButtonDoubleClick: flags = #{flags}"
+  #     puts "                          x = #{x}"
+  #     puts "                          y = #{y}"
+  #     puts "                       view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys
+  #   and other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onLButtonDoubleClick(flags, x, y, view)
+  end
+
+  # The onLButtonDown method is called by SketchUp when the left mouse button is
+  # pressed. Most tools will implement this method.
+  #
+  # @example
+  #   def onLButtonDown(flags, x, y, view)
+  #     puts "onLButtonDown: flags = #{flags}"
+  #     puts "                   x = #{x}"
+  #     puts "                   y = #{y}"
+  #     puts "                view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onLButtonDown(flags, x, y, view)
+  end
+
+  # The onLButtonUp method is called by SketchUp when the left mouse button is
+  # released.
+  #
+  # @example
+  #   def onLButtonUp(flags, x, y, view)
+  #     puts "onLButtonUp: flags = #{flags}"
+  #     puts "                 x = #{x}"
+  #     puts "                 y = #{y}"
+  #     puts "              view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onLButtonUp(flags, x, y, view)
+  end
+
+  # NOTE: Though this method has been documented in the Ruby API for many years,
+  # it has never worked properly. We are leaving this documentation in place
+  # for now in the hopes of fixing the implementation, but you won't have any
+  # luck trying to use it in SU7 and earlier.
+  #
+  # The onMButtonDoubleClick method is called by SketchUp when the middle mouse
+  # button (on a three button mouse) is double-clicked.
+  #
+  # Only implement this method if you want SketchUp to react to a middle mouse
+  # button being double-clicked.
+  #
+  # @example
+  #   def onMButtonDoubleClick(flags, x, y, view)
+  #     puts "onMButtonDoubleClick: flags = #{flags}"
+  #     puts "                          x = #{x}"
+  #     puts "                          y = #{y}"
+  #     puts "                       view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onMButtonDoubleClick(flags, x, y, view)
+  end
+
+  # The onMButtonDown method is called by SketchUp when the middle mouse button
+  # (on a three button mouse) is down.
+  #
+  # The Orbit tool is activated by default when the middle mouse button is down.
+  # Implement this method if you want a middle mouse button to do something
+  # other than invoke the Orbit tool.
+  #
+  # @example
+  #   def onMButtonDown(flags, x, y, view)
+  #     puts "onMButtonDown: flags = #{flags}"
+  #     puts "                    x = #{x}"
+  #     puts "                    y = #{y}"
+  #     puts "                 view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onMButtonDown(flags, x, y, view)
+  end
+
+  # The onMButtonUp method is called by SketchUp when the middle mouse button
+  # (on a three button mouse) is released.
+  #
+  # SketchUp returns to the previous tool from the Orbit tool when the middle
+  # mouse button is released. Implement this method if you want a middle mouse
+  # button to do something other than return to the previous tool when in the
+  # Orbit tool.
+  #
+  # @example
+  #   def onMButtonUp(flags, x, y, view)
+  #     puts "onMButtonUp: flags = #{flags}"
+  #     puts "                  x = #{x}"
+  #     puts "                  y = #{y}"
+  #     puts "               view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onMButtonUp(flags, x, y, view)
+  end
+
+  # The onMouseEnter method is called by SketchUp when the mouse enters the View
+  # object.
+  #
+  # @example
+  #   def onMouseEnter(view)
+  #     puts "onMouseEnter: view = #{view}"
+  #   end
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onMouseEnter(view)
+  end
+
+  # The onMouseLeave method is called by SketchUp when the mouse leaves the View
+  # object.
+  #
+  # @example
+  #   def onMouseLeave(view)
+  #     puts "onMouseLeave: view = #{view}"
+  #   end
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onMouseLeave(view)
+  end
+
+  # The onMouseMove method is called by SketchUp whenever the mouse is moved.
+  # You will often want to implement this method.
+  #
+  # Try to make this method as efficient as possible because this method is
+  # called often.
+  #
+  # @example
+  #   def onMouseMove(flags, x, y, view)
+  #     puts "onMouseMove: flags = #{flags}"
+  #     puts "                  x = #{x}"
+  #     puts "                  y = #{y}"
+  #     puts "               view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onMouseMove(flags, x, y, view)
+  end
+
+  # The onRButtonDoubleClick is called by SketchUp when the user double clicks
+  # with the right mouse button.
+  #
+  # @example
+  #   def onRButtonDoubleClick(flags, x, y, view)
+  #     puts "onRButtonDoubleClick: flags = #{flags}"
+  #     puts "                          x = #{x}"
+  #     puts "                          y = #{y}"
+  #     puts "                       view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onRButtonDoubleClick(flags, x, y, view)
+  end
+
+  # The onRButtonDown method is called by SketchUp when the user presses
+  # the right mouse button. Implement this method, along with the tool.getMenu
+  # method, when you want your tool to do something other than display the
+  # default context menu when the right mouse button is clicked.
+  #
+  # @example
+  #   def onRButtonDown(flags, x, y, view)
+  #     puts "onRButtonDown: flags = #{flags}"
+  #     puts "                   x = #{x}"
+  #     puts "                   y = #{y}"
+  #     puts "                view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onRButtonDown(flags, x, y, view)
+  end
+
+  # The onRButtonUp method is called by SketchUp when the user releases the
+  # right mouse button.
+  #
+  # @example
+  #   def onRButtonUp(flags, x, y, view)
+  #     puts "onRButtonUp: flags = #{flags}"
+  #     puts "                 x = #{x}"
+  #     puts "                 y = #{y}"
+  #     puts "              view = #{view}"
+  #   end
+  #
+  # @param flags
+  #   A bit mask that tells the state of the modifier keys and
+  #   other mouse buttons at the time.
+  #
+  # @param x
+  #   The X coordinate on the screen where the event occurred.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @param y
+  #   The Y coordinate on the screen where the event occurred.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onRButtonUp(flags, x, y, view)
+  end
+
+  # The onReturn method is called by SketchUp when the user hit the Return key
+  # to complete an operation in the tool. This method will rarely need to be
+  # implemented.
+  #
+  # @example
+  #   def onMouseLeave(view)
+  #     puts "onMouseLeave: view = #{view}"
+  #   end
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onReturn(view)
+  end
+
+  # The onSetCursor method is called by SketchUp when the tool wants to set the
+  # cursor.
+  #
+  # @example
+  #   def onSetCursor
+  #     puts "onSetCursor: view = #{view}"
+  #     # You would set your cursor here. See UI.set_cursor method.
+  #     UI.set_cursor(@cursor_id)
+  #   end
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onSetCursor
+  end
+
+  # The onUserText method is called by SketchUp when the user has typed text
+  # into the VCB and hit return.
+  #
+  # @example
+  #   def onUserText(text, view)
+  #     puts "onSetCursor: text = #{text}, view = #{view}"
+  #   end
+  #
+  # @param text
+  #   The text string that was typed into the VCB.
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def onUserText(text, view)
+  end
+
+  # The resume method is called by SketchUp when the tool becomes active again
+  # after being suspended.
+  #
+  # @example
+  #   def resume(view)
+  #     puts "resume: view = #{view}"
+  #   end
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def resume(view)
+  end
+
+  # The suspend method is called by SketchUp when the tool temporarily becomes
+  # inactive because another tool has been activated. This typically happens
+  # when a viewing tool is activated, such as when orbit is active due to the
+  # middle mouse button.
+  #
+  # @example
+  #   def suspend(view)
+  #     puts "suspend: view = #{view}"
+  #   end
+  #
+  # @param view
+  #   A View object where the method was invoked.
+  #
+  # @return nil
+  #
+  # @version SketchUp 6.0
+  def suspend(view)
+  end
+
+end