### Home Classes Methods

### In Files

- lib/utils.rb

### Parent

Object

### Methods

- ::add_cg_names
- ::ask_to_save_project
- ::axiom
- ::copy_shape
- ::create_default_axiom
- ::create_default_current_shape
- ::create_default_left_shape
- ::create_default_new_grammar
- ::create_default_new_project
- ::create_default_project
- ::create_default_right_shape
- ::create_rule_list
- ::current_shape
- ::first_rule_id
- ::get_directory_from_path
- ::get_directory_from_sketchup_path
- ::get_execution
- ::get_extension
- ::get_grammar
- ::get_labels
- ::get_project
- ::get_rule
- ::get_title_from_path
- ::get_title_from_sketchup_path
- ::is_projected?
- ::last_rule_id
- ::last_rule_transformation
- ::load_custom_constraints
- ::load_custom_goals
- ::paint_rule
- ::paint_rule_layout
- ::point_segment_distance
- ::prepare_canvas
- ::previous_rule_id
- ::previous_shape

### Files

- LessThan5BlueLabels.txt
- AtLeast2LargeSegments.txt

### Class Index

Quicksearch

- AddLabelTool
- AllRulesAppliedGoal
- Area
- AreaConstraint
- Array
- BalancedBinaryTree
- BalancedBinaryTreeNode
- CloseObserver
- Constants
- Constraint
- CurrentLabelledShape
- DistinctShapeConstraint
- Execution
- Goal
- Grammar
- Label
- LabelledShape
- LineDescriptor
- LinearLinkedList
- LinearLinkedListNode
- NoLabelsGoal
- NoMoreRulesGoal
- NoScalesConstraint
- Numeric
- Object
- OrderedPoint
- PiList
- Point
- Project
- Robot
- Rule
- RuleGroupsObserver
- RuleLabelledShape
- RuleShapeObserver
- Segment
- ShaDeLayersObserver
- Shade
- ShadeUtils
- UndoObserver

No matching classes.

# ShadeUtils

Author | Manuela Ruiz (mruiz@lcc.uma.es)

Utils class

### Public Class Methods

add_cg_names() click to toggle source

Adds the default constraint and goals

          # File lib/utils.rb, line 1288
    1288:         def ShadeUtils.add_cg_names()

    1289:                 #Set list of constraint names and classes

    1290:                 Shade.constraint_class_names = Array.new

    1291:                 Shade.add_constraint_class_name [ DistinctShapeConstraint, Constants::DISTINCT_SHAPE_CONSTRAINT_NAME]

    1292:                 Shade.add_constraint_class_name [ NoScalesConstraint, Constants::NO_SCALES_CONSTRAINT_NAME]

    1293:                 Shade.add_constraint_class_name [ AreaConstraint, Constants::AREA_CONSTRAINT_NAME]

    1294:

    1295:                 #Set list of goals names and classes

    1296:                 Shade.goal_class_names = Array.new

    1297:                 Shade.add_goal_class_name([NoLabelsGoal, Constants::NO_LABELS_GOAL_NAME])

    1298:                 Shade.add_goal_class_name([AllRulesAppliedGoal, Constants::ALL_RULES_APPLIED_GOAL_NAME])

    1299:                 Shade.add_goal_class_name([NoMoreRulesGoal, Constants::NO_MORE_RULES_GOAL_NAME])

    1300:         end

ask_to_save_project() click to toggle source

Shows a dialog for saving the project

         # File lib/utils.rb, line 420
    420:         def ShadeUtils.ask_to_save_project()

    421:                 if Shade.using_sketchup

    422:                         project = Shade.project

    423:                         if !project.saved

    424:                                 input = UI.messagebox("Save current project?", MB_YESNO)

    425:                                 if input == 6

    426:                                         if project.path

    427:                                                 project.save(project.path, true)

    428:                                                 project.saved = true

    429:                                         else

    430:                                                 path_to_save_to = UI.savepanel "Save Project", "", "project.prj"

    431:                                                 if path_to_save_to

    432:                                                         project.save(path_to_save_to, true)

    433:                                                 end

    434:                                                 project.saved = true

    435:                                         end

    436:                                 end

    437:

    438:                         end

    439:                 end

    440:         end

axiom() click to toggle source

returns | the axiom

          # File lib/utils.rb, line 1179
    1179:         def ShadeUtils.axiom()

    1180:                 return Shade.project.execution.grammar.axiom

    1181:         end

copy_shape(origin_rule_idx, origin_rule_part, destiny_rule_idx, destiny_rule_part) click to toggle source

origin_rule_idx: index of the origin rule origin_rule_part: Constants::LEFT or Constants::RIGHT destiny_rule_idx: index of the destiny rule. If -1, we refer to the axiom (that is, the shape is going to be copied to the axiom) destiny_rule_part: “Left”, “Right”, “Additive” or “” in case we refer to the axiom

