# Copyright 2005, @Last Software, Inc.

# This software is provided as an example of using the Ruby interface
# to SketchUp.

# Permission to use, copy, modify, and distribute this software for 
# any purpose and without fee is hereby granted, provided that the above
# copyright notice appear in all copies.

# THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#-----------------------------------------------------------------------------

require 'sketchup.rb'

#-----------------------------------------------------------------------------

# How do I force abort_operation to return false?

def abortOperationTest
        model = Sketchup.active_model
        UI.messagebox "Starting Operation"
        model.start_operation "Create Box"
        UI.messagebox "Aborting Operation"
        status = model.abort_operation
        UI.messagebox status

        
end


def activeEntitiesTest
        width=6
        height=5
        depth=4
        model = Sketchup.active_model
        entities = model.active_entities
        UI.messagebox entities
        entity = entities[0]

        # Should be no entities in the model
        if (!entity)
            UI.messagebox "No Entities in Model"
        else
            begin
                name = entity.typename
                UI.messagebox name
            rescue
                UI.messagebox $!.message
            end
        end        
        entities.add_group
        # Now there is a group entity
        entity = entities[0]
        name = entity.typename
        UI.messagebox name
end

# The active layer will also change in the Layer toolbar item and in the Layer
# Manager
def activeLayerTest
        model = Sketchup.active_model
        layer = model.active_layer

        # Should be no entities in the model
        if (!layer)
            UI.messagebox "Failure: No Layers"
        else
            # You use typename to get the name of a entity, but name to get the
            # name of a layer.
            name = layer.name
            UI.messagebox name
        end
end

def activeLayerEqualsTest
        model = Sketchup.active_model
        layers = model.layers
        layers.add "My Layer"
        status = model.active_layer=layers[1]
        UI.messagebox status
        layer = model.active_layer
        name = layer.name
        if (name != "My Layer")
            UI.messagebox "Failure: Wrong Layer is Active"
        else
           UI.messagebox name
        end
end

def activeViewTest
        model = Sketchup.active_model
        view = model.active_view
        UI.messagebox view
        height = view.vpheight
        if (height)
                UI.messagebox height
        else
                UI.messagebox "Failure"
        end
end

# 3 input values required.  Returned a note if successful; nil if unsuccessful.

def addNoteTest
        model = Sketchup.active_model
        begin
           note = model.add_note "Test Note", 0.1
        rescue
           UI.messagebox $!.message
        end
        if (note)
           UI.messagebox "Success"
           UI.messagebox note
        else
           UI.messagebox "Failure"
           UI.messagebox note
        end
end

# Do entities have attribute dictionaries by default? No.
def attributeDictionariesTest
        model = Sketchup.active_model
        create = true
        begin
            attdict = model.attribute_dictionary "My Dictionary" "true"
        rescue
            UI.messagebox $!.message
        end
        if (attdict)
            attdicts = model.attribute_dictionaries
            name = attdicts[0]
            UI.messagebox name
        else
            UI.messagebox "Failure: No Dictionaries"
        end           
       
end

def attributeDictionaryTest
        model = Sketchup.active_model
        attdict = model.attribute_dictionary "My Dictionary" "true"
        if (attdict)
            attdicts = model.attribute_dictionaries
            name = attdicts[0]
            UI.messagebox name
        else
            UI.messagebox "Failure: No Dictionaries"
        end           
end    


def behaviorModelTest

        model = Sketchup.active_model
        behavior = model.behavior
        if (behavior)
                UI.messagebox behavior
        else
                UI.messagebox "Failure"
        end


end

def boundsTest

        model = Sketchup.active_model
        boundingBox = model.bounds
        if (boundingBox)
            length = boundingBox.diagonal
            UI.messagebox "Success."
            # Should be 0 because there is nothing to bound.
            UI.messagebox length
        else
            UI.messagebox "Failure: No Bounding Box in Model"
        end
end


def commitOperationTest
        model = Sketchup.active_model
        model.start_operation "Create Box"
        model.commit_operation
end

