# Name :          Walltool
# Description :   Create a wall segment in a group
# Author :        Didier Bur
# Usage :         Select plugins/Multi-layer wall segment, enter values and height, click 2 points
# Date :          05.Oct.2oo4
# Type :          tool
# History:        1.0 (01.Oct.2oo4) - beta version
#                 2.0 (05.Oct.2oo4) - support styles
#                     (07.Oct.2oo4) - bug fixes
#-----------------------------------------------------------------------------

# 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'

#----------------------------------------------------------------------------- Utilities
def polar(p1, p2, d, angle)
 
  v = p2 - p1
  v.length = d
  translate = Geom::Transformation.translation(v)
  p_temp = p1.transform(translate)
  rotate = Geom::Transformation.rotation( p1, Geom::Vector3d.new(0, 0, 1), angle)
  result = p_temp.transform(rotate)
  return result

end
#----------------------------------------------------------------------------- Save
def mlw_save
  model = Sketchup.active_model
  entities = model.entities
  ad = model.attribute_dictionaries
  mlw_names = []
  mlw_params = []
  mlw_number = 0
  f_name = UI.openpanel "Select file to save wall styles" 
  if f_name
    file = File.new( f_name.to_s, "w" )
    # scan model for mlw styles
    i = 0
    entities.each {|e|
      #att = e.attribute_dictionary("MLW") 
      if e.attribute_dictionary("MLW")
        mlw_names[i] = e.get_attribute("MLW", "n")
        mlw_params[i] = e.get_attribute("MLW", "p")
        i = i + 1
      end 
    }
    mlw_names.uniq!
    mlw_params.uniq!
    mlw_number = mlw_names.length
    i = 0

    0.upto( mlw_names.length - 1) do |a|
      file.puts mlw_names[i]
      file.puts mlw_params[i]
      i = i + 1
    end
    file.close
    UI.messagebox mlw_number.to_s + " wall styles saved in file " + f_name
  else
    UI.messagebox "No file created or selected."
  end #of if
end # of def
#----------------------------------------------------------------------------- Load
def mlw_load
  model = Sketchup.active_model
  entities = model.entities
  $mlw_names = []
  $mlw_params = []
  $mlw_number = 0
  $layers_mat = []
  $layers_wid = []
  f_name = UI.openpanel "Select file to load wall styles" 
  if f_name
    file = File.new( f_name.to_s, "r" )
    $mlw = IO.readlines(f_name.to_s)
    i = 0
    j = 0
    0.upto( ($mlw.length / 2) - 1 ) do |e|
      $mlw_names[i] = $mlw[j].chomp
      $mlw_params[i] = $mlw[j+1].chomp
      i = i + 1
      j = j + 2
    end
    file.close
    # Dialog box
    prompts = ["Choose a style to load  ", "Wall height "]
    enums = [$mlw_names.join("|")]
    values = [$mlw_name, $height]
    results = inputbox prompts, values, enums, $mlw_names.length.to_s + " styles available:"
    return if not results
    $mlw_name, $height = results
    else
      UI.messagebox "No file selected."
  end # of if
  
    $params =  $mlw_params[$mlw_names.index($mlw_name)].split(";")
    $axis = $params[0]
    $just = $params[1]
    $layer_n = $params[2].to_i
    
    $layers_mat[0] = $params[3]
    $layers_wid[0] = $params[4]
    $layers_mat[1] = $params[5]
    $layers_wid[1] = $params[6]
    $layers_mat[2] = $params[7]
    $layers_wid[2] = $params[8]
    $layers_mat[3] = $params[9]
    $layers_wid[3] = $params[10]
    
    $layer_wid_1 = $layers_wid[0].to_f
    $layer_wid_2 = $layers_wid[1].to_f
    $layer_wid_3 = $layers_wid[2].to_f
    $layer_wid_4 = $layers_wid[3].to_f
    
    $wall_width = $layer_wid_1 + $layer_wid_2 + $layer_wid_3 + $layer_wid_4

  $height = $height

  # Material error checking
  $existing_mats = []
  materials=model.materials
  $existing_mats = materials.collect {|m| m.name}
  $layers_mat.each {|mat|
    if not ( $existing_mats.include?(mat) ) and mat != "-"

        UI.messagebox "Warning: " + mat + " not present in model.\n Please load it or this can lead to errors."
    end
  }
  
  if $mlw_name
    UI.messagebox"You can now use " + $mlw_name + " as the current style.\n Don't modify anything in the dialog boxes to use this style."
  end