Copies the origin shape (the one in the specified part of the specified rule) to the specified destiny Maintains the old transformations

         # File lib/utils.rb, line 755
    755:         def ShadeUtils.copy_shape(origin_rule_idx, origin_rule_part, destiny_rule_idx, destiny_rule_part)

    756:                 execution = Shade.project.execution

    757:                 origin_rule = execution.grammar.rules[origin_rule_idx]

    758:                 destiny_rule = execution.grammar.rules[destiny_rule_idx]

    759:

    760:                 if origin_rule_part == Constants::LEFT

    761:                         origin_shape = origin_rule.left

    762:                 elsif origin_rule_part == Constants::RIGHT

    763:                         origin_shape = origin_rule.right

    764:                 end

    765:

    766:                 new_shape = origin_shape.clone

    767:                 new_shape.host_rule_id = destiny_rule.rule_id

    768:                 new_shape.host_rule_part = destiny_rule_part

    769:

    770:                 if Shade.using_sketchup

    771:                         if destiny_rule_part == Constants::LEFT

    772:                                 Sketchup.active_model.layers.each { |layer|

    773:                                         shape_transformation = destiny_rule.alpha.shape_transformation[layer.name]

    774:                                         layout_transformation = destiny_rule.alpha.layout_transformation

    775:                                         destiny_rule.alpha.erase

    776:                                         destiny_rule.alpha = new_shape

    777:                                         destiny_rule.alpha.shape_transformation[layer.name]= shape_transformation

    778:                                         destiny_rule.alpha.layout_transformation = layout_transformation

    779:                                 }

    780:                         elsif destiny_rule_part == Constants::RIGHT

    781:                                 Sketchup.active_model.layers.each { |layer|

    782:                                         shape_transformation = destiny_rule.beta.shape_transformation[layer.name]

    783:                                         layout_transformation = destiny_rule.beta.layout_transformation

    784:                                         destiny_rule.beta.erase

    785:                                         destiny_rule.beta = new_shape

    786:                                         destiny_rule.beta.shape_transformation[layer.name] = shape_transformation

    787:                                         destiny_rule.beta.layout_transformation = layout_transformation

    788:                                 }

    789:                         end

    790:                 else

    791:                         if destiny_rule_part == Constants::LEFT

    792:                                 destiny_rule.alpha.erase

    793:                                 destiny_rule.alpha = new_shape

    794:                         elsif destiny_rule_part == Constants::RIGHT

    795:                                 destiny_rule.beta.erase

    796:                                 destiny_rule.beta = new_shape

    797:                         end

    798:                 end

    799:

    800:                 execution.grammar.saved = false

    801:         end

create_default_axiom() click to toggle source

returns | a default axiom

         # File lib/utils.rb, line 443
    443:         def ShadeUtils.create_default_axiom()

    444:                 axiom = LabelledShape.new(Array.new, Array.new)

    445:                 segments = Array.new

    446:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

    447:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

    448:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

    449:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

    450:

    451:                 if Shade.using_sketchup

    452:                         Sketchup.active_model.layers.each { |layer|

    453:                                 segments.each { |segment|

    454:                                         segment_list = LinearLinkedList.new

    455:

    456:                                         node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

    457:

    458:                                         inserted_node = axiom.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    459:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    460:                                         inserted_node.list.insert_node(segment_node)

    461:                                 }

    462:

    463:                                 Constants::PTS_1.each {|point|

    464:                                         label = Label.new(Constants::INTERSECTION_LABEL)

    465:                                         point_list = LinearLinkedList.new

    466:

    467:                                         node = LinearLinkedListNode.new(label, point_list, nil)

    468:

    469:                                         inserted_node = axiom.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

    470:

    471:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    472:                                         inserted_node.list.insert_node(point_node) #Insert the point node

    473:                                 }

    474:                         }

    475:                 else

    476:                         segments.each { |segment|

    477:                                 segment_list = LinearLinkedList.new

    478:

    479:                                 node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

    480:

    481:                                 inserted_node = axiom.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    482:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    483:                                 inserted_node.list.insert_node(segment_node)

    484:                         }

    485:

    486:                         Constants::PTS_1.each {|point|

    487:                                 label = Label.new(Constants::INTERSECTION_LABEL)

    488:                                 point_list = LinearLinkedList.new

    489:

    490:                                 node = LinearLinkedListNode.new(label, point_list, nil)

    491:

    492:                                 inserted_node = axiom.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

    493:

    494:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    495:                                 inserted_node.list.insert_node(point_node) #Insert the point node

    496:                         }

    497:                 end

    498:                 return axiom

    499:         end

create_default_current_shape() click to toggle source

returns | a default current shape

         # File lib/utils.rb, line 503
    503:         def ShadeUtils.create_default_current_shape()

    504:                 current_shape = CurrentLabelledShape.new(Array.new, Array.new)

    505:                 segments = Array.new

    506:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

    507:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

    508:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

    509:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

    510:

    511:                 if Shade.using_sketchup

    512:                         Sketchup.active_model.layers.each { |layer|

    513:                                 segments.each { |segment|

    514:                                         segment_list = LinearLinkedList.new

    515:

    516:                                         node = BalancedBinaryTreeNode.new(0, nil, nil, segment.line_descriptor.clone, segment_list)

    517:

    518:                                         inserted_node = current_shape.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    519:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    520:                                         inserted_node.list.insert_node(segment_node)

    521:                                 }

    522:

    523:

    524:                                 Constants::PTS_1.each {|point|

    525:                                         label = Label.new(Constants::INTERSECTION_LABEL)

    526:                                         point_list = LinearLinkedList.new

    527:

    528:                                         node = LinearLinkedListNode.new(label, point_list, nil)

    529:

    530:                                         inserted_node = current_shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

    531:

    532:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    533:                                         inserted_node.list.insert_node(point_node) #Insert the point node

    534:                                 }

    535:                         }

    536:                 else

    537:                         segments.each { |segment|

    538:                                 segment_list = LinearLinkedList.new

    539:

    540:                                 node = BalancedBinaryTreeNode.new(0, nil, nil, segment.line_descriptor.clone, segment_list)

    541:

    542:                                 inserted_node = current_shape.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    543:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    544:                                 inserted_node.list.insert_node(segment_node)

    545:                         }

    546:

    547:

    548:                         Constants::PTS_1.each {|point|

    549:                                 label = Label.new(Constants::INTERSECTION_LABEL)

    550:                                 point_list = LinearLinkedList.new

    551:

    552:                                 node = LinearLinkedListNode.new(label, point_list, nil)

    553:

    554:                                 inserted_node = current_shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

    555:

    556:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    557:                                 inserted_node.list.insert_node(point_node) #Insert the point node

    558:                         }

    559:                 end

    560:                 current_shape.create_pi

    561:                 return current_shape

    562:         end

create_default_left_shape() click to toggle source