# Returns a component definition list even though the list is empty. So
# basically, even an empty model has a definition list with 0 definitions.

def definitionsTest
        model = Sketchup.active_model
        definitions = model.definitions
        if (definitions)
            length = definitions.length
            UI.messagebox "Success."
            UI.messagebox length

        else
            UI.messagebox "Failure: No Component Definitions"
        end
end

# There is a default empty description. The description shows up in ModelInfo >
# File.
def descriptionTest
        model = Sketchup.active_model
        description = model.description
        if (description)
           UI.messagebox description
        else
           UI.messagebox "Failure: No Description"
        end
end

def descriptionEqualsTest
        model = Sketchup.active_model
        description = model.description
        UI.messagebox description
        description = model.description
        if (description)
           UI.messagebox description
        else
           UI.messagebox "Failure: No Description"
        end
end

# Not sure why this isn't working...
def entitiesTest
        model = Sketchup.active_model
        begin
            entities = model.entities
        rescue
            UI.messagebox $!.message
        end

        if (entities)
           UI.messagebox entities
           entity = entities[0]
           name = entity.typename
           UI.messagebox name
        else
           UI.messagebox "Failure: No Entities"
        end
end

def getAttributeTest
        model = Sketchup.active_model
        attrdict = model.attribute_dictionary "My Dictionary" "true"
        status = attrdict[mykey] = 7
        attr = attrdict.get_attribute "My Dictionary" "mykey" 
        if (attr)
                UI.messagebox attr
        else
                UI.messagebox "Failure: no attribute"
        end
end

def getDatumTest
        model = Sketchup.active_model
        datum = model.get_datum
        if (datum)
            UI.messagebox datum
        else
            UI.messagebox "Failure: No Datums"
        end
end


def guidTest
        model = Sketchup.active_model
        guid = model.guid
        if (guid)
            UI.messagebox guid
        else
            UI.messagebox "Failure: No Global Unique Identifier"
        end
end


def latlongToPointTest
        latitude = [40.01700, 105.28300]
        model = Sketchup.active_model
        begin
            latlong = Geom::LatLong.new(latitude)
        rescue
            UI.messagebox $!.message
        end

        point = model.latlong_to_point(latlong)
        if (point)
            pointvalue = point.inspect
            UI.messagebox pointvalue
        else
            UI.messagebox "Failure"
        end
end

def layersTest
        model = Sketchup.active_model
        layers = model.layers
        length = layers.length
        if (length)
            UI.messagebox length
        else
            UI.messagebox "Failure: No Layers"
        end
end

def listDatumsTest
        model = Sketchup.active_model
        datums = model.list_datums
        if (datums)
            # Display all datums supported by SketchUp    
            UI.messagebox datums  
        else
            UI.messagebox "Failure: No Datums"
        end
end

# Should return an empty array of materials regardless of whether there
# are any materials or not.
def materialsTest
        model = Sketchup.active_model
        materials = model.materials
        if (materials)
            count = materials.count
            UI.messagebox count
        else
            UI.messagebox "Failure"
        end
end

def modifiedTest
        model = Sketchup.active_model
        entities = model.active_entities
        entities.add_group
        result = model.modified?
        if (result)
            UI.messagebox "Success: Time to Save"
        else
            UI.messagebox "Failure: No Changes to Save"
        end
end
        

# By default there are four options in an empty model: PageOptions, AxisOptions
# SlideshowOptions, UnitsOptions, and NamedOptions 
def optionsTest
        model = Sketchup.active_model
        options = model.options
        if (options)
            size = options.size
            UI.messagebox size
            x = 0
            for option in options
                 option = options[x]
                 name = option.name
                 UI.messagebox name
                 x = x + 1
            end
        else
            UI.messagebox "Failure"
        end
end

def pagesTest
        model = Sketchup.active_model
        pages = model.pages
        UI.messagebox pages
        size = pages.size
        if (size)
            UI.messagebox size
            page = pages.add
            UI.messagebox page
            UI.messagebox "Lets add a page"
            size = pages.size
            UI.messagebox size

        else
            UI.messsagebox "Failure"
        end