end # of def

class MultiwallTool

# This is the standard Ruby initialize method that is called when you create
# a new object.
def initialize

  model = Sketchup.active_model
  entities = model.entities
  
  # Search for existing wall styles in the model
  ad = model.attribute_dictionaries
  mlw_names = []
    # If MLW attribute_dictionnary exists, then get it, else create it
    if ad
      ad_mlw = ad["MLW"]
    else
      ad_mlw = model.attribute_dictionary("MLW", true)
    end
  
  # Collect the MLW names, if any
  i = 0
  entities.each do |e|
    #att = e.attribute_dictionary("MLW") 
    if e.attribute_dictionary("MLW")
      mlw_names[i] = e.get_attribute("MLW", "n")
      i = i + 1
    end 
  end #of each
  mlw_names.uniq!

  # Dialog box 1: prompts for existing style or new style
  $mlw_name = "" if not $mlw_name
  $new_style = ""
  $height = 250.0 if not $height
  prompts = ["Existing wall styles  ", "New style  ", " Wall height"]
  enums = [mlw_names.join("|")]
  values = [$mlw_name, $new_style, $height]
  results = inputbox prompts, values, enums, mlw_names.length.to_s + " styles available:"
  return if not results
  $mlw_name, $new_style, $height = results
  
  if( $new_style != "" )#----------------------------------------------------------- New style created
    # create a new style
    $mlw_name = $new_style
    else
    # ------------------------------------------------------------------------------- or get existing style parameters
    # Collect the MLW "$mlw_name" params
    i = 0
    entities.each do |e|
    if e.attribute_dictionary("MLW") and ( e.get_attribute("MLW", "n") == $mlw_name )
    $pars = nil
    $params = nil
    $pars = e.get_attribute("MLW", "p")
    $params = $pars.split(";")
    i = i + 1
    end 
    end # of each
  end # of if
  
  if( $new_style == "" ) #----------------------------------------------------------- Existing style params
    $layers_mat = []
    $layers_wid = []
    $axis = $params[0]
    $just = $params[1]
    $layer_n = $params[2].to_i
    
    $layers_mat[0] = $params[3]
    $layers_wid[0] = $params[4].to_l
    $layers_mat[1] = $params[5]
    $layers_wid[1] = $params[6].to_l
    $layers_mat[2] = $params[7]
    $layers_wid[2] = $params[8].to_l
    $layers_mat[3] = $params[9]
    $layers_wid[3] = $params[10].to_l
    
    $layer_wid_1 = $layers_wid[0].to_l
    $layer_wid_2 = $layers_wid[1].to_l
    $layer_wid_3 = $layers_wid[2].to_l
    $layer_wid_4 = $layers_wid[3].to_l
    
    $wall_width = $layer_wid_1 + $layer_wid_2 + $layer_wid_3 + $layer_wid_4
  end  
  
  @ip1 = nil
  @ip2 = nil
  @xdown = 0
  @ydown = 0
  mat = []
  mat_names = []
 
  if( $new_style != "" ) #----------------------------------------------------------- New style created
    $layers_mat = []
    $layers_wid = []
  end  
  
  if( $new_style != "" ) #----------------------------------------------------------- New style created
    inputbox1 = %w[Yes No].join("|") 
    inputbox2 = %w[Left Center Right].join("|")
    layer_number = %w[1 2 3 4].join("|")
    array_of_dropdowns = [inputbox1, inputbox2, layer_number]
  
    # sets the default wall settings
    $axis = "No" if not $axis
    $just = "Center" if not $just
    $layer_n = 3 if not $layer_n
    $height = 250.0 if not $height

  
    # Dialog box 2: main params
    prompts = ["Draw walls axis  ", "Wall positionning ", "Number of layers  "]
    values = [$axis, $just, $layer_n]
    $axis, $just, $layer_n = inputbox prompts,values, array_of_dropdowns, "Wall main parameters"
  
    # Materials list
    materials=model.materials
    all_colors = Sketchup::Color.names
    mat_names = materials.collect {|m| m.name}
    if mat_names.empty?
      mat = [all_colors.join("|")]
      else
      mat = [mat_names.join("|")]
    end
    layer_1 = mat
    layer_2 = mat
    layer_3 = mat
    layer_4 = mat
  
    # sets the default layers settings
    $layer_wid_1 = 1 if not $layer_wid_1
    $layer_wid_2 = 2 if not $layer_wid_2
    $layer_wid_3 = 10 if not $layer_wid_3
    $layer_wid_4 = 1 if not $layer_wid_4
    $layer_mat_1 = "-" if not $layer_mat_1
    $layer_mat_2 = "-" if not $layer_mat_2
    $layer_mat_3 = "-" if not $layer_mat_3
    $layer_mat_4 = "-" if not $layer_mat_4
    $layer_wid_1 = 0 if not $layer_wid_1
    $layer_wid_2 = 0 if not $layer_wid_2
    $layer_wid_3 = 0 if not $layer_wid_3
    $layer_wid_4 = 0 if not $layer_wid_4
  
  # Dialog box 3: materials and widths
  if( $layer_n == 1 )
    array_of_layers = [layer_1]
    prompts = ["Layer 1 material ", "Layer 1 width "]
    values = [$layer_mat_1, $layer_wid_1]
    $layer_mat_1, $layer_wid_1, = inputbox prompts, values, array_of_layers, "Layers parameters"
    $layers_mat[0] = $layer_mat_1
    $layers_wid[0] = $layer_wid_1
    
    $layer_mat_2 = "-"
    $layer_wid_2 = 0
    $layer_mat_3 = "-"
    $layer_wid_3 = 0
    $layer_mat_4 = "-"
    $layer_wid_4 = 0
    
    
    $layers_mat[1] = $layer_mat_2
    $layers_wid[1] = $layer_wid_2
    $layers_mat[2] = $layer_mat_3
    $layers_wid[2] = $layer_wid_3
    $layers_mat[3] = $layer_mat_4
    $layers_wid[3] = $layer_wid_4
    $wall_width = $layer_wid_1
  end # of if
  
  if( $layer_n == 2 )
    array_of_layers = [layer_1, layer_2]
    prompts = ["Layer 1 material ", "Layer 2 material  ", "Layer 1 width ", "Layer 2 width "]
    values = [$layer_mat_1, $layer_mat_2, $layer_wid_1, $layer_wid_2]
    $layer_mat_1, $layer_mat_2, $layer_wid_1, $layer_wid_2 = inputbox prompts, values, array_of_layers, "Layers parameters"
    $layers_mat[0] = $layer_mat_1
    $layers_mat[1] = $layer_mat_2
    $layers_wid[0] = $layer_wid_1
    $layers_wid[1] = $layer_wid_2
    
    $layer_mat_3 = "-"
    $layer_wid_3 = 0
    $layer_mat_4 = "-"
    $layer_wid_4 = 0
    
    $layers_mat[2] = $layer_mat_3
    $layers_wid[2] = $layer_wid_3
    $layers_mat[3] = $layer_mat_4
    $layers_wid[3] = $layer_wid_4
    $wall_width = $layer_wid_1 + $layer_wid_2
  end # of if2
  
    if( $layer_n == 3 )
    array_of_layers = [layer_1, layer_2, layer_3]
    prompts = ["Layer 1 material ", "Layer 2 material  ", "Layer 3 material  ", "Layer 1 width ", "Layer 2 width ", "Layer 3 width "]
    values = [$layer_mat_1, $layer_mat_2, $layer_mat_3, $layer_wid_1, $layer_wid_2, $layer_wid_3]
    $layer_mat_1, $layer_mat_2, $layer_mat_3, $layer_wid_1, $layer_wid_2, $layer_wid_3 = inputbox prompts, values, array_of_layers, "Layers parameters"
    $layers_mat[0] = $layer_mat_1
    $layers_mat[1] = $layer_mat_2
    $layers_mat[2] = $layer_mat_3
    $layers_wid[0] = $layer_wid_1
    $layers_wid[1] = $layer_wid_2
    $layers_wid[2] = $layer_wid_3
    
    $layer_mat_4 = "-"
    $layer_wid_4 = 0
    
    $layers_mat[3] = $layer_mat_4
    $layers_wid[3] = $layer_wid_4
    $wall_width = $layer_wid_1 + $layer_wid_2 + $layer_wid_3
  end # of if3
  
  if( $layer_n == 4 )
    array_of_layers = [layer_1, layer_2, layer_3, layer_4]
    prompts = ["Layer 1 material ", "Layer 2 material  ", "Layer 3 material  ", "Layer 4 material  ", "Layer 1 width ", "Layer 2 width ", "Layer 3 width ", "Layer 4 width "]
    values = [$layer_mat_1, $layer_mat_2, $layer_mat_3, $layer_mat_4, $layer_wid_1, $layer_wid_2, $layer_wid_3, $layer_wid_4]
  
    $layer_mat_1, $layer_mat_2, $layer_mat_3, $layer_mat_4, $layer_wid_1, $layer_wid_2, $layer_wid_3, $layer_wid_4 = inputbox prompts, values, array_of_layers, "Layers parameters"
    
    $layers_mat[0] = $layer_mat_1
    $layers_mat[1] = $layer_mat_2
    $layers_mat[2] = $layer_mat_3
    $layers_mat[3] = $layer_mat_4
    $layers_wid[0] = $layer_wid_1
    $layers_wid[1] = $layer_wid_2
    $layers_wid[2] = $layer_wid_3
    $layers_wid[3] = $layer_wid_4
    $wall_width = $layer_wid_1 + $layer_wid_2 + $layer_wid_3 + $layer_wid_4
  end # of if4
  
    else
    $layer_mat_1 = $layers_mat[0]
    $layer_mat_2 = $layers_mat[1]
    $layer_mat_3 = $layers_mat[2]
    $layer_mat_4 = $layers_mat[3]
    $layer_wid_1 = $layers_wid[0]
    $layer_wid_2 = $layers_wid[1]
    $layer_wid_3 = $layers_wid[2]
    $layer_wid_4 = $layers_wid[3]
    
    
  end #of new style created
