proc CreateMyLabinLine12 { txt0 X_USED X_VALUE LAB_1 LAB_2 } {

  CreateLine line \
    label $txt0 widget $X_USED \
    label {} widget $LAB_1 \
    label {} widget $LAB_2 \
    toggle_display $X_USED open $X_VALUE

  $line.l1 config -pady 0 -height 1 -width 8
  $line.l3 config -pady 0 -height 1 -width 1
  $line.l5 config -pady 0 -height 1 -width 1

  $line.mb2 config -pady 0 -height 1 -width 18
  $line.mb4 config -pady 0 -height 1 -width 24
  $line.mb6 config -pady 0 -height 1 -width 24
  if { [string equal $LAB_1 LAB_NONE] } { $line.mb4 config -state disabled }
  if { [string equal $LAB_2 LAB_NONE] } { $line.mb6 config -state disabled }

  pack forget $line.mb6 $line.l5 $line.mb4
  pack $line.mb6 $line.l5 $line.mb4 -side right
}

proc CreateMyLabinLine34 { X_USED X_VALUE LAB_1 LAB_2 } {

  CreateLine line \
             widget $LAB_1 \
    label {} widget $LAB_2 \
    toggle_display $X_USED open $X_VALUE

  $line.l2 config -pady 0 -height 1 -width 1

  $line.mb1 config -pady 0 -height 1 -width 24
  $line.mb3 config -pady 0 -height 1 -width 24
  if { [string equal $LAB_1 LAB_NONE] } { $line.mb2 config -state disabled }
  if { [string equal $LAB_2 LAB_NONE] } { $line.mb4 config -state disabled }

  pack forget $line.mb3 $line.l2 $line.mb1
  pack $line.mb3 $line.l2 $line.mb1 -side right
}

proc widgets_LABIN { arrayname } {

    OpenSubFrame frame -toggle_display MR_MODE hide PHASED
      new _mtz_label_w $arrayname { LAB_FQ_0 {} LAB_FQ_1 {} }
      new _mtz_label_w $arrayname { LAB_JQ_0 {} LAB_JQ_1 {} }
      new _mtz_label_w $arrayname { LAB_GLGL_0 {} LAB_GLGL_1 {} LAB_GLGL_2 {} LAB_GLGL_3 {} }
      new_menu $arrayname PATT_OBS GRP_FQ {
        GRP_FQ   {   F     SIGF }
        GRP_JQ   {   I      SIGI }
        GRP_GLGL {  F(+)   F(-) }
      }
      set text "Observed"
      set text {}
      CreateMyLabinLine12 $text PATT_OBS GRP_JQ    LAB_JQ_0   LAB_JQ_1
      CreateMyLabinLine12 $text PATT_OBS GRP_FQ    LAB_FQ_0   LAB_FQ_1
      CreateMyLabinLine12 $text PATT_OBS GRP_GLGL  LAB_GLGL_0 LAB_GLGL_1
      CreateMyLabinLine34       PATT_OBS GRP_GLGL  LAB_GLGL_2 LAB_GLGL_3
    CloseSubFrame

    OpenSubFrame frame -toggle_display MR_MODE open PHASED
      new _mtz_label_w $arrayname { LAB_FP_0 {} LAB_FP_1 {} }
      new _mtz_label_w $arrayname { LAB_PW_0 {} LAB_PW_1 {} }
      new_menu $arrayname DENS_PHI GRP_FP {
        GRP_FP   {   F      PHI  }
        GRP_PW   { PHI    FOM }
      }
      set text "Map coefs"
      set text {}
      CreateMyLabinLine12 $text DENS_PHI GRP_FP    LAB_FP_0   LAB_FP_1
      CreateMyLabinLine12 $text DENS_PHI GRP_PW    LAB_PW_0   LAB_PW_1

      OpenSubFrame frame -toggle_display DENS_PHI open GRP_FP
        new _mtz_label_w $arrayname { LAB_FQ_0 {} LAB_FQ_1 {} }
        new _mtz_label_w $arrayname { LAB_NONE {} }
        new_menu $arrayname DENS_FP_OBS GRP_NONE {
          GRP_FQ   {   F     SIGF }
          GRP_NONE { Obs not used }
        }
        set text "Rescoring"
        set text {}
        CreateMyLabinLine12 $text DENS_FP_OBS GRP_NONE  LAB_NONE   LAB_NONE
        CreateMyLabinLine12 $text DENS_FP_OBS GRP_FQ    LAB_FQ_0   LAB_FQ_1
      CloseSubFrame

      OpenSubFrame frame -toggle_display DENS_PHI open GRP_PW
        new _mtz_label_w $arrayname { LAB_FQ_0 {} LAB_FQ_1 {} }
        new _mtz_label_w $arrayname { LAB_JQ_0 {} LAB_JQ_1 {} }
        new_menu $arrayname DENS_PW_OBS GRP_FQ {
          GRP_FQ   {   F     SIGF }
          GRP_JQ   {   I      SIGI }
        }
        set text "Observed"
        set text {}
        CreateMyLabinLine12 $text DENS_PW_OBS GRP_FQ    LAB_FQ_0   LAB_FQ_1
        CreateMyLabinLine12 $text DENS_PW_OBS GRP_JQ    LAB_JQ_0   LAB_JQ_1
      CloseSubFrame
    CloseSubFrame

    ParseMTZLabels $arrayname
}

