PC World Komputer 1999 March B/SCO_CASTOR4RRT.iso/scoadmin/root.1/usr/lib/sysadm.tlib/sysadm

Text File | 1998-08-19 | 202KB | 6,413 lines

# Copyright (c) 1991-1998 The Santa Cruz Operation, Inc.. All Rights Reserved.
#
#        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF THE
#                   SANTA CRUZ OPERATION INC.
#
#   The copyright notice above does not evidence any actual or intended
#   publication of such source code.

#******************************************************************************
#
#    Copyright (C) 1991-1998 The Santa Cruz Operation, Inc.
#        All Rights Reserved.
#
#    The information in this file is provided for the exclusive use of
#    the licensees of The Santa Cruz Operation, Inc.  Such users have the
#    right to use, modify, and incorporate this code into other products
#    for purposes authorized by the license agreement provided they include
#    this notice and the associated copyright notice with any such product.
#    The information in this file is provided "AS IS" without warranty.
#
#===============================================================================

#@package: SCO_UNIX_MSGS SCO_UNIX_MSGS

proc SCO_UNIX_MSGS {} {}

global SCO_UNIX_MSGS
set SCO_UNIX_MSGS(@catalog@) {unix.cat@sa 1}
set SCO_UNIX_MSGS(ERR_EPERM) {1 {Not privileged}}
set SCO_UNIX_MSGS(ERR_ENOENT) {2 {No such file or directory}}
set SCO_UNIX_MSGS(ERR_ESRCH) {3 {No such process}}
set SCO_UNIX_MSGS(ERR_EINTR) {4 {Interrupted system call}}
set SCO_UNIX_MSGS(ERR_EIO) {5 {I/O error}}
set SCO_UNIX_MSGS(ERR_ENXIO) {6 {No such device or address}}
set SCO_UNIX_MSGS(ERR_E2BIG) {7 {Arg list too long}}
set SCO_UNIX_MSGS(ERR_ENOEXEC) {8 {Exec format error}}
set SCO_UNIX_MSGS(ERR_EBADF) {9 {Bad file number}}
set SCO_UNIX_MSGS(ERR_ECHILD) {10 {No child processes}}
set SCO_UNIX_MSGS(ERR_EAGAIN) {11 {Resource temporarily unavailable}}
set SCO_UNIX_MSGS(ERR_EWOULDBLOCK) {12 {Resource temporarily unavailable}}
set SCO_UNIX_MSGS(ERR_ENOMEM) {13 {Insufficient or invalid memory}}
set SCO_UNIX_MSGS(ERR_EACCES) {14 {Permission denied}}
set SCO_UNIX_MSGS(ERR_EFAULT) {15 {Bad address}}
set SCO_UNIX_MSGS(ERR_ENOTBLK) {16 {Block device required}}
set SCO_UNIX_MSGS(ERR_EBUSY) {17 {Device busy}}
set SCO_UNIX_MSGS(ERR_EEXIST) {18 {File exists}}
set SCO_UNIX_MSGS(ERR_EXDEV) {19 {Cross-device link}}
set SCO_UNIX_MSGS(ERR_ENODEV) {20 {No such device}}
set SCO_UNIX_MSGS(ERR_ENOTDIR) {21 {Not a directory}}
set SCO_UNIX_MSGS(ERR_EISDIR) {22 {Is a directory}}
set SCO_UNIX_MSGS(ERR_EINVAL) {23 {Invalid argument}}
set SCO_UNIX_MSGS(ERR_ENFILE) {24 {File table overflow}}
set SCO_UNIX_MSGS(ERR_EMFILE) {25 {Too many open files}}
set SCO_UNIX_MSGS(ERR_ENOTTY) {26 {Not a typewriter}}
set SCO_UNIX_MSGS(ERR_ETXTBSY) {27 {Text file busy}}
set SCO_UNIX_MSGS(ERR_EFBIG) {28 {File too large}}
set SCO_UNIX_MSGS(ERR_ENOSPC) {29 {No space left on device}}
set SCO_UNIX_MSGS(ERR_ESPIPE) {30 {Illegal seek}}
set SCO_UNIX_MSGS(ERR_EROFS) {31 {Read-only file system}}
set SCO_UNIX_MSGS(ERR_EMLINK) {32 {Too many links}}
set SCO_UNIX_MSGS(ERR_EPIPE) {33 {Broken pipe}}
set SCO_UNIX_MSGS(ERR_EDOM) {34 {Argument out of domain}}
set SCO_UNIX_MSGS(ERR_ERANGE) {35 {Result too large}}
set SCO_UNIX_MSGS(ERR_ENOMSG) {36 {No message of desired type}}
set SCO_UNIX_MSGS(ERR_EIDRM) {37 {Identifier removed}}
set SCO_UNIX_MSGS(ERR_ECHRNG) {38 {Channel number out of range}}
set SCO_UNIX_MSGS(ERR_EL2NSYNC) {39 {Level 2 not synchronized}}
set SCO_UNIX_MSGS(ERR_EL3HLT) {40 {Level 3 halted}}
set SCO_UNIX_MSGS(ERR_EL3RST) {41 {Level 3 reset}}
set SCO_UNIX_MSGS(ERR_ELNRNG) {42 {Link number out of range}}
set SCO_UNIX_MSGS(ERR_EUNATCH) {43 {Protocol driver not attached}}
set SCO_UNIX_MSGS(ERR_ENOCSI) {44 {No CSI structure available}}
set SCO_UNIX_MSGS(ERR_EL2HLT) {45 {Level 2 halted}}
set SCO_UNIX_MSGS(ERR_EDEADLK) {46 {Deadlock situation detected/avoided}}
set SCO_UNIX_MSGS(ERR_ENOLCK) {47 {No record locks available}}
set SCO_UNIX_MSGS(ERR_EBADE) {48 {Bad exchange descriptor}}
set SCO_UNIX_MSGS(ERR_EBADR) {49 {Bad request descriptor}}
set SCO_UNIX_MSGS(ERR_EXFULL) {50 {Message tables full}}
set SCO_UNIX_MSGS(ERR_ENOANO) {51 {Anode table overflow}}
set SCO_UNIX_MSGS(ERR_EBADRQC) {52 {Bad request code}}
set SCO_UNIX_MSGS(ERR_EBADSLT) {53 {Invalid slot}}
set SCO_UNIX_MSGS(ERR_EDEADLOCK) {54 {File locking deadlock}}
set SCO_UNIX_MSGS(ERR_EBFONT) {55 {Bad font file format}}
set SCO_UNIX_MSGS(ERR_ECLNRACE) {56 {Error 59}}
set SCO_UNIX_MSGS(ERR_ENOSTR) {57 {Not a stream device}}
set SCO_UNIX_MSGS(ERR_ENODATA) {58 {No data available}}
set SCO_UNIX_MSGS(ERR_ETIME) {59 {Timer expired}}
set SCO_UNIX_MSGS(ERR_ENOSR) {60 {Out of stream resources}}
set SCO_UNIX_MSGS(ERR_ENONET) {61 {Machine is not on the network}}
set SCO_UNIX_MSGS(ERR_ENOPKG) {62 {Package not installed}}
set SCO_UNIX_MSGS(ERR_EREMOTE) {63 {Object is remote}}
set SCO_UNIX_MSGS(ERR_ENOLINK) {64 {Link has been severed}}
set SCO_UNIX_MSGS(ERR_EADV) {65 {Advertise error}}
set SCO_UNIX_MSGS(ERR_ESRMNT) {66 {Srmount error}}
set SCO_UNIX_MSGS(ERR_ECOMM) {67 {Communication error on send}}
set SCO_UNIX_MSGS(ERR_EPROTO) {68 {Protocol error}}
set SCO_UNIX_MSGS(ERR_EMULTIHOP) {69 {Multihop attempted}}
set SCO_UNIX_MSGS(ERR_EBADMSG) {70 {Not a data message}}
set SCO_UNIX_MSGS(ERR_ENAMETOOLONG) {71 {File name too long}}
set SCO_UNIX_MSGS(ERR_EOVERFLOW) {72 {Value too large for defined data type}}
set SCO_UNIX_MSGS(ERR_ENOTUNIQ) {73 {Name not unique on network}}
set SCO_UNIX_MSGS(ERR_EBADFD) {74 {File descriptor in bad state}}
set SCO_UNIX_MSGS(ERR_EREMCHG) {75 {Remote address changed}}
set SCO_UNIX_MSGS(ERR_ELIBACC) {76 {Can not access a needed shared library}}
set SCO_UNIX_MSGS(ERR_ELIBBAD) {77 {Accessing a corrupted shared library}}
set SCO_UNIX_MSGS(ERR_ELIBSCN) {78 {.lib section in a.out corrupted}}
set SCO_UNIX_MSGS(ERR_ELIBMAX) {79 {Attempting to link in more shared libraries than system limit}}
set SCO_UNIX_MSGS(ERR_ELIBEXEC) {80 {Can not exec a shared library directly}}
set SCO_UNIX_MSGS(ERR_EILSEQ) {81 {Illegal byte sequence}}
set SCO_UNIX_MSGS(ERR_ENOSYS) {82 {Operation not applicable}}
set SCO_UNIX_MSGS(ERR_ELOOP) {83 {Too many symbolic links in path name traversal}}
set SCO_UNIX_MSGS(ERR_ERESTART) {84 {Restartable system call}}
set SCO_UNIX_MSGS(ERR_ESTRPIPE) {85 {Streams pipe error}}
set SCO_UNIX_MSGS(ERR_ENOTEMPTY) {86 {Directory not empty}}
set SCO_UNIX_MSGS(ERR_EUSERS) {87 {Too many users}}
set SCO_UNIX_MSGS(ERR_ENOTSOCK) {88 {Socket operation on non-socket}}
set SCO_UNIX_MSGS(ERR_EDESTADDRREQ) {89 {Destination address required}}
set SCO_UNIX_MSGS(ERR_EMSGSIZE) {90 {Message too long}}
set SCO_UNIX_MSGS(ERR_EPROTOTYPE) {91 {Protocol wrong type for socket}}
set SCO_UNIX_MSGS(ERR_ENOPROTOOPT) {92 {Option not supported by protocol}}
set SCO_UNIX_MSGS(ERR_EPROTONOSUPPORT) {93 {Protocol not supported}}
set SCO_UNIX_MSGS(ERR_ESOCKTNOSUPPORT) {94 {Socket type not supported}}
set SCO_UNIX_MSGS(ERR_EOPNOTSUPP) {95 {Operation not supported on transport endpoint}}
set SCO_UNIX_MSGS(ERR_EPFNOSUPPORT) {96 {Protocol family not supported}}
set SCO_UNIX_MSGS(ERR_EAFNOSUPPORT) {97 {Address family not supported by protocol family}}
set SCO_UNIX_MSGS(ERR_EADDRINUSE) {98 {Address already in use}}
set SCO_UNIX_MSGS(ERR_EADDRNOTAVAIL) {99 {Cannot assign requested address}}
set SCO_UNIX_MSGS(ERR_ENETDOWN) {100 {Network is down}}
set SCO_UNIX_MSGS(ERR_ENETUNREACH) {101 {Network is unreachable}}
set SCO_UNIX_MSGS(ERR_ENETRESET) {102 {Network dropped connection because of reset}}
set SCO_UNIX_MSGS(ERR_ECONNABORTED) {103 {Software caused connection abort}}
set SCO_UNIX_MSGS(ERR_ECONNRESET) {104 {Connection reset by peer}}
set SCO_UNIX_MSGS(ERR_ENOBUFS) {105 {No buffer space available}}
set SCO_UNIX_MSGS(ERR_EISCONN) {106 {Transport endpoint is already connected}}
set SCO_UNIX_MSGS(ERR_ENOTCONN) {107 {Transport endpoint is not connected}}
set SCO_UNIX_MSGS(ERR_EUCLEAN) {108 {Structure needs cleaning}}
set SCO_UNIX_MSGS(ERR_ENOTNAM) {109 {Not a name file}}
set SCO_UNIX_MSGS(ERR_ENAVAIL) {110 {Not available}}
set SCO_UNIX_MSGS(ERR_EISNAM) {111 {Is a name file}}
set SCO_UNIX_MSGS(ERR_EREMOTEIO) {112 {Remote I/O error}}
set SCO_UNIX_MSGS(ERR_EINIT) {113 {Reserved for future use}}
set SCO_UNIX_MSGS(ERR_EREMDEV) {114 {Error 142}}
set SCO_UNIX_MSGS(ERR_ESHUTDOWN) {115 {Cannot send after socket shutdown}}
set SCO_UNIX_MSGS(ERR_ETOOMANYREFS) {116 {Too many references: cannot splice}}
set SCO_UNIX_MSGS(ERR_ETIMEDOUT) {117 {Connection timed out}}
set SCO_UNIX_MSGS(ERR_ECONNREFUSED) {118 {Connection refused}}
set SCO_UNIX_MSGS(ERR_EHOSTDOWN) {119 {Host is down}}
set SCO_UNIX_MSGS(ERR_EHOSTUNREACH) {120 {No route to host}}
set SCO_UNIX_MSGS(ERR_EALREADY) {121 {Operation already in progress}}
set SCO_UNIX_MSGS(ERR_EINPROGRESS) {122 {Operation now in progress}}
set SCO_UNIX_MSGS(ERR_ESTALE) {123 {Stale remote file handle}}
set SCO_UNIX_MSGS(ERR_ENOLOAD) {124 {Cannot load required kernel module}}
set SCO_UNIX_MSGS(ERR_ERELOC) {125 {Object file error in loading kernel module}}
set SCO_UNIX_MSGS(ERR_ENOMATCH) {126 {Symbol matching given spec not found}}
set SCO_UNIX_MSGS(ERR_EBADVER) {127 {Version number mismatch for loadable kernel module}}
set SCO_UNIX_MSGS(ERR_ECONFIG) {128 {Configured kernel resource exhausted}}
set SCO_UNIX_MSGS(ERR_ECANCELED) {129 {Asynchronous I/O request canceled}}
set SCO_UNIX_MSGS(ERR_ENOTAUTH) {130 {Not authenticated}}
set SCO_UNIX_MSGS(ERR_ELKBUSY) {131 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ENOVERS) {132 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EVFILE) {133 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ENOCACHE) {134 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EBLANKCK) {135 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ENOSERVICE) {136 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ENOSTATISTIC) {137 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EARCHIVE) {138 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ENORESOURCE) {139 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ERESINUSE) {140 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EYETARCHIVED) {141 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ELIBOFFLINE) {142 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ENORCHANNEL) {143 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ESEQUENCE) {144 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EBADREPLY) {145 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EINVCORRUPTED) {146 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EBADLABEL) {147 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ENOHDCH) {148 {Unknown error}}
set SCO_UNIX_MSGS(ERR_EOUTHDCH) {149 {Unknown error}}
set SCO_UNIX_MSGS(ERR_ERRNO_UNKNOWN) {150 {Unknown unix errno: %d}}


#@package: saIntlMgr IntlLocal IntlLocalizeMsg

global Intl:messageCats Intl:msgCatalogLRU

set Intl:messageCats(x) {}
unset Intl:messageCats(x)
set Intl:msgCatalogLRU {}


proc Intl:GetMsgEntry {messageId} {


    set msgSepIdx [string first _MSG_ $messageId]
    set errSepIdx [string first _ERR_ $messageId]
    if {$msgSepIdx < 0} {
        set sepIdx $errSepIdx
    } else {
        if {$errSepIdx < 0} {
            set sepIdx $msgSepIdx
        } else {
            set sepIdx [min $msgSepIdx $errSepIdx]
        }
    }


    if {$sepIdx <= 0} {
        error "Invalid message ID `$messageId'"
    }

    set modId [csubstr $messageId 0 $sepIdx]
    set msgName [csubstr $messageId [expr $sepIdx+1] end]


    upvar #0 "${modId}_MSGS" moduleDecls

    if {![info exists moduleDecls]} {
        auto_load "${modId}_MSGS"
    }


    append msgEntryVar moduleDecls "(" $msgName ")"
    if {![info exists $msgEntryVar]} {
        error "Unknown message ID `$messageId'"
    }
    append msgCatalogVar moduleDecls "(@catalog@)"
    return [concat [set $msgCatalogVar] [set $msgEntryVar]]
}


proc Intl:GetMessageCat {catalog} {
    global Intl:messageCats Intl:msgCatalogLRU


    if [info exists Intl:messageCats($catalog)] {
        set idx [lsearch ${Intl:msgCatalogLRU} $catalog]
        set Intl:msgCatalogLRU [lreplace ${Intl:msgCatalogLRU} $idx $idx]
        lappend Intl:msgCatalogLRU $catalog
        return [set Intl:messageCats($catalog)]
    }


    if {[array size Intl:messageCats] >= 4} {
        set overlayCat [lvarpop Intl:msgCatalogLRU]
        catclose [set Intl:messageCats($overlayCat)]
        unset Intl:messageCats($overlayCat)
    }


    set catHandle [catopen $catalog]
    set Intl:messageCats($catalog) $catHandle
    lappend Intl:msgCatalogLRU $catalog
    return $catHandle
}


proc Intl:GetLocalizedText {msgEntry argList} {

    set catHandle [Intl:GetMessageCat [lindex $msgEntry 0]]

    set localStr [catgets $catHandle [lindex $msgEntry 1] \
                          [lindex $msgEntry 2] [lindex $msgEntry 3]]
    return [eval format [list [cexpand $localStr]] $argList]
}


proc IntlLocal {type messageId {argList {}}} {

    set msgEntry [Intl:GetMsgEntry $messageId]

    set localText [Intl:GetLocalizedText $msgEntry $argList]

    if [cequal $type text] {
        return $localText
    }
    if [cequal $type ext] {
        return [list $messageId $localText]
    }
    error "Invalid type `$type', expected `text' or `ext'"
}


proc IntlLocalizeMsg {messageId {argList {}}} {

    set msgEntry [Intl:GetMsgEntry $messageId]

    return [Intl:GetLocalizedText $msgEntry $argList]
}


#@package: saErrorMgr ErrorStackSize ErrorId ErrorData ErrorText ErrorPush \
    ErrorPushUnix ErrorAddData ErrorOutput ErrorCatch ErrorPass \
    ErrorTopLevelCatch ErrorThrow


proc ErrorStackSize {errStackVar} {
    upvar $errStackVar errStack

    return [llength $errStack]
}


proc ErrorId {errStackVar {level 0}} {
    upvar $errStackVar errStack

    return [lindex [lindex $errStack $level] 0]
}


proc ErrorText {errStackVar {level 0}} {
    upvar $errStackVar errStack

    return [lindex [lindex $errStack $level] 1]
}


proc ErrorData {errStackVar {level 0}} {
    upvar $errStackVar errStack

    return [lindex [lindex $errStack $level] 2]
}


proc ErrorPush {errStackVar throw messageId {argList {}} {dataList {}}} {

    if [lempty $errStackVar] {
        set errStack {}
    } else {
        upvar $errStackVar errStack
        if ![info exists errStack] {
            set errStack {}
        }
    }
    set message [IntlLocal ext $messageId $argList]
    if ![lempty $dataList] {
        set message [concat $message $dataList]
    }
    set errStack [linsert $errStack 0 $message]
    if $throw {
        error [lindex $message 1] {} [list ERRORSTACK $errStack]
    }
}


proc ErrorPushUnix {errStackVar throw {messageId {}} {argList {}}} {
    global errorInfo errorCode

    if [lempty $errStackVar] {
        set errStack {}
    } else {
        upvar $errStackVar errStack
        if ![info exists errStack] {
            set errStack {}
        }
    }

    if {"[lindex $errorCode 0]" == "UNIX"} { ;# ???? 6.2 compat..
        set errorCode [concat POSIX [lrange $errorCode 1 end]]
    }
    if {"[lindex $errorCode 0]" != "POSIX"} {
        error {*ErrorPushUnix: Unexpected error*} $errorInfo $errorCode
    }

    set message [IntlLocal ext "SCO_UNIX_ERR_[lindex $errorCode 1]"]
    set errStack [linsert $errStack 0 $message]

    if ![lempty $messageId] {
        set errStack [linsert $errStack 0 [IntlLocal ext $messageId $argList]]
    }
    if $throw {
        error [lindex $message 1] {} [list ERRORSTACK $errStack]
    }
}


proc ErrorAddData {errStackVar dataList} {
    upvar $errStackVar errStack

    set message [lindex $errStack 0]
    set oldDataList [lvarpop message 2]
    lvarpop errStack 0 [concat $message $oldDataList $dataList]
}

proc ErrorOutput {errStackVar {fileId stderr} {options {}} {prefix {}}} {
    upvar $errStackVar errStack

    foreach entry $errStack {
        set outstr $prefix
        if {[lsearch $options ERRORMGR_OUTPUT_IDS] >= 0} {
            append outstr [lindex $entry 0] ": "
        }
        append outstr [lindex $entry 1]
        puts $fileId $outstr
    }
}


proc ErrorCatch {errStackVar throw command resultVar {messageId {}}
                 {argList {}}} {
    if ![lempty $errStackVar] {
        upvar $errStackVar errStack
    }
    if ![lempty $resultVar] {
        upvar $resultVar result
    }
    set errStack {}
    set resultCode [catch {uplevel $command} result]
    if {$resultCode != 1} {
        return $resultCode
    }


    global errorInfo errorCode

    switch -exact -- [lindex $errorCode 0] {
        "POSIX"      {ErrorPushUnix errStack 0 {}}
        "ERRORSTACK" {set errStack [lindex $errorCode 1]}
        default      {error $result $errorInfo $errorCode}
    }
    if ![lempty $messageId] {
        ErrorPush errStack 0 $messageId $argList
    }
    if $throw {
        error [lindex [lindex $errStack 0] 1] {} [list ERRORSTACK $errStack]
    }
    return $resultCode
}


proc ErrorPass {command messageId {argList {}}} {
    set resultCode [catch {uplevel $command} result]
    if {$resultCode != 1} {
        return -code $resultCode $result
    }

    global errorInfo errorCode

    switch -exact -- [lindex $errorCode 0] {
        "POSIX"      {ErrorPushUnix errStack 0 {}}
        "ERRORSTACK" {set errStack [lindex $errorCode 1]}
        default      {error $result $errorInfo $errorCode}
    }
    ErrorPush errStack 0 $messageId $argList
    error [lindex [lindex $errStack 0] 1] {} [list ERRORSTACK $errStack]
}


proc ErrorTopLevelCatch {command description} {

    set resultCode [catch {uplevel $command} result]
    if {$resultCode != 1} {
        return $resultCode
    }


    global errorInfo errorCode

    set saveErrorInfo $errorInfo
    set saveErrorCode $errorCode

    set logFile /tmp/tclerror.[pid].log
    if {[catch {open $logFile w} logFH] != 0} {
        set logFile "stderr"
        set logFH stderr
    }

    puts $logFH "Uncaught error in Tcl program: $description:"
    puts $logFH "$result"
    puts $logFH [replicate - 75]
    puts $logFH "Error code = $saveErrorCode"
    puts $logFH [replicate - 75]
    puts $logFH $saveErrorInfo
    puts $logFH [replicate = 75]

    puts stderr "Fatal error: $result"
    puts stderr "Error Information logged to: $logFile"
    close $logFH
    return $resultCode
}


proc ErrorThrow {errStackVar} {
    upvar $errStackVar errStack

    error [lindex [lindex $errStack 0] 1] {} [list ERRORSTACK $errStack]
}



#@package: SaCU CallNonStdCmd CallNonStdCmdLocale CallTfadminCmd


proc SaCU:ForkCmd {cmd argList outPipeVar errPipeVar} {
    upvar $outPipeVar outPipeRead $errPipeVar errPipeRead

    flush stdout
    flush stderr
    pipe outPipeRead outPipeWrite
    pipe errPipeRead errPipeWrite
    set pid [fork]
    if {$pid != 0} {
        close $outPipeWrite
        close $errPipeWrite
        return $pid
    }

    close $outPipeRead
    close $errPipeRead

    dup   $outPipeWrite stdout
    dup   $errPipeWrite stderr

    close $outPipeWrite
    close $errPipeWrite

    catch {execl $cmd $argList}


    catch {
        global errorCode
        puts stderr [IntlLocalizeMsg SCO_CMD_UTIL_ERR_EXEC \
                                     [list $cmd [lrange $errorCode 1 end]]]
        flush stderr
        kill SIGKILL [id process]
    }
    exit 100
}


proc SaCU:PollCmd {outPipe errPipe outRetVar errRetVar} {
    upvar $outRetVar outReturn $errRetVar errReturn

    set outReturn {}
    set errReturn {}

    set handleList [list $outPipe $errPipe]
    set outEof 0
    set errEof 0
    set outCnt 0
    set errCnt 0

    while {(!$outEof) || (!$errEof)} {
        set readyFiles [lindex [select $handleList] 0]

        if {(!$outEof) && ([lsearch $readyFiles $outPipe] >= 0)} {
           if {[gets $outPipe data] < 0} {
               set outEof 1
           } else {
              if {$outCnt != 0} {
                  append outReturn "\n"
              }
              append outReturn $data
              incr outCnt
           }
        }
        if {(!$errEof) && ([lsearch $readyFiles $errPipe] >= 0)} {
           if {[gets $errPipe data] < 0} {
               set errEof 1
           } else {
              if {$errCnt != 0} {
                  append errReturn "\n"
              }
              append errReturn $data
              incr errCnt
           }
        }
    }
}


proc CallNonStdCmd {cmd argList cmdErrId {errStackVar {}} {messageId {}}
                    {msgArgList {}} {exitCodeVar {}}} {
    if {$errStackVar != ""} {
        upvar $errStackVar errStack
        set throw 0
    } else {
        set throw 1
    }
    set errStack {}

    set pid [SaCU:ForkCmd $cmd $argList outPipe errPipe]
    SaCU:PollCmd $outPipe $errPipe outReturn errReturn
    close $outPipe
    close $errPipe
    set exitStatus [wait $pid]


    if {[lindex $exitStatus 1] != "EXIT"} {
        ErrorPush errStack 0 SCO_CMD_UTIL_ERR_NO_EXIT \
                  [list $cmd [lrange $exitStatus 1 end] $errReturn]
        if {$messageId != ""} {
            ErrorPush errStack 0 $messageId $msgArgList
        }
        if $throw {
            ErrorThrow errStack
        }
        return $outReturn
    } else {
        if ![lempty $exitCodeVar] {
            upvar $exitCodeVar exitCode
            set exitCode [lindex $exitStatus 2]
        }
    }


    if {$errReturn != ""} {
        set cmdName [file tail $cmd]
        ErrorPush errStack 0 $cmdErrId [list $errReturn] [lindex $exitStatus 2]
        if {$messageId != ""} {
            ErrorPush errStack 0 $messageId $msgArgList
        }
        if $throw {
            ErrorThrow errStack
        }
    }
    return $outReturn

}

proc CallNonStdCmdLocale {locale cmd argList cmdErrId {errStackVar {}}
        {messageId {}} {msgArgList {}} {exitCodeVar {}}} {
    global env

    if {![lempty $errStackVar]} {
        upvar $errStackVar callStack
    }

    if {[info exists env(LANG)]} {
        set olang $env(LANG)
    }


    set env(LANG) $locale

    set ret [CallNonStdCmd $cmd $argList $cmdErrId stack \
        $messageId $msgArgList exCode]

    if {[info exists olang]} {
        set env(LANG) $olang
    } else {
        unset env(LANG)
    }

    if {![lempty $exitCodeVar]} {
                upvar $exitCodeVar exitCode
                set exitCode $exCode
        }

    if {![lempty $errStackVar]} {
        set callStack $stack
    } else {
        if {![lempty $stack]} {
            ErrorThrow stack
        }
    }
    return $ret
}


proc CallTfadminCmd {command args cmdErrId {errStackVar {}} {messageId {}}
                    {msgArgList {}} {exitCodeVar {}}} {
    if {$errStackVar != ""} {
        upvar $errStackVar errStack
        set throw 0
    } else {
        set throw 1
    }
    set errStack {}

    if {[id userid] == "0"} {
    set cmd $command
    set argList $args
    } else {
    set cmd /sbin/tfadmin
    set argList [list $command $args]
    }
    set pid [SaCU:ForkCmd $cmd $argList outPipe errPipe]
    SaCU:PollCmd $outPipe $errPipe outReturn errReturn
    close $outPipe
    close $errPipe
    set exitStatus [wait $pid]


    if {[lindex $exitStatus 1] != "EXIT"} {
        ErrorPush errStack 0 SCO_CMD_UTIL_ERR_NO_EXIT \
                  [list $cmd [lrange $exitStatus 1 end] $errReturn]
        if {$messageId != ""} {
            ErrorPush errStack 0 $messageId $msgArgList
        }
        if $throw {
            ErrorThrow errStack
        }
        return $outReturn
    } else {
        if ![lempty $exitCodeVar] {
            upvar $exitCodeVar exitCode
            set exitCode [lindex $exitStatus 2]
        }
    }


    if {$errReturn != ""} {
        set cmdName [file tail $cmd]
        ErrorPush errStack 0 $cmdErrId [list $errReturn] [lindex $exitStatus 2]
        if {$messageId != ""} {
            ErrorPush errStack 0 $messageId $msgArgList
        }
        if $throw {
            ErrorThrow errStack
        }
    }
    return $outReturn

}

#@package: SCO_CMD_UTIL_MSGS SCO_CMD_UTIL_MSGS

proc SCO_CMD_UTIL_MSGS {} {}