end

# The activate method is called by SketchUp when the tool is first selected.
# it is a good place to put most of your initialization
def activate

    # The Sketchup::InputPoint class is used to get 3D points from screen
    # positions.  It uses the SketchUp inferencing code.
    # In this tool, we will have two points for the endpoints of the line.
    @ip1 = Sketchup::InputPoint.new
    @ip2 = Sketchup::InputPoint.new
    @ip = Sketchup::InputPoint.new
    @drawn = false
    
    # This sets the label for the VCB
    Sketchup::set_status_text "Wall length", SB_VCB_LABEL
    
    self.reset(nil)

end

# deactivate is called when the tool is deactivated because
# a different tool was selected
def deactivate(view)
    view.invalidate if @drawn
end

# The onMouseMove method is called whenever the user moves the mouse.
# because it is called so often, it is important to try to make it efficient.
# In a lot of tools, your main interaction will occur in this method.
def onMouseMove(flags, x, y, view)
    if( @state == 0 )
        # We are getting the first end of the line.  Call the pick method
        # on the InputPoint to get a 3D position from the 2D screen position
        # that is bassed as an argument to this method.
        @ip.pick view, x, y
        if( @ip != @ip1 )
            # if the point has changed from the last one we got, then
            # see if we need to display the point.  We need to display it
            # if it has a display representation or if the previous point
            # was displayed.  The invalidate method on the view is used
            # to tell the view that something has changed so that you need
            # to refresh the view.
            view.invalidate if( @ip.display? or @ip1.display? )
            @ip1.copy! @ip
            
            # set the tooltip that should be displayed to this point
            view.tooltip = @ip1.tooltip
        end
    else
        # Getting the second end of the line
        # If you pass in another InputPoint on the pick method of InputPoint
        # it uses that second point to do additional inferencing such as
        # parallel to an axis.
        @ip2.pick view, x, y, @ip1
        view.tooltip = @ip2.tooltip if( @ip2.valid? )
        view.invalidate
        
        # Update the length displayed in the VCB
        if( @ip2.valid? )
            length = @ip1.position.distance(@ip2.position)
            Sketchup::set_status_text length.to_s, SB_VCB_VALUE
        end
        
        # Check to see if the mouse was moved far enough to create a line.
        # This is used so that you can create a line by either draggin
        # or doing click-move-click
        if( (x-@xdown).abs > 10 || (y-@ydown).abs > 10 )
            @dragging = true
        end
    end
