Index: openacs-4/packages/acs-templating/tcl/form-procs.tcl
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-templating/tcl/form-procs.tcl,v
diff -u -N -r1.56 -r1.57
--- openacs-4/packages/acs-templating/tcl/form-procs.tcl	14 Sep 2018 17:37:55 -0000	1.56
+++ openacs-4/packages/acs-templating/tcl/form-procs.tcl	14 Sep 2018 17:43:51 -0000	1.57
@@ -18,8 +18,8 @@
 namespace eval template {}
 namespace eval template::form {}
 
-ad_proc -public form {command args} { 
-    form is really template::form although when in 
+ad_proc -public form {command args} {
+    form is really template::form although when in
     the "template" namespace you may omit the
     template::
 
@@ -32,7 +32,7 @@
     template::form command invokes form functions.  Please see the
     individual functions for their arguments.  The template::element
     API is used to manipulate form elements.
-    
+
     @see template::form::create
     @see template::form::get_button
     @see template::form::get_action
@@ -60,148 +60,148 @@
     Initialize the data structures for a form.
 
     @param id               A keyword identifier for the form, such as "add_user" or
-                            "edit_item".  The ID must be unique in the context of a 
+                            "edit_item".  The ID must be unique in the context of a
                             single page.
 
     @option method          The standard METHOD attribute to specify in the HTML FORM
                             tag at the beginning of the rendered form. Defaults to POST.
 
     @option html            A list of additional name-value attribute pairs to
-                            include in the HTML FORM tag at the beginning of the 
+                            include in the HTML FORM tag at the beginning of the
                             rendered form. Common use for this option is to set multipart
                             form encoding by specifying "-html { enctype multipart/form-data }".
                             Please note that to comply with newer security features, such as CSP,
                             one should not specify JavaScript event handlers here, as they will
                             be rendered inline.
-    
-    @option mode            If set to 'display', the form is shown in display-only mode, where 
+
+    @option mode            If set to 'display', the form is shown in display-only mode, where
                             the user cannot edit the fields. Each widget knows how to display its contents
                             appropriately, e.g. a select widget will show the label, not the value. If set to
                             'edit', the form is displayed as normal, for editing. Defaults to 'edit'. Switching
                             to edit mode when a button is clicked in display mode is handled automatically.
-    
-    @option cancel_url      A url to redirect to when the user hits the Cancel button. 
+
+    @option cancel_url      A url to redirect to when the user hits the Cancel button.
                             If you do not supply a cancel_url, there will be no Cancel button.
-    
+
     @option cancel_label    The label of the Cancel button, if cancel_url is supplied.
                             Default is "Cancel".
-    
-    @option actions         A list of actions available on the form, which in practice means 
-                            a list of buttons to show when the form is in display mode. 
+
+    @option actions         A list of actions available on the form, which in practice means
+                            a list of buttons to show when the form is in display mode.
                             The value should be a list of lists, with the first element being the form label
                             and the second element being the name of the form element. Defaults to
-                            { { "Edit" edit } }. The name of the button clicked can be retrieved using 
+                            { { "Edit" edit } }. The name of the button clicked can be retrieved using
                             template::form::get_button. The name of the button clicked while in display mode
-                            is called the 'action', and can be retrieved using template::form::get_action. 
+                            is called the 'action', and can be retrieved using template::form::get_action.
                             The action is automatically carried forward to the form submission, so that the value
                             that you get from calling template::form::get_action on the final form submission
-                            is the name of the button which was called when the form changed from display 
+                            is the name of the button which was called when the form changed from display
                             mode to edit mode.
 
-    @option display_buttons List of buttons to show when the form is in display mode. 
-                            Equivalent to actions. If both actions and display_buttons are present, 
+    @option display_buttons List of buttons to show when the form is in display mode.
+                            Equivalent to actions. If both actions and display_buttons are present,
                             'actions' is used. 'display_buttons' is deprecated.
 
 
-    @option edit_buttons    List of buttons to show when the form is in edit mode. 
+    @option edit_buttons    List of buttons to show when the form is in edit mode.
                             The value should be a list of lists, with the first element being the button label
                             and the second element being the name. Defaults to
-                            { { "Ok" ok } }. The name of the button clicked can be retrieved using 
-                            template::form::get_button. 
-    
+                            { { "Ok" ok } }. The name of the button clicked can be retrieved using
+                            template::form::get_button.
+
     @option has_submit      Set to 1 to suppress the OK or submit button automatically
-                            added by the form builder. Use this if your form already includes its own 
+                            added by the form builder. Use this if your form already includes its own
                             submit button.
 
     @option has_edit        Set to 1 to suppress the Edit button automatically added by the
                             form builder. Use this if you include your own.
 
     @option elements        A block of element specifications.
 
-    @option show_required_p Should the form template show which elements are required. 
+    @option show_required_p Should the form template show which elements are required.
                             Use 1 or t for true, 0 or f for false. Defaults to true.
 
     @see template::form::get_button
     @see template::form::get_action
 
 } {
-  set level [template::adp_level]
+    set level [template::adp_level]
 
-  # bump the form_count for widgets that use JavaScript to navigate through
-  # the form (liberated from my Greenpeace work ages ago)
+    # bump the form_count for widgets that use JavaScript to navigate through
+    # the form (liberated from my Greenpeace work ages ago)
 
-  incr ::ad_conn(form_count)
+    incr ::ad_conn(form_count)
 
-  # keep form properties and a list of the element items
-  upvar #$level $id:elements elements $id:properties opts
+    # keep form properties and a list of the element items
+    upvar #$level $id:elements elements $id:properties opts
 
-  # ensure minimal defaults for form properties
-  variable defaults
-  array set opts $defaults
+    # ensure minimal defaults for form properties
+    variable defaults
+    array set opts $defaults
 
-  template::util::get_opts $args
+    template::util::get_opts $args
 
-  set elements [list]
+    set elements [list]
 
-  # check whether this form is being submitted
-  upvar #$level $id:submission submission
+    # check whether this form is being submitted
+    upvar #$level $id:submission submission
 
-  if {$id eq "request"} {
-    # request is the magic ID for the form holding query parameters
-    set submission 1
-  } else {
-    # If there's a form:id argument, and it's the ID of this form,
-    # we're being submitted
-    set submission [string equal $id [ns_queryget form:id]]
-  }
+    if {$id eq "request"} {
+        # request is the magic ID for the form holding query parameters
+        set submission 1
+    } else {
+        # If there's a form:id argument, and it's the ID of this form,
+        # we're being submitted
+        set submission [string equal $id [ns_queryget form:id]]
+    }
 
-  set formbutton [get_button $id]
+    set formbutton [get_button $id]
 
-  # If the user hit a button named "cancel", redirect and about
-  if { $submission && $formbutton eq "cancel" && [info exists opts(cancel_url)] && $opts(cancel_url) ne ""} {
-      ad_returnredirect $opts(cancel_url)
-      ad_script_abort
-  }
+    # If the user hit a button named "cancel", redirect and about
+    if { $submission && $formbutton eq "cancel" && [info exists opts(cancel_url)] && $opts(cancel_url) ne ""} {
+        ad_returnredirect $opts(cancel_url)
+        ad_script_abort
+    }
 
-  set formaction [get_action $id]
-  # If we were in display mode, and a button was clicked, we should be in edit mode now
-  if { $submission && [ns_queryget "form:mode"] eq "display" } {
-    set opts(mode) "edit"
-    set submission 0
-  }
+    set formaction [get_action $id]
+    # If we were in display mode, and a button was clicked, we should be in edit mode now
+    if { $submission && [ns_queryget "form:mode"] eq "display" } {
+        set opts(mode) "edit"
+        set submission 0
+    }
 
-  # add elements specified at the time the form is created
-  if { [info exists opts(elements)] } {
+    # add elements specified at the time the form is created
+    if { [info exists opts(elements)] } {
 
     # strip carriage returns
-    regsub -all {\r} $opts(elements) {} element_data
+        regsub -all {\r} $opts(elements) {} element_data
 
-    foreach element [split $element_data "\n"] {
-      set element [string trim $element]
-      if {$element eq {}} { continue }
-      template::element create $id {*}$element
+        foreach element [split $element_data "\n"] {
+            set element [string trim $element]
+            if {$element eq {}} { continue }
+            template::element create $id {*}$element
+        }
     }
-  }
 }
- 
+
 ad_proc -public template::form::set_properties { id args } {
     Set properties for a form
 
     @param id  The ID of an ATS form object.
-    @param args Properties to set 
+    @param args Properties to set
 } {
-  # form properties 
-  upvar #[template::adp_level] $id:properties opts
+    # form properties
+    upvar #[template::adp_level] $id:properties opts
 
-  template::util::get_opts $args
+    template::util::get_opts $args
 }
 
 ad_proc -public template::form::get_properties { id } {
     Get properties of a form
 
     @param id  The ID of a form
 } {
-    # form properties 
+    # form properties
     upvar #[template::adp_level] $id:properties formprop
 
     if { [info exists formprop] } {
@@ -219,37 +219,37 @@
     @param id  The ID of an ATS form object.
     @return the name of the button clicked
 } {
-  # keep form properties and a list of the element items
-  upvar #[template::adp_level] $id:button formbutton
-    
-  # If we've already found the button, just return that
-  if { [info exists formbutton] } {
-    return $formbutton
-  }
+    # keep form properties and a list of the element items
+    upvar #[template::adp_level] $id:button formbutton
 
-  # Otherwise, find out now
+    # If we've already found the button, just return that
+    if { [info exists formbutton] } {
+        return $formbutton
+    }
 
-  set formbutton {}
+    # Otherwise, find out now
 
-  # If the form isn't being submitted at all, no button was clicked
-  if { $id ne [ns_queryget form:id] } {
-    return {}
-  }
+    set formbutton {}
 
-  # Search the submit form for the button
-  set form [ns_getform]
+    # If the form isn't being submitted at all, no button was clicked
+    if { $id ne [ns_queryget form:id] } {
+        return {}
+    }
 
-  if { $form ne "" } {
-      set size [ns_set size $form]
-      for { set i 0 } { $i < $size } { incr i } {
-          if { [string match "formbutton:*" [ns_set key $form $i]] } {
-              set formbutton [string range [ns_set key $form $i] [string length "formbutton:"] end]
-              break
-          }
-      }
-  }
+    # Search the submit form for the button
+    set form [ns_getform]
 
-  return $formbutton
+    if { $form ne "" } {
+        set size [ns_set size $form]
+        for { set i 0 } { $i < $size } { incr i } {
+            if { [string match "formbutton:*" [ns_set key $form $i]] } {
+                set formbutton [string range [ns_set key $form $i] [string length "formbutton:"] end]
+                break
+            }
+        }
+    }
+
+    return $formbutton
 }
 
 ad_proc -public template::form::get_action { id } {
@@ -259,35 +259,35 @@
     @param id  The ID of an ATS form object.
     @return the name of the action in progress
 } {
-  # keep form properties and a list of the element items
-  upvar #[template::adp_level] $id:formaction formaction
-    
-  # If we've already found the action, just return that
-  if { [info exists formaction] } {
-    return $formaction
-  }
+    # keep form properties and a list of the element items
+    upvar #[template::adp_level] $id:formaction formaction
 
-  # Otherwise, find out now
+    # If we've already found the action, just return that
+    if { [info exists formaction] } {
+        return $formaction
+    }
 
-  set formaction {}
+    # Otherwise, find out now
 
-  # If the form isn't being submitted at all, there's no action
-  if { $id ne [ns_queryget "form:id"] } {
-    return {}
-  }
+    set formaction {}
 
-  set formbutton [get_button $id]
+    # If the form isn't being submitted at all, there's no action
+    if { $id ne [ns_queryget "form:id"] } {
+        return {}
+    }
 
-  # If we were in display mode, and a button was clicked, we should be in edit mode now
-  if { [ns_queryget "form:mode"] eq "display" && $formbutton ne "" } {
-    set formaction $formbutton
-    return $formaction
-  }
+    set formbutton [get_button $id]
 
-  # Otherwise, there should be a form:formaction variable in the form
-  set formaction [ns_queryget "form:formaction"]
+    # If we were in display mode, and a button was clicked, we should be in edit mode now
+    if { [ns_queryget "form:mode"] eq "display" && $formbutton ne "" } {
+        set formaction $formbutton
+        return $formaction
+    }
 
-  return $formaction
+    # Otherwise, there should be a form:formaction variable in the form
+    set formaction [ns_queryget "form:formaction"]
+
+    return $formaction
 }
 
 ad_proc -public template::form::exists { id } {
@@ -297,9 +297,9 @@
 
     @return 1 if a form with the specified ID exists. 0 if it does not.
 } {
-  upvar #[template::adp_level] $id:elements elements 
+    upvar #[template::adp_level] $id:elements elements
 
-  return [info exists elements]
+    return [info exists elements]
 }
 
 ad_proc -private template::form::template { id { style "" } } {
@@ -313,53 +313,53 @@
     @return A string containing a template for the body of the form.
 } {
 
-  get_reference 
+    get_reference
 
-  #
-  # Elements
-  # RAL: moved this below so we could take advantage of the template::element
-  # API in the button loop above.  The buttons multirow in standard.adp is
-  # no longer necessary.
-  #
-  set elements:rowcount 0
+    #
+    # Elements
+    # RAL: moved this below so we could take advantage of the template::element
+    # API in the button loop above.  The buttons multirow in standard.adp is
+    # no longer necessary.
+    #
+    set elements:rowcount 0
 
-  foreach element_ref $elements {
+    foreach element_ref $elements {
 
-    incr elements:rowcount
+        incr elements:rowcount
 
-    # get a reference by index for the multirow data source
-    upvar #$level $element_ref elements:${elements:rowcount} 
-    set "elements:${elements:rowcount}(rownum)" ${elements:rowcount}
-  }
+        # get a reference by index for the multirow data source
+        upvar #$level $element_ref elements:${elements:rowcount}
+        set "elements:${elements:rowcount}(rownum)" ${elements:rowcount}
+    }
 
-  if {$style eq {}} { 
-      set style [parameter::get \
-                     -package_id [ad_conn subsite_id] \
-                     -parameter DefaultFormStyle \
-                     -default [parameter::get \
-                                   -package_id [apm_package_id_from_key "acs-templating"] \
-                                   -parameter DefaultFormStyle \
-                                   -default "standard-lars"]]
-  }
+    if {$style eq {}} {
+        set style [parameter::get \
+            -package_id [ad_conn subsite_id] \
+            -parameter DefaultFormStyle \
+            -default [parameter::get \
+            -package_id [apm_package_id_from_key "acs-templating"] \
+            -parameter DefaultFormStyle \
+            -default "standard-lars"]]
+    }
 
-  set file_stub [template::resource_path -type forms -style $style]
+    set file_stub [template::resource_path -type forms -style $style]
 
-  if { ![file exists "$file_stub.adp"] } {
-      # We always have a template named 'standard'
-      set file_stub [template::resource_path -type forms -style standard]
-  }
+    if { ![file exists "$file_stub.adp"] } {
+        # We always have a template named 'standard'
+        set file_stub [template::resource_path -type forms -style standard]
+    }
 
-  # ensure that the style template has been compiled and is up-to-date
-  template::adp_init adp $file_stub
+    # ensure that the style template has been compiled and is up-to-date
+    template::adp_init adp $file_stub
 
-  # get result of template output procedure into __adp_output
-  # the only data source on which this template depends is the "elements"
-  # multirow data source.  The output of this procedure will be
-  # placed in __adp_output in this stack frame.
+    # get result of template output procedure into __adp_output
+    # the only data source on which this template depends is the "elements"
+    # multirow data source.  The output of this procedure will be
+    # placed in __adp_output in this stack frame.
 
-  template::code::adp::$file_stub
+    template::code::adp::$file_stub
 
-  return $__adp_output
+    return $__adp_output
 }
 
 ad_proc -private template::form::generate { id { style "" } } {
@@ -372,32 +372,32 @@
 
     @return A string containing the HTML for the body of the form.
 } {
-  set __adp_output [template $id $style]
-  
-  set level [template::adp_level]
+    set __adp_output [template $id $style]
 
-  # compile the template
-  set code [template::adp_compile -string $__adp_output]
+    set level [template::adp_level]
 
-  # these variables are expected by the formwidget and formgroup tags
-  set form:id $id
-  upvar #$level $id:elements $id:elements formerror formerror $id:properties form_properties
+    # compile the template
+    set code [template::adp_compile -string $__adp_output]
 
-  foreach element_ref [set $id:elements] { 
-    # get a reference by element ID for formwidget and formgroup tags
-    upvar #$level $element_ref $element_ref
-  }
+    # these variables are expected by the formwidget and formgroup tags
+    set form:id $id
+    upvar #$level $id:elements $id:elements formerror formerror $id:properties form_properties
 
-  # evaluate the code and return the rendered HTML for the form
-  return [template::adp_eval code]
+    foreach element_ref [set $id:elements] {
+        # get a reference by element ID for formwidget and formgroup tags
+        upvar #$level $element_ref $element_ref
+    }
+
+    # evaluate the code and return the rendered HTML for the form
+    return [template::adp_eval code]
 }
 
-ad_proc -public template::form::section { 
-	{-fieldset ""}
-	{-legendtext ""}
-	{-legend ""}
-	id 
-	section 
+ad_proc -public template::form::section {
+    {-fieldset ""}
+    {-legendtext ""}
+    {-legend ""}
+    id
+    section
 } {
     Set the current section (fieldset) of the form. A form may be
     divided into any number of fieldsets to group related
@@ -426,27 +426,27 @@
     set properties(sec_fieldset) ""
     array set fs_attributes $fieldset
     foreach name [array names fs_attributes] {
-	if {$fs_attributes($name) eq ""} {
-	    append properties(sec_fieldset) " $name"
-	} else {
-	    append properties(sec_fieldset) " $name=\"$fs_attributes($name)\""
-	}
+        if {$fs_attributes($name) eq ""} {
+            append properties(sec_fieldset) " $name"
+        } else {
+            append properties(sec_fieldset) " $name=\"$fs_attributes($name)\""
+        }
     }
 
     # legend attributes
     set properties(sec_legend) ""
     if { $legendtext ne "" } {
-	array set lg_attributes $legend
+        array set lg_attributes $legend
         if {![info exists lg_attributes(class)]} {
             append properties(sec_legend) " class=\"form-legend\""
         }
-	foreach name [array names lg_attributes] {
-	    if {$lg_attributes($name) eq ""} {
-		append properties(sec_legend) " $name"
-	    } else {
-		append properties(sec_legend) " $name=\"$lg_attributes($name)\""
-	    }
-	}
+        foreach name [array names lg_attributes] {
+            if {$lg_attributes($name) eq ""} {
+                append properties(sec_legend) " $name"
+            } else {
+                append properties(sec_legend) " $name=\"$lg_attributes($name)\""
+            }
+        }
     }
 }
 
@@ -460,193 +460,193 @@
 
     @return A string containing the rendered tags.
 } {
-  get_reference
+    get_reference
 
-  #----------------------------------------------------------------------
-  # Check for errors on form
-  #----------------------------------------------------------------------
+    #----------------------------------------------------------------------
+    # Check for errors on form
+    #----------------------------------------------------------------------
 
-  # make a reference to the formerror array with any validation messages
-  upvar #$level $id:error $id:error
+    # make a reference to the formerror array with any validation messages
+    upvar #$level $id:error $id:error
 
-  # Clear the formerror array if it has
-  # been set by another form on the same page
-  upvar #$level formerror formerror
-  if { [info exists formerror] } { unset formerror }
+    # Clear the formerror array if it has
+    # been set by another form on the same page
+    upvar #$level formerror formerror
+    if { [info exists formerror] } { unset formerror }
 
-  if { [info exists $id:error] } {
+    if { [info exists $id:error] } {
 
-      uplevel #$level "upvar 0 $id:error formerror"
-    
-      # There were errors on the form, force edit mode
-      set properties(mode) edit
-  }
+        uplevel #$level "upvar 0 $id:error formerror"
 
-  #----------------------------------------------------------------------
-  # Buttons
-  #----------------------------------------------------------------------
-
-  if { [info exists form_properties(cancel_url)] && $form_properties(cancel_url) ne ""} {
-    if {![info exists form_properties(cancel_label)] || $form_properties(cancel_label) eq ""} {
-      set form_properties(cancel_label) [_ acs-kernel.common_Cancel]
+        # There were errors on the form, force edit mode
+        set properties(mode) edit
     }
-    lappend form_properties(edit_buttons) [list $form_properties(cancel_label) cancel]
-  }
 
-  if { [info exists form_properties(has_submit)] 
-       && [template::util::is_true $form_properties(has_submit)] 
-     } {
-    set form_properties(edit_buttons) {}
-  }
-  
-  if { [info exists form_properties(has_edit)] 
-       && [template::util::is_true $form_properties(has_edit)] 
-     } {
-    set form_properties(display_buttons) {}
-  }
+    #----------------------------------------------------------------------
+    # Buttons
+    #----------------------------------------------------------------------
 
-  if { [info exists form_properties(actions)] 
-       && $form_properties(actions) ne "" 
-     } {
-    set form_properties(display_buttons) $form_properties(actions)
-  }
-    
-  # We keep this, so if anyone has an old form template that still loops over this multirow, it won't break hard
-  # We should remove this later, maybe 6.0
-  set buttons:rowcount 0
+    if { [info exists form_properties(cancel_url)] && $form_properties(cancel_url) ne ""} {
+        if {![info exists form_properties(cancel_label)] || $form_properties(cancel_label) eq ""} {
+            set form_properties(cancel_label) [_ acs-kernel.common_Cancel]
+        }
+        lappend form_properties(edit_buttons) [list $form_properties(cancel_label) cancel]
+    }
 
-  foreach button $form_properties(${form_properties(mode)}_buttons) {
-    lassign $button label name
+    if { [info exists form_properties(has_submit)]
+         && [template::util::is_true $form_properties(has_submit)]
+    } {
+        set form_properties(edit_buttons) {}
+    }
 
-    if {$name eq "ok"} {
-      # We hard-code the OK button to be wider than it otherwise would
-      set label "       $label       "
+    if { [info exists form_properties(has_edit)]
+         && [template::util::is_true $form_properties(has_edit)]
+    } {
+        set form_properties(display_buttons) {}
     }
-    set name "formbutton:$name"
-    
-    template::element create $id $name -widget submit -label $label -datatype text
-  }
 
-  # Propagate form mode to all form elements
-  foreach element_ref $elements { 
- 
-    # get a reference by element ID 
-    upvar #$level $element_ref element
-   
-    # Check if the element has an empty string mode, and in 
-    # that case, set to form mode
-    if {$element(mode) eq ""} {
-      set element(mode) $properties(mode)
+    if { [info exists form_properties(actions)]
+         && $form_properties(actions) ne ""
+    } {
+        set form_properties(display_buttons) $form_properties(actions)
     }
-  }
 
-  # Check for errors in hidden elements
-  foreach element_ref $elements { 
-    
-    # get a reference by element ID 
-    upvar #$level $element_ref element
-   
-    if { $element(widget) eq "hidden" && 
-	 [info exists $id:error($element(id))] && [set $id:error($element(id))] ne "" 
-       } {
-      # Submitting invalid data to hidden elements is a common attack vector.  
-      # This does not give them much information in the response.
-      ad_return_complaint 1 "Your request is invalid."
-      ad_log Warning "Validation error in hidden form element.\
-	This may be part of a vulnerability scan or attack reconnaissance: \
-	'[set $id:error($element(id))]' on element '$element(id)'."
-      ad_script_abort
+    # We keep this, so if anyone has an old form template that still loops over this multirow, it won't break hard
+    # We should remove this later, maybe 6.0
+    set buttons:rowcount 0
+
+    foreach button $form_properties(${form_properties(mode)}_buttons) {
+        lassign $button label name
+
+        if {$name eq "ok"} {
+        # We hard-code the OK button to be wider than it otherwise would
+            set label "       $label       "
+        }
+        set name "formbutton:$name"
+
+        template::element create $id $name -widget submit -label $label -datatype text
     }
-  }
 
-  # get any additional attributes developer specified to include in form tag
-  if { [info exists properties(html)] } {
-    array set attributes $properties(html)
-  }
+    # Propagate form mode to all form elements
+    foreach element_ref $elements {
 
-  # add on or replace with attributes specified by designer in formtemplate tag
-  array set attributes $tag_attributes
+        # get a reference by element ID
+        upvar #$level $element_ref element
 
-  # set the form to point back to itself if action is not specified
-  if { ! [info exists properties(action)] } {
-    set properties(action) [ns_conn url]
-  }
-  
-  set output "<form id=\"$id\" name=\"$id\" method=\"$properties(method)\" 
-                    action=\"$properties(action)\""
+        # Check if the element has an empty string mode, and in
+        # that case, set to form mode
+        if {$element(mode) eq ""} {
+            set element(mode) $properties(mode)
+        }
+    }
 
-  ### 2/17/2007
-  ### Adding a default class for forms if one does not exist 
-  if {![info exists attributes(class)]} {
-      append output " class=\"margin-form\""
-  }
+    # Check for errors in hidden elements
+    foreach element_ref $elements {
 
-  # make sure, that event handlers have IDs
-  foreach name [array names attributes] {
-      if {[regexp -nocase {^on(.*)%} $name . event]} {
-          if {![info exists attributes(id)]} {
-              set attributes(id) "id[clock clicks -microseconds]"
-          }
-      }
-  }
-    
-  # append attributes to form tag
-  foreach name [array names attributes] {
-    if {[regexp -nocase {^on(.*)%} $name . event]} {
-        #
-        # Convert automatically on$event attribute into event listener
-        #
-        ns_log notice "automatically adding event listener for attribute $name in form with id $id"
-        template::add_event_listener \
-            -event $event
-            -id $attributes(id) \
-            -script $attributes($name)
-    } elseif {$attributes($name) eq {}} {
-      append output " $name"
-    } else {
-      append output " $name=\"$attributes($name)\""
+        # get a reference by element ID
+        upvar #$level $element_ref element
+
+        if { $element(widget) eq "hidden" &&
+             [info exists $id:error($element(id))] && [set $id:error($element(id))] ne ""
+        } {
+            # Submitting invalid data to hidden elements is a common attack vector.
+            # This does not give them much information in the response.
+            ad_return_complaint 1 "Your request is invalid."
+            ad_log Warning "Validation error in hidden form element.\
+                This may be part of a vulnerability scan or attack reconnaissance: \
+                '[set $id:error($element(id))]' on element '$element(id)'."
+            ad_script_abort
+        }
     }
-  }
 
-  append output ">"
+    # get any additional attributes developer specified to include in form tag
+    if { [info exists properties(html)] } {
+        array set attributes $properties(html)
+    }
 
-  ### 2/11/2007
-  ### Adding Form Fieldset legend and attributes
-  if { [info exists properties(fieldset)] } {
-    # Fieldset
-    append output " <fieldset"
-    array set fs_attributes [lindex $properties(fieldset) 0]
-    if {![info exists fs_attributes(class)]} {
-      append output " class=\"form-fieldset\""
+    # add on or replace with attributes specified by designer in formtemplate tag
+    array set attributes $tag_attributes
+
+    # set the form to point back to itself if action is not specified
+    if { ! [info exists properties(action)] } {
+        set properties(action) [ns_conn url]
     }
-    foreach name [array names fs_attributes] {
-      if {$fs_attributes($name) eq {}} {
-	append output " $name"
-      } else {
-	append output " $name=\"$fs_attributes($name)\""
-      }
+
+    set output "<form id=\"$id\" name=\"$id\" method=\"$properties(method)\"
+    action=\"$properties(action)\""
+
+    ### 2/17/2007
+    ### Adding a default class for forms if one does not exist
+    if {![info exists attributes(class)]} {
+        append output " class=\"margin-form\""
     }
+
+    # make sure, that event handlers have IDs
+    foreach name [array names attributes] {
+        if {[regexp -nocase {^on(.*)%} $name . event]} {
+            if {![info exists attributes(id)]} {
+                set attributes(id) "id[clock clicks -microseconds]"
+            }
+        }
+    }
+
+    # append attributes to form tag
+    foreach name [array names attributes] {
+        if {[regexp -nocase {^on(.*)%} $name . event]} {
+            #
+            # Convert automatically on$event attribute into event listener
+            #
+            ns_log notice "automatically adding event listener for attribute $name in form with id $id"
+            template::add_event_listener \
+                -event $event
+            -id $attributes(id) \
+                -script $attributes($name)
+        } elseif {$attributes($name) eq {}} {
+            append output " $name"
+        } else {
+            append output " $name=\"$attributes($name)\""
+        }
+    }
+
     append output ">"
 
-    # Legend
-    set fieldset_legend [lindex $properties(fieldset) 1]
-    append output "<legend>$fieldset_legend</legend>"
-  }
+    ### 2/11/2007
+    ### Adding Form Fieldset legend and attributes
+    if { [info exists properties(fieldset)] } {
+        # Fieldset
+        append output " <fieldset"
+        array set fs_attributes [lindex $properties(fieldset) 0]
+        if {![info exists fs_attributes(class)]} {
+            append output " class=\"form-fieldset\""
+        }
+        foreach name [array names fs_attributes] {
+            if {$fs_attributes($name) eq {}} {
+                append output " $name"
+            } else {
+                append output " $name=\"$fs_attributes($name)\""
+            }
+        }
+        append output ">"
 
-  # Export form ID and current form mode
-  append output [export_vars -form { { form\:id $id } { form\:mode $properties(mode) } }]
-  
-  # If we're in edit mode, output the action
-  upvar #$level $id:formaction formaction
+        # Legend
+        set fieldset_legend [lindex $properties(fieldset) 1]
+        append output "<legend>$fieldset_legend</legend>"
+    }
+
+    # Export form ID and current form mode
+    append output [export_vars -form { { form\:id $id } { form\:mode $properties(mode) } }]
+
+    # If we're in edit mode, output the action
+    upvar #$level $id:formaction formaction
     if { $properties(mode) eq "edit"
          && [info exists formaction]
          && $formaction ne ""
-     } {
-    upvar #$level $id:formaction action
-    append output [export_vars -form { { form\:formaction $formaction } }]
-  }
+    } {
+        upvar #$level $id:formaction action
+        append output [export_vars -form { { form\:formaction $formaction } }]
+    }
 
-  return $output
+    return $output
 }
 
 ad_proc -private template::form::check_elements { id } {
@@ -656,48 +656,48 @@
 
     @param id               The form identifier
 } {
-  get_reference
+    get_reference
 
-  set output ""
+    set output ""
 
-  foreach element_ref $elements { 
- 
-    # get a reference by element ID 
-    upvar #$level $element_ref element
-   
-    # Check if the element has been rendered already
-    if {$element(is_rendered) == "f"} {
+    foreach element_ref $elements {
 
-      # If the element is hidden, render it
-      if {$element(widget) eq "hidden"} {
+        # get a reference by element ID
+        upvar #$level $element_ref element
 
-        append output "<div>[template::element render $id $element(id) {} ]</div>\n"
-        set element(is_rendered) t
+        # Check if the element has been rendered already
+        if {$element(is_rendered) == "f"} {
 
-      } else {
+            # If the element is hidden, render it
+            if {$element(widget) eq "hidden"} {
 
-        ad_log Warning "template::form::check_elements: MISSING FORMWIDGET: $id\:$element_ref"
-        # Throw an error ?
-      }
+                append output "<div>[template::element render $id $element(id) {} ]</div>\n"
+                set element(is_rendered) t
+
+            } else {
+
+                ad_log Warning "template::form::check_elements: MISSING FORMWIDGET: $id\:$element_ref"
+                # Throw an error ?
+            }
+        }
     }
-  }
- 
-  return $output
+
+    return $output
 }
 
 ad_proc -public template::form::is_request { id } {
     Return true if preparing a form for an initial request (as opposed
     to repreparing a form that is returned to the user due to validation
-    problems).  This command is used to conditionally set default values 
+    problems).  This command is used to conditionally set default values
     for form elements.
 
     @param id               The form identifier
 
-    @return 1 if preparing a form for an initial request; or 0 if 
-            repreparing a form that is returned to the user due to 
+    @return 1 if preparing a form for an initial request; or 0 if
+            repreparing a form that is returned to the user due to
             validation problems
 } {
-  return [expr {! [is_submission $id]}] 
+    return [expr {! [is_submission $id]}]
 }
 
 ad_proc -public template::form::is_submission { id } {
@@ -708,9 +708,9 @@
 
     @return 1 if true or 0 if false
 } {
-  upvar #[template::adp_level] $id:submission submission
+    upvar #[template::adp_level] $id:submission submission
 
-  return $submission
+    return $submission
 }
 
 ad_proc -public template::form::is_valid { id } {
@@ -723,51 +723,51 @@
 
     @return 1 if id is the form identifier of a valid submission or 0 otherwise
 } {
-  upvar #[template::adp_level] $id:submission submission $id:error formerror
+    upvar #[template::adp_level] $id:submission submission $id:error formerror
 
-  if { ! $submission } { 
-    return 0 
-  }
+    if { ! $submission } {
+        return 0
+    }
 
-  if { [info exists formerror] } {
+    if { [info exists formerror] } {
     # errors exist in the form so it is not valid
-    return 0 
-  } else {
+        return 0
+    } else {
     # no errors exist in the form, submission approved
-    return 1
-  }
+        return 1
+    }
 }
 
 ad_proc -public template::form::get_values { id args } {
     Set local variables for form variables (assume they are all single values).
     Typically used when processing the form submission to prepare for DML
     or other type of transaction.
 
-    NB! This proc must always be called through "form get_values" 
-    or "template::form get_values", or it won't be able to find 
+    NB! This proc must always be called through "form get_values"
+    or "template::form get_values", or it won't be able to find
     the variable.
 
 
     @param id            The form identifier
     @param args          A list of element identifiers. If the list is empty,
                          retrieve all form elements
 } {
-  if { [llength $args] > 0 } {
-    set elements $args
-  } else {
-    # Get all the form elements 
-    set elements [get_elements $id]
-  }
+    if { [llength $args] > 0 } {
+        set elements $args
+    } else {
+        # Get all the form elements
+        set elements [get_elements $id]
+    }
 
-  foreach element_id $elements {
-    upvar 2 $element_id value
-    set value [template::element get_value $id $element_id]
-  }
+    foreach element_id $elements {
+        upvar 2 $element_id value
+        set value [template::element get_value $id $element_id]
+    }
 }
 
-ad_proc -public template::form::get_elements { 
+ad_proc -public template::form::get_elements {
     {-no_api:boolean}
-    id 
+    id
 } {
     Return a list of element names for the form with given id.
 
@@ -798,15 +798,15 @@
     @param id               The form identifier
     @return the list of form errors
 } {
-  upvar #[template::adp_level] $id:error formerror
+    upvar #[template::adp_level] $id:error formerror
 
-  if { [info exists formerror] } {
-    # errors exist in the form, return them
-    return [array get formerror]
-  } else {
-    # no errors exist in the form, return the empty list
-    return [list]
-  }
+    if { [info exists formerror] } {
+        # errors exist in the form, return them
+        return [array get formerror]
+    } else {
+        # no errors exist in the form, return the empty list
+        return [list]
+    }
 }
 
 ad_proc -public template::form::get_combined_values { id args } {
@@ -815,25 +815,25 @@
 
     @param id             The form identifier
     @param args           A list of element identifiers. Each identifier may be
-                          a regexp. For example, 
+                          a regexp. For example,
                           <code>form get_combined_values "foo.*"</code>
                           will combine the values of all elements starting with
                           "foo"
 
     @return               The combined list of values
 } {
-  get_reference 
+    get_reference
 
-  set exp [join $args "|"]
-  set values [list]
+    set exp [join $args "|"]
+    set values [list]
 
-  foreach element_name $properties(element_names) {
-    if { [regexp $exp $element_name match] } {
-      lappend values {*}[template::element get_values $id $element_name]
+    foreach element_name $properties(element_names) {
+        if { [regexp $exp $element_name match] } {
+            lappend values {*}[template::element get_values $id $element_name]
+        }
     }
-  }
 
-  return $values
+    return $values
 }
 
 ad_proc -public template::form::set_values { id array_ref } {
@@ -842,20 +842,20 @@
     source from database and pass the resulting array reference to
     set_values for setting default values in an update form.
 
-    NB! This proc must always be called through "form set_values" 
-    or "template::form set_values", or it won't be able to find 
+    NB! This proc must always be called through "form set_values"
+    or "template::form set_values", or it won't be able to find
     the variable.
 
     @param id               The form identifier
     @param array_ref        The name of a local array variable whose
                             keys correspond to element identifiers in the form
 } {
-  upvar 2 $array_ref values
-  
-  foreach name [array names values] {
-    
-    template::element set_value $id $name $values($name) 
-  }
+    upvar 2 $array_ref values
+
+    foreach name [array names values] {
+
+        template::element set_value $id $name $values($name)
+    }
 }
 
 ad_proc -public template::form::export {} {
@@ -866,46 +866,46 @@
     @return A string containing hidden input tags for inclusion in a
             form.
 } {
-  set form [ns_getform]
-  if { $form eq "" } { return "" }
+    set form [ns_getform]
+    if { $form eq "" } { return "" }
 
-  set export_data ""
+    set export_data ""
 
-  for { set i 0 } { $i < [ns_set size $form] } { incr i } {
-    
-    set key [ns_set key $form $i]
-    set value [ns_set value $form $i]
+    for { set i 0 } { $i < [ns_set size $form] } { incr i } {
 
-    append export_data "
-      <div><input type=\"hidden\" name=\"$key\" value=\"[ns_quotehtml $value]\"></div>"
-  }
+        set key [ns_set key $form $i]
+        set value [ns_set value $form $i]
 
-  return $export_data
+        append export_data "
+        <div><input type=\"hidden\" name=\"$key\" value=\"[ns_quotehtml $value]\"></div>"
+    }
+
+    return $export_data
 }
 
 ad_proc -public template::form::size { id } {
     @param id               The form identifier
     @return the number of elements in the form identified by id
 } {
-  template::form::get_reference
-  return [llength $elements]
+    template::form::get_reference
+    return [llength $elements]
 }
 
 ad_proc -private template::form::get_reference {} {
     Helper procedure used to access the basic data structures of a form object.
     Called by several of the form commands.
 } {
-  uplevel {
-    set level [template::adp_level]
-    
-    # GN: why does it alias "$id:properties" to "properties" and
-    # "form_properties"?
-    upvar #$level $id:elements elements $id:properties properties $id:properties form_properties
+    uplevel {
+        set level [template::adp_level]
 
-    if { ! [info exists elements] } {
-      error "Form $id does not exist"
+        # GN: why does it alias "$id:properties" to "properties" and
+        # "form_properties"?
+        upvar #$level $id:elements elements $id:properties properties $id:properties form_properties
+
+        if { ! [info exists elements] } {
+            error "Form $id does not exist"
+        }
     }
-  }
 }
 
 ad_proc -public template::form::set_error {
@@ -914,10 +914,10 @@
     error
 } {
 
-    Set an error on a form element. Can be called from the -on_submit or 
-    -after_submit block of an ad_form. Will cause the form to no longer 
-    be considered valid, and thus the form will be redisplayed with the 
-    error message embedded, provided that 'break' is also called, so any 
+    Set an error on a form element. Can be called from the -on_submit or
+    -after_submit block of an ad_form. Will cause the form to no longer
+    be considered valid, and thus the form will be redisplayed with the
+    error message embedded, provided that 'break' is also called, so any
     code that redirects away from the form (e.g. in the after_submit block)
     isn't called either.
 
@@ -929,7 +929,7 @@
 } {
     # use an array to hold error messages for this form
     upvar #[template::adp_level] $id:error formerror
-    
+
     set formerror($element) $error
 }