global SCO_CMD_UTIL_MSGS
set SCO_CMD_UTIL_MSGS(@catalog@) {sysadm.cat@sa 9}
set SCO_CMD_UTIL_MSGS(ERR_NO_EXIT) {1 {%1$s terminated with %2$s, stderr: %3$s}}
set SCO_CMD_UTIL_MSGS(ERR_EXEC) {2 {exec of \"%1$s\" failed: %2$s}}

#@package: SCO_NONSTD_CMDS_MSGS SCO_NONSTD_CMDS_MSGS

proc SCO_NONSTD_CMDS_MSGS {} {}

global SCO_NONSTD_CMDS_MSGS
set SCO_NONSTD_CMDS_MSGS(@catalog@) {sysadm.cat@sa 10}
set SCO_NONSTD_CMDS_MSGS(ERR_accept) {1 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_auths) {2 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_brand) {3 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_cancel) {4 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_cat) {5 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_chgrp) {6 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_chmod) {7 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_chown) {8 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_configure) {9 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_copy) {10 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_cp) {11 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_devtree) {12 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_df) {13 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_disable) {14 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_dkconfig) {15 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_dprint) {16 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_enable) {17 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_exportfs) {18 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_find) {19 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_format) {20 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_fsck) {21 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_fsstat) {22 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_fstyp) {23 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_hostname) {24 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_link_unix) {25 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_ln) {26 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpadmin) {27 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpsched) {28 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpshut) {29 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpstat) {30 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpusers) {31 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lp) {32 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpd) {33 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpmove) {34 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpfilter) {35 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_lpform) {36 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_ls) {37 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_mkdev) {38 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_mkdir) {39 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_mknod) {40 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_mnt) {41 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_mount) {42 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_mountd) {43 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_mv) {44 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_nfsd) {45 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_nfstyp) {46 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_nping) {47 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_nwlpadmin) {48 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_nwservers) {49 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_nwvolumes) {50 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_ping) {51 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_ps) {52 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_reject) {53 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_rm) {54 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_scoprint) {55 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_secdefs) {56 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_sed) {57 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_share) {58 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_showmount) {59 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_tape) {60 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_umount) {61 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_uname) {62 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_unshare) {63 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_who) {64 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_xdtarch) {65 %s}
set SCO_NONSTD_CMDS_MSGS(ERR_objcall) {66 %s}


#@package: SaGetOpt getopt SaGetOpt:Reset


set optind        0
set optarg        ""
set SaGetOpt_optindChar    1
set SaGetOpt_optindArg    1
set SaGetOpt_state    "arg"


proc SaGetOpt:Reset {} {
    global SaGetOpt_optindChar SaGetOpt_optindArg SaGetOpt_state
    global optind optarg
    set SaGetOpt_optindChar    1
    set SaGetOpt_optindArg    1
    set SaGetOpt_state        "arg"
}


proc SaGetOpt:CharFromString {index str} {
    return [string range $str $index $index]
}

proc getopt {argc argv optstr} {

    global optind opterr optarg
    global SaGetOpt_state SaGetOpt_optindChar SaGetOpt_optindArg

    if {![info exists opterr]} {
        set opterr    1    ;# booelan - error to stderr
    }
    while {1} {
        if {$optind >= $argc} {
            return -1
        }
        case $SaGetOpt_state {
            {arg} {
                set SaGetOpt_optindChar 1
                set arg [lindex $argv $optind]
                set opt [SaGetOpt:CharFromString 0 $arg]
                if {$opt != "-"} {
                    SaGetOpt:Reset
                    return -1
                }
                if {$arg == "--"} {
                    set optind [expr "$optind + 1"]
                    SaGetOpt:Reset
                    return -1
                }
                set SaGetOpt_state option
                continue
            }
            {option} {
                set arg [lindex $argv $optind]
                if {$SaGetOpt_optindChar >= [string length $arg]} {
                    set SaGetOpt_state arg
                    set optind $SaGetOpt_optindArg
                    set SaGetOpt_optindArg \
                        [expr "$SaGetOpt_optindArg + 1" ]
                    continue
                }
                set opt [SaGetOpt:CharFromString $SaGetOpt_optindChar $arg]
                set SaGetOpt_optindChar [expr "$SaGetOpt_optindChar + 1" ]
                if {[set i [string first $opt $optstr]] == -1} {
                    if {$opterr} {
                        puts stderr [IntlLocalizeMsg SCO_GETOPT_ERR_BADOPT $opt]
                    }
                    return "?"
                }
                if {[SaGetOpt:CharFromString \
                    [expr "$i + 1"] $optstr] == ":"} {
                    if {$SaGetOpt_optindChar < \
                        [string length $arg]} {
                        set optarg [string range \
                            $arg \
                            $SaGetOpt_optindChar \
                            end]
                        set SaGetOpt_state arg
                        set optind $SaGetOpt_optindArg
                        set SaGetOpt_optindArg \
                            [expr "$optind + 1" ]
                    } else {
                        if {$SaGetOpt_optindArg >= $argc} {
                            if {$opterr} {
                               puts stderr [IntlLocalizeMsg \
                                SCO_GETOPT_ERR_MISSING \
                        $opt]
                            }
                            return "?"
                        }
                        set optarg [lindex $argv $SaGetOpt_optindArg]
                        set SaGetOpt_optindArg [expr "$SaGetOpt_optindArg + 1"]
                    }
                }
                return $opt
            }
        }
    }
}

#@packend: SaGetOpt

#@package: SCO_GETOPT_MSGS SCO_GETOPT_MSGS

proc SCO_GETOPT_MSGS {} {}

global SCO_GETOPT_MSGS
set SCO_GETOPT_MSGS(@catalog@) {sysadm.cat@sa 16}
set SCO_GETOPT_MSGS(ERR_BADOPT) {1 {getopt: illegal option -- %s}}
set SCO_GETOPT_MSGS(ERR_MISSING) {2 {getopt: option requires an argument -- %s}}


#@package: SaBR BmipResponseOperation BmipResponseOperation BmipResponseClass BmipResponseObjectInstance BmipResponseAttrValList BmipResponseActionType BmipResponseActionInfo BmipResponseErrorStack BmipResponseErrorId BmipResponseErrorText BmipResponseErrorIsPresent


proc BmipResponseOperation {bmipVarName} {
        upvar $bmipVarName bmipResponse

        return [lindex $bmipResponse 0]
}


proc BmipResponseClass {bmipVarName} {
        upvar $bmipVarName bmipResponse

        return [lindex $bmipResponse 1]
}


proc BmipResponseObjectInstance {bmipVarName} {
        upvar $bmipVarName bmipResponse

        return [lindex $bmipResponse 2]
}


proc BmipResponseAttrValList {bmipVarName} {
        upvar $bmipVarName bmipResponse

        return [lindex $bmipResponse 3]
}


proc BmipResponseActionType {bmipVarName} {
        upvar $bmipVarName bmipResponse

        return [lindex $bmipResponse 4]
}


proc BmipResponseActionInfo {bmipVarName} {
        upvar $bmipVarName bmipResponse

        return [lindex $bmipResponse 5]
}


proc BmipResponseErrorStack {bmipVarName} {
        upvar $bmipVarName bmipResponse

        return [lindex $bmipResponse 6]
}


proc BmipResponseErrorId {bmipVarName {index 0}} {
        upvar $bmipVarName bmipResponse

        set errorStack [lindex $bmipResponse 6]
        if {[string match $index end]} {
            set index [expr "[llength $errorStack] - 1"]
        }
        return [lindex [lindex $errorStack $index] 0]
}


proc BmipResponseErrorText {bmipVarName {index 0}} {
        upvar $bmipVarName bmipResponse

        set errorStack [lindex $bmipResponse 6]
        if {[string match $index end]} {
            set index [expr "[llength $errorStack] - 1"]
        }
        return [lindex [lindex $errorStack $index] 1]
}


proc BmipResponseErrorIsPresent {bmipVarName} {
        upvar $bmipVarName bmipResponse

        if {"" != [lindex $bmipResponse 6]} {
                return 1
        }
        return 0
}


#@package: SCO_OSA_MSGS SCO_OSA_MSGS

proc SCO_OSA_MSGS {} {}

global SCO_OSA_MSGS
set SCO_OSA_MSGS(@catalog@) {fw.cat@sa 2}
set SCO_OSA_MSGS(ERR_ACCESS_DENIED) {1 {The requested operation was not performed for reasons pertinent to the security of the system.}}
set SCO_OSA_MSGS(ERR_CLASS_INSTANCE_CONFLICT) {2 {The specified managed object instance is not a member of the specified class.}}
set SCO_OSA_MSGS(ERR_DUPLICATE_INVOCATION) {3 {The invoke identifier specified is allocated to another operation.}}
set SCO_OSA_MSGS(ERR_DUPLICATE_MANAGED_OBJECT_INSTANCE) {4 {The object instance %s already exists.}}
set SCO_OSA_MSGS(ERR_GET_LIST_ERROR) {5 %s}
set SCO_OSA_MSGS(ERR_INVALID_ARGUMENT_VALUE) {6 {The action information value specified, %s, was out of range or otherwise inappropriate.}}
set SCO_OSA_MSGS(ERR_INVALID_ATTRIBUTE_VALUE) {7 {The value supplied for attribute %s is invalid.}}
set SCO_OSA_MSGS(ERR_INVALID_FILTER) {8 {A filter parameter, %s, contains an invalid assertion or an unrecognized logical operator.}}
set SCO_OSA_MSGS(ERR_INVALID_SCOPE) {9 {The value of the scope parameter, %s, is invalid.}}
set SCO_OSA_MSGS(ERR_INVALID_OBJECT_INSTANCE) {10 {An object name, %s, violates the naming rules.}}
set SCO_OSA_MSGS(ERR_MISSING_ATTRIBUTE_VALUE) {11 {An attribute, %s, was given without an associated value.}}
set SCO_OSA_MSGS(ERR_MISTYPED_ARGUMENT) {12 {One of the parameters supplied, %s, is not supported by this service.}}
set SCO_OSA_MSGS(ERR_NO_SUCH_ACTION) {13 {The action type %s is not implemented.}}
set SCO_OSA_MSGS(ERR_NO_SUCH_ARGUMENT) {14 {The action information specified was not supported.}}
set SCO_OSA_MSGS(ERR_NO_SUCH_ATTRIBUTE) {15 {No such attribute %1$s in class %2$s}}
set SCO_OSA_MSGS(ERR_NO_SUCH_OBJECT_CLASS) {16 {The class %s has not been bound to the framework.}}
set SCO_OSA_MSGS(ERR_NO_SUCH_OBJECT_INSTANCE) {17 {The object instance %s does not exist.}}
set SCO_OSA_MSGS(ERR_NO_SUCH_REFERENCE_OBJECT) {18 {The reference object %s does not exist.}}
set SCO_OSA_MSGS(ERR_PROCESSING_FAILURE) {19 {General failure occured in processing the request.}}
set SCO_OSA_MSGS(ERR_PROCESSING_FAILURE_ON_ATTRIBUTE) {20 {General failure occured in processing attribute %s}}
set SCO_OSA_MSGS(ERR_RESOURCE_LIMITATION) {21 {The operation failed due to lack of a needed resource.}}
set SCO_OSA_MSGS(ERR_SET_LIST_ERROR) {22 %s}
set SCO_OSA_MSGS(ERR_SYNC_NOT_SUPPORTED) {23 {The type of synchronization specified, %s, is not supported.}}
set SCO_OSA_MSGS(ERR_UNRECOGNIZED_OPERATION) {24 {The operation attempted, %s, is not supported.}}


#@package: SaSH SaSelectHostText SaSelectHostDialog SaSelectHostGetText SaSelectHostGetTextWidget SaSelectHostGetButtonWidget SaSelectHostGetSelection




proc SCO_SA_SELHOST_MSGS {} {}

global SCO_SA_SELHOST_MSGS
set SCO_SA_SELHOST_MSGS(@catalog@) {sysadm.cat@sa 24}
set SCO_SA_SELHOST_MSGS(MSG_DIALOG_TITLE) {1 {Select Host}}
set SCO_SA_SELHOST_MSGS(MSG_LLABEL_NAME) {2 {Host Name}}
set SCO_SA_SELHOST_MSGS(MSG_LLABEL_ADDR) {3 {IP Address}}
set SCO_SA_SELHOST_MSGS(MSG_BOXLABEL_SORTBY) {4 {Sort By:}}
set SCO_SA_SELHOST_MSGS(MSG_TOGGLE_BYNAME) {5 Name}
set SCO_SA_SELHOST_MSGS(MSG_TOGGLE_BYADDR) {6 Address}
set SCO_SA_SELHOST_MSGS(MSG_TXTLABEL_FILTER) {7 Filter:}
set SCO_SA_SELHOST_MSGS(MSG_TXTLABEL_SELECTION) {8 Selection:}
set SCO_SA_SELHOST_MSGS(MSG_CANCELBUTTON) {9 Cancel}
set SCO_SA_SELHOST_MSGS(MSG_APPLYBUTTON) {10 Filter}
set SCO_SA_SELHOST_MSGS(MSG_LIST_HELP) {11 {Select from list, or enter a name in the 'selection' field}}
set SCO_SA_SELHOST_MSGS(MSG_SORT_NAME_HELP) {12 {Sort list alphabetically by name}}
set SCO_SA_SELHOST_MSGS(MSG_SORT_ADDR_HELP) {13 {Sort list numerically by IP address}}
set SCO_SA_SELHOST_MSGS(MSG_FILTER_CHARM_HELP) {14 {Enter a pattern to match, use <Enter> key to activate}}
set SCO_SA_SELHOST_MSGS(MSG_FILTER_MOTIF_HELP) {15 {Enter a pattern to match}}
set SCO_SA_SELHOST_MSGS(MSG_SELECTION_HELP) {16 {Enter host here, or use the list to select a host}}
set SCO_SA_SELHOST_MSGS(ERR_NO_HOST_SELECTED) {17 {No Host has been selected}}
set SCO_SA_SELHOST_MSGS(ERR_NO_HOST_MATCH) {18 {No hosts match that filter}}
set SCO_SA_SELHOST_MSGS(ERR_BAD_HOST) {19 {Invalid host name entered}}
set SCO_SA_SELHOST_MSGS(ERR_CODE_ERR) {20 {Error:  data missing from parameter list}}
set SCO_SA_SELHOST_MSGS(MSG_RETRIEVING) {21 {Retrieving host information...}}




proc SaSelectHostText {pList} {

    global SaSH_info

    if {[keylget pList parent parent] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELHOST_ERR_CODE_ERR
    }
    if {[keylget pList instance instance] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELHOST_ERR_CODE_ERR
    }
    if {[keylget pList labeltype labeltype] == 0} {
    set labeltype title
    }
    if {[keylget pList labeltext labeltext] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELHOST_ERR_CODE_ERR
    }
    if {[keylget pList textcols textcols] == 0} {
    set textcols 30
    }
    if {[keylget pList buttontext buttontext] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELHOST_ERR_CODE_ERR
    }
    if {[keylget pList show show] == 0} {
    set show name
    }
    if {[keylget pList userproc userproc] == 0} {
    set userproc {}
    }

    set returnform [VtForm $parent.SaSH_form -marginHeight 0 -marginWidth 0]

    if {$labeltype == "label"} {

    set innerform [VtForm $returnform.innerform -marginHeight 0 -marginWidth 0]
    VtSetValues $innerform -leftSide FORM -rightSide FORM

    set textlabel [VtLabel $innerform.textlabel -label $labeltext]

    set textfield [VtText $innerform.textfield \
        -columns $textcols]
    if {![lempty $userproc]} {
        VtSetValues $textfield -callback $userproc
    }
        keylset pList textfield $textfield

    set pushbutton [VtPushButton $innerform.button \
        -label $buttontext \
        -callback "SaSelectHostDialog {$pList}" ]

    set lheight [lindex [VtGetValues $textlabel -baseLineList] 0]
    set theight [lindex [VtGetValues $textfield -baseLineList] 0]
    set bheight [lindex [VtGetValues $pushbutton -baseLineList] 0]

    if {$lheight >= $theight && $lheight >= $bheight} {

        set diff1 [expr $lheight - $theight]
        set diff2 [expr $lheight - $bheight]

        VtSetValues $textlabel \
        -leftSide FORM -rightSide NONE \
        -topSide FORM -MOTIF_topOffset 0

        VtSetValues $textfield \
        -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset $diff1

        VtSetValues $pushbutton \
        -leftSide NONE \
        -rightSide FORM \
        -topSide FORM -MOTIF_topOffset $diff2

    } elseif {$theight >= $bheight} {

        set diff1 [expr $theight - $lheight]
        set diff2 [expr $theight - $bheight]

        VtSetValues $textlabel \
        -leftSide FORM -rightSide NONE \
        -topSide FORM -MOTIF_topOffset $diff1

        VtSetValues $textfield \
        -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset 0

        VtSetValues $pushbutton \
        -leftSide NONE \
        -rightSide FORM \
        -topSide FORM -MOTIF_topOffset $diff2

    } else {

        set diff1 [expr $bheight - $lheight]
        set diff2 [expr $bheight - $theight]

        VtSetValues $textlabel \
        -leftSide FORM -rightSide NONE \
        -topSide FORM -MOTIF_topOffset $diff1

        VtSetValues $textfield \
        -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset $diff2

        VtSetValues $pushbutton \
        -leftSide NONE \
        -rightSide FORM \
        -topSide FORM -MOTIF_topOffset 0
    }

    VtSetValues $textlabel -leftSide FORM -rightSide NONE

    VtSetValues $textfield -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM

    VtSetValues $pushbutton -leftSide NONE \
        -rightSide FORM -topSide FORM

    } else {

    set textlabel [VtLabel $returnform.textlabel -label $labeltext]

    set innerform [VtForm $returnform.innerform -marginHeight 0 -marginWidth 0]
    VtSetValues $innerform -leftSide FORM -rightSide FORM

    set textfield [VtText $innerform.textfield \
        -columns $textcols]
    if {![lempty $userproc]} {
        VtSetValues $textfield -callback $userproc
    }
        keylset pList textfield $textfield

    set pushbutton [VtPushButton $innerform.button \
        -label $buttontext \
        -callback "SaSelectHostDialog {$pList}" ]

    set theight [lindex [VtGetValues $textfield -baseLineList] 0]
    set bheight [lindex [VtGetValues $pushbutton -baseLineList] 0]

    set diff [abs ([expr $theight - $bheight])]

    if {$theight > $bheight} {

        VtSetValues $textfield -leftSide FORM \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset 0

        VtSetValues $pushbutton \
        -leftSide NONE -rightSide FORM \
        -topSide FORM -MOTIF_topOffset $diff

    } else {

        VtSetValues $textfield -leftSide FORM \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset $diff

        VtSetValues $pushbutton \
        -leftSide NONE -rightSide FORM \
        -topSide FORM -MOTIF_topOffset 0
    }
    }

    set SaSH_info($instance:textwidgetname) $textfield
    set SaSH_info($instance:button) $pushbutton
    set SaSH_info($instance:has_textwidget) TRUE
    set SaSH_info(showvalue) $show

    VxSetVar $returnform text $textfield
    VxSetVar $returnform label $textlabel
    VxSetVar $returnform button $pushbutton

    return $returnform
}



proc SaSelectHostDialog {pList cbs} {
    global SaSH_info
    global SaSH_gl_host_list SaSH_radio_value

    set parent [keylget cbs dialog]

    VtLock

    if {[keylget pList instance instance] == 0} {
    VtUnLock
    ErrorPush errorStack 1 SCO_SA_SELHOST_ERR_CODE_ERR
    }
    if {[keylget pList show show] == 0} {
    set show name
    }
    if {[keylget pList title title] == 0} {
    set title [IntlLocalizeMsg SCO_SA_SELHOST_MSG_DIALOG_TITLE]
    }
    if {[keylget pList textcols textcols] == 0} {
    set textcols 30
    }
    if {[keylget pList userproc userproc] == 0} {
    set userproc {}
    }
    if {[keylget pList textfield textfield] == 0} {
    set textfield {}
    }


    set SaSH_info(showvalue) $show

    set selhostdlog [VtFormDialog $parent.selhostdlog \
    -title $title \
    -ok \
    -okCallback [list SaSH:ProcessUserSelectionCB $instance $userproc ] \
    -cancel \
    -cancelLabel [IntlLocalizeMsg SCO_SA_SELHOST_MSG_CANCELBUTTON] \
    -cancelCallback SaSH:EndFormCB \
    -cancelButton CANCEL \
    -MOTIF_apply \
    -MOTIF_applyLabel [IntlLocalizeMsg SCO_SA_SELHOST_MSG_APPLYBUTTON] \
    -MOTIF_applyCallback SaSH:ApplyFilterCB \
    -MOTIF_autoLock SaSH:ApplyFilterCB \
    -help \
    -wmShadowThickness 0]
    SaCharmSetMaxFormDimensions $selhostdlog 1
    set listform [VtForm $selhostdlog.listform -marginHeight 0 -marginWidth 0]

    set namelabel [IntlLocalizeMsg SCO_SA_SELHOST_MSG_LLABEL_NAME]
    set addrlabel [IntlLocalizeMsg SCO_SA_SELHOST_MSG_LLABEL_ADDR]
    if [VtInfo -charm] {
    set labelstring [format "   %-30.30s  %s" $namelabel $addrlabel]
    } else {
    set labelstring [format "%-30.30s  %s" $namelabel $addrlabel]
    }
    set listlabel [VtLabel $listform.listlabel \
    -label $labelstring \
    -labelLeft]

    set hostlist [VtList $listform.hostlist \
    -autoSelect 1 \
    -rows 12 \
    -itemList {} \
    -shortHelpString [IntlLocalizeMsg SCO_SA_SELHOST_MSG_LIST_HELP] \
    -shortHelpCallback SaShortHelpCB \
    -callback "SaSH:HostListSelectCB $show" \
    -defaultCallback "SaSH:HostListEnterCB $show" ]

    set optionsform [VtForm $selhostdlog.optform -marginHeight 0 -marginWidth 0]

    set sortlabel [VtLabel $optionsform.sortlabel \
    -label [IntlLocalizeMsg SCO_SA_SELHOST_MSG_BOXLABEL_SORTBY] \
    -labelLeft]
    set sortbox [VtRadioBox $optionsform.sortbox \
    -autoSelect 1 \
    -borderWidth 1 \
    -numColumns 2 \
    ]

    set byname [VtToggleButton $sortbox.byname \
    -callback "SaSH:ChangeSortCB $instance" \
    -autoLock SaSH:ChangeSortCB \
    -shortHelpString [IntlLocalizeMsg SCO_SA_SELHOST_MSG_SORT_NAME_HELP] \
    -shortHelpCallback SaShortHelpCB \
    -label [IntlLocalizeMsg SCO_SA_SELHOST_MSG_TOGGLE_BYNAME] ]
    set byaddr [VtToggleButton $sortbox.byaddr \
    -callback "SaSH:ChangeSortCB $instance" \
    -autoLock SaSH:ChangeSortCB \
    -shortHelpString [IntlLocalizeMsg SCO_SA_SELHOST_MSG_SORT_ADDR_HELP] \
    -shortHelpCallback SaShortHelpCB \
    -label [IntlLocalizeMsg SCO_SA_SELHOST_MSG_TOGGLE_BYADDR] ]

    set flabel [VtLabel $optionsform.flabel \
    -label [IntlLocalizeMsg SCO_SA_SELHOST_MSG_TXTLABEL_FILTER] \
    -labelLeft]
    set filter [VtText $optionsform.filter \
    -MOTIF_shortHelpString \
        [IntlLocalizeMsg SCO_SA_SELHOST_MSG_FILTER_MOTIF_HELP] \
    -CHARM_shortHelpString \
        [IntlLocalizeMsg SCO_SA_SELHOST_MSG_FILTER_CHARM_HELP] \
    -shortHelpCallback SaShortHelpCB \
    -autoLock SaSH:ApplyFilterCB \
    -callback SaSH:ApplyFilterCB]

    if [VtInfo -charm]  {
    set textcols 28
    }
    set slabel [VtLabel $optionsform.slabel \
    -label [IntlLocalizeMsg SCO_SA_SELHOST_MSG_TXTLABEL_SELECTION] \
    -labelLeft]
    set selection [VtText $optionsform.selection \
    -columns $textcols \
    -shortHelpString [IntlLocalizeMsg SCO_SA_SELHOST_MSG_SELECTION_HELP] \
    -shortHelpCallback SaShortHelpCB \
    -autoLock SaSH:HostTextCB \
    -callback SaSH:HostTextCB \
    -horizontalScrollBar 1]

    set statusBar [SaStatusBar $selhostdlog.statusbar]


    VtSetValues $listform \
    -topSide FORM \
    -leftSide FORM \
    -MOTIF_rightSide 55 -MOTIF_rightOffset 5 \
    -bottomSide $statusBar

    VtSetValues $listlabel \
    -rightSide FORM -leftSide FORM \
    -topSide FORM -bottomSide NONE

    VtSetValues $hostlist \
    -rightSide FORM -leftSide FORM \
    -topSide $listlabel -topOffset 0 -bottomSide FORM


    VtSetValues $optionsform \
    -topSide FORM \
    -CHARM_leftSide $listform -CHARM_leftOffset 1 \
    -MOTIF_leftSide 55 -MOTIF_leftOffset 5 \
    -rightSide FORM \
    -bottomSide $statusBar

    VtSetValues $sortlabel \
    -topSide FORM -MOTIF_topOffset 10 \
    -bottomSide NONE \
    -leftSide FORM -leftOffset 0 \
    -rightSide FORM
    VtSetValues $sortbox \
    -topSide $sortlabel -topOffset 0 \
    -alignLeft $sortlabel \
    -bottomSide NONE \
    -leftSide FORM -rightSide FORM

    VtSetValues $flabel \
    -topSide $sortbox -topOffset 20 -CHARM_topOffset 2 \
    -bottomSide NONE \
    -leftSide FORM -rightSide FORM
    VtSetValues $filter \
    -topSide $flabel -topOffset 0 \
    -alignLeft $flabel \
    -bottomSide NONE \
    -leftSide FORM -rightSide FORM

    VtSetValues $slabel \
    -topSide $filter -topOffset 20 -CHARM_topOffset 2 \
    -bottomSide NONE \
    -leftSide FORM -rightSide FORM
    VtSetValues $selection \
    -topSide $slabel -topOffset 0 \
    -alignLeft $slabel \
    -bottomSide NONE -bottomOffset 0 \
    -leftSide FORM -rightSide FORM

    VtRemoveAllTabGroups $selhostdlog
    VtAddTabGroup $hostlist
    VtAddTabGroup $sortbox
    VtAddTabGroup $filter
    VtAddTabGroup $selection

    VxSetVar $selhostdlog hostlist $hostlist
    VxSetVar $selhostdlog sort $sortbox
    VxSetVar $selhostdlog byname $byname
    VxSetVar $selhostdlog byaddr $byaddr
    VxSetVar $selhostdlog filter $filter
    VxSetVar $selhostdlog text $selection


    VtShow $selhostdlog
    VtSetFocus $hostlist

    SaStatusBarSet $statusBar [IntlLocalizeMsg SCO_SA_SELHOST_MSG_RETRIEVING]

    if {![info exists SaSH_info(init)]} {
    set init 1
    set SaSH_info(init) [SaSH:init $textfield]
    } else {
    set init 0
    }

    if {"$SaSH_info(sortby)"== "name"} {
    set listitems [SaSH:SortByName]
    } {
    set listitems [SaSH:SortByAddress]
    }

    VtListSetItem $hostlist -itemList $listitems

    set currentitem [lsearch $listitems $SaSH_info(screenselection)*]

    if {$currentitem != -1} {
    incr currentitem
    VtListSelectItem $hostlist -notify -position $currentitem
    SaListShowSelectedItem $hostlist
    }

    if {"$SaSH_info(sortby)"== "name"} {
    VtSetValues $byname -value 1
    } {
    VtSetValues $byaddr -value 1
    }
    set SaSH_radio_value [VtGetValues $sortbox -value]

    if {$init} {
        VtListSelectItem $hostlist -notify -position 1
    SaListShowSelectedItem $hostlist
    }


    set name [lindex $SaSH_info(screenselection) 0]
    set addr [lindex $SaSH_info(screenselection) 1]

    case $show {
    "name" {
        set textdefault $name
    }
    "ipaddr" {
        set textdefault $addr
    }
    "both" {
        set textdefault "$name   $addr"
    }
    default {
        set textdefault $name
    }
    }

    VtSetValues $selection -value $textdefault
    VtSetValues $filter -value $SaSH_info(filter)

    SaStatusBarClear $statusBar

    VtUnLock
}


proc SaSH:SortByAddress {} {
    global SaSH_info
    global SaSH_gl_host_list

    set newlist ""

    foreach one $SaSH_gl_host_list {
        set addr [lindex $one 0]
    set name [lindex $one 1]
        lappend newlist [format "%s %s" $addr $name]
    }

    set sortedlist [lsort $newlist]

    set newlist ""
    foreach one $sortedlist {
    set addr [lindex $one 0]
    set name [lindex $one 1]
        lappend newlist [format "%-30.30s  %s" $name $addr]
    }

    return $newlist
}


proc SaSH:SortByName {} {
    global SaSH_info
    global SaSH_gl_host_list

    set newlist ""

    foreach one $SaSH_gl_host_list {
    set addr [lindex $one 0]
        set name [lindex $one 1]
        lappend newlist [format "%s %s" $name $addr]
    }

    set sortedlist [lsort $newlist]

    set newlist ""
    foreach one $sortedlist {
    set addr [lindex $one 1]
    set name [lindex $one 0]
        lappend newlist [format "%-30.30s  %s" $name $addr]
    }

    return $newlist
}


proc SaSH:ApplyFilterCB {cbs} {
    global SaSH_info
    global SaSH_gl_host_list

    VtLock


    set dlog [keylget cbs dialog]
    set widget [keylget cbs widget]
    set filter [VxGetVar $dlog filter]
    set hostlist [VxGetVar $dlog hostlist]
    set textfield [VxGetVar $dlog text]
    set sort [VxGetVar $dlog sort]
    set byname [VxGetVar $dlog byname]

    set SaSH_info(filter) [VtGetValues $filter -value]
    set hl  [SaHostsGet]


    set newhl ""

    foreach one $hl {
        set addr [lindex $one 0]
    set name [lindex $one 1]


    if {[string match $SaSH_info(filter) $addr]==1 || [string match $SaSH_info(filter) $name]==1 } {
        lappend newhl $one
    }
    }

     if {[llength $newhl]==0} {
    VtShow [VtInformationDialog $dlog.nohostmatch \
        -ok \
        -message [IntlLocalizeMsg SCO_SA_SELHOST_ERR_NO_HOST_MATCH] ]
     } else {

     set SaSH_gl_host_list $newhl


    set sortby [VtGetValues $sort -value]
       if {$sortby == $byname} {
           set listitems [SaSH:SortByName]
       } {
           set listitems [SaSH:SortByAddress]
       }

    VtListDeleteItem $hostlist -all
    VtListSetItem $hostlist -itemList $listitems

    set currentitem [lsearch $listitems $SaSH_info(screenselection)*]

    if {$currentitem != -1} {
        set show $SaSH_info(showvalue)
        incr currentitem
        VtListSelectItem $hostlist -notify -position $currentitem
        SaListShowSelectedItem $hostlist
        set name [lindex $SaSH_info(screenselection) 0]
        set addr [lindex $SaSH_info(screenselection) 1]
        case $show {
        "name" { set textdefault $name }
        "ipaddr" { set textdefault $addr }
        "both" { set textdefault "$name   $addr" }
        default { set textdefault $name }
        }
        VtSetValues $textfield -value $textdefault

    } else {
        VtListSelectItem $hostlist -notify -position 1
        VtSetValues $textfield -value ""
    }
    if {$widget == $filter} {
        VtSetFocus $hostlist
    }
    }
    VtUnLock
}

proc SaSH:ChangeSortCB {instance cbs} {
    global SaSH_info
    global SaSH_gl_host_list

    set dlog [keylget cbs dialog]
    set hostlist [VxGetVar $dlog hostlist]
    set textfield [VxGetVar $dlog text]
    set sort [VxGetVar $dlog sort]
    set byname [VxGetVar $dlog byname]
    set sortbox [VxGetVar $dlog sort]

    VtLock
    if {[keylget cbs mode] != "done"} {
    }
    global SaSH_radio_value
    set radio_value [VtGetValues $sortbox -value]
    if {$radio_value != $SaSH_radio_value} {
        set SaSH_radio_value $radio_value

        set ret [VtGetValues $sort -value]
        if {$ret == $byname} {
        set listitems [SaSH:SortByName]
        set SaSH_info(sortby) "name"
        } {
        set listitems [SaSH:SortByAddress]
        set SaSH_info(sortby) "addr"
        }

        VtListDeleteItem $hostlist -all
        VtListSetItem $hostlist -itemList $listitems

        set currentitem [lsearch $listitems $SaSH_info(screenselection)*]

        if {$currentitem != -1} {
        incr currentitem
        VtListSelectItem $hostlist -notify -position $currentitem
        SaListShowSelectedItem $hostlist
        }
    }

    if {[keylget cbs mode] == "done"} {
        VtSetFocus $hostlist
    }

    VtUnLock
}


proc SaSH:HostTextCB {cbs} {
    global SaSH_info

    set dialog [keylget cbs dialog]
    set hostlist [VxGetVar $dialog hostlist]
    set textwidgie [keylget cbs widget]
    set okbutton [VtGetValues $dialog -ok]
    set hostname [VtGetValues $textwidgie -value]

    if {[lempty $hostname]} {
    VtListDeselectItem $hostlist -notify -all
    } else {
        if {[SaHostCheck $hostname] != 0} {
        set pattern "${hostname} *"
        if {[ctype digit [lindex [split $hostname .] 0]]} {
            set pattern "* ${hostname}"
        }
            set currentitem [lsearch [VtListGetItem $hostlist -all] \
                $pattern]
        if {$currentitem != -1} {
            incr currentitem
            VtListSelectItem $hostlist -position $currentitem
            SaSH:HostListSelectCB show $cbs
            SaListShowSelectedItem $hostlist
        } else {
            VtListDeselectItem $hostlist -notify -all
        }
        } else {
            ErrorPush errorStack 0 SCO_SA_SELHOST_ERR_BAD_HOST
            SaDisplayErrorStacks $dialog.errorbox [list $errorStack] HELP
        }
    }

    if {[keylget cbs mode] == "done"} {
        VtSetFocus $okbutton
    }
    VtUnLock
}


proc SaSH:HostListSelectCB {show cbs} {
    global SaSH_info

    set dlog [keylget cbs dialog]
    set hostlist [VxGetVar $dlog hostlist]
    set textfield [VxGetVar $dlog text]


    set new_item [lindex [VtListGetSelectedItem $hostlist -byItemList] 0]

    set name [lindex $new_item 0]
    set addr [lindex $new_item 1]

    case $show {
    "name" {
        set final $name
    }
    "ipaddr" {
        set final $addr
    }
    "both" {
        set final "$name   $addr"
    }
    default {
        set final $name
    }
    }

    set SaSH_info(screenselection) $new_item
    VtSetValues $textfield -value $final
}


proc SaSH:HostListEnterCB {show cbs} {

    global SaSH_info

    set dlog [keylget cbs dialog]
    set hostlist [keylget cbs widget]
    set textfield [VxGetVar $dlog text]


    set new_item [lindex [VtListGetSelectedItem $hostlist -byItemList] 0]

    set name [lindex $new_item 0]
    set addr [lindex $new_item 1]

    case $show {
    "name" {
        set final $name
    }
    "ipaddr" {
        set final $addr
    }
    "both" {
        set final "$name   $addr"
    }
    default {
        set final $name
    }
    }

    set SaSH_info(screenselection) $new_item
    VtSetValues $textfield -value $final

    set okbutton [VtGetValues $dlog -ok]
    VtSetFocus $okbutton
}



proc SaSH:ProcessUserSelectionCB {instance userproc cbs} {

    global SaSH_info

    set dlog [keylget cbs dialog]
    set hostlist [VxGetVar $dlog hostlist]
    set textfield [VxGetVar $dlog text]


    set returnval [VtGetValues $textfield -value]

    if {! [lempty $returnval] } {

    if [info exists SaSH_info($instance:has_textwidget)] {


        VtSetValues $SaSH_info($instance:textwidgetname) -value $returnval
    }

    set SaSH_info($instance:userselection) $returnval


    set currentitem [lsearch [VtListGetItem $hostlist -all] $returnval]
    if {$currentitem == -1} {
        set currentitem [lindex $SaSH_info(screenselection) 0]

            VtDestroyDialog $dlog
    }

    if {![lempty $userproc]} {
        lappend userproc $cbs
        eval "$userproc"
    }
    } else {
    VtShow [VtErrorDialog $dlog.nohost \
        -ok \
        -message [IntlLocalizeMsg SCO_SA_SELHOST_ERR_NO_HOST_SELECTED] ]
    }
}


proc SaSH:CheckTextCB {instance userproc userdata cbs} {

    global SaSH_info
    set widget [keylget cbs widget]
    set dialog [keylget cbs dialog]

    set uservalue [VtGetValues $widget -value]

    if {[SaHostCheck $uservalue] != 0} {

    set SaSH_info($instance:userselection) $uservalue

    if {$userproc != "NULL"} {
        if {$userdata != "NULL"} {
        $userproc $userdata
        } else {
        $userproc
        }
    }

    } else {
    ErrorPush errorStack 0 SCO_SA_SELHOST_ERR_BAD_HOST
    SaDisplayErrorStacks $dialog.errorbox [list $errorStack] HELP
    }
}

proc SaSH:init {textfield} {

    global SaSH_info
    global SaSH_gl_host_list

    set name {}
    if {![lempty $textfield]} {
        set name [VtGetValues $textfield -value]
        set SaSH_info(screenselection) [format "%-30.30s" $name]
    } else {
        if {[info exists SaSH_info(init)]} {
        return "done"
    }
    }

    set SaSH_gl_host_list [SaHostsGet]

    set SaSH_info(sortby) "name"

    set SaSH_info(filter) "*"


    if {[lempty $name]} {
        set localhost [lindex $SaSH_gl_host_list 0]
        set addr [lindex $localhost 0]
        set name [lindex $localhost 1]
        set SaSH_info(screenselection) [format "%-30.30s  %s" $name $addr]
    }

    return "done"
}

proc SaSH:EndFormCB {cbs} {
    VtDestroyDialog [keylget cbs dialog]
}


proc SaSelectHostGetText {instance} {
    global SaSH_info
    return [VtGetValues $SaSH_info($instance:textwidgetname) -value ]
}

proc SaSelectHostGetTextWidget {instance} {
    global SaSH_info
    return $SaSH_info($instance:textwidgetname)
}

proc SaSelectHostGetButtonWidget {instance} {
    global SaSH_info
    return $SaSH_info($instance:button)
}

proc SaSelectHostGetSelection {instance} {
    global SaSH_info
    if [info exists SaSH_info($instance:userselection)] {
        return $SaSH_info($instance:userselection)
    }
}

#@package: BRW BRW:ExpandoList BRW:ExpandoCollapse BRW:ExpandoGetLevel BRW:ExpandoGetIcon BRW:ExpandoSetIcon BRW:ExpandoGetRecord BRW:ExpandoAddItem BRW:ExpandoDeleteItem BRW:AddItemCB BRW:ExpandoAddItemList BRW:ExpandoListReset
proc BRW:ExpandoList {dlist fmt args {prefixIcon 0}} {
    set dlist [eval VtDrawnList $dlist $args]
    set fmt [linsert $fmt 0 {DATA}]
    VxSetVar $dlist format $fmt
    VxSetVar $dlist count  0
    if {$prefixIcon} {
        VxSetVar $dlist levelOffset 1
    } else {
        VxSetVar $dlist levelOffset 0
    }
    return $dlist
}; # BRW:ExpandoList
proc BRW:ExpandoCollapse {dlist pos} {
    set count [VxGetVar $dlist count]
    if {$pos >= $count} {
    return
    }
    set deleted [BRW:ExpandoDeleteItem $dlist $pos on]
    VtDrawnListSelectItem $dlist -position $pos
    return $deleted
}; # BRW:ExpandoCollapse
proc BRW:ExpandoGetLevel {dlist pos} {
    set record [VtDrawnListGetItem $dlist -position $pos]
    set record [lindex $record 0]
    set recordLevel [lindex $record 0]
    return $recordLevel
}; # BRW:ExpandoGetLevel
proc BRW:ExpandoGetIcon {dlist pos} {
    set record [VtDrawnListGetItem $dlist -position $pos]
    set record [lindex $record 0]
    set icons [lindex $record 1]
    return [lrange $icons end end]
}; # BRW:ExpandoGetIcon
proc BRW:ExpandoSetIcon {dlist pos icon} {
    set record [VtDrawnListGetItem $dlist -position $pos]
    set record [lindex $record 0]
    set icons [lindex $record 1]
    set icons [lreplace $icons end end $icon]
    set record [lreplace $record 1 1 $icons]
    VtDrawnListSetItem $dlist -position $pos -fieldList $record
}; # BRW:ExpandoSetIcon
proc BRW:ExpandoGetRecord {dlist pos level icon rec} {
    set record [VtDrawnListGetItem $dlist -position $pos]
    set record [lindex $record 0]
    set icons [lindex $record 1]
    upvar 1 $icon rIcon $rec rRecord $level rLevel
    set rLevel  [lindex $record  0]
    set rIcon   [lrange $icons end end]
    set rRecord [lrange $record 2 end]
}; # BRW:ExpandoGetRecord
proc BRW:HasDown {icon} {
    switch $icon {
    CONNECT_I -
    CONNECT_T  {
        return 1
    }
    default {
        return 0
    }
    }
}; # BRW:HasDown
proc BRW:HasUp {icon} {
    switch $icon {
    CONNECT_L -
    CONNECT_I -
    CONNECT_T  {
        return 1
    }
    default {
        return 0
    }
    }
}; # BRW:HasUp
proc BRW:SetIconConnector {dlist n col connector} {
    set rec [VtDrawnListGetItem $dlist -position $n]
    set rec [lindex $rec 0]
    set icons [lindex $rec 1]
    if {$col < [llength $icons]} {
    set icons [lreplace $icons $col $col $connector]
    }
    set rec [lreplace $rec 1 1 $icons]
    VtDrawnListSetItem $dlist -position $n -fieldList $rec
}; # BRW:SetIconConnector
proc BRW:GetIconConnector {dlist n col} {
    set rec [VtDrawnListGetItem $dlist -position $n]
    set rec [lindex $rec 0]
    set icons [lindex $rec 1]
    if {$col < [llength $icons]} {
    return [lindex $icons $col]
    } else {
    return ""
    }
}; # BRW:GetIconConnector
proc BRW:PatchConnectors {dlist pos level cmd} {
    set count [VxGetVar $dlist count]
    set levelOffset [VxGetVar $dlist levelOffset]
    set offset [expr 1 - $levelOffset]
    set indx [expr $level - $offset]
    while {1} {
    set icon [BRW:GetIconConnector $dlist $pos $indx]
    set rLevel [BRW:ExpandoGetLevel $dlist $pos]
    if {$cmd == "ADD"} {
        if {$icon == "NO_ICON"} {
        set icon CONNECT_I
        } elseif {$icon == "CONNECT_L"} {
                if {$count > 0} {
            set icon CONNECT_T
                }
        }
    } else {
        if {$icon == "CONNECT_I"} {
        set icon NO_ICON
        } elseif {$icon == "CONNECT_T"} {
        set icon CONNECT_L
        }
    }
    BRW:SetIconConnector $dlist $pos $indx $icon
    incr pos -1
    if {$rLevel <= $level} {
            break
        }
    }
}; # BRW:PatchConnectors
proc BRW:AnalyzeConnect {dlist pos level stateIcon icon} {
    set iconList ""
    if {$stateIcon != "NO_ICON"} {
        lappend iconList $stateIcon
    }
    if {$level == 0} {
        lappend iconList $icon
        return $iconList
    }
    set count [VxGetVar $dlist count]
    if {$count == 0} {
        lappend iconList CONNECT_L $icon
        return $iconList
    }
    if {$pos == 0} {
        set pos [expr $count + 1]
    }
    set aboveRec [VtDrawnListGetItem $dlist -position [expr $pos - 1]]
    set aboveRec [lindex $aboveRec 0]
    if {$pos <= $count} {
        set belowRec [VtDrawnListGetItem $dlist -position $pos]
    set belowRec [lindex $belowRec 0]
    } else {
    set belowRec ""
    }
    set aboveIcons [lindex $aboveRec 1]
    set belowIcons [lindex $belowRec 1]
    set levelOffset [VxGetVar $dlist levelOffset]
    set offset      [expr 1 - $levelOffset]
    set endLevel [expr $level - $offset]
    set start    [expr 0 + $levelOffset]
    for {set i $start} {$i < $endLevel} {incr i} {
    set abvIcon [lindex $aboveIcons $i]
    set blwIcon [lindex $belowIcons $i]
    if {[BRW:HasDown $abvIcon] && [BRW:HasUp $blwIcon]} {
        lappend iconList CONNECT_I
    } else {
        lappend iconList NO_ICON
    }
    }
    set abvIcon [lindex $aboveIcons $endLevel]
    set blwIcon [lindex $belowIcons $endLevel]
    if {[BRW:HasUp $abvIcon] && [BRW:HasUp $blwIcon]} {
        lappend iconList CONNECT_T
    } else {
        lappend iconList CONNECT_L
    }
    lappend iconList $icon
    return $iconList
}; # BRW:AnalyzeConnect
proc BRW:IsConnector {i} {
    switch $i {
    NO_ICON   -
    CONNECT_L -
    CONNECT_I -
    CONNECT_T  {
        return 1
    }
    default {
        return 0
    }
    }
}; # BRW:IsConnector
proc BRW:ExpandoAddItem {dlist pos level icon data {stateIcon NO_ICON}} {
    set count [VxGetVar $dlist count]
    set fmt   [VxGetVar $dlist format]
    set fmt [BRW:GenFormat $fmt $level]
    set connectors [BRW:AnalyzeConnect $dlist $pos $level $stateIcon $icon]
    set data [linsert $data 0 $level $connectors]
    eval [list VtDrawnListAddItem $dlist -formatList $fmt -fieldList $data \
             -position $pos ]
    if {$pos == 0} {
    set pos $count
    } else {
    incr pos -1
    }
    if {$level > 0} {
        BRW:PatchConnectors $dlist $pos $level ADD
    }
    incr count 1
    VxSetVar $dlist count $count
}; # BRW:ExpandoAddItem
proc BRW:ExpandoDeleteItem {dlist pos {collaspe off} } {
    set count [VxGetVar $dlist count]
    set startLevel [BRW:ExpandoGetLevel $dlist $pos]
    if {[BRW:GetIconConnector $dlist $pos [expr $startLevel-1]] == "CONNECT_L"} {
    set patch on
    } else {
    set patch off
    }
    if {$collaspe} {
        incr pos
    }
    set deleted 0
    while {$pos <= $count} {
    VtDrawnListDeleteItem $dlist -position $pos
        incr deleted
    incr count -1
    if {$count == 0 || $pos > $count} {
            break
        }
    set level [BRW:ExpandoGetLevel $dlist $pos]
    if {$level <= $startLevel} {
            break
        }
    }
    if {$patch} {
    incr pos -1
    BRW:PatchConnectors $dlist $pos $startLevel SUB
    }
    VxSetVar $dlist count $count
    return $deleted
}; # BRW:ExpandoDeleteItem
proc BRW:GenFormat {userFormat level} {
    if {[VtInfo -charm]} {
        if {$level > 1} {
            set fList [list ICON [expr $level+2] 1 [expr $level * 2]]
        } else {
            set fList [list ICON [expr $level+2] 1 2]
        }
    } else {
        set fList [list ICON [expr $level+2] 3]
    }
    set fmt [linsert $userFormat 1 $fList]
    return $fmt
}; # BRW:GenFormat
proc BRW:ExpandoAddItemList {dlist pos level itemList} {
    set count [VxGetVar $dlist count]
    set fmt   [VxGetVar $dlist format]
    set fmt [BRW:GenFormat $fmt $level]
    if {$pos == 0} {
        set pos $count
    }
    set abovePos [expr $pos - 1]
    if {$abovePos > 0} {
        set aboveRec [VtDrawnListGetItem $dlist -position $abovePos]
        set aboveRec [lindex $aboveRec 0]
        set type     DRAWNLIST
    } else {
        set aboveRec ""
        set type     DATALIST
    }
    set belowPos $pos
    if {$count > 0 && $belowPos <= $count} {
        set belowRec [VtDrawnListGetItem $dlist -position $belowPos]
        set belowRec [lindex $belowRec 0]
    } else {
        set belowRec ""
    }
    set dataList {}
    set patchPos $abovePos
    set flag 1
    foreach item $itemList {
        set icon      [lindex $item 0]
        set data      [lindex $item 1]
        set stateIcon [lindex $item 2]
        if {[lempty $stateIcon]} {
            set stateIcon NO_ICON
        }
        set connectors [BRW:AnalyzeConnectList $dlist $aboveRec $belowRec \
            $level $stateIcon $icon]
        set data [linsert $data 0 $level $connectors]
        if {$level > 0} {
            BRW:PatchConnector $dlist dataList $data $aboveRec $patchPos \
                $count $type
        }
        lappend dataList $data
        set aboveRec $data
        set type     DATALIST
        incr count
        if {$flag} {
           set flag 0
           set patchPos 0
        } else {
            incr patchPos
        }
    }
    VtDrawnListAddItem $dlist -formatList $fmt \
         -recordList $dataList -position $pos
    VxSetVar $dlist count $count
}; # BRW:ExpandoAddItemList
proc BRW:PatchConnector {dlist dataList itemRec aboveRec position count \
    type} {
    upvar $dataList itemList
    set itemLevel  [lindex $itemRec  0]
    set aboveLevel [lindex $aboveRec 0]
    if {$aboveLevel >= $itemLevel} {
        set patch 0
        set levelOffset [VxGetVar $dlist levelOffset]
        set offset [expr 1 - $levelOffset]
        set aboveIndx [expr $aboveLevel - $offset]
        set itemIndx  [expr $itemLevel  - $offset]
        set aboveIcons [lindex $aboveRec  1]
        set aboveIcon  [lindex $aboveIcons $aboveIndx]
        if {$aboveIcon == "NO_ICON"} {
           set icon CONNECT_I
           set patch 1
        } elseif {$aboveIcon == "CONNECT_L"} {
            if {$count > 0} {
                set icon CONNECT_T
                set patch 1
            }
        }
        if {$patch} {
            if {$type == "DRAWNLIST"} {
                BRW:SetIconConnector $dlist $position $aboveLevel $icon
            } else {
                set itemRec [lindex $itemList $position]
                set itemIcons [lindex $itemRec 1]
                set itemIcons [lreplace $itemIcons $itemIndx $itemIndx $icon]
                set itemRec [lreplace $itemRec 1 1 $itemIcons]
                set itemList [lreplace $itemList $position $position $itemRec]
            }
        }
    }
}; # BRW:PatchConnector
proc BRW:AnalyzeConnectList {dlist aboveRec belowRec level stateIcon icon} {
    set iconList ""
    if {$stateIcon != "NO_ICON"} {
        lappend iconList $stateIcon
    }
    if {$level == 0} {
        lappend iconList $icon
        return $iconList
    }
    set count [VxGetVar $dlist count]
    if {$count == 0} {
        lappend iconList CONNECT_L $icon
        return $iconList
    }
    set aboveIcons [lindex $aboveRec 1]
    set belowIcons [lindex $belowRec 1]
    set levelOffset [VxGetVar $dlist levelOffset]
    set offset      [expr 1 - $levelOffset]
    set endLevel [expr $level - $offset]
    set start    [expr 0 + $levelOffset]
    for {set i $start} {$i < $endLevel} {incr i} {
    set abvIcon [lindex $aboveIcons $i]
    set blwIcon [lindex $belowIcons $i]
    if {[BRW:HasDown $abvIcon] && [BRW:HasUp $blwIcon]} {
        lappend iconList CONNECT_I
    } else {
        lappend iconList NO_ICON
    }
    }
    set abvIcon [lindex $aboveIcons $endLevel]
    set blwIcon [lindex $belowIcons $endLevel]
    if {[BRW:HasUp $abvIcon] && [BRW:HasUp $blwIcon]} {
        lappend iconList CONNECT_T
    } else {
        lappend iconList CONNECT_L
    }
    lappend iconList $icon
    return $iconList
}; # BRW:AnalyzeConnectList
proc BRW:ExpandoListReset {dlist} {
    VtDrawnListDeleteItem $dlist -all
    VxSetVar $dlist count  0
}; # BRW:ExpandoListReset
#@packend: browser
#@package: SaEH SaMakeObjectCall SaDisplayErrorStacks SaDisplayErrorInfo SaUnexpectedErrorCB SaDisplayNoAuths SaDisplayNotRoot
proc SCO_SA_ERRHANDLER_MSGS {} {}
global SCO_SA_ERRHANDLER_MSGS
set SCO_SA_ERRHANDLER_MSGS(@catalog@) {sysadm.cat@sa 23}
set SCO_SA_ERRHANDLER_MSGS(ERR_CONNECT_FAIL) {1 {%1$s failed to connect to %2$s.\n\nPlease check the following:\n   * your network configuration\n   * your network connection\n   * remote access (rhost) permissions on the remote site\n   * that SCOadmin is installed at the remote site}}
set SCO_SA_ERRHANDLER_MSGS(ERR_UNEXPECTED) {2 {Unexpected error:\n%s}}
set SCO_SA_ERRHANDLER_MSGS(ERR_UNEXPECTED_DT) {3 {\n%s}}
set SCO_SA_ERRHANDLER_MSGS(MSG_ERROR) {4 Error}
set SCO_SA_ERRHANDLER_MSGS(MSG_DETAILS) {5 Details...}
set SCO_SA_ERRHANDLER_MSGS(MSG_ERROR_DT) {6 {Error Details}}
set SCO_SA_ERRHANDLER_MSGS(MSG_NO_AUTHS) {7 {You are not authorized to run %1$s on %2$s}}
set SCO_SA_ERRHANDLER_MSGS(MSG_SAVE_BUTTON) {8 Save...}
set SCO_SA_ERRHANDLER_MSGS(MSG_SAVE_TITLE) {9 {Save Error Details}}
set SCO_SA_ERRHANDLER_MSGS(MSG_NOT_ROOT) {10 {You must be root to run %1$s on %2$s}}
proc SaEH:GetManagedHostName {} {
    return "remote host"
}
proc SaMakeObjectCall {objectCall} {
global errorCode
    set result [catch { eval $objectCall } returnValue]
    if { $result } {
        case [lindex $errorCode 0] {
        ERRORSTACK
        {
            set errorStack [lindex $errorCode 1]
                set topErrorCode [lindex [lindex $errorStack 0] 0]
                if {$topErrorCode == "SCO_LOCAL_PIPE_ERR_CLIENT_CONNECT_FAILURE"} {
                    set localHost [lindex [split [SaHostGetLocalName] .] 0]
                    set managedHost \
            [lindex [split [SaHostGetManagedName] .] 0]
                    ErrorPush errorStack 0 SCO_SA_ERRHANDLER_ERR_CONNECT_FAIL \
                        [list $localHost $managedHost]
                }
        set bmipResponse \
            [list [SaEH:BuildBmipResponse $errorStack]]
        }
        default
        {
        set errorStack [lindex $errorCode 1]
        ErrorThrow errorStack
        }
    }
    } else {
    set bmipResponse $returnValue
    }
    return $bmipResponse
}
proc SaEH:BuildBmipResponse {errorStack} {
    return [list operation class instance attributes {} {} $errorStack]
}
proc SaEH:DisplayErrorStacksIterateCB {newparms cbs} {
    set dialogName [lvarpop newparms]
    set errorStacks [lvarpop newparms]
    set help [lvarpop newparms]
    set callback [lvarpop newparms]
    if {[lempty $errorStacks]} {
        VtUnLock
        eval $callback [list $cbs]
        VtUnLock
        return
    }
    VxEndFormCB $cbs
    SaDisplayErrorStacks $dialogName $errorStacks $help $callback
    VtUnLock
}
proc SaDisplayErrorStacks {dialogName errorStacks help {callBack {}}} {
    if { [lempty $callBack] } {
        set callBack VxEndFormCB
    } else {
        set callBack $callBack
    }
    set errorStack [lvarpop errorStacks]
    set newparms [list $dialogName $errorStacks $help $callBack]
    set callBack [list SaEH:DisplayErrorStacksIterateCB $newparms]
    set stackLength [llength $errorStack]
    set topErrorText [lindex [lindex $errorStack 0] 1]
    if { $stackLength == 1 } {
        if { $help == "HELP" } {
        set error [VtFormDialog $dialogName \
            -title [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_ERROR] \
            -defaultButton OK \
            -ok \
            -okCallback $callBack \
            -autoLock [lindex $callBack 0] \
            -cancelButton OK \
            -help \
            -autoDestroy FALSE \
            -autoHide FALSE \
            -defaultButton OK \
            -cancelButton OK ]
        } else {
        set error [VtFormDialog $dialogName \
            -title [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_ERROR] \
            -defaultButton OK \
            -ok \
            -okCallback $callBack \
            -autoLock [lindex $callBack 0] \
            -cancelButton OK \
            -autoDestroy FALSE \
            -autoHide FALSE \
            -defaultButton OK \
            -cancelButton OK ]
        }
    } else {
        set list {}
        foreach entry $errorStack {
            set list [format "%s\n%s" $list [lindex $entry 1]]
        }
        set list [string trimleft $list "\n"]
        if { $help == "HELP" } {
        set error [VtFormDialog $dialogName \
            -title [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_ERROR] \
            -ok \
            -okCallback $callBack \
            -cancel \
            -cancelLabel [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_DETAILS] \
            -cancelCallback "SaEH:ShowObjectErrorDetails [list $list]" \
            -autoLock [list SaEH:ShowObjectErrorDetails \
                   [lindex $callBack 0]] \
            -help \
            -autoDestroy FALSE \
            -autoHide FALSE \
            -defaultButton OK \
            -cancelButton OK \
            ]
        } else {
        set error [VtFormDialog $dialogName \
            -title [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_ERROR] \
            -ok \
            -okCallback $callBack \
            -cancel \
            -cancelLabel [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_DETAILS] \
            -cancelCallback "SaEH:ShowObjectErrorDetails [list $list]" \
            -autoLock [list SaEH:ShowObjectErrorDetails \
                   [lindex $callBack 0]] \
            -autoDestroy FALSE \
            -autoHide FALSE \
            -defaultButton OK \
            -cancelButton OK \
            ]
        }
    }
    VtLabel $error.message \
        -rightSide FORM \
        -label $topErrorText
    VtSetFocus [VtGetValues $error -ok]
    VtShow $error
}
proc SaEH:SaveDetailsCB {pdialog errorList cbs} {
    set dialog [keylget cbs dialog]
    set file [keylget cbs selection]
    if {[catch [list open $file w] fd]} {
        VtShow [VtErrorDialog $dialog.writeerror \
            -message $fd]
        return
    } else {
        VtDestroyDialog $dialog
        VtSetFocus [VtGetValues $pdialog -ok]
        puts $fd $errorList
        close $fd
    }
}
proc SaEH:SaveDetailsFileSelectCB {errorList cbs} {
    set dialog [keylget cbs dialog]
    global env
    set dir [pwd]
    set dir [string trimright $dir "/"]/
    VtShow [VtFileSelectionDialog $dialog.fileSelect \
        -title \
        [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_SAVE_TITLE] \
        -filter "${dir}*" \
        -selection "$dir" \
        -okCallback [list SaEH:SaveDetailsCB $dialog $errorList] \
        -autoDestroy 0 -autoHide 0 \
        -cancelCallback VxEndFormCB \
        ]
    VtUnLock
}
proc SaEH:ShowObjectErrorDetails {errorList cbs} {
    set detailsForm [VtFormDialog [keylget cbs dialog].detailsForm \
            -title [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_ERROR_DT] \
            -ok \
            -defaultButton OK \
            -okCallback VxEndFormCB \
            -apply \
            -applyLabel \
            [IntlLocalizeMsg SCO_SA_ERRHANDLER_MSG_SAVE_BUTTON] \
            -applyCallback \
                [list SaEH:SaveDetailsFileSelectCB $errorList] \
            -autoLock SaEH:SaveDetailsFileSelectCB \
            -cancelButton OK]
    VtText $detailsForm.text \
            -readOnly \
            -value $errorList \
            -verticalScrollBar TRUE \
            -horizontalScrollBar TRUE \
            -rows 5 \
            -columns 50    \
            -rightSide FORM \
            -bottomSide FORM
    VtShow $detailsForm
    VtUnLock
}
proc SaDisplayErrorInfo {errorDialog topErrorText help {callback {}}} {
global errorInfo
 ErrorPush errorStack 0 SCO_SA_ERRHANDLER_ERR_UNEXPECTED_DT [list $errorInfo]
 ErrorPush errorStack 0 SCO_SA_ERRHANDLER_ERR_UNEXPECTED [list $topErrorText]
 SaDisplayErrorStacks $errorDialog [list $errorStack] $help $callback
}
proc SaUnexpectedErrorCB {callback cbs} {
    set dialog [keylget cbs dialog]
    set errorText [keylget cbs result]
    if {[SaEH:ExpectedUnexpectedError $errorText]} {
        VtUnLock
        return
    }
    SaDisplayErrorInfo $dialog.errorInfo $errorText HELP $callback
    VtUnLock
}
proc SaEH:ExpectedUnexpectedError {text} {
    if {[string match "*Duplicate name*" $text]} {
        return 1
    }
    return 0
}
proc SaDisplayNoAuths {dialogName manager cb {host {}}
    {messageId SCO_SA_ERRHANDLER_MSG_NO_AUTHS}} {
        if {$host == ""} {
            set host [SaHostGetLocalName]
        }
        VtShow [VtMessageDialog $dialogName \
                -message [IntlLocalizeMsg $messageId [list $manager $host] ] \
                -cancelButton OK \
                -okCallback $cb -ok -help ]
}
proc SaDisplayNotRoot {dialogName manager cb {host {}}  } {
    SaDisplayNoAuths $dialogName $manager $cb $host \
        SCO_SA_ERRHANDLER_MSG_NOT_ROOT
}
#@packend SaEH
#@package: SaHost SaHostGetLocalName SaHostGetManagedName SaHostRemoteOsaAccessible SaHostsGet SaHostCheck SaHostExtractSystemName SaHostExtractDomain
proc SaHostGetLocalName {} {
    set errStack ""
    if {[file executable /usr/ucb/hostname]} {
            set host [CallNonStdCmd /usr/ucb/hostname {} "" errStack]
    }
    if {[file executable /usr/sbin/hostname]} {
            set host [CallNonStdCmd /usr/sbin/hostname {} "" errStack]
    }
        if {[ErrorStackSize errStack]} {
               set host [CallNonStdCmd uname {-n} "" errStack]
        }
        if {[ErrorStackSize errStack]} {
                set host "localhost"
        }
    return $host
}
proc SaHostGetManagedName {} {
    global argv
    if { $argv == "" } {
        return [SaHostGetLocalName]
    } else {
        return [lindex $argv 0]
    }
}
proc SaHostRemoteOsaAccessible {} {
    if {[FWIdentifingHostsByIpMethod]} {
    return 1
    } else {
    return 0
    }
}
proc SaHostExtractSystemName {hostname} {
    set first [lindex [split $hostname .] 0]
    if {[ctype digit $first]} {
        return $hostname
    } else {
        return $first
    }
}
proc SaHostExtractDomain {host} {
    if {[set i [string first "." $host]] == -1} {
        return {}
    }
    incr i
    return [string range $host $i end]
}
proc SaHostsGet {} {
    if {[catch {ObjectGet {sco selhost} {dummyInstance} hostAddrList} result]} {
        return [list "" ""]
    } else {
    set newlist {}
        set hostlist [lindex [lindex [lindex [lindex $result 0] 3] 0] 1]
    foreach one $hostlist {
        set addr [lindex [lindex $one 0] 0]
            set name [lindex [lindex $one 0] 1]
            lappend newlist [format "%s %s" $addr $name]
    }
    return $newlist
    }
}
proc SaHostCheck {hostname} {
    set result 1
    return $result
}
#@packend SaHost
#@package: SCO_SCREENPOLICY_MSGS SCO_SCREENPOLICY_MSGS
proc SCO_SCREENPOLICY_MSGS {} {}
global SCO_SCREENPOLICY_MSGS
set SCO_SCREENPOLICY_MSGS(@catalog@) {defaults 1}
set SCO_SCREENPOLICY_MSGS(ERR_APP_NOT_FOUND) {1 {Section %s not found}}
set SCO_SCREENPOLICY_MSGS(ERR_ATTR_NOT_FOUND) {2 {Attribute %s not found}}
#@packend
#@package: SaScreenPolicy  SaScreenPolicyGet SaScreenPolicySet
proc SaScreenPolicyGet {app attribute} {
    global env
    set home [string trimright $env(HOME) "/"]
    set stanzaFile ${home}/.scoadmin.pref
    ErrorCatch {} 1 "StanzaOpen $stanzaFile STZ_RDONLY" handle
    set sects [StanzaGetSects $handle]
    if {[lsearch $sects $app] == -1} {
        StanzaClose $handle
        ErrorPush {} 1 SCO_SCREENPOLICY_ERR_APP_NOT_FOUND $app
    }
    set attrs [StanzaGetAttrs $handle $app]
    if {[lsearch $attrs $attribute] != -1} {
        set value [StanzaGetVals $handle $app $attribute]
    } else {
        ErrorPush {} 1 SCO_SCREENPOLICY_ERR_ATTR_NOT_FOUND $attribute
    }
    StanzaClose $handle
    return $value
} ;# SaScreenPolicyGet
proc SaScreenPolicySet {app attribute value} {
    global env
    set home [string trimright $env(HOME) "/"]
    set stanzaFile ${home}/.scoadmin.pref
    ErrorCatch {} 1 "StanzaOpen $stanzaFile STZ_RDWR" handle
    set sects [StanzaGetSects $handle]
    if {[lsearch $sects $app] == -1} {
        StanzaAddSect $handle $app
    }
    set attrs [StanzaGetAttrs $handle $app]
    if {[lsearch $attrs $attribute] == -1} {
        StanzaAddAttr $handle $app $attribute
    }
    StanzaReplaceValue $handle $app $attribute $value
    StanzaClose $handle
} ;# SaScreenPolicySet
#@packend
#@package: SaSB SaStatusBar SaStatusBarSet SaStatusBarGet SaStatusBarClear SaStatusBarHide SaStatusBarShow SaShortHelpCB SaShortHelpSetState SaShortHelpGetState SaShortHelpMenuOptions SaShortHelpLoad SaShortHelpStore
proc SCO_SA_STATUSBAR_MSGS {} {}
global SCO_SA_STATUSBAR_MSGS
set SCO_SA_STATUSBAR_MSGS(@catalog@) {sysadm.cat@sa 21}
set SCO_SA_STATUSBAR_MSGS(MSG_POINTHELP) {1 {Point Help}}
set SCO_SA_STATUSBAR_MSGS(MSG_SHPOINTHELP) {2 {Enable/disable Point Help}}
set SCO_SA_STATUSBAR_MSGS(ERR_BADSTORE) {3 {Unable to save short help preference(s)}}
proc SaSB:SetDefaultFormSpacing {form} {
    VtSetValues $form \
        -horizontalSpacing 0 \
        -verticalSpacing 0 \
        -marginWidth 0 \
        -marginHeight 0
    return $form
}
proc SaSB:SaGetParentWidget {child} {
    set i [string last . $child]
    incr i -1
    return [string range $child 0  $i]
}
proc SaStatusBar {name {main 0} {icon /usr/lib/scoadmin/icons/statuslogo.px}} {
    set charm [VtInfo -charm]
    if $charm {
        set leftOffset 0
    } else {
        set leftOffset 5
    }
    set parent [SaSB:SaGetParentWidget $name]
    if !$charm {
        set bar [VtSeparator ${name}bar \
                -xmArgs [list XmNseparatorType XmNO_LINE] \
                -topSide NONE \
                -leftSide FORM \
                -rightSide FORM]
    }
    set form [VtForm $name \
            -topOffset 0 \
            -topSide NONE \
            -leftSide FORM \
            -rightSide FORM \
            -bottomSide FORM \
            -bottomOffset 0]
    SaSB:SetDefaultFormSpacing $form
    set statusBar $form
    if !$charm {
        VtSetValues $bar -bottomSide $form
        set statusBar $bar
    }
    set topSide FORM
    set rightSide FORM
    if {$main} {
        set statusSep [VtSeparator $form.statusSep \
                -topOffset 0 \
                -leftOffset 0 \
                -rightOffset 0\
                -leftSide FORM \
                -rightSide FORM]
        set logoLabel [VtLabel $form.logoLabel \
                    -leftSide NONE \
                    -rightSide FORM \
                    -rightOffset 2 \
                    -topSide $statusSep \
                    -MOTIF_pixmap $icon \
                    -label "" \
                    -bottomSide FORM]
        set topSide $statusSep
        set rightSide $logoLabel
        global SaSB_mainBar
        set SaSB_mainBar $statusBar
    }
    set statusLabel [VtLabel $form.statusLabel \
                -label " " \
                -labelLeft \
                -leftSide FORM \
                -rightSide $rightSide \
                -topSide $topSide \
                -leftOffset $leftOffset \
                -recomputeSize 0 \
                -bottomSide FORM]
    VxSetVar $statusBar statusLabel $statusLabel
    VxSetVar $statusBar form $form
    VxSetVar $statusBar visible 1
    VxSetVar $parent statusBar $statusBar
    return $statusBar
}
proc SaStatusBarSet {form text} {
    set statusLabel [VxGetVar $form statusLabel]
    set old [VtGetValues $statusLabel -label]
    VtSetValues $statusLabel -label $text
    return $old
}
proc SaStatusBarClear {form} {
    set statusLabel [VxGetVar $form statusLabel]
    set old [VtGetValues $statusLabel -label]
    VtSetValues $statusLabel -label " "
    return $old
}
proc SaStatusBarGet {form} {
    set statusLabel [VxGetVar $form statusLabel]
    return [VtGetValues $statusLabel -label]
}
set SaSB_shortHelpEnabled 1
proc SaShortHelpCB {cbs} {
    global SaSB_shortHelpEnabled
    if {!$SaSB_shortHelpEnabled} {
        return
    }
    set dialog [keylget cbs dialog]
    set form [VxGetVar $dialog statusBar]
    set text [keylget cbs helpString]
    if {[lempty $text]} {
        set text " "
    }
    SaStatusBarSet $form $text
}
proc SaShortHelpSetState {state} {
    global SaSB_shortHelpEnabled
    set SaSB_shortHelpEnabled $state
    if {!$state} {
        global SaSB_mainBar
        if {[info exists SaSB_mainBar]} {
            SaStatusBarClear $SaSB_mainBar
        }
    }
}
proc SaShortHelpGetState {} {
    global SaSB_shortHelpEnabled
    return $SaSB_shortHelpEnabled
}
proc SaSB:SaShortHelpMenuOptionCB {cbs} {
    set widget [keylget cbs widget]
    SaShortHelpSetState [VtGetValues $widget -value]
}
proc SaShortHelpMenuOptions {menu} {
    set shortHelpButton [VtToggleButton $menu.shortHelp \
        -label [IntlLocalizeMsg SCO_SA_STATUSBAR_MSG_POINTHELP] \
        -callback SaSB:SaShortHelpMenuOptionCB \
        -value [SaShortHelpGetState] \
        -shortHelpCallback SaShortHelpCB \
    -shortHelpString [IntlLocalizeMsg SCO_SA_STATUSBAR_MSG_SHPOINTHELP]]
    return $shortHelpButton
}
proc SaShortHelpLoad {client} {
    set state [SaShortHelpGetState]
    if {[catch {SaScreenPolicyGet $client shorthelp} state] == 0} {
        SaShortHelpSetState $state
    }
    global SaSB_state
    set SaSB_state [SaShortHelpGetState]
    return $state
}
proc SaShortHelpStore {client} {
    set state [SaShortHelpGetState]
    global SaSB_state
    if {[info exists SaSB_state]} {
        if {$state == $SaSB_state} {
            return $state
        }
    }
    set cmd [list SaScreenPolicySet $client shorthelp $state]
    ErrorCatch errorStack 1 $cmd dummy SCO_SA_STATUSBAR_ERR_BADSTORE
    return $state
}
proc SaStatusBarHide {form} {
    if {[VtInfo -charm]} {
        return
    }
    VtSetValues $form -bottomSide FORM
    VtHide [VxGetVar $form form]
    VxSetVar $form visible 0
}
proc SaStatusBarShow {form} {
    if {[VtInfo -charm]} {
        return
    }
    set sub [VxGetVar $form form]
    VtShow $sub
    VtSetValues $form -bottomSide $sub
    VxSetVar $form visible 1
}
proc SaStatusBarVisible {form} {
    if {[catch {VxGetVar $form visible} visible]} {
        return 1
    }
    return $visible
}
#@packend: SaSB
#@package: SaTL SaTwoList SaTwoListGetItems SaTwoListSelectItems SaTwoListAddItems SaTwoListDeleteItems SaTwoListGetTabList SaTwoListSetFocus
proc SCO_SA_TWOLIST_MSGS {} {}
global SCO_SA_TWOLIST_MSGS
set SCO_SA_TWOLIST_MSGS(@catalog@) {sysadm.cat@sa 19}
set SCO_SA_TWOLIST_MSGS(MSG_SEARCH_FOR_LABEL) {1 {Search for:}}
proc SaTwoListGetItems {twoList list} {
    set listWidget [VxGetVar $twoList list${list}]
    return [VtGetValues $listWidget -itemList]
}
proc SaTwoListSelectItems {twoList list itemList} {
    set listWidget [VxGetVar $twoList list${list}]
    VtListSelectItem $listWidget -notify -itemList $itemList
}
proc SaTwoListAddItems {twoList list itemList} {
    set listWidget [VxGetVar $twoList list${list}]
    VtListAddItem $listWidget -itemList $itemList
}
proc SaTwoListDeleteItems {twoList list} {
    set listWidget [VxGetVar $twoList list${list}]
    VtListDeleteItem $listWidget -all
}
proc SaTwoList {widget \
                label1_label list1_items \
                label2_label list2_items \
                1To2Button_label 2To1Button_label \
                {optionList {}}} {
    set listRows 7
    set listColumns auto
    set selection multiple
    set search neither
    set sorting {}
    set copySelected never
    set movement next
    set searchLabel1_label [IntlLocalizeMsg SCO_SA_TWOLIST_MSG_SEARCH_FOR_LABEL]
    set searchLabel2_label $searchLabel1_label
    foreach element $optionList {
        set option [lindex $element 0]
        case $option in {
            {-rows} {
                if {[llength $element] != 2} {
                    error "$option needs a single integer argument"
                }
                set listRows [lindex $element 1]
                if {![ctype digit $listRows]} {
                    error "$option needs a single integer argument"
                }}
            {-columns} {
                if {[llength $element] != 2} {
                    error "$option needs a single integer argument"
                }
                set listColumns [lindex $element 1]
                if {![ctype digit $listColumns]} {
                    error "$option needs a single integer argument"
                }
                if {$listColumns <= 0} {
                    set listColumns auto
                } else {
            if [WsInfo -charm] {
                incr listColumns 2
            }
        }}
            {-selection} {
                if {[llength $element] != 2} {
                    error "$option needs an argument, either 'single' or multiple'"
                }
                set selection [lindex $element 1]
                case $selection in {
                    {single multiple} {}
                    default {
                         error "$option needs an argument, either 'single' or multiple'"
                }}}
            {-search} {
                if {[llength $element] != 2} {
                    error "$option needs an argument, one of 'list1' 'list2' 'neither' or 'both'"
                }
                set search [lindex $element 1]
                case $search in {
                    {list1 list2 neither both} {}
                    default {
                        error "$option needs an argument, one of 'list1' 'list2' 'neither' or 'both'"
                }}}
            {-sorting} {
                if {[llength $element] != 2} {
                    error "$option needs an argument, either 'none' or a valid lsort option."
                }
                set sorting [lindex $element 1]}
            {-copySelected} {
                if {[llength $element] != 2} {
                    error "$option needs an argument, one of 'never', '1To2', '2To1', 'always'"
                }
                set copySelected [lindex $element 1]
                case $copySelected in {
                    {never 1To2 2To1 always} {}
                    default {
                        error "$option needs an argument, one of 'never', '1To2', '2To1', 'always'"
                }}}
            {-movement} {
                if {[llength $element] != 2} {
                    error "$option needs an argument, either 'next' or 'follow'"
                }
                set movement [lindex $element 1]
                case $movement in {
                    {next follow} {}
                    default {
                        error "$option needs an argument, either 'next' or 'follow'"
                }}}
        }
    }
    set maxwidth 35
    if {$listColumns == "auto"} {
        set max [SaTL:GetLabelMaxLength $label1_label]
        set len [SaTL:GetLabelMaxLength $label2_label]
        if { $len > $max } {
            set max $len
        }
        set len [SaTL:GetLabelMaxLength $searchLabel1_label]
        if { $len > $max } {
            set max $len
        }
        set len [SaTL:GetLabelMaxLength $searchLabel2_label]
        if { $len > $max } {
            set max $len
        }
        foreach entry $list1_items {
            set cur [expr "[string length $entry] + 2"]
            if {$cur > $max} {
                set max $cur
            }
        }
        foreach entry $list2_items {
            set cur [expr "[string length $entry] + 2"]
            if {$cur > $max} {
                set max $cur
            }
        }
    } else {
        set max $listColumns
    }
    if {$max > $maxwidth} {set max $maxwidth}
    case $search in {
        {list1} {set search1_present 1; set search2_present 0}
        {list2} {set search1_present 0; set search2_present 1}
        {neither} {set search1_present 0; set search2_present 0}
        {both} {set search1_present 1; set search2_present 1}
    }
    case $copySelected in {
        {1To2} {set 1To2Move 0; set 2To1Move 1}
        {2To1} {set 1To2Move 1; set 2To1Move 0}
        {never} {set 1To2Move 1; set 2To1Move 1}
        {always} {set 1To2Move 0; set 2To1Move 0}
    }
    set selection [string toupper $selection]
if {$selection == "SINGLE"} {set selection BROWSE}
    if {$selection == "MULTIPLE"} {set selection EXTENDED}
    set parent [join [lreplace [split $widget "."] end end] "."]
    set formname [lindex [split $widget "."] end]
    set form \
            [VtForm $parent.$formname -verticalSpacing 0 -horizontalSpacing 0]
    set label1 \
            [VtLabel $form.label1 \
                    -label $label1_label \
                    -labelLeft]
    set list1 \
            [VtList $form.list1 \
            -columns $max \
            -rows $listRows \
                    -itemList $list1_items \
                    -selection $selection \
            -callback "SaTL:List1CB $form" \
            -scrollBar 1 \
            -defaultCallback "SaTL:1To2CB $form"]
if {$selection == "BROWSE"} {VtSetValues $list1 -autoSelect 1}
    VxSetVar $list1 sortOptions $sorting
    VxSetVar $list1 selectBehaviour $movement
    if {$search1_present} {
        set searchLabel1 \
                [VtLabel $form.searchLabel1 \
                        -label $searchLabel1_label \
                        -labelLeft]
        set searchField1 \
                [VtText $form.searchField1 \
                        -columns $max \
                        -callback "SaTL:Search1CB $form"]
    }
    set buttonRowCol \
            [VtRowColumn $form.buttonRowCol]
    set 1To2Button \
            [VtPushButton $buttonRowCol.1To2Button \
                    -label $1To2Button_label \
                    -labelCenter \
                    -callback "SaTL:1To2CB $form"]
    VtSetSensitive $1To2Button 0
    set 2To1Button \
            [VtPushButton $buttonRowCol.2To1Button \
                    -label $2To1Button_label \
                    -labelCenter \
                    -callback "SaTL:2To1CB $form"]
    VtSetSensitive $2To1Button 0
    set label2 \
            [VtLabel $form.label2 \
                    -label $label2_label \
                    -labelLeft]
    set list2 \
            [VtList $form.list2 \
                    -columns $max \
            -rows $listRows \
                    -itemList $list2_items \
                    -selection $selection \
                    -callback "SaTL:List2CB $form" \
            -scrollBar 1 \
                    -defaultCallback "SaTL:2To1CB $form"]
if {$selection == "BROWSE"} {VtSetValues $list2 -autoSelect 1}
    VxSetVar $list2 sortOptions $sorting
    VxSetVar $list2 selectBehaviour $movement
    if {$search2_present} {
        set searchLabel2 \
                [VtLabel $form.searchLabel2 \
                        -label $searchLabel2_label \
                        -labelLeft]
        set searchField2 \
                [VtText $form.searchField2 \
                        -columns $max \
                        -callback "SaTL:Search2CB $form"]
    }
    VtSetValues $label1 -topSide FORM -topOffset 0 -leftSide FORM -leftOffset 0
    VtSetValues $list1 -topSide $label1 -leftSide FORM -leftOffset 0
    VtSetValues $buttonRowCol -leftSide $list1 -alignTop $list1
    VtSetValues $label2 -topSide FORM -topOffset 0 -leftSide $buttonRowCol
    VtSetValues $list2 -topSide $label2 -leftSide $buttonRowCol
    if {$search1_present} {
        VtSetValues $searchLabel1 -topSide $list1 -leftSide FORM -leftOffset 0 \
                -alignRight $list1
        VtSetValues $searchField1 -topSide $searchLabel1 -leftSide FORM \
                -leftOffset 0 -alignRight $searchLabel1
    }
    if {$search2_present} {
        VtSetValues $searchLabel2 -topSide $list2 -leftSide $buttonRowCol \
                -alignRight $list2
        VtSetValues $searchField2 -topSide $searchLabel2 \
                -leftSide $buttonRowCol -alignRight $searchLabel2
    }
    VxSetVar $form selectionType $selection
    VxSetVar $form selectionMovement $movement
    VxSetVar $form buttonRowCol $buttonRowCol
    VxSetVar $form 1To2Move $1To2Move
    VxSetVar $form 2To1Move $2To1Move
    VxSetVar $form label1 $label1
    VxSetVar $form list1 $list1
    VxSetVar $form label2 $label2
    VxSetVar $form list2 $list2
    VxSetVar $form 1To2Button $1To2Button
    VxSetVar $form 2To1Button $2To1Button
    if {$search1_present} {
        VxSetVar $form searchLabel1 $searchLabel1
        VxSetVar $form searchField1 $searchField1
    } else {
        VxSetVar $form searchLabel1 {}
        VxSetVar $form searchField1 {}
    }
    if {$search2_present} {
        VxSetVar $form searchLabel2 $searchLabel2
        VxSetVar $form searchField2 $searchField2
    } else {
        VxSetVar $form searchLabel2 {}
        VxSetVar $form searchField2 {}
    }
    return $form
}
proc SaTL:GetLabelMaxLength {label} {
    set list [split $label "\n"]
    set max [string length [lindex $list 0]]
    foreach item $list {
        if { [string length $item] > $max } {
        set max [string length $item]
        }
     }
    return $max
}
proc SaTL:List1Sensitive {twoList} {
    set 1To2Button [VxGetVar $twoList 1To2Button]
    set 2To1Button [VxGetVar $twoList 2To1Button]
    set list1  [VxGetVar $twoList list1]
    set list2  [VxGetVar $twoList list2]
    VtSetSensitive $1To2Button 1
    VtSetSensitive $2To1Button 0
    VtListDeselectItem $list2 -all
    VtSetFocus $list1
}
proc SaTL:List2Sensitive {twoList} {
    set 1To2Button [VxGetVar $twoList 1To2Button]
    set 2To1Button [VxGetVar $twoList 2To1Button]
    set list1  [VxGetVar $twoList list1]
    set list2  [VxGetVar $twoList list2]
    VtSetSensitive $1To2Button 0
    VtSetSensitive $2To1Button 1
    VtListDeselectItem $list1 -all
    VtSetFocus $list2
}
proc SaTL:List1CB {twoList cbs} {
    set currval [keylget cbs selectedItemList]
    if {[lempty $currval]} {
        VtSetSensitive [VxGetVar $twoList 1To2Button] 0
    } else {
        SaTL:List1Sensitive $twoList
    }
}
proc SaTL:List2CB {twoList cbs} {
    set selectedItemList [keylget cbs selectedItemList]
    if {[lempty $selectedItemList]} {
        VtSetSensitive [VxGetVar $twoList 2To1Button] 0
    } else {
        SaTL:List2Sensitive $twoList
    }
}
proc SaTL:Search1CB {twoList cbs} {
    set searchValue [VtGetValues [keylget cbs widget] -value]
    set list1 [VxGetVar $twoList list1]
    set itemList [VtGetValues $list1 -itemList]
    set listIndex [lsearch $itemList ${searchValue}*]
    if {$listIndex > -1} {
        VtListSelectItem $list1 -notify -position [expr $listIndex+1]
        SaListShowSelectedItem $list1
    }
}
proc SaTL:Search2CB {twoList cbs} {
    set searchValue [VtGetValues [keylget cbs widget] -value]
    set list2 [VxGetVar $twoList list2]
    set itemList [VtGetValues $list2 -itemList]
    set listIndex [lsearch $itemList ${searchValue}*]
    if {$listIndex > -1} {
        VtListSelectItem $list2 -notify -position [expr $listIndex+1]
        SaListShowSelectedItem $list2
    }
}
proc SaTL:1To2CB {twoList cbs} {
    set list1 [VxGetVar $twoList list1]
    set selectedItemList [VtListGetSelectedItem $list1 -byItemList]
    if {[lempty $selectedItemList]} {return}
    set list2 [VxGetVar $twoList list2]
    set list2ItemList [VtGetValues $list2 -itemList]
    set list2AddList {}
    foreach item $selectedItemList {
        if {[lsearch $list2ItemList $item] < 0} {
            lappend list2AddList $item
        }
    }
    if {[VxGetVar $twoList 1To2Move]} {
        set selectNextItem 1
        set nextPosition [SaTL:DeleteFromList $list1 $selectedItemList]
    } else {
        set selectNextItem 0
    }
    if {![lempty $list2AddList]} {
        SaTL:AddToList $list2 $list2AddList
    }
    if {[VxGetVar $twoList selectionMovement] == "next"} {
        if {$selectNextItem} {
            if {$nextPosition < 0} {
                VtSetSensitive [VxGetVar $twoList 1To2Button] 0
            } else {
                VtListSelectItem $list1 -notify -position $nextPosition
            }
        }
    } else {
        VtListSelectItem $list2 -notify -itemList $selectedItemList
        SaTL:List2Sensitive $twoList
    }
}
proc SaTL:2To1CB {twoList cbs} {
    set list2 [VxGetVar $twoList list2]
    set selectedItemList [VtListGetSelectedItem $list2 -byItemList]
    if {[lempty $selectedItemList]} {return}
    set list1 [VxGetVar $twoList list1]
    set list1ItemList [VtGetValues $list1 -itemList]
    set list1AddList {}
    foreach item $selectedItemList {
        if {[lsearch $list1ItemList $item] < 0} {
            lappend list1AddList $item
        }
    }
    if {[VxGetVar $twoList 2To1Move]} {
        set selectNextItem 1
        set nextPosition [SaTL:DeleteFromList $list2 $selectedItemList]
    } else {
        set selectNextItem 0
    }
    if {![lempty $list1AddList]} {
        SaTL:AddToList $list1 $list1AddList
    }
    if {[VxGetVar $twoList selectionMovement] == "next"} {
        if {$selectNextItem} {
            if {$nextPosition < 0} {
                VtSetSensitive [VxGetVar $twoList 2To1Button] 0
            } else {
                VtListSelectItem $list2 -notify -position $nextPosition
            }
        }
    } else {
        VtListSelectItem $list1 -notify -itemList $selectedItemList
        SaTL:List1Sensitive $twoList
    }
}
proc SaTL:DeleteFromList {listWidget deleteItems} {
    set currentItems [VtGetValues $listWidget -itemList]
    set firstDeleteItem [lindex $deleteItems 0]
    set nextItemPosition [expr "[lsearch $currentItems $firstDeleteItem] + 1"]
    VtListDeleteItem $listWidget -itemList $deleteItems
    if {[llength [VtGetValues $listWidget -itemList]] \
            < $nextItemPosition} {
        incr nextItemPosition -1
    }
    if {$nextItemPosition == 0} {return -1}
    return $nextItemPosition
}
proc SaTL:AddToList {listWidget addItems} {
    set sortOptions [VxGetVar $listWidget sortOptions]
    set currentItems [VtGetValues $listWidget -itemList]
    case $sortOptions in {
        {none} {
            set newItems [concat $currentItems $addItems]}
        {} {
            set newItems \
        [lsort [concat $currentItems $addItems]]}
        default {
            set newItems \
                    [lsort $sortOptions [concat $currentItems $addItems]]}
    }
    VtListDeleteItem $listWidget -all
    VtListAddItem $listWidget -itemList $newItems
}
proc SaTwoListGetTabList {form} {
    lappend list [VxGetVar $form list1]
        lappend list [VxGetVar $form searchField1]
    lappend list [VxGetVar $form 1To2Button]
    lappend list [VxGetVar $form 2To1Button]
    lappend list [VxGetVar $form list2]
        lappend list [VxGetVar $form searchField2]
    return $list
}
proc SaTwoListSetFocus {twoList {i 1}} {
    set list list$i
    if {[lempty [SaTwoListGetItems $twoList $i]]} {
        set i [expr $i==1 ? 2 : 1]
        set list list${i}
        if {[lempty [SaTwoListGetItems $twoList $i]]} {
            VtSetFocus [VxGetVar $twoList $list]
            return
        }
    }
    set list [VxGetVar $twoList $list]
    VtSetFocus $list
    if {[lempty [VtListGetSelectedItem $list]]} {
        VtListSelectItem $list -position 1 -notify
    }
}
#@packend saTwoList
#@package: SaAR SaAutoRefresh SaAutoRefreshGetState SaAutoRefreshSetInterval SaAutoRefreshGetInterval SaAutoRefreshOn SaAutoRefreshOff SaAutoRefreshCalled SaAutoRefreshLoad SaAutoRefreshStore SaAutoRefreshPause SaAutoRefreshResume SaAutoRefreshIntervalCB
proc SCO_SA_AUTOREFRESH_MSGS {} {}
global SCO_SA_AUTOREFRESH_MSGS
set SCO_SA_AUTOREFRESH_MSGS(@catalog@) {sysadm.cat@sa 17}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SHSETREFRESH) {1 {Configure automatic refresh parameters}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SHREFRESH) {2 {Refresh %s}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SHREFRESHON) {3 {Enable automatic refresh}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SHREFRESHOFF) {4 {Disable automatic refresh}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SHREFRESHINT) {5 {Set time interval for automatic refresh}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_INTERVAL) {6 {Auto Refresh Interval}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_MINUTES) {7 Minutes}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SETREFRESH) {8 {Set Auto Refresh}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SETREFRESHMN) {9 S}
set SCO_SA_AUTOREFRESH_MSGS(MSG_REFRESHNOW) {10 {Refresh Now}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_REFRESH) {11 Refresh}
set SCO_SA_AUTOREFRESH_MSGS(MSG_REFRESHMN) {12 f}
set SCO_SA_AUTOREFRESH_MSGS(MSG_REFRESHACC) {13 <Key>F5}
set SCO_SA_AUTOREFRESH_MSGS(MSG_REFRESHACCSTR) {14 F5}
set SCO_SA_AUTOREFRESH_MSGS(MSG_ON) {15 On}
set SCO_SA_AUTOREFRESH_MSGS(MSG_ONMN) {16 O}
set SCO_SA_AUTOREFRESH_MSGS(MSG_OFF) {17 Off}
set SCO_SA_AUTOREFRESH_MSGS(MSG_OFFMN) {18 f}
set SCO_SA_AUTOREFRESH_MSGS(MSG_REFRESHINT) {19 Interval...}
set SCO_SA_AUTOREFRESH_MSGS(MSG_REFRESHINTMN) {20 I}
set SCO_SA_AUTOREFRESH_MSGS(ERR_BADSTORE) {21 {Unable to save auto refresh preferences}}
set SCO_SA_AUTOREFRESH_MSGS(MSG_SHREFRESHDATA) {22 {Refresh data}}
set SaAR_State 0            ;# until this is implemented
set SaAR_Interval 120000    ;# dummy value for now
set SaAR_Menu ""            ;# if null, no button actions
set SaAR_RefreshCB    ""
set SaAR_ID        ""
set SaAR_Lock        0
proc SaAutoRefresh {refreshCB {menu ""} {shortStr ""} {shortCB ""} {intervalCB ""}} {
    global SaAR_Menu SaAR_RefreshCB
    set SaAR_RefreshCB $refreshCB
    if {$menu == "" } {
        return
    }
    if {$shortCB == "" } {
        set shortCB SaShortHelpCB
    }
    set refreshMenu [VtPulldown $menu.refreshMenu \
        -label [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SETREFRESH] \
        -shortHelpCallback $shortCB \
        -shortHelpString \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SHSETREFRESH] \
        -mnemonic [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SETREFRESHMN]]
    VxSetVar $menu refreshMenu $refreshMenu
    set SaAR_Menu $refreshMenu
    if { "$shortStr" == "data" } {
        set shortHelp \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SHREFRESHDATA]
    } else {
        set shortHelp \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SHREFRESH [list $shortStr]]
    }
    set refreshNow [VtPushButton $menu.refreshNow -callback $refreshCB \
        -autoLock [lindex $refreshCB 0 ] \
        -label [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_REFRESHNOW] \
        -mnemonic [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_REFRESHMN] \
        -shortHelpCallback $shortCB \
        -shortHelpString $shortHelp \
        -accelerator \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_REFRESHACC] \
        -acceleratorString \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_REFRESHACCSTR]]
    VxSetVar $menu refreshNow $refreshNow
    set refreshOn [VtPushButton $refreshMenu.refreshOn \
        -label [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_ON] \
        -mnemonic [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_ONMN] \
        -shortHelpCallback $shortCB \
        -shortHelpString \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SHREFRESHON] \
        -callback SaAutoRefreshOn]
    VtSetSensitive $refreshOn off
    VxSetVar $refreshMenu refreshOn $refreshOn
    set refreshOff [VtPushButton $refreshMenu.refreshOff \
        -label [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_OFF] \
        -mnemonic [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_OFFMN] \
        -shortHelpCallback $shortCB \
        -shortHelpString \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SHREFRESHOFF] \
        -callback SaAutoRefreshOff]
    VtSetSensitive $refreshOff off
    VxSetVar $refreshMenu refreshOff $refreshOff
    SaAR:SetRefreshOptionSensitivity
    if {$intervalCB == ""} {
        return
    }
    VtSeparator $refreshMenu.s4
    set refreshInterval [VtPushButton $refreshMenu.refreshInterval \
        -label [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_REFRESHINT] \
        -mnemonic [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_REFRESHINTMN] \
        -shortHelpCallback $shortCB \
        -shortHelpString \
            [IntlLocalizeMsg SCO_SA_AUTOREFRESH_MSG_SHREFRESHINT] \
        -callback $intervalCB -autoLock $intervalCB]
    VxSetVar $refreshMenu refreshInterval $refreshInterval
}
proc SaAR:SetRefreshOptionSensitivity {} {
    global SaAR_State SaAR_Menu
    if {$SaAR_Menu == ""} {
        return
    }
    set refreshOn [VxGetVar $SaAR_Menu refreshOn]
    set refreshOff [VxGetVar $SaAR_Menu refreshOff]
    case $SaAR_State {
        {1} {
            VtSetSensitive $refreshOn off
            VtSetSensitive $refreshOff 1
        }
        {0} {
            VtSetSensitive $refreshOn 1
            VtSetSensitive $refreshOff off
        }
    }
}
proc SaAR:AutoRefreshCB {cbs} {
    global SaAR_RefreshCB SaAR_Lock SaAR_ID
    VtLock
    set SaAR_ID ""
    if {$SaAR_RefreshCB != ""} {
        keylset cbs autoRefresh 1
        eval $SaAR_RefreshCB [list $cbs]
        SaAR:AutoRefreshSchedule
    }
    VtUnLock
}
proc SaAutoRefreshOn {{cbs ""}} {
    SaAR:SetAutoRefreshState 1
}
proc SaAutoRefreshOff {{cbs ""}} {
    SaAR:SetAutoRefreshState 0
}
proc SaAutoRefreshPause {{cbs ""}} {
    global SaAR_ID SaAR_State
    set SaAR_State [expr $SaAR_State|10]
    if {$SaAR_ID != ""} {
        VtRemoveTimeOut $SaAR_ID
        set SaAR_ID ""
    }
}
proc SaAutoRefreshResume {{cbs ""}} {
    global SaAR_State
    set SaAR_State [expr $SaAR_State&1]
    if {[SaAutoRefreshGetState]} {
        SaAR:AutoRefreshSchedule
    }
}
proc SaAR:AutoRefreshSchedule {} {
    global SaAR_ID SaAR_Interval SaAR_State
    if {[expr $SaAR_State&10] != 10 && [lempty $SaAR_ID]} {
        set SaAR_ID [VtAddTimeOut \
                    -interval $SaAR_Interval \
                    -callback SaAR:AutoRefreshCB]
    }
}
proc SaAR:SetAutoRefreshState {state {cbs ""}} {
    global SaAR_State SaAR_Interval SaAR_RefreshCB
    if {[expr $SaAR_State&1] != "$state"} {
        set SaAR_State $state
        SaAR:SetRefreshOptionSensitivity
        case $SaAR_State {
            {1} {
                SaAR:AutoRefreshSchedule
            }
            {0} {
                SaAutoRefreshPause
            }
        }
    }
    return $SaAR_State
}
proc SaAutoRefreshGetState {} {
    global SaAR_State
    return [expr $SaAR_State&1]
}
proc SaAutoRefreshSetInterval {interval} {
    global SaAR_Interval
    set new [expr "$interval * 1000"]
    if {$new != $SaAR_Interval} {
        SaAutoRefreshPause
    }
    set SaAR_Interval $new
    SaAutoRefreshResume
    return $interval
}
proc SaAutoRefreshGetInterval {} {
    global SaAR_Interval
    return [expr "$SaAR_Interval / 1000"]
}
proc SaAutoRefreshCalled {cbs} {
    return [keylget cbs autoRefresh dummy]
}
proc SaAutoRefreshLoad {client} {
    if {[catch {SaScreenPolicyGet $client autoRefreshInterval} value] == 0} {
        set  interval $value
        SaAutoRefreshSetInterval $interval
    }
    if {[catch {SaScreenPolicyGet $client autoRefreshState} value] == 0} {
        set state $value
        SaAR:SetAutoRefreshState $state
    }
    return 1
}
proc SaAutoRefreshStore {client} {
    set state [SaAutoRefreshGetState]
    set cmd [list SaScreenPolicySet $client autoRefreshState $state]
    ErrorCatch errorStack 1 $cmd dummy SCO_SA_AUTOREFRESH_ERR_BADSTORE
    set interval [SaAutoRefreshGetInterval]
    set cmd [list SaScreenPolicySet $client autoRefreshInterval $interval]
    ErrorCatch errorStack 1 $cmd dummy SCO_SA_AUTOREFRESH_ERR_BADSTORE
    return 1
}
proc SaAR:SaAutoRefreshIntervalOkCB {cbs} {
    set dialog [keylget cbs dialog]
    set scale [VxGetVar $dialog scale]
    set value [VtGetValues $scale -value]
    set value [expr "$value * 60"]
    SaAutoRefreshSetInterval $value
    VtDestroyDialog $dialog
}
proc SaAutoRefreshIntervalCB {min max cbs} {
    set dialog [keylget cbs dialog]
    set form [VtFormDialog $dialog.interval \
            -title [IntlLocalizeMsg \
                SCO_SA_AUTOREFRESH_MSG_INTERVAL] \
            -okCallback SaAR:SaAutoRefreshIntervalOkCB \
            -cancelCallback VxEndFormCB \
            -cancelButton CANCEL \
            -help]
    set value [SaAutoRefreshGetInterval]
    set value [expr "$value / 60"]
    set scale [VtScale $form.scale \
            -leftSide FORM -rightSide FORM -topSide FORM \
            -title [IntlLocalizeMsg \
                SCO_SA_AUTOREFRESH_MSG_MINUTES] \
            -min $min -max $max \
            -value $value \
            -horizontal]
    VxSetVar $form scale $scale
    VtShow $form
    VtUnLock
}
#@packend: SaAR
#@package: SaTb SaToolbar SaToolbarGet SaToolbarSetVisibility SaToolbarCustomize SaToolbarMenuOptions SaToolbarDummyCB SaToolbarLoad SaToolbarStore SaToolbarButtonSetSensitive SaToolbarCustomized
proc SCO_SA_TOOLBAR_MSGS {} {}
global SCO_SA_TOOLBAR_MSGS
set SCO_SA_TOOLBAR_MSGS(@catalog@) {sysadm.cat@sa 18}
set SCO_SA_TOOLBAR_MSGS(MSG_NULLSHORTHELP) {1 {Button not assigned to any task}}
set SCO_SA_TOOLBAR_MSGS(MSG_NULLICON) {2 /usr/lib/scoadmin/icons/question.px}
set SCO_SA_TOOLBAR_MSGS(MSG_SHOW) {3 Toolbar}
set SCO_SA_TOOLBAR_MSGS(MSG_SHSHOW) {4 {Show/hide Toolbar}}
set SCO_SA_TOOLBAR_MSGS(MSG_CUSTOM) {5 {Customize Toolbar}}
set SCO_SA_TOOLBAR_MSGS(MSG_SHCUSTOM) {6 {Configure toolbar icons/commands to suit personal preferences}}
set SCO_SA_TOOLBAR_MSGS(MSG_FORMAT) {7 Formatting}
set SCO_SA_TOOLBAR_MSGS(MSG_SPACEL) {8 {Add Space Left}}
set SCO_SA_TOOLBAR_MSGS(MSG_SPACER) {9 {Add Space Right}}
set SCO_SA_TOOLBAR_MSGS(MSG_BUTTONL) {10 {Add Button Left}}
set SCO_SA_TOOLBAR_MSGS(MSG_BUTTONR) {11 {Add Button Right}}
set SCO_SA_TOOLBAR_MSGS(MSG_DELETE) {12 Delete}
set SCO_SA_TOOLBAR_MSGS(MSG_STANDARD) {13 {Restore Default Toolbar}}
set SCO_SA_TOOLBAR_MSGS(MSG_BORDER) {14 {Change Border}}
set SCO_SA_TOOLBAR_MSGS(MSG_DESC) {15 Description}
set SCO_SA_TOOLBAR_MSGS(MSG_TOOLBAR) {16 Toolbar}
set SCO_SA_TOOLBAR_MSGS(MSG_ICONS) {17 Icons}
set SCO_SA_TOOLBAR_MSGS(MSG_COMMANDS) {18 Commands}
set SCO_SA_TOOLBAR_MSGS(MSG_SEP) {19 {-----[Space]-----}}
set SCO_SA_TOOLBAR_MSGS(MSG_SEP_DESC) {20 {This separates buttons in the toolbar}}
set SCO_SA_TOOLBAR_MSGS(ERR_DUPCOMMAND) {21 {A button already exists to perform the %s command.}}
set SCO_SA_TOOLBAR_MSGS(ERR_NOCOMMAND) {22 {This button has not been assigned a command}}
set SCO_SA_TOOLBAR_MSGS(ERR_NOBUTTONS) {23 {You cannot configure an empty toolbar.\nYou can hide the toolbar with the 'Toolbar' menu option.}}
set SCO_SA_TOOLBAR_MSGS(ERR_BADCOMMAND) {24 {Invalid command index in toolbar: '%s'}}
set SCO_SA_TOOLBAR_MSGS(ERR_DUPINDEX) {25 {Duplicate command index in toolbar: '%s'}}
set SCO_SA_TOOLBAR_MSGS(ERR_BADICON) {26 {Invalid icon index in toolbar: '%s'}}
set SCO_SA_TOOLBAR_MSGS(ERR_BADSTORE) {27 {Unable to save toolbar preferences}}
set SaTb_frame ""
set SaTb_icons ""
set SaTb_commands ""
set SaTb_display ""
set SaTb_visibility 1
set SaTb_init_visibility $SaTb_visibility
set SaTb_pulldown ""
set SaTb_modified_ever 0
set SaTb_modified 0
set SaTb_nullShortHelp     [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_NULLSHORTHELP]
set SaTb_nullIcon    [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_NULLICON]
set SaTb_nullIconIndex -1
set SaTb_shrink 1
proc SaToolbar {name attachment \
        icons commands default \
        {shorthelp SaShortHelpCB} \
        {visibility 1} {current ""} {frame IN} \
        {sensitizeCB ""} {customizeCB ""} \
        {redraw 0}} {
    if {[VtInfo -charm]} {
        return ""
    }
    global SaTb_icons SaTb_display SaTb_frame
    global SaTb_display_standard
    global SaTb_frame SaTb_commands SaTb_visibility
    global SaTb_nullIcon SaTb_nullIconIndex SaTb_nullCommandIndex
    global SaTb_nullCommandIndexNext
    if {! $redraw} then {
        set SaTb_icons $icons
        set SaTb_nullIconIndex [llength $SaTb_icons]
        set SaTb_icons [concat $SaTb_icons $SaTb_nullIcon]
        set SaTb_commands $commands
        set SaTb_nullCommandIndex [llength $SaTb_commands]
        set SaTb_display_standard [SaTb:ToolbarConvertIn $default]
        set SaTb_display [SaTb:ToolbarConvertIn $current]
        if {[lempty $current]} {
            set SaTb_display $SaTb_display_standard
        }
        set parent [SaTb:GetParentWidget $name]
        set SaTb_frame [VtFrame ${name}_frame \
            -topSide $attachment \
            -bottomSide NONE \
            -leftSide FORM \
            -rightSide FORM \
        -leftOffset 2 -rightOffset 2 -topOffset 2 \
        -xmArgs [list XmNshadowThickness 1]]
        SaToolbarSetBorder $frame
        SaTb:SET $SaTb_frame toolbar_parent $parent
        SaTb:SET $SaTb_frame toolbar_shorthelp $shorthelp
        SaTb:SET $SaTb_frame toolbar_sensitizeCB $sensitizeCB
        SaTb:SET $SaTb_frame toolbar_customizeCB $customizeCB
        SaTb:SET $SaTb_frame toolbar_attach $attachment
        SaTb:SET $SaTb_frame SaTb_frame_type $frame
        set toolbar [VtForm $SaTb_frame.toolbar \
            -marginWidth 1 \
            -marginHeight 1]
        SaTb:SET $SaTb_frame toolbar $toolbar
        set toolbar_line [VtSeparator $name \
            -xmArgs [list XmNseparatorType XmNO_LINE] \
            -topSide $SaTb_frame \
            -bottomSide NONE \
            -leftSide FORM \
            -rightSide FORM \
            -topOffset 3 \
            -horizontal]
        SaTb:SET $SaTb_frame toolbar_line $toolbar_line
    } else {
        set attachment [SaTb:GET $SaTb_frame toolbar_attach]
        set shorthelp [SaTb:GET $SaTb_frame toolbar_shorthelp]
        set toolbar [SaTb:GET $SaTb_frame toolbar]
        foreach i [SaTb:GETKEYS $toolbar] {
            VtDestroy [SaTb:GET $toolbar $i]
            SaTb:UNSET $toolbar $i
        }
    }
    set space_size 0
    set last_button FORM
    set buttonHeight 20
    foreach i $SaTb_display {
        set command [lindex $i 1]
        if {[lindex $i 1] == "S"} then {
            incr space_size 15
        } else {
            set pixmapi [lindex $i 0]
            set commandi [lindex $i 1]
            SaTb:GetButtonComponents pixmapi commandi \
                pixmap command callback desc_text
            set button [VtPushButton $toolbar.$command \
                -topSide FORM \
                -bottomSide FORM \
                -leftSide $last_button \
                -leftOffset $space_size \
                -rightSide NONE \
                -pixmap $pixmap \
                -callback $callback \
                -autoLock [lindex $callback 0] \
                -shortHelpCallback $shorthelp \
                -shortHelpString $desc_text \
                -hidden 1 \
                -xmArgs {XmNhighlightThickness 0 \
                     XmNmarginHeight 1 \
                     XmNmarginWidth 1}]
            VtShow $button
            set buttonHeight [VtGetValues $button -height]
            SaTb:SET $toolbar $command $button
            SaTb:SET $button state 1
            set last_button $button
            set space_size 0
        }
    }
    set button [VtLabel $toolbar.Dummy \
        -topSide FORM \
        -bottomSide FORM \
        -leftSide $last_button \
        -leftOffset $space_size \
        -rightSide NONE \
        -hidden 1 \
        -label ""]
    VtShow $button
    SaTb:SET $toolbar Dummy $button
    if {!$redraw} {
        SaToolbarSetVisibility $visibility
    }
    set height [expr "$buttonHeight + 8"]
    VtSetValues $SaTb_frame -height $height
    if {! $redraw} then {
        return $toolbar_line
    } else {
        return $SaTb_frame
    }
}
proc SaToolbarMenuOptions {pulldown options {shorthelpCB SaShortHelpCB}} {
    global SaTb_visibility SaTb_pulldown
    if {[VtInfo -charm]} {
        return
    }
    foreach option $options {
        case $option {
            {show} {
                set toolbarVisibilityButton \
                    [VtToggleButton $pulldown.but1 \
                    -label \
                        [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_SHOW] \
                    -callback SaTb:ShowToolbarCB \
                    -value $SaTb_visibility \
                -shortHelpCallback $shorthelpCB \
                -shortHelpString [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_SHSHOW]]
                VxSetVar $pulldown toolbarShow \
                    $toolbarVisibilityButton
            }
            {custom} {
                set toolbarCustomizeButton \
                    [VtPushButton $pulldown.but2 \
                    -label \
                        [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_CUSTOM]... \
                    -shortHelpCallback $shorthelpCB \
                    -shortHelpString \
                        [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_SHCUSTOM] \
                    -callback [list SaToolbarCustomize] \
                    -autoLock SaToolbarCustomize]
                VxSetVar $pulldown toolbarCustomize \
                    $toolbarCustomizeButton
            }
        }
    }
    if {!$SaTb_visibility} {
        VtSetSensitive $toolbarCustomizeButton 0
    }
    set SaTb_pulldown $pulldown
}
proc SaToolbarButtonSetSensitive {key state} {
    global SaTb_frame
    if {[VtInfo -charm]} {
        return 0
    }
    set keys [SaToolbarGetKeys]
    if {[lsearch $keys $key] == -1} {
        return 0
    }
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set widget [SaTb:GET $toolbar $key]
    VtSetSensitive $widget $state
    SaTb:SET $widget state $state
    return 1
}
proc SaToolbarGet {vp {cp ""} {fp ""}} {
    global SaTb_display SaTb_frame SaTb_visibility
    if {[VtInfo -charm]} {
        return
    }
    upvar $vp v
    set v $SaTb_visibility
    if {$cp != ""} {
        upvar $cp c
        set c [SaTb:ToolBarConvertOut $SaTb_display]
    }
    if {$fp != ""} {
        upvar $fp f
        set f [VtGetValues $SaTb_frame -shadowType]
    }
}
proc SaToolbarSetVisibility {visibility} {
    global SaTb_frame SaTb_visibility SaTb_pulldown
    global SaTb_shrink
    if {[VtInfo -charm]} {
        return
    }
    if {$SaTb_visibility == $visibility} {
        return
    }
    set SaTb_visibility $visibility
    set toolbar_line [SaTb:GET $SaTb_frame toolbar_line]
    set toolbar_attach [SaTb:GET $SaTb_frame toolbar_attach]
    set visibilityButton [VxGetVar $SaTb_pulldown toolbarShow]
    set parent [SaTb:GET $SaTb_frame toolbar_parent]
    if {[catch \
        {VxGetVar $SaTb_pulldown toolbarCustomize} \
        customizeButton]} {
        unset customizeButton
    }
    VtSetValues $parent -xmArgs "XmNresizable 0"
    if {$SaTb_visibility} then {
        if {$SaTb_shrink} {
            VtSetValues $toolbar_line \
                -topSide $SaTb_frame
        }
        VtShow $SaTb_frame
        VtSetValues $visibilityButton -value 1
        if {[info exists customizeButton]} {
            VtSetSensitive $customizeButton 1
        }
    } else {
        if {$SaTb_shrink} {
            VtSetValues $toolbar_line \
                -topSide $toolbar_attach
        }
        VtHide $SaTb_frame
        VtSetValues $visibilityButton -value 0
        if {[info exists customizeButton]} {
            VtSetSensitive $customizeButton 0
        }
    }
    VtSetValues $parent -xmArgs "XmNresizable 1"
}
proc SaToolbarLoad {client visibilityp {currentp ""} {framep ""}} {
    upvar $visibilityp visibility
    if {[VtInfo -charm]} {
        return 0
    }
    if {[catch {SaScreenPolicyGet $client toolbarVisibility} value] == 0} {
        set visibility $value
    }
    global SaTb_init_visibility
    set SaTb_init_visibility $visibility
    if {$currentp != ""} {
        upvar $currentp current
        if {[catch {SaScreenPolicyGet $client toolbar} value] == 0} {
            set current $value
            set current [split $current +]
            set current2 ""
            foreach button $current {
                lappend current2 [split $button :]
            }
            set current $current2
        }
    }
    if {$framep != ""} {
        upvar $framep frame
        if {[catch {SaScreenPolicyGet $client toolbarFrame} value] == 0} {
            set frame $value
        }
    }
    return 1
}
proc SaToolbarStore {client vp {cp ""} {fp ""} {required 0}} {
    upvar $vp v
    upvar $cp c
    upvar $fp f
    if {[VtInfo -charm]} {
        return 0
    }
    SaToolbarGet v c f
    set visibility $v
    global SaTb_init_visibility
    if {$SaTb_init_visibility != $visibility} {
        set cmd [list SaScreenPolicySet \
            $client toolbarVisibility $visibility]
        ErrorCatch errorStack 1 $cmd dummy SCO_SA_TOOLBAR_ERR_BADSTORE
    }
    if {!$required && ![SaToolbarCustomized]} {
        return 1
    }
    if {$cp != ""} {
        set toolbar $c
        set toolbar2 ""
        foreach button $toolbar {
            append toolbar2 +[lindex $button 0]:[lindex $button 1]
        }
        set toolbar [string trim $toolbar2 +]
        set cmd [list SaScreenPolicySet $client toolbar $toolbar]
        ErrorCatch errorStack 1 $cmd dummy SCO_SA_TOOLBAR_ERR_BADSTORE
    }
    if {$fp != ""} {
        set frame $f
        set cmd [list SaScreenPolicySet $client toolbarFrame $frame]
        ErrorCatch errorStack 1 $cmd dummy SCO_SA_TOOLBAR_ERR_BADSTORE
    }
    return 1
}
proc SaToolbarGetKeys {} {
    global SaTb_frame
    if {[VtInfo -charm]} {
        return ""
    }
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    return [SaTb:GETKEYS $toolbar]
}
proc SaToolbarCustomized {} {
    global SaTb_modified_ever
    return $SaTb_modified_ever
}
proc SaToolbarCustomize {{cbs ""}} {
    global SaTb_icons SaTb_display SaTb_commands
    global SaTb_frame SaTb_visibility
    global SaTb_modified
    global SaTb_display_standard
    if {[VtInfo -charm]} {
        return
    }
    if {! $SaTb_visibility} then {
        return
    }
    set customizeCB [SaTb:GET $SaTb_frame toolbar_customizeCB]
    if {$customizeCB != ""} {
        $customizeCB 1 $cbs
    }
    set SaTb_modified 0
    VtLock
    SaTb:SaveButtonSensitivity 1
    set old_SaTb_display $SaTb_display
    set old_SaTb_frame [SaTb:GET $SaTb_frame SaTb_frame_type]
    set parent [SaTb:GET $SaTb_frame toolbar_parent]
    set custom [VtFormDialog $parent.custom \
        -cancel \
        -autoLock SaTb:CancelCustomCB \
        -cancelCallback "SaTb:CancelCustomCB \
                    [list $old_SaTb_display \
                        $old_SaTb_frame]" \
        -cancelButton CANCEL \
        -ok \
        -okCallback SaTb:CloseCustomCB \
        -help \
        -defaultButton OK \
        -title [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_CUSTOM] \
        -wmDecoration ALL]
    SaTb:SET $SaTb_frame custom $custom
    set button_frame [VtFrame $custom.button_frame \
        -topSide FORM \
        -bottomSide NONE \
        -leftSide NONE \
        -rightSide FORM \
        -topOffset 22 \
        -title [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_FORMAT] \
        -shadowType ETCHED_IN]
        set button_form [VtRowColumn $button_frame.button_form \
            -spacing 2 \
            -vertical]
            set toolbar_leftinsert_button [VtPushButton \
                $button_form.toolbar_leftinsert_button \
                -sensitive FALSE \
                -labelCenter \
                -label [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_BUTTONL] \
                -callback "SaTb:ToolbarModifyButtonCB leftinsert" \
                -autoLock SaTb:ToolbarModifyButtonCB]
            set toolbar_rightinsert_button [VtPushButton \
                $button_form.toolbar_rightinsert_button \
                -sensitive FALSE \
                -labelCenter \
                -label [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_BUTTONR] \
                -callback "SaTb:ToolbarModifyButtonCB rightinsert" \
                -autoLock SaTb:ToolbarModifyButtonCB]
            set toolbar_leftspace_button [VtPushButton \
                $button_form.toolbar_leftspace_button \
                -sensitive FALSE \
                -labelCenter \
                -label [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_SPACEL] \
                -callback "SaTb:ToolbarModifyButtonCB leftspace" \
                -autoLock SaTb:ToolbarModifyButtonCB]
            set toolbar_rightspace_button [VtPushButton \
                $button_form.toolbar_rightspace_button \
                -sensitive FALSE \
                -labelCenter \
                -label [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_SPACER] \
                -callback "SaTb:ToolbarModifyButtonCB rightspace" \
                -autoLock SaTb:ToolbarModifyButtonCB]
            set toolbar_delete_button [VtPushButton \
                $button_form.toolbar_delete_button \
                -sensitive FALSE \
                -labelCenter \
                -label [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_DELETE] \
                -callback "SaTb:ToolbarModifyButtonCB delete" \
                -autoLock SaTb:ToolbarModifyButtonCB]
            set toolbar_reset_button [VtPushButton \
                $button_form.toolbar_reset_button \
                -labelCenter \
                -label  [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_STANDARD] \
                -callback [list SaTb:ResetToolbarCB \
                        $SaTb_display_standard] \
                -autoLock SaTb:ResetToolbarCB]
            set toolbar_border_button [VtPushButton \
                $button_form.toolbar_border_button \
                -labelCenter \
                -label [IntlLocalizeMsg \
                        SCO_SA_TOOLBAR_MSG_BORDER] \
                -callback SaTb:ToolbarBorderCB \
                -autoLock SaTb:ToolbarBorderCB]
    set current_toolbar_label [VtLabel \
        $custom.current_toolbar_label \
        -topSide FORM \
        -bottomSide NONE \
        -leftSide FORM \
        -rightSide NONE \
        -topOffset 10 \
        -label [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_TOOLBAR]]
    SaTb:SET $custom current_toolbar_label $current_toolbar_label
    set current_toolbar_list [VtDrawnList \
        $custom.current_toolbar_list \
        -topSide $current_toolbar_label \
        -bottomSide NONE \
        -leftSide FORM \
        -rightSide $button_frame \
        -topOffset 0 \
        -rightOffset 20 \
        -rows 3 \
        -columns 25 \
        -selection SINGLE \
        -iconList $SaTb_icons \
        -callback "SaTb:ToolbarSelectButtonCB $custom"]
    SaTb:SET $custom current_toolbar_list $current_toolbar_list
    foreach i $SaTb_display {
        if {[lindex $i 1] == "S"} then {
            VtDrawnListAddItem $current_toolbar_list \
                -formatList {{STRING 24}} \
                -fieldList [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_SEP]
        } else {
            set pixmapi [lindex $i 0]
            set commandi [lindex $i 1]
            SaTb:GetButtonComponents pixmapi commandi \
                pixmap command callback description
            if {[string match "NONE*" $command]} then {
                set command "NONE"
            }
            set callback [lindex $i 2]
            set description [lindex $i 3]
            VtDrawnListAddItem $current_toolbar_list \
                -formatList {{ICON 1 5 5} {STRING 40 10}} \
                -fieldList "$pixmapi [list $command]"
        }
    }
    set toolbar_description_frame [VtFrame \
        $custom.toolbar_description_frame \
        -topSide NONE \
        -bottomSide FORM \
        -leftSide FORM \
        -rightSide FORM \
        -title [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_DESC] \
        -shadowType ETCHED_IN]
    VtSetValues $button_frame -bottomSide $toolbar_description_frame
    set toolbar_descriptions [VtLabel \
        $toolbar_description_frame.toolbar_descriptions \
        -labelLeft \
        -label " "]
    set toolbar_buttons_label [VtLabel $custom.toolbar_buttons_label \
        -topSide $current_toolbar_list \
        -bottomSide NONE \
        -leftSide FORM \
        -rightSide NONE \
        -topOffset 15 \
        -sensitive FALSE \
        -label [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_ICONS ]]
    set toolbar_icon_list [VtDrawnList $custom.toolbar_icon_list \
        -topSide $toolbar_buttons_label \
        -bottomSide $toolbar_description_frame \
        -leftSide FORM \
        -rightSide NONE \
        -topOffset 0 \
        -bottomOffset 15 \
        -rows 5 \
        -columns 5 \
        -selection SINGLE \
        -formatList {{ICON 1 5 5}} \
        -sensitive FALSE \
        -iconList $SaTb_icons \
        -callback "SaTb:ChangeButtonCB $custom"]
    set i 0
    while {$i < [llength $SaTb_icons]} {
        VtDrawnListAddItem $toolbar_icon_list \
            -fieldList $i
        incr i
    }
    set toolbar_command_list [VtDrawnList $custom.toolbar_command_list \
        -rows 5 \
        -topSide NONE \
        -leftSide $toolbar_icon_list \
        -rightSide NONE \
        -alignTop $toolbar_icon_list \
        -alignBottom $toolbar_icon_list \
        -alignRight $current_toolbar_list \
        -leftOffset 15 \
        -selection SINGLE \
        -formatList {{STRING 1} {STRING 25}} \
        -sensitive FALSE \
        -callback "SaTb:ChangeButtonCB $custom"]
    set toolbar_command_label [VtLabel $custom.toolbar_command_label \
        -topSide NONE \
        -bottomSide $toolbar_command_list \
        -leftSide NONE \
        -rightSide NONE \
        -alignLeft $toolbar_command_list \
        -bottomOffset 0 \
        -sensitive FALSE \
        -label [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_COMMANDS]]
    foreach i $SaTb_commands {
        VtDrawnListAddItem $toolbar_command_list \
            -fieldList [list " " [lindex $i 0]]
    }
    VtDrawnListAddItem $toolbar_command_list -fieldList [list " " NULL]
    SaTb:SET $custom toolbar_leftspace_button $toolbar_leftspace_button
    SaTb:SET $custom toolbar_rightspace_button $toolbar_rightspace_button
    SaTb:SET $custom toolbar_leftinsert_button $toolbar_leftinsert_button
    SaTb:SET $custom toolbar_rightinsert_button $toolbar_rightinsert_button
    SaTb:SET $custom toolbar_delete_button $toolbar_delete_button
    SaTb:SET $custom toolbar_reset_button $toolbar_reset_button
    SaTb:SET $custom toolbar_buttons_label $toolbar_buttons_label
    SaTb:SET $custom toolbar_icon_list $toolbar_icon_list
    SaTb:SET $custom toolbar_command_list $toolbar_command_list
    SaTb:SET $custom toolbar_command_label $toolbar_command_label
    SaTb:SET $custom toolbar_descriptions $toolbar_descriptions
SaTb:CustomizeSelectButton 1
    VtShow $custom
    VtUnLock
}
proc SaToolbarSetBorder {frame} {
    global SaTb_frame
    global SaTb_modified
    incr SaTb_modified
    if {[VtInfo -charm]} {
        return
    }
    if {$frame != "NONE"} then {
        VtSetValues $SaTb_frame \
            -shadowType $frame
    } else {
    }
    SaTb:SET $SaTb_frame SaTb_frame_type $frame
}
proc SaTb:InternalKey {key} {
    if {[string match "NULL*" $key]} {
        return 1
    }
    case $key in {
        {Dummy} {
            return 1
        }
    }
    return 0
}
proc SaTb:SaveButtonSensitivity {state} {
    global SaTb_frame old_sensitivity
    if {[info exists old_sensitivity]} {
        unset old_sensitivity
    }
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set keys [SaToolbarGetKeys]
    foreach key $keys {
        if {[SaTb:InternalKey $key]} {
            continue
        }
        set widget [SaTb:GET $toolbar $key]
        lappend old_sensitivity [list $key [SaTb:GET $widget state]]
        VtSetSensitive $widget $state
    }
}
proc SaTb:RestoreButtonSensitivity {} {
    global SaTb_frame old_sensitivity
    if {![info exists old_sensitivity]} {
        return
    }
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set keys [SaToolbarGetKeys]
    foreach record $old_sensitivity {
        set okey [lindex $record 0]
        set index [lsearch $keys $okey]
        if {$index != -1} {
            set key [lindex $keys $index]
            set state [lindex $record 1]
            set widget [SaTb:GET $toolbar $key]
            VtSetSensitive $widget $state
            SaTb:SET $widget state $state
            set keys [lreplace $keys $index $index]
        }
    }
    set keys2 ""
    foreach key $keys {
        if {![SaTb:InternalKey $key]} {
            lappend keys2 $key
        }
    }
    set keys $keys2
    if {![lempty $keys]} {
        set sensitizeCB [SaTb:GET $SaTb_frame toolbar_sensitizeCB]
        if {![lempty $sensitizeCB]} {
            $sensitizeCB $keys {}
        }
    }
}
proc SaTb:ToolbarBorderCB {cbs} {
    global SaTb_frame
    set current_frame [SaTb:GET $SaTb_frame SaTb_frame_type]
    case $current_frame in {
        IN {set frame OUT}
        OUT {set frame ETCHED_IN}
        ETCHED_IN {set frame ETCHED_OUT}
        ETCHED_OUT {set frame NONE}
        NONE {set frame IN}
    }
    SaToolbarSetBorder $frame
    VtUnLock
}
proc SaTb:ToolbarSelectButtonCB {custom cbs} {
    global SaTb_display SaTb_frame SaTb_commands
    global SaTb_nullShortHelp
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set current_toolbar_list [SaTb:GET $custom current_toolbar_list]
    set toolbar_icon_list [SaTb:GET $custom toolbar_icon_list]
    set toolbar_command_list [SaTb:GET $custom toolbar_command_list]
    set toolbar_descriptions [SaTb:GET $custom toolbar_descriptions]
    set record [lindex [VtDrawnListGetSelectedItem \
        $current_toolbar_list -byRecordList] 0]
    set position [lindex [VtDrawnListGetSelectedItem \
        $current_toolbar_list -byPositionList] 0]
    if {[lempty $record]} {
        foreach i {toolbar_delete_button \
                toolbar_leftspace_button \
                toolbar_rightspace_button \
                toolbar_rightinsert_button \
                toolbar_buttons_label \
                toolbar_icon_list \
                toolbar_command_label \
                toolbar_command_list} {
            VtSetSensitive [SaTb:GET $custom $i] 0
        }
        foreach i {toolbar_buttons_label \
                toolbar_icon_list \
                toolbar_command_label \
                toolbar_command_list} {
            VtSetSensitive [SaTb:GET $custom $i] 0
        }
        VtSetValues $toolbar_descriptions \
            -label " "
        return
    }
    if {[llength $record] != 1} then {
        foreach i {toolbar_delete_button \
                toolbar_leftspace_button \
                toolbar_rightspace_button \
                toolbar_leftinsert_button \
                toolbar_rightinsert_button \
                toolbar_buttons_label \
                toolbar_icon_list \
                toolbar_command_label \
                toolbar_command_list} {
            VtSetSensitive [SaTb:GET $custom $i] 1
        }
        set ci [lindex [lindex $SaTb_display \
                    [expr {$position - 1}]] 1]
        if {$ci < 0} {
            set button NULL[expr "$ci*-1"]
            set text $SaTb_nullShortHelp
        } else {
            set SaTb_display_rec [lindex $SaTb_commands $ci]
            set button [lindex $SaTb_display_rec 0]
            set text [lindex $SaTb_display_rec 2]
        }
        set button [SaTb:GET $toolbar $button]
        VtDrawnListSelectItem $toolbar_icon_list \
            -field 0 [lindex $record 0]
        SaDrawnListShowSelectedItem $toolbar_icon_list
        set command [lindex $record 1]
        if {[string match "NULL*" $command]} then {
            set command "NULL"
        }
        VtDrawnListSelectItem $toolbar_command_list \
            -field 1 $command
        SaDrawnListShowSelectedItem $toolbar_command_list
        VtSetValues $toolbar_descriptions \
            -label $text
    } else {
        VtDrawnListDeselectItem $toolbar_icon_list -all
        VtDrawnListDeselectItem $toolbar_command_list -all
        foreach i {toolbar_delete_button \
                toolbar_leftspace_button \
                toolbar_rightspace_button \
                toolbar_leftinsert_button \
                toolbar_rightinsert_button} {
            VtSetSensitive [SaTb:GET $custom $i] 1
        }
        foreach i {toolbar_buttons_label \
                toolbar_icon_list \
                toolbar_command_label \
                toolbar_command_list} {
            VtSetSensitive [SaTb:GET $custom $i] 0
        }
        VtSetValues $toolbar_descriptions \
            -label [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_SEP_DESC]
    }
}
proc SaTb:PositionToKey {pos} {
    global SaTb_display
    global SaTb_commands
    set ci [lindex [lindex $SaTb_display $pos] 1]
    if {$ci == ""} {
        return "Dummy"
    }
    if { $ci == "S" } {
        return $ci
    }
    if {$ci < 0} {
        return NULL[expr {$ci * -1} ]
    } else {
        return [lindex [lindex $SaTb_commands $ci] 0]
    }
}
proc SaTb:GetNeighbours {position} {
    global SaTb_display SaTb_frame SaTb_commands
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set Lsep 0
    set Rsep 0
    set Lwidget ""
    set Rwidget ""
    set widget [SaTb:PositionToKey $position]
    set count [expr {$position - 1}]
    while {$count >= 0} {
        set record [lindex [lindex $SaTb_display $count] 1]
        if {$record == "S"} then {
            incr Lsep 15
        } else {
            set Lwidget [SaTb:PositionToKey $count]
            break
        }
        incr count -1
    }
    if {$Lwidget == ""} then {
        set Lwidget "FORM"
    }
    set count [expr {$position + 1}]
    while {$count <= [llength $SaTb_display]} {
        set record [lindex [lindex $SaTb_display $count] 1]
        if {$record == "S"} then {
            incr Rsep 15
        } else {
            set Rwidget [SaTb:PositionToKey $count]
            break
        }
        incr count
    }
    if {$Rwidget == ""} then {
        set Rwidget "Dummy"
    }
    return [list \
        [expr {($widget == "S")? \
            $widget : [SaTb:GET $toolbar $widget]}] \
        [expr {($Lwidget == "FORM")? \
            $Lwidget : [SaTb:GET $toolbar $Lwidget]}] \
        [SaTb:GET $toolbar $Rwidget] \
        $Lsep \
        $Rsep]
}
proc SaTb:CustomizeSelectButton {position} {
        global SaTb_frame
        set custom [SaTb:GET $SaTb_frame custom]
        set current_toolbar_list [SaTb:GET $custom current_toolbar_list]
        set max [llength [VtDrawnListGetItem $current_toolbar_list -all]]
        if {$position > $max} {
            set position $max
        }
        if {$position} {
            VtDrawnListSelectItem $current_toolbar_list  -position $position
        }
        SaTb:ToolbarSelectButtonCB $custom ""
}
proc SaTb:ToolbarModifyButtonCB {modification cbs} {
    global SaTb_display SaTb_icons SaTb_commands SaTb_frame
    global SaTb_frame
    global SaTb_modified
    global SaTb_nullShortHelp SaTb_nullIcon SaTb_nullIconIndex
    incr SaTb_modified
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set custom [keylget cbs dialog]
    set current_toolbar_list [SaTb:GET $custom current_toolbar_list]
    set toolbar_icon_list [SaTb:GET $custom toolbar_icon_list]
    set toolbar_command_list [SaTb:GET $custom toolbar_command_list]
    set shorthelp [SaTb:GET $SaTb_frame toolbar_shorthelp]
    set record [lindex [VtDrawnListGetSelectedItem $current_toolbar_list \
        -byRecordList] 0]
    if {$record == ""} then {
        set position 1
    } else {
        set position [lindex [VtDrawnListGetSelectedItem $current_toolbar_list \
                -byPositionList] 0]
    }
    set neighbours [SaTb:GetNeighbours [expr {$position - 1}]]
    case $modification in {
        leftinsert {
            if {[lindex $neighbours 0] == "S"} then {
                set nextbutton [lindex $neighbours 2]
                set space [expr {[lindex $neighbours 4] + 15}]
            } else {
                set nextbutton [lindex $neighbours 0]
                set space 0
            }
            set unique [SaTb:GetUnique]
            set command NULL$unique
            set callback SaToolbarDummyCB
            set desc_text $SaTb_nullShortHelp
            set button [VtPushButton \
                [SaTb:GET $SaTb_frame toolbar].$command \
                -topSide FORM \
                -leftSide [lindex $neighbours 1] \
                -leftOffset [lindex $neighbours 3] \
                -pixmap $SaTb_nullIcon \
                -callback $callback \
                -autoLock [lindex $callback 0] \
                -shortHelpCallback $shorthelp \
                -shortHelpString $desc_text \
                -hidden 1 \
                -xmArgs {XmNhighlightThickness 0 \
                     XmNmarginHeight 1 \
                     XmNmarginWidth 1}]
            VtShow $button
            SaTb:SET $toolbar $command $button
            VtSetValues $nextbutton \
                -leftSide $button \
                -leftOffset $space
            set SaTb_display [linsert $SaTb_display \
                [expr {$position - 1}] \
                [list $SaTb_nullIconIndex \
                    [expr {$unique * -1}]]]
            VtDrawnListAddItem $current_toolbar_list \
                -position $position \
                -formatList {{ICON 1 5 5} {STRING 40 10}} \
                -fieldList "$SaTb_nullIconIndex $command"
            VtDrawnListSelectItem $current_toolbar_list \
                -position $position
            SaDrawnListShowSelectedItem $current_toolbar_list
            SaTb:ToolbarSelectButtonCB \
                $custom {from SaTb:ToolbarModifyButtonCB}
        }
        rightinsert {
            if {[lindex $neighbours 0] == "S"} then {
                set nextbutton [lindex $neighbours 1]
                set space [expr {[lindex $neighbours 3] + 15}]
            } else {
                set nextbutton [lindex $neighbours 0]
                set space 0
            }
            set unique [SaTb:GetUnique]
            set command NULL$unique
            set callback SaToolbarDummyCB
            set desc_text $SaTb_nullShortHelp
            set button [VtPushButton \
                [SaTb:GET $SaTb_frame toolbar].NULL$unique \
                -topSide FORM \
                -leftSide $nextbutton \
                -leftOffset $space \
                -pixmap $SaTb_nullIcon \
                -callback $callback \
                -autoLock [lindex $callback 0] \
                -shortHelpCallback $shorthelp \
                -shortHelpString $desc_text \
                -hidden 1 \
                -xmArgs {XmNhighlightThickness 0 \
                     XmNmarginHeight 1 \
                     XmNmarginWidth 1}]
            VtShow $button
            SaTb:SET $toolbar NULL$unique $button
            VtSetValues [lindex $neighbours 2] \
                -leftSide $button \
                -leftOffset [lindex $neighbours 4]
            set SaTb_display [linsert $SaTb_display \
                $position \
                [list $SaTb_nullIconIndex \
                    [expr {$unique * -1}]]]
            VtDrawnListAddItem $current_toolbar_list \
                -position [expr {$position + 1}] \
                -formatList {{ICON 1 5 5} {STRING 40 10}} \
                -fieldList "$SaTb_nullIconIndex $command"
            VtDrawnListSelectItem $current_toolbar_list \
                -position [expr {$position + 1}]
            SaDrawnListShowSelectedItem $current_toolbar_list
            SaTb:ToolbarSelectButtonCB $custom \
                {from SaTb:ToolbarModifyButtonCB}
        }
        delete {
            if {[lindex $neighbours 0] != "S"} then {
                SaTb:UNSET $toolbar \
                    [SaTb:PositionToKey [expr {$position - 1}]]
                VtDestroy [lindex $neighbours 0]
            }
            VtSetValues [lindex $neighbours 2] \
                -leftSide [lindex $neighbours 1] \
                -leftOffset [expr {[lindex $neighbours 3] + \
                    [lindex $neighbours 4]}]
            set SaTb_display [lreplace $SaTb_display \
                [expr {$position - 1}] [expr {$position - 1}]]
            VtDrawnListDeleteItem $current_toolbar_list \
                -position $position
            VtDrawnListDeselectItem $toolbar_icon_list -all
            VtDrawnListDeselectItem $toolbar_command_list -all
            SaTb:CustomizeSelectButton $position
        }
        leftspace {
            if {[lindex $neighbours 0] == "S"} then {
                set nextbutton [lindex $neighbours 2]
                set space [expr {[lindex $neighbours 4] + 30}]
            } else {
                set nextbutton [lindex $neighbours 0]
                set space 15
            }
            VtSetValues $nextbutton \
                -leftSide [lindex $neighbours 1] \
                -leftOffset [expr {[lindex $neighbours 3] + \
                    $space}]
            set SaTb_display [linsert $SaTb_display \
                [expr {$position - 1}] {{} S}]
            VtDrawnListAddItem $current_toolbar_list \
                -position $position \
                -formatList {{STRING 24}} \
                -fieldList  [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_SEP]
        }
        rightspace {
            if {[lindex $neighbours 0] == "S"} then {
                set nextbutton [lindex $neighbours 1]
                set space [expr {[lindex $neighbours 3] + 30}]
            } else {
                set nextbutton [lindex $neighbours 0]
                set space 15
            }
            VtSetValues [lindex $neighbours 2] \
                -leftSide $nextbutton \
                -leftOffset [expr {[lindex $neighbours 4] + \
                    $space}]
            set SaTb_display [linsert $SaTb_display \
                $position {{} S}]
            VtDrawnListAddItem $current_toolbar_list \
                -position [expr {$position + 1}] \
                -formatList {{STRING 24}} \
                -fieldList [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_SEP]
        }
    }
    VtUnLock
}
proc SaTb:GetUnique {} {
    global SaTb_display
    set keys [SaToolbarGetKeys]
    set unique 1
    while {$unique} {
        set ok 1
        foreach i $keys {
            if {$i == "NULL$unique"} {
                incr unique
                set ok 0
                break
            }
        }
        if {$ok} {
            break
        }
    }
    return $unique
}
proc SaTb:ChangeButtonCB {custom cbs} {
    global SaTb_icons SaTb_display SaTb_commands SaTb_frame
    global SaTb_frame
    global SaTb_modified
    global SaTb_nullShortHelp SaTb_nullIcon
    incr SaTb_modified
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set current_toolbar_list [SaTb:GET $custom current_toolbar_list]
    set toolbar_icon_list [SaTb:GET $custom toolbar_icon_list]
    set toolbar_command_list [SaTb:GET $custom toolbar_command_list]
    set toolbar_descriptions [SaTb:GET $custom toolbar_descriptions]
    set shorthelp [SaTb:GET $SaTb_frame toolbar_shorthelp]
    set record [lindex [VtDrawnListGetSelectedItem $current_toolbar_list \
        -byRecordList] 0]
    set position [lindex [VtDrawnListGetSelectedItem $current_toolbar_list \
        -byPositionList] 0]
    set icon [VtDrawnListGetSelectedItem $toolbar_icon_list \
        -byRecordList]
    set command_pos [VtDrawnListGetSelectedItem $toolbar_command_list \
        -byPositionList]
    set command [VtDrawnListGetSelectedItem $toolbar_command_list -byRecordList]
    set command [lindex $command 0]
    set command [lindex $command 1]
    set command_pos [expr {$command_pos - 1}]
    if {$command == "NULL"} then {
        set unique [SaTb:GetUnique]
        set command "NULL$unique"
        set command_pos -$unique
        set callback SaToolbarDummyCB
        set description $SaTb_nullShortHelp
        set pixmap [lindex $SaTb_icons $icon]
    } else {
        SaTb:GetButtonComponents icon command_pos \
            pixmap command callback description
    }
    if {$command != [lindex $record 1]} then {
        foreach i $SaTb_display {
            set ci [lindex $i 1]
            if {$ci == "S"} {
                continue
            }
            if {$ci < 0} {
                continue
            }
            set i [lindex $SaTb_commands $ci]
            if {[lindex $i 0] == $command} then {
                SaTb:Error $custom [IntlLocalizeMsg \
                    SCO_SA_TOOLBAR_ERR_DUPCOMMAND \
                    [list $command]]
                incr SaTb_modified -1
                VtUnLock
                return
            }
        }
    }
    set neighbours [SaTb:GetNeighbours [expr {$position - 1}]]
    VtDestroy [lindex $neighbours 0]
    set button [VtPushButton [SaTb:GET $SaTb_frame toolbar].$command \
        -topSide FORM \
        -leftSide [lindex $neighbours 1] \
        -leftOffset [lindex $neighbours 3] \
        -pixmap $pixmap \
        -callback $callback \
        -autoLock [lindex $callback 0] \
        -shortHelpCallback $shorthelp \
        -shortHelpString $description \
        -hidden 1 \
        -xmArgs {XmNhighlightThickness 0 \
             XmNmarginHeight 1 \
             XmNmarginWidth 1}]
    VtShow $button
    VtSetValues [lindex $neighbours 2] \
        -leftSide $button \
        -leftOffset [lindex $neighbours 4]
    SaTb:UNSET $toolbar [SaTb:PositionToKey [expr {$position - 1}]]
    SaTb:SET $toolbar $command $button
    SaTb:SET $button state 1
    set SaTb_display [lreplace $SaTb_display \
        [expr {$position - 1}] [expr {$position - 1}] \
        [list $icon $command_pos]]
    VtDrawnListSetItem [SaTb:GET $custom current_toolbar_list] \
        -position $position \
        -formatList {{ICON 1 5 5} {STRING 40 10}} \
        -fieldList "$icon [list $command]"
    VtSetValues $toolbar_descriptions \
        -label $description
    VtUnLock
}
proc SaTb:CancelCustomCB {old_SaTb_display old_toolbar_border cbs} {
    global SaTb_frame SaTb_modified
    if {$SaTb_modified} {
        SaTb:ResetToolbarCB $old_SaTb_display $cbs
        SaToolbarSetBorder $old_toolbar_border
    }
    VtDestroyDialog [keylget cbs dialog]
    SaTb:RestoreButtonSensitivity
    set SaTb_modified 0
    set customizeCB [SaTb:GET $SaTb_frame toolbar_customizeCB]
    if {$customizeCB != ""} {
        $customizeCB 0 $cbs
    }
    VtUnLock
}
proc SaTb:ResetToolbarCB {old_SaTb_display cbs} {
    global SaTb_display SaTb_frame
    global SaTb_frame SaTb_visibility
    global SaTb_modified
    incr SaTb_modified
    VtLock
    set custom [keylget cbs dialog]
    set toolbar [SaTb:GET $SaTb_frame toolbar]
    set current_toolbar_list [SaTb:GET $custom current_toolbar_list]
    set toolbar_icon_list [SaTb:GET $custom toolbar_icon_list]
    set toolbar_command_list [SaTb:GET $custom toolbar_command_list]
    set toolbar_descriptions [SaTb:GET $custom toolbar_descriptions]
    set SaTb_display $old_SaTb_display
    set toolbar [SaToolbar {} {} {} {} {} {} {} {} {} {} {} 1]
    VtDrawnListDeleteItem $current_toolbar_list \
        -all
    foreach i $SaTb_display {
        if {[lindex $i 1] == "S"} then {
            VtDrawnListAddItem $current_toolbar_list \
                -formatList {{STRING 24}} \
                -fieldList [IntlLocalizeMsg SCO_SA_TOOLBAR_MSG_SEP]
        } else {
            set pixmapi [lindex $i 0]
            set commandi [lindex $i 1]
            SaTb:GetButtonComponents pixmapi commandi \
                pixmap command callback desc_text
            VtDrawnListAddItem $current_toolbar_list \
                -formatList {{ICON 1 5 5} {STRING 40 10}} \
                -fieldList "$pixmapi [list $command]"
        }
    }
    SaTb:CustomizeSelectButton 1
    VtUnLock
}
proc SaTb:ToolBarConvertOut {toolbar} {
    global set SaTb_nullIconIndex
    set toolbarOut ""
    foreach button $toolbar {
        set ii [lindex $button 0]
        set ci [lindex $button 1]
        if {$ii == $SaTb_nullIconIndex} {
            set ii -1
        }
        if {$ci < 0} {
            set ci -1
        }
        lappend toolbarOut [list $ii $ci]
    }
    return $toolbarOut
}
proc SaTb:ToolbarConvertIn {toolbar} {
    global SaTb_nullIconIndex
    global SaTb_nullCommandIndex SaTb_nullCommandIndexNext
    set toolbarIn ""
    set clist ""
    set SaTb_nullCommandIndexNext -1
    foreach button $toolbar {
        set ii [lindex $button 0]
        set ci [lindex $button 1]
        if {$ci != "S"} {
            if {$ci <= -1 || $ci >= $SaTb_nullCommandIndex} {
                if {$ci != -1} {
                    puts stderr [IntlLocalizeMsg SCO_SA_TOOLBAR_ERR_BADCOMMAND \
                        [list $ci]]
                }
                set ci $SaTb_nullCommandIndexNext
                incr SaTb_nullCommandIndexNext -1
            }
            if {$ci >= 0 } {
                if {[lsearch $clist $ci] >= 0} {
                    puts stderr [IntlLocalizeMsg SCO_SA_TOOLBAR_ERR_DUPINDEX \
                        [list $ci]]
                    set ci $SaTb_nullCommandIndexNext
                    incr SaTb_nullCommandIndexNext -1
                } else {
                    lappend clist $ci
                }
            }
            if {$ii == "" || $ii <= -1 || $ii >= $SaTb_nullIconIndex } {
                if {$ii != -1} {
                    puts stderr [IntlLocalizeMsg SCO_SA_TOOLBAR_ERR_BADICON \
                        [list $ii]]
                }
                set ii $SaTb_nullIconIndex
            }
        }
        lappend toolbarIn [list $ii $ci]
    }
    return $toolbarIn
}
proc SaTb:GetButtonComponents {iip cip iconp commandp callbackp textp} {
    upvar $iip ii
    upvar $cip ci
    upvar $iconp icon
    upvar $commandp command
    upvar $callbackp callback
    upvar $textp text
    global SaTb_nullShortHelp SaTb_nullIcon
    global SaTb_icons SaTb_commands
    set icon [lindex $SaTb_icons $ii]
    if {$ci < 0} {
        set command NULL[expr {$ci * -1}]
        set callback SaToolbarDummyCB
        set text $SaTb_nullShortHelp
    } else {
        set record [lindex $SaTb_commands $ci]
        set command [lindex $record 0]
        set callback [lindex $record 1]
        set text [lindex $record 2]
    }
}
proc SaToolbarDummyCB {cbs} {
    set form [keylget cbs dialog]
    set message [VtMessageDialog $form.popupmessagebox \
        -ok \
        -defaultButton OK \
        -message [IntlLocalizeMsg SCO_SA_TOOLBAR_ERR_NOCOMMAND]]
    VtShowDialog $message
    VtUnLock
}
proc SaTb:CloseCustomCB {cbs} {
    global SaTb_frame
    global SaTb_modified SaTb_modified_ever
    set custom [SaTb:GET $SaTb_frame custom]
    set current_toolbar_list [SaTb:GET $custom current_toolbar_list]
    set list  [VtDrawnListGetItem $current_toolbar_list -all]
    if {[lempty $list]} {
        set form [keylget cbs dialog]
        set message [VtErrorDialog $form.popupmessagebox \
            -ok \
            -defaultButton OK \
            -message [IntlLocalizeMsg SCO_SA_TOOLBAR_ERR_NOBUTTONS]]
        VtShowDialog $message
        return
    }
    if {$SaTb_modified} {
        incr SaTb_modified_ever
    }
    VtDestroyDialog [keylget cbs dialog]
    SaTb:RestoreButtonSensitivity
    set customizeCB [SaTb:GET $SaTb_frame toolbar_customizeCB]
    if {$customizeCB != ""} {
        $customizeCB 0 $cbs
    }
}
proc SaTb:ShowToolbarCB {cbs} {
    SaToolbarSetVisibility [keylget cbs set]
}
proc SaTb:SET {klist element value} {
    eval "global $klist"
    keylset $klist $element $value
SaTb:GET $klist $element
}
proc SaTb:UNSET {klist element} {
    eval "global $klist"
    keyldel $klist $element
}
proc SaTb:GET {klist element} {
    eval "global $klist"
    set ret [catch {set value [keylget $klist $element]} res]
    if {$ret != 0} then {
            echo "Bug: $element not found in keyed list - $klist"
        return "ERROR"
    }
    return $value
}
proc SaTb:GETKEYS {klist} {
    eval "global $klist"
    return [keylkeys $klist]
}
proc SaTb:Error {form text} {
        set error [VtErrorDialog $form.popuperrorbox \
                -ok \
                -defaultButton OK \
                -message $text]
        VtShowDialog $error
}
proc SaTb:GetParentWidget {child} {
    set i [string last . $child]
    incr i -1
    return [string range $child 0 $i]
}
#@package: SaOH SaOpenHostDialog SaOpenHostCB SaOpenHostInvokeManager SaOpenHostManagerRunning
proc SCO_SA_OPENHOST_MSGS {} {}
global SCO_SA_OPENHOST_MSGS
set SCO_SA_OPENHOST_MSGS(@catalog@) {sysadm.cat@sa 20}
set SCO_SA_OPENHOST_MSGS(MSG_openHost) {1 {Open Host}}
set SCO_SA_OPENHOST_MSGS(MSG_host) {2 Host:}
set SCO_SA_OPENHOST_MSGS(MSG_select) {3 Select...}
set SCO_SA_OPENHOST_MSGS(ERR_running) {4 {%1$s manager is already running on %2$s}}
set SCO_SA_OPENHOST_MSGS(ERR_exec) {5 {Failed to execute SCOadmin %1$s manager.\n%2$s}}
set SCO_SA_OPENHOST_MSGS(ERR_missing_host) {6 {Please enter name of the remote host you want to manage.}}
set SCO_SA_OPENHOST_MSGS(MSG_noRemoteAdmin) {7 {Remote administration is not currently accessible}}
proc SaOpenHostDialog {parent instance value okcb} {
    set hostForm [VtFormDialog $parent.hostForm \
            -title [IntlLocalizeMsg SCO_SA_OPENHOST_MSG_openHost] \
            -MOTIF_marginWidth 10 \
            -MOTIF_marginHeight 10 \
            -help \
            -okCallback $okcb \
            -cancelCallback VxEndFormCB \
            -cancelButton CANCEL]
    keylset hostDisplayList parent $hostForm
    keylset hostDisplayList instance $instance
    keylset hostDisplayList labeltype title
    keylset hostDisplayList labeltext \
                [IntlLocalizeMsg SCO_SA_OPENHOST_MSG_host]
    keylset hostDisplayList buttontext \
                [IntlLocalizeMsg SCO_SA_OPENHOST_MSG_select]
    keylset hostDisplayList textcols 25
    keylset hostDisplayList show name
    keylset hostDisplayList userproc [list SaSetFocus next]
    set selhost [SaSelectHostText $hostDisplayList]
    VtSetValues $selhost -MOTIF_topOffset 10 -MOTIF_bottomOffset 10 \
             -leftSide FORM -rightSide FORM
    if {$value != "" } {
    VtSetValues [VxGetVar $selhost text] -value $value
    }
    VxSetVar $hostForm text [VxGetVar $selhost text]
    VtRemoveAllTabGroups $hostForm
    VtAddTabGroup [VxGetVar $selhost text]
    VtAddTabGroup [VxGetVar $selhost button]
    SaSetFocusList $hostForm [list \
            [VxGetVar $selhost text] \
            [VtGetValues $hostForm -ok]]
    return $hostForm
}
proc SaOpenHostCB {cbs} {
    VtLock
    if {![SaHostRemoteOsaAccessible]} {
    VtUnLock
    VtShow [VtInformationDialog [keylget cbs dialog].noRemote \
        -message [IntlLocalizeMsg SCO_SA_OPENHOST_MSG_noRemoteAdmin] \
        -ok -help]
    return
    }
    set parent [keylget cbs dialog]
    set script [info script]
    set form [SaOpenHostDialog $parent hostForm "" "SaOpenHostInvokeManager $script"]
    VtUnLock
    VtShow $form
    VtSetFocus [VxGetVar $form text]
}
proc SaOpenHostInvokeManager {script cbs} {
        set widget [keylget cbs widget]
    set hostName [SaSelectHostGetText hostForm]
    if { $hostName == "" } {
        ErrorPush errStack 0 SCO_SA_OPENHOST_ERR_missing_host
        SaDisplayErrorStacks $widget.error [list $errStack] NOHELP
            VtSetFocus [VxGetVar [keylget cbs dialog] text]
        return
    }
    set index [string last "/" $script]
    if { $index != -1 } {
        set scriptName [string range $script [expr $index+1] end]
    }
    set index [string first GUI $scriptName]
    set managerName [string range $scriptName 0 [expr $index-1]]
    if { [VtInfo -charm] } {
         set command [list exec $script $hostName]
    } else {
         set command [list exec $script $hostName &]
    }
    VtLock
    VtControl -suspend
        if { [catch $command result] } {
        ErrorPush errStack 0 SCO_SA_OPENHOST_ERR_exec \
            [list $managerName $hostName] [list $result]
        VtControl -resume
        SaDisplayErrorStacks $widget.error [list $errStack] HELP \
            [list SaOH:CloseCB $widget]
        VtUnLock
        return
        }
    VtControl -resume
    VtDestroyDialog $widget
    VtUnLock
}
proc SaOH:CloseCB {widget cbs} {
    VtDestroyDialog $widget
}
proc SaOpenHostManagerRunning {scriptName hostname} {
    set localHost [lindex [split [SaHostGetLocalName] .] 0]
    set hostname [lindex [split $hostname .] 0]
    set command [list exec ps -ef | grep $scriptName | egrep -v grep ]
    if { [catch $command result] } {
    ErrorPushUnix errStack 1
    }
    set result [split $result \n]
    foreach i $result {
        set name [lindex $i 8]
        set name [lindex [split $name .] 0]
        if { $hostname == $name } {
            return "true"
        }
        if { $hostname == $localHost && $name == "" } {
            return "true"
        }
    }
    return "false"
}
#@packend
#@package: SaMachGroupFileCB SaMachGroupPromptCB SaMachGroupFileWrite SaMachGroupFileRead SaMachGroupUpdate SaMachGroupAddCB SaGroupSlaveDeleteCB SaMachGroupSlaveDelete SaMachGroupSlaveAdd SaMachGroupMasterAdd SaOpenGroupInvokeManager SaOpenGroupCB SaOpenGroupDialog SaMachGroupProc SaMachGroupRestart
proc SCO_SA_OPENGROUP_MSGS {} {}
global SCO_SA_OPENGROUP_MSGS
set SCO_SA_OPENGROUP_MSGS(@catalog@) {sysadm.cat@sa 25}
set SCO_SA_OPENGROUP_MSGS(MSG_openGroup) {1 {Open Host Group...}}
set SCO_SA_OPENGROUP_MSGS(MSG_master) {2 {Master Host:}}
set SCO_SA_OPENGROUP_MSGS(MSG_slave) {3 {Managed Host:}}
set SCO_SA_OPENGROUP_MSGS(MSG_select) {4 Select...}
set SCO_SA_OPENGROUP_MSGS(ERR_running) {5 {%1$s manager is already running for group}}
set SCO_SA_OPENGROUP_MSGS(ERR_exec) {6 {Failed to execute SCOadmin Group Manager}}
set SCO_SA_OPENGROUP_MSGS(ERR_missing_master) {7 {Please enter name of Master Host}}
set SCO_SA_OPENGROUP_MSGS(MSG_noRemoteAdmin) {8 {Remote Administration is not currently accessable}}
set SCO_SA_OPENGROUP_MSGS(MSG_selectMaster) {9 {Select Master Host}}
set SCO_SA_OPENGROUP_MSGS(MSG_selectSlave) {10 {Select Managed Host}}
set SCO_SA_OPENGROUP_MSGS(MSG_currentSlaves) {11 {Managed Host List:}}
set SCO_SA_OPENGROUP_MSGS(MSG_deleteSlaves) {12 Delete}
set SCO_SA_OPENGROUP_MSGS(MSG_addSlaves) {13 Add}
set SCO_SA_OPENGROUP_MSGS(MSG_fileSlaves) {14 {Open File}}
set SCO_SA_OPENGROUP_MSGS(MSG_prompt) {15 Prompt}
set SCO_SA_OPENGROUP_MSGS(ERR_execFailed) {16 {Remote Machine Failure %s}}
set SCO_SA_OPENGROUP_MSGS(MSG_noErrorContinue) {17 {Continue work on %s?}}
set SCO_SA_OPENGROUP_MSGS(MSG_errorContinue) {18 {An Error Occurred. (%1$s)\nContinue work on %2$s?}}
set SCO_SA_OPENGROUP_MSGS(MSG_machGroupDataDir) {19 /usr/lib/sysadm/mach_groups/}
set SCO_SA_OPENGROUP_MSGS(MSG_machGroupDataFilter) {20 *.mgrp}
set SCO_SA_OPENGROUP_MSGS(MSG_machGroupDataRead) {21 Read}
set SCO_SA_OPENGROUP_MSGS(MSG_machGroupDataWrite) {22 Write}
set SCO_SA_OPENGROUP_MSGS(MSG_machGroupPromptNever) {23 Never}
set SCO_SA_OPENGROUP_MSGS(MSG_machGroupPromptAlways) {24 Always}
set SCO_SA_OPENGROUP_MSGS(MSG_machGroupPromptOnError) {25 {On Error}}
set SCO_SA_OPENGROUP_MSGS(MSG_openGroupTitle) {26 {Open Host Group}}
global    SaOG_info
set    SaOG_info(SCO_SA_MachGroupSlaveText) {}
set    SaOG_info(SCO_SA_MachGroupMasterText) {}
set    SaOG_info(SCO_SA_MachGroupSlaveList) {}
set    SaOG_info(SCO_SA_MachGroupMasterList) {}
set    SaOG_info(SCO_SA_MachGroupErrorPrompt) [IntlLocalizeMsg \
        SCO_SA_OPENGROUP_MSG_machGroupPromptOnError]