end

# The onLButtonDOwn method is called when the user presses the left mouse button.
def onLButtonDown(flags, x, y, view)
    # When the user clicks the first time, we switch to getting the
    # second point.  When they click a second time we create the line
    if( @state == 0 )
        @ip1.pick view, x, y
        if( @ip1.valid? )
            @state = 1
            Sketchup::set_status_text "End of wall axis ", SB_PROMPT
            @xdown = x
            @ydown = y
        end
    else
        # create the line on the second click
        if( @ip2.valid? )
            self.create_geometry(@ip1.position, @ip2.position,view)
            self.reset(view)
        end
    end
    
    # Clear any inference lock
    view.lock_inference
end

# The onLButtonUp method is called when the user releases the left mouse button.
def onLButtonUp(flags, x, y, view)
    # If we are doing a drag, then create the line on the mouse up event
    if( @dragging && @ip2.valid? )
        self.create_geometry(@ip1.position, @ip2.position,view)
        self.reset(view)
    end
end

# onKeyDown is called when the user presses a key on the keyboard.
# We are checking it here to see if the user pressed the shift key
# so that we can do inference locking
def onKeyDown(key, repeat, flags, view)
    if( key == CONSTRAIN_MODIFIER_KEY && repeat == 1 )
        @shift_down_time = Time.now
        
        # if we already have an inference lock, then unlock it
        if( view.inference_locked? )
            # calling lock_inference with no arguments actually unlocks
            view.lock_inference
        elsif( @state == 0 && @ip1.valid? )
            view.lock_inference @ip1
        elsif( @state == 1 && @ip2.valid? )
            view.lock_inference @ip2, @ip1
        end
    end
