wish(1)                  Tk Applications                  wish(1)


       wish - Simple windowing shell

       wish ?fileName arg arg ...?

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

       -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-

       -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.

       -use                                                       |
                           id                                                           ||
                           Specifies that the main window for the |
                           application is to be embedded  in  the |
                           window whose identifier is id, instead |
                           of being  created  as  an  independent |
                           toplevel window.  Id must be specified |
                           in the same way as the value  for  the |
                           -use option for toplevel widgets (i.e. |
                           it has a form like  that  returned  by |
                           the winfo id command).

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

       --                  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.

       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.

       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.

       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.

       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.

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

       If you create a Tcl script in a file whose first line is
       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 char-
       acters in length, so be sure that the wish executable  can
       be accessed with a short file name.

       An even better approach is to start your script files with
       the following three lines:
              # 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 previ-
       ous 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 sys-
       tems:  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  pro-
       cesses  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.

       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.

       shell, toolkit

Tk                             8.0                              1