returns | a default left shape for the rules

         # File lib/utils.rb, line 565
    565:         def ShadeUtils.create_default_left_shape()

    566:                 shape = RuleLabelledShape.new(Array.new, Array.new, nil, nil)

    567:                 segments = Array.new

    568:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

    569:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

    570:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

    571:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

    572:

    573:                 if Shade.using_sketchup

    574:                         Sketchup.active_model.layers.each { |layer|

    575:                                 segments.each { |segment|

    576:                                         segment_list = LinearLinkedList.new

    577:

    578:                                         node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

    579:

    580:                                         inserted_node = shape.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    581:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    582:                                         inserted_node.list.insert_node(segment_node)

    583:                                 }

    584:

    585:                                 Constants::PTS_1.each {|point|

    586:                                         label = Label.new(Constants::INTERSECTION_LABEL)

    587:                                         point_list = LinearLinkedList.new

    588:

    589:                                         node = LinearLinkedListNode.new(label, point_list, nil)

    590:

    591:                                         inserted_node = shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

    592:

    593:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    594:                                         inserted_node.list.insert_node(point_node) #Insert the point node

    595:                                 }

    596:                         }

    597:                         shape.changed = true

    598:                 else

    599:                         segments.each { |segment|

    600:                                 segment_list = LinearLinkedList.new

    601:

    602:                                 node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

    603:

    604:                                 inserted_node = shape.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    605:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    606:                                 inserted_node.list.insert_node(segment_node)

    607:                         }

    608:

    609:                         Constants::PTS_1.each {|point|

    610:                                 label = Label.new(Constants::INTERSECTION_LABEL)

    611:                                 point_list = LinearLinkedList.new

    612:

    613:                                 node = LinearLinkedListNode.new(label, point_list, nil)

    614:

    615:                                 inserted_node = shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

    616:

    617:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    618:                                 inserted_node.list.insert_node(point_node) #Insert the point node

    619:                         }

    620:                 end

    621:                 return shape

    622:         end

create_default_new_grammar() click to toggle source

Creates and loads a default grammar

         # File lib/utils.rb, line 805
    805:         def ShadeUtils.create_default_new_grammar

    806:                 execution = Shade.project.execution

    807:                 rules = execution.grammar.rules

    808:

    809:                 size = rules.size

    810:                 i = 0

    811:                 while i < size

    812:                         execution.grammar.remove_rule(size-i-1)

    813:                         i += 1

    814:                 end

    815:

    816:                 # Create default shapes for the first rule

    817:                 left = ShadeUtils.create_default_left_shape()

    818:                 right = ShadeUtils.create_default_right_shape()

    819:

    820:                 # Create the first rule

    821:                 rule = ShadeUtils.paint_rule(1, left, right)

    822:                 execution.grammar.add_rule(rule)

    823:                 execution.grammar.saved = true

    824:

    825:                 #Create the axiom

    826:                 execution.grammar.axiom = create_default_axiom

    827:                 execution.reset

    828:

    829:                 Shade.project.refresh

    830:         end

create_default_new_project() click to toggle source

Creates and loads a new project

         # File lib/utils.rb, line 835
    835:         def ShadeUtils.create_default_new_project()

    836:                 project = Shade.project

    837:                 project.set_title(Constants::DEFAULT_PROJECT_TITLE)

    838:

    839:                 project.set_path(nil)

    840:

    841:                 ShadeUtils.create_default_new_grammar()

    842:

    843:                 project.execution.constraints = Array.new

    844:                 project.execution.goals = Array.new

    845:

    846:                 project.refresh

    847:

    848:                 project.saved = true

    849:         end

create_default_project() click to toggle source

returns | a default project

         # File lib/utils.rb, line 852
    852:         def ShadeUtils.create_default_project

    853:

    854:                 # Create the grammar

    855:                 grammar = Grammar.new

    856:

    857:                 # Create the execution

    858:                 execution = Execution.new(grammar, nil)

    859:

    860:                 # Create the project

    861:                 project = Project.new(execution)

    862:

    863:                 #Add the project to Shade

    864:                 Shade.project = project

    865:

    866:                 #Create default shapes for the first rule

    867:                 left = ShadeUtils.create_default_left_shape()

    868:                 right = ShadeUtils.create_default_right_shape()

    869:

    870:                 #Create the axiom

    871:                 execution.grammar.axiom = create_default_axiom

    872:                 execution.current_shape = create_default_current_shape

    873:

    874:                 # Create the first rule

    875:                 rule = ShadeUtils.paint_rule(1, left, right)

    876:

    877:

    878:                 # Add rule to the grammar

    879:                 grammar.add_rule rule

    880:

    881:                 grammar.saved = true

    882:

    883:                 # Associate the grammar with the execution

    884:                 execution.grammar = grammar

    885:

    886:                 if Shade.using_sketchup

    887:                         # We only need to do this once. Then, only changing observed ids is needed

    888:                         Shade.rule_groups_observer = RuleGroupsObserver.new

    889:                         Sketchup.active_model.entities.add_observer(Shade.rule_groups_observer)

    890:                 end

    891:

    892:                 # Return the project

    893:                 return project

    894:         end

create_default_right_shape() click to toggle source