end

# onKeyUp is called when the user releases the key
# We use this to unlock the interence
# If the user holds down the shift key for more than 1/2 second, then we
# unlock the inference on the release.  Otherwise, the user presses shift
# once to lock and a second time to unlock.
def onKeyUp(key, repeat, flags, view)
    if( key == CONSTRAIN_MODIFIER_KEY &&
        view.inference_locked? &&
        (Time.now - @shift_down_time) > 0.5 )
        view.lock_inference
    end
end

# onUserText is called when the user enters something into the VCB
# In this implementation, we create a line of the entered length if
# the user types a length while selecting the second point
def onUserText(text, view)
    # We only accept input when the state is 1 (i.e. getting the second point)
    # This could be enhanced to also modify the last line created if a length
    # is entered after creating a line.
    return if not @state == 1
    return if not @ip2.valid?
    
    # The user may type in something that we can't parse as a length
    # so we set up some exception handling to trap that
    begin
        value = text.to_l
    rescue
        # Error parsing the text
        UI.beep
        puts "Cannot convert #{text} to a Length"
        value = nil
        Sketchup::set_status_text "", SB_VCB_VALUE
    end
    return if !value

    # Compute the direction and the second point
    pt1 = @ip1.position
    vec = @ip2.position - pt1
    if( vec.length == 0.0 )
        UI.beep
        return
    end
    vec.length = value
    pt2 = pt1 + vec

    # Create a line
    self.create_geometry(pt1, pt2, view)
    self.reset(view)
end

# The draw method is called whenever the view is refreshed.  It lets the
# tool draw any temporary geometry that it needs to.
def draw(view)
    if( @ip1.valid? )
        if( @ip1.display? )
            @ip1.draw(view)
            @drawn = true
        end
        
        if( @ip2.valid? )
            @ip2.draw(view) if( @ip2.display? )
            
            # The set_color_from_line method determines what color
            # to use to draw a line based on its direction.  For example
            # red, green or blue.
            view.set_color_from_line(@ip1, @ip2)
            self.draw_geometry(@ip1.position, @ip2.position, view)
            @drawn = true
        end
    end
end

# onCancel is called when the user hits the escape key
def onCancel(flag, view)
    self.reset(view)
end


# The following methods are not directly called from SketchUp.  They are
# internal methods that are used to support the other methods in this class.

# Reset the tool back to its initial state
def reset(view)
    # This variable keeps track of which point we are currently getting
    @state = 0
    
    # Display a prompt on the status bar
    Sketchup::set_status_text("Select first end", SB_PROMPT)
    
    # clear the InputPoints
    @ip1.clear
    @ip2.clear
    
    if( view )
        view.tooltip = nil
        view.invalidate if @drawn
    end
    
    @drawn = false
    @dragging = false
end

