wish

NAME

       wish - Simple windowing shell

SYNOPSIS

       wish ?fileName arg arg ...?

OPTIONS

       -colormap new       Specifies  that the window should have
                           a  new  private  colormap  instead  of
                           using  the  default  colormap  for the
                           screen.

       -display display    Display (and screen) on which to  dis-
                           play window.

       -geometry geometry  Initial  geometry  to  use for window.
                           If this option is specified, its value
                           is stored in the geometry global vari-
                           able of the application's  Tcl  inter-
                           preter.

       -name name          Use  name as the title to be displayed
                           in the window, and as the name of  the
                           interpreter for send commands.

       -sync               Execute  all  X  server  commands syn-
                           chronously,   so   that   errors   are
                           reported   immediately.    This   will
                           result in much slower  execution,  but
                           it is useful for debugging.

       -visual visual      Specifies  the  visual  to use for the
                           window.  Visual may have  any  of  the
                           forms  supported  by  the Tk_GetVisual
                           procedure.

       --                  Pass all remaining  arguments  through
                           to  the script's argv variable without
                           interpreting them.   This  provides  a
                           mechanism  for  passing arguments such
                           as -name to a script instead of having
                           wish interpret them.

DESCRIPTION

       Wish  is  a  simple  program consisting of the Tcl command
       language, the Tk toolkit, and a main  program  that  reads
       commands from standard input or from a file.  It creates a
       main window and then processes Tcl commands.  If  wish  is
       invoked  with  no arguments, or with a first argument that
       starts with ``-'', then it  reads  Tcl  commands  interac-
       tively  from  standard input.  It will continue processing
       commands until all windows have been deleted or until end-
       of-file  is  reached on standard input.  If there exists a
       file .wishrc in the home directory of the user, wish eval-
       uates  the  file  as  a Tcl script just before reading the
       first command from standard input.

       If wish is invoked with an initial fileName argument, then
       fileName  is  treated  as the name of a script file.  Wish
       will evaluate the script  in  fileName  (which  presumably
       creates  a user interface), then it will respond to events
       until all windows have been deleted.  Commands will not be
       read  from  standard input.  There is no automatic evalua-
       tion of .wishrc in this case,  but  the  script  file  can
       always source it if desired.

OPTIONS

       Wish  automatically  processes  all  of  the  command-line
       options described in the OPTIONS summary above.  Any other
       command-line arguments besides these are passed through to
       the  application  using  the  argc  and   argv   variables
       described later.

APPLICATION NAME AND CLASS

       The  name  of  the application, which is used for purposes
       such as send commands, is taken from the -name option,  if
       it  is specified;  otherwise it is taken from fileName, if
       it is specified, or from the command name  by  which  wish
       was  invoked.  In the last two cases, if the name contains
       a ``/'' character, then only the characters after the last
       slash are used as the application name.

       The  class  of the application, which is used for purposes
       such as specifying options with a  RESOURCE_MANAGER  prop-
       erty  or  .Xdefaults  file, is the same as its name except
       that the first letter is capitalized.

VARIABLES

       Wish sets the following Tcl variables:

       argc           Contains a count of the number of arg argu-
                      ments   (0  if  none),  not  including  the
                      options described above.

       argv           Contains a Tcl list whose elements are  the
                      arg  arguments  that  follow a -- option or
                      don't match any of the options described in
                      OPTIONS above, in order, or an empty string
                      if there are no such arguments.

       argv0          Contains  fileName  if  it  was  specified.
                      Otherwise,  contains the name by which wish
                      was invoked.

       geometry       If the -geometry option is specified,  wish
                      copies  its  value  into this variable.  If
                      the variable still  exists  after  fileName
                      has  been evaluated, wish uses the value of
                      the variable in a wm  geometry  command  to
                      set the main window's geometry.

       tcl_interactive
                      Contains  1  if  wish  is  reading commands
                      interactively (fileName was  not  specified
                      and   standard  input  is  a  terminal-like
                      device), 0 otherwise.

SCRIPT FILES

       If you create a Tcl script in a file whose first  line  is
       #!/usr/local/bin/wish  then you can invoke the script file
       directly from your shell if you  mark  it  as  executable.
       This  assumes  that wish has been installed in the default
       location in /usr/local/bin;  if it's  installed  somewhere
       else  then  you'll have to modify the above line to match.
       Many UNIX systems do not allow the #! line to exceed about
       30  characters  in  length,  so be sure that the wish exe-
       cutable can be accessed with a short file name.

       An even better approach is to start your script files with
       the  following  three  lines:  #!/bin/sh  #  the next line
       restarts using wish \ exec wish "$0"  "$@"  This  approach
       has  three  advantages  over  the approach in the previous
       paragraph.  First, the location of the wish binary doesn't
       have to be hard-wired into the script:  it can be anywhere
       in your shell search path.  Second,  it  gets  around  the
       30-character  file  name  limit  in the previous approach.
       Third, this approach will work even if wish  is  itself  a
       shell  script  (this  is  done on some systems in order to
       handle multiple architectures or operating  systems:   the
       wish  script selects one of several binaries to run).  The
       three lines cause both sh and wish to process the  script,
       but  the  exec  is  only executed by sh.  sh processes the
       script first;  it treats the second line as a comment  and
       executes  the  third  line.   The exec statement cause the
       shell to stop processing and instead to start up  wish  to
       reprocess  the  entire  script.   When  wish starts up, it
       treats all three lines as comments, since the backslash at
       the  end  of  the  second line causes the third line to be
       treated as part of the comment on the second line.

PROMPTS

       When wish is invoked interactively it normally prompts for
       each  command  with  ``% ''.  You can change the prompt by
       setting the variables  tcl_prompt1  and  tcl_prompt2.   If
       variable  tcl_prompt1 exists then it must consist of a Tcl
       script to output a prompt;  instead of outputting a prompt
       wish  will  evaluate the script in tcl_prompt1.  The vari-
       able tcl_prompt2 is used in a similar way when  a  newline
       is  typed  but  the current command isn't yet complete; if
       tcl_prompt2 isn't set then no prompt is output for  incom-
       plete commands.

KEYWORDS

       shell, toolkit