# -*- autoconf -*-
# FILE: "/diska/home/joze/src/tclreadline/configure.in"
# LAST MODIFICATION: "Mon Sep 13 17:51:49 1999 (joze)"
# FILE: "/disk01/home/joze/src/tclreadline/configure.in"
# LAST MODIFICATION: "Tue Sep 14 11:23:46 1999 (joze)"
# (C) 1998, 1999 by Johannes Zellner, <johannes@zellner.org>
# $Id$
# ---
#
# tclreadline -- gnu readline for tcl
# Copyright (C) 1999  Johannes Zellner
#

AC_ARG_WITH(readline-includes,
            [  --with-readline-includes=DIR
                          readline include files in DIR],
            rl_includes=$withval, rl_includes=$prefix/include)

AC_MSG_CHECKING([where to look for readline.h])
READLINE_INCLUDE_DIR=""
for dir in $rl_includes $prefix/include/readline /usr/include/readline /usr/include; do
for dir in $rl_includes $prefix/include/readline /usr/include/readline /usr/include /usr/local/include/readline /usr/local/include; do
    if test -r $dir/readline.h; then
        READLINE_INCLUDE_DIR=$dir
        break
    fi
done

if test -z "$READLINE_INCLUDE_DIR"; then

    GPL
    Makefile.in
    README
    configure.in
    pkgIndex.tcl.in
    sample.tclshrc
    sources
    config.h.in
    tclreadline.c
    tclreadline.h.in
    tclreadline.n.in
    tclreadlineConfig.sh.in
    tclreadlineInit.tcl.in
    tclreadlineSetup.tcl.in
    tclreadlineCompleter.tcl

 /* ==================================================================

    FILE: "/home/joze/src/tclreadline/tclreadline.c"
    LAST MODIFICATION: "Tue Sep 14 00:57:33 1999 (joze)"
    FILE: "/diska/home/joze/src/tclreadline/tclreadline.c"
    LAST MODIFICATION: "Tue Sep 14 11:57:42 1999 (joze)"
    (C) 1998, 1999 by Johannes Zellner, <johannes@zellner.org>
    $Id$
    ---

    tclreadline -- gnu readline for tcl
    Copyright (C) 1999  Johannes Zellner

#   include "config.h"
#endif

#include <tcl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define READLINE_LIBRARY
#include <readline.h>
#include <history.h>
#include <readline/readline.h>
#include <readline/history.h>

/**
 * this prototype is missing
 * in readline.h
 */
void rl_extend_line_buffer(int len);

#!/usr/locanl/bin/tclsh
# FILE: "/home/joze/src/tclreadline/tclreadlineCompleter.tcl"
# LAST MODIFICATION: "Tue Sep 14 01:55:17 1999 (joze)"
# -*- tclsh -*-
# FILE: "/diska/home/joze/src/tclreadline/tclreadlineCompleter.tcl"
# LAST MODIFICATION: "Tue Sep 14 16:17:25 1999 (joze)"
# (C) 1998, 1999 by Johannes Zellner, <johannes@zellner.org>
# $Id$
# ---
#
# tclreadline -- gnu readline for tcl
# Copyright (C) 1999  Johannes Zellner
#

        # as we've reached here no valid specific completer
        # was found. Check, if it's a proc and return the
        # arguments.
        #
        if {[string length [uplevel [info level] info proc $alias]]} {
            set args [uplevel [info level] info args $alias]
            set arg [lindex $args [expr $pos - 1]]
            if {"" != $arg} {
            if {"" != $arg && "args" != $arg} {
                if {[uplevel [info level] info default $alias $arg junk]} {
                    return [DisplayHints ?$arg?]
                } else {
                    return [DisplayHints <$arg>]
                }
            }
        }


        # Ok, also no proc. Try to do the same as for widgets now:
        # try to get at least the first option from an error output.
        # if the subcommand is configure or cget, try to get the
        # option table.
        #
        switch -- $pos {
            1 {
                set cmds [TrySubCmds ${alias}]
                if {[llength ${cmds}]} {
                    return [TryFromList ${part} ${cmds}]
                }
            }
            default {
                set sub [Lindex $line 1]
                switch -- $sub {
                    configure -
                    cget {
                        if {[OptionTable ${widget} options]} {
                        }
                    }
                }
            }
        }


        # no specific command completer found.
        return ""
    }

                eval -
                exists -
                expose -
                hide -
                hidden -
                invokehidden -
                marktrusted -
                target { return [DisplayHints [interp slaves]] }
                target { return [CompleteFromList ${text} [interp slaves]] }

                aliases -
                delete -
                issafe -
                slaves { return [DisplayHints [interp slaves]] }
                slaves { return [CompleteFromList ${text} [interp slaves]] }

                alias -
                share -
                transfer { return [DisplayHints <srcPath>] }
            }
        }
        3 {

                        return [CompleteFromList $text "$cmds ?path?"]
                    } else {
                        return [DisplayHints ?path?]
                    }
                }

                eval { return [DisplayHints <arg>] }
                delete { return [DisplayHints [interp slaves]] }
                delete { return [CompleteFromList ${text} [interp slaves]] }

                expose { return [DisplayHints <hiddenName>] }
                hide { return [DisplayHints <exposedCmdName>] }

                invokehidden {
                    return \
                    [CompleteFromList $text {?-global? <hiddenCmdName>}]

                    }
                }

                expose { return [DisplayHints ?exposedCmdName?] }
                hide { return [DisplayHints ?hiddenCmdName?] }

                share -
                transfer { return [DisplayHints [interp slaves]] }
                transfer { return [CompleteFromList ${text} [interp slaves]] }
            }
        }
        5 {
            switch -- $cmd {

                alias { return [DisplayHints <targetCmd>] }
                invokehidden -
                eval { return [DisplayHints ?arg?] }

                expose { return [DisplayHints ?exposedCmdName?] }
                hide { return [DisplayHints ?hiddenCmdName?] }

                share -
                transfer { return [DisplayHints [interp slaves]] }
                transfer { return [CompleteFromList ${text} [interp slaves]] }
            }
        }
    }
    return ""
}

