Seth Woolley's Man Viewer

wish(1) - wish, wish - Simple windowing shell - man 1 wish

([section] manual, -k keyword, -K [section] search, -f whatis)
man plain no title

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

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

       -geometry geometry  Initial geometry to use for window.  If this option
                           is specified, its value is stored in(1,8)  the  geometry
                           global  variable  of  the  application's Tcl inter-

       -name name          Use name as the title to be displayed in(1,8)  the  win-
                           dow,  and  as  the name of the interpreter for send(2,n)

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

       -use id             Specifies  that the main window for the application
                           is to be embedded in(1,8) the window whose identifier is
                           id,  instead  of  being  created  as an independent
                           toplevel window.  Id must be specified in(1,8) 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 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.

       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 interactively from stan-
       dard 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(1,n) .wishrc in(1,8) the home directory of the user,  wish
       evaluates  the  file(1,n) as a Tcl script just before reading the first com-
       mand 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(1,8)
       fileName (which presumably creates a  user  interface),  then  it  will
       respond  to  events until all windows have been deleted.  Commands will
       not be read(2,n,1 builtins) from standard input.  There is no automatic  evaluation  of
       .wishrc when the name of a script file(1,n) is presented on the wish command
       line, but the script file(1,n) can always source it if(3,n) desired.

       Wish automatically processes all of the command-line options  described
       in(1,8) 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(2,n)
       commands, is taken from the -name option, if(3,n) it is  specified;   other-
       wise it is taken from fileName, if(3,n) it is specified, or from the command
       name by which wish was invoked.  In the last two  cases,  if(3,n)  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 speci-
       fying  options  with a RESOURCE_MANAGER property or .Xdefaults file(1,n), 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  arguments  (0  if(3,n)
                      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(1,8)  OPTIONS  above,  in(1,8) order, or an
                      empty string(3,n) if(3,n) there are no such arguments.

       argv0          Contains fileName if(3,n) it was specified.  Otherwise,  con-
                      tains 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(1,8) a wm geometry command to set(7,n,1 builtins) the main
                      window's geometry.

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

       If   you   create   a  Tcl  script  in(1,8)  a  file(1,n)  whose  first  line  is
       #!/usr/local/bin/wish then you can invoke the script file(1,n) directly from
       your  shell  if(3,n)  you mark it as executable.  This assumes that wish has
       been installed in(1,8) the default  location  in(1,8)  /usr/local/bin;   if(3,n)  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(1,8)  length,  so  be  sure  that  the wish executable can be
       accessed with a short file(1,n) name.

       An even better approach is to start your script files with the  follow-
       ing  three  lines: #!/bin/sh # the next line restarts using wish \ exec(3,n,1 builtins)
       wish "$0" "$@" This approach has three advantages over the approach  in(1,8)
       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(1,8)  your
       shell  search  path.  Second, it gets(3,n) around the 30-character file(1,n) name
       limit in(1,8) the previous approach.  Third, this approach will work even if(3,n)
       wish is itself a shell script (this is done on some systems in(1,8) 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(3,n,1 builtins) 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(3,n,1 builtins) 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.

       The end of a script file(1,n) may be marked either by the  physical  end  of
       the medium, or by the character, '\032' ('\u001a', control-Z).  If this
       character is present in(1,8) the file(1,n), the wish application will  read(2,n,1 builtins)  text
       up  to  but  not including the character.  An application that requires
       this character in(1,8) the file(1,n) may encode  it  as  ``\032'',  ``\x1a'',  or
       ``\u001a'';  or  may  generate  it by use of commands such as format or

       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(1,8)  tcl_prompt1.   The  variable
       tcl_prompt2  is  used  in(1,8) a similar way when a newline is typed but the
       current command isn't yet complete; if(3,n) tcl_prompt2 isn't  set(7,n,1 builtins)  then  no
       prompt is output for incomplete commands.

       shell, toolkit

Tk                                    8.0                              wish(1)

References for this manual (incoming links)