---

Class ::xowiki::formfield::repeatContainer

::xowiki::formfield::repeatContainer create ... \
           [ -max (default "5") ] \
           [ -min (default "1") ] \
           [ -repeat_add_label (default "#xowiki.form-repeatable-add#") ] \
           [ -repeat_remove_label (default "#xowiki.delete#") ]

Class Relations

• class: ::xotcl::Class
• superclass: ::xowiki::formfield::CompoundField

::xotcl::Class create ::xowiki::formfield::repeatContainer \
     -superclass ::xowiki::formfield::CompoundField

Methods (to be applied on instances)

• check_nr_components (scripted)

  if {$neededComponents > $availableComponents} {
    lassign [:item_spec] isRequired itemSpec
    for {set i $availableComponents} {$i < $neededComponents} {incr i} {
      :require_component $i
    }
  }

• component_item_spec (scripted)

  #
  # Return a single itemspec suited for the nth component, derived
  # from the repeatable formfield spec.
  #
  if {$i <= [:min] && $isRequired} {
    set componentItemSpec [list $i $itemSpec,required,label=$i]
  } else {
    set componentItemSpec [list $i $itemSpec,label=$i]
  }
  return $componentItemSpec

• convert_to_internal (scripted)

  set values [:value]
  :trim_values
  set r [next]
  #:msg name=${:name},value=[:get_compound_value]
  
  #
  # remove "unneeded" entries from instance attributes
  #
  ${:object} instvar instance_attributes
  foreach {name value} $values {
    if {[dict exists $instance_attributes $name]} {
      dict unset instance_attributes $name
    }
  }
  return $r

• count_values (scripted)

  set count 1
  set highestCount 1
  if {![:required]} {set highestCount [:min]}
  # The first pair is the default from the template field (.0)
  set default [lindex $values 1]
  foreach f [lrange ${:components} 1 end] {name value} [lrange $values 2 end] {
    if {[$f required] || ($value ne "" && ![$f same_value $value $default])} {set highestCount $count}
    incr count
  }
  return $highestCount

• initialize (scripted)

  ::xo::Page requireJS "/resources/xowiki/repeat.js"
  ::xo::Page requireJS urn:ad:js:jquery
  
  if {[info exists :__initialized_repeat]} {return}
  next
  
  set :__initialized_repeat 1
  #
  # Derive the spec of the contained items from the spec of the
  # container.
  #
  lassign [:item_spec] isRequired itemSpec
  
  #
  # Use item .0 as template for other items in .js (e.g. blank an
  # item with the template, when it is deleted. By using a
  # potentially compound item as template, we are able to preserve
  # default values for subfields without knowing the detailed
  # structure).
  #
  set componentItemSpecs [list [list 0 $itemSpec]]
  
  #
  # Add max content items (1 .. max) and build form fields
  #
  set formAction [${:object} form_parameter __form_action:graph {}]
  # TODO: we use for the time being the code for dynamic repeat field
  if {0 && $formAction eq ""} {
    #
    # The form field is in input mode; as long there is no js
    # support do incrementally add form fields in js, we have to
    # generate it here.
    #
    set max [:max]
  } else {
    #set max [:max]
    set max [:min] ;# use dynamic repeat fields: if set to min, repeat fields will be created on demand
  }
  #ns_log notice "dynamic repeat MAX=$max FORMACTION <$formAction>"
  for {set i 1} {$i <= $max} {incr i} {
    set componentItemSpec [:component_item_spec $i $itemSpec $isRequired]
    #ns_log notice "dynamic repeat componentItemSpec $componentItemSpec"
    lappend componentItemSpecs $componentItemSpec
  }
  :create_components $componentItemSpecs
  
  #
  # Deactivate template item
  #
  set componentList ${:components}
  if {[llength $componentList] > 0} {
    [lindex $componentList 0] set_disabled true
    [lindex $componentList 0] set_is_repeat_template true
  }