returns | a default right shape for the rules

         # File lib/utils.rb, line 625
    625:         def ShadeUtils.create_default_right_shape()

    626:                 shape = RuleLabelledShape.new(Array.new, Array.new, nil, nil)

    627:                 segments = Array.new

    628:                 segments[0] = Segment.new(OrderedPoint.new(Constants::PTS_1[0].clone), OrderedPoint.new(Constants::PTS_1[1].clone))

    629:                 segments[1] = Segment.new(OrderedPoint.new(Constants::PTS_1[1].clone), OrderedPoint.new(Constants::PTS_1[2].clone))

    630:                 segments[2] = Segment.new(OrderedPoint.new(Constants::PTS_1[2].clone), OrderedPoint.new(Constants::PTS_1[3].clone))

    631:                 segments[3] = Segment.new(OrderedPoint.new(Constants::PTS_1[3].clone), OrderedPoint.new(Constants::PTS_1[0].clone))

    632:

    633:                 segments[4] = Segment.new(OrderedPoint.new(Constants::PTS_2[0].clone), OrderedPoint.new(Constants::PTS_2[1].clone))

    634:                 segments[5] = Segment.new(OrderedPoint.new(Constants::PTS_2[1].clone), OrderedPoint.new(Constants::PTS_2[2].clone))

    635:                 segments[6] = Segment.new(OrderedPoint.new(Constants::PTS_2[2].clone), OrderedPoint.new(Constants::PTS_2[3].clone))

    636:                 segments[7] = Segment.new(OrderedPoint.new(Constants::PTS_2[3].clone), OrderedPoint.new(Constants::PTS_2[0].clone))

    637:

    638:                 if Shade.using_sketchup

    639:                         Sketchup.active_model.layers.each { |layer|

    640:                                 segments.each { |segment|

    641:                                         segment_list = LinearLinkedList.new

    642:

    643:                                         node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

    644:

    645:                                         inserted_node = shape.s[layer.name].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    646:                                         segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    647:                                         inserted_node.list.insert_node(segment_node)

    648:                                 }

    649:

    650:                                 Constants::PTS_1.each {|point|

    651:                                         label = Label.new(Constants::INTERSECTION_LABEL)

    652:                                         point_list = LinearLinkedList.new

    653:

    654:                                         node = LinearLinkedListNode.new(label, point_list, nil)

    655:

    656:                                         inserted_node = shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

    657:

    658:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    659:                                         inserted_node.list.insert_node(point_node) #Insert the point node

    660:                                 }

    661:

    662:                                 Constants::PTS_2.each {|point|

    663:                                         label = Label.new(Constants::INTERSECTION_LABEL)

    664:                                         point_list = LinearLinkedList.new

    665:

    666:                                         node = LinearLinkedListNode.new(label, point_list, nil)

    667:

    668:                                         inserted_node = shape.p[layer.name].insert_node(node) #Insert the node corresponding to the label of the point

    669:

    670:                                         point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    671:                                         inserted_node.list.insert_node(point_node) #Insert the point node

    672:                                 }

    673:

    674:                                 label = Label.new(Constants::INTERSECTION_LABEL)

    675:                                 intersection_label_node = shape.p[layer.name].get_node(label)

    676:

    677:                                 #Insert the other intersection points

    678:                                 point_node1 = LinearLinkedListNode.new(OrderedPoint.new(Geom::Point3d.new(4,8,0)), nil, nil)

    679:                                 point_node2 = LinearLinkedListNode.new(OrderedPoint.new(Geom::Point3d.new(8,4,0)), nil, nil)

    680:                                 intersection_label_node.list.insert_node(point_node1) #Insert the point node

    681:                                 intersection_label_node.list.insert_node(point_node2) #Insert the point node

    682:                         }

    683:

    684:                         shape.changed = true

    685:                 else

    686:                         segments.each { |segment|

    687:                                 segment_list = LinearLinkedList.new

    688:

    689:                                 node = LinearLinkedListNode.new(segment.line_descriptor.clone, segment_list, nil)

    690:

    691:                                 inserted_node = shape.s["Layer0"].insert_node(node) #Insert the node corresponding to the line descriptor of the segment

    692:                                 segment_node = LinearLinkedListNode.new(segment.clone, nil, nil)

    693:                                 inserted_node.list.insert_node(segment_node)

    694:                         }

    695:

    696:                         Constants::PTS_1.each {|point|

    697:                                 label = Label.new(Constants::INTERSECTION_LABEL)

    698:                                 point_list = LinearLinkedList.new

    699:

    700:                                 node = LinearLinkedListNode.new(label, point_list, nil)

    701:

    702:                                 inserted_node = shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

    703:

    704:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    705:                                 inserted_node.list.insert_node(point_node) #Insert the point node

    706:                         }

    707:

    708:                         Constants::PTS_2.each {|point|

    709:                                 label = Label.new(Constants::INTERSECTION_LABEL)

    710:                                 point_list = LinearLinkedList.new

    711:

    712:                                 node = LinearLinkedListNode.new(label, point_list, nil)

    713:

    714:                                 inserted_node = shape.p["Layer0"].insert_node(node) #Insert the node corresponding to the label of the point

    715:

    716:                                 point_node = LinearLinkedListNode.new(OrderedPoint.new(point.clone), nil, nil)

    717:                                 inserted_node.list.insert_node(point_node) #Insert the point node

    718:                         }

    719:

    720:                         label = Label.new(Constants::INTERSECTION_LABEL)

    721:                         intersection_label_node = shape.p["Layer0"].get_node(label)

    722:

    723:                         #Insert the other intersection points

    724:                         point_node1 = LinearLinkedListNode.new(OrderedPoint.new(Point.new(4,8,0)), nil, nil)

    725:                         point_node2 = LinearLinkedListNode.new(OrderedPoint.new(Point.new(8,4,0)), nil, nil)

    726:                         intersection_label_node.list.insert_node(point_node1) #Insert the point node

    727:                         intersection_label_node.list.insert_node(point_node2) #Insert the point node

    728:                 end

    729:                 return shape

    730:         end

create_rule_list() click to toggle source

returns: a String object with a list of the present rule IDs, for example, if there are four rules: “1|2|3|4”

         # File lib/utils.rb, line 734
    734:         def ShadeUtils.create_rule_list()

    735:                 execution = Shade.project.execution

    736:                 rule_list = ""

    737:                 rules_size = execution.grammar.rules.size

    738:                 rules_size.times do |s|

    739:                         if (s+1) == rules_size

    740:                                 rule_list = "#{rule_list}#{s+1}"

    741:                         else

    742:                                 rule_list = "#{rule_list}#{s+1}|"

    743:                         end

    744:                 end

    745:                 return rule_list

    746:         end