end



# Will return an empty string even if no model has been opened

def pathTest
        model = Sketchup.active_model
        path = model.path
        if (path)
            UI.messagebox path
        else
            UI.messagebox "Failure"
        end
end


def placeComponentTest
end

def pointToLatlongTest
        coordinates = [10, 10, 10]
        model = Sketchup.active_model
        begin
            point = Geom::Point3d.new(coordinates)
        rescue
            UI.messagebox $!.message
        end

        latlong = model.point_to_latlong(point)
        if (latlong)
            latlongvalue = latlong.to_s
            UI.messagebox latlongvalue
        else
            UI.messagebox "Failure"
        end
end

def pointToUTMTest
        coordinates = [10, 10, 10]
        model = Sketchup.active_model
        begin
            point = Geom::Point3d.new(coordinates)
        rescue
            UI.messagebox $!.message
        end

        utm = model.point_to_utm(point)
        if (utm)
            utmvalue = utm.to_s
            UI.messagebox utmvalue
        else
            UI.messagebox "Failure"
        end
end

def raytestTest
end

def renderingOptionsTest
        model = Sketchup.active_model
        begin
                renderingoptions = model.rendering_options
        rescue
                UI.messagebox $!.message
        end
        if (renderingoptions)
            option = renderingoptions[0]
            UI.messagebox option           
        else
            UI.messagebox "Failure"
        end
end


def saveThumbnailTest
        depth = 100
        width = 100
        model = Sketchup.active_model
        entities = model.active_entities
        pts = []
        pts[0] = [0, 0, 0]
        pts[1] = [width, 0, 0]
        pts[2] = [width, depth, 0]
        pts[3] = [0, depth, 0]
        # Add the face to the entities in the model
        face = entities.add_face pts
        status = model.save_thumbnail "testthumbnail2.jpg"
        UI.messagebox status
end

# accepts a name value. Can't seem to find a way to append a path. I
# this equivalent to autosave?

# By default, file is saved in root sketchup directory.
def saveTest
        model = Sketchup.active_model
        status = model.save "test.skp"
        if (status)
           UI.messagebox "Success"
           UI.messagebox status
        else
           UI.messagebox "Failure"
        end
end

# Don't pass anything and we get the selection tool


def selectToolTest
        model = Sketchup.active_model
        begin
                tool = model.select_tool nil
        rescue
                UI.messagebox $!.message
        end
        if (tool)
            UI.messagebox "Success"
            UI.messagebox tool
        else
            UI.messagebox "Failure"
        end
end
                
# Returns an empty array (0 elements) on an empty model.

def selectionTest
        model = Sketchup.active_model
        selection = model.selection
        if (selection)
            count = selection.count
            UI.messagebox count
        else
            UI.messagebox "Failure"
        end
end

# models can have attribute dictionaries. Must supply dictionary name, key and
# value. Returns the value.
def setAttributeTest
        model = Sketchup.active_model
        value = model.set_attribute "testictionary", "test", 115
        if (value)
            UI.messagebox value
        else
            UI.messagebox "Failure"
        end
end

# Returns old datum. In general how the APIs show success is inconsistent, some
# return the same values passed, some return True, some return old values, and so on

def setDatumTest
        model = Sketchup.active_model
        value = model.set_datum "Adindan"
        if (value)
            UI.messagebox value
            value = model.get_datum
            UI.messagebox value

            # Set it back
            value = model.set_datum "WGS 84"
        else
            UI.messagebox "Failure"
        end
end

def shadowInfoTest
        model = Sketchup.active_model
        shadowinfo = model.shadow_info
        if (shadowinfo)
           UI.messagebox "Success"
        else
           UI.messagebox "Failure"
        end
end


def startOperationTest
        model = Sketchup.active_model
        model.start_operation "Create Box"

end

# Not sure where the title is stored?

def titleTest
        model = Sketchup.active_model
        title = model.title
        if (title)
            UI.messagebox title
        else
            UI.messagebox "Failure"
        end
