proc ::alited::Balloon {msg {red no} {timo 100} args} {
  # Displays a message in a balloon window.
  #   msg - message
  #   red - yes for red background
  #   timo - millisec. before showing the message
  #   args - options of baltip::tip

  variable al
  variable obPav
  set cs [$obPav csGet]
  set fg [lindex $cs 14]  ;# colors of tips
  set bg [lindex $cs 15]
  if {$red} {set fg #6e0000}
  lassign [split [winfo geometry $al(WIN)] x+] w h x y
  set geo "+([expr {$w+$x}]-W)+$y-60"
  set msg [string map [list \n "  \n  "] $msg]
  ::baltip clear $al(WIN)
  after $timo [list ::baltip tip $al(WIN) $msg -fg $fg -bg $bg -alpha 0.9  -font {-weight bold -size 11} -pause 1000 -fade 1000  -geometry $geo -bell $red -on yes -relief groove {*}$args]
}

proc ::alited::Balloon1 {fname} {
  # Shows a balloon about non-existing file.
  #   fname - file's name

  variable al
  Balloon [string map [list %f $fname] $al(MC,filenoexist)]
}

proc ::alited::CheckRun {} {
  # Runs "Check Tcl".

  CheckSource
  check::_run
}

proc ::alited::CheckSource {} {
  # Sources check.tcl (at need).

  ScriptSource check
}

proc ::alited::CloseDlg {} {
  # Tries to close a Help dialogue, open non-modal aside by the current dialogue.

  variable obDlg
  catch {[$obDlg ButOK] invoke}
}

proc ::alited::destroyWindow {win foc args} {
  # Destroys current window and focuses on previously focused widget.
  #   win - current window passed as %w
  #   foc - previously focused widget

  catch {destroy $win}
  catch {
    after idle "after 100 {::apave::FocusByForce $foc}"
  }
}

proc ::alited::EnsureArray {arName args} {
  # Ensures restoring an array at calling a proc.
  #   arName - fully qualified array name
  #   args - proc name & arguments

  set foc [focus]
  ::apave::EnsureArray $arName {*}$args
  after 100 "::apave::FocusByForce $foc"
}

proc ::alited::Exit {{w {}} {res 0} {ask yes}} {
  # Closes alited application.
  #   w - not used
  #   res - result of running of main window
  #   ask - if "yes", requests the confirmation of the exit

  variable al
  variable obPav
  set al(INI,isfindrepl) [expr {[winfo exist $al(WIN).winFind]}]
  if {$al(INI,confirmexit)>1} {
    set timo "-timeout {$al(INI,confirmexit) ButOK}"
  } else {
    set timo {}
  }
  if {!$ask || !$al(INI,confirmexit) ||  [msg okcancel info [msgcat::mc {Quitting alited.}] OK {*}$timo]} {
    if {[file::AllSaved]} {
      alited::menu::SaveCascadeMenuGeo
      catch {find::CloseFind}  ;# save Find/Replace geometry
      if {$res eq {2}} {
        # save alited's settings: in main::_run not saved yet
        catch {ini::SaveIni}
      }
      tool::_close                     ;# close all of the
      catch {run::Cancel}              ;# possibly open
      catch {check::Cancel}            ;# non-modal
      catch {destroy $::alited::find::win2}    ;# windows
      catch {destroy $::alited::al(FN2WINDOW)} ;# and its possible children
      catch {paver::Destroy}
      $obPav res $al(WIN) $res
      ::apave::endWM
    }
  }
}

proc ::alited::ExtTrans {{fname {}}} {
  # Gets a file's extention and translation attributes (istrans, from, to).
  #   fname - the file name

  if {$fname eq {}} {set fname [bar::FileName]}
  set ext [string trimleft [file extension $fname] .]
  lassign [split $ext -] from to
  set ismsg [expr {[string tolower $ext] eq {msg}}]
  if {$ismsg} {
    set from en  ;# e.g. ru.msg is from English to Russian
    set to [file rootname [file tail $fname]]
  }
  set istrans [regexp {^[[:alpha:]][[:alpha:]]-[[:alpha:]][[:alpha:]]$} $ext]
  set istrans [expr {$istrans || $ismsg}]
  return [list $ext $istrans $from $to]
}

proc ::alited::FgAdditional {} {
  # Gets the list of additional colors: branch, red, todo.

  lassign [::hl_tcl::addingColors {} -AddTags] - - fgbr - - fgred - - - fgtodo
  list  $fgbr $fgred $fgtodo
}

proc ::alited::FgFgBold {} {
  # Gets foregrounds of normal and colored text of current color scheme
  # and red color of TODOs.

  variable obPav
  lassign [FgAdditional] -> fgred
  if {[catch {set lst [$obPav csGet]}]} {
    set fg [ttk::style lookup "." -foreground]
    set bg [ttk::style lookup "." -background]
    set fgbold $fgred
  } else {
    lassign $lst - fg - bg fgbold
  }
  list $fg $fgbold $fgred $bg
}

proc ::alited::Font {} {
  # Gets editor's font.

  variable al
  return $al(FONT,txt)
}

proc ::alited::Help {win {suff {}} args} {
  # Shows a help file for a procedure.
  #   win - currently active window
  #   suff - suffix for a help file's name
  #   args - options of HelpFile

  HelpFile $win [HelpFname $win $suff] {*}$args
}

proc ::alited::HelpAbout {} {
  # Shows "About..." dialogue.

  if {[info commands about::About] eq {}} {
    source [file join $::alited::SRCDIR about.tcl]
  }
  about::About
}

proc ::alited::HelpAlited {{ilink {}}} {
  # Shows a main help of alited.
  #   ilink - internal link

  openDoc file://[file join $::alited::DIR doc index.html]$ilink
}

proc ::alited::HelpFile {win fname args} {
  # Reads and shows a help file.
  #   win - currently active window
  #   fname - the file's name
  #   args - option of msg

  variable obDlg
  variable al
  if {[HelpOnce 1 $fname]} return
  lassign [::apave::extractOptions args -ale1Help no -ontop 0] ale1Help ontop
  set tags [MessageTags]
  if {[file exists $fname]} {
    set msg [::apave::readTextFile $fname]
  } else {
    set msg "Here should be a text of\n\"$fname\""
  }
  if {$::alited::DEBUG} {puts "help file: $fname"}
  set wmax 1
  foreach ln [split $msg \n] {
    set oc 0
    foreach tag {r b link} {
      foreach yn {{} /} {
        set ln2 $ln
        set t <$yn$tag>
        set ln [string map [list $t {}] $ln]
        incr oc [expr {([string length $ln2]-[string length $ln])/([string length $t]+1)}]
      }
    }
    set wmax [expr {max($wmax,[string length $ln]+$oc)}]
  }
  set pobj $obDlg
  if {[info commands $pobj] eq {}} {
    # at first start, there are no apave objects bound to the main window of alited
    # -> create an independent one to be deleted afterwards
    set pobj alitedHelpObjToDel
    catch {::apave::APave create $pobj}
  }
  if {[llength [split $msg \n]]>30} {
    set args [linsert $args 0 -h 30 -scroll 1]
  }
  after 200 [list alited::HelpOnce 0 $fname]
  if {$ale1Help} {
    # if run from "Help/Context", remove its predecessor
    catch {destroy $al(DLGPREV)}
    after idle "set ::alited::al(DLGPREV) \[$pobj dlgPath\]"
  }
  set res [$pobj ok {} Help "\n$msg\n" -modal no -waitvar no  -onclose "alited::destroyWindow %w [focus]" -centerme $win -text 1 -scroll no  {*}$tags -ontop $ontop -w [incr wmax] {*}$args]
  return $res
}

proc ::alited::HelpFname {win {suff {}}} {
  # Gets a help file's name.
  #   win - currently active window
  #   suff - suffix for a help file's name

  variable DATADIR
  set fname [lindex [split [dict get [info frame -2] proc] :] end-2]
  set fname [file join [file join $DATADIR help] $fname$suff.txt]
  return $fname
}

proc ::alited::HelpMe {win {suff {}}} {
  # Shows a help file for a procedure with "Don't show again" checkbox.
  #   win - currently active window
  #   suff - suffix for a help file's name

  variable al
  if {[lsearch -exact $al(HelpedMe) $win]>-1} return
  set ans [HelpFile $win [HelpFname $win $suff] -ch $al(MC,noask)]
  if {[lindex $ans 0]==11} {
    lappend al(HelpedMe) $win
  }
}

proc ::alited::HelpOnce {mode fname} {
  # Handles "Help" window to have the only instance of it.
  #   mode - 1 to check for existance the help; 0 to register it
  #   fname - file of help

  variable al2
  variable obDlg
  set key _help_$fname
  if {$mode} {
    if {[info exists al2($key)] && [winfo exists $al2($key)]} {
      ::apave::deiconify $al2($key)
      return 1
    }
    return 0
  }
  if {[catch {set al2($key) [$obDlg dlgPath]}]} {set al2($key) 0}
}

proc ::alited::HighlightAddon {wtxt fname colors} {
  # Tries to highlight add-on extensions.
  #   wtxt - text's path
  #   fname - current file's name
  #   colors - colors of highlighting

  namespace upvar ::alited al al LIBDIR LIBDIR
  set res {}
  lassign [ExtTrans $fname] ext istrans
  if {$ext ne {}} {
    catch {
      if {$istrans} {
        # it's a file to translate from language to language
        set ext trans
        HelpMe $ext -trans
        after idle alited::main::FocusText
      }
      switch $ext {
        htm - ui - tpl1 {set ext html}
        ale - conf {set ext ini}
      }
      set addon hl_$ext
      lassign [glob -nocomplain [file join $LIBDIR addon $addon.tcl]] fhl
      set addon [file rootname [file tail $fhl]]
      if {![namespace exists ::alited::$addon]} {
        if {[catch {source $fhl} err]} {
          alited::Message $err 4
          return {}
        }
      }
      lappend colors [FgFgBold]
      if {[dict exists $al(FONT,txt) -size]} {
        set fsz [dict get $al(FONT,txt) -size]
      } else {
        set fsz $al(FONTSIZE,std)
      }
      set res [${addon}::init $wtxt $al(FONT,txt) $fsz {*}$colors]
      obj set_highlight_matches $wtxt
      foreach tag {sel hilited hilited2} {after idle $wtxt tag raise $tag}
    }
  }
  return $res
}

proc ::alited::Hl_Colors {} {
  # Gets highlighting colors.

  variable al
  foreach nam [::hl_tcl::hl_colorNames] {lappend colors $al(ED,$nam)}
  return $colors
}

proc ::alited::InitUnitTree {TID} {
  # Initializes the unit tree of file to be processed.
  #   TID - tab's ID

  set wtxt [main::GetWTXT $TID]
  if {$wtxt ne {}} {unit::RecreateUnits $TID $wtxt}
  return 1
}

proc ::alited::isTclScript {tab} {
  # Check if the tab's file is of .tcl type.
  #   tab - tab's info

  set TID [lindex $tab 0]
  set fn [alited::bar::FileName $TID]
  expr {[string tolower [file extension $fn]] eq {.tcl}}
}

proc ::alited::IsTipable {} {
  # Checks if a tip on the tree/favorites can be shown.

  variable al
  if {[set foc [focus]] eq {} || [string match *tearoff* $foc]} {
    return no  ;# no tips while focusing on a tearoff menu
  }
  if {[winfo toplevel $foc] ne $al(WIN)} {
    return no  ;# no tips while focusing on a toplevel other than alited's main
  }
  return yes
}

proc ::alited::ListPaved {} {
  # Returns a list of apave objects for dialogues.

  list obDlg obDl2 obFND obFN2 obCHK obRun
}

proc ::alited::main_user_dirs {} {
  # Gets names of main user directories for settings.

  set ::alited::USERDIR [file join $::alited::CONFIGDIR alited]
  set ::alited::INIDIR [file join $::alited::USERDIR ini]
  set ::alited::PRJDIR [file join $::alited::USERDIR prj]
}

proc ::alited::Map {opts str args} {
  # Maps wildcards and %% in a string.
  #   opts - options of "string map" command
  #   str - string
  #   args - list of wildcards and values: {%w1 $val1 %w2 $val2 ...}

    set abra {*^e!`i@U50=|}
    set str [string map [list %% $abra] $str]
    foreach {wc val} $args {
      set str [string map {*}$opts [list $wc $val] $str]
    }
    set str [string map [list $abra %] $str]
}

proc ::alited::MapWildCards {com} {
  # Maps some common wildcards in a command
  #   com - the command
  # Wildcards:
  #   %H - home directory
  #   %P - directory of current project
  #   %F - current file name
  #   %D - directory of current file
  #   %A - directory of alited
  #   %M - directory of e_menu's menus
  #   %E - Tcl/Tk executable as set in Preferences/Tools

  variable al
  variable DIR
  set filename [bar::FileName]
  set dirname [file dirname $filename]
  set com [Map {} $com  %H [apave::HomeDir]  %P $al(prjroot)  %F $filename  %D $dirname  %A $DIR  %M $al(EM,mnudir)  %E [Tclexe]]
}

proc ::alited::Message {msg {mode 1} {lab {}} {first yes}} {
  # Displays a message in statusbar.
  #   msg - message
  #   mode - 1: simple; 2: bold; 3: bold color; 4: bold red bell; 5: static; 6: bold red
  #   lab - label's name to display the message in
  #   first - serves to recursively erase the message

  variable al
  variable obPav
  if {[info commands $obPav] eq {} || [catch {lassign [FgFgBold] fg fgbold fgred bg}]} {
    return  ;# at exiting app
  }
  if {$lab eq {}} {set lab [$obPav Labstat3]}
  if {$first} {set msg [msgcat::mc $msg]}
  if {!$first && $msg ne {} && [winfo exists $lab]} {
    set curmsg [$lab cget -text]
    # if a message changed or expired, don't touch it (don't cover it with old 'msg')
    if {[string first $msg $curmsg]<0} return
  }
  set font [[$obPav Labstat2] cget -font]
  set fontB [list {*}$font -weight bold]
  set msg [string range [string map [list \n { } \r {}] $msg] 0 500]
  set slen [string length $msg]
  if {[catch {$lab configure -text $msg}] || !$slen} return
  $lab configure -font $font -foreground $fg
  if {$mode in {2 3 4 5 6}} {
    $lab configure -font $fontB
    if {$mode eq {4}} {
      $lab configure -foreground $fgred
      if {$first} bell
    } elseif {$mode in {3 5}} {
      $lab configure -foreground $fgbold
    } elseif {$mode eq {6}} {
      $lab configure -foreground $fgred
    }
  }
  if {$mode eq {5}} {
    update
    return
  }
  if {$first} {
    set msec [expr {200*$slen}]
    if {$mode in {2 3 4 5}} {
      set opts "-font {$fontB}"
    } else {
      set opts {}
    }
    set tip [string trim [string range $msg 0 130]]
    if {[string trim [string range $msg [string length $tip] end]] ne {}} {
      append tip ...
    }
    baltip::tip $lab $tip -command [list alited::TipMessage %w %t] -per10 0 {*}$opts
  } else {
    set msg [string range $msg 0 end-1]
    set msec 10
  }
  catch {after cancel $al(afterID)}
  if {$msec>0} {
    set al(afterID) [after $msec [list ::alited::Message $msg $mode $lab no]]
  }
}

proc ::alited::MessageError {msg} {
  # Doubles error message: in infobar and in status bar.
  #   msg - error message

    info::Put $msg {} yes yes yes -fg
    Message $msg 4
}

proc ::alited::MessageNotDisturb {} {
  # Shows "Don't disturb" message.

  variable al
  lassign [alited::complete::TextCursorCoordinates] X Y
  set msg "Working...\nDon't disturb."
  Message $msg 3
  ::baltip::showBalloon $msg  -geometry "+$X+$Y" -fg $al(MOVEFG) -bg $al(MOVEBG)
}

proc ::alited::MessageTags {} {
  # Gets tags for texts shown with messages.
  # Returns "-tags option" for messages.

  lassign [FgFgBold] -> fS
  set ::alited::textTags [list  [list "r" "-font {$::apave::FONTMAINBOLD} -foreground $fS"]  [list "b" "-foreground $fS"]  [list "link" "openDoc %t@@https://%l@@"]  ]
  return "-tags ::alited::textTags"
}

proc ::alited::Msg {inf {ic info} args} {
  # Shows a message in text box.
  #   inf - the message
  #   ic - icon

  msg ok $ic $inf -text 1 -w 50 {*}$args
}

proc ::alited::msg {type icon message {defb {}} args} {
  # Shows a message and asks for an answer.
  #   type - ok/yesno/okcancel/yesnocancel
  #   icon - info/warn/err
  #   message - the message
  #   defb - default button (for not "ok" dialogs)
  #   args - additional arguments (-title and font's option)
  # For "ok" dialogue, 'defb' is omitted (being a part of args).

  variable obDlg
  variable al
  if {$type eq {ok}} {
    set args [linsert $args 0 $defb]
    set defb {}
  } elseif {$defb eq {}} {
    set defb YES
  }
  lappend defb -centerme [::apave::rootModalWindow $al(WIN)]
  lassign [::apave::extractOptions args -title {} -noesc 0] title noesc
  if {$title eq {}} {
    switch $icon {
      warn {set title $al(MC,warning)}
      err  {set title $al(MC,error)}
      ques {set title $al(MC,question)}
      default {set title $al(MC,info)}
    }
  } else {
    set title [msgcat::mc $title]
  }
  set message [msgcat::mc $message]
  if {[info exists al(obDlg-BUSY)]} {
    # the obDlg is engaged: no actions, just a message
    Message $message 4
    set res 0
  } else {
    set al(obDlg-BUSY) yes
    set res [$obDlg $type $icon $title "\n$message\n" {*}$defb {*}$args]
    unset -nocomplain al(obDlg-BUSY)
  }
  return [lindex $res 0]
}

proc ::alited::msgcatMessages {} {
  # Sets common localized messages.

  # alited_checked

  variable al

  ## _ common _ ##
  set al(MC,nofile)      [msgcat::mc {No name}]
  set al(MC,info)        [msgcat::mc Information]
  set al(MC,warning)     [msgcat::mc Warning]
  set al(MC,error)       [msgcat::mc Error]
  set al(MC,question)    [msgcat::mc Question]
  set al(MC,wait)        [msgcat::mc {Wait a little ...}]
  set al(MC,help)        [msgcat::mc Help]
  set al(MC,select)      [msgcat::mc Select]  ;# verb
  set al(MC,notsaved)    [msgcat::mc "\"%f\" wasn't saved.\n\nSave it?"]
  set al(MC,saving)      [msgcat::mc Saving]
  set al(MC,files)       [msgcat::mc Files]
  set al(MC,moving)      [msgcat::mc Moving]
  set al(MC,run)         [msgcat::mc Run]
  set al(MC,runAsIs)     [msgcat::mc {Run as Is}]
  set al(MC,new)         [msgcat::mc New]
  set al(MC,open...)     [msgcat::mc Open...]
  set al(MC,close)       [msgcat::mc Close]
  set al(MC,save)        [msgcat::mc Save]
  set al(MC,saveas...)   [msgcat::mc {Save as...}]
  set al(MC,saveall)     [msgcat::mc {Save All}]
  set al(MC,clall)       [msgcat::mc {... All}]
  set al(MC,clallleft)   [msgcat::mc {... All at Left}]
  set al(MC,clallright)  [msgcat::mc {... All at Right}]
  set al(MC,pref)        [msgcat::mc Preferences]
  set al(MC,pref...)     [msgcat::mc Preferences...]
  set al(MC,notrecomm)   [msgcat::mc "Not recommended for projects\nwith large files (>2000 LOC)!"]
  set al(MC,quit)        [msgcat::mc Quit]
  set al(MC,indent)      [msgcat::mc Indent]
  set al(MC,unindent)    [msgcat::mc Unindent]
  set al(MC,corrindent)  [msgcat::mc {Correct Indentation}]
  set al(MC,comment)     [msgcat::mc Comment]
  set al(MC,uncomment)   [msgcat::mc Uncomment]
  set al(MC,findreplace) [msgcat::mc {Find / Replace}]
  set al(MC,findnext)    [msgcat::mc {Find Next}]
  set al(MC,alloffile)   [msgcat::mc "All of \"%f\""]
  set al(MC,lines)       [msgcat::mc Lines]
  set al(MC,moveupU)     [msgcat::mc {Move Unit Up}]
  set al(MC,movedownU)   [msgcat::mc {Move Unit Down}]
  set al(MC,moveupF)     [msgcat::mc {Move File Up}]
  set al(MC,movedownF)   [msgcat::mc {Move File Down}]
  set al(MC,FavLists)    [msgcat::mc {Saved Lists of Favorites}]
  set al(MC,swfiles)     [msgcat::mc {Switch to Unit Tree}]
  set al(MC,swunits)     [msgcat::mc {Switch to File Tree}]
  set al(MC,filesadd)    [msgcat::mc {Create File}]
  set al(MC,filesadd...) [msgcat::mc {Create File...}]
  set al(MC,filesadd2)   [msgcat::mc "Enter a name of file to create in:\n%d\n\nIf it is a directory, check 'Directory' box.\nThe directory can include subdirectories (a/b/c)."]
  set al(MC,filesdel)    [msgcat::mc {Delete File}]
  set al(MC,fileexist)   [msgcat::mc "\nFile \"%f\" already exists in\n%d\n"]
  set al(MC,filenoexist) [msgcat::mc "\nFile\n  \"%f\"\ndoesn't exist.\n"]
  set al(MC,unitsdel)    [msgcat::mc {Delete Unit(s)}]
  set al(MC,favoradd)    [msgcat::mc {Add to Favorites}]
  set al(MC,favordel)    [msgcat::mc {Delete}]
  set al(MC,favorren)    [msgcat::mc {Rename}]
  set al(MC,favordelall) [msgcat::mc {Delete All}]
  set al(MC,updtree)     [msgcat::mc {Update Tree}]
  set al(MC,movefile)    [msgcat::mc "Move %f\nto\n%d\n?"]
  set al(MC,introln1)    [msgcat::mc {First Lines}]
  set al(MC,introln2)    [msgcat::mc {Can't touch the first %n lines.}]
  set al(MC,favorites)   [msgcat::mc Favorites]
  set al(MC,currfavs)    [msgcat::mc {Current list of favorites}]
  set al(MC,lastvisit)   [msgcat::mc {Last Visited}]
  set al(MC,addfavor)    [msgcat::mc "Add \"%n\" of %f\nto Favorites?"]
  set al(MC,addexist)    [msgcat::mc "Item \"%n\" of %f\nis already in Favorites."]
  set al(MC,delfavor)    [msgcat::mc "Remove \"%n\" of %f\nfrom Favorites?"]
  set al(MC,notfavor)    [msgcat::mc "\"%n\" unit of %f is not in the list."]
  set al(MC,selfavor)    [msgcat::mc "Click \"%t\""]
  set al(MC,copydecl)    [msgcat::mc {Copy Declaration}]
  set al(MC,openofdir)   [msgcat::mc "Open All Tcl Files of \"%n\""]
  set al(MC,delitem)     [msgcat::mc "Remove \"%n\"\nfrom \"%f\"?"]
  set al(MC,delfile)     [msgcat::mc "Delete \"%f\"?"]
  set al(MC,modiffile)   [msgcat::mc "File \"%f\" was modified by some application.\n\nCancel your edition and reload the file?"]
  set al(MC,wasdelfile)  [msgcat::mc "File \"%f\" was deleted by some application.\n\nSave the file?"]
  set al(MC,Row:)        [msgcat::mc {Row }]
  set al(MC,Col:)        [msgcat::mc { Col }]
  set al(MC,Item)        [msgcat::mc Item]
  set al(MC,errmove)     [msgcat::mc "\"%n\" contains unbalanced \{\}: %1!=%2"]
  set al(MC,afterstart)  [msgcat::mc {For Start}]
  set al(MC,locale)      [msgcat::mc "This is a language code: ru, uk, de...\nIn alited, \"en\" means American English."]
  set al(MC,noask)       [msgcat::mc {Don't show anymore}]
  set al(MC,needcs)      [msgcat::mc "These themes need\nlight / dark color schemes\naccordingly"]
  set al(MC,nocs)        [msgcat::mc {No color scheme at all}]
  set al(MC,fitcs)       [msgcat::mc {Fit for theme}]
  set al(MC,hue)         [msgcat::mc {Makes colors darker .. lighter}]
  set al(MC,maxbak)      [msgcat::mc {Maximum of backup copies per a file}]
  set al(MC,othertcl)    [msgcat::mc {Do it in other Tcl files}]
  set al(MC,otherfiles)  [msgcat::mc {Do it in other files}]
  set al(MC,inconsole)   [msgcat::mc {in console}]
  set al(MC,intkcon)     [msgcat::mc {in Tkcon}]
  set al(MC,on)          [msgcat::mc on]
  set al(MC,test)        [msgcat::mc Test]
  set al(MC,restart)     [msgcat::mc "For the settings to be active,\nalited application should be restarted."]
  set al(MC,incorrname)  [msgcat::mc {Incorrect name: "%n"}]
  set al(MC,allfiles)    [msgcat::mc {All files}]
  set al(MC,currfile)    [msgcat::mc {Current}]
  set al(MC,none)        [msgcat::mc {None}]

  ## _  menu items _ ##
  set al(MC,lookdecl)    [msgcat::mc {Look for Declaration}]
  set al(MC,lookword)    [msgcat::mc {Look for Word}]
  set al(MC,toline)      [msgcat::mc {Go to Line}]
  set al(MC,tomatched)   [msgcat::mc {To Matched Bracket}]
  set al(MC,hlcolors)    [msgcat::mc {Display Colors}]
  set al(MC,playtkl)     [msgcat::mc {Play Macro}]
  set al(MC,quickmacro)  {Quick macro}
  set al(MC,formatdesc)  [msgcat::mc {Moving Unit Descriptions}]
  set al(MC,formatdesc...) [msgcat::mc {Moving Unit Descriptions...}]

  ## _  project options _ ##
  set al(MC,Ign:)        [msgcat::mc {Skip subdirectories:}]
  set al(MC,EOL:)        [msgcat::mc {End of line:}]
  set al(MC,indent:)     [msgcat::mc {Indentation:}]
  set al(MC,indentAuto)  [msgcat::mc {Auto detection}]
  set al(MC,redunit)     [msgcat::mc {Unit lines per 1 red bar:}]
  set al(MC,multiline)   [msgcat::mc {Multi-line strings:}]
  set al(MC,trailwhite)  [msgcat::mc {Remove trailing whitespaces:}]
  set al(MC,useleafRE)   [msgcat::mc {Use leaf's regexp:}]
  set al(MC,leafRE)      [msgcat::mc {Leaf's regexp:}]

  ## _ templates _ ##
  set al(MC,tpl)         [msgcat::mc Templates]
  set al(MC,tplsel)      [msgcat::mc {Click a template}]
  set al(MC,tplnew)      [msgcat::mc {The template #%n added}]
  set al(MC,tplupd)      [msgcat::mc {The template #%n updated}]
  set al(MC,tplrem)      [msgcat::mc {The template #%n removed}]
  set al(MC,tplent1)     [msgcat::mc {Enter a name of the template}]
  set al(MC,tplent2)     [msgcat::mc {Enter a text of the template}]
  set al(MC,tplent3)     [msgcat::mc "Choose a hot key combination\nfor the template insertion."]
  set al(MC,tplaft1)     [msgcat::mc "Inserts a template\nbelow a current line"]
  set al(MC,tplaft2)     [msgcat::mc "Inserts a template\nbelow a current unit"]
  set al(MC,tplaft3)     [msgcat::mc "Inserts a template at the cursor\n(good for one-liners)"]
  set al(MC,tplaft4)     [msgcat::mc "Inserts a template after 1st line of a file\n(License, Introduction etc.)"]
  set al(MC,tplexists)   [msgcat::mc {A template with the attribute(s) already exists.}]
  set al(MC,tpldelq)     [msgcat::mc {Delete a template #%n ?}]

  ## _ projects _ ##
  set al(MC,projects)    [msgcat::mc Projects]
  set al(MC,prjgoing)    [msgcat::mc {You are going to %n!}]
  set al(MC,prjadd)      [msgcat::mc {Add a project}]
  set al(MC,prjchg)      [msgcat::mc {Change a project}]
  set al(MC,prjdel1)     [msgcat::mc {Delete a project}]
  set al(MC,prjcantdel)  [msgcat::mc {Don't delete the current project!}]
  set al(MC,prjnew)      [msgcat::mc "The project \"%n\" added"]
  set al(MC,prjupd)      [msgcat::mc "The project \"%n\" updated"]
  set al(MC,prjdel2)     [msgcat::mc "The project \"%n\" removed"]
  set al(MC,prjOptions)  [msgcat::mc Options]
  set al(MC,prjName)     [msgcat::mc {Project:}]
  set al(MC,prjaddfl)    [msgcat::mc Add]
  set al(MC,prjsubstfl)  [msgcat::mc Substitute]
  set al(MC,prjdelfl)    [msgcat::mc Delete]
  set al(MC,prjnochfl)   [msgcat::mc {Don't change}]
  set al(MC,prjsel)      [msgcat::mc {Click a project}]
  set al(MC,prjdelq)     [msgcat::mc "Delete a project \"%n\" ?"]
  set al(MC,prjexists)   [msgcat::mc "A project \"%n\" already exists."]
  set al(MC,DEFopts)     [msgcat::mc {Options for new projects are set in "Preferences/General/Projects"}]
  set al(MC,prjTdelete)  [msgcat::mc {Erase a text}]
  set al(MC,prjTpaste)   [msgcat::mc {Paste a text}]
  set al(MC,prjTundo)    [msgcat::mc {Undo changes}]
  set al(MC,prjTredo)    [msgcat::mc {Redo changes}]
  set al(MC,prjTtext)    [msgcat::mc {Text of a reminder}]
  set al(MC,prjTprevious)  [msgcat::mc {TODO previous day}]
  set al(MC,prjTprevious2) [msgcat::mc {TODO previous week}]
  set al(MC,prjTnext)    [msgcat::mc {TODO next day}]
  set al(MC,prjTnext2)   [msgcat::mc {TODO next week}]
  set al(MC,TemplPrj)    [msgcat::mc "Enter a tree of directories for the project template.\nIndent them by equal indents to mean subdirectories.\n\nFiles like README*, CHANGELOG* will be created blank.\nFiles like LICENSE* will be taken from the current project."]
  set al(MC,CrTemplPrj)  [msgcat::mc {Create a project by template}]
  set al(MC,ViewDir)     [msgcat::mc {Project directory}]
  set al(MC,com)         [msgcat::mc Command]
  set al(MC,coms)        [msgcat::mc Commands]

  ## _ favorites _ ##
  set al(MC,favsel)      [msgcat::mc {Click a list of favorites}]
  set al(MC,favnew)      [msgcat::mc {The list #%n added}]
  set al(MC,favupd)      [msgcat::mc {The list #%n updated}]
  set al(MC,favrem)      [msgcat::mc {The list #%n removed}]
  set al(MC,favent1)     [msgcat::mc {Enter a name of the list}]
  set al(MC,favent3)     [msgcat::mc {The current list is empty!}]
  set al(MC,favexists)   [msgcat::mc {This list already exists}]
  set al(MC,faverrsav)   [msgcat::mc "This list not saved to\n\"%f\"."]
  set al(MC,favdelq)     [msgcat::mc {Delete a favorites' list #%n ?}]
  set al(MC,unitprocsd)  [msgcat::mc {%f processed, units affected: %n - ALREADY PROCESSED?}]

  ## _ find-replace dialogue _ ##
  set al(MC,frMatch) [msgcat::mc {Match: }]
  set al(MC,frWord)  [msgcat::mc {Match whole word}]
  set al(MC,frExact) [msgcat::mc {Exact}]
  set al(MC,frCase)  [msgcat::mc {Match case}]
  set al(MC,frres1)  [msgcat::mc "Found %n matches for \"%s\"."]
  set al(MC,frres2)  [msgcat::mc "Made %n replacements of \"%s\" with \"%r\" in \"%f\"."]
  set al(MC,frres3)  [msgcat::mc "Made %n replacements of \"%s\" with \"%r\" in all of session."]
  set al(MC,frdoit1) [msgcat::mc "Replace all of \"%s\"\n\nwith \"%r\"\n\nin \"%f\" ?"]
  set al(MC,frdoit2) [msgcat::mc "Replace all of \"%s\"\n\nwith \"%r\"\n\nin all%Stexts?"]

  ## _ file & directory _ ##
  set al(MC,removed)     [msgcat::mc "\"%f\" removed to \"%d\""]
  set al(MC,nottoopen)   [msgcat::mc "The file \"%f\" seems to be not of types\n%s.\n\nStill do you want to open it?"]
  set al(MC,renamefile)  [msgcat::mc {Rename File}]
  set al(MC,renamefile...) [msgcat::mc {Rename File...}]
  set al(MC,clonefile)   [msgcat::mc {Clone File}]
  set al(MC,clonefile...) [msgcat::mc {Clone File...}]
  set al(MC,openselfile) [msgcat::mc {Open Selected Files}]
  set al(MC,filelist)    [msgcat::mc {File List}]

  ## _ start and update _ ##
  set al(MC,chini1)      [msgcat::mc {Choosing Directory for Settings}]
  set al(MC,chini2)      [msgcat::mc "\n The \"alited\" needs a configuration directory to store its settings.\n You can pass its name to alited as an argument.\n\n The default configuration directory is \"%d\".\n It's preferable as used to run \"alited\" without arguments.\n"]
  set al(MC,chini3)      [msgcat::mc {Choose a directory}]
  set al(MC,updateALE)   [msgcat::mc {Updating alited}]
  set al(MC,updLab1)     [msgcat::mc " You are highly recommended to accept\n these changes in order to complete updating:"]
  set al(MC,updmnu)      [msgcat::mc {.em files for "Tools"}]
  set al(MC,updini)      [msgcat::mc {.ini file for "Templates"}]
  set al(MC,updLab2)     [msgcat::mc { Your previous files will be saved to:}]

  ## _ misc _ ##
  set al(MC,notes)       [msgcat::mc "Sort of diary.\nList of TODOs etc."]
  set al(MC,checktcl)    [msgcat::mc {Check Tcl}]
  set al(MC,checktcl...) [msgcat::mc {Check Tcl...}]
  set al(MC,colorpicker) [msgcat::mc {Color Picker}]
  set al(MC,datepicker)  [msgcat::mc {Date Picker}]
  set al(MC,marks)       [msgcat::mc Marks]

  ## _ icons of toolbar _ ##
  set al(MC,icofile)     [msgcat::mc "Create a file\nCtrl+N"]
  set al(MC,icoOpenFile) [msgcat::mc "Open a file\nCtrl+O"]
  set al(MC,icoSaveFile) [msgcat::mc {Save the file}]
  set al(MC,icosaveall)  [msgcat::mc "Save all files\nCtrl+Shift+S"]
  set al(MC,icohelp)     [msgcat::mc "Tcl/Tk help on the selection\nF1"]
  set al(MC,icoreplace)  [msgcat::mc "Find / Replace\nCtrl+F"]
  set al(MC,icook)       $al(MC,checktcl)
  set al(MC,icocolor)    $al(MC,colorpicker)
  set al(MC,icodate)     $al(MC,datepicker)
  set al(MC,icoother)    Tkcon
  set al(MC,icorun)      [msgcat::mc {Run the file}]
  set al(MC,icoe_menu)   [msgcat::mc {Run e_menu}]
  set al(MC,icoundo)     [msgcat::mc "Undo changes\nCtrl+Z"]
  set al(MC,icoredo)     [msgcat::mc "Redo changes\nCtrl+Shift+Z"]
  set al(MC,icobox)      [msgcat::mc Projects]

  ## _ find units _ ##
  set al(MC,findunit)    [msgcat::mc "Use glob patterns to find units' declarations\ne.g. \"s*rt\" would find \"start\" and \"insert\".\nThe letter case is ignored."]
  set al(MC,notfndunit)  [msgcat::mc {Unit not found: %u}]
}

proc ::alited::open_files_and_raise {iin args} {
  # Opens files of CLI.
  #   iin - count of call
  #   args - list of file names
  # See also: bar::FillBar

  if {$iin<10} {
    # let the tab bar be filled first
    if {![info exists ::alited::al(BID)]} {
      after idle [list after 1000 [list ::alited::open_files_and_raise [incr iin] {*}$args]]
      return
    }
    foreach fname [lreverse $args] {
      set fname [string trim $fname "\"\{\}"]
      if {[file isfile $fname]} {
        file::OpenFile $fname yes
      } else {
        Balloon1 $fname
        file::NewFile $fname
      }
    }
  }
  raise_window
}

proc ::alited::PrinterRun {} {
  # Runs "Project Printer".

  ScriptSource printer
  printer::_run
}

proc ::alited::ProcEOL {val mode} {
  # Transforms \n to "EOL chars" and vise versa.
  #   val - string to transform
  #   mode - if "in", gets \n-valued; if "out", gets EOL-valued.

  variable EOL
  if {$mode eq {in}} {
    return [string map [list $EOL \n] $val]
  } else {
    return [string map [list \n $EOL] $val]
  }
}

proc ::alited::ProcessFiles {procname what} {
  # Processes files according to Selected/All choice.
  #   procname - name of command to run on files (TID passed)
  #   what - what to process: 1 - selected, 2 - all
  # Returns numbers of all and processed files.
  # See also: SessionList

  variable da
  set all [set processed 0]
  foreach tab [alited::SessionList $what] {
    incr all
    incr processed [$procname [lindex $tab 0]]
  }
  return [list $all $processed]
}

proc ::alited::raise_window {} {
  # Raises the app's window.

  variable al
  catch {
    wm withdraw $al(WIN)
    wm deiconify $al(WIN)
  }
}

proc ::alited::RestoreRunOptions {} {
  # Restores options of "Run..." dialogue.

  variable al
  lassign $al(_SavedRunOptions_)  al(prjincons) al(comForce) al(comForceLs) al(comForceCh) al(prjbeforerun)
}

proc ::alited::Run {args} {
  # Runs Tcl/Tk script.
  #   args - script's name and arguments

  set com [string trimright "$args" &]
  if {{TEST_ALITED} in $args} {
    set com [string map [list { TEST_ALITED} {}] $com]
    puts [Tclexe]\ $com
  }
  return [pid [open |[list [Tclexe] {*}$com]]]
}

proc ::alited::run_remote {cmd args} {
  # Runs a command that was started by another process.

  if {[catch { $cmd {*}$args } err]} {
    puts $err
    return -code error
  }
}

proc ::alited::Runtime {args} {
  # Runs Tcl/Tk script by alited's Tcl/Tk runtime.
  #   args - script's name and arguments

  exec -- [info nameofexecutable] {*}$args &
}

proc ::alited::SaveRunOptions {} {
  # Saves options of "Run..." dialogue.

  variable al
  set al(_SavedRunOptions_) [list  $al(prjincons) $al(comForce) $al(comForceLs) $al(comForceCh) $al(prjbeforerun)]
}

proc ::alited::ScriptSource {script} {
  # Sources script.tcl (at need).
  #   script - the script name

  variable SRCDIR
  if {[info commands ::alited::${script}::_run] eq {}} {
    source [file join $SRCDIR $script.tcl]
  }
}

proc ::alited::SessionList {{mode 0}} {
  # Returns a list of all tabs or selected tabs (if set).
  #   mode - 0 get selected or all, 1 force selected, 2 force all

  set res [alited::bar::BAR listFlag s]
  if {(!$mode && [llength $res]==1) || $mode==2} {
    set res [alited::bar::BAR listTab]
  }
  return $res
}

proc ::alited::SessionTclList {{mode 0}} {
  # Returns a list of all tabs or selected tabs of .tcl files.
  #   mode - 0 get selected or all, 1 force selected, 2 force all

  set ltabs [list]
  foreach tab [alited::SessionList $mode] {
    if {[alited::isTclScript $tab]} {
      lappend ltabs $tab
    }
  }
  return $ltabs
}

proc ::alited::Source_e_menu {} {
  # Sources e_menu.tcl at need.

  if {![info exists ::em::geometry]} {
    source [file join $::e_menu_dir e_menu.tcl]
  }
}

proc ::alited::SyntaxColors {} {
  # Gets colors for syntax highlighting.

  variable al
  foreach nam [::hl_tcl::hl_colorNames] {lappend colors $al(ED,$nam)}
  lassign [::hl_tcl::addingColors] clrCURL clrCMN2
  lappend colors $clrCURL $clrCMN2
  return $colors
}

proc ::alited::SyntaxHighlight {lng wtxt colors {cs {}} args} {
  # Makes a text being syntax highlighted.
  #   lng - language (tcl, c)
  #   wtxt - text's path
  #   colors - highlighting colors
  #   cs - color scheme
  #   args - other options

  variable al
  if {$cs eq {}} {set cs [obj csCurrent]}
  ::hl_${lng}::hl_init $wtxt -dark [obj csDark $cs] -colors $colors  -multiline 1 -font $al(FONT,txt) -insertwidth $al(CURSORWIDTH)  -cmdpos ::apave::None -dobind yes {*}$args
  ::hl_${lng}::hl_text $wtxt
}

proc ::alited::Tclexe {} {
  # Gets Tcl's executable file.

  variable al
  if {$al(EM,Tcl) eq {}} {
    if {$al(IsWindows)} {
      # important: refer to tclsh (not wish), to run it in Windows console
      # though not good for deployed Tcl/Tk 8.6-
      set tclexe [::apave::autoexec tclsh .exe]
    } else {
      set tclexe [info nameofexecutable]
    }
  } else {
    set tclexe $al(EM,Tcl)
  }
  return $tclexe
}

proc ::alited::TextIcon {ico {to out}} {
  # Gets a picture from a character and vice versa.
  #   ico - picture or character
  #   to - "in" gets in-chars, "out" gets out-chars

  set in [list 0 1 2 3 4 5 6 7 8 9 & ~ = @]
  set out [list ∀ ∃ ∏ ∑ ⁂ ⊍ ⋀ ⋁ ⋈ ⋒ ⌗ ⌛ ⌬ ⏏]
  if {$to eq {out}} {
    set lfrom $in
    set lto $out
  } else {
    set lfrom $out
    set lto $in
  }
  if {[set i [lsearch -exact $lfrom $ico]]>-1} {
    set tico [lindex $lto $i]
  } else {
    set tico $ico
  }
  return $tico
}

proc ::alited::TipMessage {lab tip} {
  # Shows a tip on status message and clears the status message.
  #   lab - message label's path
  #   tip - text of tip

  if {$tip ne {}} {$lab configure -text {}}
  return $tip
}

proc ::alited::TmpFile {tname} {
  # Gets a temporary file's name.
  #   tname - tailing part of the name

  variable al
  return [file join $al(EM,mnudir) $tname]
}

proc ::alited::Tnext {{wprev {}}} {
  # Returns "next & prev widgets" for Tab & Shift/Tab keys, just to skip "Help".
  #   wprev - widget for Shift/Tab
  # Used by obPrf & obPrj objects.

  return [list *.ButOK $wprev]
}

proc ::alited::about::About {} {
  # Shows "About" dialogue.

  # alited_checked

  namespace upvar ::alited al al
  variable textTags

  ## ________________________ Preparing tabs _________________________ ##

  ::alited::Source_e_menu
  ::alited::edit::MacroInit
  lassign [obj csGet] fg fg2 bg bg2 - bS fS
  ::apave::InitAwThemesPath $::alited::LIBDIR
  foreach _ {alited apave bartabs baltip hl_tcl playtkl} {
    if {[set v$_ v[package versions $_]] eq {v}  && [catch {set v$_ v[package require $_]}]} {
      set v$_ {}
    }
  }
  set font [obj csFontDef]
  obj initLinkFont {*}$font -underline 1 -foreground $fg2 -background $bg2
  append font " -weight bold"

  ### ________________________ Tags and links _________________________ ###

  set textTags [list  [list "red" "-font {$font} -foreground $fS -background $bS"]  [list "link1" "openDoc %t@@https://%l@@"]  [list "link2" "openDoc %t@@https://wiki.tcl-lang.org/recent@@"]  [list "linkapl" "openDoc %t@@https://github.com/aplsimple/@@"]  [list "linkCN" "openDoc %t@@https://www.nemethi.de/@@"]  [list "linkSH" "openDoc %t@@https://wiki.tcl-lang.org/page/Steve+Huntley@@"]  [list "linkHE" "openDoc %t@@https://wiki.tcl-lang.org/page/HE@@"]  [list "linkRD" "openDoc %t@@https://github.com/rdbende@@"]  [list "linkPO" "openDoc %t@@https://wiki.tcl-lang.org/page/Paul+Obermeier@@"]  [list "linkPW" "openDoc %t@@https://wiki.tcl-lang.org/page/PW@@"]  [list "linkRK" "openDoc %t@@https://rkeene.org/projects/info@@"]  [list "linkMIT" "openDoc %t@@https://en.wikipedia.org/wiki/MIT_License@@"]  [list "linkJS" "openDoc %t@@https://wiki.tcl-lang.org/page/Jeff+Smith@@"]  [list "linkRS" "openDoc %t@@http://wiki.tcl-lang.org/page/Richard+Suchenwirth@@"]  [list "linkAN" "openDoc %t@@https://www.magicsplat.com/@@"]  [list "linkDF" "openDoc %t@@https://wiki.tcl-lang.org/page/Donal+Fellows@@"]  [list "linkJO" "openDoc %t@@https://www.johann-oberdorfer.eu/@@"]  [list "linkTW" "openDoc %t@@https://github.com/phase1geo@@"]  [list "linkCM" "openDoc %t@@https://wiki.tcl-lang.org/page/Colin+Macleod@@"]  [list "linkDB" "openDoc %t@@https://wiki.tcl-lang.org/page/dbohdan"]  [list "linkDG" "openDoc %t@@https://wiki.tcl-lang.org/page/Detlef+Groth"]  [list "linkPY" "openDoc %t@@https://wiki.tcl-lang.org/page/Poor+Yorick"]  [list "linkMH" "openDoc %t@@https://wiki.tcl-lang.org/page/Matthias+Hoffmann"]  [list "linkNB" "openDoc %t@@https://github.com/sl1200mk2@@"]  [list "linkTZ" "openDoc %t@@https://github.com/thanoulis@@"]  [list "linkCW" "openDoc %t@@https://wiki.tcl-lang.org/page/chw@@"]  [list "linkAK" "openDoc %t@@https://wiki.tcl-lang.org/page/Andreas+Kupries@@"]  [list "linkAG" "openDoc %t@@https://wiki.tcl-lang.org/page/Andy+Goth@@"]  [list "linkDA" "openDoc %t@@https://github.com/ray2501@@"]  [list "linkET" "openDoc %t@@https://github.com/eht16"]  [list "link-apave" "openDoc %t@@https://aplsimple.github.io/en/tcl/pave"]  [list "link-e_menu" "openDoc %t@@https://aplsimple.github.io/en/tcl/e_menu"]  [list "link-baltip" "openDoc %t@@https://aplsimple.github.io/en/tcl/baltip/baltip.html"]  [list "link-bartabs" "openDoc %t@@https://aplsimple.github.io/en/tcl/bartabs"]  [list "link-hl_tcl" "openDoc %t@@https://aplsimple.github.io/en/tcl/hl_tcl/hl_tcl.html"]  [list "link-aloupe" "openDoc %t@@https://aplsimple.github.io/en/tcl/aloupe/aloupe.html"]  [list "link-playtkl" "openDoc %t@@https://aplsimple.github.io/en/tcl/playtkl/playtkl.html"]  [list "link-tkcc" "openDoc %t@@https://aplsimple.github.io/en/tcl/tkcc"]  [list "link-repl" "openDoc %t@@https://github.com/apnadkarni/tcl-repl"]  [list "link-ale_themes" "openDoc %t@@https://github.com/aplsimple/ale_themes"]  [list "link-tkcon" "openDoc %t@@https://wiki.tcl-lang.org/page/Tkcon"]  [list "link_" "openDoc %t@@https://aplsimple.github.io/en/misc/links/links.html@@"]  [list "linkRH" "openDoc %t@@http://www.hwaci.com/drh/@@"]  [list "linkBL" "openDoc %t@@https://wiki.tcl-lang.org/page/bll@@"]  [list "linkFF" "openDoc %t@@https://wiki.tcl-lang.org/page/FF@@"]  [list "linkSS" "openDoc %t@@https://github.com/antirez@@"]  [list "linkML" "openDoc %t@@https://wiki.tcl-lang.org/page/Martin+Lemburg@@"]  [list "linkDN" "openDoc %t@@https://github.com/par7133@@"]  [list "linkAM" "openDoc %t@@https://en.wikipedia.org/wiki/Argentina@@"]  [list "linkHO" "openDoc %t@@https://wiki.tcl-lang.org/page/Harald+Oehlmann@@"]  [list "linkJM" "openDoc %t@@https://github.com/jgm@@"]  ]

  ### ________________________ "General" tab _________________________ ###

  set long1 [msgcat::mc {And well fit for programming with it.}]
  set long2 __________________________________________
  set long3 [file nativename [info nameofexecutable]]
  set msg "  <red>alited $valited</red> [msgcat::mc {stands for}] \"a lite editor\".\n\n  [msgcat::mc {Written in pure Tcl/Tk.}] \n  $long1\n\n  [msgcat::mc {Details:}] \n\n  \u2022 <link1>aplsimple.github.io/en/tcl/alited</link1>\n  \u2022 <link1>github.com/aplsimple/alited</link1>\n  \u2022 <link1>chiselapp.com/user/aplsimple/repository/alited</link1>\n\n  [msgcat::mc {Authors:}] \n\n  \u2022 <linkapl>Alex Plotnikov</linkapl>\n\n  [msgcat::mc {License:}] <linkMIT>MIT</linkMIT>\n  $long2\n  \n  <red> $long3 </red>\n  \n  <red> Tcl/Tk $::alited::tcltk_version </red> <link2></link2>\n  \n  <red> $::tcl_platform(os) $::tcl_platform(osVersion) </red>"

  ### ________________________ "Packages" tab _________________________ ###

  set packages [msgcat::mc {Packages used by <red>alited %ver</red>:}]
  set packages [string map [list %ver $valited] $packages]
  set vemenu   v[lindex $::em::em_version 1]
  set ::alited::AboutPack "\n $packages\n\n  \u2022 <link-apave>apave $vapave</link-apave>\n\n  \u2022 <link-e_menu>e_menu $vemenu</link-e_menu>\n\n  \u2022 <link-ale_themes>ale_themes</link-ale_themes>\n\n  \u2022 <link-baltip>baltip $vbaltip</link-baltip>\n\n  \u2022 <link-bartabs>bartabs $vbartabs</link-bartabs>\n\n  \u2022 <link-hl_tcl>hl_tcl $vhl_tcl</link-hl_tcl>\n\n  \u2022 <link-aloupe>aloupe v1.6</link-aloupe>\n\n  \u2022 <link-playtkl>playtkl $vplaytkl</link-playtkl>\n\n  \u2022 <link-tkcc>tkcc</link-tkcc>\n\n  \u2022 <link-repl>tcl-repl</link-repl>\n\n  \u2022 <link-tkcon>tkcon v2.7</link-tkcon>\n  \n menus/*.em v$al(MNUversion)  \n alited.ini v$al(INIversion)"

  ### ________________________ "Acknowledgements" tab _________________________ ###

  set ackn [msgcat::mc "Many thanks to the following people  \n who have contributed to this project  \n with their participation, advice and code"]
  set spec [msgcat::mc "Special thanks also to"]
  set ::alited::AboutAckn "\n $ackn\n\n  \u2022 <linkSH>Steve Huntley</linkSH>\n  \u2022 <linkHE>Holger Ewert</linkHE>\n  \u2022 <linkCN>Csaba Nemethi</linkCN>\n  \u2022 <linkPO>Paul Obermeier</linkPO>\n  \u2022 <linkAN>Ashok P. Nadkarni</linkAN>\n  \u2022 <linkRD>rdbende</linkRD>\n  \u2022 <linkBL>Brad Lanam</linkBL>\n  \u2022 <linkPW>Paul Walton</linkPW>\n  \u2022 <linkJO>Johann Oberdorfer</linkJO>\n  \u2022 <linkRS>Richard Suchenwirth</linkRS>\n  \u2022 <linkCW>Christian Werner</linkCW>\n  \u2022 <linkNB>Nicolas Bats</linkNB>\n  \u2022 <linkTZ>Thanos Zygouris</linkTZ>\n  \u2022 <linkFF>Federico Ferri</linkFF>\n  \u2022 <linkSS>Salvatore Sanfilippo</linkSS>\n  \u2022 <linkML>Martin Lemburg</linkML>\n  \u2022 <linkDN>Daniele Bonini</linkDN>\n  \u2022 <linkAM>Alexis Martin</linkAM>\n  \n $spec\n\n  \u2022 <linkTW>Trevor Williams</linkTW>\n  \u2022 <linkDF>Donal K. Fellows</linkDF>\n  \u2022 <linkJS>Jeff Smith</linkJS>\n  \u2022 <linkRK>Roy Keene</linkRK>\n  \u2022 <linkDB>D. Bohdan</linkDB>\n  \u2022 <linkDG>Detlef Groth</linkDG>\n  \u2022 <linkCM>Colin Macleod</linkCM>\n  \u2022 <linkPY>Nathan Coulter</linkPY>\n  \u2022 <linkAK>Andreas Kupries</linkAK>\n  \u2022 <linkRH>D. Richard Hipp</linkRH>\n  \u2022 <linkMH>Matthias Hoffmann</linkMH>\n  \u2022 <linkAG>Andy Goth</linkAG>\n  \u2022 <linkDA>Danilo Chang</linkDA>\n  \u2022 <linkET>Enrico Troeger</linkET>\n  \u2022 <linkHO>Harald Oehlmann</linkHO>\n  \u2022 <linkJM>John MacFarlane</linkJM>\n  \n <link_>Excuse my memory if I omitted someone's name.</link_>\n"

  ### ________________________ Combining tabs _________________________ ###

  set wmax [expr {4+max([string length $long1],  [string length $long2],[string length $long3])}]
  set tab2 [list General Packages "{fra - - 1 99 {-st nsew -rw 1 -cw 1}}  {.TexPack - - - - {pack -side left -expand 1 -fill both} {-w $wmax -h 31  -rotext ::alited::AboutPack -tags ::alited::about::textTags}}"  Acknowledgements "{fra - - 1 99 {-st nsew -rw 1 -cw 1}}  {.TexAckn - - - - {pack -side left -expand 1 -fill both}  {-w $wmax -h 34 -rotext ::alited::AboutAckn -tags ::alited::about::textTags}}  {.sbv .texAckn L - - {pack -side right}}"]

  ## ________________________ Change default options _________________________ ##

  # invert link colors
  set aopts "{-fg $::apave::FGMAIN -bg $::apave::BGMAIN}"
  obj untouchWidgets "*.texM $aopts" "*.texPack $aopts" "*.texAckn $aopts"
  lassign [obj csGet] fg fg2 bg bg2
  lappend textTags "FG $fg2" "FG2 $fg" "BG $bg2" "BG2 $bg"

  # tooltips to show in the left & bottom point from the mouse pointer
  lassign [::baltip cget -shiftX] -> shiftX
  ::baltip configure -shiftX 10

  ## ________________________ Open dialogue _________________________ ##

  ::alited::msg ok {} $msg  -title [msgcat::mc About] -t 1 -w $wmax -h {30 30} -scroll 0  -tags ::alited::about::textTags -my "after idle {alited::about::textImaged %w}"  -tab2 $tab2

  ## ________________________ Restore defaults _________________________ ##

  ::baltip configure -shiftX $shiftX
  obj touchWidgets *.texM *.texPack *.texAckn
  unset -nocomplain ::alited::AboutAckn
  unset -nocomplain ::alited::AboutPack
}

proc ::alited::about::textImaged {w} {
  # Makes the feather blink.
  #  w - window's path

  obj labelFlashing [obj textLink $w 5] "" 1  -data $::alited::img::_AL_IMG(feather) -pause 0.5 -incr 0.1 -after 40
}

proc ::alited::bar::BAR {args} {
  # Runs the tab bar's method.
  #   args - method's name and its arguments

  namespace upvar ::alited al al
  if {[lindex $args 0] eq {popList}} {
    if {[llength $args] eq 1} {lappend args {} {}}
    lappend args $al(sortList)
  }
  if {[lindex $args 1] eq {cget}} {
    if {![al(bts) isTab [lindex $args 0]]} {
      return {} ;# at closing tabs: cget must return "" to "after" proc
    }
  }
  return [al(bts) $al(BID) {*}$args]
}

proc ::alited::bar::ColorBar {} {
  # Makes the bar of tabs to have a "marked tab" color
  # consistent with current color scheme.

  namespace upvar ::alited obPav obPav
  set cs [$obPav csCurrent]
  if {$cs>-1} {
    lassign [$obPav csGet $cs] cfg2 cfg1 cbg2 cbg1 cfhh - - - - - - - - - - - - fgmark
    # %t wildcard means "a tooltip on the list of files":
    BAR configure -fgmark $fgmark -comlist {::alited::bar::SelFile %ID "%t"}
  }
}

proc ::alited::bar::CompareByDate {t1 t2} {
  # Compares two tabs by date.
  #   t1 - 1st tab
  #   t2 - 2nd tab

  lassign [SortData $t1] fname1 - date1
  lassign [SortData $t2] fname2 - date2
  if {$date1 < $date2} {
    set res -1
  } elseif {$date1 > $date2} {
    set res 1
  } elseif {$::alited::al(incdec) eq {increasing}} {
    set res [string compare -nocase $fname1 $fname2]
  } else {
    set res [string compare -nocase $fname2 $fname1]
  }
  return $res
}

proc ::alited::bar::CompareByExtn {t1 t2} {
  # Compares two tabs by extension.
  #   t1 - 1st tab
  #   t2 - 2nd tab

  lassign [SortData $t1] fname1 ext1
  lassign [SortData $t2] fname2 ext2
  if {[set res [string compare -nocase $ext1 $ext2]]==0} {
    if {$::alited::al(incdec) eq {increasing}} {
      set res [string compare -nocase $fname1 $fname2]
    } else {
      set res [string compare -nocase $fname2 $fname1]
    }
  }
  return $res
}

proc ::alited::bar::CompareBySize {t1 t2} {
  # Compares two tabs by size.
  #   t1 - 1st tab
  #   t2 - 2nd tab

  lassign [SortData $t1] fname1 - - size1
  lassign [SortData $t2] fname2 - - size2
  if {$size1 < $size2} {
    set res -1
  } elseif {$size1 > $size2} {
    set res 1
  } elseif {$::alited::al(incdec) eq {increasing}} {
    set res [string compare -nocase $fname1 $fname2]
  } else {
    set res [string compare -nocase $fname2 $fname1]
  }
  return $res
}

proc ::alited::bar::ControlTab {} {
  # Switches between last two active tabs.

  variable ctrltablist
  alited::favor::SkipVisited yes
  set fname [CurrentControlTab]
  set found no
  while {[llength $ctrltablist]} {
    set fnext [lindex $ctrltablist 0]
    foreach tab [BAR listTab] {
      set TID [lindex $tab 0]
      if {$fnext eq [FileName $TID]} {
        set found yes
        break
      }
    }
    if {$found} break
    # if the file was closed, remove it from the ctrl-tabbed
    set ctrltablist [lreplace $ctrltablist 0 0]
  }
  if {$found} {
    CurrentControlTab $fname
    BAR $TID show
  }
  after idle "focus \[alited::main::CurrentWTXT\]; alited::favor::SkipVisited no"
}

proc ::alited::bar::CurrentControlTab {{fname {}}} {
  # Keeps a list of last switched files, to switch between last two.
  #   fname - file name

  variable ctrltablist
  if {[set ret [expr {$fname eq {}}]]} {
    set fname [FileName]
  }
  ::apave::PushInList ctrltablist $fname $ret
  return $fname
}

proc ::alited::bar::CurrentTab {io {TID {}}} {
  # Gets an attribute of the current tab.
  #   io - 0 to get ID, 1 - short name (tab label), 2 - full name, 3 - index
  #   TID - tab's ID

  if {$TID eq {}} {set TID [CurrentTabID]}
  switch $io {
    0 {set res $TID}
    1 {set res [BAR $TID cget -text]}
    2 {set res [FileName $TID]}
    3 {set res [lsearch -index 0 [BAR listTab] $TID]}
    default {set res {}}
  }
  return $res
}

proc ::alited::bar::CurrentTabID {} {
  # Gets ID of the current tab.

  return [BAR cget -tabcurrent]
}

proc ::alited::bar::DisableTabLeft {tab} {
  # Checks for left tabs to disable "select all at left".
  #   tab - tab's ID
  # Returns 1, if no left tab exists, thus disabling the menu's item.

  set i [CurrentTab 3 $tab]
  if {$i} {return 0}
  return 1
}

proc ::alited::bar::DisableTabRight {tab} {
  # Checks for right tabs to disable "select all at right".
  #   tab - tab's ID
  # Returns 1, if no right tab exists, thus disabling the menu's item.

  set i [CurrentTab 3 $tab]
  if {$i < ([llength [BAR listTab]]-1)} {return 0}
  return 1
}

proc ::alited::bar::FileName {{TID {}}} {
  # Gets a file name of a tab.
  #   TID - tab's ID

  if {$TID eq {}} {set TID [CurrentTabID]}
  set tip [BAR $TID cget -tip]
  return [lindex [split $tip \n] 0]
}

proc ::alited::bar::FilesTIDs {} {
  # Gets a list of pairs "filename & TID".
  # Useful at massive calls of FileTID proc.
  # See also: FileTID

  set filesTIDs [list]
  foreach tab [BAR listTab] {
    set TID [lindex $tab 0]
    lappend filesTIDs [list [FileName $TID] $TID]
  }
  return $filesTIDs
}

proc ::alited::bar::FileTID {fname {filesTIDs {}}} {
  # Gets a tab's ID of a file name.
  #   fname - file name
  #   filesTIDs - prepared list of pairs "filename & TID"
  # The *filesTIDs* is useful at massive calls of this proc.
  # See also: FilesTIDs

  if {[llength $filesTIDs]} {
    if {[set i [lsearch -exact -index 0 $filesTIDs $fname]]>=0} {
      return [lindex $filesTIDs $i 1]
    }
  } else {
    foreach tab [BAR listTab] {
      set TID2 [lindex $tab 0]
      if {$fname eq [FileName $TID2]} {
        return $TID2
      }
    }
  }
  return {}
}

proc ::alited::bar::FillBar {wframe {newproject no}} {
  # Fills the bar of tabs.
  #   wframe - frame's path to place the bar in
  #   newproject - if yes, creates the bar from scratch

  namespace upvar ::alited al al obPav obPav
  update ;# to get real sizes of -wbase
  set wbase [$obPav LbxInfo]
  set lab0 [msgcat::mc (Un)Select]
  set lab1 [msgcat::mc {... Visible}]
  set lab2 [msgcat::mc {... All at Left}]
  set lab3 [msgcat::mc {... All at Right}]
  set lab4 [msgcat::mc {... All}]
  if {$al(ED,btsbd)} {set bd {-bd 2 -relief sunken}} {set bd {}}
  set bar1Opts [list -wbar $wframe -wbase $wbase -pady 2 -scrollsel no -lifo $al(lifo)  -lowlist $al(FONTSIZE,small) -lablen $al(INI,barlablen) -tiplen $al(INI,bartiplen)  -bg [lindex [$obPav csGet] 3] -popuptip ::alited::bar::PopupTip  -menu [list  sep  "com {$lab0} {::alited::bar::SelTab %t} {} {}"  "com {$lab1} {::alited::bar::SelTabVis} {} {}"  "com {$lab2} {::alited::bar::SelTabLeft %t} {} {{\[::alited::bar::DisableTabLeft %t\]}}"  "com {$lab3} {::alited::bar::SelTabRight %t} {} {{\[::alited::bar::DisableTabRight %t\]}}"  "com {$lab4} {::alited::bar::SelTabAll} {} {}"]  -separator no -font apaveFontDefTypedsmall  -csel2 {alited::bar::OnTabSelection %t}  -csel3 alited::bar::OnControlClick  -cdel {alited::file::CloseFile %t yes}  -cmov2 alited::bar::OnTabMove  -cmov3 {alited::bar::OnTabMove3 %t}  -title $al(MC,filelist)  -expand 9 -padx 0 {*}$bd]
  set tabs [set files [set posis [set wraps [list]]]]
  foreach tab $al(tabs) {
    lassign [split $tab \t] tab pos wrap
    lappend files $tab
    lappend posis $pos
    lappend wraps $wrap
    set tab [UniqueTab $tabs [file tail $tab]]
    lappend tabs $tab
    lappend bar1Opts -tab $tab
  }
  set byname [msgcat::mc Sort]
  set bydate [msgcat::mc {... by date}]
  set bysize [msgcat::mc {... by size}]
  set byextn [msgcat::mc {... by extension}]
  set ttl [msgcat::mc {Files to Beginning}]
  set tip [msgcat::mc  "If it's checked, open files would be placed\nonto the beginning page of the bar."]
  lappend bar1Opts -menu [list  sep  "com {$byname} {alited::bar::Sort Name}"  "com {$bydate} {alited::bar::Sort Date {\n$bydate}}"  "com {$bysize} {alited::bar::Sort Size {\n$bysize}}"  "com {$byextn} {alited::bar::Sort Extn {\n$byextn}}"  sep  "chb {$ttl} alited::bar::Lifo {} {} {$tip} ::alited::al(lifo)"  ]
  set curname [lindex $tabs $al(curtab)]
  catch {BAR removeAll}
  catch {::bartabs::Bars create al(bts)}   ;# al(bts) is Bars object
  if {$newproject || [catch {set al(BID) [al(bts) create al(bt) $bar1Opts $curname]}]} {
    foreach tab $tabs {BAR insertTab $tab}
  }
  set tabs [BAR listTab]
  foreach tab $tabs fname $files pos $posis wrap $wraps {
    set tid [lindex $tab 0]
    SetTabState $tid --fname $fname --pos $pos --wrap $wrap
    BAR $tid configure -tip [alited::file::FileStat $fname]
  }
  set curname [lindex $files $al(curtab)]
  SetBarState -1 $curname [$obPav Text] [$obPav SbvText]
  ColorBar
  alited::file::CheckForNew
}

proc ::alited::bar::GetBarState {} {
  # Gets attributes of a tab that are specific for alited.

  return [BAR cget -ALITED]
}

proc ::alited::bar::GetTabState {{TID {}} args} {
  # Gets attributes of a tab.
  #   TID - tab's ID (current one by default)
  #   args - list of attributes + values

  if {$TID eq {}} {set TID [CurrentTabID]}
  if {![BAR isTab $TID]} {return {}}
  return [BAR $TID cget {*}$args]
}

proc ::alited::bar::InsertTab {tab tip} {
  # Inserts a new tab into the beginning of bar of tabs.
  #   tab - the tab
  #   tip - the tab's tip

  namespace upvar ::alited al al
  set TID [BAR insertTab $tab 0]
  BAR $TID configure -tip $tip
  SetTabState $TID --fname $tip
  alited::ini::SaveCurrentIni $al(INI,save_onadd)
  return $TID
}

proc ::alited::bar::Lifo {} {
  # Sets -lifo option of the bar.

  namespace upvar ::alited al al
  BAR configure -lifo $al(lifo)
}

proc ::alited::bar::OnControlClick {} {
  # Shows a number of tabs selected by Ctrl+Click.

  set llen [llength [alited::bar::BAR cget -select]]
  set msg [string map "%n $llen" [msgcat::mc {Selected files: %n}]]
  alited::Message $msg 3
}

proc ::alited::bar::OnTabMove {} {
  # Handles moving a tab in the bar.

  namespace upvar ::alited al al
  alited::ini::SaveCurrentIni $al(INI,save_onmove)
}

proc ::alited::bar::OnTabMove3 {{TID {}}} {
  # Handles moving selected tab(s) in the bar.
  #   TID - if empty, the selected tabs are moved

  namespace upvar ::alited al al
  alited::ini::SaveCurrentIni $al(INI,save_onmove)
  if {$TID eq {}} {
    # no selection of tabs after moving
    BAR unselectTab
    OnControlClick
  }
}

proc ::alited::bar::OnTabSelection {TID} {
  # Handles selecting a tab in the bar.
  #   TID - tab's ID

  namespace upvar ::alited al al
  variable whilesorting
  if {$whilesorting} return
  alited::favor::SkipVisited yes
  set fname [FileName $TID]
  alited::main::ShowText
  alited::file::SbhText
  alited::find::ClearTags
  alited::ini::SaveCurrentIni $al(INI,save_onselect)
  alited::edit::CheckSaveIcons [alited::file::IsModified $TID]
  alited::edit::CheckUndoRedoIcons [alited::main::CurrentWTXT] $TID
  if {[alited::edit::CommentChar] ne {}} {set cmnst normal} {set cmnst disabled}
  if {[set wtxt [alited::main::GetWTXT $TID]] ne {}} {
    set al(wrapwords) [expr {[$wtxt cget -wrap] eq {word}}]
  }
  CurrentControlTab $fname
  alited::menu::FillRunItems $fname
  alited::main::HighlightLine
  lassign [alited::main::CalcIndentation $wtxt] indent indentchar
  ::apave::setTextIndent $indent $indentchar
  if {$al(prjindentAuto)} {alited::main::UpdateProjectInfo $indent}
  after 10 {
    ::alited::tree::SeeSelection
    ::alited::main::UpdateGutter
    ::alited::favor::SkipVisited no
  }
  if {![alited::file::IsNoName $fname] && ![file exists $fname]} {
    after idle [list alited::Balloon1 $fname]
  }
}

proc ::alited::bar::PopupTip {wmenu idx TID} {
  # Makes tooltips (full file names) for popup menu items.
  # wmenu - path to popup menu
  # idx - index of item
  # TID - ID of item's tab

  if {[$wmenu cget -tearoff]} {incr idx}
  ::baltip::tip $wmenu [alited::file::FileStat [FileName $TID]] -index $idx -shiftX 10 -ontop 1
}

proc ::alited::bar::RenameTitles {TID} {
  # After closing a tab, seeks and renames synonyms of tabs: "name (2)", "name (3)"
  #   TID - closed tab's ID

  set names [list]
  foreach tab [BAR listTab] {
    set TID2 [lindex $tab 0]
    if {$TID2 ne $TID} {
      set name [file tail [FileName $TID2]]
      set icnt 1
      if {[set i [lsearch -exact -index 1 $names $name]]>-1} {
        lassign [lindex $names $i] tid name icnt
        incr icnt
        set names [lreplace $names $i $i [list $tid $name $icnt]]
        set name "$name ($icnt)"
      }
      lappend names [list $TID2 $name $icnt]
    }
  }
  set doupdate no
  foreach name $names {
    lassign $name TID2 name
    if {[BAR $TID2 cget -text] ne $name} {
      set doupdate yes
      BAR $TID2 configure -text $name
    }
  }
  if {$doupdate} {BAR draw no}
}

proc ::alited::bar::SelFile {TID tip} {
  # Open a file from the file list even when it's closed
  # (the file list may be open due to -tearoff option).

  lassign [split $tip \n] fname
  if {[alited::file::OpenFile $fname yes] eq {}} {
    BAR $TID show
    after idle [list alited::Balloon1 $fname]
  }
}

proc ::alited::bar::SelTab {tab {mode -1}} {
  # Makes a tab selected / unselected.
  #   tab - tab's ID
  #   mode - if 1, selects the tab

  set selected [BAR cget -select]
  if {$mode == 1 || $tab in $selected} {
    BAR unselectTab $tab
  } elseif {$mode == 0 || $tab ni $selected} {
    BAR selectTab $tab
  }
}

proc ::alited::bar::SelTabAll {} {
  # Makes all tabs selected / unselected.

  set mode [expr {[llength [BAR cget -select]]>0}]
  foreach tab [BAR listTab] {
    SelTab [lindex $tab 0] $mode
  }
}

proc ::alited::bar::SelTabLeft {tab} {
  # Makes all left tabs selected / unselected.
  #   tab - tab's ID

  foreach t [BAR listTab] {
    set t [lindex $t 0]
    if {$t eq $tab} break
    SelTab $t
  }
}

proc ::alited::bar::SelTabRight {tab} {
  # Makes all right tabs selected / unselected.
  #   tab - tab's ID

  set cntrd no
  foreach t [BAR listTab] {
    set t [lindex $t 0]
    if {$t eq $tab} {
      set cntrd yes
    } elseif {$cntrd} {
      SelTab $t
    }
  }
}

proc ::alited::bar::SelTabVis {} {
  # Makes visible tabs selected / unselected.

  foreach tab [BAR listFlag v] {
    SelTab $tab
  }
}

proc ::alited::bar::SetBarState {TID args} {
  # Sets attributes of the tab bar that are specific for alited.
  #   TID - tab's ID
  #   args - list of attributes + values

  BAR configure -ALITED [list $TID {*}$args]
}

proc ::alited::bar::SetTabState {TID args} {
  # Sets attributes of a tab.
  #   TID - tab's ID
  #   args - list of attributes + values

  if {![BAR isTab $TID]} return
  BAR $TID configure {*}$args
}

proc ::alited::bar::Sort {by {ttl {}}} {
  # Sorts tabs.
  #   by - sort type (by name is default)
  #   ttl - sort title

  namespace upvar ::alited obDl2 obDl2
  variable whilesorting
  set ::alited::al(incdec) [set ::alited::al(incdec$by)]
  lassign [$obDl2 input {} [msgcat::mc Sort] [list  radA  {{  }} {"$::alited::al(incdec)" increasing decreasing}  ] -head [msgcat::mc {Sort files}]$ttl] res ::alited::al(incdec)
  if {$res} {
    set whilesorting yes
    SortData
    if {$by eq {Name}} {set cmd {}} {set cmd alited::bar::CompareBy$by}
    if {$::alited::al(incdec) in [list increasing [msgcat::mc increasing]]} {
      set ::alited::al(incdec) increasing
    } else {
      set ::alited::al(incdec) decreasing
    }
    BAR sort -$::alited::al(incdec) $cmd
    set ::alited::al(incdec$by) $::alited::al(incdec)
    set whilesorting no
  }
}

proc ::alited::bar::SortData {{tab {}}} {
  # Sets or gets data for sorting bar tabs.
  #   tab - tab info (if empty, sets all tabs' data)
  # Returns a list of file's name, extension, date and size.

  if {$tab eq {}} {
    set sortdata [list]
    foreach tab [BAR listTab] {
      set tid [lindex $tab 0]
      set fname [FileName $tid]
      if {![catch {file stat $fname ares}]} {
        BAR $tid configure --sortdate $ares(mtime) --sortsize $ares(size)
      }
    }
    return {}
  } else {
    set tid [lindex $tab 0]
    lassign [BAR $tid cget -text --sortdate --sortsize] fname date size
    set ext [file extension $fname]
    if {[set i [string first " \(" $ext]]>-1} {
      set ext [string range $ext 0 $i-1]
    }
    return [list $fname $ext $date $size]
  }
}

proc ::alited::bar::TabName {{TID {}}} {
  # Gets a tab's title.
  #   TID - tab's ID

  if {$TID eq {}} {set TID [CurrentTabID]}
  return [BAR $TID cget -text]
}

proc ::alited::bar::UniqueListTab {fname} {
  # Returns a unique tab name for a file.
  #   fname - file name

  return [UniqueTab [BAR listTab] [file tail $fname] -index 1]
}

proc ::alited::bar::UniqueTab {tabs tab args} {
  # Returns a unique name for a tab.
  #   tabs - list of tabs
  #   tab - tab name to be checked for its duplicate
  #   args - options of lsearch to find a duplicate name
  # If some file has a tail name (tab name) equal to an existing one's,
  # the new tab name should get "(N)" suffix to be unique.
  # This is required by bartabs package: no duplicates allowed.

  set cnttab 1
  set taborig $tab
  while {1} {
    if {[lsearch {*}$args $tabs $tab]==-1} break
    set tab "$taborig ([incr cnttab])"
  }
  return $tab
}

proc ::alited::check::_create {} {
  # Creates "Checking" dialogue.

  namespace upvar ::alited al al obCHK obCHK
  variable win
  catch {destroy $win}
  $obCHK makeWindow $win.fra $al(MC,checktcl)
  $obCHK paveWindow $win.fra {
    {v_ - -}
    {labHead v_ T 1 1 {-st w -pady 4 -padx 8} {-t "Checks available:"}}
    {chb1 labHead T 1 1 {-st sw -pady 1 -padx 22} {-var ::alited::check::chBrace -t {Consistency of {} }}}
    {chb2 + T 1 1 {-st sw -pady 5 -padx 22} {-var ::alited::check::chBracket -t {Consistency of []}}}
    {chb3 + T 1 1 {-st sw -pady 1 -padx 22} {-var ::alited::check::chParenthesis -t {Consistency of ()}}}
    {chb4 + T 1 1 {-st sw -pady 5 -padx 22} {-var ::alited::check::chQuotes -t {Consistency of ""}}}
    {chb9 + T 1 1 {-st sw -pady 1 -padx 22} {-var ::alited::check::chDuplUnits -t {Duplicate units}}}
    {v_2 + T}
    {fra + T 1 1 {-st nsew -pady 0 -padx 3} {-padding {5 5 5 5} -relief groove}}
    {fra.lab - - - - {pack -side left} {-t "Check:"}}
    {fra.radA - - - - {pack -side left -padx 9}  {-t "current file" -var ::alited::check::what -value 1}}
    {fra.radB - - - - {pack -side left -padx 9}  {-t "all of session files" -var ::alited::check::what -value 2}}
    {fra2 fra T 1 1 {-st nsew -pady 3 -padx 3} {-padding {5 5 5 5} -relief groove}}
    {.ButHelp - - - - {pack -side left} {-t {$al(MC,help)} -tip F1 -com {alited::HelpAlited #checktool}}}
    {.h_ - - - - {pack -side left -expand 1 -fill both}}
    {.ButOK - - - - {pack -side left -padx 2} {-t "Check" -com ::alited::check::Check}}
    {.butCancel - - - - {pack -side left} {-t Cancel -com ::alited::check::Cancel}}
  }
  bind $win <F1> "[$obCHK ButHelp] invoke"
  if {[set geo $al(checkgeo)] ne {}} {
    set geo [string range $geo [string first + $geo] end]
    set geo "-geometry $geo"
  }
  $obCHK showModal $win -modal no -waitvar no -onclose alited::check::Cancel  -focus [$obCHK ButOK] {*}$geo -ontop [::isKDE]
}

proc ::alited::check::_run {} {
  # Runs "Checking" dialogue.

  namespace upvar ::alited al al obCHK obCHK
  variable win
  variable atopen
  set atopen yes
  if {[::apave::repaintWindow $win "$obCHK ButOK"]} {
    wm deiconify $win
  } else {
    after idle alited::check::Check
    _create
  }
}

proc ::alited::check::Cancel {args} {
  # Handles hitting "Cancel" button.

  namespace upvar ::alited al al
  variable win
  set al(checkgeo) [wm geometry $win]
  alited::CloseDlg
  destroy $win
}

proc ::alited::check::Check {} {
  # Runs checking.

  namespace upvar ::alited al al
  variable what
  variable atopen
  variable errors
  variable fileerrors
  alited::info::Clear
  alited::info::Put $al(MC,wait) {} yes yes
  set errors [set fileerrors 0]
  if {$atopen || $what==1} {  ;# at start, check a current file
    CheckFile
  } elseif {$what==2} {
    CheckAll
  }
  ShowResults
}

proc ::alited::check::CheckAll {} {
  # Checks all files of session.

  update
  set allfnd [list]
  foreach tab [alited::bar::BAR listTab] {
    set TID [lindex $tab 0]
    lassign [alited::main::GetText $TID] curfile wtxt
    CheckFile $curfile $wtxt $TID
  }
}