current_shape() click to toggle source

returns | the current shape

          # File lib/utils.rb, line 1165
    1165:         def ShadeUtils.current_shape()

    1166:                 return Shade.project.execution.current_shape

    1167:         end

first_rule_id() click to toggle source

returns | the id of the first rule applied

          # File lib/utils.rb, line 1246
    1246:         def ShadeUtils.first_rule_id()

    1247:                 if Shade.project.execution.execution_history

    1248:                         return Shade.project.execution.execution_history.first[0]

    1249:                 else

    1250:                         return nil

    1251:                 end

    1252:         end

get_directory_from_path(path) click to toggle source

path | a String representing a path of a file inside the system
returns | the parent directory of the file represented by the path

          # File lib/utils.rb, line 1151
    1151:         def ShadeUtils.get_directory_from_path(path)

    1152:                 i = path.rindex("\\")

    1153:                 return path[0..i]

    1154:         end

get_directory_from_sketchup_path(path) click to toggle source

path | a String representing a path of a file inside the system, returned by the SketchUp utils for getting paths
returns | the parent directory of the file represented by the path

          # File lib/utils.rb, line 1159
    1159:         def ShadeUtils.get_directory_from_sketchup_path(path)

    1160:                 i = path.rindex("/")

    1161:                 return path[0..i]

    1162:         end

get_execution() click to toggle source

returns | the current execution

          # File lib/utils.rb, line 1222
    1222:         def ShadeUtils.get_execution()

    1223:                 return Shade.project.execution

    1224:         end

get_extension(path) click to toggle source

path | a String representing a path of a file inside the system
returns | the extension of the file represented by the path

          # File lib/utils.rb, line 1138
    1138:         def ShadeUtils.get_extension(path)

    1139:                 if path.rindex(".")

    1140:                         i = path.rindex(".") + 1

    1141:                         j = (path.length) -1

    1142:                         return path[i..j]

    1143:                 else

    1144:                         return nil

    1145:                 end

    1146:         end

get_grammar() click to toggle source

returns | the current grammar

          # File lib/utils.rb, line 1232
    1232:         def ShadeUtils.get_grammar()

    1233:                 return Shade.project.execution.grammar

    1234:         end

get_labels(shape, type) click to toggle source

shape | a LabelledShape object
type | String that can take the values “ALL” (referring to all types of labels) or “INTERSECTION” (referring only to the intersection points)
returns | an Array with the lists of labels present in the current shape

          # File lib/utils.rb, line 1187
    1187:         def ShadeUtils.get_labels(shape, type)

    1188:

    1189:                 labels = Array.new

    1190:                 case type

    1191:                         when ("ALL" or "All")

    1192:                                 shape.p.each_key { |layer_name|

    1193:                                         ShadeUtils.current_shape.p[layer_name].reset_iterator

    1194:                                         while l_node = ShadeUtils.current_shape.p[layer_name].get_next

    1195:                                                 labels.push l_node.list

    1196:                                         end

    1197:                                 }

    1198:                         when ("INTERSECTION" or "Intersection")

    1199:

    1200:                                 shape.p.each_key { |layer_name|

    1201:

    1202:                                         l_node = ShadeUtils.current_shape.p[layer_name].get_node(Label.new(Constants::INTERSECTION_LABEL))

    1203:                                         if l_node

    1204:                                                 labels.push l_node.list

    1205:                                         end

    1206:                                 }

    1207:                         else

    1208:                                 shape.p.each_key { |layer_name|

    1209:                                         l_node = ShadeUtils.current_shape.p[layer_name].get_node(Label.new(type.capitalize))

    1210:                                         if l_node

    1211:                                                 labels.push l_node.list

    1212:                                         end

    1213:                                 }

    1214:

    1215:

    1216:                 end

    1217:

    1218:                 return labels

    1219:         end

get_project() click to toggle source

returns | the current project

          # File lib/utils.rb, line 1227
    1227:         def ShadeUtils.get_project()

    1228:                 return Shade.project

    1229:         end

get_rule(rule_idx) click to toggle source

rule_idx | an integer number
returns | the rule with the specified index, that is, that is in the rule_idx position of the array of rules

          # File lib/utils.rb, line 1279
    1279:         def ShadeUtils.get_rule(rule_idx)

    1280:                 if rule_idx > Shade.project.execution.grammar.rules.size

    1281:                         puts "Index out of range"

    1282:                 else

    1283:                         return Shade.project.execution.grammar.rules[rule_idx]

    1284:                 end

    1285:         end

get_title_from_path(path) click to toggle source

path | a String representing a path of a file inside the system
returns | the title of the file represented by the path

          # File lib/utils.rb, line 1120
    1120:         def ShadeUtils.get_title_from_path(path)

    1121:                 i = path.rindex("\\")+1

    1122:                 j = path.rindex(".")-1

    1123:                 return path[i..j]

    1124:         end

get_title_from_sketchup_path(path) click to toggle source

path | a String representing a path of a file inside the system, returned by the SketchUp utils for getting paths
returns | the title of the file represented by the path

          # File lib/utils.rb, line 1129
    1129:         def ShadeUtils.get_title_from_sketchup_path(path)

    1130:                 i = path.rindex("/")+1

    1131:                 j = path.rindex(".")-1

    1132:                 return path[i..j]

    1133:         end

is_projected?(point, segment) click to toggle source

point | a Point object
segment | a Segment object
returns | the distance, in meters, from point to segment (ortogonally projected)

         # File lib/utils.rb, line 410
    410:         def ShadeUtils.is_projected?(point, segment)

    411:                 result = false

    412:                 projected_point = OrderedPoint.new(point.project_to_line(segment.line_descriptor, segment.tail, segment.head))

    413:                 if segment.coincident? projected_point

    414:                         result = true

    415:                 end

    416:                 return result

    417:         end

last_rule_id() click to toggle source