set    SaOG_info(SCO_SA_MachGroupSlaveItemList) {}
proc SaOG:SaMachGroupFileCB { okcb cbs } {
    set        SCO_SA_MachGroupDataDir \
        [IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_machGroupDataDir]
    set        SCO_SA_MachGroupDataFile \
        [IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_machGroupDataFilter]
    set parent [ keylget cbs dialog ]
    set filetext [IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_fileSlaves]
    set fileForm [ VtFileSelectionDialog $parent.fileForm \
        -filter $SCO_SA_MachGroupDataDir/$SCO_SA_MachGroupDataFile \
        -title $filetext \
        -help \
        -okCallback $okcb \
        -cancelButton CANCEL]
    VtUnLock
    VtShow $fileForm
}
proc SaOG:SaMachGroupPromptCB { cbs } {
    global SaOG_info
    set value [ keylget cbs value ]
    set SaOG_info(SCO_SA_MachGroupErrorPrompt) $value
}
proc SaOG:SaMachGroupFileWrite { cbs } {
    global SaOG_info
    set filename [ keylget cbs selection ]
    set fp [ open $filename w ]
    puts $fp $SaOG_info(SCO_SA_MachGroupMasterList)
    foreach i $SaOG_info(SCO_SA_MachGroupSlaveList) {
        puts $fp $i
    }
    close $fp
}
proc SaOG:SaMachGroupFileRead { cbs } {
    global SaOG_info
    set set_master 0
    set filename [ keylget cbs selection ]
    set fp [ open $filename r ]
    while { [gets $fp buf] != -1 } {
        if { $set_master == 0 } {
            set SaOG_info(SCO_SA_MachGroupMasterList) $buf
            set SaOG_info(SCO_SA_MachGroupSlaveList) {}
            set set_master 1
        } else {
            SaOG:SaMachGroupSlaveAdd $buf
        }
    }
    close $fp
    SaOG:SaMachGroupUpdate
}
proc SaOG:SaMachGroupUpdate { } {
    global SaOG_info
    VtSetValues $SaOG_info(SCO_SA_MachGroupMasterText) \
        -value $SaOG_info(SCO_SA_MachGroupMasterList)
    VtSetValues $SaOG_info(SCO_SA_MachGroupSlaveItemList) \
        -itemList $SaOG_info(SCO_SA_MachGroupSlaveList)
}
proc SaOG:SaMachGroupAddCB {list cbs} {
    global SaOG_info
    if { "$list" == "slave" } {
        SaOG:SaMachGroupSlaveAdd [VtGetValues \
            $SaOG_info(SCO_SA_MachGroupSlaveText) -value]
        VtSetValues $SaOG_info(SCO_SA_MachGroupSlaveText) -value {}
    } else {
        SaOG:SaMachGroupMasterAdd [VtGetValues \
            $SaOG_info(SCO_SA_MachGroupMasterText) -value]
    }
}
proc SaOG:SaGroupSlaveDeleteCB { cbs } {
    global SaOG_info
    set name [VtListGetSelectedItem \
            $SaOG_info(SCO_SA_MachGroupSlaveItemList) -byItemList]
    SaOG:SaMachGroupSlaveDelete $name
    SaOG:SaMachGroupUpdate
}
proc SaOG:SaMachGroupSlaveDelete { name } {
    global SaOG_info
    set to_rep [ lsearch -exact $SaOG_info(SCO_SA_MachGroupSlaveList) \
            $name ]
    if { $to_rep != -1 } {
        set SaOG_info(SCO_SA_MachGroupSlaveList) [ lreplace \
            $SaOG_info(SCO_SA_MachGroupSlaveList) $to_rep $to_rep ]
    }
}
proc SaOG:SaMachGroupSlaveAdd { name } {
    global SaOG_info
    if { "$name" == "" } {
        return
    }
    if { [ lsearch -exact $SaOG_info(SCO_SA_MachGroupSlaveList) "$name" ] \
        == -1 } {
        set new_slave [ concat $SaOG_info(SCO_SA_MachGroupSlaveList) \
                "$name" ]
        set SaOG_info(SCO_SA_MachGroupSlaveList) [lsort $new_slave]
    }
    SaOG:SaMachGroupUpdate
}
proc SaOG:SaMachGroupMasterAdd { name } {
    global SaOG_info
    set SaOG_info(SCO_SA_MachGroupMasterList) "$name"
}
proc SaOG:SaOpenGroupInvokeManager { script cbs } {
    global SaOG_info
    set dialog [keylget cbs dialog]
    if { "$SaOG_info(SCO_SA_MachGroupSlaveList)" != "" } {
        set command [list exec $script \
            $SaOG_info(SCO_SA_MachGroupMasterList) \
            "$SaOG_info(SCO_SA_MachGroupSlaveList)" \
            "$SaOG_info(SCO_SA_MachGroupErrorPrompt)" "&"]
    } else {
        set command [list exec \
            $script $SaOG_info(SCO_SA_MachGroupMasterList) "&"]
    }
    if { "$SaOG_info(SCO_SA_MachGroupMasterList)" != "" } {
        VtDestroyDialog $dialog
        if { [catch $command returnVal] } {
                ErrorPush errorStack 0 SCO_SA_OPENGROUP_ERR_exec \
                [list $returnVal]
                SaDisplayErrorStacks execErr [list $errorStack] NOHELP
        }
    } else {
        ErrorPush errorStack 0 SCO_SA_OPENGROUP_ERR_missing_master {}
            SaDisplayErrorStacks execErr [list $errorStack] NOHELP
    }
}
proc SaOpenGroupCB {cbs} {
    VtLock
    if {![SaHostRemoteOsaAccessible]} {
        VtUnLock
        VtShow [VtInformationDialog [keylget cbs dialog].noRemote \
        -message [IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_noRemoteAdmin] \
        -ok -help]
        return
    }
    set parent [keylget cbs dialog]
    set script [info script]
    set form [SaOG:SaOpenGroupDialog $parent groupForm "" \
        "SaOG:SaOpenGroupInvokeManager $script"]
    VtUnLock
    VtShow $form
    VtSetFocus [VxGetVar $form text]
}
proc SaOG:SaOpenGroupDialog {parent instance value okcb} {
    global SaOG_info
    set groupForm [VtFormDialog $parent.groupForm \
        -title [IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_openGroupTitle] \
        -MOTIF_marginWidth 10 \
        -MOTIF_marginHeight 10 \
        -help \
        -okCallback $okcb \
        -cancelCallback VxEndFormCB \
        -cancelButton CANCEL]
    set groupMaster [VtForm $groupForm.Master \
        -leftSide FORM \
        -rightSide FORM \
        ]
    set groupSlave [VtForm $groupForm.Slave \
        -leftSide FORM \
        -rightSide FORM \
        ]
    set groupPrompt [VtForm $groupForm.Prompt \
        -leftSide FORM \
        -rightSide FORM \
        ]
    keylset groupMasterList parent $groupMaster
    keylset groupMasterList instance $groupMaster
    keylset groupMasterList labeltype text
    keylset groupMasterList labeltext \
        [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_master]
    keylset groupMasterList buttontext \
        [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_select]
    keylset groupMasterList textcols 25
    keylset groupMasterList show name
    keylset groupMasterList title \
        [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_selectMaster]
    keylset groupMasterList userproc [list SaOG:SaMachGroupAddCB master ]
    set selmaster [SaSelectHostText $groupMasterList]
    set SaOG_info(SCO_SA_MachGroupMasterText) [VxGetVar $selmaster text]
    if {$SaOG_info(SCO_SA_MachGroupMasterList) != "" } {
        VtSetValues [VxGetVar $selmaster text] \
            -value $SaOG_info(SCO_SA_MachGroupMasterList)
    }
    keylset groupSlaveList parent $groupSlave
    keylset groupSlaveList instance $groupSlave
    keylset groupSlaveList labeltype text
    keylset groupSlaveList labeltext \
        [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_slave]
    keylset groupSlaveList buttontext \
        [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_select]
    keylset groupSlaveList textcols 25
    keylset groupSlaveList show name
    keylset groupSlaveList title \
        [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_selectSlave]
    keylset groupSlaveList userproc [list SaOG:SaMachGroupAddCB slave ]
    set selslave [SaSelectHostText $groupSlaveList]
    set SaOG_info(SCO_SA_MachGroupSlaveText) [VxGetVar $selslave text]
    set buttonform [ VtForm $groupSlave.buttons ]
    set slavelistlabeltext \
        [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_currentSlaves]
    set slavelistlabel [VtLabel $groupSlave.listlabel \
        -label $slavelistlabeltext ]
    set SaOG_info(SCO_SA_MachGroupSlaveItemList) [VtList $groupSlave.list \
        -rows 5 \
        -autoSelect 1 \
        -itemList $SaOG_info(SCO_SA_MachGroupSlaveList) \
        ]
    set dellabeltext [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_deleteSlaves ]
    set slavelistdel [ VtPushButton $buttonform.del \
        -label $dellabeltext \
        -callback SaOG:SaGroupSlaveDeleteCB \
        ]
    set addlabeltext [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_addSlaves ]
    set slavelistadd [ VtPushButton $buttonform.add \
        -label $addlabeltext \
        -callback [list SaOG:SaMachGroupAddCB slave ] \
        ]
    set filelabeltext [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_fileSlaves ]
    if { 0 } {
        set slavelistfile [ VtPushButton $buttonform.file \
            -label $filelabeltext \
            -callback [list SaOG:SaMachGroupFileCB \
                SaOG:SaMachGroupFileRead ] \
            -autoLock [list SaOG:SaMachGroupFileCB \
                SaOG:SaMachGroupFileRead ] \
            ]
    } else {
        set slavelistfile [ VtOptionMenu $buttonform.menu \
            -label $filelabeltext \
            ]
        set slavelistfileread [ VtPushButton $slavelistfile.read \
            -label [IntlLocalizeMsg \
                SCO_SA_OPENGROUP_MSG_machGroupDataRead] \
            -callback [list SaOG:SaMachGroupFileCB \
                SaOG:SaMachGroupFileRead ] \
            -autoLock [list SaOG:SaMachGroupFileCB \
                SaOG:SaMachGroupFileRead ] \
            ]
        set slavelistfilewrite [ VtPushButton $slavelistfile.write \
            -label [IntlLocalizeMsg \
                SCO_SA_OPENGROUP_MSG_machGroupDataWrite] \
            -callback [list SaOG:SaMachGroupFileCB \
                SaOG:SaMachGroupFileWrite ] \
            -autoLock [list SaOG:SaMachGroupFileCB \
                SaOG:SaMachGroupFileWrite ] \
            ]
    }
    set slavepromptlabeltext [ IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_prompt ]
    set slavepromptlabel [ VtLabel $groupPrompt.label \
        -label $slavepromptlabeltext \
        ]
    set slaveprompt [ VtComboBox $groupPrompt.combo \
        -itemList [list \
            [IntlLocalizeMsg \
                SCO_SA_OPENGROUP_MSG_machGroupPromptOnError] \
            [IntlLocalizeMsg \
                SCO_SA_OPENGROUP_MSG_machGroupPromptNever] \
            [IntlLocalizeMsg \
                SCO_SA_OPENGROUP_MSG_machGroupPromptAlways] ] \
        -value $SaOG_info(SCO_SA_MachGroupErrorPrompt) \
        -callback SaOG:SaMachGroupPromptCB \
        -leftSide $slavepromptlabel \
        ]
    VtSetValues $slavelistadd \
                -leftSide FORM \
                -rightSide FORM
    VtSetValues $slavelistfile \
                -leftSide FORM \
                -rightSide FORM
    VtSetValues $slavelistdel \
                -leftSide FORM \
                -rightSide FORM
    VtSetValues $selmaster \
                -MOTIF_topOffset 10 \
                -MOTIF_bottomOffset 10 \
                -leftSide FORM \
                -rightSide FORM
    VtSetValues $slavelistlabel \
            -leftSide FORM \
            -topSide $selslave \
            -MOTIF_topOffset 10 \
            -MOTIF_bottomOffset 10
    VtSetValues $buttonform \
            -leftSide NONE \
            -rightSide FORM \
            -topSide $slavelistlabel
    VtSetValues $SaOG_info(SCO_SA_MachGroupSlaveItemList) \
            -leftSide FORM \
            -rightSide $buttonform \
            -topSide $slavelistlabel \
            -MOTIF_topOffset 10 \
            -MOTIF_bottomOffset 10
    VtSetValues $selslave \
            -MOTIF_topOffset 10 \
            -MOTIF_bottomOffset 10 \
            -rightSide FORM \
            -leftSide FORM
    VtSetValues $slaveprompt \
            -MOTIF_topOffset 10 \
            -MOTIF_bottomOffset 10 \
            -topSide FORM \
            -bottomSide FORM
    VtSetValues $slavepromptlabel \
            -MOTIF_topOffset 10 \
            -leftSide FORM \
            -topSide FORM \
            -bottomSide FORM
    VtShow $groupMaster
    VtShow $groupSlave
    VtShow $groupPrompt
    VxSetVar $groupForm text [VxGetVar $selmaster text]
    SaSetFocusList $groupForm [list \
                [VxGetVar $selmaster text] \
                [VtGetValues $groupForm -ok]]
    return $groupForm
}
proc SaMachGroupProc { masterName {groups {}} {errorPrompt {}} \
    proclist parent cbs } {
    set groupList [split $groups]
    set hosts $masterName
    if { [llength $groupList] > 0 } {
        set hosts [concat $masterName $groupList]
    }
    set alwaysPrompt [IntlLocalizeMsg \
                        SCO_SA_OPENGROUP_MSG_machGroupPromptAlways]
    set neverPrompt [IntlLocalizeMsg \
                        SCO_SA_OPENGROUP_MSG_machGroupPromptNever]
    foreach hostName $hosts {
        set errorStack {}
        set evalCmd [lindex $proclist 0]
        set evalArgs [lrange $proclist 1 [llength $proclist]]
        set cmd [list eval $evalCmd $hostName errorStack $evalArgs]
        ErrorCatch errorStack 0 $cmd dummyResult \
            SCO_SA_OPENGROUP_ERR_execFailed [list $hostName]
        if {[string compare $errorPrompt $neverPrompt] != 0} {
            set nameind [lsearch -exact $hosts $hostName]
            incr nameind
            set newmaster [lindex $hosts $nameind]
            set newlist [lrange $hosts [incr nameind] \
                [llength $hosts]]
            if { $newmaster == {} } {
                VtUnLock
                if { [llength $errorStack] != 0 } {
                    SaDisplayErrorStacks openGroupErr \
                        [list $errorStack] NOHELP
                }
                return
            }
            if { [llength $errorStack] != 0} {
                VtUnLock
                SaOG:SaMachGroupRestart $errorStack \
                    $newmaster $newlist $errorPrompt \
                      $proclist $parent $cbs
                return
            } elseif {[string compare $errorPrompt $alwaysPrompt] \
                    == 0} {
                VtUnLock
                SaOG:SaMachGroupRestart $errorStack $newmaster \
                     $newlist $errorPrompt $proclist \
                      $parent $cbs
                return
            }
        }
    }
    VtUnLock
}
proc SaOG:SaMachGroupRestart { eStack master slaves prompt proclist \
                parent cbs } {
    set cb  "SaMachGroupProc $master [list $slaves] \"$prompt\" \
        [list $proclist] $parent"
    if { [llength $eStack] != 0 } {
        set err [ErrorText eStack]
        set emsg [IntlLocalizeMsg SCO_SA_OPENGROUP_MSG_errorContinue \
            [list $err $master]]
        set msg [VtErrorDialog $parent.grpPrompt \
            -message "$emsg" \
                    -autoLock $cb \
            -okCallback $cb \
        ]
    } else {
        set msg [VtQuestionDialog $parent.grpPrompt \
            -message [IntlLocalizeMsg \
            SCO_SA_OPENGROUP_MSG_noErrorContinue $master] \
                    -autoLock $cb \
            -okCallback $cb \
        ]
    }
    VtShow $msg
    if { [llength $eStack] != 0 } {
            SaDisplayErrorStacks execErr [list $eStack] NOHELP
    }
}
#@packend
#@package: SaNW SaSelectNWDialog SaSelectNWText SaSelectNWAuth SaSelectNWGetSelection
proc SCO_SA_SELNW_MSGS {} {}
global SCO_SA_SELNW_MSGS
set SCO_SA_SELNW_MSGS(@catalog@) {sysadm.cat@sa 26}
set SCO_SA_SELNW_MSGS(MSG_TITLE) {1 {NetWare File Server Selection}}
set SCO_SA_SELNW_MSGS(MSG_LIST_TITLE) {2 {File Servers}}
set SCO_SA_SELNW_MSGS(MSG_SELECTION) {3 Selection:}
set SCO_SA_SELNW_MSGS(MSG_FILTER) {4 Filter:}
set SCO_SA_SELNW_MSGS(MSG_NETWARE_LOGIN_TI) {5 {NetWare Server Login on %s}}
set SCO_SA_SELNW_MSGS(MSG_LOGIN) {6 Login:}
set SCO_SA_SELNW_MSGS(MSG_PASSWORD) {7 Password:}
set SCO_SA_SELNW_MSGS(ERR_LOGIN) {8 {Unable to login to host %s}}
set SCO_SA_SELNW_MSGS(ERR_CODE_ERR) {9 {Error:  data missing from parameter list}}
set SCO_SA_SELNW_MSGS(ERR_AUTHHOST) {10 {You must first select a NetWare server to authenticate with.}}
set SCO_SA_SELNW_MSGS(MSG_CONTEXT) {11 Context:}
proc SaNW:NextItemCB {next cbs} {
    VtSetFocus $next
}
proc SaNW:SaSelectNWFilterCB {ins cbs} {
    global SaNW_mainList SaNW_filter SaNW_selected
    set dialog [keylget cbs dialog]
    set selecttxt     [VxGetVar $dialog selecttxt]
    set hostlist     [VxGetVar $dialog hostlist]
    set SaNW_filter($ins)    [keylget cbs value]
    VtListDeleteItem $hostlist -all
    VtListAddItem $hostlist -itemList [lmatch $SaNW_mainList($ins) $SaNW_filter($ins)]
    VtListSelectItem $hostlist -position 1
    set SaNW_selected($ins) [lindex [VtListGetSelectedItem $hostlist -byItemList] 0]
    VtSetValues $selecttxt -value $SaNW_selected($ins)
}
proc SaNW:SaSelectNWSelectCB {ins cbs} {
    global SaNW_selected
    set dialog [keylget cbs dialog]
    set value  [keylget cbs value]
    set hostlist [VxGetVar $dialog hostlist]
    VtListSelectItem $hostlist -item $value
    set SaNW_selected($ins) [lindex [VtListGetSelectedItem $hostlist -byItemList] 0]
}
proc SaNW:SaSelectNWlistCB {ins cbs} {
    global SaNW_selected
    set dialog [keylget cbs dialog]
    set SaNW_selected($ins)  [lindex [keylget cbs selectedItemList] 0]
    set selecttxt [VxGetVar $dialog selecttxt]
    VtSetValues $selecttxt -value $SaNW_selected($ins)
}
proc SaNW:SaSelectNWDialogOkCB {pList ins cbs} {
global SaNW_selected
    set textfield [keylget pList textfield]
    VtSetValues $textfield -value $SaNW_selected($ins)
    if {[keylget pList userCB userCB]} {
        if {![lempty $userCB]} {
                lappend userCB $cbs
                eval "$userCB"
        }
    }
    VxEndFormCB $cbs
}
proc SaNW_GetNwFileServers {{host {}}} {
    if {"$host" != ""} {
        set instance [list [list [list systemId $host] NULL]]
    } else {
        set instance NULL
    }
    set objcall [list ObjectAction \
                    {sco id-oc-server} $instance listNwFservers {}]
    set bmipResponse [lindex [SaMakeObjectCall $objcall] 0]
    if {[BmipResponseErrorIsPresent bmipResponse] } {
        set errorStack [BmipResponseErrorStack bmipResponse]
    ErrorThrow errorStack
    } else {
    set nwfservers [BmipResponseActionInfo bmipResponse]
    }
}
proc SaSelectNWDialog {pList cbs} {
    global SaNW_mainList SaNW_filter SaNW_selected
    set ins [keylget pList instance]
    set dialog  [keylget cbs dialog]
    set hosttxt [keylget pList textfield]
    set current [VtGetValues $hosttxt -value]
    set parent [keylget pList parent]
    set proc [keylget pList proc]
    if {[catch "keylget pList title" TITLE]} {
        set TITLE [IntlLocalizeMsg SCO_SA_SELNW_MSG_TITLE]
    }
    if {[catch "keylget pList listtitle" LIST_TITLE]} {
        set LIST_TITLE [IntlLocalizeMsg SCO_SA_SELNW_MSG_LIST_TITLE]
    }
    set SELECTION [IntlLocalizeMsg SCO_SA_SELNW_MSG_SELECTION]
    set FILTER    [IntlLocalizeMsg SCO_SA_SELNW_MSG_FILTER]
    if {![info exists SaNW_filter($ins)]} {
        set SaNW_filter($ins) "*"
    }
    if {![info exists SaNW_selected($ins)]} {
        set SaNW_selected($ins) ""
    }
    set form [VtFormDialog $dialog.form  \
            -title $TITLE \
            -ok \
            -okCallback "SaNW:SaSelectNWDialogOkCB [list $pList] $ins" \
            -cancel \
            -cancelCallback VxEndFormCB \
    ]
    VtLabel $form.listlbl -label "$LIST_TITLE"
    set hostlist [VtList $form.list \
                -selection BROWSE \
                -CHARM_autoSelect 1 \
                -rows 13 \
                -columns 15 \
                -callback "SaNW:SaSelectNWlistCB $ins" \
    ]
    VxSetVar $form hostlist $hostlist
    set rowCol [VtRowColumn $form.rowcol \
            -alignTop $hostlist \
            -leftSide $hostlist \
            -packing COLUMN \
            -horizontal \
            -numColumns 4 \
    ]
    VtLabel $rowCol.selectlbl -label   "$SELECTION"
    set selecttxt [VtText  $rowCol.selecttxt \
                -columns 15 \
                -callback "SaNW:SaSelectNWSelectCB $ins" \
    ]
    VxSetVar $form selecttxt $selecttxt
    VtLabel $rowCol.filterlbl -label "$FILTER"
    set filtertxt [VtText  $rowCol.filtertxt \
                -columns 15 \
                -value "$SaNW_filter($ins)" \
                -callback "SaNW:SaSelectNWFilterCB $ins" \
    ]
    VxSetVar $form filtertxt $filtertxt
    VtShow $form
    if {[ErrorCatch eStk 0 "$proc" SaNW_mainList($ins)]} {
    VtUnLock
    VtDestroy $form
        SaDisplayErrorStacks $parent.errbox [list $eStk] NOHELP
    return
    }
    set SaNW_mainList($ins) [lsort $SaNW_mainList($ins)]
    VtListAddItem $hostlist -itemList [lmatch $SaNW_mainList($ins) $SaNW_filter($ins)]
    if {"$SaNW_selected($ins)" == "" } {
    VtListSelectItem $hostlist -position 1
    } else {
    VtListSelectItem $hostlist -item $SaNW_selected($ins)
    }
    set SaNW_selected($ins) [lindex [VtListGetSelectedItem $hostlist -byItemList] 0]
    VtSetValues $selecttxt -value $SaNW_selected($ins)
    VtSetFocus $hostlist
    VtUnLock
}
proc SaNW:NWLoginCB {pList parentcbs cbs} {
    set dialog [keylget cbs dialog]
    set authhost [keylget pList authhost]
    set login [VtGetValues [VxGetVar $dialog login] -value]
    set context [VtGetValues [VxGetVar $dialog context] -value]
    set passwd [VtGetValues [VxGetVar $dialog passwd] -value]
    if {"$context" != "" && ![ctype space $context]} {
    set login "$login.$context"
    }
    if {[catch "keylget pList host" host] == 0} {
        set instance [list [list [list systemId $host] NULL]]
    } else {
        set instance NULL
    }
    set objcall [list ObjectAction \
                    {sco id-oc-server} $instance nwlogin \
            [list "$authhost" "$login" "$passwd"]]
    ErrorCatch eStk 0 "SaMakeObjectCall [list $objcall]" bmipResponse
    set bmipResponse [lindex $bmipResponse 0]
    if {[BmipResponseErrorIsPresent bmipResponse]} {
        set eStk [BmipResponseErrorStack bmipResponse]
    ErrorPush eStk 0 SCO_SA_SELNW_ERR_LOGIN $authhost
        SaDisplayErrorStacks $dialog.err [list $eStk] NOHELP
    } else {
    VxEndFormCB $cbs
    SaSelectNWDialog $pList $parentcbs
    }
}
proc SaSelectNWAuth {pList cbs} {
    set dialog [keylget cbs dialog]
    if {[catch "keylget pList authhostproc" authhostproc] == 0} {
    if {[catch "eval $authhostproc" authhost] == 0} {
        if {"$authhost" != ""} {
            keylset pList authhost $authhost
        } else {
        VtUnLock
        ErrorPush eStk 0 SCO_SA_SELNW_ERR_AUTHHOST
            SaDisplayErrorStacks $dialog.ebox [list $eStk] NOHELP
        return
        }
    }
        set NETWARE_LOGIN_TI \
      [IntlLocalizeMsg SCO_SA_SELNW_MSG_NETWARE_LOGIN_TI $authhost]
        set LOGIN [IntlLocalizeMsg SCO_SA_SELNW_MSG_LOGIN]
        set CONTEXT [IntlLocalizeMsg SCO_SA_SELNW_MSG_CONTEXT]
        set PASSWORD [IntlLocalizeMsg SCO_SA_SELNW_MSG_PASSWORD]
        if {[catch "keylget pList host" host] == 0} {
            set instance [list [list [list systemId $host] NULL]]
        } else {
            set instance NULL
        }
        set objcall [list ObjectAction \
                    {sco id-oc-server} $instance nwauthquery $authhost]
        set bmipResponse [lindex [SaMakeObjectCall $objcall] 0]
        set result [BmipResponseActionInfo bmipResponse]
    if {"$result" == "true"} {
        SaSelectNWDialog $pList $cbs
    } else {
        set logindlog [VtFormDialog dialog.loginform \
            -title "$NETWARE_LOGIN_TI" \
            -ok \
            -okCallback "SaNW:NWLoginCB [list $pList] [list $cbs]" \
            -cancel \
            -cancelCallback VxEndFormCB \
        ]
        keylset formargs $LOGIN "VtText -columns 15"
        keylset formargs $CONTEXT "VtText -columns 15"
        keylset formargs $PASSWORD "VtText -columns 15 -noEcho"
        set loginform [VxAlignedForm $logindlog.form $formargs]
        VtShow $logindlog
        set login [VxGetVar $loginform widget1]
        VxSetVar $logindlog login $login
        set context [VxGetVar $loginform widget2]
        VxSetVar $logindlog context $context
        set passwd [VxGetVar $loginform widget3]
        VxSetVar $logindlog passwd $passwd
        VtSetValues $login -callback "SaNW:NextItemCB $context"
        VtSetValues $context -callback "SaNW:NextItemCB $passwd"
        VtSetValues $passwd -callback "SaNW:NextItemCB $logindlog.ok"
        VtSetFocus $login
        VtUnLock
    }
    } else {
    SaSelectNWDialog $pList $cbs
    }
}
proc SaSelectNWText {pList} {
    global SaNW_info
    if {[keylget pList parent parent] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELNW_ERR_CODE_ERR
    }
    if {[keylget pList instance instance] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELNW_ERR_CODE_ERR
    }
    if {[keylget pList labeltype labeltype] == 0} {
    set labeltype title
    }
    if {[keylget pList labeltext labeltext] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELNW_ERR_CODE_ERR
    }
    if {[keylget pList textcols textcols] == 0} {
    set textcols 30
    }
    if {[keylget pList buttontext buttontext] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELNW_ERR_CODE_ERR
    }
    if {[keylget pList show show] == 0} {
    set show name
    }
    if {[keylget pList proc proc] == 0} {
        if {[keylget pList host host] == 0} {
        keylset pList proc SaNW_GetNwFileServers
    } else {
        keylset pList proc "SaNW_GetNwFileServers $host"
    }
    }
    set returnform [VtForm $parent.SaNW_form$instance -marginHeight 0 -marginWidth 0]
    if {$labeltype == "label"} {
    set innerform [VtForm $returnform.innerform -marginHeight 0 -marginWidth 0]
    VtSetValues $innerform -leftSide FORM -rightSide FORM
    set textlabel [VtLabel $innerform.textlabel -label $labeltext]
    set textfield [VtText $innerform.textfield \
        -columns $textcols]
        keylset pList textfield $textfield
    set pushbutton [VtPushButton $innerform.button \
        -label $buttontext \
        -callback "SaSelectNWAuth [list $pList]" ]
    set lheight [lindex [VtGetValues $textlabel -baseLineList] 0]
    set theight [lindex [VtGetValues $textfield -baseLineList] 0]
    set bheight [lindex [VtGetValues $pushbutton -baseLineList] 0]
    if {$lheight >= $theight && $lheight >= $bheight} {
        set diff1 [expr $lheight - $theight]
        set diff2 [expr $lheight - $bheight]
        VtSetValues $textlabel \
        -leftSide FORM -rightSide NONE \
        -topSide FORM -MOTIF_topOffset 0
        VtSetValues $textfield \
        -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset $diff1
        VtSetValues $pushbutton \
        -leftSide NONE \
        -rightSide FORM \
        -topSide FORM -MOTIF_topOffset $diff2
    } elseif {$theight >= $bheight} {
        set diff1 [expr $theight - $lheight]
        set diff2 [expr $theight - $bheight]
        VtSetValues $textlabel \
        -leftSide FORM -rightSide NONE \
        -topSide FORM -MOTIF_topOffset $diff1
        VtSetValues $textfield \
        -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset 0
        VtSetValues $pushbutton \
        -leftSide NONE \
        -rightSide FORM \
        -topSide FORM -MOTIF_topOffset $diff2
    } else {
        set diff1 [expr $bheight - $lheight]
        set diff2 [expr $bheight - $theight]
        VtSetValues $textlabel \
        -leftSide FORM -rightSide NONE \
        -topSide FORM -MOTIF_topOffset $diff1
        VtSetValues $textfield \
        -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset $diff2
        VtSetValues $pushbutton \
        -leftSide NONE \
        -rightSide FORM \
        -topSide FORM -MOTIF_topOffset 0
    }
    VtSetValues $textlabel -leftSide FORM -rightSide NONE
    VtSetValues $textfield -leftSide $textlabel -MOTIF_leftOffset 3 \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM
    VtSetValues $pushbutton -leftSide NONE \
        -rightSide FORM -topSide FORM
    } else {
    set textlabel [VtLabel $returnform.textlabel -label $labeltext]
    set innerform [VtForm $returnform.innerform -marginHeight 0 -marginWidth 0]
    VtSetValues $innerform -leftSide FORM -rightSide FORM
    set textfield [VtText $innerform.textfield \
        -columns $textcols]
        keylset pList textfield $textfield
    set pushbutton [VtPushButton $innerform.button \
        -label $buttontext \
        -callback "SaSelectNWAuth [list $pList]" ]
    set theight [lindex [VtGetValues $textfield -baseLineList] 0]
    set bheight [lindex [VtGetValues $pushbutton -baseLineList] 0]
    set diff [abs ([expr $theight - $bheight])]
    if {$theight > $bheight} {
        VtSetValues $textfield -leftSide FORM \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset 0
        VtSetValues $pushbutton \
        -leftSide NONE -rightSide FORM \
        -topSide FORM -MOTIF_topOffset $diff
    } else {
        VtSetValues $textfield -leftSide FORM \
        -rightSide $pushbutton -MOTIF_rightOffset 20 \
        -topSide FORM -MOTIF_topOffset $diff
        VtSetValues $pushbutton \
        -leftSide NONE -rightSide FORM \
        -topSide FORM -MOTIF_topOffset 0
    }
    }
    set SaNW_info($instance:textwidgetname) $textfield
    set SaNW_info($instance:button) $pushbutton
    set SaNW_info($instance:has_textwidget) TRUE
    set SaNW_info(showvalue) $show
    VxSetVar $returnform text $textfield
    VxSetVar $returnform label $textlabel
    VxSetVar $returnform button $pushbutton
    return $returnform
}
proc SaSelectNWGetSelection {instance} {
global SaNW_selected
    if [info exists SaNW_selected($instance)] {
    return $SaNW_selected($instance)
    }
    return ""
}
#@package: SaSF SaFileBrowserDialog SaFileGetSelection SaFileExists SaFileIsDirectory SaFileGetAttr
proc SCO_SA_SELFILE_MSGS {} {}
global SCO_SA_SELFILE_MSGS
set SCO_SA_SELFILE_MSGS(@catalog@) {sysadm.cat@sa 27}
set SCO_SA_SELFILE_MSGS(ERR_MISSING_PARAMETER) {1 {A required parameter is missing.}}
set SCO_SA_SELFILE_MSGS(ERR_MISSING_PARENT) {2 {Programming error: name of parent dialog is missing.}}
set SCO_SA_SELFILE_MSGS(ERR_NULL) {3 {Nothing is selected.}}
set SCO_SA_SELFILE_MSGS(ERR_NONEXIST) {4 {File %s does not exist.}}
set SCO_SA_SELFILE_MSGS(ERR_GET_DIRLIST) {5 {Could not get list of directories in %s}}
set SCO_SA_SELFILE_MSGS(ERR_GET_FILELIST) {6 {Could not get list of files in %s}}
set SCO_SA_SELFILE_MSGS(ERR_GET_ATTR) {7 {Could not get attribute of %s}}
set SCO_SA_SELFILE_MSGS(MSG_TITLE) {8 {Select a File on %s}}
set SCO_SA_SELFILE_MSGS(MSG_DIRECTORIES) {9 Directories}
set SCO_SA_SELFILE_MSGS(MSG_FILES) {10 Files}
set SCO_SA_SELFILE_MSGS(MSG_SELECTION) {11 Selection:}
proc SaFileBrowserDialog {arglist {cbs {}} } {
    set parent ""
    if { $cbs != "" } {
    set parent [keylget cbs dialog]
    }
    if { $parent == "" && [keylget arglist parent parent] == 0} {
    ErrorPush errorStack 1 SCO_SA_SELFILE_ERR_MISSING_PARENT
        return
    }
    if {[keylget arglist host host] == 0} {
    set host localhost
    }
    if {[keylget arglist path path] == 0} {
    set path "/"
    }
    if {[keylget arglist title title] == 0} {
    set title [IntlLocalizeMsg SCO_SA_SELFILE_MSG_TITLE $host]
    }
    if {[keylget arglist autodestroy autodestroy] == 0 ||
    [lsearch [list 0 1 true false] $autodestroy] == -1 } {
    set autodestroy 1
    }
    if {[keylget arglist userproc userproc] == 0} {
    set userproc {}
    }
    if {[keylget arglist userdata userdata] == 0} {
        set hasUserData 0
    set userdata {}
    } else {
    set hasUserData 1
    }
    if { $path == "" || [string match "* *" $path] } {
    set path "/"
    } else {
        if { [catch "SaFileExists $host $path" result] || $result == 0 } {
        set path "/"
    }
    }
    if { ! [SaFileIsDirectory $host $path] } {
        set path [crange $path 0 [string last "/" $path]]
    }
    if { [cindex $path end] != "/" } {
    set path $path/
    }
    set form \
        [VtFormDialog $parent.selectDirForm \
    -wmShadowThickness 0 \
    -title $title \
    -ok \
    -okCallback \
       [list SaSF:SelectionCB $userproc $userdata $autodestroy] \
    -cancelButton CANCEL -cancelCallback VxEndFormCB \
     -help]
    SaCharmSetMaxFormDimensions $form 1
    set dirlist \
        [VxList $form.dirlist \
    -autoSelect 1 \
    -selection SINGLE \
    -title [IntlLocalizeMsg SCO_SA_SELFILE_MSG_DIRECTORIES] \
    -rows 8 \
    -MOTIF_columns 15 \
    -CHARM_columns 30 \
    -scrollBar true \
    -leftSide FORM \
    -callback SaSF:dirlistCB \
    -MOTIF_defaultCallback SaSF:dirlistCB]
    set dirlistForm [VxGetVar $dirlist form]
    set filelist \
        [VxList $form.filelist \
    -selection SINGLE \
    -title [IntlLocalizeMsg SCO_SA_SELFILE_MSG_FILES] \
    -rows 8 \
    -scrollBar true \
    -leftSide $dirlistForm \
    -alignTop $dirlistForm \
    -rightSide FORM \
    -callback SaSF:filelistCB \
    -MOTIF_defaultCallback SaSF:filelistCB]
    set dirtext \
        [VxText $form.dirtext \
    -topSide $dirlistForm \
    -title [IntlLocalizeMsg SCO_SA_SELFILE_MSG_SELECTION] \
    -leftSide FORM \
    -rightSide FORM \
    -horizontalScrollBar true \
    -value $path \
    -callback SaSF:dirtextCB]
    VxSetVar $form dirtext $dirtext
    VxSetVar $form dirlist $dirlist
    VxSetVar $form filelist $filelist
    VxSetVar $form managedHost $host
    VxSetVar $form hasUserData $hasUserData
    SaSF:UpdateBrowser $path $form
    VtShow $form
    VtSetFocus $dirlist
    VtUnLock
    return $form
}
proc SaFileGetSelection {dialog} {
    global SaSF_info
    if [info exists SaSF_info($dialog)] {
        return $SaSF_info($dialog)
    }
}
proc SaFileExists { host file } {
    set instanceList [SaSF:GetInstanceList $file $host]
    set command "ObjectGet {sco file} [list $instanceList] {type}"
    set result [SaSF:RunObjectCommand $command]
    set result [lindex $result 0]
    if { [BmipResponseErrorIsPresent result] } {
        return 0
    }
    set attr [BmipResponseAttrValList result]
    set type [keylget attr type]
    if { $type != "file" && $type != "directory" } {
        return 0
    }
    return 1
}
proc SaFileIsDirectory { host dir } {
    set instanceList [SaSF:GetInstanceList $dir $host]
    set command "ObjectGet {sco file} [list $instanceList] {type}"
    set result [SaSF:RunObjectCommand $command]
    set result [lindex $result 0]
    if { [BmipResponseErrorIsPresent result] } {
        return 0
    }
    set attr [BmipResponseAttrValList result]
    set type [keylget attr type]
    if { $type == "directory" } {
        return 1
    }
    return 0
}
proc SaFileGetAttr {host path {attr {}}} {
        set class    [list sco file]
        set instance [SaSF:GetInstanceList $path $host]
        set command [list ObjectGet $class $instance $attr]
        VtLock
        set result [SaMakeObjectCall $command]
        VtUnLock
        set result [lindex $result 0]
        if { [BmipResponseErrorIsPresent result] } {
                set errorStack [BmipResponseErrorStack result]
            ErrorPush errorStack 1 SCO_SA_SELFILE_ERR_GET_ATTR $path
                return {}
        }
        set retVal [BmipResponseAttrValList result]
        return $retVal
}
proc SaSF:SelectionCB {userproc userdata autodestroy cbs} {
    global SaSF_info
    set dialog [keylget cbs dialog]
    set textfield [VxGetVar $dialog dirtext]
    set value [VtGetValues $textfield -value]
    set SaSF_info($dialog) $value
    if { $value == "" } {
    VtShow [VtErrorDialog $dialog.nohost \
        -ok \
        -message [IntlLocalizeMsg SCO_SA_SELFILE_ERR_NULL]]
    return
    } else {
    if {![lempty $userproc]} {
        if { [VxGetVar $dialog hasUserData] } {
        lappend userproc $value $userdata $cbs
        } else {
        lappend userproc $value $cbs
        }
        eval "$userproc"
    }
    }
    if { $autodestroy } {
    VtDestroyDialog $dialog
    }
}
proc SaSF:RunObjectCommand {cmd} {
    VtLock
    set objresult [SaMakeObjectCall $cmd]
    VtUnLock -once
    return $objresult
}
proc SaSF:OCGetDirList {host dir} {
    set instanceList [SaSF:GetInstanceList $dir $host]
    set command "ObjectAction {sco directory} \
                [list $instanceList] {listDirs} {}"
    set result [SaSF:RunObjectCommand $command]
    set result [lindex $result 0]
    if { [BmipResponseErrorIsPresent result] } {
        set errorStack [BmipResponseErrorStack result]
        ErrorPush errorStack 1 SCO_SA_SELFILE_ERR_GET_DIRLIST $dir
    }
    set result [BmipResponseActionInfo result]
    set result [lsort $result]
    if { $dir == "/" } {
        set list {}
    } else {
        set list {../}
    }
    foreach name $result {
        lappend list "./$name/"
    }
    return $list
}
proc SaSF:OCGetFileList {host dir} {
    set instanceList [SaSF:GetInstanceList $dir $host]
    set command "ObjectAction {sco directory} \
                 [list $instanceList] {listRegFiles} {}"
    set result [SaSF:RunObjectCommand $command]
    set result [lindex $result 0]
    if { [BmipResponseErrorIsPresent result] } {
        set errorStack [BmipResponseErrorStack result]
        ErrorPush errorStack 1 SCO_SA_SELFILE_ERR_GET_FILELIST $dir
    }
    set list [BmipResponseActionInfo result]
    set list [lsort $list]
    return $list
}
proc SaSF:dirlistCB {cbs} {
    set dirlist [keylget cbs widget]
    set dialog [keylget cbs dialog]
    set dirtext [VxGetVar $dialog dirtext]
    set oldvalue [VtGetValues $dirtext -value]
    set selection [VtListGetSelectedItem $dirlist -byItemList]
    if { $selection == "" || $selection == "./" } {
    return
    }
    if { $selection == "../" } {
    set index [string last "/" $oldvalue]
    set value1 [crange $oldvalue 0 [expr $index-1]]
    set newvalue [crange $value1 0 [string last "/" $value1]]
    } else {
    set selection [crange $selection 2 end]
        append newvalue $oldvalue $selection
    }
    VtSetValues $dirtext -value $newvalue
    SaSF:UpdateBrowser $newvalue $dialog
}
proc SaSF:filelistCB {cbs} {
    set filelist [keylget cbs widget]
    set selection [VtListGetSelectedItem $filelist -byItemList]
    if { $selection == "" } {
    return
    }
    set dialog [keylget cbs dialog]
    set dirtext [VxGetVar $dialog dirtext]
    set value [VtGetValues $dirtext -value]
    set value $value$selection
    VtSetValues $dirtext -value $value
    VtSetFocus $dirtext
}
proc SaSF:dirtextCB {cbs} {
    set dirtext [keylget cbs widget]
    set dialog [keylget cbs dialog]
    set dir [keylget cbs value]
    set host [VxGetVar $dialog managedHost]
    if { [SaFileIsDirectory $host $dir] } {
    if { [crange $dir end end] != "/" } {
        VtSetValues $dirtext -value $dir/
     }
    SaSF:UpdateBrowser $dir $dialog
    }
    VtSetFocus [VtGetValues $dialog -ok]
}
proc SaSF:UpdateBrowser { dir dialog } {
    set host [VxGetVar $dialog managedHost]
    set dirlist [VxGetVar $dialog dirlist]
    if {[ErrorCatch errStack 0 "SaSF:OCGetDirList $host $dir" items]} {
    SaDisplayErrorStacks $dialog.error [list $errStack] HELP
    return
    }
    VtListSetItem $dirlist -itemList $items
    set filelist [VxGetVar $dialog filelist]
    if {[ErrorCatch errStack 0 "SaSF:OCGetFileList $host $dir" items]} {
    SaDisplayErrorStacks $dialog.error [list $errStack] HELP
    return
    }
    VtListSetItem $filelist -itemList $items
}
proc SaSF:GetInstanceList { names host } {
    set instanceList {}
    if { $host == "localhost" } {
        foreach name $names {
            set instance [list $name]
            lappend instanceList $instance
        }
    } else {
        foreach name $names {
            set instance [list [list systemId $host] [list $name]]
            lappend instanceList $instance
        }
    }
    return $instanceList
}
#@packend: SaSF
#@package: SaAF SaAlignedForm
proc SaAlignedForm { wname dataList } {
    set newDataList {}
    foreach list $dataList {
        set labelList [lindex $list 0]
        set wlist [lindex $list 1]
        set label [eval IntlLocalizeMsg $labelList]
        lappend newDataList [list $label $wlist]
    }
    return [WxAlignedForm $wname $newDataList]
}
#@packend: SaAF
#@package: SCO_SA_MISC_MSGS SCO_SA_MISC_MSGS
proc SCO_SA_MISC_MSGS {} {}
global SCO_SA_MISC_MSGS
set SCO_SA_MISC_MSGS(@catalog@) {sysadm.cat@sa 22}
set SCO_SA_MISC_MSGS(ERR_SCOPRINT) {1 {Error encountered while executing '%s.'}}
set SCO_SA_MISC_MSGS(ERR_GETVERS) {2 {unknown version}}
#@package: SaCharmMaxForm  SaCharmSetMaxFormDimensions
proc SaCharmSetMaxFormDimensions {form {secondary 0}} {
    if {![VtInfo -charm]} {
        return
    }
    set incr -2
    set displayWidth [VtInfo -displayWidth]
    incr displayWidth $incr
    set displayHeight [VtInfo -displayHeight]
    if {$secondary} {
        set incr -4
    }
    incr displayHeight $incr
    VtSetValues $form \
            -CHARM_height $displayHeight \
            -CHARM_width $displayWidth \
            -CHARM_resizable 0
    return $form
}
#@packend
#@package: SaHelp  SaHelpGetOptionsList
proc SaHelpGetOptionsList {} {
    return [list ON_CONTEXT ON_WINDOW ON_KEYS INDEX ON_HELP ON_VERSION]
}
#@packend
#@package: SaList SaListShowSelectedItem SaDrawnListShowSelectedItem
proc SaDrawnListShowSelectedItem {list {forcetop 0}} {
    SaListShowSelectedItem $list $forcetop "Drawn"
}
proc SaListShowSelectedItem {list {forcetop 0} {drawn ""}} {
    if {$drawn != ""} {
        set drawn Drawn
    }
    set selected \
            [lindex [Vt${drawn}ListGetSelectedItem $list -byPositionList] 0]
    if {[lempty $selected]} {return}
    set rows [VtGetValues $list -rows]
    set top [VtGetValues $list -topItemPosition]
    set count [llength [Vt${drawn}ListGetItem $list -all]]
    if {[expr "$selected - $top"] < 0} {
        VtSetValues $list -topItemPosition $selected
    } elseif {[expr "$selected - $top"] < $rows} {
        if {$forcetop} {
                VtSetValues $list -topItemPosition $selected
        }
    } elseif {[expr "$count - $selected"] >= $rows} {
        if {$forcetop} {
                VtSetValues $list -topItemPosition $selected
        } else {
                set selected [expr "$selected - $rows + 1"]
                VtSetValues $list -topItemPosition $selected
        }
    } else {
        VtSetValues $list -topItemPosition [expr "$count - $rows + 1"]
    }
}
#@packend
#@package: SaPrint SaPrint SaPrintSetup SaPrintGetPrinterName
proc SaPrint {icon {file {}} {option {}}} {
    global saPrint_exe
    set saPrint_exe    "/usr/X/bin/scoprint"
    VtLock
    case $option {
        printerName {
            set saPrint_exe "/usr/bin/lpstat"
            lappend args "-d"
        }
        setup {
            if {[VtInfo -charm]} {
                VtUnLock; return
            }
        }
        default {
            if {![lempty $file]} {
                lappend args $file
            } else {
                if {[VtInfo -charm]} {
                    VtUnLock; return
                }
            }
        }
    }
    if {[VtInfo -charm]} {
        VtUnLock
    }
    if {[ErrorCatch errorStack 0 \
        [list CallNonStdCmd $saPrint_exe $args \
            SCO_NONSTD_CMDS_ERR_scoprint] \
        res] != 0 } {
        VtUnLock
        ErrorPush errorStack 1 SCO_SA_MISC_ERR_SCOPRINT [list $saPrint_exe]
    }
    if { $option == "printerName" } {
        set max [llength $res]
        set res [lindex $res [expr $max-1]]
    }
    VtUnLock
    return $res
}
proc SaPrintSetup {icon} {
    SaPrint $icon {} setup
}
proc SaPrintGetPrinterName {icon} {
    return [SaPrint $icon {} default]
}
#@packend
#@package: SaFocus SaSetFocus SaSetTabGroups  SaSetFocusList
proc SaSetFocusList {form list} {
    VxSetVar $form focusList $list
}
proc SaSetFocus { widget cbs } {
    if {[keylget cbs mode mode] != 0} {
        if {$mode != "done"} {
        return
        }
    } else {
    return
    }
    if { $widget != "next" } {
    VtSetFocus $widget
     return
    }
    set currentWidget [keylget cbs widget]
    set dialog [keylget cbs dialog]
    set catchvalue [catch "VxGetVar $currentWidget focusParent" parentWidget]
    if {$catchvalue == 0 && ![lempty $parentWidget]} {
    set currentWidget $parentWidget
    }
    if {[catch "VxGetVar $dialog focusList" focusList] || [lempty $focusList]} {
        return
    }
    set index [lsearch $focusList $currentWidget]
    if { $index == -1 } {
    return
    }
    incr index
    if { $index >= [llength $focusList] } {
        set index 0
    }
    VtSetFocus [lindex $focusList $index]
}
proc SaSetTabGroups { form tabgroups } {
    VtRemoveAllTabGroups $form
    foreach widget $tabgroups {
    VtAddTabGroup $widget
    }
}
#@packend
#@package: SaSystem SaRunLevelGet SaRunLevelIsSingleUser SaGetSSOVersion SaGetLocale
proc SaRunLevelGet {} {
    set result [CallNonStdCmd /bin/who -r SCO_NONSTD_CMDS_ERR_who]
    set level [lindex $result 2]
    return $level
}
proc SaRunLevelIsSingleUser {} {
    set level [SaRunLevelGet]
    case $level in {
      {S s 1} {return 1}
      default {return 0}
    }
}
proc SaGetSSOVersion {{patchArea 0}} {
    set release [CallNonStdCmd uname {-r} "" errStack]
    if { [cequal $release "4.2MP"] || $release  >= 5} {
        set cmd [list exec /bin/pkginfo -x scoadmin]
        if { [catch $cmd retval] } {
            set retval [IntlLocalizeMsg SCO_SA_MISC_ERR_GETVERS]
            return $retval
        } else {
            return [lindex $retval end]
        }
    } else {
        if {$patchArea == 0} {
            set cmd [list exec /bin/pkginfo -x scoadmin]
            if { [catch $cmd retval] } {
                set retval [IntlLocalizeMsg SCO_SA_MISC_ERR_GETVERS]
                return $retval
            } else {
                return [lindex $retval end]
            }
        } else {
            return [file tail [SSO_GetSegmentRootPath SHARED $patchArea]]
        }
    }
}
proc SaGetLocale {} {
    global env
    if { [info exists env(LANG)] } {
        return $env(LANG)
    } else {
        set locale [SaSystem:ReadDefaultLangFile]
                if { $locale == "" } {
            set locale en_US
        }
        return $locale
    }
}
proc SaSystem:ReadDefaultLangFile {} {
    set filename "/etc/default/lang"
    if { [file exists $filename] && [file readable $filename] } {
        set fileid [open $filename r]
        while { [gets $fileid line] != -1 } {
            if { [string match "LANG=*" $line] == 1 } {
                set locale [crange $line 5 end]
                set locale [string trimright $locale]
                break
            }
        }
        close $fileid
        return $locale
    } else {
        return  ""
    }
}
#@packend
#@package: SaAccount  SaUsersGet SaGetPwEnts SaGroupsGet
proc SaUsersGet {{host localhost}} {
    set userlist {}
    if {$host == "localhost"} {
        set instance [SaHostGetLocalName]
    } else {
        set instance [list [list [list systemId $host] $host]]
    }
    set call [list \
        ObjectGet -scope 1 {sco users} \
        $instance \
        {pw_name}]
    set bmipResponse [SaMakeObjectCall $call]
    set firstBmip [lindex $bmipResponse 0]
        set errorStack [BmipResponseErrorStack firstBmip]
        if { ![lempty $errorStack] } {
        ErrorThrow errorStack
    } else {
        foreach item $bmipResponse {
            set attrval [BmipResponseAttrValList item]
            lappend userlist [keylget attrval pw_name]
        }
    }
    return [lsort $userlist]
}
proc SaGetPwEnts {{host localhost}} {
    set userlist {}
    if {$host == "localhost"} {
        set instance [SaHostGetLocalName]
    } else {
        set instance [list [list [list systemId $host] $host]]
    }
    set call [list \
        ObjectGet -scope 1 {sco users} \
        $instance \
        {pw_name pw_uid pw_gid pw_dir pw_shell}]
    set bmipResponse [SaMakeObjectCall $call]
    set firstBmip [lindex $bmipResponse 0]
        set errorStack [BmipResponseErrorStack firstBmip]
        if { ![lempty $errorStack] } {
        ErrorThrow errorStack
    } else {
        foreach item $bmipResponse {
            set attrval [BmipResponseAttrValList item]
            set pw_name [keylget attrval pw_name]
            keylset userlist $pw_name $attrval
        }
    }
    return $userlist
}
proc SaGroupsGet {{host localhost}} {
    set grouplist {}
    if {$host == "localhost"} {
        set instance [SaHostGetLocalName]
    } else {
        set instance [list [list [list systemId $host] $host]]
    }
    set call [list \
        ObjectGet -scope 1 {sco groups} \
        $instance \
        {gr_name}]
    set bmipResponse [SaMakeObjectCall $call]
    set firstBmip [lindex $bmipResponse 0]
        set errorStack [BmipResponseErrorStack firstBmip]
        if { ![lempty $errorStack] } {
        ErrorThrow errorStack
    } else {
        foreach item $bmipResponse {
            set attrval [BmipResponseAttrValList item]
            lappend grouplist [keylget attrval gr_name]
        }
    }
    return [lsort $grouplist]
}
#@packend
#@package: SaPrinter  SaPrintersGet SaPrinterGetDefault SaPrinterGetClasses SaPrinterGetQueues
proc SaPrintersGet {} {
    set printerlist {}
    set curdir [pwd]
    cd /usr/spool/lp/admins/lp/printers
    if {[catch "glob *" printerlist] } {
        set printerlist {}
    }
    cd $curdir
    return $printerlist
}
proc SaPrinterGetDefault {} {
    set default {}
    if {[info exists env(LPDEST)]} {
        set default $env(LPDEST)
        return $default
    } elseif {[catch "open /usr/spool/lp/admins/lp/default r" fd]} {
        return $default
    } else {
        set default [read -nonewline $fd]
        close $fd
        return $default
    }
}
proc SaPrinterGetClasses {} {
    set curdir [pwd]
    cd /usr/spool/lp/admins/lp/classes
    if {[catch "glob *" classlist] } {
        set classlist {}
    }
    cd $curdir
    return $classlist
}
proc SaPrinterGetQueues {} {
    return [concat [SaPrintersGet] [SaPrinterGetClasses]]
}
#@packend