proc ::apave::autoexec {comm {ext {}}} {
  # Imitates Tcl's auto_execok.
  #   comm - a command to find
  #   ext - file's extension (for Windows)
  # If it doesn't get the command from Tcl's auto_execok,
  # it tries to knock at its file by itself.

  if {$ext ne {} && [::iswindows]} {append comm $ext}
  set res [auto_execok $comm]
  if {$res eq {} && [file exists $comm]} {
    set res $comm
  }
  return $res
}

proc ::apave::bindCantagToEvent {w tag event args} {
  # Binds an event on a canvas tag to a command.
  #   w - the widget's path
  #   tag - the tag
  #   event - the event
  #   args - the command

  ::baltip::my::BindCantagToEvent $w $tag $event {*}$args
}

proc ::apave::bindTextagToEvent {w tag event args} {
  # Binds an event on a text tag to a command.
  #   w - the widget's path
  #   tag - the tag
  #   event - the event
  #   args - the command

  ::baltip::my::BindTextagToEvent $w $tag $event {*}$args
}

proc ::apave::bindToEvent {w event args} {
  # Binds an event on a widget to a command.
  #   w - the widget's path
  #   event - the event
  #   args - the command

  ::baltip::my::BindToEvent $w $event {*}$args
}

proc ::apave::blinkWidget {w {fg #000} {bg #fff} {fg2 {}} {bg2 red} {pause 1000} {count -1} {mode 1}} {
  # Makes a widget blink.
  #   w - the widget's path
  #   fg - normal foreground color
  #   bg - normal background color
  #   fg2 - blinking foreground color (if {}, stops the blinking)
  #   bg2 - blinking background color
  #   pause - pause in millisec between blinkings
  #   count - means how many times do blinking
  #   mode - for recursive calls

  if {![winfo exists $w]} return
  if {$count==0 || $fg2 eq {}} {
    catch {after cancel $::apave::BLINKWIDGET1}
    catch {after cancel $::apave::BLINKWIDGET2}
    after idle "$w configure -foreground $fg; $w configure -background $bg"
  } elseif {$mode==1} {
    incr count -1
    $w configure -foreground $fg2
    $w configure -background $bg2
    set ::apave::BLINKWIDGET1 [after  $pause ::apave::blinkWidget $w $fg $bg $fg2 $bg2 $pause $count 2]
  } elseif {$mode==2} {
    $w configure -foreground $fg
    $w configure -background $bg
    set ::apave::BLINKWIDGET2 [after  $pause ::apave::blinkWidget $w $fg $bg $fg2 $bg2 $pause $count 1]
  }
}

proc ::apave::blinkWidgetImage {w img1 {img2 alimg_none} {cnt 6} {ms 100}} {
  # Makes a widget's image blink.
  #   w - widget's path
  #   img1 - main image
  #   img2 - flashed image
  #   cnt - count of flashes
  #   ms - millisec between flashes

  set imgcur $img1
  if {$cnt>0} {
    if {$cnt % 2} {set imgcur $img2}
    after $ms "::apave::blinkWidgetImage $w $img1 $img2 [incr cnt -1] $ms"
  }
  $w configure -image $imgcur
}

proc ::apave::checkGeometry {geo} {
  # Checks a window's geometry.
  #   geo - the geometry
  # Returns a "normalized" geometry (+0+0 if input not correct).

  if {!([regexp {^\d+x\d+\+-?\d+\+-?\d+$} $geo] ||
  [regexp {^\+-?\d+\+-?\d+$} $geo] || [regexp {^\d+x\d+$} $geo])} {
    set geo +0+0
  }
  return $geo
}

proc ::apave::checkHomeDir {com} {
  # For Tcl 9.0 & Windows: checks a command for "~".

  set hd [HomeDir]
  set com [string map [list { ~/} " $hd/" \"~/ \"$hd/ '~/ '$hd/ \\n~/ \\n$hd/ \n~/ \n$hd/ \{~/ \{$hd/] $com]
  if {[string match ~/* $com]} {set com $hd[string range $com 1 end]}
  return $com
}

proc ::apave::countChar {str ch} {
  # Counts a character in a string.
  #   str - a string
  #   ch - a character
  #
  # Returns a number of non-escaped occurences of character *ch* in
  # string *str*.
  #
  # See also:
  # [wiki.tcl-lang.org](https://wiki.tcl-lang.org/page/Reformatting+Tcl+code+indentation)

  set icnt 0
  while {[set idx [string first $ch $str]] >= 0} {
    set backslashes 0
    set nidx $idx
    while {[string equal [string index $str [incr nidx -1]] \\]} {
      incr backslashes
    }
    if {$backslashes % 2 == 0} { incr icnt }
    set str [string range $str [incr idx] end]
  }
  return $icnt
}

proc ::apave::cs_Active {{flag {}}} {
  # Gets/sets "is changing CS possible" flag for a whole application.

  if {[string is boolean -strict $flag]} {
    set ::apave::_CS_(isActive) $flag
  }
  return $::apave::_CS_(isActive)
}

proc ::apave::cs_Max {} {
  # Gets a maximum index of available color schemes

  expr {[llength $::apave::_CS_(ALL)] - 1}
}

proc ::apave::cs_MaxBasic {} {
  # Gets a maximum index of basic color schemes

  return $::apave::_CS_(STDCS)
}

proc ::apave::cs_Min {} {
  # Gets a minimum index of available color schemes

  return $::apave::_CS_(MINCS)
}

proc ::apave::cs_Non {} {
  # Gets non-existent CS index

  return -3
}

proc ::apave::CursorAtEnd {w} {
  # Sets the cursor at the end of a field.
  #   w - the field's path

  focus $w
  $w selection clear
  $w icursor end
}

proc ::apave::CursorToBEOL {wt where} {
  # Sets the cursor to the real start/end of text line.
  #   wt - text's path
  #   where - where to set

  set idx [$wt index insert]
  ::tk::TextSetCursor $wt [$wt index "$idx $where"]
}

proc ::apave::defaultAttrs {{type {}} {opts {}} {atrs {}} {widget {}}} {
  # Sets, gets or registers default options and attributes for widget type.
  #   type - widget type
  #   opts - new default grid/pack options
  #   atrs - new default attributes
  #   widget - Tcl/Tk command for the new registered widget type
  # See also: APaveBase::defaultATTRS

  obj defaultATTRS $type $opts $atrs $widget
}

proc ::apave::DefaultCS {} {
  # Gets default color scheme counting current background of Tk root window.

  if {[catch {set ib [ttk::style config . -background]}] ||
  [lindex [InvertBg $ib B] 0] eq {B}} {
    set res 5  ;# light
  } else {
    set res 23 ;# dark
  }
  return $res
}

proc ::apave::deiconify {w} {
  # Does 'deiconify' for a window.
  #   w - the window's path
  # See also: iconifyOption

  switch -- [iconifyOption] {
    none {          ; # no withdraw/deiconify actions
    }
    Linux {         ; # do it for Linux
      catch {wm deiconify $w ; raise $w}
    }
    Windows {       ; # do it for Windows
      if {[wm attributes $w -alpha] < 0.1} {wm attributes $w -alpha 1.0}
      catch {wm deiconify $w ; raise $w}
    }
    default {       ; # do it depending on the platform
      if {[::iswindows]} {
        if {[wm attributes $w -alpha] < 0.1} {wm attributes $w -alpha 1.0}
      }
      catch {wm deiconify $w ; raise $w}
    }
  }
}

proc ::apave::dlgPath {} {
  # Gets a current dialogue's path.
  # In fact, it does the same as [my dlgPath], but it can be
  # called outside of apave dialogue object (useful sometimes).

  return $::apave::querydlg
}

proc ::apave::endWM {args} {
  # Finishes the window management by apave, closing and clearing all.
  #   args - if any set, means "ask if apave's WM is finished"

  if {[llength $args]} {return [info exists ::apave::_CS_(endWM)]}
  set ::apave::_CS_(endWM) yes
}

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

  set arSave [array get $arName]
  {*}$args
  RestoreArray $arName $arSave
}

proc ::apave::error {{fileName {}}} {
  # Gets the error's message at reading/writing.
  #   fileName - if set, return a full error messageat opening file

  variable _PU_opts
  if {$fileName eq ""} {
    return $_PU_opts(_ERROR_)
  }
  return "Error of access to\n\"$fileName\"\n\n$_PU_opts(_ERROR_)"
}

proc ::apave::eventOnText {w ev} {
  # Generates an event on a text, saving its current index in hl_tcl.
  #   w - text widget's path
  #   ev - event
  # The hl_tcl needs to call MemPos before any action changing the text.

  catch {::hl_tcl::my::MemPos $w}
  if {[catch {$w tag ranges sel} sels]} {set sels [list]}
  switch -exact -- $ev {
    <<Cut>> - <<Copy>> {
      if {[set llen [expr {[llength $sels]-1}]] < 2} return
      # multiple ranges of selection:
      # first, copy all selections to clipboard
      clipboard clear -displayof $w
      foreach {pos1 pos2} $sels {
        clipboard append -displayof $w [$w get $pos1 $pos2]
      }
      if {$ev eq {<<Cut>>}} {
        # for Cut event: delete all selections
        for {set i $llen} {$i>0} {incr i -2} {
          set pos1 [lindex $sels $i-1]
          set pos2 [lindex $sels $i]
          $w delete $pos1 $pos2
        }
      }
      return -code break
    }
    default {
      event generate $w $ev
    }
  }
}

proc ::apave::extractOptions {optsVar args} {
  # Gets options' values and removes the options from the input list.
  #  optsVar - variable name for the list of options and values
  #  args  - list of "option / default value" pairs
  # Returns a list of options' values, according to args.
  # See also: parseOptions

  upvar 1 $optsVar opts
  set retlist [::apave::parseOptions $opts {*}$args]
  foreach {o v} $args {
    set opts [::apave::removeOptions $opts $o]
  }
  return $retlist
}

proc ::apave::FileRelativeTail {basepath fullpath} {
  # Gets a base relative path.
  # E.g. FileRelativeTail /a/b /a/b/cd/ef => ../ef
  #   basepath - base path
  #   fullpath - full path

  set tail [FileTail $basepath $fullpath]
  set lev [llength [file split $tail]]
  set base {}
  for {set i 1} {$i<$lev} {incr i} {append base ../}
  append base [file tail $tail]
}

proc ::apave::FileTail {basepath fullpath} {
  # Extracts a tail path from a full file path.
  # E.g. FileTail /a/b /a/b/cd/ef => cd/ef
  #   basepath - base path
  #   fullpath - full path

  set lbase [file split $basepath]
  set lfull [file split $fullpath]
  set ll [expr {[llength $lfull] - [llength $lbase] - 1}]
  if {$ll>-1} {
    return [file join {*}[lrange $lfull end-$ll end]]
  }
  return {}
}

proc ::apave::focusApp {{win {}}} {
  # Saves (if *win* is set) or restores app's focus.
  #   win - focused window's path
  # In some DE, if app loses focus, restoring it
  # focuses main window, ignores modal toplevel, locks keyboard.
  # focusApp tries to focus on last modal window.

  variable FOCUSED
  if {$win ne {}} {
    setProperty FOCW_$win [focus]
    return
  }
  catch {
    if {[set foc [focus]] ne {}} {
      set foc [winfo toplevel $foc]
      set modal 0
      foreach fw $FOCUSED {
        if {$fw eq $foc} {set modal 1; break}
      }
      # if non-modal is currently focused, let it be so
      if {!$modal} {
        if {[focus] eq $foc} {catch {focus [getProperty FOCW_$foc]}}
        return
      }
    }
    # find and focus last open modal
    for {set i [llength $FOCUSED]} {$i} {} {
      set fw [lindex $FOCUSED [incr i -1]]
      if {[winfo exists $fw]} {
        if {$fw ne $foc} {
          focus -force $fw
          catch {focus [getProperty FOCW_$fw]}
        }
        break
      }
      set FOCUSED [lreplace $FOCUSED $i $i]
    }
  }
}

proc ::apave::focusByForce {foc {cnt 10}} {
  # Focuses a widget.
  #   foc - widget's path

  if {[incr cnt -1]>0} {
    after idle after 5 ::apave::focusByForce $foc $cnt
  } else {
    catch {focus -force [winfo toplevel $foc]; focus $foc}
  }
}

proc ::apave::focusedWidget {w} {
  # Gets a flag "is a widget can be focused".
  #   w - widget's path

  set wclass [string tolower [winfo class $w]]
  foreach c [list entry text button box list view] {
    if {[string match *$c $wclass]} {
      if {[catch {set state [$w cget -state]}]} {set state normal}
      if {$state ne {disabled}} {
        if {[catch {set focus [$w cget -takefocus]}]} {set focus no}
        return [expr {![string is boolean -strict $focus] || $focus}]
      }
      break
    }
  }
  return no
}

proc ::apave::focusFirst {w {dofocus yes} {res {}}} {
  # Sets a focus on a first widget of a parent widget.
  #  w - the parent widget
  #  dofocus - if no, means "only return the widget's path"
  #  res - used for recursive call
  # Returns a path to a focused widget or "".

  if {$w ne {}} {
    foreach w [winfo children $w] {
      if {[focusedWidget $w]} {
        if {$dofocus} {after 200 "catch {focus -force $w}"}
        return $w
      } else {
        if {[set res [focusFirst $w $dofocus]] ne {}} break
      }
    }
  }
  return $res
}

proc ::apave::getAppIcon {} {
  # Gets application's icon.

  variable _AP_VARS
  return $_AP_VARS(APPICON)
}

proc ::apave::getN {sn {defn 0} {min {}} {max {}}} {
  # Gets a number from a string
  #   sn - string containing a number
  #   defn - default value when sn is not a number
  #   min - minimal value allowed
  #   max - maximal value allowed

  if {$sn eq "" || [catch {set sn [expr {$sn}]}]} {set sn $defn}
  if {$max ne ""} {
    set sn [expr {min($max,$sn)}]
  }
  if {$min ne ""} {
    set sn [expr {max($min,$sn)}]
  }
  return $sn
}

proc ::apave::getOption {optname args} {
  # Extracts one option from an option list.
  #   optname - option name
  #   args - option list
  # Returns an option value or "".
  # Example:
  #     set options [list -name some -value "any value" -tip "some tip"]
  #     set optvalue [::apave::getOption -tip {*}$options]

  set optvalue [lindex [::apave::parseOptions $args $optname ""] 0]
  return $optvalue
}

proc ::apave::getProperty {name {defvalue {}}} {
  # Gets a property's value as "application-wide".
  #   name - name of property
  #   defvalue - default value
  # If the property had been set, the method returns its value.
  # Otherwise, the method returns the default value (`$defvalue`).

  variable _AP_Properties
  if {[info exists _AP_Properties($name)]} {
    return $_AP_Properties($name)
  }
  return $defvalue
}

proc ::apave::getTextHotkeys {key} {
  # Gets upper & lower keys for a hot key.
  #   key - the hot key

  variable _AP_VARS
  if {![info exist _AP_VARS(KEY,$key)]} {return [list]}
  set keys $_AP_VARS(KEY,$key)
  if {[llength $keys]==1} {
    if {[set i [string last - $keys]]>0} {
      set lt [string range $keys $i+1 end]
      if {[string length $lt]==1} {  ;# for lower case of letters
        set keys "[string range $keys 0 $i][string toupper $lt]"
        lappend keys "[string range $keys 0 $i][string tolower $lt]"
      }
    }
  }
  return $keys
}

proc ::apave::HomeDir {} {
  # For Tcl 9.0 & Windows: gets a home directory ("~").

  if {[catch {set hd [file home]}]} {
    if {[info exists ::env(HOME)]} {set hd $::env(HOME)} {set hd ~}
  }
  return $hd
}

proc ::apave::iconData {{icon info} {iconset {}}} {
  # Gets an icon's data.
  #   icon - icon's name
  #   iconset - one of small/middle/large
  # Returns data of the icon.

  variable _AP_IMG
  iconImage -init
  if {$iconset ne {} && "_AP_IMG(img$icon-$iconset)" in [image names]} {
    return [set _AP_IMG($icon-$iconset)]
  }
  set _AP_IMG($icon)
}

proc ::apave::iconifyOption {args} {
  # Gets/sets "-iconify" option.
  #   args - if contains no arguments, gets "-iconify" option; otherwise sets it
  # Option values mean:
  #   none - do nothing: no withdraw/deiconify
  #   Linux - do withdraw/deiconify for Linux
  #   Windows - do withdraw/deiconify for Windows
  #   default - do withdraw/deiconify depending on the platform
  # See also: withdraw, deiconify

  if {[llength $args]} {
    set iconify [::apave::obj setShowOption -iconify $args]
  } else {
    set iconify [::apave::obj getShowOption -iconify]
  }
  return $iconify
}

proc ::apave::iconImage {{icon {}} {iconset small} {doit no}} {
  # Gets a defined icon's image or list of icons.
  # If *icon* equals to "-init", initializes apave's icon set.
  #   icon - icon's name
  #   iconset - one of small/middle/large
  #   doit - force the initialization
  # Returns the icon's image or, if *icon* is blank, a list of icons
  # available in *apave*.

  variable _AP_IMG
  variable _AP_ICO
  if {$icon eq {}} {return $_AP_ICO}
  ; proc imagename {icon} {   # Get a defined icon's image name
    return _AP_IMG(img$icon)
  }
  variable apaveDir
  if {![array size _AP_IMG] || $doit} {
    # Make images of icons
    source [file join $apaveDir apaveimg.tcl]
    if {$iconset ne "small"} {
      foreach ic $_AP_ICO {  ;# small icons best fit for menus
        set _AP_IMG($ic-small) [set _AP_IMG($ic)]
      }
      if {$iconset eq "middle"} {
        source [file join $apaveDir apaveimg2.tcl]
      } else {
        source [file join $apaveDir apaveimg2.tcl] ;# TODO
      }
    }
    foreach ic $_AP_ICO {
      if {[catch {image create photo [imagename $ic] -data [set _AP_IMG($ic)]}]} {
        # some png issues on old Tk
        image create photo [imagename $ic] -data [set _AP_IMG(none)]
      } elseif {$iconset ne "small"} {
        image create photo [imagename $ic-small] -data [set _AP_IMG($ic-small)]
      }
    }
  }
  if {$icon eq "-init"} {return $_AP_ICO} ;# just to get to icons
  if {$icon ni $_AP_ICO} {set icon [lindex $_AP_ICO 0]}
  if {$iconset eq "small" && "_AP_IMG(img$icon-small)" in [image names]} {
    set icon $icon-small
  }
  return [imagename $icon]
}

proc ::apave::InfoFind {w modal} {
  # Searches data of a window in a list of registered windows.
  #   w - root window's path
  #   modal - yes, if the window is modal
  # Returns: the window's path or "" if not found.
  # See also: InfoWindow

  variable _PU_opts
  foreach winfo [lrange $_PU_opts(_MODALWIN_) 1 end] {  ;# skip 1st window
    incr i
    lassign $winfo w1 var1 modal1
    if {[winfo exists $w1]} {
      if {$w eq $w1 && ($modal && $modal1 || !$modal && !$modal1)} {
        return $w1
      }
    } else {
      catch {set _PU_opts(_MODALWIN_) [lreplace $_PU_opts(_MODALWIN_) $i $i]}
    }
  }
  return {}
}

proc ::apave::InfoWindow {{val {}} {w .} {modal no} {var {}} {regist no}} {
  # Registers/unregisters windows. Also sets/gets 'count of open modal windows'.
  #   val - current number of open modal windows
  #   w - root window's path
  #   modal - yes, if the window is modal
  #   var - variable's name for tkwait
  #   regist - yes or no for registering/unregistering
  # See also: APaveBase::showWindow

  variable _PU_opts
  if {$modal || $regist} {
    set info [list $w $var $modal]
    set i [lsearch -exact $_PU_opts(_MODALWIN_) $info]
    catch {set _PU_opts(_MODALWIN_) [lreplace $_PU_opts(_MODALWIN_) $i $i]}
    if {$regist} {
      lappend _PU_opts(_MODALWIN_) $info
    }
    set res [IntStatus . MODALS $val]
  } else {
    set res [IntStatus . MODALS]
  }
  return $res
}

proc ::apave::InitAwThemesPath {libdir} {
  # Initializes the path to awthemes package.
  #   libdir - root directory of themes (where 'theme' subdirectory is)

  global auto_path
  set awpath [file join $libdir theme awthemes-10.4.0]
  if {[lindex $auto_path 0] ne $awpath} {
    set auto_path [linsert $auto_path 0 $awpath]
  }
}

proc ::apave::initBaltip {} {
  # Initializes baltip package.

  if {[info command ::baltip] eq {}} {
    if {$::apave::ISBALTIP} {
      source [file join $::apave::SRCDIR baltip baltip.tcl]
    } else {
      # disabling baltip facilities with stub proc (no source "baltip.src")
      namespace eval ::baltip {
        variable expproc [list configure cget tip update hide repaint  optionlist tippath clear sleep showBalloon showTip]
        foreach _ $expproc {
        ; proc $_ {args} {return {}}
          namespace export $_
        }
        namespace ensemble create
        namespace eval my {
        ; proc BindToEvent {args} {}
        }
      }
    }
  }
}

proc ::apave::initPOP {w} {
  # Initializes system popup menu (if possible) to call it in a window.
  #   w - window's name

  bind $w <KeyPress> {
    if {"%K" eq "Menu"} {
      if {[winfo exists [set w [focus]]]} {
        event generate $w <Button-3> -rootx [winfo pointerx .]  -rooty [winfo pointery .]
      }
    }
  }
}

proc ::apave::initStyle {wt wbase args} {
  # Initializes a style for a widget type, e.g. button's.
  #   wt - target widget type
  #   wbase - base widget type
  #   args - options of the style

  ttk::style configure $wt {*}[ttk::style configure $wbase]
  ttk::style configure $wt {*}$args
  ttk::style map       $wt {*}[ttk::style map $wbase]
  ttk::style layout    $wt [ttk::style layout $wbase]
}

proc ::apave::initStyles {} {
  # Initializes miscellaneous styles, e.g. button's.

  obj create_Fonts
  initStyle TButtonWest TButton -anchor w -font $::apave::FONTMAIN
  initStyle TButtonBold TButton -font $::apave::FONTMAINBOLD
  initStyle TButtonWestBold TButton -anchor w -font $::apave::FONTMAINBOLD
  initStyle TButtonWestHL TButton -anchor w -foreground [lindex [obj csGet] 4]
  initStyle TMenuButtonWest TMenubutton -anchor w -font $::apave::FONTMAIN -relief raised
  initStyle TreeNoHL Treeview -borderwidth 0
  lassign [obj csGet] - - - - thlp tbgS tfgS - - bclr
  ttk::style map TreeNoHL {*}[ttk::style map Treeview]  -foreground [list {selected focus} $tfgS {selected !focus} $tfgS]  -background [list {selected focus} $tbgS {selected !focus} $tbgS]
}

proc ::apave::initStylesFS {args} {
  # Initializes miscellaneous styles, e.g. button's.
  #   args - font options ("name value" pairs)

  ::apave::obj create_Fonts
  set font  "$::apave::FONTMAIN $args"
  set fontB "$::apave::FONTMAINBOLD $args"

  initStyle TLabelFS TLabel -font $font
  initStyle TCheckbuttonFS TCheckbutton -font $font
  initStyle TComboboxFS TCombobox -font $font
  initStyle TRadiobuttonFS TRadiobutton -font $font
  initStyle TButtonWestFS TButton -anchor w -font $font
  initStyle TButtonBoldFS TButton -font $fontB
  initStyle TButtonWestBoldFS TButton -anchor w -font $fontB
}

proc ::apave::InitTheme {intheme libdir} {
  # Initializes app's theme.
  #   intheme - name of the theme
  #   libdir - root directory of themes (where 'theme' subdirectory is)
  # Returns a list of theme name and label's border (for status bar).
  # The returned values are used in ::apave::initWM procedure.

  set theme {}
  switch -glob -- $intheme {
    azure* - sun-valley* {
      set i [string last - $intheme]
      set name [string range $intheme 0 $i-1]
      set type [string range $intheme $i+1 end]
      catch {source [file join $libdir theme $name $name.tcl]}
      catch {
        set_theme $type
        set theme $intheme
      }
      set lbd 0
    }
    forest* {
      set i [string last - $intheme]
      set name [string range $intheme 0 $i-1]
      set type [string range $intheme $i+1 end]
      catch {
        source [file join $libdir theme $name $intheme.tcl]
        set theme $intheme
      }
      set lbd 0
    }
    awdark - awlight {
      catch {package forget ttk::theme::$intheme}
      catch {namespace delete ttk::theme::$intheme}
      catch {package forget awthemes}
      catch {namespace delete awthemes}
      InitAwThemesPath $libdir
      package require awthemes
      package require ttk::theme::$intheme
      set theme $intheme
      set lbd 1
    }
    plastik - lightbrown - darkbrown {
      set path [file join $libdir theme $intheme]
      source [file join $path $intheme.tcl]
      set theme $intheme
      set lbd 1
    }
    default {
      set theme $intheme
      set lbd 1
    }
  }
  list $theme $lbd
}

proc ::apave::initWM {args} {
  # Initializes Tcl/Tk session. Used to be called at the beginning of it.
  #   args - options ("name value" pairs)
  # If args eq "?", return a flag "need to call initWM"

  if {$args eq {?}} {return $::apave::_CS_(initWM)}
  if {!$::apave::_CS_(initWM)} return
  ::apave::withdraw .
  ::apave::place . 0 0 center
  lassign [parseOptions $args -cursorwidth $::apave::cursorwidth -theme default  -buttonwidth -8 -buttonborder 1 -labelborder 0 -padding 1 -cs -2 -isbaltip yes]  cursorwidth theme buttonwidth buttonborder labelborder padding cs ::apave::ISBALTIP
  initBaltip
  if {$theme eq {}} {set theme default}
  if {$cs<-2 || $cs>47} {set cs -2}
  set ::apave::_CS_(initWM) 0
  set ::apave::_CS_(CURSORWIDTH) $cursorwidth
  set ::apave::_CS_(LABELBORDER) $labelborder
  # for default theme: only most common settings
  set tfg1 $::apave::_CS_(!FG)
  set tbg1 $::apave::_CS_(!BG)
  if {$theme ne {} && [catch {ttk::style theme use $theme}]} {
    catch {ttk::style theme use default}
  }
  ttk::style map .  -selectforeground [list !focus $tfg1 {focus active} $tfg1]  -selectbackground [list !focus $tbg1 {focus active} $tbg1]
  ttk::style configure . -selectforeground	$tfg1 -selectbackground	$tbg1

  # configure separate widget types
  ttk::style configure TButton -anchor center -width $buttonwidth  -relief raised -borderwidth $buttonborder -padding $padding
  ttk::style configure TMenubutton -width 0 -padding 0
  # TLabel's standard style saved for occasional uses
  initStyle TLabelSTD TLabel -anchor w
  # ... TLabel new style
  ttk::style configure TLabel -borderwidth $labelborder -padding $padding
  # ... Treeview colors
  set twfg [ttk::style map Treeview -foreground]
  set twfg [putOption selected $tfg1 {*}$twfg]
  set twbg [ttk::style map Treeview -background]
  set twbg [putOption selected $tbg1 {*}$twbg]
  ttk::style map Treeview -foreground $twfg
  ttk::style map Treeview -background $twbg
  # ... TCombobox colors
  ttk::style map TCombobox -fieldforeground [list {active focus} $tfg1 readonly $tfg1 disabled grey]
  ttk::style map TCombobox -fieldbackground [list {active focus} $tbg1 {readonly focus} $tbg1 {readonly !focus} white]
  initStyles
  initPOP .
  if {$cs!=-2} {obj csSet $cs}
}

proc ::apave::InsertChar {wt ch} {
  # Inserts character(s) into a text at cursor's position.
  #   wt - text's path
  #   ch - character(s)

  $wt insert [$wt index insert] $ch
}

proc ::apave::intInRange {int min max} {
  # Checks whether an integer is in min-max range.
  #   int - the integer
  #   min - minimum of the range
  #   max - maximum of the range

  expr {[string is integer -strict $int] && $int>=$min && $int<=$max}
}

proc ::apave::IntStatus {w {name status} {val {}}} {
  # Sets/gets a status of window. The status is an integer assigned to a name.
  #   w - window's path
  #   name - name of status
  #   val - if blank, to get a value of status; otherwise a value to set
  # Default value of status is 0.
  # Returns an old value of status.
  # See also: WindowStatus

  set old [WindowStatus $w $name {} 0]
  if {$val ne {}} {WindowStatus $w $name $val 1}
  return $old
}

proc ::apave::InvertBg {clr {B #000000} {W #FFFFFF}} {
  # Gets a "inverted" color (white/black) for an color.
  #   clr - color (#hhh or #hhhhhh)
  #   B - "black" color
  #   W - "white" color
  # Returns a list of "black/white" and normalized input color

  if {[string length $clr]==4} {
    lassign [split $clr {}] -> r g b
    set clr #$r$r$g$g$b$b
  }
  lassign [winfo rgb . $clr] r g b
  if {($r%256+$b%256)<15 && ($g%256)>180 || $r+1.5*$g+0.5*$b > 100000} {
    set res $B
  } else {
    set res $W
  }
  list $res $clr
}

proc ::apave::IsRoundInt {i1 i2} {
  # Checks whether an integer equals roundly to other integer.
  #   i1 - integer to compare
  #   i2 - integer to be compared (rounded) to i1

  expr {$i1>($i2-3) && $i1<($i2+3)}
}

proc ::apave::KeyAccelerator {acc} {
  # Returns a key accelerator.
  #   acc - key name, may contain 2 items (e.g. Control-D Control-d)

  set acc [lindex $acc 0]
  string map {Control Ctrl - + bracketleft [ bracketright ]} $acc
}

proc ::apave::LbxSelect {w idx} {
  # Selects a listbox item.
  #   w - listbox's path
  #   idx - item index

  $w activate $idx
  $w see $idx
  if {[$w cget -selectmode] in {single browse}} {
    $w selection clear 0 end
    $w selection set $idx
    event generate $w <<ListboxSelect>>
  }
}

proc ::apave::logMessage {msg {lev 16}} {
  # Logs messages to a log file.
  #   msg - the message
  #   lev - maximum level for [info level] to introspect calls
  # A log file's name is set by _PU_opts(_LOGFILE_). If it's blank,
  # no logging is made.

  variable _PU_opts;
  if {$_PU_opts(_LOGFILE_) eq {}} return
  set chan [open $_PU_opts(_LOGFILE_) a]
  set dt [clock format [clock seconds] -format {%d%b'%y %T}]
  set msg "$dt $msg"
  for {set i $lev} {$i>0} {incr i -1} {
    catch {
      lassign [info level -$i] p1 p2
      if {$p1 eq {my}} {append p1 " $p2"}
      append msg " / $p1"
    }
  }
  puts $chan $msg
  close $chan
  puts "$_PU_opts(_LOGFILE_) - $msg"
}

proc ::apave::logName {fname} {
  # Sets a log file's name.
  #   fname - file name
  # If fname is {}, disables logging.

  variable _PU_opts;
  set _PU_opts(_LOGFILE_) [file normalize $fname]
}

proc ::apave::lsearchFile {flist fname} {
  # Searches a file name in a list, using normalized file names.
  #   flist - list of file names
  #   fname - file name to find
  # Returns an index of found file name or -1 if it's not found.

  set i 0
  set fname [file normalize $fname]
  foreach fn $flist {
    if {[file normalize $fn] eq $fname} {
      return $i
    }
    incr i
  }
  return -1
}

proc ::apave::mainWindowOfApp {{win {}}} {
  # Sets/gets a main window of application.
  #   win - window's path
  # This should be run at application start, before opening any window.

  WindowStatus . MAIN_WINDOW_OF_APP $win
}

proc ::apave::mc {msg} {
  # Gets a localized version of a message.
  #   msg - the message

  variable _MC_
  if {[info exists _MC_($msg)]} {return $_MC_($msg)}
  return $msg
}

proc ::apave::MouseOnWidget {w1} {
  # Places the mouse pointer on a widget.
  #   w1 - the widget's path

  update
  set w2 [winfo parent $w1]
  set w3 [winfo parent $w2]
  lassign [split [winfo geometry $w1] +x] w h x1 y1
  lassign [split [winfo geometry $w2] +x] - - x2 y2
  event generate $w3 <Motion> -warp 1  -x [expr {$x1+$x2+int($w/2)}] -y [expr {$y1+$y2+int($h/2)}]
}

proc ::apave::msgcatDialogs {} {
  # Prepares localized messages used in dialogues.

  variable msgarray
  foreach n [array names msgarray] {
    set msgarray($n) [msgcat::mc $msgarray($n)]
  }
}

proc ::apave::None {args} {
  # Useful when to do nothing is better than to do something.
}

proc ::apave::NormalizeFileName {name} {
  # Removes spec.characters from a file/dir name (sort of normalizing it).
  #   name - the name of file/dir

  set name [string trim $name]
  string map [list  * _ ? _ ~ _ / _ \\ _ \{ _ \} _ \[ _ \] _ \t _ \n _ \r _  | _ < _ > _ & _ , _ : _ \; _ \" _ ' _ ` _] $name
}

proc ::apave::NormalizeName {name} {
  # Removes spec.characters from a name (sort of normalizing it).
  #   name - the name

  string map [list \\ {} \{ {} \} {} \[ {} \] {} \t {} \n {} \r {} \" {}] $name
}

proc ::apave::obj {com args} {
  # Calls a method of APave class.
  #   com - a method
  #   args - arguments of the method
  # It can (and must) be used only for temporary tasks.
  # For persistent tasks, use a "normal" apave object.
  # Returns the command's result.

  variable _OBJ_
  if {$_OBJ_ eq {}} {set _OBJ_ [::apave::APave new]}
  if {[set exported [expr {$com eq "EXPORT"}]]} {
    set com [lindex $args 0]
    set args [lrange $args 1 end]
    oo::objdefine $_OBJ_ "export $com"
  }
  set res [$_OBJ_ $com {*}$args]
  if {$exported} {
    oo::objdefine $_OBJ_ "unexport $com"
  }
  return $res
}

proc ::apave::openDoc {url} {
  # Opens a document.
  #   url - document's file name, www link, e-mail etc.

  set commands {xdg-open open start}
  foreach opener $commands {
    if {$opener eq "start"} {
      set command [list {*}[auto_execok start] {}]
    } else {
      set command [auto_execok $opener]
    }
    if {[string length $command]} {
      break
    }
  }
  if {[string length $command] == 0} {
    puts "ERROR: couldn't find any opener"
  }
  # remove the tailing " &" (as e_menu can set)
  set url [string trimright $url]
  if {[string match "* &" $url]} {set url [string range $url 0 end-2]}
  set url [string trim $url]
  if {[catch {exec -- {*}$command $url &} error]} {
    puts "ERROR: couldn't execute '$command':\n$error"
  }
}

proc ::apave::p+ {p1 p2} {
  # Sums two text positions straightforward: lines & columns separately.
  #   p1 - 1st position
  #   p2 - 2nd position
  # The lines may be with "-".
  # Reasons for this:
  #  1. expr $p1+$p2 doesn't work, e.g. 309.10+1.4=310.5 instead of 310.14
  #  2. do it without a text widget's path (for text's arithmetic)

  lassign [split $p1 .] l11 c11
  lassign [split $p2 .] l21 c21
  foreach n {l11 c11 l21 c21} {
    if {![string is digit -strict [string trimleft [set $n] -]]} {set $n 0}
  }
  return [incr l11 $l21].[incr c11 $c21]
}

proc ::apave::parseOptions {opts args} {
  # Parses argument list containing options.
  #  opts - list of options and values
  #  args - list of "option / default value" pairs
  # It's the same as parseOptionsFile, excluding the file name stuff.
  # Returns a list of options' values, according to args.
  # See also: parseOptionsFile

  lassign [::apave::parseOptionsFile 0 $opts {*}$args] tmp
  foreach {nam val} $tmp {
    lappend retlist $val
  }
  return $retlist
}

proc ::apave::parseOptionsFile {strict inpargs args} {
  # Parses argument list containing options and (possibly) a file name.
  #   strict - if 0, 'args' options will be only counted for,
  #              other options are skipped
  #   strict - if 1, only 'args' options are allowed,
  #              all the rest of inpargs to be a file name
  #          - if 2, the 'args' options replace the
  #              appropriate options of 'inpargs'
  #   inpargs - list of options, values and a file name
  #   args  - list of default options
  #
  # The inpargs list contains:
  #   - option names beginning with "-"
  #   - option values following their names (may be missing)
  #   - "--" denoting the end of options
  #   - file name following the options (may be missing)
  #
  # The *args* parameter contains the pairs:
  #   - option name (e.g., "-dir")
  #   - option default value
  #
  # If the *args* option value is equal to =NONE=, the *inpargs* option
  # is considered to be a single option without a value and,
  # if present in inpargs, its value is returned as "yes".
  #
  # If any option of *inpargs* is absent in *args* and strict==1,
  # the rest of *inpargs* is considered to be a file name.
  #
  # The proc returns a list of two items:
  #   - an option list got from args/inpargs according to 'strict'
  #   - a file name from inpargs or {} if absent
  #
  # Examples see in tests/obbit.test.

  variable _PU_opts
  set actopts true
  array set argarray "$args yes yes" ;# maybe, tail option without value
  if {$strict==2} {
    set retlist $inpargs
  } else {
    set retlist $args
  }
  set retfile {}
  for {set i 0} {$i < [llength $inpargs]} {incr i} {
    set parg [lindex $inpargs $i]
    if {$actopts} {
      if {$parg eq "--"} {
        set actopts false
      } elseif {[catch {set defval $argarray($parg)}]} {
        if {$strict==1} {
          set actopts false
          append retfile $parg " "
        } else {
          incr i
        }
      } else {
        if {$strict==2} {
          if {$defval == $_PU_opts(-NONE)} {
            set defval yes
          }
          incr i
        } else {
          if {$defval == $_PU_opts(-NONE)} {
            set defval yes
          } else {
            set defval [lindex $inpargs [incr i]]
          }
        }
        set ai [lsearch -exact $retlist $parg]
        incr ai
        set retlist [lreplace $retlist $ai $ai $defval]
      }
    } else {
      append retfile $parg " "
    }
  }
  list $retlist [string trimright $retfile]
}

proc ::apave::pint {pos} {
  # Gets int part of text position, e.g. "4" for "4.end".
  #   pos - position in text

  if {[set i [string first . $pos]]>0} {incr i -1} {set i end}
  expr {int([string range $pos 0 $i])}
}

proc ::apave::place {path w h args} {
  update idletasks

  # If the window is not mapped, it may have any current size.
  # Then use required size, but bound it to the screen width.
  # This is mostly inexact, because any toolbars will still be removed
  # which may reduce size.
  if { $w == 0 && [winfo ismapped $path] } {
    set w [winfo width $path]
  } else {
    if { $w == 0 } {
      set w [winfo reqwidth $path]
    }
    set vsw [winfo vrootwidth  $path]
    if { $w > $vsw } { set w $vsw }
  }

  if { $h == 0 && [winfo ismapped $path] } {
    set h [winfo height $path]
  } else {
    if { $h == 0 } {
      set h [winfo reqheight $path]
    }
    set vsh [winfo vrootheight $path]
    if { $h > $vsh } { set h $vsh }
  }

  set arglen [llength $args]
  if { $arglen > 3 } {
    return -code error "apave::place: bad number of argument"
  }

  if { $arglen > 0 } {
    set where [lindex $args 0]
    set list  [list at center left right above below]
    set idx   [lsearch $list $where]
    if { $idx == -1 } {
      return -code error "apave::place: bad position: $where $list"
    }
    if { $idx == 0 } {
      set err [catch {
        # purposely removed the {} around these expressions - [PT]
        set x [expr int([lindex $args 1])]
        set y [expr int([lindex $args 2])]
      } e]
      if { $err } {
        return -code error "apave::place: bad position: $e"
      }
      if {$::tcl_platform(platform) eq {windows}} {
        # handle windows multi-screen. -100 != +-100
        if {[string index [lindex $args 1] 0] ne {-}} {
          set x +$x
        }
        if {[string index [lindex $args 2] 0] ne {-}} {
          set y +$y
        }
      } else {
        if { $x >= 0 } {
          set x +$x
        }
        if { $y >= 0 } {
          set y +$y
        }
      }
    } else {
      if { $arglen == 2 } {
        set widget [lindex $args 1]
        if { ![winfo exists $widget] } {
          return -code error "apave::place: \"$widget\" does not exist"
        }
      } else {
        set widget .
      }
      set sw [winfo screenwidth  $path]
      set sh [winfo screenheight $path]
      if { $idx == 1 } {
        if { $arglen == 2 } {
          # center to widget
          set x0 [expr {[winfo rootx $widget] + ([winfo width  $widget] - $w)/2}]
          set y0 [expr {[winfo rooty $widget] + ([winfo height $widget] - $h)/2}]
        } else {
          # center to screen
          set x0 [expr {($sw - $w)/2 - [winfo vrootx $path]}]
          set y0 [expr {($sh - $h)/2 - [winfo vrooty $path]}]
        }
        set x +$x0
        set y +$y0
        if {$::tcl_platform(platform) ne {windows}} {
          if { $x0+$w > $sw } {set x {-0}; set x0 [expr {$sw-$w}]}
          if { $x0 < 0 }      {set x {+0}}
          if { $y0+$h > $sh } {set y {-0}; set y0 [expr {$sh-$h}]}
          if { $y0 < 0 }      {set y {+0}}
        }
      } else {
        set x0 [winfo rootx $widget]
        set y0 [winfo rooty $widget]
        set x1 [expr {$x0 + [winfo width  $widget]}]
        set y1 [expr {$y0 + [winfo height $widget]}]
        if { $idx == 2 || $idx == 3 } {
          set y +$y0
          if {$::tcl_platform(platform) ne {windows}} {
            if { $y0+$h > $sh } {set y {-0}; set y0 [expr {$sh-$h}]}
            if { $y0 < 0 }      {set y {+0}}
          }
          if { $idx == 2 } {
            # try left, then right if out, then 0 if out
            if { $x0 >= $w } {
              set x [expr {$x0-$w}]
            } elseif { $x1+$w <= $sw } {
              set x +$x1
            } else {
              set x {+0}
            }
          } else {
            # try right, then left if out, then 0 if out
            if { $x1+$w <= $sw } {
              set x +$x1
            } elseif { $x0 >= $w } {
              set x [expr {$x0-$w}]
            } else {
              set x {-0}
            }
          }
        } else {
          set x +$x0
          if {$::tcl_platform(platform) ne {windows}} {
            if { $x0+$w > $sw } {set x {-0}; set x0 [expr {$sw-$w}]}
            if { $x0 < 0 }      {set x {+0}}
          }
          if { $idx == 4 } {
            # try top, then bottom, then 0
            if { $h <= $y0 } {
              set y [expr {$y0-$h}]
            } elseif { $y1+$h <= $sh } {
              set y +$y1
            } else {
              set y {+0}
            }
          } else {
            # try bottom, then top, then 0
            if { $y1+$h <= $sh } {
              set y +$y1
            } elseif { $h <= $y0 } {
              set y [expr {$y0-$h}]
            } else {
              set y {-0}
            }
          }
        }
      }
    }

    ## If there's not a + or - in front of the number, we need to add one.
    if {[string is integer [string index $x 0]]} { set x +$x }
    if {[string is integer [string index $y 0]]} { set y +$y }

    wm geometry $path "${w}x${h}${x}${y}"
  } else {
    wm geometry $path "${w}x${h}"
  }
  update idletasks
}

proc ::apave::precedeWidgetName {widname prename} {
  # Adds a preceding name to a tail name of widget.
  #   widname - widget's full name
  #   prename - preceding name
  # Useful at getting a entry/button name of chooser.

  # Example:
  #   set wentry [::apave::precedeWidgetName [$pobj DirToChoose] ent]
  # See also: APaveBase::Replace_chooser

  set p [string last . $widname]
  set res [string range $widname 0 $p]
  append res $prename [string range $widname $p+1 end]
  return $res
}

proc ::apave::PushInList {listName item {pos 0} {max 16}} {
  # Pushes an item in a list: deletes an old instance, inserts a new one.
  #   listName - the list's variable name
  #   item - item to push
  #   pos - position in the list to push in
  #   max - maximum length of the list

  upvar $listName ln
  if {[set i [lsearch -exact $ln $item]]>-1} {
    set ln [lreplace $ln $i $i]
  }
  set ln [linsert $ln $pos $item]
  catch {set ln [lreplace $ln $max end]}
}

proc ::apave::putOption {optname optvalue args} {
  # Replaces or adds one option to an option list.
  #   optname - option name
  #   optvalue - option value
  #   args - option list
  # Returns an updated option list.

  set optlist {}
  set doadd true
  foreach {a v} $args {
    if {$a eq $optname} {
      set v $optvalue
      set doadd false
    }
    lappend optlist $a $v
  }
  if {$doadd} {lappend optlist $optname $optvalue}
  return $optlist
}

proc ::apave::readTextFile {fname {varName {}} {doErr 0} args} {
  # Reads a text file.
  #   fname - file name
  #   varName - variable name for file content or ""
  #   doErr - if 'true', exit at errors with error message
  # Returns file contents or "".

  variable _PU_opts
  if {$varName ne {}} {upvar $varName fvar}
  if {[catch {set chan [open $fname]} _PU_opts(_ERROR_)]} {
    if {$doErr} {error [::apave::error $fname]}
    set fvar {}
  } else {
    set enc [::apave::getOption -encoding {*}$args]
    set eol [string tolower [::apave::getOption -translation {*}$args]]
    if {$eol eq {}} {set eol auto} ;# let EOL be autodetected by default
    ::apave::textChanConfigure $chan $enc $eol
    set fvar [read $chan]
    close $chan
    logMessage "read $fname"
  }
  return $fvar
}

proc ::apave::removeOptions {opts args} {
  # Removes some options from a list of options.
  #   opts - list of options and values
  #   args - list of option names to remove
  # The `opts` may contain "key value" pairs and "alone" options
  # without values.
  # To remove "key value" pairs, `key` should be an exact name.
  # To remove an "alone" option, `key` should be a glob pattern with `*`.

  foreach key $args {
    while {[incr maxi]<99} {
      if {[set i [lsearch -exact $opts $key]]>-1} {
        catch {
          # remove a pair "option value"
          set opts [lreplace $opts $i $i]
          set opts [lreplace $opts $i $i]
        }
      } elseif {[string first * $key]>=0 &&  [set i [lsearch -glob $opts $key]]>-1} {
        # remove an option only
        set opts [lreplace $opts $i $i]
      } else {
        break
      }
    }
  }
  return $opts
}

proc ::apave::repaintWindow {win {wfoc {}}} {
  # Shows a window and, optionally, focuses on a widget of it.
  #   win - the window's path
  #   wfoc - the widget's path or a command to get it
  # Returns yes, if the window is shown successfully.

  if {[winfo exists $win]} {
    # esp. for KDE
    if {[isKDE]} { ;# KDE is KDE, Tk is Tk, and never the twain shall meet
      wm withdraw $win
      wm deiconify $win
      wm attributes $win -topmost [wm attributes $win -topmost]
    }
    update
    if {$wfoc ne {}} {
      catch {set wfoc [{*}$wfoc]}
      focus $wfoc
    }
    return yes
  }
  return no
}

proc ::apave::RestoreArray {arName arSave} {
  # Tries restoring an array 1:1.
  #   arName - fully qualified array name
  #   arSave - saved array's value (got with "array get")
  # At restoring, new items of $arName are deleted and existing items are updated,
  # so that after restoring *array get $arName* is equal to $arSave.
  # Note: "array unset $arName *; array set $arName $arSave" doesn't ensure this equality.

  set ar $arName
  array set artmp $arSave
  set tmp1 [array names artmp]
  set tmp2 [array names $arName]
  foreach n $tmp2 {
    if {$n ni $tmp1} {unset [set ar]($n)} {set [set ar]($n) $artmp($n)}
  }
  foreach n $tmp1 {
    # deleted items can break 1:1 equality (not the case with alited)
    if {$n ni $tmp2} {set [set ar]($n) $artmp($n)}
  }
}

proc ::apave::rootModalWindow {pwin} {
  # Gets a parent modal window for a given one.
  #   pwin - default parent

  set root $pwin
  foreach w [winfo children $pwin] {
    if {[winfo ismapped $w] && [InfoFind $w yes] ne {}} {
      set root [winfo toplevel $w]
    }
  }
  return $root
}

proc ::apave::setAppIcon {win {winicon {}}} {
  # Sets application's icon.
  #   win - path to a window of application
  #   winicon - data of icon
  # The *winicon* may be a contents of variable (as supposed by default) or
  # a file's name containing th image data.
  # If it fails to find an image in either, no icon is set.

  variable _AP_VARS
  set _AP_VARS(APPICON) {}
  if {$winicon ne {}} {
    if {[catch {set _AP_VARS(APPICON) [image create photo -data $winicon]}]} {
      catch {set _AP_VARS(APPICON) [image create photo -file $winicon]}
    }
  }
  if {$_AP_VARS(APPICON) ne {}} {wm iconphoto $win -default $_AP_VARS(APPICON)}
}

proc ::apave::setProperty {name args} {
  # Sets a property's value as "application-wide".
  #   name - name of property
  #   args - value of property
  # If *args* is omitted, the method returns a property's value.
  # If *args* is set, the method sets a property's value as $args.

  variable _AP_Properties
  switch -exact [llength $args] {
    0 {return [getProperty $name]}
    1 {return [set _AP_Properties($name) [lindex $args 0]]}
  }
  puts -nonewline stderr  "Wrong # args: should be \"::apave::setProperty propertyname ?value?\""
  return -code error
}

proc ::apave::setTextHotkeys {key value} {
  # Sets new key combinations for some operations on text widgets.
  #   key - ctrlD for "double selection", ctrlY for "delete line" operation
  #   value - list of new key combinations

  variable _AP_VARS
  set _AP_VARS(KEY,$key) $value
}

proc ::apave::setTextIndent {len {padchar { }}} {
  # Sets an indenting for text widgets.
  #   len - length of indenting
  #   padchar - indenting character

  variable _AP_VARS
  if {$padchar ne "\t"} {set padchar { }}
  set _AP_VARS(INDENT) [string repeat $padchar $len]
}

proc ::apave::splitGeometry {geom {X +0} {Y +0}} {
  # Gets widget's geometry components.
  #   geom - geometry
  #   X - default X-coordinate
  #   Y - default Y-coordinate
  # Returns a list of width, height, X and Y (coordinates are always with + or -)
  # and also a flag "negative coordinates, calculated from bottom right".

  lassign [split $geom x+-] w h
  lassign [regexp -inline -all {([+-][[:digit:]]+)} $geom] -> x y
  if {$geom ne {}} {
    if {$x in {"" 0} || [catch {expr {$x+0}}]} {set x $X}
    if {$y in {"" 0} || [catch {expr {$y+0}}]} {set y $Y}
  }
  set neg [expr {[string first - $geom]>=0 && [string first + $geom]<0}]
  list $w $h $x $y $neg
}

proc ::apave::textChanConfigure {channel {coding {}} {eol {}}} {
  # Configures a channel for text file.
  #   channel - the channel
  #   coding - if set, defines encoding of the file
  #   eol - if set, defines EOL of the file

  if {$coding eq {}} {
    chan configure $channel -encoding utf-8
  } else {
    chan configure $channel -encoding $coding
  }
  if {$eol eq {}} {
    chan configure $channel {*}[::apave::textEOL translation]
  } else {
    chan configure $channel -translation $eol
  }
}

proc ::apave::textEOL {{EOL -}} {
  # Gets/sets End-of-Line for text reqding/writing.
  #   EOL - LF, CR, CRLF or {}
  # If EOL omitted or equals to {} or "-", return the current EOL.
  # If EOL equals to "translation", return -translation option or {}.

  variable _PU_opts
  if {$EOL eq "-"} {return $_PU_opts(_EOL_)}
  if {$EOL eq "translation"} {
    if {$_PU_opts(_EOL_) eq ""} {return ""}
    return "-translation $_PU_opts(_EOL_)"
  }
  set _PU_opts(_EOL_) [string trim [string tolower $EOL]]
}

proc ::apave::textsplit {textcont} {
  # Splits a text's contents by EOLs. Those inventors of EOLs...
  #   textcont - text's contents

  split [string map [list \r\n \n \r \n] $textcont] \n
}

proc ::apave::traceRemove {v} {
  # Cancels tracing of a variable.
  #   v - variable's name

  foreach t [trace info variable $v] {
    lassign $t o c
    trace remove variable $v $o $c
  }
}

proc ::apave::TreSelect {w idx} {
  # Selects a treeview item.
  #   w - treeview's path
  #   idx - item index

  set items [$w children {}]
  catch {
    set it [lindex $items $idx]
    $w see $it
    $w focus $it
    $w selection set $it  ;# generates <<TreeviewSelect>>
  }
}

proc ::apave::ttkToolbutton {} {
  # Initializes Toolbutton's style, depending on CS.
  # Creates also btt / brt / blt widget types to be paved,
  # with images top / right / left accordingly.

  lassign [obj csGet] fg1 - bg1
  ttk::style map Toolbutton {*}[dict replace [ttk::style map Toolbutton]  -foreground "pressed $fg1 active $fg1" -background "pressed $bg1 active $bg1"]
  defaultAttrs btt {} {-style Toolbutton -compound top -takefocus 0} ttk::button
  defaultAttrs brt {} {-style Toolbutton -compound right -takefocus 0} ttk::button
  defaultAttrs blt {} {-style Toolbutton -compound left -takefocus 0} ttk::button
}

proc ::apave::undoIn {wtxt} {
  # Enters a block of undo/redo for a text widget.
  #   wtxt - text widget's path
  # Run before massive changes of the text, to have Undo/Redo done at one blow.
  # See also: undoOut

  $wtxt configure -autoseparators no
  $wtxt edit separator
}