# Create new geometry when the user has selected two points.
def create_geometry(p1, p2, view)
    
    model = Sketchup.active_model
    # define a new group
    group = Sketchup.active_model.entities.add_group
    entities = group.entities
    # set an attribute MLW:name
    group.set_attribute "MLW", "n", $mlw_name
    # set an attribute MLW:params
    $params = $axis + ";" + $just + ";" + $layer_n.to_s + ";" + $layers_mat[0] + ";" + $layers_wid[0].to_s + ";" + $layers_mat[1] + ";" + $layers_wid[1].to_s + ";" + $layers_mat[2] + ";" + $layers_wid[2].to_s + ";" + $layers_mat[3] + ";" + $layers_wid[3].to_s + ";"
  
    group.set_attribute "MLW", "p", $params
    model.start_operation "Create Wall"
    
    # Computes the other lines
    pis2 = 1.5707963267948965
    pt1_0 = @ip1.position
    pt2_0 = p2
    vec = @ip2.position - pt1_0
    rotate_left_1 = Geom::Transformation.rotation( pt1_0, Geom::Vector3d.new(0, 0, 1), pis2)
    rotate_right_1 = Geom::Transformation.rotation( pt1_0, Geom::Vector3d.new(0, 0, 1), (0 - pis2))
    rotate_left_2 = Geom::Transformation.rotation( pt2_0, Geom::Vector3d.new(0, 0, 1), pis2)
    rotate_right_2 = Geom::Transformation.rotation( pt2_0, Geom::Vector3d.new(0, 0, 1), (0 - pis2))
  # ----------------------------------------------------------------------------------------------------- One layer
  if( $layer_n == 1)
    pt1_1l = nil
    pt1_1r = nil
    pt2_1l = nil
    pt2_1r = nil
    
    vec.length = ($wall_width.to_f / 2 )
    translate = Geom::Transformation.translation(vec)
    
    pt1t = pt1_0.transform(translate)
    
    if( $just == "Left" )
      pt1_1l = pt1t.transform(rotate_left_1)
      pt1_1r = pt1_0
    end
    if( $just == "Center" )
    
      pt1_1l = pt1t.transform(rotate_left_1)
      pt1_1r = pt1t.transform(rotate_right_1)
    end    
    if( $just == "Right" )
      pt1_1l = pt1_0
      pt1_1r = pt1t.transform(rotate_right_1)
    end

    pt2t = pt2_0.transform(translate)
    if( $just == "Left" )
      pt2_1l = pt2t.transform(rotate_left_2)
      pt2_1r = pt2_0
    end
    if( $just == "Center" )
      pt2_1l = pt2t.transform(rotate_left_2)
      pt2_1r = pt2t.transform(rotate_right_2)
    end    
    if( $just == "Right" )
      pt2_1l = pt2_0
      pt2_1r = pt2t.transform(rotate_right_2)
    end
    
    base = entities.add_face([pt1_1l, pt2_1l, pt2_1r,pt1_1r])
    base.reverse!
    base.material = $layer_mat_1
    base.pushpull $height

  end #of if $layer_n == 1
  
  # ----------------------------------------------------------------------------------------------------- Two layers
  if( $layer_n > 1)
    pt1_1l = nil
    pt1_1r = nil
    pt2_1l = nil
    pt2_1r = nil
    
  # First layer
    vec.length = $wall_width
    translate = Geom::Transformation.translation(vec)
    
    pt1t = pt1_0.transform(translate)
    pt2t = pt2_0.transform(translate)
    
    pt1_1l = polar( pt1_0, pt2_0, $wall_width, pis2 )
    pt1_1r = polar( pt1_0, pt2_0, ($wall_width - $layer_wid_1), pis2 )
    pt2_1l = polar( pt2_0, pt1_0, $wall_width, (0 - pis2))
    pt2_1r = polar( pt2_0, pt1_0, ($wall_width - $layer_wid_1), (0 - pis2))
    
    base = entities.add_face([pt1_1l, pt2_1l, pt2_1r,pt1_1r])
    base.reverse!
    base.material = $layer_mat_1
    base.pushpull $height
  
  # Second layer
    
    pt1_2l = nil
    pt1_2r = nil
    pt2_2l = nil
    pt2_2r = nil
    vec.length = $wall_width - $layer_wid_1
    translate = Geom::Transformation.translation(vec)
    
    pt1t = pt1_0.transform(translate)
    pt2t = pt2_0.transform(translate)
    
    pt1_2l = polar( pt1_0, pt2_0, vec.length, pis2 )
    pt1_2r = polar( pt1_0, pt2_0, (vec.length - $layer_wid_2), pis2 )
    pt2_2l = polar( pt2_0, pt1_0, vec.length, (0 - pis2))
    pt2_2r = polar( pt2_0, pt1_0, (vec.length - $layer_wid_2), (0 - pis2))
    
    base = entities.add_face([pt1_2l, pt2_2l, pt2_2r,pt1_2r])
    base.reverse!
    base.material = $layer_mat_2
    base.pushpull $height
    base = entities.add_face([pt1_2l, pt2_2l, pt2_2r,pt1_2r])
    base.material = $layer_mat_2
    
  end #of if $layer_n > 1
  
  # ----------------------------------------------------------------------------------------------------- Three layers
  
  if( $layer_n > 2)
    pt1_3l = nil
    pt1_3r = nil
    pt2_3l = nil
    pt2_3r = nil
    
  # Third layer  
    vec.length = $wall_width - $layer_wid_1 - $layer_wid_2
    translate = Geom::Transformation.translation(vec)
    
    pt1t = pt1_0.transform(translate)
    pt2t = pt2_0.transform(translate)
    
    pt1_3l = polar( pt1_0, pt2_0, vec.length, pis2 )
    pt1_3r = polar( pt1_0, pt2_0, (vec.length - $layer_wid_3), pis2 )
    pt2_3l = polar( pt2_0, pt1_0, vec.length, (0 - pis2))
    pt2_3r = polar( pt2_0, pt1_0, (vec.length - $layer_wid_3), (0 - pis2))
    
    base = entities.add_face([pt1_3l, pt2_3l, pt2_3r,pt1_3r])
    base.reverse!
    base.material = $layer_mat_3
    base.pushpull $height
    base = entities.add_face([pt1_3l, pt2_3l, pt2_3r,pt1_3r])
    base.material = $layer_mat_3
  end #of if $layer_n > 2
    
  # ----------------------------------------------------------------------------------------------------- Four layers
  
  if( $layer_n > 3)
    pt1_4l = nil
    pt1_4r = nil
    pt2_4l = nil
    pt2_4r = nil
    
  # Fourth layer  
    vec.length = $wall_width - $layer_wid_1 - $layer_wid_2 - $layer_wid_3
    translate = Geom::Transformation.translation(vec)
    
    pt1t = pt1_0.transform(translate)
    pt2t = pt2_0.transform(translate)
    
    pt1_4l = polar( pt1_0, pt2_0, vec.length, pis2 )
    pt1_4r = polar( pt1_0, pt2_0, (vec.length - $layer_wid_4), pis2 )
    pt2_4l = polar( pt2_0, pt1_0, vec.length, (0 - pis2))
    pt2_4r = polar( pt2_0, pt1_0, (vec.length - $layer_wid_4), (0 - pis2))
    
    base = entities.add_face([pt1_4l, pt2_4l, pt2_4r,pt1_4r])
    base.reverse!
    base.material = $layer_mat_4
    base.pushpull $height
    base = entities.add_face([pt1_4l, pt2_4l, pt2_4r,pt1_4r])
    base.material = $layer_mat_4
  end #of if $layer_n > 3
  
  # group move
  if( $just == "Center" )
    vec = pt1_0 - pt1_1l
    vec.length = $wall_width / 2
    translate = Geom::Transformation.translation(vec)
    group.transform!(translate)
  end
  
  if( $just == "Right" )
    vec = pt1_0 - pt1_1l
    vec.length = $wall_width
    translate = Geom::Transformation.translation(vec)
    group.transform!(translate)
  end
  
  # Draw center line if any
  if( $axis == "Yes" )
      view.model.entities.add_cline(p1,p2)
  end
    
  model.commit_operation
    
end #of def create_geometry

# Draw the geometry
def draw_geometry(pt1, pt2, view)
    view.draw_line(pt1, pt2)
end

end # class WallTool

#-----------------------------------------------------------------------------
def multiwalltool
    Sketchup.active_model.select_tool MultiwallTool.new
end

if( not file_loaded?("multiwalltool_2.rb") )
    add_separator_to_menu("Plugins")
    UI.menu("Plugins").add_item("Load wall styles") { mlw_load }
    UI.menu("Plugins").add_item("Multi-layer wall segment") { multiwalltool }
    UI.menu("Plugins").add_item("Save wall styles") { mlw_save }
end
#-----------------------------------------------------------------------------
file_loaded("multiwalltool_2.rb")