Index: openacs-4/packages/xotcl-core/tcl/generic-procs.tcl
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/xotcl-core/tcl/generic-procs.tcl,v
diff -u -N -r1.98 -r1.99
--- openacs-4/packages/xotcl-core/tcl/generic-procs.tcl	7 Aug 2017 23:48:30 -0000	1.98
+++ openacs-4/packages/xotcl-core/tcl/generic-procs.tcl	21 Oct 2017 11:40:37 -0000	1.99
@@ -48,138 +48,128 @@
   
   Form instproc init {} {
     set level [template::adp_level]
-    my forward var uplevel #$level set 
+    :forward var uplevel #$level set 
 
-    my instvar data package_id folder_id
-    if {$package_id eq ""} {set package_id [$data package_id]}
-    if {$folder_id < 0} {
-      set folder_id [expr {[$data exists parent_id] ? [$data parent_id] : [$package_id folder_id]}]
+    if {${:package_id} eq ""} {set :package_id [${:data} package_id]}
+    if {${:folder_id} < 0} {
+      set :folder_id [expr {[${:data} exists parent_id] ? [${:data} parent_id] : [${:package_id} folder_id]}]
     }
     
-    set class [$data info class]
-    my set data_id [$class id_column]
+    set class [${:data} info class]
+    set :data_id [$class id_column]
 
-    if {![my exists add_page_title]} {
-      my set add_page_title [_ xotcl-core.create_new_type \
+    if {![info exists :add_page_title]} {
+      set :add_page_title [_ xotcl-core.create_new_type \
                                  [list type [$class pretty_name]]]
     }
-    if {![my exists edit_page_title]} {
-      my set edit_page_title [_ xotcl-core.edit_type \
+    if {![info exists :edit_page_title]} {
+      set :edit_page_title [_ xotcl-core.edit_type \
                                   [list type [$class pretty_name]]]
     }
 
-    if {![my exists fields]} {my mkFields}
-    #my log --fields=[my fields]
+    if {![info exists :fields]} {my mkFields}
+    #my log --fields=[:fields]
   }
   
   Form instproc form_vars {} {
     set vars [list]
-    foreach varspec [my fields] {
+    foreach varspec [:fields] {
       lappend vars [lindex [split [lindex $varspec 0] :] 0]
     }
     return $vars
   }
   Form instproc get_id_field {} {
-    my instvar data
-    if {[$data istype ::xo::db::CrItem]} {
+    if {[${:data} istype ::xo::db::CrItem]} {
       return item_id
     }
     return object_id
   }
   Form instproc new_data {} {
-    my instvar data
     #my log "--- new_data ---"
-    $data save_new
-    return [$data set [my get_id_field]]
+    ${:data} save_new
+    return [${:data} set [:get_id_field]]
   }
   Form instproc edit_data {} {
-    #my log "--- edit_data --- setting form vars=[my form_vars]"
-    my instvar data
-    $data save
+    #my log "--- edit_data --- setting form vars=[:form_vars]"
+    ${:data} save
     # Renaming is meant for cr_items and such
-    if {[$data istype ::xo::db::CrItem]} {
+    if {[${:data} istype ::xo::db::CrItem]} {
       set old_name [::xo::cc form_parameter __object_name ""]
-      set new_name [$data set name]
+      set new_name [${:data} set name]
       if {$old_name ne $new_name} {
         #
         # The item was renamed.
         #
 	#my log "--- rename from $old_name to $new_name"
-	$data rename -old_name $old_name -new_name $new_name
+	${:data} rename -old_name $old_name -new_name $new_name
         #
         # Check, whether we have to change the redirect url due to
         # renaming. When the method returns non-empty use this value.
         #
-        set url [$data changed_redirect_url]
+        set url [${:data} changed_redirect_url]
         if {$url ne ""} {
-          my submit_link $url
+          :submit_link $url
         }
       }
     }
-    return [$data set [my get_id_field]]
+    return [${:data} set [:get_id_field]]
   }
 
   Form instproc request {privilege} {
-    my instvar edit_form_page_title context data package_id
-
-    if {[my isobject ::$package_id] && ![::$package_id exists policy]} {
+    if {[:isobject ::${:package_id}] && ![::${:package_id} exists policy]} {
       # not needed, if governed by a policy
       auth::require_login
       permission::require_permission \
-          -object_id $package_id \
+          -object_id ${:package_id} \
           -privilege $privilege
     }
-    set edit_form_page_title [if {$privilege eq "create"} \
+    set :edit_form_page_title [if {$privilege eq "create"} \
                                   {my add_page_title} {my edit_page_title}]
 
-    set context [list $edit_form_page_title]
+    set :context [list ${:edit_form_page_title}]
   }
   
   Form instproc set_form_data {} {
-    my instvar data data_id
-    foreach var [$data info vars] {
-      if {![$data array exists $var]} {
-        my var $var [list [$data set $var]]
+    foreach var [${:data} info vars] {
+      if {![${:data} array exists $var]} {
+        :var $var [list [${:data} set $var]]
       }
     }
     # Alias object_id to the id of our object
-    if {[$data exists $data_id]} {
-      $data set object_id [$data set $data_id]
+    if {[${:data} exists ${:data_id}]} {
+      ${:data} set object_id [${:data} set ${:data_id}]
     }
   }
 
   Form instproc new_request {} {
     #my log "--- new_request ---"
-    my request create
-    my set_form_data
+    :request create
+    :set_form_data
   }
   Form instproc edit_request {item_id} {
     #my log "--- edit_request ---"
-    my request write
-    my set_form_data
+    :request write
+    :set_form_data
   }
 
   Form instproc on_submit {item_id} {
     # On redirects after a submit to the same page, ensure 
     # the setting of edit_form_page_title and context
-    my request write
+    :request write
     # Put form content into data object
-    my instvar data
-    foreach __var [my form_vars] {
-      $data set $__var [my var $__var]
+    foreach __var [:form_vars] {
+      ${:data} set $__var [:var $__var]
     }
-    $data initialize_loaded_object
+    ${:data} initialize_loaded_object
   }
 
   Form instproc on_validation_error {} {
-    my instvar edit_form_page_title context
     #my log "-- "
-    set edit_form_page_title [my edit_page_title]
-    set context [list $edit_form_page_title]
+    set :edit_form_page_title [:edit_page_title]
+    set :context [list ${:edit_form_page_title}]
   }
   Form instproc after_submit {item_id} {
-    my instvar data
-    set link [my submit_link]
+    set link [:submit_link]
     if {$link eq "view"} {
       set link [export_vars -base $link {item_id}]
     }
@@ -200,22 +190,23 @@
     @param export list of attribue value pairs to be exported to the form (nested list)
   } {
     # set form name for adp file
-    my set $template [my name]
-    my instvar data package_id folder_id
+    set :$template [:name]
 
-    set object_type [[$data info class] object_type]
-    set object_name [expr {[$data exists name] ? [$data set name] : ""}]
-    #my log "-- $data, cl=[$data info class] [[$data info class] object_type]"
+    set object_type [[${:data} info class] object_type]
+    set object_name [expr {[${:data} exists name] ? [${:data} set name] : ""}]
+    #my log "-- ${:data}, cl=[${:data} info class] [[${:data} info class] object_type]"
     
-    #my log "--e [my name] final fields [my fields]"
+    #my log "--e [:name] final fields [:fields]"
     set exports [list \
       [list object_type $object_type] \
-      [list folder_id $folder_id] \
-      [list __object_name $object_name]] 
-    if {[info exists export]} {foreach pair $export {lappend exports $pair}}
+                     [list folder_id ${:folder_id}] \
+                     [list __object_name $object_name]] 
+    if {[info exists export]} {
+      foreach pair $export {lappend exports $pair}
+    }
 
-    ad_form -name [my name] -form [my fields] -mode $mode \
-        -export $exports -action [my action] -html [my html]
+    ad_form -name [:name] -form [:fields] -mode $mode \
+        -export $exports -action [:action] -html [:html]
 
     set new_data            "set item_id \[[self] new_data\]"
     set edit_data           "set item_id \[[self] edit_data\]"
@@ -225,18 +216,18 @@
     set on_validation_error "[self] on_validation_error"
     set on_submit           "[self] on_submit \$item_id"
 
-    if {[my with_categories]} {
-      set coid [expr {[$data exists item_id] ? [$data set item_id] : ""}]
-      category::ad_form::add_widgets -form_name [my name] \
-          -container_object_id $package_id \
+    if {[:with_categories]} {
+      set coid [expr {[${:data} exists item_id] ? [${:data} set item_id] : ""}]
+      category::ad_form::add_widgets -form_name [:name] \
+          -container_object_id ${:package_id} \
           -categorized_object_id $coid
           
       # When editing, fill category form widgets 
       # with current mappings for this object
       append edit_request {
 	category::ad_form::fill_widgets \
-          -container_object_id $package_id \
-          -categorized_object_id $item_id
+            -container_object_id ${:package_id} \
+            -categorized_object_id $item_id
       }
       append new_data {
         category::map_object -remove_old -object_id $item_id $category_ids
@@ -246,16 +237,16 @@
       }
       append on_submit {
         set category_ids [category::ad_form::get_categories \
-                              -container_object_id $package_id]
+                              -container_object_id ${:package_id}]
       }
     }
     #ns_log notice "-- ad_form new_data=<$new_data> edit_data=<$edit_data> edit_request=<$edit_request>"
 
     # action blocks must be added last
     # -new_data and -edit_data are enclosed in a transaction only in the end,
     # so eventual additional code from category management is executed safely
-    ad_form -extend -name [my name] \
-        -validate [my validate] \
+    ad_form -extend -name [:name] \
+        -validate [:validate] \
         -new_data "xo::dc transaction \{ $new_data \}" -edit_data "xo::dc transaction \{ $edit_data \}" \
         -on_submit $on_submit -new_request $new_request -edit_request $edit_request \
         -on_validation_error $on_validation_error -after_submit $after_submit
@@ -429,97 +420,92 @@
   }
   
   List instproc init {} {
-    my instvar class name
-    my set id_column     [$class id_column]
-    my set pretty_name   [$class pretty_name]
-    set pretty_plural [$class pretty_plural]
-    my set pretty_plural $pretty_plural
-    my set list_name     $name
+    set :id_column     [${:class} id_column]
+    set :pretty_name   [${:class} pretty_name]
+    set :pretty_plural [${:class} pretty_plural]
+    set :list_name     ${:name}
   }
 
   List instproc get_actions {} {
-    my instvar actions no_create_p create_url
-    if {[string is false $no_create_p]} {
-      set type [my set pretty_name]
-      if {$create_url eq ""} {set create_url add-edit}
+    if {[string is false ${:no_create_p}]} {
+      set type ${:pretty_name}
+      if {${:create_url} eq ""} {set create_url add-edit}
       set create_action [list \
-                             [_ xotcl-core.create_new_type] $create_url [_ xotcl-core.create_new_type]]
-      set actions [concat $create_action $actions]
+                             [_ xotcl-core.create_new_type] ${:create_url} [_ xotcl-core.create_new_type]]
+      set :actions [concat $create_action ${:actions}]
     }
-    return $actions
+    return ${:actions}
   }
 
   List instproc get_elements {} {
-    my instvar no_edit_p no_delete_p edit_template delete_template
     set elements {}
     # build the edit button
-    if {!$no_edit_p} {
-      set type [my set pretty_name]
+    if {!${:no_edit_p}} {
+      set type ${:pretty_name}
       set title [_ xotcl-core.edit_type]
       lappend elements \
           edit [list \
                     link_url_col edit_url \
-                    display_template $edit_template \
+                    display_template ${:edit_template} \
                     link_html [list title $title] \
                     sub_class narrow]
     }
     # edit button will be the first list element,
     # in between there will be user's elements,
     # delete button will be last
-    set elements [concat $elements [my set elements]]
+    set elements [concat $elements ${:elements}]
     # build delete button
-    if {!$no_delete_p} {
+    if {!${:no_delete_p}} {
       set title [_ xotcl-core.delete_item]
       lappend elements \
           delete [list \
                       link_url_col delete_url \
                       link_html [list title $title class acs-confirm] \
-                      display_template $delete_template \
+                      display_template ${:delete_template} \
                       sub_class narrow]
     }
     return $elements
   }
 
   List instproc page_query {} {
-    my instvar class id_column list_name orderby
-    if {$orderby ne ""} {
-      return [$class instance_select_query \
-                  -select_attributes [list $id_column] \
-                  -where_clause "\[template::list::filter_where_clauses -name $list_name -and\]" \
-                  -orderby "\[lrange \[template::list::orderby_clause -name $list_name -orderby\] 2 end\]"]
+    if {${:orderby} ne ""} {
+      set orderby {:orderby}
+      return [${:class} instance_select_query \
+                  -select_attributes [list ${:id_column}] \
+                  -where_clause "\[template::list::filter_where_clauses -name ${:list_name} -and\]" \
+                  -orderby "\[lrange \[template::list::orderby_clause -name ${:list_name} -orderby\] 2 end\]"]
     } else {
-      return [$class instance_select_query \
-                  -select_attributes [list $id_column] \
-                  -where_clause "\[template::list::filter_where_clauses -name $list_name -and\]"]
+      return [${:class} instance_select_query \
+                  -select_attributes [list ${:id_column}] \
+                  -where_clause "\[template::list::filter_where_clauses -name ${:list_name} -and\]"]
     }
   }
 
   List instproc get_filters {} {
-    my instvar filters rows_per_page
-    if {$rows_per_page ne "" &&
-        "rows_per_page" ni $filters} {
+    if {${:rows_per_page} ne "" &&
+        "rows_per_page" ni ${:filters}} {
       set opts {}
-      set opt [expr {int($rows_per_page / 2)}]
+      set opt [expr {int(${:rows_per_page} / 2)}]
       for {set i 0} {$i < 3} {incr i} {
         lappend opts [list $opt $opt]
         set opt [expr {$opt*($i+2)}]
       }
-            append filters "
+            append :filters "
         rows_per_page {
           label \"[_ acs-templating.Page_Size]\"
           values {$opts}
-          default_value $rows_per_page
+          default_value ${:rows_per_page}
         }"
     }
-    set ulevel [expr {[my set ulevel] + 1}]
-    my set filters [uplevel $ulevel [list subst $filters]]
-    return $filters
+    set ulevel [expr {${:ulevel} + 1}]
+    set :filters [uplevel $ulevel [list subst ${:filters}]]
+    return ${:filters}
   }
 
   List instproc extend_cols {} {
     set cols {}
     set specs {}
-    foreach {el spec} [my get_elements] {
+    foreach {el spec} [:get_elements] {
       lappend cols $el
       foreach {prop val} $spec {
         if {$prop in
@@ -530,27 +516,26 @@
   }
 
   List instproc get_ids {} {
-    my instvar list_name rows_per_page
-    if {$rows_per_page ne ""} {
-      return [template::list::page_get_ids -name $list_name -tcl_list]
+    if {${:rows_per_page} ne ""} {
+      return [template::list::page_get_ids -name ${:list_name} -tcl_list]
     }
     # If we are not paginating, just get all ids in table
-    return [::xo::dc list query [subst [my page_query]]]
+    return [::xo::dc list query [subst [:page_query]]]
   }
 
   List instproc multirow {} {
-    my instvar list_name id_column no_edit_p {edit_url base_edit_url} no_delete_p {delete_url base_delete_url} row_code
-    set ulevel [expr {[my set ulevel] + 1}]
+    :instvar list_name id_column no_edit_p {edit_url base_edit_url} no_delete_p {delete_url base_delete_url} row_code
+    set ulevel [expr {${:ulevel} + 1}]
     if {$base_edit_url   eq ""} {set base_edit_url "add-edit"}
     if {$base_delete_url eq ""} {set base_delete_url "delete"}
     set this_url [::xo::cc url]
-    set extend_cols [my extend_cols]
+    set extend_cols [:extend_cols]
     # Create the multirow
     {*}"template::multirow create $list_name $extend_cols"
     set multirow_append "template::multirow append $list_name"
     foreach col $extend_cols {lappend multirow_append "\$$col"}
     # Loop through objects in this page...
-    foreach item_id [my get_ids] {
+    foreach item_id [:get_ids] {
       # ...get the object
       set o [::xo::db::Class get_instance_from_db -id $item_id]
       set obj_vars [$o info vars]
@@ -580,37 +565,36 @@
   }
 
   List instproc generate {} {
-    my instvar list_name id_column rows_per_page bulk_actions formats ulevel
     set cmd [list \
                  template::list::create \
-                 -ulevel [expr {$ulevel+1}] \
-                 -name $list_name \
-                 -multirow $list_name \
-                 -actions [my get_actions] \
-                 -elements [my get_elements] \
-                 -filters [my get_filters] \
-                 -orderby [my set orderby]]
-    if {$bulk_actions ne ""} {
+                 -ulevel [expr {${:ulevel}+1}] \
+                 -name ${:list_name} \
+                 -multirow ${:list_name} \
+                 -actions [:get_actions] \
+                 -elements [:get_elements] \
+                 -filters [:get_filters] \
+                 -orderby ${:orderby}]
+    if {${:bulk_actions} ne ""} {
       lappend cmd \
-          -bulk_actions $bulk_actions \
-          -bulk_action_method [my set bulk_action_method] \
-          -bulk_action_export_vars [my set bulk_action_export_vars] \
-          -key $id_column
+          -bulk_actions ${:bulk_actions} \
+          -bulk_action_method ${:bulk_action_method} \
+          -bulk_action_export_vars ${:bulk_action_export_vars} \
+          -key ${:id_column}
     }
-    if {$formats ne ""} {
+    if {${:formats} ne ""} {
       lappend cmd \
-          -formats $formats \
-          -selected_format [my set selected_format]
+          -formats ${:formats} \
+          -selected_format ${:selected_format}
     }
-    if {$rows_per_page ne ""} {
+    if {${:rows_per_page} ne ""} {
       lappend cmd \
           -page_flush_p t \
-          -page_size $rows_per_page \
-          -page_groupsize [my set page_groupsize] \
-          -page_query [my page_query]
+          -page_size ${:rows_per_page} \
+          -page_groupsize ${:page_groupsize} \
+          -page_query [:page_query]
     }
     lappend cmd \
-        -row_pretty_plural [my set pretty_plural]
+        -row_pretty_plural ${:pretty_plural}
     # This properties will be passed as they are
     foreach prop {
       pass_properties
@@ -621,7 +605,7 @@
       bulk_action_click_function
       html
     } {
-      set val [my set $prop]
+      set val [set :$prop]
       if {$val ne ""} {
         lappend cmd -${prop} $val
       }
@@ -631,21 +615,21 @@
       html_sub_class
       html_class
     } {
-      set val [my set $prop]
+      set val [set :$prop]
       set prop [string range $prop 5 end]
       if {$val ne ""} {
         lappend cmd -${prop} $val
       }
     }
     {*}$cmd
-    my multirow
+    :multirow
 
     # Don't put handlers directly on the HTML, but rather define them in javascript afterwards
     template::add_confirm_handler -CSSclass acs-confirm -message [_ acs-subsite.Delete]?
   }
 
   List instproc to_csv {} {
-    template::list::write_csv -name [my set list_name]
+    template::list::write_csv -name ${:list_name}
   }
 } 
 namespace import -force ::Generic::*