proc ParseMTZLabels { arrayname { reset_flag {} } } {

  set filename [GetFullFileName0 $arrayname HKLIN]
  set do_reset [expr [string equal $reset_flag -reset] || ![llength $filename]]

  set type_seq_list { JQ FQ FP PW GLGL }
  foreach type_seq $type_seq_list {
     foreach type [split $type_seq {}] {
        set label_map($type) {}
     }
  }

  set label_list [GetMtzAllCols $filename]
  set type_str {}
  foreach label $label_list {
    set type [GetMtzColType $filename $label]
    set type_str $type_str$type
    if { [llength [array names label_map $type]] } {
      lappend label_map($type) $label
    }
  }

  set m [string length $type_str]
  foreach type_seq $type_seq_list {
    set group_map($type_seq) {}
    set n [string length $type_seq]
    for { set i 0 } { 0 <= [set i [string first $type_seq $type_str $i]] && $i < $m } {} {
       set j [expr $i + $n - 1]
       set type_str [string replace $type_str $i $j [string repeat X $n]]
       lappend group_map($type_seq) [lrange $label_list $i $j]
    }
  }

  set group_list {}
  foreach group { "FWT PHWT" "DELFWT PHDELWT" } {
    if { [lsearch $group_map(FP) $group] >= 0 } { lappend group_list $group }
  }
  if { [llength $group_list] } { set group_map(FP) $group_list }


  set menu_font $::configure(FONT_REGULAR)
  foreach type_seq $type_seq_list {
    set mb_list_list {}
    set textvar_list {}
    for { set ind 0 ; set len [string length $type_seq] } { $ind < $len } { incr ind } {
      set mb_list [GetWidget $arrayname [join [list LAB $type_seq $ind] _]]
      if { ![llength $mb_list] } { puts "something is wrong in molrep task interface" ; return }
      lappend mb_list_list $mb_list
      lappend textvar_list [[lindex $mb_list 0] cget -textvariable]
      foreach mb $mb_list {
        initialise_menu $mb
      }
    }
    set type_list [split $type_seq {}]
    foreach group $group_map($type_seq) {
      set cmd_list {}
      foreach label $group textvar $textvar_list {
        lappend cmd_list [list set $textvar $label]
      }
      set cmd [join $cmd_list { ; }]
      foreach label $group mb_list $mb_list_list {
        foreach mb $mb_list {
          $mb.m add command -label $label -font $menu_font -command $cmd
        }
      }
    }
    set group_count [llength $group_map($type_seq)]
    foreach mb_list $mb_list_list type $type_list textvar $textvar_list {
      foreach mb $mb_list {
        if { $group_count } { $mb.m add separator }
        $mb.m add cascade -label {Customise (experts)} -font $menu_font -menu $mb.m.m
        initialise_menu $mb.m
        set label_count 0
        foreach label [linsert $label_map($type) 0 Unassigned] {
          if { [incr label_count] == 2 } { $mb.m.m add separator }
          set cmd [list set $textvar $label]
          $mb.m.m add command -label $label -font $menu_font -command $cmd
        }
      }
      if { $do_reset } {
        if { [llength $group_map($type_seq)] } {
          $mb.m invoke 0
        } else {
          foreach mb $mb_list { $mb.m.m invoke 0 }
        }
      }
    }
  }
}

proc molrep_setup { typedefVar arrayname } {
  upvar #0 $arrayname array
  upvar #0 $typedefVar typedef
  set array(_typedefKey) $typedefVar
  set array(PARAM_LIST) {}
  set array(FOLDERS_OPENED) 0
  set typedef(_CIF_hkl_file) { file CIF ".cif" "CIF reflection data" "" "" }
  return 1
}

proc new_laue_space_group_2 { arrayname } {
  upvar #0 $arrayname array
  upvar #0 $array(_typedefKey) typedef

  set sg_index_file [lindex [array get array FILE_SPACE_GROUP] 1]
  if { ![llength $sg_index_file] } {
    set sg_index_file Unassigned
  }
  new _text $arrayname { FILE_SPACE_GROUP {} }
  set array(FILE_SPACE_GROUP) $sg_index_file

  set sg_index_test None
  set sg_number_test [lindex [array get array TEST_SPACE_GROUP] 1]
  if { ![llength $sg_number_test] } {
    set sg_number_test NONE
  }

  set type_key _molrep_space_group
  set type_value [list menu [list $sg_index_test] [list $sg_number_test]]
  set typedef($type_key) $type_value

  set array(TEST_SPACE_GROUP) $sg_number_test

  set array(_TEST_SPACE_GROUP) $type_key
  set i [lsearch $array(PARAM_LIST) TEST_SPACE_GROUP]
  if { $i < 0 } { lappend array(PARAM_LIST) TEST_SPACE_GROUP }
}

proc init_laue_space_group_2 { arrayname } {
  upvar #0 $arrayname array
  upvar #0 $array(_typedefKey) typedef

  lappend sg_index_list {As is}
  lappend sg_number_list INPUT
  if { ![string equal [GetValue $arrayname MR_MODE] MULT] } {
    lappend sg_index_list {Laue class}
    lappend sg_number_list ALL
  }

  set sg_index_file [lindex [array get array FILE_SPACE_GROUP] 1]
  if { [llength $sg_index_file] } {
    set laue_no [GetLaueGroupNumber $sg_index_file]
    if { $laue_no > 0 } {
      foreach sg_number [GetLaueGroup $laue_no] {
        set sg_index [GetSpaceGroupStdCode $sg_number]
        if { ![string equal $sg_index $sg_index_file] } {
          lappend sg_number_list $sg_number
          lappend sg_index_list $sg_index
        }
      }
    }
  } else {
    set array(FILE_SPACE_GROUP) Unassigned
    puts "Something wrong with space group in input MTZ"
  }

  set sg_number_test [GetValue $arrayname TEST_SPACE_GROUP]
  if { [lsearch $sg_number_list $sg_number_test] < 0 } {
    set sg_number_test [lindex $sg_number_list 0]
  }

  foreach item [GetWidget $arrayname FILE_SPACE_GROUP] {
    if { [winfo exists $item] } {
      $item config -background [$item cget -highlightbackground]
    }
  }

  set menu_font $::configure(FONT_REGULAR)
  foreach item [GetWidget $arrayname TEST_SPACE_GROUP] {
    if { [winfo exists $item] } {
      initialise_menu $item
      set text_var [$item cget -textvariable]
      foreach sg_index $sg_index_list {
        set cmd [list set $text_var $sg_index]
        $item.m add command -label $sg_index -font $menu_font -command $cmd
      }
    }
  }

  set type_key $array(_TEST_SPACE_GROUP)
  set type_value [list menu $sg_index_list $sg_number_list]
  set typedef($type_key) $type_value

  SetValue $arrayname TEST_SPACE_GROUP $sg_number_test
}