• item_spec (scripted)

  #
  # Return the spec of a contained item, which is a subset of the
  # container spec.
  #
  set result {}
  set is_required false
  foreach s [split [:spec] ,] {
    # don't propagate "repeat" and "label" properties
    if { [string match "repeat=*" $s] || [string match "label=*" $s] } continue
    if { "required" eq $s} {set is_required true; continue}
    if { "disabled" eq $s} {:set_disabled true}
    lappend result $s
  }
  return [list $is_required [join $result ,]]

• max (setter)

• min (setter)

• pretty_value (scripted)

  #
  # Simple renderer for repeated values
  #
  set ff [dict create {*}$v]
  set html "<ol class='repeatContainer'>\n"
  
  :set_compound_value $v
  foreach c [lrange ${:components} 1 [:count_values $v]] {
    if {[dict exists $ff [$c set name]]} {
      append html "<li>[$c pretty_value [dict get $ff [$c set name]]]</li>\n"
    }
  }
  append html "</ol>\n"
  return $html

• render_input (scripted)

  #
  # Render content of the container within in a fieldset,
  # without labels for the contained items.
  #
  html::fieldset [:get_attributes id {CSSclass class}] {
    set i 0
    set clientData [subst {{"min":${:min},"max":${:max}, "name":"${:name}"}}]
    set CSSclass   "[:form_widget_CSSclass] repeatable"
  
    set providedValues [:count_values [:value]]
    if {${:min} > $providedValues} {
      set nrItems ${:min}
    } else {
      set nrItems $providedValues
    }
    incr nrItems
  
    set containerIsDisabled [:is_disabled]
    set containerIsPrototype [string match "*.0*" ${:name}]
    set isPrototypeElement 0
    foreach c ${:components} {
      set atts [list class $CSSclass]
      lappend atts data-repeat $clientData
      if {$i == 0 || $i >= $nrItems} {
        lappend atts style "display: none;"
      }
      ::html::div $atts {
        #
        # Compound fields - link not shown if we are not rendering
        # for the template and copy the template afterwards.
        #
        if {!$containerIsDisabled || $containerIsPrototype} {
          set del_id "repeat-del-link-[$c set id]"
          ::html::a -href "#"  -id $del_id  -title ${:repeat_remove_label}  -class "delete-item-button repeat-del-link" {
                html::t ""
              }
          template::add_event_listener  -id $del_id  -script [subst {xowiki.repeat.delItem(this,'$clientData');}]
        }
        $c render_input          
      }
      incr i
    }
    #ns_log notice "repeat container $c [$c name] isDisabled $containerIsDisabled containerIsPrototype $containerIsPrototype"
    if {!$containerIsDisabled || $containerIsPrototype } {
      set hidden [expr {[:count_values [:value]] == ${:max} ? "display: none;" : ""}]
      set add_id "repeat-add-link-[:id]"
      #ns_log notice "... add another for ${:name}"
      html::a -href "#"  -id $add_id  -style $hidden  -class "repeat-add-link" {
            html::t ${:repeat_add_label}
          }
      template::add_event_listener  -id $add_id  -script [subst {xowiki.repeat.newItem(this,'$clientData');}]
    }
  }

• repeat_add_label (setter)

• repeat_remove_label (setter)

• require_component (scripted)

  #
  # Require the nth component of a repeat field
  #
  lassign [:item_spec] isRequired itemSpec
  set componentItemSpec [:component_item_spec $i $itemSpec $isRequired]
  #ns_log notice "dynamic repeat field: add component on the fly: $componentItemSpec"
  :add_component $componentItemSpec

• set_compound_value (scripted)

  #
  # Before setting compound values, check if we have the repeat
  # structure already set.
  #
  set neededComponents [expr {[llength $value] / 2}]
  set availableComponents [llength ${:components}]
  #:log "repeatContainer set_compound_value <$value> have $availableComponents needed $neededComponents"
  :check_nr_components $neededComponents $availableComponents
  next

• trim_values (scripted)

  # Trim trailing values identical to default.
  # Trimming the components list seems sufficient.
  set count [:count_values [:value]]
  set :components [lrange ${:components} 0 $count]

• validate (scripted)

  foreach c [lrange ${:components} 1 [:count_values [:value]]] {
    set result [$c validate $obj]
    if {$result ne ""} {
      return $result
    }
  }
  return ""

---