returns | the id of the last rule applied

          # File lib/utils.rb, line 1237
    1237:         def ShadeUtils.last_rule_id()

    1238:                 if Shade.project.execution.execution_history

    1239:                         return Shade.project.execution.execution_history.last[0]

    1240:                 else

    1241:                         return nil

    1242:                 end

    1243:         end

last_rule_transformation() click to toggle source

returns | the transformation of the last rule applied

          # File lib/utils.rb, line 1268
    1268:         def ShadeUtils.last_rule_transformation()

    1269:                 if Shade.project.execution.execution_history

    1270:                         return Shade.project.execution.execution_history.last[1]

    1271:                 else

    1272:                         return nil

    1273:                 end

    1274:         end

load_custom_constraints() click to toggle source

Loads the constraints present in the directory “custom_constraints“

         # File lib/utils.rb, line 273
    273:         def ShadeUtils.load_custom_constraints()

    274:                 #We suppose that custom constraints have already been syntax-checked and executed

    275:                 if Shade.using_sketchup

    276:                         file_name = Sketchup.find_support_file Constants::STARTUP_FILE_NAME, Constants::LIB_DIR

    277:                         directory = ShadeUtils.get_directory_from_sketchup_path(file_name)

    278:                         custom_constraints_directory = "#{directory}/#{Constants::CONSTRAINT_FOLDER_NAME}"

    279:                 else

    280:                         custom_constraints_directory = "#{File.dirname(__FILE__)}/#{Constants::CONSTRAINT_FOLDER_NAME}"

    281:                         custom_constraints_directory.gsub!("/", "\\")

    282:                 end

    283:                 old_dir = Dir.pwd

    284:                 Dir.chdir(custom_constraints_directory)

    285:

    286:                 #For each file inside the custom constraints directory

    287:                 Dir.entries(".").each { |file_name|

    288:                         if Shade.using_sketchup

    289:                         file_path = "#{custom_constraints_directory}/#{file_name}"

    290:                         name =  get_title_from_sketchup_path(file_path)

    291:                         else

    292:                         file_path = "#{custom_constraints_directory}\\#{file_name}"

    293:                         name =  get_title_from_path(file_path)

    294:                         end

    295:                         extension = get_extension(file_path)

    296:                         if extension == "txt"

    297:                                 code = ""

    298:                                 File.open(file_path, 'r') do |f|

    299:                                         while line = f.gets

    300:                                                 code += line

    301:                                         end

    302:                                 end

    303:

    304:                                 #Make the right class

    305:                                 class_name = name.gsub(" ", "_")

    306:                                 Object.const_set(class_name, Class.new {

    307:

    308:                                         eval("attr_reader :name")

    309:

    310:                                         eval("def initialize;  @name = \"#{name}\" end")

    311:

    312:                                         eval("def satisfied?; result = true\n #{code} \n end")

    313:

    314:                                         eval("def delete; end")

    315:

    316:                                 })

    317:

    318:                                 #Add the class and the name to the Shade.constraint_class_names

    319:                                 constraint_class = eval("#{class_name}")

    320:                                 Shade.add_constraint_class_name([constraint_class, name])

    321:                         end

    322:                 }

    323:

    324:                 Dir.chdir(old_dir)

    325:         end

load_custom_goals() click to toggle source

Loads the goals present in the directory “custom_constraints“

         # File lib/utils.rb, line 329
    329:         def ShadeUtils.load_custom_goals()

    330:                 #We suppose that custom constraints have already been syntax-checked and executed

    331:                 if Shade.using_sketchup

    332:                         file_name = Sketchup.find_support_file Constants::STARTUP_FILE_NAME, Constants::LIB_DIR

    333:                         directory = ShadeUtils.get_directory_from_sketchup_path(file_name)

    334:                         custom_goals_directory = "#{directory}/#{Constants::GOAL_FOLDER_NAME}"

    335:                 else

    336:                         custom_goals_directory = "#{File.dirname(__FILE__)}/#{Constants::GOAL_FOLDER_NAME}"

    337:                         custom_goals_directory.gsub!("/", "\\")

    338:                 end

    339:

    340:                 old_dir = Dir.pwd

    341:                 Dir.chdir(custom_goals_directory)

    342:

    343:                 #For each file inside the custom constraints directory

    344:                 Dir.entries(".").each { |file_name|

    345:                         if Shade.using_sketchup

    346:                                 file_path = "#{custom_goals_directory}/#{file_name}"

    347:                                 name =  get_title_from_sketchup_path(file_path)

    348:                         else

    349:                                 file_path = "#{custom_goals_directory}\\#{file_name}"

    350:                                 name =  get_title_from_path(file_path)

    351:                         end

    352:                         extension = get_extension(file_path)

    353:                         if extension == "txt"

    354:                                 code = ""

    355:                                 File.open(file_path, 'r') do |f|

    356:                                         while line = f.gets

    357:                                                 code += line

    358:                                         end

    359:                                 end

    360:

    361:                                 #Make the right class

    362:                                 class_name = name.gsub(" ", "_")

    363:                                 Object.const_set(class_name, Class.new {

    364:

    365:                                         eval("attr_reader :name")

    366:

    367:                                         eval("def initialize;  @name = \"#{name}\" end")

    368:

    369:                                         eval("def satisfied?; result = true\n #{code} \n end")

    370:

    371:                                         eval("def delete; end")

    372:

    373:                                 })

    374:

    375:                                 #Add the class and the name to the Shade.constraint_class_names

    376:                                 goal_class = eval("#{class_name}")

    377:                                 Shade.add_goal_class_name([goal_class, name])

    378:                         end

    379:                 }

    380:

    381:                 Dir.chdir(old_dir)

    382:         end

paint_rule(id, left, right) click to toggle source