proc new_menu { arrayname param default_key body } {
  upvar #0 $arrayname array
  upvar #0 $array(_typedefKey) typedef

  foreach { key value } [regsub -all -line {#.*} $body {}] {
    lappend key_list $key
    lappend value_list $value
  }
  set type_key _molrep_[string tolower $param]
  set type_value [list menu $value_list $key_list]
  set typedef($type_key) $type_value

  set key [lindex [array get array $param] 1]
  if { [lsearch -exact $key_list $key] < 0 } {
    set array($param) $default_key
  }
  set array(_$param) $type_key
  set i [lsearch $array(PARAM_LIST) $param]
  if { $i < 0 } { lappend array(PARAM_LIST) $param }
}

proc new { what arrayname param_list { reset_key {} } } {
  upvar #0 $arrayname array
  upvar #0 $array(_typedefKey) typedef

  foreach { param default } $param_list {
    if { ![info exists array($param)] || [string equal $reset_key -reset] } {
      set array($param) $default
    }
    set array(_$param) $what
    set i [lsearch $array(PARAM_LIST) $param]
    if { $i < 0 } { lappend array(PARAM_LIST) $param }
  }
}

proc printall { arrayname } {
  upvar #0 $arrayname array
  upvar #0 $array(_typedefKey) typedef

  set f [open log_array w]
  foreach { k v } [array get array] { puts $f "$k $v" }
  close $f

  set f [open log_typedef w]
  foreach { k v } [array get typedef] { puts $f "$k $v" }
  close $f
}

proc NextFolder { arrayname title args } {
  upvar #0 $arrayname array
  if { ![info exists array(FOLDERS_OPENED)] } {
    set folder_count [set array(FOLDERS_OPENED) 1]
  } else {
    set folder_count [incr array(FOLDERS_OPENED)]
  }
  set contents $array(WINDOW).main.canvas.contents
  set label $contents.param_$folder_count.top.lab
  if { [llength $title] } {
    if { [winfo exists $label] } {
      $label config -text $title
      eval OpenFolder $folder_count $args
    } else {
      puts "Insufficient number of folders"
    }
  } else {
    while { [winfo exists $label] } {
      OpenFolder $folder_count hide
      set label $contents.param_[incr folder_count].top.lab
    }
  }
}

proc file_label_mapping { arrayname label_list label line } {
  bind $line <Destroy> "label_list_remove $arrayname $label_list $label"
  bind $line <Map> "label_list_add $arrayname $label_list $label"
  bind $line <Unmap> "label_list_remove $arrayname $label_list $label"
}

proc label_list_add { arrayname label_list label } {
  upvar $arrayname array
  lappend array($label_list) $label
}

proc label_list_remove { arrayname label_list label } {
  upvar $arrayname array
  set i [lsearch $array($label_list) $label]
  set array($label_list) [lreplace $array($label_list) $i $i]
}

proc is_shown { arrayname varname } {
  upvar #0 $arrayname array
  foreach wc $array(WIDGET_$varname) {
    set ok 1
    while { $ok && ![string equal [winfo name $wc] contents] } {
      set wp [winfo parent $wc]
      if { [string equal [winfo name $wc] body] } { set wc $wp.top }
      set ok [expr [lsearch [pack slaves $wp] $wc] >= 0]
      set wc $wp
    }
    if { $ok } { return 1 }
  }
  return 0
}

proc empty_if_not_shown { arrayname varname } {
  upvar #0 $arrayname array
  foreach wc $array(WIDGET_$varname) {
    set ok 1
    while { $ok && ![string equal [winfo name $wc] contents] } {
      set wp [winfo parent $wc]
      if { [string equal [winfo name $wc] body] } { set wc $wp.top }
      set ok [expr [lsearch [pack slaves $wp] $wc] >= 0]
      set wc $wp
    }
    if { $ok } return
  }
  set array($varname) {}
}

proc pressme { arrayname } {
  upvar #0 $arrayname array
  set w $array(WINDOW)
  puts -----------------------
  puts [winfo children $w]
  puts [winfo children $w.main]
  puts [winfo children $w.main.canvas]
  puts [winfo children $w.main.canvas.contents]
  puts -----------------------
  foreach x [$w.main config] { puts $x }
  puts -----------------------
  foreach x [$w.main.canvas config] { puts $x }
  puts -----------------------
  foreach x [$w.main.canvas.contents config] { puts $x }
  puts -----------------------
}

proc molrep_task_window { arrayname } {

  append proc_run_body {
    upvar #0 $arrayname array
  }

  set folder_list [split [string repeat { } 10]]
  if { ![CreateTaskWindow $arrayname "Molrep" "Molrep" $folder_list ] } {
    puts "Cannot create folders"
    return 0
  }


OpenFolder protocol


  new _title_text $arrayname { TITLE {} }
  CreateTitleLine line TITLE





  new_menu $arrayname MR_MODE CROSS {
    CROSS   "Molecular Replacement"
    PHASED  "MR Using Phases"
    MULT    "Multicopy Search"
    SELF    "Self Rotation Function"
    FIT     "Fitting Two Atomic Models"
  }

  new_menu $arrayname MULT_MODE DIMER {
    DIMER   "dimers (quick)"
    HOMO    "homo multimers"
    HETERO  "hetero multimers"
  }

  OpenSubFrame frame -toggle_display MR_MODE open { CROSS PHASED SELF FIT }
    CreateLine line \
      message "Choose basic operation of Molrep" \
      label "Do" \
      widget MR_MODE \
      -command "init_laue_space_group_2 $arrayname; molrep_oblig_mx $arrayname"
    $line.l1 config -width 3
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open MULT
    CreateLine line \
      message "Choose basic operation of Molrep" \
      label "Do" \
      widget MR_MODE \
      -command "init_laue_space_group_2 $arrayname; molrep_oblig_mx $arrayname" \
      label "for" \
      widget MULT_MODE
    $line.l1 config -width 3
    $line.l3 config -width 3 -anchor center
    $line.l3 config -padx 2
  CloseSubFrame


  new _logical $arrayname {
    DATA_ARE_MAP 0
    MODEL_IS_MAP 0
  }

  OpenSubFrame frame -toggle_display MR_MODE open PHASED
    CreateLine line \
      label "Use MAP files for" \
      widget DATA_ARE_MAP label "observed data" \
      widget MODEL_IS_MAP label "search model"
    $line.l1 config -width 16
    $line.cb2 config -width 13
    $line.cb3 config -width 13
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open CROSS
    CreateLine line \
      label "Use MAP files for" \
      widget MODEL_IS_MAP label "search model"
    $line.l1 config -width 16
    $line.cb2 config -width 13
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open SELF
    CreateLine line \
      label "Use MAP files for" \
      widget DATA_ARE_MAP label "observed data"
    $line.l1 config -width 16
    $line.cb2 config -width 13
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open {MULT FIT}
    CreateLine line label ""
    $line.l1 config -pady 2
  CloseSubFrame


OpenFolder file


  append proc_run_body {
    foreach label $array(MAPPED_INPUT_FILES) {
      set win [lindex [GetWidget $arrayname $label] 0]
      set cmd [bind $win <Key-Return>]
      set ind [lsearch $cmd -notoblig]
      if { [llength $array($label)] || $ind < 0 } { lappend label_list $label }
    }
    set array(INPUT_FILES) $label_list
  }

  new _list_of_text $arrayname {
    INPUT_FILES {}
  } -reset

  new _MTZ_file $arrayname {
    HKLIN {}
  }
  new _pdb_file $arrayname {
    XYZIN_M {}
    XYZIN_M2 {}
    XYZIN_MX {}
  }
  new _seq_file $arrayname {
    SEQIN {}
    SEQIN_2 {}
  }
  new _map_file $arrayname {
    MAPIN {}
    MAPIN_M {}
  }
  new _default_dirs $arrayname {
    DIR_HKLIN {}
    DIR_MAPIN {}
    DIR_XYZIN_M {}
    DIR_SEQIN {}
    DIR_MAPIN_M {}
    DIR_XYZIN_M2 {}
    DIR_SEQIN_2 {}
    DIR_XYZIN_MX {}
  }

  set labwidth 8

  set open_data_hkl {
    set text "Data"
    CreateInputFileLine line "Enter input MTZ file name (HKLIN)" \
      $text HKLIN DIR_HKLIN \
      -setfileparam space_group_name FILE_SPACE_GROUP \
      -command "init_laue_space_group_2 $arrayname" \
      -command "SetValue $arrayname PATT_OBS GRP_FQ" \
      -command "SetValue $arrayname DENS_PHI GRP_FP" \
      -command "SetValue $arrayname DENS_FP_OBS GRP_NONE" \
      -command "SetValue $arrayname DENS_PW_OBS GRP_FQ" \
      -command "ParseMTZLabels $arrayname -reset" \
      -command "molrep_oblig_mx $arrayname"
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES HKLIN $line
    widgets_LABIN $arrayname
  }

  set open_data_map {
    set text "Data"
    CreateInputFileLine line \
      "Enter Xtal or EM map file name (MAPIN)" \
      $text MAPIN DIR_MAPIN
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES MAPIN $line
  }

  set open_model_xyz {
    set text "Model"
    CreateInputFileLine line \
      "Enter input coordinate file name (XYZIN)" \
      $text XYZIN_M DIR_XYZIN_M \
      -fileout XYZOUT DIR_XYZOUT "_molrep"
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES XYZIN_M $line
  }

  set open_sequence {
    set text "Sequence"
    CreateInputFileLine line \
      "Enter name of file containing the target sequence(SEQIN)" \
      $text SEQIN DIR_SEQIN \
      -notoblig
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES SEQIN $line
  }

  set open_model2_xyz {
    set text "Model-2"
    CreateInputFileLine line \
      "Enter input coordinate file name (XYZIN)" \
      $text XYZIN_M2 DIR_XYZIN_M2
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES XYZIN_M2 $line
  }

  set open_sequence2 {
    set text "Sequence"
    CreateInputFileLine line \
      "Enter name of file containing the target sequence(SEQIN)" \
      $text SEQIN_2 DIR_SEQIN_2 \
      -notoblig
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES SEQIN_2 $line
  }

  set open_fixed_xyz {
    set text "Fixed"
    CreateInputFileLine line \
      "Enter fixed model file name (MODEL_2)" \
      $text XYZIN_MX DIR_XYZIN_MX \
      -notoblig
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES XYZIN_MX $line
  }

  set open_model_map {
    set text "Model"
    CreateInputFileLine line \
      "Enter input map file name (XYZIN)" \
      $text MAPIN_M DIR_MAPIN_M \
      -fileout MAPOUT DIR_MAPOUT "_molrep"
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES MAPIN_M $line
  }

  set open_data {
    OpenSubFrame frame -toggle_display DATA_ARE_MAP open 0
      eval $open_data_hkl
    CloseSubFrame
    OpenSubFrame frame -toggle_display DATA_ARE_MAP open 1
      eval $open_data_map
    CloseSubFrame
  }

  set open_model {
    OpenSubFrame frame -toggle_display MODEL_IS_MAP open 0
      eval $open_model_xyz
      eval $open_sequence
      eval $open_fixed_xyz
    CloseSubFrame
    OpenSubFrame frame -toggle_display MODEL_IS_MAP open 1
      eval $open_model_map
    CloseSubFrame
  }

  OpenSubFrame frame -toggle_display MR_MODE open SELF
    eval $open_data
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open CROSS
    eval $open_data_hkl
    eval $open_model
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open PHASED
    eval $open_data
    eval $open_model
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open MULT
    OpenSubFrame frame -toggle_display MULT_MODE hide HETERO
      eval $open_data_hkl
      eval $open_model_xyz
      eval $open_sequence
      eval $open_fixed_xyz
    CloseSubFrame
    OpenSubFrame frame -toggle_display MULT_MODE open HETERO
      eval $open_data_hkl
      eval $open_model_xyz
      eval $open_sequence
      eval $open_model2_xyz
      eval $open_sequence2
      eval $open_fixed_xyz
    CloseSubFrame
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open FIT
    eval $open_model_xyz
    eval $open_sequence
    eval $open_fixed_xyz
  CloseSubFrame



  new _logical $arrayname { AUTO_SOLOUT_SET 0 }
  new _list_of_text $arrayname { OUTPUT_FILES {} } -reset
  new _pdb_file $arrayname { XYZOUT {} }
  new _CIF_hkl_file $arrayname { MAPOUT {} }
  new _default_dirs $arrayname { DIR_XYZOUT {} DIR_MAPOUT {} }

  set open_solution_name {
    CreateLine line \
      widget AUTO_SOLOUT_SET \
      label "Automatic output filename"
    $line config -pady 2
  }

  set open_solution_xyz {
    set text "Solution"
    CreateOutputFileLine line \
      "Output coordinate file" \
       $text XYZOUT DIR_XYZOUT
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname OUTPUT_FILES XYZOUT $line
  }

  set open_solution_map {
    set text "Solution"
    CreateOutputFileLine line \
      "Output coordinate file" \
       $text MAPOUT DIR_MAPOUT
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname OUTPUT_FILES MAPOUT $line
  }

  set open_solution {
    eval $open_solution_name
    OpenSubFrame frame -toggle_display AUTO_SOLOUT_SET open 0
      OpenSubFrame frame -toggle_display MODEL_IS_MAP open 0
        eval $open_solution_xyz
      CloseSubFrame
      OpenSubFrame frame -toggle_display MODEL_IS_MAP open 1
        eval $open_solution_map
      CloseSubFrame
    CloseSubFrame
  }

  set open_nosolution_msg {
    CreateLine line \
      message "Test all SGs from Laue class in this mode and then run MR in the best SG" \
      label "No output in this mode"
    $line config -pady 2
    $line.l1 config -pady 2
    $line.l1 config -fg orchid4
  }

  OpenSubFrame frame -toggle_display MR_MODE open CROSS
    OpenSubFrame frame -toggle_display TEST_SPACE_GROUP hide ALL
      eval $open_solution
    CloseSubFrame
    OpenSubFrame frame -toggle_display TEST_SPACE_GROUP open ALL
      eval $open_nosolution_msg
    CloseSubFrame
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open PHASED
    eval $open_solution
  CloseSubFrame

  OpenSubFrame frame -toggle_display MR_MODE open {MULT FIT}
    eval $open_solution_name
    OpenSubFrame frame -toggle_display AUTO_SOLOUT_SET open 0
      eval $open_solution_xyz
    CloseSubFrame
  CloseSubFrame


NextFolder $arrayname "SRF options" MR_MODE hide {CROSS PHASED MULT FIT} closed



  set label_length 30


  new _positivereal $arrayname {
    PHASED_RAD {}
    SELF_RAD {}
  }
  CreateLine line \
    message "This value will be used as integration radius for SRF" \
    label "Expected molecule size " \
    widget SELF_RAD


  new _logical $arrayname {
    SELF_CHI_SET 0
  }
  new _positivereal $arrayname {
    SELF_CHI 60.0
  }
  CreateLine line \
    widget SELF_CHI_SET \
    label "Select Chi sections" \
    toggle_display SELF_CHI_SET open 0
  CreateLine line \
    widget SELF_CHI_SET \
    label "Select Chi sections at 180, 90, 120 and" \
    widget SELF_CHI \
    label "degrees" \
    toggle_display SELF_CHI_SET open 1


  new _logical $arrayname {
    SELF_SCALE_SET 0
  }
  new _positivereal $arrayname {
    SELF_SCALE 6.0
  }
  CreateLine line \
    widget SELF_SCALE_SET \
    label "Top isoline level" \
    toggle_display SELF_SCALE_SET open 0
  CreateLine line \
    widget SELF_SCALE_SET \
    label "Top isoline level:" \
    widget SELF_SCALE \
    label "sigmas" \
    toggle_display SELF_SCALE_SET open 1




NextFolder $arrayname "Search Options" MR_MODE hide SELF closed


  set label_length 30


  new_menu $arrayname PRF N {
    N "RF + Phased TF"
    Y "SAPTF + Local Phased RF + Phased TF"
    S "SAPTF + Local RF + Phased TF"
  }
  CreateLine line \
    message "MR protocol involving Spherically Averaged Phased Translation Function" \
    label "Search protocol " \
    widget PRF \
    toggle_display MR_MODE open PHASED


  append proc_run_body {
    empty_if_not_shown $arrayname NMON_VALUE
  }
  new _positiveint $arrayname {
    NMON_VALUE {}
  }
  set open_nmon_value {
    CreateLine line \
      label "Number of copies to find" \
      widget NMON_VALUE
    $line.l1 config -width $label_length
  }
  set open_nmon_msg {
    CreateLine line \
      message "Search for one copy only if model is map or in Laue class scan" \
      label "Search for one copy only in this mode"
    $line.l1 config -pady 2
    $line.l1 config -fg orchid4
  }

  OpenSubFrame frame -toggle_display MR_MODE open CROSS
    OpenSubFrame frame -toggle_display MODEL_IS_MAP open 0
      OpenSubFrame frame -toggle_display TEST_SPACE_GROUP hide ALL
        eval $open_nmon_value
      CloseSubFrame
      OpenSubFrame frame -toggle_display TEST_SPACE_GROUP open ALL
        eval $open_nmon_msg
      CloseSubFrame
    CloseSubFrame
    OpenSubFrame frame -toggle_display MODEL_IS_MAP open 1
      eval $open_nmon_msg
    CloseSubFrame
  CloseSubFrame
  OpenSubFrame frame -toggle_display MR_MODE open PHASED
    OpenSubFrame frame -toggle_display MODEL_IS_MAP open 0
      eval $open_nmon_value
    CloseSubFrame
    OpenSubFrame frame -toggle_display MODEL_IS_MAP open 1
      eval $open_nmon_msg
    CloseSubFrame
  CloseSubFrame
  OpenSubFrame frame -toggle_display MR_MODE open MULT
    OpenSubFrame frame -toggle_display TEST_SPACE_GROUP hide ALL
      eval $open_nmon_value
    CloseSubFrame
    OpenSubFrame frame -toggle_display TEST_SPACE_GROUP open ALL
      eval $open_nmon_msg
    CloseSubFrame
  CloseSubFrame
  OpenSubFrame frame -toggle_display MR_MODE open FIT
    eval $open_nmon_value
  CloseSubFrame


  append proc_run_body {
    empty_if_not_shown $arrayname NP_VALUE
    empty_if_not_shown $arrayname NP_MODEL_2
    empty_if_not_shown $arrayname N_MULTIMER
  }
  new _positiveint $arrayname {
    NP_VALUE {}
    NP_MODEL_2 {}
    N_MULTIMER {}
  }

  OpenSubFrame frame -toggle_display MR_MODE hide MULT
    CreateLine line \
      label "Number of RF peaks to use in TF" \
      widget NP_VALUE
    $line.l1 config -width $label_length
  CloseSubFrame
  OpenSubFrame frame -toggle_display MR_MODE open MULT
    OpenSubFrame frame -toggle_display MULT_MODE hide HETERO
      CreateLine line \
        label "Number of RF peaks to use" \
        widget NP_VALUE
      $line.l1 config -width $label_length
    CloseSubFrame
    OpenSubFrame frame -toggle_display MULT_MODE open HETERO
      CreateLine line \
        label "Number of RF peaks for Model" \
        widget NP_VALUE
      $line.l1 config -width $label_length
      CreateLine line \
        label "Number of RF peaks for Model-2" \
        widget NP_MODEL_2
      $line.l1 config -width $label_length
    CloseSubFrame
    CreateLine line \
      label "Number of multimers to try" \
      widget N_MULTIMER
    $line.l1 config -width $label_length
  CloseSubFrame


  new_laue_space_group_2 $arrayname
  OpenSubFrame frame -toggle_display MR_MODE open { CROSS MULT }

    CreateLine line \
      label "Input SG:" \
      varlabel FILE_SPACE_GROUP \
      label "SG to use: " \
      widget TEST_SPACE_GROUP \

    $line.l1 config -width 8
    $line.l2 config -width 11
    $line.l3 config -width 9 -padx 2
    $line.mb4 config -width 11
  CloseSubFrame
  init_laue_space_group_2 $arrayname


  append proc_run_body {
    empty_if_not_shown $arrayname LRF_METHOD
    empty_if_not_shown $arrayname LRF_NPEAKS
  }
  new _molrep_file $arrayname {
    SRFIN {}
  }
  new _default_dirs $arrayname {
    DIR_SRFIN {}
  }
  new_menu $arrayname LRF_METHOD OFF {
    OFF  "Do Not Use"
    AUTO "Auto"
    FILE "Use SRF table"
  }
  new _positiveint $arrayname {
    LRF_NPEAKS {}
  }
  set label_length_lrf $label_length
  OpenSubFrame frame -toggle_display MR_MODE open { CROSS MULT }
    CreateLine line \
      message "Enhance RF peaks related by NCS" \
      label "Locked Rotation Function:" \
      widget LRF_METHOD \
      toggle_display LRF_METHOD open OFF
    $line.l1 config -width $label_length_lrf

    CreateLine line \
      message "Enhance RF peaks related by NCS" \
      label "Locked Rotation Function:" \
      widget LRF_METHOD \
      label "with" \
      widget LRF_NPEAKS \
      label "top SRF peaks" \
      toggle_display LRF_METHOD hide OFF
    $line.l1 config -width $label_length_lrf

    set text "SRF tab"
    CreateInputFileLine line \
      "Enter file containing self-rotation function solutions" \
      $text SRFIN DIR_SRFIN \
      -toggle_display LRF_METHOD open FILE
    $line.l1 config -width $labwidth
    file_label_mapping $arrayname MAPPED_INPUT_FILES SRFIN $line
  CloseSubFrame


  OpenSubFrame frame -toggle_display MR_MODE open PHASED
    CreateLine line \
      message "This value will be used as integration radius for Phased RF" \
      label "Radius of search model " \
      widget PHASED_RAD \
      toggle_display PRF hide N
    $line.l1 config -width $label_length

    CreateLine line \
      message "This value will be used as integration radius for RF" \
      label "Diameter of search model " \
      widget SELF_RAD \
      toggle_display PRF open N
    $line.l1 config -width $label_length
  CloseSubFrame

  CreateLine line \
    message "This value will be used as integration radius for RF" \
    label "Diameter of search model " \
    widget SELF_RAD \
    toggle_display MR_MODE hide PHASED
  $line.l1 config -width $label_length


  append proc_run_body {
    empty_if_not_shown $arrayname PST
  }
  new_menu $arrayname PST A {
    A {Auto}
    N {Do not use}
  }

  CreateLine line \
    message "Pseudo translation copy is used in TF search" \
    label "Pseudo-Translation: " \
    widget PST \
    toggle_display MR_MODE open {CROSS PHASED}
  $line.l1 config -width $label_length


NextFolder $arrayname "Experimental Data" closed


  CreateLine line \
    label "Change default behaviour for"


  new _logical $arrayname {
    DIFF_PHASED_SET 0
  }
  new_menu $arrayname DIFF_PHASED_VALUE MASK {
    MASK {use SFs from masked map}
    OFF {Off}
  }
  OpenSubFrame frame -toggle_display MR_MODE open PHASED
    CreateLine line \
      message "Use modified structure factors" \
      widget DIFF_PHASED_SET \
      label "Account for fixed model in RF or SAPTF" \
      toggle_display DIFF_PHASED_SET open 0
    $line config -pady 2
    CreateLine line \
      message "Use modified structure factors" \
      widget DIFF_PHASED_SET \
      label "Account for fixed model in RF or SAPTF" \
      widget DIFF_PHASED_VALUE \
      toggle_display DIFF_PHASED_SET open 1
  CloseSubFrame


  new _logical $arrayname {
    RESMAX_SET 0
  }
  new _positivereal $arrayname {
    RESMAX {}
  }
  CreateLine line \
    message "Ignore high resolution data above the specified threshold" \
    widget RESMAX_SET \
    label "High resolution cut-off" \
    toggle_display RESMAX_SET open 0
  CreateLine line \
    message "Ignore high resolution data above the specified threshold" \
    widget RESMAX_SET \
    label "High resolution cut-off" \
    widget RESMAX \
    toggle_display RESMAX_SET open 1


  append proc_run_body {
    if { ![is_shown $arrayname HPF_SET] } { set array(HPF_SET) 0 }
  }
  new _logical $arrayname {
    HPF_SET 0
  }
  new_menu $arrayname HPF_METHOD HPF_METHOD_SIM {
    HPF_METHOD_SIM similarity
    HPF_METHOD_BADD BADD
  }
  new _fraction $arrayname {
    SIM_VALUE {}
  }
  new _real $arrayname {
    BADD_VALUE {}
  }
  CreateLine line \
    message "W = exp( - BADD* s^ 2) where BADD can be defined via sequence similarity" \
    widget HPF_SET \
    label "Down-weighting high resolution data" \
    toggle_display HPF_SET open 0
  $line config -pady 2
  OpenSubFrame frame -toggle_display HPF_SET open 1
    CreateLine line \
      message "W = exp( - BADD* s^ 2) where BADD can be defined via sequence similarity" \
      widget HPF_SET \
      label "Down-weighting high resolution data using" \
      widget HPF_METHOD \
      label "equal to" \
      widget SIM_VALUE \
      toggle_display HPF_METHOD open HPF_METHOD_SIM
    CreateLine line \
      message "W = exp( - BADD* s^ 2) where BADD can be defined via sequence similarity" \
      widget HPF_SET \
      label "Down-weighting high resolution data using" \
      widget HPF_METHOD \
      label "equal to" \
      widget BADD_VALUE \
      toggle_display HPF_METHOD open HPF_METHOD_BADD
  CloseSubFrame


  append proc_run_body {
    if { ![is_shown $arrayname RESMIN_SET] } { set array(RESMIN_SET) 0 }
  }
  new _logical $arrayname {
    RESMIN_SET 0
  }
  new _positivereal $arrayname {
    RESMIN {}
  }
  CreateLine line \
    message "W = 1 - exp( Boff* s^2 ) where Boff = 2* RESMIN^2 and RESMIN approx equal dimension of model" \
    widget RESMIN_SET \
    label "Down-weighting low resolution data" \
    toggle_display RESMIN_SET open 0
  CreateLine line \
    message "W = 1 - exp( Boff* s^2 ) where Boff = 2* RESMIN^2 and RESMIN approx equal dimension of model" \
    widget RESMIN_SET \
    label "Down-weighting low resolution data: RESMIN" \
    widget RESMIN \
    toggle_display RESMIN_SET open 1


  append proc_run_body {
    if { ![is_shown $arrayname ANISO_SET] } { set array(ANISO_SET) 0 }
  }
  new _logical $arrayname {
    ANISO_SET 0
  }
  new_menu $arrayname ANISO Y {
    Y {aniso scaling}
    C {aniso scaling in RF only}
    S {aniso scaling in TF only}
    N {isotropic scaling}
    K {overall scale factor only}
  }
  CreateLine line \
    widget ANISO_SET \
    label "Scaling" \
    toggle_display ANISO_SET open 0
  $line config -pady 2
  CreateLine line \
    widget ANISO_SET \
    label "Scaling: use" \
    widget ANISO \
    toggle_display ANISO_SET open 1


NextFolder $arrayname "Model" MR_MODE hide SELF closed


  CreateLine line \
    label "Change default behaviour for"


  append proc_run_body {
    if { ![is_shown $arrayname SURF_SET] } { set array(SURF_SET) 0 }
  }
  new _logical $arrayname {
    SURF_SET 0
  }
  new_menu $arrayname SURF_METHOD SURF_Y {
    SURF_Y {Increase Bs on surface}
    SURF_2 {Set all Bs equal}
    SURF_OC {Use Bs from file}
    SURF_A {Polyalanine model}
  }
  new _logical $arrayname {
    SURF_OC_O 1
  }
  CreateLine line \
    message "Modify B-factor in search model or use polyalanine model" \
    widget SURF_SET \
    label "Model modification" \
    toggle_display SURF_SET open 0
  $line config -pady 2
  OpenSubFrame frame -toggle_display SURF_SET open 1
    CreateLine line \
      message "Modify B-factor in search model or use polyalanine model" \
      widget SURF_SET \
      label "Model modification:" \
      widget SURF_METHOD \
      toggle_display SURF_METHOD hide SURF_OC
    CreateLine line \
      message "Modify B-factor in search model or use polyalanine model" \
      widget SURF_SET \
      label "Model modification:" \
      widget SURF_METHOD \
      label "and" \
      widget SURF_OC_O \
      label "increase Bs on surface for Packing Function" \
      toggle_display SURF_METHOD open SURF_OC
  CloseSubFrame


  append proc_run_body {
    if { ![is_shown $arrayname NMR_SET] } { set array(NMR_SET) 0 }
  }
  new _logical $arrayname {
    NMR_SET 0
    NMR_Y 1
  }
  CreateLine line \
    message "Handling input PDB containing ensemble or NMR models" \
    widget NMR_SET \
    label "Ensemble model" \
    toggle_display NMR_SET open 0
  CreateLine line \
    message "Handling input PDB containing ensemble or NMR models" \
    widget NMR_SET \
    label "Ensemble model:" \
    widget NMR_Y \
    label "average intensities for RF" \
    toggle_display NMR_SET open 1


NextFolder $arrayname "Infrequently used options" MR_MODE hide SELF closed


  CreateLine line \
    label "Change default behaviour for"


  append proc_run_body {
    if { ![is_shown $arrayname PACK_SET] } { set array(PACK_SET) 0 }
  }
  new _logical $arrayname {
    PACK_SET 0
    PACK_Y 1
  }
  CreateLine line \
    message "Define whether to use Packing Function in TF search" \
    widget PACK_SET \
    label "Packing function" \
    toggle_display PACK_SET open 0
  CreateLine line \
    message "Define whether to use Packing Function in TF search" \
    widget PACK_SET \
    label "Packing function:" \
    widget PACK_Y \
    label "do use PF" \
    toggle_display PACK_SET open 1


  append proc_run_body {
    if { ![is_shown $arrayname SCORE_SET] } { set array(SCORE_SET) 0 }
  }
  new _logical $arrayname {
    SCORE_SET 0
    SCORE_Y 1
  }
  set msg "Define whether to use Packing Function in TF search"
  CreateLine line \
    message $msg \
    widget SCORE_SET \
    label "Score usage" \
    toggle_display SCORE_SET open 0
  CreateLine line \
    message $msg \
    widget SCORE_SET \
    label "Score usage:" \
    widget SCORE_Y \
    label "stop adding monomers if score does not improve" \
    toggle_display SCORE_SET open 1


NextFolder $arrayname {}


  append proc_run_body {
    return 1
  }

  proc molrep_run { arrayname } $proc_run_body


  foreach elem { LAB_FP_0 LAB_FP_1 } {
    foreach mb [GetWidget $arrayname $elem] {
      bind $mb <Map> "molrep_oblig_mx $arrayname"
      bind $mb <Unmap> "molrep_oblig_mx $arrayname"
      bind $mb.m <Unmap> "after idle [list molrep_oblig_mx $arrayname]"
    }
  }
}


proc molrep_oblig_mx { arrayname } {
  upvar #0 $arrayname array
  set oblig 0
  if { [string equal [GetValue $arrayname MR_MODE] FIT] } {
    set oblig 1
  } elseif { [string equal [GetValue $arrayname MR_MODE] PHASED] } {
    if { !$array(DATA_ARE_MAP) } {
      if { [string equal [GetValue $arrayname DENS_PHI] GRP_FP] } {
        set value "$array(LAB_FP_0) $array(LAB_FP_1)"
        if { [string equal $value "FWT PHWT"] || [string equal $value "DELFWT PHDELWT"] } {
          set oblig 1
        }
      }
    }
  }
  foreach win [GetWidget $arrayname XYZIN_MX] {
    if { [winfo exists $win] } {
      set cmd [bind $win <Key-Return>]
      set ind [lsearch $cmd -notoblig]
      if { $ind < 0 } {
        if { $oblig } {
          set cmd {}
        } else {
          lappend cmd -notoblig
        }
      } else {
        if { $oblig } {
          set cmd [lreplace $cmd $ind $ind]
        } else {
          set cmd {}
        }
      }
      if { [llength $cmd] } {
        foreach action { <Key-Tab> <ButtonRelease-2> <Key-Return> <FocusOut> } {
          bind $win $action $cmd
        }
        eval $cmd
      }
    }
  }
}