proc complete(join) {text start end line pos mod} {

    set tree [WidgetChildren ${pattern}]
    foreach widget $tree {
        append tree " [WidgetDescendants $widget]"
    }
    return $tree
}

proc complete(WIDGET) {text start end line pos mod} {
    set widget [lindex ${line} 0]
    set cmd [lindex ${line} 1]

proc ToplevelWindows {} {
    set children [WidgetChildren ""]
    set toplevels ""
    foreach widget $children {
        set toplevel [winfo toplevel $widget]
        if {-1 == [lsearch $toplevels $toplevel]} {
            lappend toplevels $toplevel
        }
    }
    return $toplevels
}

#**
# try to get options for commands which
# allow `configure' (cget).
# @param command.
# @param optionsT where the table will be stored.
# @return number of options
# @date Sep-14-1999
#
proc OptionTable {cmd optionsT} {
    upvar $optionsT options
    # first we build an option table
    #
    if {[catch [list set option_table [${widget} configure]] msg]} {
        return ""
        return 0
    }
    foreach optline ${option_table} {
        if {5 != [llength ${optline}]} continue else {
            lappend options(switches) [lindex ${optline} 0]
            lappend options(value)    [lindex ${optline} 4]
        }
    }
    return [llength ${option_table}
}

#**
# :xa
# @param
# @return
# @warning
# @sa
# @author Johannes Zellner
# @date Sep-14-1999
#
proc CompleteFromOptions {text start line cmd} {
    OptionTable ${widget} options
    set prev [PreviousWord ${start} ${line}]
    #puts \nprev=|$prev|
    #puts switches=|$options(switches)|
    #puts found=[lsearch -exact ${prev} $options(switches)]
    if {-1 != [set found \
        [lsearch -exact $options(switches) ${prev}]]
    } {
        if {![llength ${text}]} {
            return [list "[lindex $options(value) ${found}]"]
        }
    } else {
        return [TryFromList ${text} $options(switches)]
    }
}

proc complete(WIDGET) {text start end line pos mod} {
    set widget [lindex ${line} 0]
    set cmd [lindex ${line} 1]

    switch -- $pos {
        1 {
            set cmds [TrySubCmds ${widget}]
            if {[llength ${cmds}]} {
                return [TryFromList ${mod} ${cmds}]
            }
        }
        2 {
            if {([string match ${cmd}* cget] || \
                [string match ${cmd}* configure])
            } {
                set prev [PreviousWord ${start} ${line}]
                return [CompleteFromOptions ${text} ${start} ${line} ${widget}]
                #puts \nprev=|$prev|
                #puts switches=|$options(switches)|
                #puts found=[lsearch -exact ${prev} $options(switches)]
                if {-1 != [set found \
                    [lsearch -exact $options(switches) ${prev}]]
                } {
                    if {![llength ${mod}]} {
                        return [list "[lindex $options(value) ${found}]"]
                    }
                } else {
                    return [TryFromList ${mod} $options(switches)]
                }
            }
        }
    }
    return ""
}

# SPECIFIC TK COMMAND COMPLETERS

proc complete(bell) {text start end line pos mod} {
    switch -- $pos {
        1 { return [CompleteFromList ${text} -displayof] }
        2 {
            if {"-displayof" == [PreviousWord ${start} ${line}]} {
                return [CompleteFromList ${text} [ToplevelWindows]]
            }
        }
    }
}

# proc complete(bind) {text start end line pos mod} {
#     TODO
#     return ""
# }

proc complete(image) {text start end line pos mod} {
    set sub [Lindex $line 1]
    switch -- $pos {
        1 { return [CompleteFromList ${text} [TrySubCmds image]] }
        2 {
            switch -- $sub {
                create { return [CompleteFromList ${text} [image types]] }
                delete -
                height -
                type -
                width { return [CompleteFromList ${text} [image names]] }
                names {}
                types {}
            }
        }
        3 {
            switch -- $sub {
                create {
                    set type [Lindex $line 2]
                    switch -- $type {
                        bitmap {
                return [CompleteFromList ${text} [WidgetDescendants ${text}]]
                            return [CompleteFromList ${text} {
                                ?name? -background -data -file
                                -foreground -maskdata -maskfile
                            }]
                        }
                        photo {
                            # TODO
                        }
                        default {}
                    }
                }
                default {}
            }
        }
        default {
            switch -- $sub {
                create {
                    set type [Lindex $line 2]
                    set prev [PreviousWord $start $line]
                    # puts stderr prev=$prev
                    switch -- $type {
                        bitmap {
                            switch -- $prev {
                                -background -
                                -foreground { return [DisplayHints <color>] }
                                -data -
                                -maskdata { return [DisplayHints <string>] }
                                -file -
                                -maskfile { return "" }
                                default {
                                    return [CompleteFromList ${text} \
                                    [RemoveUsedOptions ${line} {
                                        -background -data -file
                                        -foreground -maskdata -maskfile
                                    }]]
                                }
                            }
                        }
                        photo {
                            # TODO
                        }
                    }
                }
            }
        }
    }
}

proc complete(winfo) {text start end line pos mod} {
    set cmd [lindex ${line} 1]