Adds observers, descends the shapes and paint lines and arrow

          # File lib/utils.rb, line 981
     981:         def ShadeUtils.paint_rule(id, left, right)

     982:

     983:                 execution = Shade.project.execution

     984:

     985:                 previous_rule = execution.grammar.search_rule_by_id(id)

     986:

     987:                 if previous_rule

     988:                         UI.messagebox("The id #{id} is already in use")

     989:                         return nil

     990:                 end

     991:

     992:                 if Shade.using_sketchup

     993:

     994:                         # Get handles

     995:                         entities = Sketchup.active_model.entities

     996:

     997:                         if execution.grammar

     998:                                 idx = execution.grammar.rules.size

     999:                         else

    1000:                                 idx = 0

    1001:                         end

    1002:                         t = idx

    1003:

    1004:                         # Transform the layout transformation of the shapes

    1005:                         t_left = Geom::Transformation.new

    1006:                         t_right = Geom::Transformation.new

    1007:                         t.times do

    1008:                                 t_left = Constants::DESCEND_T * t_left

    1009:                                 t_right = Constants::DESCEND_T * t_right

    1010:                         end

    1011:                         t_left = Constants::LEFT_T * t_left

    1012:                         t_right = Constants::RIGHT_T * t_right

    1013:                         left.layout_transformation =  t_left

    1014:                         right.layout_transformation = t_right

    1015:

    1016:                         group_arrow = Hash.new(nil)

    1017:                         Sketchup.active_model.layers.each { |layer|

    1018:                                 # Draw an arrow, for the rule

    1019:                                 point1 = Constants::PTS_ARROW[0].clone

    1020:                                 point2 = Constants::PTS_ARROW[1].clone

    1021:                                 point3 = Constants::PTS_ARROW[2].clone

    1022:                                 point4 = Constants::PTS_ARROW[3].clone

    1023:

    1024:                                 t.times do

    1025:                                         point1.transform! Constants::DESCEND_T

    1026:                                         point2.transform! Constants::DESCEND_T

    1027:                                         point3.transform! Constants::DESCEND_T

    1028:                                         point4.transform! Constants::DESCEND_T

    1029:                                 end

    1030:

    1031:                                 group_arrow[layer.name] = entities.add_group

    1032:                                 group_arrow[layer.name].entities.add_line point1, point2

    1033:                                 group_arrow[layer.name].entities.add_line point3, point2

    1034:                                 group_arrow[layer.name].entities.add_line point4, point2

    1035:                                 group_arrow[layer.name].layer = layer

    1036:                                 group_arrow[layer.name].locked = true

    1037:                         }

    1038:

    1039:                         group_origin_right = Hash.new(nil)

    1040:                         group_origin_left = Hash.new(nil)

    1041:                         Sketchup.active_model.layers.each { |layer|

    1042:                                 #Draw the origin references

    1043:                                 point1 = Constants::PTS_ORIGIN[0].clone

    1044:                                 point2 = Constants::PTS_ORIGIN[1].clone

    1045:                                 point3 = Constants::PTS_ORIGIN[2].clone

    1046:                                 point4 = Constants::PTS_ORIGIN[3].clone

    1047:

    1048:                                 group_origin_left[layer.name] = entities.add_group

    1049:                                 group_origin_left[layer.name].entities.add_edges point1, point3

    1050:                                 group_origin_left[layer.name].entities.add_edges point2, point4

    1051:                                 group_origin_left[layer.name].transformation = t_left

    1052:                                 group_origin_left[layer.name].layer = layer

    1053:                                 group_origin_left[layer.name].locked = true

    1054:

    1055:

    1056:                                 group_origin_right[layer.name] = entities.add_group

    1057:                                 group_origin_right[layer.name].entities.add_edges point1, point3

    1058:                                 group_origin_right[layer.name].entities.add_edges point2, point4

    1059:                                 group_origin_right[layer.name].transformation = t_right

    1060:                                 group_origin_right[layer.name].layer = layer

    1061:                                 group_origin_right[layer.name].locked = true

    1062:

    1063:                         }

    1064:

    1065:                         line_group = Hash.new(nil)

    1066:                         Sketchup.active_model.layers.each { |layer|

    1067:                                 #Draw horizontal line

    1068:                                 point_h1 = Constants::PTS_H[0].clone

    1069:                                 point_h2 = Constants::PTS_H[1].clone

    1070:

    1071:                                 t.times do

    1072:                                         point_h1.transform! Constants::DESCEND_T

    1073:                                         point_h2.transform! Constants::DESCEND_T

    1074:                                 end

    1075:                                 line_group[layer.name] = entities.add_group

    1076:                                 line_group[layer.name].entities.add_line point_h1,point_h2

    1077:                                 line_group[layer.name].layer = layer

    1078:                                 line_group[layer.name].locked = true

    1079:

    1080:                         }

    1081:                 end

    1082:

    1083:                 # Create the rule

    1084:                 rule = Rule.new(id, left, right, line_group, group_arrow, group_origin_left, group_origin_right)

    1085:

    1086:                 return rule

    1087:         end

paint_rule_layout(rule_idx, layer_name) click to toggle source

rule_idx | the index of a rule
layer_name | a name of a layer