end


# Must be a 2 or 3 value array for both point and utm.

def utmToPointTest
        point = [10,10,10]
        model = Sketchup.active_model
        begin
            point = Geom::Point3d.new(point) 
        rescue
            UI.messagebox $!.message
        end
        utm = model.point_to_utm point
        UI.messagebox utm
        point = model.utm_to_point utm
        if (point)
            pointvalue = point.to_s
            UI.messagebox pointvalue
        else
            UI.messagebox "Failure"
        end
end

def validTest
        model = Sketchup.active_model
        valid = model.valid?
        if (valid)
            UI.messagebox valid
        else
            UI.messagebox "Failure"
        end
end



if( not file_loaded?("modeltests.rb") )

    # This will add a separator to the menu, but only once
    add_separator_to_menu("Plugins")
    
    plugins_menu = UI.menu("Plugins")
    UITest_menu = plugins_menu.add_submenu("Model Tests")
    UITest_menu.add_item("Model.abort_operation") { abortOperationTest }
    UITest_menu.add_item("Model.active_entities") { activeEntitiesTest }
    UITest_menu.add_item("Model.active_layer") { activeLayerTest }
    UITest_menu.add_item("Model.active_layer=") { activeLayerEqualsTest }
    UITest_menu.add_item("Model.active_view") { activeViewTest }
    UITest_menu.add_item("Model.add_note") { addNoteTest }
    UITest_menu.add_item("Model.attribute_dictionaries") { attributeDictionariesTest }
    UITest_menu.add_item("Model.attribute_dictionary") { attributeDictionaryTest }
    UITest_menu.add_item("Model.behavior") { behaviorModelTest }
    UITest_menu.add_item("Model.bounds") { boundsTest }
    UITest_menu.add_item("Model.commit_operation") { commitOperationTest }
    UITest_menu.add_item("Model.definitions") { definitionsTest }
    UITest_menu.add_item("Model.description") { descriptionTest }
    UITest_menu.add_item("Model.description=") { descriptionEqualsTest }
    UITest_menu.add_item("Model.entities") { entitiesTest }
    UITest_menu.add_item("Model.get_attribute") { getAttributeTest }
    UITest_menu.add_item("Model.get_datum") { getDatumTest }
    UITest_menu.add_item("Model.guid") { guidTest }
    UITest_menu.add_item("Model.latlong_to_point") { latlongToPointTest }
    UITest_menu.add_item("Model.layers") { layersTest }
    UITest_menu.add_item("Model.list_datums") { listDatumsTest }
    UITest_menu.add_item("Model.materials") { materialsTest }
    UITest_menu.add_item("Model.modified?") { modifiedTest }
    UITest_menu.add_item("Model.options") { optionsTest }
    UITest_menu.add_item("Model.pages") { pagesTest }
    UITest_menu.add_item("Model.path") { pathTest }
    UITest_menu.add_item("Model.point_to_latlong") { pointToLatlongTest }
    UITest_menu.add_item("Model.point_to_utm") { pointToUTMTest }
    UITest_menu.add_item("Model.rendering_options") { renderingOptionsTest }
    UITest_menu.add_item("Model.save") { saveTest }
    UITest_menu.add_item("Model.save_thumbnail") { saveThumbnailTest }
    UITest_menu.add_item("Model.select_Tool") { selectToolTest }
    UITest_menu.add_item("Model.selection") { selectionTest }
    UITest_menu.add_item("Model.set_attribute") { setAttributeTest }
    UITest_menu.add_item("Model.set_datum") { setDatumTest }
    UITest_menu.add_item("Model.shadow_info") { shadowInfoTest }
    UITest_menu.add_item("Model.start_operation") { startOperationTest }
    UITest_menu.add_item("Model.title") { titleTest }
    UITest_menu.add_item("Model.utm_to_point") { utmToPointTest }
    UITest_menu.add_item("Model.valid?") { validTest }

    
   
end

#-----------------------------------------------------------------------------
file_loaded("modeltests.rb")