Paints the given layer of the rule specified by rule_idx

         # File lib/utils.rb, line 901
    901:         def ShadeUtils.paint_rule_layout(rule_idx, layer_name)

    902:

    903:                 if Shade.using_sketchup

    904:                         execution = Shade.project.execution

    905:                         rule = execution.grammar.rules[rule_idx]

    906:

    907:                         entities = Sketchup.active_model.entities

    908:

    909:                         t = rule_idx

    910:

    911:                         Sketchup.active_model.layers.each { |layer|

    912:                                 if layer.name == layer_name

    913:                                         # Draw an arrow, for the rule

    914:                                         point1 = Constants::PTS_ARROW[0].clone

    915:                                         point2 = Constants::PTS_ARROW[1].clone

    916:                                         point3 = Constants::PTS_ARROW[2].clone

    917:                                         point4 = Constants::PTS_ARROW[3].clone

    918:

    919:                                         t.times do

    920:                                                 point1.transform! Constants::DESCEND_T

    921:                                                 point2.transform! Constants::DESCEND_T

    922:                                                 point3.transform! Constants::DESCEND_T

    923:                                                 point4.transform! Constants::DESCEND_T

    924:                                         end

    925:

    926:                                         rule.arrow_group[layer.name] = entities.add_group

    927:                                         rule.arrow_group[layer.name].entities.add_line point1, point2

    928:                                         rule.arrow_group[layer.name].entities.add_line point3, point2

    929:                                         rule.arrow_group[layer.name].entities.add_line point4, point2

    930:                                         rule.arrow_group[layer.name].layer = layer

    931:                                         rule.arrow_group[layer.name].locked = true

    932:                                 end

    933:                         }

    934:

    935:                         Sketchup.active_model.layers.each { |layer|

    936:                                 if layer.name == layer_name

    937:                                         #Draw the origin references

    938:                                         point1 = Constants::PTS_ORIGIN[0].clone

    939:                                         point2 = Constants::PTS_ORIGIN[1].clone

    940:                                         point3 = Constants::PTS_ORIGIN[2].clone

    941:                                         point4 = Constants::PTS_ORIGIN[3].clone

    942:

    943:                                         rule.group_origin_left[layer.name] = entities.add_group

    944:                                         rule.group_origin_left[layer.name].entities.add_edges point1, point3

    945:                                         rule.group_origin_left[layer.name].entities.add_edges point2, point4

    946:                                         rule.group_origin_left[layer.name].transformation = rule.left.layout_transformation

    947:                                         rule.group_origin_left[layer.name].layer = layer

    948:                                         rule.group_origin_left[layer.name].locked = true

    949:

    950:

    951:                                         rule.group_origin_right[layer.name] = entities.add_group

    952:                                         rule.group_origin_right[layer.name].entities.add_edges point1, point3

    953:                                         rule.group_origin_right[layer.name].entities.add_edges point2, point4

    954:                                         rule.group_origin_right[layer.name].transformation = rule.right.layout_transformation

    955:                                         rule.group_origin_right[layer.name].layer = layer

    956:                                         rule.group_origin_right[layer.name].locked = true

    957:                                 end

    958:                         }

    959:

    960:                         Sketchup.active_model.layers.each { |layer|

    961:                                 if layer.name == layer_name

    962:                                         #Draw horizontal line

    963:                                         point_h1 = Constants::PTS_H[0].clone

    964:                                         point_h2 = Constants::PTS_H[1].clone

    965:

    966:                                         t.times do

    967:                                                 point_h1.transform! Constants::DESCEND_T

    968:                                                 point_h2.transform! Constants::DESCEND_T

    969:                                         end

    970:                                         rule.line_group[layer.name] = entities.add_group

    971:                                         rule.line_group[layer.name].entities.add_line point_h1,point_h2

    972:                                         rule.line_group[layer.name].layer = layer

    973:                                         rule.line_group[layer.name].locked = true

    974:                                 end

    975:                         }

    976:                 end

    977:         end

point_segment_distance(point, segment) click to toggle source

point | a Point object
segment | a Segment object
returns | the distance, in meters, from point to segment (ortogonally projected)

         # File lib/utils.rb, line 391
    391:         def ShadeUtils.point_segment_distance(point, segment)

    392:                 projected_point = OrderedPoint.new(point.project_to_line(segment.line_descriptor, segment.tail, segment.head))

    393:                 if segment.coincident? projected_point

    394:                         distance = point.distance(projected_point.point)

    395:                 else

    396:                         distance_start = point.distance(segment.tail.point)

    397:                         distance_end = point.distance(segment.head.point)

    398:                         distance = distance_end

    399:                         if distance_start < distance_end

    400:                                 distance = distance_start

    401:                         end

    402:                 end

    403:                 return distance

    404:         end

prepare_canvas(axes = true) click to toggle source

axes | true iff the axes are to be shown

Prepares the canvas for the plugin

          # File lib/utils.rb, line 1094
    1094:         def ShadeUtils.prepare_canvas(axes = true)

    1095:                 if Shade.using_sketchup

    1096:                         # Prepare view

    1097:                         Sketchup.send_action("viewTop:")

    1098:                         if axes

    1099:                                 Sketchup.send_action("viewShowAxes:")

    1100:                         end

    1101:

    1102:                         # Center view

    1103:                         eye = [Constants::PTS_H[1][0], Constants::PTS_H[1][1], Constants::INITIAL_Z_CAMERA]

    1104:                         target = Constants::PTS_H[1]

    1105:                         up = Sketchup.active_model.active_view.camera.up

    1106:                         Sketchup.active_model.active_view.camera.set eye, target, up

    1107:

    1108:                         # Draw vertical line

    1109:                         point1 = Constants::PTS_V[0].clone

    1110:                         point2 = Constants::PTS_V[1].clone

    1111:                         group = Sketchup.active_model.entities.add_group

    1112:                         group.entities.add_line point1,point2

    1113:                 end

    1114:         end

previous_rule_id() click to toggle source

returns | the id of the rule applied previously to the last one

          # File lib/utils.rb, line 1255
    1255:         def ShadeUtils.previous_rule_id()

    1256:                 if Shade.project.execution.execution_history

    1257:                         if Shade.project.execution.execution_history.size > 1

    1258:                                 return Shade.project.execution.execution_history[Shade.project.execution.execution_history.size - 2][0]

    1259:                         else

    1260:                                 return nil

    1261:                         end

    1262:                 else

    1263:                         return nil

    1264:                 end

    1265:         end

previous_shape() click to toggle source

returns | the shape previous to the last rule application

          # File lib/utils.rb, line 1170
    1170:         def ShadeUtils.previous_shape()

    1171:                 if Shade.project.execution.execution_history

    1172:                         return Shade.project.execution.execution_history.last[2]

    1173:                 else

    1174:                         return nil

    1175:                 end

    1176:         end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.