ttk.Label(frm, text="Name:").grid(column=0, row=0, sticky="w")
  ttk.Entry(frm).grid(column=1, row=0)
  ttk.Button(frm, text="OK").grid(column=1, row=1, sticky="e")

  toolbar.pack(side="top", fill="x")
  status.pack(side="bottom", fill="x")
  body.pack(side="left", expand=True, fill="both")

  background.place(x=0, y=0, relwidth=1.0, relheight=1.0)
  badge.place(relx=1.0, rely=0.0, anchor="ne")

  def print_it():
      print("hi there")
  fred["command"] = print_it

  Return the current value of the configuration option named *key*
  for this widget, as a string. The expression "widget[key]" is
  equivalent and may be used instead.

  Query or modify the configuration options of the widget. With no
  arguments, return a dictionary mapping every available option
  name to a tuple describing it (its name, X resource name, X
  resource class, default value and current value). If a single
  option name is given as a string, return the tuple for just that
  option. If one or more keyword arguments are given, or a
  dictionary is passed as *cnf*, set each named option to the
  corresponding value; the expression "widget[key] = value" sets a
  single option in the same way.

  "config()" is an alias of "configure()".

  Return a list of the names of all configuration options of this
  widget.

  Interpret the string *s* as a Tcl boolean and return the
  corresponding "bool". Tcl accepts values such as "'1'", "'0'",
  "'yes'", "'no'", "'true'" and "'false'". Raise "ValueError" if
  *s* is not a valid boolean.

  Interpret the string *s* as a Tcl floating-point number and
  return it as a "float". Raise "ValueError" if *s* is not a valid
  number.

  Added in version 3.5.

  Interpret the string *s* as a Tcl integer and return it as an
  "int". Raise "ValueError" if *s* is not a valid integer.

  Return the value of the Tcl global variable named *name*.

  Set the Tcl global variable named *name* to *value*.

  The "getvar()" and "setvar()" methods give direct access to Tcl
  variables. In most code you will instead use a "Variable"
  subclass such as "StringVar" or "IntVar", which wraps a Tcl
  variable and converts its value to and from a Python type.

  Register the Python callable *func* as a Tcl command and return
  the name of the new command as a string. Whenever Tcl invokes
  that command, *func* is called; if *subst* is given, it is
  applied to the command's arguments first. This is the mechanism
  used internally to turn Python callbacks into the command names
  passed to Tk options such as *command*. Unless *needcleanup* is
  false, the command is deleted automatically when the widget is
  destroyed.

  Distinto en la versión 3.13: The arguments passed to *func* are
  no longer converted to strings.

  Delete the Tcl command named *name*, such as one previously
  returned by "register()".

  Return the widget instance corresponding to the Tk pathname
  *name*.

  Send the Tcl command *cmd*, with the given *args*, to the Tcl
  interpreter registered under the name *interp*, and return its
  result. This is not available on all platforms.

  Destroy this widget and all of its descendant widgets, and
  delete the Tcl commands associated with them.

  Raise this widget in the stacking order so that it is drawn on
  top of its siblings. If *aboveThis* is given, the widget is
  moved to be just above it in the stacking order instead.

  "lift()" is an alias of "tkraise()".

  Lower this widget in the stacking order so that it is drawn
  beneath its siblings. If *belowThis* is given, the widget is
  moved to be just below it in the stacking order instead.

  "tkraise()"/"lift()" and "lower()" are overridden by the
  "Canvas" widget, where they restack canvas items instead.

  Return the names of all images that currently exist in the Tcl
  interpreter.

  This is overridden by the "Text" widget, where "image_names()"
  returns the names of its embedded images instead.

  Return the available image types, such as "'photo'" and
  "'bitmap'".

  Set the anchor that controls where the grid is placed inside
  this container when the container is larger than the grid and no
  row or column has a non-zero weight. *anchor* is one of the
  usual anchor strings, such as "'nw'" (the default) or
  "'center'". Called with no argument, this method has no effect.

  "anchor()" is an alias of "grid_anchor()".

  Added in version 3.3.

  Return the bounding box, in pixels, of a region of the grid laid
  out in this container, as a 4-tuple "(xoffset, yoffset, width,
  height)". With no arguments the bounding box of the whole grid
  is returned. If *column* and *row* are given, the box spans from
  the cell at row and column 0 to that cell; if *col2* and *row2*
  are also given, it spans from the cell (*column*, *row*) to the
  cell (*col2*, *row2*).

  "bbox()" is an alias of "grid_bbox()", except on "Canvas",
  "Listbox", "Spinbox", "Text", "ttk.Entry" and "ttk.Treeview",
  which provide their own "bbox()" method.

  Query or set the properties of the column (or columns) *index*
  of the grid managed by this container. *index* may be a column
  number; when setting options it may also be a list of column
  numbers, the string "'all'" to affect every column, or a child
  widget whose occupied columns are affected. The supported
  options are:

  *minsize*
     The column's minimum size, in pixels.

  *weight*
     An integer setting how much of any extra space is apportioned
     to the column. A weight of "0" keeps the column at its
     requested size, and a column of weight two grows twice as
     fast as a column of weight one.

  *uniform*
     The name of a uniform group. Columns sharing a non-empty
     group name are kept in sizes that are strictly proportional
     to their weights.

  *pad*
     Extra space, in pixels, added to the largest widget in the
     column when computing the column's size.

  With a single option name, return that option's value; with no
  options, return a dictionary of all of them.

  "columnconfigure()" is an alias of "grid_columnconfigure()".

  Query or set the properties of the row (or rows) *index* of the
  grid managed by this container. *index* is interpreted as for
  "grid_columnconfigure()", and the supported options (*minsize*,
  *weight*, *uniform* and *pad*) are the same, applied to a row
  instead of a column.

  "rowconfigure()" is an alias of "grid_rowconfigure()".

  Return the "(column, row)" of the grid cell that contains the
  pixel at position (*x*, *y*), given in pixels relative to this
  container. For locations above or to the left of the grid, "-1"
  is returned for the corresponding coordinate.

  Enable or disable geometry propagation for this container when
  it manages its children with the grid geometry manager. When
  *flag* is true, the container resizes itself to fit the
  requested sizes of its children; when it is false, its size is
  left under your control. Called with no argument, return the
  current setting as a boolean.

  Return the size of the grid managed by this container as a
  "(columns, rows)" tuple.

  "size()" is an alias of "grid_size()", except on the "Listbox"
  widget, which provides its own "size()" method.

  Return a list of the child widgets managed in this container's
  grid, most recently managed first. If *row* or *column* is
  given, only the children in that row or column are returned.

  Enable or disable geometry propagation for this container when
  it manages its children with the pack geometry manager. When
  *flag* is true, the container resizes itself to fit the
  requested sizes of its children; when it is false, its size is
  left under your control. Called with no argument, return the
  current setting as a boolean.

  "propagate()" is an alias of "pack_propagate()".

  Return a list of the child widgets managed by this container
  with the pack geometry manager, in packing order.

  "slaves()" is an alias of "pack_slaves()".

  Return a list of the child widgets managed by this container
  with the place geometry manager.

  Bind the event pattern *sequence* on this widget to the callable
  *func*.

  *sequence* is an event pattern, such as "'<Button-1>'" (a mouse
  click) or "'<KeyPress-a>'", optionally a concatenation of
  several such patterns that must occur shortly after one another.
  When the event occurs, *func* is called with an "Event" instance
  describing it as its only argument; if *func* returns the string
  "'break'", no further bindings for the event are invoked.

  If *add* is true, *func* is added to any functions already bound
  to *sequence*; otherwise it replaces them. The binding applies
  only to this widget.

  "bind()" returns a string identifier (a *funcid*) that can later
  be passed to "unbind()" to remove the binding without leaking
  the associated Tcl command.

  If *func* is omitted, return the binding currently associated
  with *sequence*; if *sequence* is also omitted, return a list of
  all the sequences for which bindings exist on this widget.

  Like "bind()", but bind *func* to the binding tag *className*
  rather than to a single widget, so that the binding applies to
  every widget having that tag. *className* is usually the name of
  a widget class, such as "'Button'", in which case the binding
  affects all widgets of that class. The set of binding tags for a
  widget can be inspected and changed with "bindtags()".

  The remaining arguments and the return value are as for
  "bind()".

  Like "bind()", but bind *func* to the special binding tag
  "'all'", so that the binding applies to every widget in the
  application.

  The remaining arguments and the return value are as for
  "bind()".

  Remove bindings for the event pattern *sequence* on this widget.

  If *funcid* is given, only the function identified by it (a
  value returned from a previous call to "bind()") is removed, and
  its associated Tcl command is deleted. Otherwise all bindings
  for *sequence* are destroyed, leaving it unbound.

  Distinto en la versión 3.13: If *funcid* is given, only that
  callback is unbound; other callbacks bound to *sequence* are
  kept.

  Remove all bindings for the event pattern *sequence* from the
  binding tag *className*. See "bind_class()".

  Remove all bindings for the event pattern *sequence* from the
  special binding tag "'all'". See "bind_all()".

  If *tagList* is omitted, return a tuple of the binding tags
  associated with this widget. When an event occurs in a widget,
  it is applied to each of the widget's binding tags in order, and
  for each tag the most specific matching binding is executed. By
  default a widget has four binding tags: its own pathname, its
  widget class, the pathname of its nearest toplevel ancestor, and
  "'all'", in that order.

  If *tagList* is given, it must be a sequence of strings; the
  widget's binding tags are set to its elements, which determines
  the order in which bindings are evaluated.

  Associate the virtual event *virtual*, whose name has the form
  "'<<Paste>>'", with each of the physical event patterns given by
  *sequences*, so that the virtual event triggers whenever any of
  them occurs. If *virtual* is already defined, the new sequences
  are added to its existing ones.

  Remove each of *sequences* from those associated with the
  virtual event *virtual*. Sequences that are not currently
  associated with *virtual* are ignored. If no *sequences* are
  given, all physical event sequences are removed, so that
  *virtual* no longer triggers.

  Generate the event *sequence* on this widget and arrange for it
  to be processed just as if it had come from the window system.
  *sequence* must be a single event pattern, such as
  "'<Button-1>'" or "'<<Paste>>'", not a concatenation of several.
  Keyword arguments specify additional fields of the event, for
  example *x* and *y* for the pointer position, or *when* to
  control when the event is processed; refer to the Tk "event"
  manual page for the full list.

  If *virtual* is omitted, return a tuple of all the virtual
  events that are currently defined. If *virtual* is given, return
  a tuple of the physical event sequences currently associated
  with it, or an empty tuple if it is not defined.

  Schedule the callable *func* to be called after *ms*
  milliseconds, with *args* and *kw* passed to it as positional
  and keyword arguments. Return an identifier that can be passed
  to "after_cancel()" to cancel the call.

  If *func* is omitted, sleep for *ms* milliseconds instead,
  processing no events during that time, and return "None".

  Distinto en la versión 3.10: *func* can now be any callable
  object, not only a function.

  Distinto en la versión 3.14: Keyword arguments are now passed to
  *func*.

  Cancel a callback previously scheduled with "after()" or
  "after_idle()". *id* must be an identifier returned by one of
  those methods; passing a value that is not such an identifier
  raises "ValueError". If the callback has already run or been
  cancelled, this has no effect.

  Distinto en la versión 3.7: Passing "None" (or any false value)
  as *id* now raises "ValueError".

  Schedule the callable *func* to be called, with *args* and *kw*
  passed to it, when the Tk main loop next becomes idle, that is,
  when it has no other events to process. Return an identifier
  that can be passed to "after_cancel()" to cancel the call.

  Distinto en la versión 3.14: Keyword arguments are now passed to
  *func*.

  If *id* is omitted, return a tuple of the identifiers of all
  callbacks currently scheduled with "after()" and "after_idle()"
  for this interpreter.

  If *id* is given, it must identify a callback that has not yet
  run or been cancelled, and the return value is a tuple "(script,
  type)", where *script* refers to the function to be called and
  *type* is either "'idle'" or "'timer'". A "TclError" is raised
  if *id* does not exist.

  Added in version 3.13.

  Enter the Tk event loop, which processes events until all
  windows are destroyed. This is normally called once, on the root
  window, to run the application.

  Quit the Tcl interpreter, causing "mainloop()" to return.

  Enter the event loop until all pending events, including idle
  callbacks, have been processed. This brings the display up to
  date and handles any events that are already queued, then
  returns.

  Enter the event loop until all pending idle callbacks have been
  called. This updates the display of windows, for example after
  geometry changes, but does not process events caused by the
  user.

  Wait until the Tcl variable *name* is modified, continuing to
  process events in the meantime so that the application stays
  responsive. *name* is usually a "Variable" instance, such as an
  "IntVar" or "StringVar".

  "waitvar()" is an alias of "wait_variable()".

  Wait until *window* is destroyed, continuing to process events
  in the meantime. If *window* is omitted, this widget is used.
  This is typically used to wait for the user to finish
  interacting with a dialog box.

  Wait until the visibility state of *window* changes, for example
  when it first appears on the screen, continuing to process
  events in the meantime. If *window* is omitted, this widget is
  used. This is typically used to wait for a newly created window
  to become visible before acting on it.

  Direct the keyboard input focus for this widget's display to
  this widget. If the application does not currently have the
  input focus on this widget's display, the widget is remembered
  as the focus window for its top level, and the focus will be
  redirected to it the next time the window manager gives the
  focus to the top level. "focus()" is an alias of "focus_set()",
  except on the "Canvas" and "ttk.Treeview" widgets, which provide
  their own "focus()" method.

  Direct the keyboard input focus to this widget even if the
  application does not currently have the input focus for the
  widget's display. This method should be used sparingly, if at
  all; normally an application should wait for the window manager
  to give it the focus rather than claiming it.

  Return the widget that currently has the keyboard focus in the
  application, or "None" if no widget in the application has the
  focus. Use "focus_displayof()" to work correctly with several
  displays.

  Return the widget that currently has the keyboard focus on the
  display where this widget is located, or "None" if no widget in
  the application has the focus on that display.

  Return the most recent widget to have had the keyboard focus
  among all the widgets in the same top level as this widget; this
  is the widget that will receive the focus the next time the
  window manager gives the focus to the top level. If no widget in
  that top level has ever had the focus, or if the most recent
  focus widget has been deleted, the top level itself is returned.

  Reconfigure Tk to use an implicit focus model in which the focus
  is set to a widget whenever the mouse pointer enters it. This
  cannot easily be disabled once enabled.

  Return the next widget after this one in the keyboard traversal
  order, or "None" if there is none. The traversal order goes
  first to the next child, then recursively to the children of
  that child, and then to the next sibling higher in the stacking
  order. A widget is skipped if its "takefocus" option is set to
  "0". This method is used in the default bindings for the "Tab"
  key.

  Return the previous widget before this one in the keyboard
  traversal order, or "None" if there is none. See
  "tk_focusNext()" for how the order is defined. This method is
  used in the default bindings for the "Shift"-"Tab" key.

  Set a local grab on this widget. A grab confines pointer events
  to this widget and its descendants: while the pointer is outside
  the widget's subtree, button presses and releases and pointer
  motion are reported to the grab widget, and windows outside the
  subtree become insensitive until the grab is released. A local
  grab affects only the grabbing application. Any grab previously
  set by this application on the widget's display is automatically
  released. Setting a grab is the usual way to make a dialog
  modal: while the grab is in effect the user cannot interact with
  the other windows of the application.

  Set a global grab on this widget. A global grab is like the
  local grab set by "grab_set()", but it locks out all other
  applications on the screen, so that only this widget's subtree
  is sensitive to pointer events, and it also grabs the keyboard.
  Use with caution: it is easy to render a display unusable with a
  global grab, since other applications stop receiving events
  until it is released.

  Release the grab on this widget if there is one; otherwise do
  nothing.

  Return the widget that currently holds the grab in this
  application for this widget's display, or "None" if there is no
  such widget.

  Return "None" if no grab is currently set on this widget,
  ""local"" if a local grab is set, or ""global"" if a global grab
  is set.

  Clear the X selection, so that no window owns it anymore. The
  selection to clear is given by the keyword argument *selection*,
  an atom name such as "'PRIMARY'" or "'CLIPBOARD'"; it defaults
  to "PRIMARY". The *displayof* keyword argument names a widget
  that determines the display on which to operate, and defaults to
  this widget.

  This is overridden by the "Entry", "Listbox" and "Spinbox"
  widgets, where "selection_clear()" clears the widget's own
  selection instead.

  Return the contents of the current X selection. The keyword
  argument *selection* names the selection and defaults to
  "PRIMARY". The keyword argument *type* specifies the form in
  which the data is to be returned (the desired conversion
  target), an atom name such as "'STRING'" or "'FILE_NAME'"; it
  defaults to "STRING", except on X11, where "UTF8_STRING" is
  tried first and "STRING" is used as a fallback. The *displayof*
  keyword argument names a widget that determines the display from
  which to retrieve the selection, and defaults to this widget.

  Register *command* as a handler to supply the X selection owned
  by this widget when another application requests it. When the
  selection is retrieved, *command* is called with two arguments,
  the starting character offset and the maximum number of
  characters to return, and must return at most that many
  characters of the selection starting at that offset; for very
  long selections it is called repeatedly with increasing offsets.
  The keyword argument *selection* names the selection (default
  "PRIMARY") and the keyword argument *type* gives the form of the
  selection that the handler supplies (such as "'STRING'" or
  "'FILE_NAME'", default "STRING").

  Make this widget the owner of the X selection on its display.
  The previous owner, if any, is notified that it has lost the
  selection. The keyword argument *selection* names the selection
  and defaults to "PRIMARY".

  Return the widget in this application that owns the X selection
  on the display containing this widget, or "None" if no widget in
  this application owns the selection. The keyword argument
  *selection* names the selection and defaults to "PRIMARY". The
  *displayof* keyword argument names a widget that determines the
  display to query, and defaults to this widget.

  Append *string* to the Tk clipboard and claim ownership of the
  clipboard on this widget's display. Before appending, the
  clipboard should be emptied with "clipboard_clear()"; all
  appends should be completed before returning to the event loop
  so that the clipboard is updated atomically. The keyword
  argument *type* specifies the form of the data, an atom name
  such as "'STRING'" or "'FILE_NAME'" (default "STRING"), and the
  keyword argument *format* specifies the representation used to
  transmit it (default "STRING"). The *displayof* keyword argument
  names a widget that determines the target display, and defaults
  to this widget. The contents can be retrieved with
  "clipboard_get()" or "selection_get()".

  Claim ownership of the clipboard on this widget's display and
  remove any previous contents. The *displayof* keyword argument
  names a widget that determines the target display, and defaults
  to this widget.

  Retrieve data from the clipboard on this widget's display. The
  keyword argument *type* specifies the form in which the data is
  to be returned, an atom name such as "'STRING'" or
  "'FILE_NAME'"; it defaults to "STRING", except on X11, where
  "UTF8_STRING" is tried first and "STRING" is used as a fallback.
  The *displayof* keyword argument names a widget that determines
  the display, and defaults to the root window of the application.
  This is equivalent to "selection_get(selection='CLIPBOARD')".

  Add an option to the Tk option database that associates *value*
  with *pattern*. *pattern* consists of names and/or classes
  separated by asterisks or dots, in the usual X format.
  *priority* is an integer between 0 and 100, or one of the
  symbolic names "'widgetDefault'" (20), "'startupFile'" (40),
  "'userDefault'" (60), or "'interactive'" (80); it defaults to
  "interactive".

  Clear the Tk option database. Default options from the
  "RESOURCE_MANAGER" property or the ".Xdefaults" file are
  reloaded automatically the next time an option is added to or
  removed from the database.

  Return the value of the option matching this widget under *name*
  and *className* from the Tk option database, or an empty string
  if there is no matching entry. When several entries match, the
  one with the highest priority is returned, and among entries of
  equal priority the most recently added one.

  Read the file named *fileName*, which should have the standard
  format for an X resource database such as ".Xdefaults", and add
  all the options it specifies to the Tk option database.
  *priority* is interpreted as for "option_add()" and defaults to
  "interactive".

  Ring the bell on the display for this widget, using the
  display's current bell-related settings, and reset the screen
  saver for the screen. If *displayof* is given as a widget, the
  bell is rung on that widget's display instead.

  Set a new color scheme for all Tk widget elements. Existing
  widgets are updated and the option database is changed so that
  future widgets use the new colors. A single color argument is
  taken as the normal background color, from which a complete
  palette is computed. Alternatively, the arguments may be given
  as keyword *name*/*value* pairs naming individual options in the
  option database. The recognized option names are
  "activeBackground", "activeForeground", "background",
  "disabledForeground", "foreground", "highlightBackground",
  "highlightColor", "insertBackground", "selectColor",
  "selectBackground", "selectForeground", and "troughColor";
  reasonable defaults are computed for any that are not specified.

  Restore the application's colors to the light brown (bisque)
  color scheme used in Tk 3.6 and earlier versions. Provided for
  backward compatibility.

  Query or set whether Tk's look and feel should strictly adhere
  to Motif. A true *boolean* value enables strict Motif compliance
  (for example, no color change when the mouse passes over a
  slider). Return the resulting setting.

  Make this widget appear busy. A transparent window is placed in
  front of the widget, so that it and all of its descendants in
  the widget hierarchy are blocked from pointer events and display
  a busy cursor. Normally "update()" should be called immediately
  afterwards to ensure that the hold operation is in effect before
  the application starts its processing.

  The only supported configuration option is *cursor*, the cursor
  to be displayed while the widget is busy; it may have any of the
  values accepted by "configure()".

  "busy_hold()", "busy()" and "tk_busy()" are aliases of
  "tk_busy_hold()".

  Added in version 3.13.

  Query or modify the configuration options of the busy window.
  The widget must have been previously made busy by
  "tk_busy_hold()". With no arguments, return a dictionary
  describing all of the available options; if *cnf* is the name of
  an option, return a tuple describing that one option. Otherwise
  set the given options to the given values. Options may have any
  of the values accepted by "tk_busy_hold()".

  The option database is referenced through the widget name or
  class. For example, if a "Frame" widget named "frame" is to be
  made busy, the busy cursor can be specified for it by either of
  the calls:

     w.option_add('*frame.busyCursor', 'gumby')
     w.option_add('*Frame.BusyCursor', 'gumby')

  "busy_configure()", "busy_config()" and "tk_busy_config()" are
  aliases of "tk_busy_configure()".

  Added in version 3.13.

  Return the current value of the busy configuration *option*. The
  widget must have been previously made busy by "tk_busy_hold()",
  and *option* may have any of the values accepted by that method.

  "busy_cget()" is an alias of "tk_busy_cget()".

  Added in version 3.13.

  Make this widget no longer busy, releasing the resources
  (including the transparent window) allocated when it was made
  busy. User events will again be received by the widget. These
  resources are also released when the widget is destroyed.

  "busy_forget()" is an alias of "tk_busy_forget()".

  Added in version 3.13.

  Return "True" if the widget is currently busy, "False"
  otherwise.

  "busy_status()" is an alias of "tk_busy_status()".

  Added in version 3.13.

  Return a list of widgets that are currently busy. If *pattern*
  is given, only busy widgets whose path names match the pattern
  are returned.

  "busy_current()" is an alias of "tk_busy_current()".

  Added in version 3.13.

  Return the integer identifier for the atom whose name is *name*,
  creating a new atom if none exists. If *displayof* is given, the
  atom is looked up on the display of that window; otherwise it is
  looked up on the display of the application's main window.

  Return the textual name for the atom whose integer identifier is
  *id*. This is the inverse of "winfo_atom()". If *displayof* is
  given, the identifier is looked up on the display of that
  window; otherwise it is looked up on the display of the
  application's main window.

  Return the number of cells in the colormap for the widget.

  Return a list containing the widgets that are children of the
  widget, in stacking order from lowest to highest. Toplevel
  windows are returned as children of their logical parents.

  Return the class name of the widget.

  Return "True" if the colormap for the widget is known to be
  full, "False" otherwise.

  Return the widget containing the point given by *rootX* and
  *rootY*, or "None" if no window in this application contains the
  point. The coordinates are in screen units in the coordinate
  system of the root window. If *displayof* is given, the
  coordinates refer to the screen containing that window;
  otherwise they refer to the screen of the application's main
  window.

  Return the depth of the widget, that is, the number of bits per
  pixel.

  Return true if the widget exists, false otherwise.

  Return a floating-point value giving the number of pixels in the
  widget corresponding to the screen distance *number* (for
  example, ""2.0c"" or ""1i""). The result may be fractional; for
  a rounded integer value use "winfo_pixels()".

  Return the geometry of the widget, in the form
  "widthxheight+x+y". All dimensions are in pixels. An offset can
  be negative; see "geometry()".

  Return the height of the widget in pixels. When a window is
  first created its height is 1 pixel; it is eventually changed by
  a geometry manager. See also "winfo_reqheight()".

  Return a low-level platform-specific identifier for the widget.
  On Unix this is the X window identifier, and on Windows it is
  the window handle.

  Return a tuple of the names of all Tcl interpreters currently
  registered for a particular display. If *displayof* is given,
  the return value refers to the display of that window; otherwise
  it refers to the display of the application's main window.

  Return true if the widget is currently mapped, false otherwise.

  Return the name of the geometry manager currently responsible
  for the widget, or an empty string if it is not managed by any
  geometry manager.

  Return the widget's name within its parent, as opposed to its
  full path name.

  Return the path name of the widget's parent, or an empty string
  if the widget is the main window of the application.

  Return the path name of the window whose identifier is *id*. If
  *displayof* is given, the identifier is looked up on the display
  of that window; otherwise it is looked up on the display of the
  application's main window.

  Return the number of pixels in the widget corresponding to the
  screen distance *number* (for example, ""2.0c"" or ""1i""). The
  result is rounded to the nearest integer; for a fractional
  result use "winfo_fpixels()".

  Return the pointer's *x* coordinate, in pixels, relative to the
  screen's root window (or virtual root, if one is in use). Return
  "-1" if the pointer is not on the same screen as the widget.

  Return the pointer's coordinates as an "(x, y)" tuple, in
  pixels, relative to the screen's root window (or virtual root,
  if one is in use). Both coordinates are "-1" if the pointer is
  not on the same screen as the widget.

  Return the pointer's *y* coordinate, in pixels, relative to the
  screen's root window (or virtual root, if one is in use). Return
  "-1" if the pointer is not on the same screen as the widget.

  Return the widget's requested height in pixels. This is the
  value used by the widget's geometry manager to compute its
  geometry.

  Return the widget's requested width in pixels. This is the value
  used by the widget's geometry manager to compute its geometry.

  Return an "(r, g, b)" tuple of the red, green, and blue
  intensities, in the range 0 to 65535, that correspond to *color*
  in the widget. *color* may be specified in any of the forms
  acceptable for a color option.

  Return the *x* coordinate, in the root window of the screen, of
  the upper-left corner of the widget's border (or of the widget
  itself if it has no border).

  Return the *y* coordinate, in the root window of the screen, of
  the upper-left corner of the widget's border (or of the widget
  itself if it has no border).

  Return the name of the screen associated with the widget, in the
  form "displayName.screenIndex".

  Return the number of cells in the default colormap for the
  widget's screen.

  Return the depth of the root window of the widget's screen, that
  is, the number of bits per pixel.

  Return the height of the widget's screen in pixels.

  Return the height of the widget's screen in millimeters.

  Return the width of the widget's screen in millimeters.

  Return the default visual class for the widget's screen, one of
  ""directcolor"", ""grayscale"", ""pseudocolor"",
  ""staticcolor"", ""staticgray"", or ""truecolor"".

  Return the width of the widget's screen in pixels.

  Return a string containing information about the server for the
  widget's display. The exact format of this string may vary from
  platform to platform.

  Return the top-of-hierarchy window containing the widget. In
  standard Tk this is always a "Toplevel" widget.

  Return true if the widget and all of its ancestors up through
  the nearest toplevel window are mapped, false otherwise.

  Return the visual class for the widget, one of ""directcolor"",
  ""grayscale"", ""pseudocolor"", ""staticcolor"", ""staticgray"",
  or ""truecolor"".

  Return the X identifier for the visual for the widget.

  Return a list describing the visuals available for the widget's
  screen. Each item consists of a visual class (see
  "winfo_visual()") followed by an integer depth. If *includeids*
  is true, the X identifier for the visual is also included.

  Return the height of the virtual root window associated with the
  widget if there is one; otherwise return the height of the
  widget's screen.

  Return the width of the virtual root window associated with the
  widget if there is one; otherwise return the width of the
  widget's screen.

  Return the *x* offset of the virtual root window associated with
  the widget, relative to the root window of its screen. This is
  normally zero or negative, and is "0" if there is no virtual
  root window.

  Return the *y* offset of the virtual root window associated with
  the widget, relative to the root window of its screen. This is
  normally zero or negative, and is "0" if there is no virtual
  root window.

  Return the width of the widget in pixels. When a window is first
  created its width is 1 pixel; it is eventually changed by a
  geometry manager. See also "winfo_reqwidth()".

  Return the *x* coordinate, in the widget's parent, of the upper-
  left corner of the widget's border (or of the widget itself if
  it has no border).

  Return the *y* coordinate, in the widget's parent, of the upper-
  left corner of the widget's border (or of the widget itself if
  it has no border).

  Return the Tcl/Tk patch level as a named tuple with the same
  five fields as "sys.version_info": *major*, *minor*, *micro*,
  *releaselevel* and *serial*. *releaselevel* is "'alpha'",
  "'beta'" or "'final'". Converting it to a string gives the
  version in the usual Tcl/Tk notation, for example "'9.0.3'" for
  a final release or "'9.1b2'" for a pre-release.

  Added in version 3.11.

  Constrain the aspect ratio (the ratio of width to height) of the
  window. If all four arguments are given, the window manager
  keeps the ratio between "minNumer/minDenom" and
  "maxNumer/maxDenom"; passing empty strings removes any existing
  restriction. With no arguments, return a tuple of the four
  current values, or "None" if no aspect restriction is in effect.
  "wm_aspect()" is an alias of "aspect()".

  Query or set platform-specific attributes of the window. With no
  arguments, return the platform-specific flags and their values;
  pass *return_python_dict* as true to get them as a dictionary. A
  single option name such as "'alpha'" returns the value of that
  option, and options are set using keyword arguments
  ("alpha=0.5").

  The available attributes differ by platform. All platforms
  support:

  *alpha*
     The window's opacity, from "0.0" (fully transparent) to "1.0"
     (opaque). Where transparency is unsupported the value stays
     at "1.0".

  *appearance*
     Whether the window is rendered in dark mode on Windows and
     macOS: "'auto'", "'light'" or "'dark'" (this has no effect on
     X11).

  *fullscreen*
     Whether the window takes up the entire screen and has no
     borders.

  *topmost*
     Whether the window is displayed above all other windows.

  Windows additionally supports:

  *disabled*
     Whether the window is in a disabled state.

  *toolwindow*
     Whether the window uses the tool window style.

  *transparentcolor*
     The color that is made fully transparent, or an empty string
     for none.

  macOS additionally supports:

  *class*
     Whether the underlying Aqua window is an "nswindow" or an
     "nspanel"; this can only be set before the window is created.

  *modified*
     The modification state shown by the window's close button and
     proxy icon.

  *notify*
     Whether the application's dock icon bounces to request
     attention.

  *stylemask*
     The style mask of the underlying Aqua window, given as a list
     of bit names such as "titled" or "resizable".

  *tabbingid*
     The identifier of the tab group that the window belongs to.

  *tabbingmode*
     Whether the window may be opened as a tab: "'auto'",
     "'preferred'" or "'disallowed'".

  *titlepath*
     The path of the file represented by the window's proxy icon.

  *transparent*
     Whether the content area is transparent and the window shadow
     is turned off.

  X11 additionally supports:

  *type*
     The window type, or a list of types in order of preference,
     that the window manager should use to interpret the window,
     such as "'dialog'" or "'splash'".

  *zoomed*
     Whether the window is maximized.

  Nota:

    Tk 8.6 added the *type* attribute, and Tk 9.0 added the
    *appearance*, *class*, *stylemask*, *tabbingid* and
    *tabbingmode* attributes.

  On X11 changes are applied asynchronously, so a queried value
  may not yet reflect the most recent request. "wm_attributes()"
  is an alias of "attributes()".

  Distinto en la versión 3.13: A single attribute may now be
  queried by name without the leading "-", and attributes may be
  set using keyword arguments. The *return_python_dict* parameter
  was added.

  Obsoleto desde la versión 3.13: Setting an attribute by passing
  the option name (with a leading "-") and its value as two
  positional arguments, as in "w.attributes('-alpha', 0.5)", is
  deprecated; use keyword arguments instead.

  Store *name*, which should be the name of the host on which the
  application is running, in the window's "WM_CLIENT_MACHINE"
  property for use by the window or session manager. An empty
  string deletes the property. With no argument, return the last
  name set, or an empty string. "wm_client()" is an alias of
  "client()".

  Manipulate the "WM_COLORMAP_WINDOWS" property, which tells the
  window manager about windows that have private colormaps. If
  *wlist* is given, overwrite the property with those windows
  (their order is a priority order for installing colormaps). With
  no arguments, return the list of windows currently named in the
  property. "wm_colormapwindows()" is an alias of
  "colormapwindows()".

  Store *value* in the window's "WM_COMMAND" property for use by
  the window or session manager; it should be a list giving the
  words of the command used to invoke the application. An empty
  string deletes the property. With no argument, return the last
  value set, or an empty string. "wm_command()" is an alias of
  "command()".

  Display the window in normal (non-iconified) form by mapping it.
  If the window has never been mapped, this ensures it appears de-
  iconified when it is first mapped. On Windows the window is also
  raised and given the focus. "wm_deiconify()" is an alias of
  "deiconify()".

  Set or query the focus model for the window. *model* is either
  "'active'" (the window claims the input focus for itself or its
  descendants, even when the focus is in another application) or
  "'passive'" (the window relies on the window manager to give it
  the focus). With no argument, return the current model. The
  default is "'passive'", which is what the "focus()" command
  assumes. "wm_focusmodel()" is an alias of "focusmodel()".

  Unmap *window* from the screen so that it is no longer managed
  by the window manager. A "Toplevel" is then treated like a
  "Frame", although its "-menu" configuration is remembered and
  the menu reappears if the widget is managed again. "wm_forget()"
  is an alias of "forget()".

  Not to be confused with "Pack.forget()".

  Added in version 3.3.

  Return the platform-specific window identifier for the outermost
  decorative frame containing the window, if the window manager
  has reparented it into such a frame; otherwise return the
  identifier of the window itself. "wm_frame()" is an alias of
  "frame()".

  Set or query the geometry of the window. *newGeometry* has the
  form "=widthxheight+x+y", where any of "=", "widthxheight" and
  the "+x+y" position may be omitted. *width* and *height* are in
  pixels (or grid units for a gridded window); a position preceded
  by "+" is measured from the left or top edge of the screen and
  one preceded by "-" from the right or bottom edge. An offset can
  be negative, as in "'200x100+-9+-8'", when the window edge is
  positioned beyond the corresponding screen edge. An empty string
  cancels any user-specified geometry, letting the window revert
  to its natural size. With no argument, return the current
  geometry as a string of the form "'200x200+10+10'".
  "wm_geometry()" is an alias of "geometry()".

  Manage the window as a gridded window and define the
  relationship between grid units and pixels. *baseWidth* and
  *baseHeight* are the numbers of grid units for the window's
  internally requested size, and *widthInc* and *heightInc* are
  the pixel sizes of a horizontal and vertical grid unit. Empty
  strings turn off gridded management. With no arguments, return a
  tuple of the four current values, or "None" if the window is not
  gridded. "wm_grid()" is an alias of "grid()".

  Not to be confused with the grid geometry manager "Grid.grid()".

  Set or query the leader of a group of related windows.
  *pathName* gives the path name of the group leader; the window
  manager may, for example, unmap all windows in the group when
  the leader is iconified. An empty string removes the window from
  any group. With no argument, return the path name of the current
  group leader, or an empty string. "wm_group()" is an alias of
  "group()".

  Set or query the bitmap used by the window manager for the
  window's icon. *bitmap* names a bitmap in one of the standard
  forms accepted by Tk; an empty string cancels the current icon
  bitmap. With no argument, return the name of the current icon
  bitmap, or an empty string. On Windows the *default* argument
  names an icon (for example an ".ico" file) applied to all top-
  level windows that have no icon of their own. "wm_iconbitmap()"
  is an alias of "iconbitmap()".

  Iconify the window. If the window has not yet been mapped for
  the first time, arrange for it to appear in the iconified state
  when it is eventually mapped. "wm_iconify()" is an alias of
  "iconify()".

  Set or query the bitmap used as a mask for the icon (see
  "iconbitmap()"). Where the mask is zero no icon is displayed;
  where it is one, the corresponding bits of the icon bitmap are
  shown. An empty string cancels the current mask. With no
  argument, return the name of the current icon mask, or an empty
  string. "wm_iconmask()" is an alias of "iconmask()".

  Set or query the name displayed by the window manager inside the
  window's icon. With no argument, return the current icon name,
  or an empty string if none has been set (in which case the
  window manager normally displays the window's title).
  "wm_iconname()" is an alias of "iconname()".

  Set the titlebar icon for the window from one or more
  "PhotoImage" objects given in *images*. Several images of
  different sizes (for example 16x16 and 32x32) may be supplied so
  that the window manager can choose an appropriate one. The image
  data is taken as a snapshot at the time of the call; later
  changes to the images are not reflected. If *default* is true,
  the icon is also applied to all top-level windows created in the
  future. On macOS only the first image is used. "wm_iconphoto()"
  is an alias of "iconphoto()".

  Added in version 3.3.

  Set or query a hint to the window manager about where the
  window's icon should be positioned. Empty strings cancel an
  existing hint. With no arguments, return a tuple of the two
  current values, or "None" if no hint is in effect.
  "wm_iconposition()" is an alias of "iconposition()".

  Set or query the window used as the icon for the window. When
  the window is iconified, *pathName* is mapped to serve as its
  icon and unmapped again when it is de-iconified. An empty string
  cancels the association. With no argument, return the path name
  of the current icon window, or an empty string. Not all window
  managers support icon windows, and the concept is meaningless on
  non-X11 platforms. "wm_iconwindow()" is an alias of
  "iconwindow()".

  Make *widget* a stand-alone top-level window, decorated by the
  window manager with a title bar and so on. Only "Frame",
  "LabelFrame" and "Toplevel" widgets may be used (the
  "tkinter.ttk" versions are **not** accepted); passing any other
  widget type raises an error. "wm_manage()" is an alias of
  "manage()".

  Added in version 3.3.

  Set or query the maximum permissible dimensions of the window,
  in pixels (or grid units for a gridded window). The window
  manager restricts the window to be no larger than *width* and
  *height*. With no arguments, return a tuple of the current
  maximum width and height. The maximum size defaults to the size
  of the screen. "wm_maxsize()" is an alias of "maxsize()".

  Set or query the minimum permissible dimensions of the window,
  in pixels (or grid units for a gridded window). The window
  manager restricts the window to be no smaller than *width* and
  *height*. With no arguments, return a tuple of the current
  minimum width and height. The minimum size defaults to one pixel
  in each dimension. "wm_minsize()" is an alias of "minsize()".

  Set or query the override-redirect flag for the window. When
  this flag is set, the window is ignored by the window manager:
  it is not reparented into a decorative frame and the user cannot
  manipulate it through the usual window manager controls. With no
  argument, return a boolean indicating whether the flag is set,
  or "None" if it has not been set. The flag is reliably honored
  only when the window is first mapped or remapped from the
  withdrawn state. "wm_overrideredirect()" is an alias of
  "overrideredirect()".

  Set or query the source of the window's current position. *who*
  is either "'program'" or "'user'" and indicates whether the
  position was requested by the program or by the user; an empty
  string cancels the current source. With no argument, return the
  current source, or an empty string if none has been set. Tk
  automatically sets the source to "'user'" when "geometry()" is
  called, unless it has been set explicitly to "'program'".
  "wm_positionfrom()" is an alias of "positionfrom()".

  Register *func* as the handler for the window manager protocol
  *name*, an atom such as "'WM_DELETE_WINDOW'",
  "'WM_SAVE_YOURSELF'" or "'WM_TAKE_FOCUS'"; *func* is then called
  whenever the window manager sends a message of that protocol. Tk
  installs a default "WM_DELETE_WINDOW" handler that destroys the
  window, which this method can replace. If *func* is an empty
  string, the handler is removed. With only *name*, return the
  name of its registered handler command, or an empty string if
  none is set (the default "WM_DELETE_WINDOW" handler is not
  reported); with no arguments, return a tuple of the protocols
  that currently have handlers. "wm_protocol()" is an alias of
  "protocol()".

  Control whether the user may interactively resize the window.
  *width* and *height* are boolean values that determine whether
  the window's width and height may be changed. With no arguments,
  return a tuple of two "0"/"1" values indicating whether each
  dimension is currently resizable. By default a window is
  resizable in both dimensions. "wm_resizable()" is an alias of
  "resizable()".

  Set or query the source of the window's current size. *who* is
  either "'program'" or "'user'" and indicates whether the size
  was requested by the program or by the user; an empty string
  cancels the current source. With no argument, return the current
  source, or an empty string if none has been set. "wm_sizefrom()"
  is an alias of "sizefrom()".

  Set or query the state of the window. With no argument, return
  the current state: one of "'normal'", "'iconic'", "'withdrawn'",
  "'icon'" or, on Windows and macOS only, "'zoomed'". "'iconic'"
  refers to a window that has been iconified, while "'icon'"
  refers to a window serving as the icon for another window (see
  "iconwindow()"); the "'icon'" state cannot be set. "wm_state()"
  is an alias of "state()".

  Not to be confused with "ttk.Widget.state".

  Set or query the title for the window, which the window manager
  should display in the window's title bar. With no argument,
  return the current title. The title defaults to the window's
  name. "wm_title()" is an alias of "title()".

  Mark the window as a transient window (such as a pull-down menu
  or dialog) working on behalf of *master*, the path name of
  another top-level window. An empty string clears the transient
  status. With no argument, return the path name of the current
  master, or an empty string. A transient window mirrors state
  changes in its master and may be decorated differently by the
  window manager; it is an error to make a window a transient of
  itself. "wm_transient()" is an alias of "transient()".

  Withdraw the window from the screen, unmapping it and causing
  the window manager to forget about it. If the window has never
  been mapped, it is instead mapped in the withdrawn state. It is
  sometimes necessary to withdraw a window and then re-map it (for
  example with "deiconify()") to make some window managers notice
  changes to window attributes. "wm_withdraw()" is an alias of
  "withdraw()".

 "Pack", "Place" and "Grid" all define the short method names
 "forget()", "info()", "slaves()", "content()" and "propagate()".
 On a widget the bare names resolve to the *pack* manager's
 versions, since "Pack" and "Misc" precede "Place" and "Grid" in
 the method resolution order, whatever manager actually manages
 the widget; and "configure()"/"config()" configure the widget's
 options, not its geometry. Use the explicit "pack_*", "grid_*"
 and "place_*" methods (and "pack", "grid", "place" for geometry
 configuration) to act on a specific geometry manager.

  Pack the widget inside its container, positioning it relative to
  the siblings already packed there. The supported options are:

  *side*
     Which side of the container to pack the widget against:
     "'top'" (the default), "'bottom'", "'left'" or "'right'".

  *fill*
     Whether to stretch the widget to fill its parcel: "'none'"
     (the default), "'x'", "'y'" or "'both'".

  *expand*
     Whether the widget should expand to consume any extra space
     in its container (a boolean, default false).

  *anchor*
     Where to position the widget in its parcel when the parcel is
     larger than the widget: an anchor such as "'n'" or "'sw'"
     (default "'center'").

  *ipadx*, *ipady*
     Internal padding added on the left and right (*ipadx*) or top
     and bottom (*ipady*) of the widget, as a screen distance
     (default "0").

  *padx*, *pady*
     External padding left on the left and right (*padx*) or top
     and bottom (*pady*) of the widget, as a screen distance or a
     pair of two distances for the two sides (default "0").

  *after*
     Pack the widget after the given widget in the packing order,
     using the same container.

  *before*
     Pack the widget before the given widget in the packing order,
     using the same container.

  *in_*
     The container in which to pack the widget; it defaults to the
     parent widget.

  "pack()", "configure()" and "config()" are aliases of
  "pack_configure()".

  Unmap the widget and remove it from the packing order,
  forgetting its packing options. It can be packed again later
  with "pack_configure()". "forget()" is an alias of
  "pack_forget()", except on "PanedWindow", "ttk.Notebook" and
  "ttk.PanedWindow", which provide their own "forget()" method.

  Not to be confused with "Wm.forget()".

  Return a dictionary of the widget's current packing options.
  "info()" is an alias of "pack_info()".

  Same as "Misc.pack_propagate()", treating this widget as a
  container: enable or disable geometry propagation. "propagate()"
  is an alias of "pack_propagate()".

  Same as "Misc.pack_slaves()": return the list of widgets packed
  in this widget. "slaves()" is an alias of "pack_slaves()".

  Place the widget inside its container at an absolute or relative
  position. The supported options are:

  *x*, *y*
     The absolute horizontal and vertical position of the widget's
     anchor point, as a screen distance (default "0").

  *relx*, *rely*
     The horizontal and vertical position of the widget's anchor
     point as a fraction of the container's width and height,
     where "0.0" is the left or top edge and "1.0" is the right or
     bottom edge. If both the absolute and the relative option are
     given, their values are summed.

  *anchor*
     Which point of the widget is placed at the given position: an
     anchor such as "'n'" or "'se'" (default "'nw'").

  *width*, *height*
     The absolute width and height of the widget, as a screen
     distance. By default the widget's requested size is used.

  *relwidth*, *relheight*
     The width and height of the widget as a fraction of the
     container's width and height. If both the absolute and the
     relative option are given, their values are summed.

  *bordermode*
     How the container's border affects placement: "'inside'" (the
     default) measures the area inside the border, "'outside'"
     measures the area including the border, and "'ignore'" uses
     the official X area.

  *in_*
     The container relative to which the widget is placed; it must
     be the widget's parent or a descendant of the parent, and
     defaults to the parent.

  "place()", "configure()" and "config()" are aliases of
  "place_configure()".

  Unmap the widget and remove it from the placement, forgetting
  its place options.

  Return a dictionary of the widget's current place options.

  Same as "Misc.place_slaves()": return the list of widgets placed
  in this widget.

  Position the widget in a cell of its container's grid.

  Not to be confused with "Wm.grid()".

  The supported options are:

  *row*, *column*
     The row and column of the cell to place the widget in,
     counting from "0". *column* defaults to the column after the
     previous widget placed in the same "grid_configure()" call
     (or "0"), and *row* defaults to the next empty row.

  *rowspan*, *columnspan*
     The number of rows and columns the widget should span
     (default "1").

  *sticky*
     How to position or stretch the widget when its cell is larger
     than the widget: a string containing zero or more of the
     characters "'n'", "'s'", "'e'" and "'w'", naming the cell
     sides the widget sticks to. Specifying both "'n'" and "'s'"
     (or "'e'" and "'w'") stretches the widget to fill the height
     (or width) of the cell. The default is "''", which centers
     the widget at its requested size.

  *ipadx*, *ipady*
     Internal padding added on the left and right (*ipadx*) or top
     and bottom (*ipady*) of the widget, as a screen distance
     (default "0").

  *padx*, *pady*
     External padding left on the left and right (*padx*) or top
     and bottom (*pady*) of the widget, as a screen distance or a
     pair of two distances for the two sides (default "0").

  *in_*
     The container in whose grid to place the widget; it defaults
     to the parent widget.

  "grid()", "configure()" and "config()" are aliases of
  "grid_configure()".

  Unmap the widget and remove it from the grid, forgetting its
  grid options.

  Unmap the widget and remove it from the grid, but remember its
  grid options so that it is restored to the same cell if it is
  gridded again.

  Return a dictionary of the widget's current grid options.

  Same as "Misc.grid_bbox()". "bbox()" is an alias of
  "grid_bbox()", except on "Canvas", "Listbox", "Spinbox", "Text",
  "ttk.Entry" and "ttk.Treeview", which provide their own "bbox()"
  method.

  Same as "Misc.grid_columnconfigure()": query or set the options
  (such as *weight*, *minsize*, *pad* and *uniform*) of a grid
  column. "columnconfigure()" is an alias of
  "grid_columnconfigure()".

  Same as "Misc.grid_rowconfigure()": query or set the options of
  a grid row. "rowconfigure()" is an alias of
  "grid_rowconfigure()".

  Same as "Misc.grid_location()": return the "(column, row)" of
  the cell that covers the pixel at *x*, *y*. "location()" is an
  alias of "grid_location()".

  Same as "Misc.grid_size()": return a "(columns, rows)" tuple
  giving the size of the grid. "size()" is an alias of
  "grid_size()", except on the "Listbox" widget, which provides
  its own "size()" method.

  Same as "Misc.grid_propagate()".

  Same as "Misc.grid_slaves()": return the widgets managed in the
  grid, optionally restricted to a *row* and/or *column*.

  Query or change the horizontal position of the view. With no
  arguments, return a tuple "(first, last)" of two fractions
  between 0 and 1 giving the portion of the document that is
  currently visible. Otherwise the arguments are passed to the Tk
  "xview" widget command and are usually generated by a scrollbar;
  "xview_moveto()" and "xview_scroll()" provide a more convenient
  interface.

  Adjust the view so that *fraction* of the total width of the
  document is off-screen to the left. *fraction* is a number
  between 0 and 1.

  Shift the view left or right by *number* units. *what* is either
  "'units'" or "'pages'"; a negative *number* scrolls left and a
  positive one scrolls right.

  Query or change the vertical position of the view. With no
  arguments, return a tuple "(first, last)" of two fractions
  between 0 and 1 giving the portion of the document that is
  currently visible. Otherwise the arguments are passed to the Tk
  "yview" widget command, usually generated by a scrollbar;
  "yview_moveto()" and "yview_scroll()" provide a more convenient
  interface.

  Adjust the view so that *fraction* of the total height of the
  document is off-screen above the top. *fraction* is a number
  between 0 and 1.

  Shift the view up or down by *number* units. *what* is either
  "'units'" or "'pages'"; a negative *number* scrolls up and a
  positive one scrolls down.

  Destroy this widget and all of its children, removing the
  corresponding Tk widgets and deleting the associated Tcl
  commands.

  Hay que tener en cuenta que en algunas plataformas, esto solo
  funcionará correctamente si el *id* se refiere a un marco Tk o a
  un nivel superior que tenga habilitada la opción -container.

 On Windows, creating a Tcl interpreter (by instantiating "Tk" or
 calling "Tcl()") sets the "HOME" environment variable for the
 process, if it is not already set, to "%HOMEDRIVE%%HOMEPATH%" (or
 "USERPROFILE", or "c:\").  This is done by Tcl and can affect
 other code that reads "HOME".

  El objeto de la aplicación Tk creado al instanciar "Tk". Esto
  proporciona acceso al intérprete de Tcl. Todos los widget que se
  adjuntan a la misma instancia de "Tk" tienen el mismo valor para
  el atributo "tk".

  The widget object that contains this widget. For "Tk", the
  "master" is "None" because it is the main window. The terms
  *master* and *parent* are similar and sometimes used
  interchangeably as argument names; however, calling
  "winfo_parent()" returns a string of the widget name whereas
  "master" returns the object. *parent*/*child* reflects the tree-
  like relationship while *master* (or *container*)/*content*
  reflects the container structure.

  Los descendientes directos de este widget como "dict" con los
  nombres del widget secundario como clave y los objetos de
  instancia secundarios como valor.

  Destroy this and all descendant widgets and, for the main
  window, end the connection to the underlying Tcl interpreter.

  Finish loading and initializing the Tk subsystem. This is needed
  only when the interpreter was created without Tk (for example
  through "Tcl()"); it is called automatically when *useTk* is
  true.

  Read and source the user's profile files ".*className*.tcl" and
  ".*baseName*.tcl" into the Tcl interpreter, and execute the
  corresponding ".*className*.py" and ".*baseName*.py" files. This
  is called during initialization; see the description of the
  constructor above.

  Report a callback exception. This is called when an exception
  propagates out of a Tkinter callback; *exc*, *val* and *tb* are
  the exception type, value and traceback as returned by
  "sys.exc_info()". The default implementation prints a traceback
  to "sys.stderr". It can be overridden to customize error
  handling, for example to display the traceback in a dialog.

  Invoke the command associated with the button, if there is one,
  and return its result, or an empty string if no command is
  associated with the button. This is ignored if the button's
  state is "disabled".

  Flash the button by redisplaying it several times, alternating
  between the active and normal colors. At the end of the flash
  the button is left in the same normal or active state as when
  the method was called. This is ignored if the button's state is
  "disabled".

  Create a new item of the corresponding type and return its
  integer id. Each method is called as "create_TYPE(coord...,
  **options)": the leading positional arguments give the
  coordinates that define the item (as separate numbers, as a
  single sequence of numbers, or as coordinate pairs), and the
  keyword arguments set item-specific options. Coordinates and
  screen distances may be given as numbers (interpreted as pixels)
  or as strings with a unit suffix ("'m'", "'c'", "'i'" or "'p'"
  for millimetres, centimetres, inches or printer's points), but
  are always stored and returned in pixels.

  The item types are: "arc" (an arc-shaped region that is a
  section of an oval, defined by two diagonally opposite corners
  "x1, y1, x2, y2" of the enclosing rectangle); "bitmap" (a two-
  color bitmap positioned at a point "x, y"); "image" (a Tk image
  positioned at a point "x, y"); "line" (a line or curve through
  the points "x1, y1, ..., xn, yn"); "oval" (a circle or ellipse
  inscribed in the rectangle "x1, y1, x2, y2"); "polygon" (a
  closed polygon through the points "x1, y1, ..., xn, yn");
  "rectangle" (a rectangle with corners "x1, y1, x2, y2"); "text"
  (a string of text positioned at a point "x, y"); and "window" (a
  child widget embedded in the canvas at a point "x, y", specified
  with the *window* option).

  Most item types accept a common set of *standard item options*,
  plus a few options specific to each type. Option names are
  passed as keyword arguments, without the leading hyphen.

  The standard item options are:

  *fill*
     The color used to fill the item's interior, or to draw a
     *line* item or the characters of a *text* item. An empty
     string (the default for all types except *line* and *text*)
     leaves the item unfilled.

  *outline*
     The color used to draw the item's outline. An empty string
     draws no outline.

  *width*
     The width of the outline, defaulting to "1.0". Has no effect
     if *outline* is empty.

  *dash*
     A dash pattern for the outline, given either as a sequence of
     segment lengths in pixels or as a string of the characters
     "'.'", "','", "'-'", "'_'" and space. An empty pattern (the
     default) draws a solid outline.

  *dashoffset*
     The starting offset in pixels into the *dash* pattern.
     Ignored if there is no *dash* pattern.

  *stipple*
     A bitmap used as a stipple pattern when filling the item.
     Only well supported on X11.

  *outlinestipple*
     A bitmap used as a stipple pattern when drawing the outline.
     Has no effect if *outline* is empty.

  *offset*, *outlineoffset*
     The offset of the fill and outline stipple patterns, given as
     "'x,y'" or as a side such as "'n'", "'se'" or "'center'".
     Stipple offsets are only supported on X11.

  *state*
     Overrides the canvas state for this item; one of "'normal'",
     "'disabled'" or "'hidden'".

  *tags*
     A single tag or a sequence of tags to associate with the
     item, replacing any existing tags.

  Many of these options have *active...* and *disabled...*
  variants (such as *activefill*, *disabledfill*, *activewidth*,
  *disableddash*, *activeoutline*, *disabledstipple*) that
  override the base option when the item is the active item (under
  the mouse pointer) or is in the disabled state.

  The following item types support additional options.

  For "arc" items:

  *start*
     The start of the arc's angular range, in degrees measured
     counter-clockwise from the 3-o'clock position.

  *extent*
     The size of the angular range, in degrees counter-clockwise
     from *start*.

  *style*
     How the arc is drawn: "'pieslice'" (the default), "'chord'"
     or "'arc'".

  For "line" items:

  *arrow*
     Where to draw arrowheads: "'none'" (the default), "'first'",
     "'last'" or "'both'".

  *arrowshape*
     A sequence of three distances describing the shape of the
     arrowheads.

  *capstyle*
     How line ends are drawn: "'butt'" (the default),
     "'projecting'" or "'round'".

  *joinstyle*
     How line vertices are drawn: "'round'" (the default),
     "'bevel'" or "'miter'".

  *smooth*
     The smoothing method: a false value (the default) for no
     smoothing, or "'true'"/"'bezier'" or "'raw'" to draw the line
     as a curve.

  *splinesteps*
     The number of line segments approximating each spline when
     *smooth* is enabled.

  For "polygon" items:

  *joinstyle*, *smooth*, *splinesteps*
     As for "line" items, applied to the polygon's outline.

  For "text" items:

  *text*
     The string to display; newline characters start new lines.

  *font*
     The font used for the text.

  *justify*
     How lines are justified: "'left'" (the default), "'right'" or
     "'center'".

  *anchor*
     How the text is positioned relative to its point, defaulting
     to "'center'".

  *width*
     The maximum line length; if non-zero, lines are wrapped at
     spaces.

  *angle*
     How many degrees to rotate the text counter-clockwise about
     its positioning point, from "0.0" to "360.0" (default "0.0").

  *underline*
     The index of a character to underline, or "-1" for none.

  For "bitmap" items:

  *bitmap*
     The bitmap to display.

  *anchor*
     How the bitmap is positioned relative to its point.

  *background*, *foreground*
     The colors used for the bitmap's "0" and "1" pixels; an empty
     *background* makes the "0" pixels transparent. Both have
     *active...* and *disabled...* variants, and *bitmap* has
     *activebitmap* and *disabledbitmap* variants.

  For "image" items:

  *image*
     The Tk image to display, previously created with the image
     protocols.

  *anchor*
     How the image is positioned relative to its point.

  Both options have *active...* and *disabled...* variants
  (*activeimage*, *disabledimage*) used in the active and disabled
  states.

  For "window" items:

  *window*
     The widget to embed; it must be a child of the canvas or of
     one of its ancestors, and may not be a top-level window.

  *anchor*
     How the window is positioned relative to its point.

  *width*, *height*
     The size to assign to the window; if zero (the default), the
     window is given its requested size.

  "oval" and "rectangle" items have no type-specific options; they
  use only the standard item options.

  Nota:

    Tk 8.6 added the *angle* option and Tk 9.0 added the
    *underline* option for "text" items.

  Query or modify the coordinates of an item. With only *tagOrId*,
  return a list of the floating-point coordinates of the item
  given by *tagOrId* (the first matching item if it matches
  several). Given new coordinates, replace the coordinates of that
  item with them; like the "create_*" methods, the coordinates may
  be given as separate numbers, as a single sequence, or as
  coordinate pairs. The returned coordinates are always in pixels,
  regardless of the units used to specify them; for rectangles,
  ovals and arcs they are ordered left, top, right, bottom.

  Distinto en la versión 3.12: The arguments are now flattened:
  the coordinates may be given as separate arguments, as a single
  sequence, or grouped in pairs, like the "create_*" methods.

  Move each of the items given by *tagOrId* in the canvas
  coordinate space by adding *xAmount* to every x-coordinate and
  *yAmount* to every y-coordinate of the item.

  Move the items given by *tagOrId* so that the first coordinate
  pair (the upper-left corner of the bounding box) of the lowest
  matching item is at position (*x*, *y*). *x* or *y* may be an
  empty string, in which case the corresponding coordinate is
  unchanged. All matching items keep their positions relative to
  each other.

  Added in version 3.8.

  Rescale the coordinates of all items given by *tagOrId* in
  canvas coordinate space. Each x-coordinate is adjusted so that
  its distance from *xOrigin* changes by a factor of *xScale*, and
  each y-coordinate so that its distance from *yOrigin* changes by
  a factor of *yScale* (a factor of "1.0" leaves the coordinate
  unchanged).

  Delete each of the items given by the *tagOrIds* arguments.

  Delete from each of the items given by *tagOrId* the characters
  (for text items) or coordinates (for line and polygon items) in
  the range from *first* to *last* inclusive; *last* defaults to
  *first*. Items that do not support indexing ignore this
  operation.

  Insert *string* into each of the items given by *tagOrId* just
  before the character or coordinate whose index is *beforeThis*.
  For line and polygon items *string* must be a valid sequence of
  coordinates.

  Return the current value of the configuration option *option*
  for the item given by *tagOrId* (the lowest matching item if it
  matches several). This is like "cget()" but applies to an
  individual item.

  Query or modify the configuration options of the items given by
  *tagOrId*. This mirrors "configure()", except that it applies to
  individual items rather than to the canvas as a whole. With no
  options, it returns a dictionary describing the current options
  of the first matching item; otherwise it sets the given options
  on every matching item. The legal options are those accepted by
  the corresponding "create_*" method. "itemconfig()" is an alias
  of "itemconfigure()".

  Return the type of the item given by *tagOrId* (the first
  matching item if it matches several), such as "'rectangle'" or
  "'text'", or "None" if *tagOrId* does not match any item.

  Return a tuple of the tags associated with the item given by
  *tagOrId* (the first matching item in display-list order if it
  matches several). Return an empty tuple if no item matches or
  the item has no tags.

  Remove the tag *tagToDelete* (which defaults to *tagOrId*) from
  each of the items given by *tagOrId*. Items that do not have
  that tag are unaffected.

  Add the tag *newtag* to each item selected by the search
  specification *searchSpec* (and any further *args*).
  *searchSpec* is one of "'above'", "'all'", "'below'",
  "'closest'", "'enclosed'", "'overlapping'" or "'withtag'"; the
  "addtag_*" methods below are convenient wrappers that supply
  each of these forms.

  Add the tag *newtag* to the item just above (after) *tagOrId* in
  the display list.

  Add the tag *newtag* to all items in the canvas.

  Add the tag *newtag* to the item just below (before) *tagOrId*
  in the display list.

  Add the tag *newtag* to the item closest to the point (*x*,
  *y*). If *halo* is given, any item within that distance of the
  point is treated as overlapping it. If *start* is given (a tag
  or id), select the topmost closest item that lies below *start*
  in the display list, which can be used to step through all the
  closest items.

  Add the tag *newtag* to every item completely enclosed within
  the rectangle (*x1*, *y1*, *x2*, *y2*), where *x1* <= *x2* and
  *y1* <= *y2*.

  Add the tag *newtag* to every item that overlaps or is enclosed
  within the rectangle (*x1*, *y1*, *x2*, *y2*), where *x1* <=
  *x2* and *y1* <= *y2*.

  Add the tag *newtag* to every item given by *tagOrId*.

  Return a tuple of the ids of all items selected by the search
  specification *searchSpec* (and any further *args*), in stacking
  order with the lowest item first. The search specification has
  any of the forms accepted by "addtag()". The "find_*" methods
  below are more convenient wrappers around it.

  Return a tuple containing the id of the item just above
  *tagOrId* in the display list.

  Return a tuple of the ids of all items in the canvas, in
  stacking order.

  Return a tuple containing the id of the item just below
  *tagOrId* in the display list.

  Return a tuple containing the id of the item closest to the
  point (*x*, *y*). *halo* and *start* are interpreted as for
  "addtag_closest()".

  Return a tuple of the ids of all items completely enclosed
  within the rectangle (*x1*, *y1*, *x2*, *y2*).

  Return a tuple of the ids of all items that overlap or are
  enclosed within the rectangle (*x1*, *y1*, *x2*, *y2*).

  Return a tuple of the ids of all items given by *tagOrId*.

  Move all items given by *tagOrId* to a new position in the
  display list just above the item given by *aboveThis*, or to the
  top of the display list if *aboveThis* is omitted. When several
  items are moved their relative order is preserved. This has no
  effect on embedded window items, whose stacking order is
  controlled by "Misc.tkraise()" and "Misc.lower()" instead.
  "lift()" and "tkraise()" are aliases of "tag_raise()".

  Move all items given by *tagOrId* to a new position in the
  display list just below the item given by *belowThis*, or to the
  bottom of the display list if *belowThis* is omitted. When
  several items are moved their relative order is preserved. This
  has no effect on embedded window items. "lower()" is an alias of
  "tag_lower()".

  Nota:

    On a "Canvas", "tkraise()"/"lift()" and "lower()" restack
    canvas items, shadowing the inherited
    "Misc.tkraise()"/"Misc.lift()" and "Misc.lower()" methods that
    restack the widget itself, which are therefore not available.

  Bind the callback *func* to the event *sequence* for all items
  given by *tagOrId*, so that *func* is invoked whenever that
  event occurs for one of the items. This is like "Widget.bind"
  but operates on canvas items rather than on whole widgets; only
  mouse, keyboard and virtual events may be bound. Mouse events
  are directed to the current item and keyboard events to the
  focus item (see "focus()"). If *add* is true the new binding is
  added to any existing bindings for the same sequence, rather
  than replacing them. Return the identifier of the bound
  function, which can be passed to "tag_unbind()".

  Remove for all items given by *tagOrId* the binding for the
  event *sequence*. If *funcid* is given, only that callback (as
  returned by "tag_bind()") is unbound and deregistered.

  Distinto en la versión 3.13: If *funcid* is given, only that
  callback is unbound.

  Return a 4-tuple "(x1, y1, x2, y2)" giving an approximate
  bounding box, in pixels, that encloses all the items given by
  *tagOrId* and any further *tagOrIds*. The result may
  overestimate the true bounding box by a few pixels. Return
  "None" if no item matches or the matching items have nothing to
  display.

  This shadows the inherited "Misc.bbox()"; use "grid_bbox()" for
  the grid bounding box.

  Given a window x-coordinate *screenx*, return the canvas
  x-coordinate displayed at that location. If *gridspacing* is
  given, the result is rounded to the nearest multiple of
  *gridspacing* units.

  Given a window y-coordinate *screeny*, return the canvas
  y-coordinate displayed at that location. If *gridspacing* is
  given, the result is rounded to the nearest multiple of
  *gridspacing* units.

  With *tagOrId*, set the keyboard focus for the canvas to the
  first item given by *tagOrId* that supports the insertion
  cursor; the focus is left unchanged if no such item exists. If
  *tagOrId* is an empty string, reset the focus so that no item
  has it. With no argument, return the id of the item that
  currently has the focus, or an empty string if none does. An
  item only displays the insertion cursor when both it is the
  focus item and its canvas has the input focus.

  This shadows the inherited "Misc.focus()"; use "focus_set()" to
  focus the widget itself.

  Set the insertion cursor of the items given by *tagOrId* to just
  before the character given by *index*. Items that do not support
  an insertion cursor are unaffected. The cursor is only displayed
  when the item has the focus, but its position may be set at any
  time.

  Return as an integer the numerical index within *tagOrId*
  corresponding to *index*, which is a textual description of a
  position (for text items an index into the characters, for line
  and polygon items an index into the coordinates). If *tagOrId*
  matches several items, the first one that supports indexing is
  used.

  Adjust the end of the selection in *tagOrId* nearest to *index*
  so that it is at *index*, and make the other end the anchor
  point for future "select_to()" calls. If the selection is not
  currently in *tagOrId*, this behaves like "select_to()".

  Clear the selection if it is in this canvas; otherwise do
  nothing.

  Set the selection anchor point to just before the character
  given by *index* in the item given by *tagOrId*. This does not
  change the selection itself; it sets the fixed end for future
  "select_to()" calls.

  Return the id of the item that holds the selection, or "None" if
  the selection is not in this canvas. Unlike "find()" and the
  "find_*" methods, this returns the id as a string rather than an
  integer.

  Set the selection to the characters of *tagOrId* between the
  selection anchor point and *index*, inclusive of *index*. The
  anchor point is the one set by the most recent "select_adjust()"
  or "select_from()" call.

  Record *x*, *y* and the current view, for use with later
  "scan_dragto()" calls. This is typically bound to a mouse button
  press in the widget.

  Scroll the canvas by *gain* times the difference between *x*,
  *y* and the coordinates passed to the last "scan_mark()" call.
  This is typically bound to mouse motion events in the widget,
  producing the effect of dragging the canvas at high speed
  through its window.

  Generate a PostScript (Encapsulated PostScript, version 3.0)
  representation of part or all of the canvas. If the *file* or
  *channel* option is given, the PostScript is written there and
  an empty string is returned; otherwise it is returned as a
  string. By default only the area currently visible in the window
  is generated, so it is usually necessary either to call
  "update()" first or to use the *width* and *height* options.
  Supported options include *colormap*, *colormode*, *file*,
  *fontmap*, *height*, *pageanchor*, *pageheight*, *pagewidth*,
  *pagex*, *pagey*, *rotate*, *width*, *x* and *y*.

  Do just what would happen if the user pressed the checkbutton
  with the mouse: toggle the selection state of the button and
  invoke the associated command, if there is one. Return the
  result of the command, or an empty string if no command is
  associated with the checkbutton. This is ignored if the
  checkbutton's state is "disabled".

  Select the checkbutton and set the associated variable to its
  "onvalue".

  Deselect the checkbutton and set the associated variable to its
  "offvalue".

  Toggle the selection state of the button, redisplaying it and
  modifying its associated variable to reflect the new state.

  Flash the checkbutton by redisplaying it several times,
  alternating between the active and normal colors. At the end of
  the flash the checkbutton is left in the same normal or active
  state as when the method was called. This is ignored if the
  checkbutton's state is "disabled".

  Delete the characters from index *first* up to but not including
  index *last*. If *last* is omitted, only the single character at
  *first* is deleted.

  Return the entry's current string.

  Insert *string* just before the character given by *index*.

  Arrange for the insertion cursor to be displayed just before the
  character given by *index*.

  Return the numerical index corresponding to *index*.

  Locate the end of the selection nearest to the character given
  by *index*, and adjust that end to be at *index* (including but
  not going beyond it); the other end becomes the anchor point for
  future "selection_to()" calls. If there is no selection in the
  entry, a new one is created between *index* and the most recent
  anchor point, inclusive. "select_adjust()" is an alias of
  "selection_adjust()".

  Clear the selection if it is currently in this widget. If the
  selection is not in this widget the method has no effect.
  "select_clear()" is an alias of "selection_clear()".

  Nota:

    This shadows the inherited "Misc.selection_clear()", which
    clears the X selection; that method is not available on an
    "Entry".

  Set the selection anchor point to just before the character
  given by *index*, without changing the selection.
  "select_from()" is an alias of "selection_from()".

  Return "True" if there are characters selected in the entry,
  "False" otherwise. "select_present()" is an alias of
  "selection_present()".

  Set the selection to include the characters starting with the
  one indexed by *start* and ending with the one just before
  *end*. If *end* refers to the same character as *start* or an
  earlier one, the selection is cleared. "select_range()" is an
  alias of "selection_range()".

  Set the selection between the anchor point and *index*: if
  *index* is before the anchor point, the selection runs from
  *index* up to but not including the anchor; if *index* is after
  it, from the anchor up to but not including *index*; if they
  coincide, nothing happens. The anchor point is the one set by
  the most recent "selection_from()" or "selection_adjust()" call.
  If there is no selection in the entry, a new one is created
  using the most recent anchor point. "select_to()" is an alias of
  "selection_to()".

  Record *x* and the current view in the entry window, for use
  with later "scan_dragto()" calls. Typically associated with a
  mouse button press in the widget.

  Compute the difference between *x* and the *x* given to the last
  "scan_mark()" call, and adjust the view left or right by 10
  times that difference. Typically associated with mouse motion
  events, to produce the effect of dragging the entry at high
  speed through the window.

  Insert the given *elements* as new items just before the item
  given by *index*. If *index* is "'end'", the new items are
  appended to the end of the list.

  Delete the items in the range from *first* to *last* inclusive.
  If *last* is omitted, it defaults to *first*, so that a single
  item is deleted.

  If *last* is omitted, return the contents of the item given by
  *first*, or an empty string if *first* refers to a non-existent
  item. If *last* is given, return a tuple of all the items in the
  range from *first* to *last* inclusive.

  Return the total number of items in the listbox.

  This shadows the inherited "Misc.size()"; use "grid_size()" for
  the grid size.

  Return the integer index value corresponding to *index*, or
  "None" if *index* is out of range. If *index* is "'end'", the
  result is a count of the number of items in the listbox (not the
  index of the last item).

  Return a tuple "(x, y, width, height)" describing the bounding
  box, in pixels relative to the widget, of the text of the item
  given by *index*. Return "None" if no part of that item is
  visible on the screen, or if *index* refers to a non-existent
  item; if the item is only partly visible, the result still gives
  the full area of the item, including the parts that are not
  visible.

  This shadows the inherited "Misc.bbox()"; use "grid_bbox()" for
  the grid bounding box.

  Given a y-coordinate within the listbox window, return the index
  of the visible item nearest to that y-coordinate.

  Adjust the view so that the item given by *index* is visible. If
  the item is already visible the method has no effect; if it is
  near an edge of the window the listbox scrolls just enough to
  bring it into view at that edge, otherwise the listbox scrolls
  to center the item.

  Set the active item to the one given by *index*. If *index* is
  outside the range of items, the closest item is activated
  instead. The active item is drawn as specified by the
  *activestyle* option when the widget has the input focus, and
  its index may be retrieved with the "'active'" index.

  Return a tuple containing the numerical indices of all of the
  items that are currently selected, or an empty tuple if no items
  are selected.

  Set the selection anchor to the item given by *index*. If
  *index* refers to a non-existent item, the closest item is used.
  The selection anchor is the end of the selection that is fixed
  while dragging out a selection with the mouse, and may
  afterwards be referred to with the "'anchor'" index.
  "select_anchor()" is an alias of "selection_anchor()".

  Deselect any of the items in the range from *first* to *last*
  inclusive that are selected. The selection state of items
  outside this range is not changed. "select_clear()" is an alias
  of "selection_clear()".

  Nota:

    This shadows the inherited "Misc.selection_clear()", which
    clears the X selection; that method is not available on a
    "Listbox".

  Return "True" if the item given by *index* is currently
  selected, "False" otherwise. "select_includes()" is an alias of
  "selection_includes()".

  Select all of the items in the range from *first* to *last*
  inclusive, without affecting the selection state of items
  outside that range. "select_set()" is an alias of
  "selection_set()".

  Return the current value of the configuration option *option*
  for the item given by *index*.

  Query or modify the configuration options of the item given by
  *index*. This mirrors "configure()", except that it applies to
  an individual item rather than to the listbox as a whole. With
  no options, it returns a dictionary describing the current
  options of the item; otherwise it sets the given options. The
  supported item options are *background*, *foreground*,
  *selectbackground* and *selectforeground*. "itemconfig()" is an
  alias of "itemconfigure()".

  Record *x*, *y* and the current view, for use with later
  "scan_dragto()" calls. This is typically bound to a mouse button
  press in the widget.

  Scroll the listbox by 10 times the difference between *x*, *y*
  and the coordinates passed to the last "scan_mark()" call. This
  is typically bound to mouse motion events in the widget,
  producing the effect of dragging the list at high speed through
  the window.

  Add a new entry to the bottom of the menu. *itemType* is one of
  "'command'", "'cascade'", "'checkbutton'", "'radiobutton'" or
  "'separator'" and determines the type of the new entry; the
  remaining options configure it. The "add_command()",
  "add_cascade()", "add_checkbutton()", "add_radiobutton()" and
  "add_separator()" convenience methods call this method with the
  corresponding *itemType*.

  The entry is configured by the following options, although not
  every option applies to every entry type (a separator accepts
  none of them):

  *label*
     The text to display in the entry.

  *command*
     The function to call when the entry is invoked (command,
     checkbutton and radiobutton entries).

  *accelerator*
     A string displayed at the right of the entry to advertise an
     accelerator keystroke; it does not itself create the binding.

  *underline*
     The index of a character in the label to underline for
     keyboard traversal.

  *state*
     One of "'normal'", "'active'" or "'disabled'".

  *image*
     An image to display instead of, or together with, the text
     label.

  *compound*
     Where to show the image relative to the text: "'none'" (the
     default), "'text'", "'image'", "'top'", "'bottom'", "'left'"
     or "'right'".

  *bitmap*
     A bitmap to display instead of the text label.

  *font*
     The font to use for the text.

  *background*, *foreground*
     The entry's background and foreground colors in its normal
     state (ignored on macOS).

  *activebackground*, *activeforeground*
     The background and foreground colors used when the entry is
     active (ignored on macOS).

  *columnbreak*
     If true, the entry starts a new column instead of being
     placed below the previous entry.

  *hidemargin*
     If true, the standard margin around the entry is omitted,
     which is useful when a menu is used as a palette.

  *menu*
     The submenu posted by a cascade entry; it must be a child of
     this menu.

  *variable*
     The variable associated with a checkbutton or radiobutton
     entry.

  *onvalue*, *offvalue*
     The values stored in *variable* when a checkbutton entry is
     selected or cleared.

  *value*
     The value stored in *variable* when a radiobutton entry is
     selected.

  *indicatoron*
     Whether to display the indicator of a checkbutton or
     radiobutton entry.

  *selectcolor*
     The color of the indicator of a checkbutton or radiobutton
     entry when it is selected.

  *selectimage*
     The image displayed when a checkbutton or radiobutton entry
     is selected and *image* is also given.

  Add a new cascade entry to the bottom of the menu. A cascade
  entry has an associated submenu, given by its *menu* option,
  which must be a child of this menu; posting the entry posts the
  submenu next to it.

  Add a new checkbutton entry to the bottom of the menu. When
  invoked, a checkbutton entry toggles between its *onvalue* and
  *offvalue*, storing the result in its associated *variable*, and
  displays an indicator showing whether it is selected.

  Add a new command entry to the bottom of the menu. A command
  entry behaves much like a button: when it is invoked, the
  callback given by its *command* option is called.

  Add a new radiobutton entry to the bottom of the menu.
  Radiobutton entries sharing the same *variable* form a group of
  which only one may be selected at a time; selecting an entry
  stores its *value* in the variable.

  Add a separator to the bottom of the menu. A separator is
  displayed as a horizontal dividing line and cannot be activated
  or invoked.

  Same as "add()", except that the new entry is inserted just
  before the entry given by *index* instead of being appended to
  the end of the menu. *itemType* is one of "'command'",
  "'cascade'", "'checkbutton'", "'radiobutton'" or "'separator'".
  The "insert_command()", "insert_cascade()",
  "insert_checkbutton()", "insert_radiobutton()" and
  "insert_separator()" convenience methods call this method with
  the corresponding *itemType*.

  Insert a new cascade entry before the entry given by *index*
  (see "add_cascade()").

  Insert a new checkbutton entry before the entry given by *index*
  (see "add_checkbutton()").

  Insert a new command entry before the entry given by *index*
  (see "add_command()").

  Insert a new radiobutton entry before the entry given by *index*
  (see "add_radiobutton()").

  Insert a separator before the entry given by *index* (see
  "add_separator()").

  Delete all of the menu entries between *index1* and *index2*
  inclusive. If *index2* is omitted, it defaults to *index1*, so
  that a single entry is deleted. Attempts to delete a tear-off
  entry are ignored; remove it by changing the *tearoff* option
  instead.

  Return the current value of the configuration option *option*
  for the entry given by *index*.

  Query or modify the configuration options of the entry given by
  *index*. This mirrors "configure()", except that it applies to
  an individual entry rather than to the menu as a whole. With no
  options, it returns a dictionary describing the current options
  of the entry; otherwise it sets the given options. The supported
  options are those accepted by "add()" for the entry's type.
  "entryconfig()" is an alias of "entryconfigure()".

  Return the numerical index corresponding to *index*, or "None"
  if *index* selects no entry.

  Return the type of the entry given by *index*: one of
  "'command'", "'cascade'", "'checkbutton'", "'radiobutton'",
  "'separator'" or "'tearoff'" (for the tear-off entry).

  Make the entry given by *index* the active entry, redisplaying
  it with its active colors, and deactivate any previously active
  entry. If *index* selects no entry, or the selected entry is
  disabled, the menu ends up with no active entry.

  Invoke the action of the entry given by *index*, as if it had
  been clicked. Nothing happens if the entry is disabled. If the
  entry has a *command* associated with it, the result of that
  command is returned; otherwise the result is an empty string.

  Display the menu on the screen at the root-window coordinates
  *x* and *y*, adjusting them if necessary so that the whole menu
  is visible. If the *postcommand* option has been specified, it
  is evaluated before the menu is posted.

  Post the menu as a popup at the root-window coordinates *x* and
  *y*. If *entry* is given, the menu is positioned so that this
  entry is displayed under the pointer.

  Unmap the menu so that it is no longer displayed, also unposting
  any posted lower-level cascaded submenu. This has no effect on
  Windows and macOS, which manage the unposting of menus
  themselves.

  Return the x-coordinate, within the menu window, of the leftmost
  pixel of the entry given by *index*.

  Added in version 3.3.

  Return the y-coordinate, within the menu window, of the topmost
  pixel of the entry given by *index*.

  Destroy the widget, also cleaning up the associated pop-up menu.

  Add *child* to the panedwindow as a new pane, placed after any
  existing panes. The keyword arguments specify per-pane
  management options for *child*; they may be any of the options
  accepted by "paneconfigure()".

  Remove the pane containing *child* from the panedwindow. All
  geometry management options for *child* are forgotten.
  "forget()" is an alias of "remove()". This shadows the inherited
  geometry-manager "forget()"; use "pack_forget()",
  "grid_forget()" or "place_forget()" to remove the widget itself
  from its manager.

  Return a tuple of the widgets managed by the panedwindow, one
  per pane, in order.

  Return the current value of the management option *option* for
  the pane containing *child*. *option* may be any value allowed
  by "paneconfigure()".

  Query or modify the management options of the pane containing
  the widget *tagOrId*. With no options, it returns a dictionary
  describing all of the available options for the pane; given a
  single option name as a string, it returns a description of that
  one option; otherwise it sets the given options. The supported
  options include *after* and *before* (insert the pane after or
  before another managed window), *height* and *width* (the outer
  dimensions of the window, including any border), *minsize* (the
  minimum size in the paned dimension), *padx* and *pady* (extra
  space to leave on each side of the window), *sticky* (position
  or stretch the window within an oversized pane, using a string
  of the characters "n", "s", "e" and "w"), *hide* (hide the pane
  while keeping it in the list of panes) and *stretch* (how extra
  space is allocated to the pane: one of "'always'", "'first'",
  "'last'", "'middle'" or "'never'"). "paneconfig()" is an alias
  of "paneconfigure()".

  Identify the panedwindow component underneath the point given by
  *x* and *y*, in window coordinates. If the point is over a sash
  or a sash handle, the result is a two-element tuple containing
  the index of the sash or handle and a word indicating whether it
  is over a sash or a handle, such as "(0, 'sash')" or "(2,
  'handle')". If the point is over any other part of the
  panedwindow, the result is an empty string.

  Query or change the position of the sashes in the panedwindow.
  This is a thin wrapper around the Tk "sash" subcommand; the
  convenience methods "sash_coord()", "sash_mark()" and
  "sash_place()" should normally be used instead.

  Return the current x and y coordinate pair for the sash given by
  *index*, which must be an integer between 0 and one less than
  the number of panes in the panedwindow. The coordinates returned
  are those of the top left corner of the region containing the
  sash.

  Record the current mouse position for the sash given by *index*,
  for use together with later sash-drag operations to move the
  sash.

  Place the sash given by *index* at the coordinates *x* and *y*.

  Query or change the position of the sash proxy, the "ghost" sash
  shown while a sash is being dragged with non-opaque resizing.
  This is a thin wrapper around the Tk "proxy" subcommand; the
  convenience methods "proxy_coord()", "proxy_forget()" and
  "proxy_place()" should normally be used instead.

  Return a tuple containing the x and y coordinates of the most
  recent proxy location.

  Remove the proxy from the display.

  Place the proxy at the coordinates *x* and *y*.

  Do just what would happen if the user pressed the radiobutton
  with the mouse: select the button and invoke the associated
  command, if there is one. Return the result of the command, or
  an empty string if no command is associated with the
  radiobutton. This is ignored if the radiobutton's state is
  "disabled".

  Select the radiobutton and set the associated variable to the
  value corresponding to this widget.

  Deselect the radiobutton and set the associated variable to an
  empty string. If this radiobutton was not currently selected,
  this has no effect.

  Flash the radiobutton by redisplaying it several times,
  alternating between the active and normal colors. At the end of
  the flash the radiobutton is left in the same normal or active
  state as when the method was called. This is ignored if the
  radiobutton's state is "disabled".

  Return the current value of the scale. The result is an integer
  if the scale's *resolution* yields whole numbers, and a float
  otherwise.

  Set the scale to *value*, moving the slider accordingly. This
  has no effect if the scale is disabled.

  Return a tuple "(x, y)" giving the pixel coordinates, relative
  to the widget, of the point on the centerline of the trough that
  corresponds to *value*. If *value* is omitted, the scale's
  current value is used.

  Return a string describing the part of the scale at the pixel
  coordinates *x*, *y*: "'slider'", "'trough1'" (the part of the
  trough above or to the left of the slider), "'trough2'" (below
  or to the right of the slider), or an empty string if the point
  is not over any of these elements.

  Return the current scrollbar settings as a tuple "(first, last)"
  of two fractions between 0 and 1, describing the portion of the
  document that is currently visible, as last passed to "set()".

  Set the scrollbar. *first* and *last* are fractions between 0
  and 1 giving the positions of the start and end of the visible
  portion of the associated document. This method is normally
  registered as the scrolled widget's *xscrollcommand* or
  *yscrollcommand* and called by that widget.

  Mark the element *index* (one of "'arrow1'", "'slider'" or
  "'arrow2'") as active, displaying it according to the
  *activebackground* and *activerelief* options. If *index* is
  omitted, return the name of the currently active element, or
  "None" if no element is active.

  Distinto en la versión 3.5: The *index* argument is now
  optional.

  Return a float indicating the fractional change in the scrollbar
  setting that corresponds to moving the slider by *deltax* pixels
  horizontally (for horizontal scrollbars) or *deltay* pixels
  vertically (for vertical scrollbars).

  Return a float between 0 and 1 indicating where the point at
  pixel coordinates *x*, *y* lies in the trough: 0 corresponds to
  the top or left of the trough and 1 to the bottom or right.

  Return the name of the element under the pixel coordinates *x*,
  *y* (such as "'arrow1'"), or an empty string if the point does
  not lie in any element of the scrollbar.

  Return the spinbox's string.

  Insert the characters of the string *s* just before the
  character given by *index*.

  Delete one or more characters of the spinbox. *first* is the
  index of the first character to delete, and *last* is the index
  of the character just after the last one to delete. If *last* is
  omitted, a single character at *first* is deleted.

  Arrange for the insertion cursor to be displayed just before the
  character given by *index*.

  Return the numerical index corresponding to *index*, as a
  string.

  Return a tuple of four integers "(x, y, width, height)"
  describing the bounding box of the character given by *index*.
  *x* and *y* are the pixel coordinates of the upper-left corner
  of the character relative to the widget, and *width* and
  *height* are its size in pixels. The bounding box may refer to a
  region outside the visible area of the window.

  This shadows the inherited "Misc.bbox()"; use "grid_bbox()" for
  the grid bounding box.

  Return the name of the window element at the pixel coordinates
  *x*, *y*: one of "'buttondown'", "'buttonup'", "'entry'" or
  "'none'".

  Invoke the spin button given by *element*, either "'buttonup'"
  or "'buttondown'", triggering the action associated with it.

  A thin wrapper around the Tk "scan" widget subcommand, used to
  implement fast dragging of the view: "scan('mark', x)" records
  *x* and the current view, and "scan('dragto', x)" adjusts the
  view relative to that mark. The "scan_mark()" and
  "scan_dragto()" methods wrap the two forms.

  Record *x* and the current view in the spinbox window, for use
  with a later "scan_dragto()" call. This is typically associated
  with a mouse button press in the widget.

  Adjust the view by 10 times the difference between *x* and the
  *x* passed to the last "scan_mark()" call. This is typically
  associated with mouse motion events, producing the effect of
  dragging the spinbox at high speed through the window.

  A thin wrapper around the Tk "selection" widget subcommand, used
  to adjust the selection within the spinbox. It has several forms
  depending on the first argument, such as "selection('adjust',
  index)", "selection('clear')", "selection('element', ?elem?)",
  "selection('from', index)", "selection('present')",
  "selection('range', start, end)" and "selection('to', index)".
  The "selection_adjust()", "selection_clear()",
  "selection_element()", "selection_from()",
  "selection_present()", "selection_range()" and "selection_to()"
  methods wrap these forms.

  Locate the end of the selection nearest to the character given
  by *index* and adjust that end of the selection to be at *index*
  (including but not going beyond *index*). The other end becomes
  the anchor point for future "selection_to()" calls. If the
  selection is not currently in the spinbox, a new selection is
  created to include the characters between *index* and the most
  recent anchor point, inclusive.

  Clear the selection if it is currently in this widget. If the
  selection is not in this widget, the method has no effect.

  Nota:

    This shadows the inherited "Misc.selection_clear()", which
    clears the X selection; that method is not available on a
    "Spinbox".

  Set or get the currently selected element. If *element* (one of
  "'buttonup'", "'buttondown'" or "'none'") is given, that spin
  button is selected and displayed depressed; otherwise the name
  of the currently selected element is returned.

  Set the selection anchor point to just before the character
  given by *index*, without changing the selection itself.

  Added in version 3.8.

  Return "True" if there are characters selected in the spinbox,
  "False" otherwise.

  Added in version 3.8.

  Set the selection to include the characters starting with the
  one indexed by *start* and ending with the one just before
  *end*. If *end* refers to the same character as *start* or an
  earlier one, the selection is cleared.

  Added in version 3.8.

  Set the selection between *index* and the anchor point. If
  *index* is before the anchor point, the selection runs from
  *index* up to but not including the anchor point; if it is
  after, the selection runs from the anchor point up to but not
  including *index*; if it is the same, nothing happens. The
  anchor point is the one set by the most recent
  "selection_from()" or "selection_adjust()" call. If the
  selection is not in this widget, a new selection is created
  using the most recent anchor point.

  Added in version 3.8.

  Insert the string *chars* just before the character at *index*
  (if *index* is "'end'", just before the final newline). By
  default the new text inherits any tags present on both sides of
  the insertion point. If *args* is given, it consists of
  alternating *tagList*, *chars* values: the preceding *chars*
  receives exactly the tags listed (a tag list may be a single tag
  name or a sequence of names), overriding the surrounding tags.

  Delete the range of characters from *index1* up to but not
  including *index2*. If *index2* is omitted, the single character
  at *index1* is deleted. The widget always keeps a newline as its
  last character, so a deletion that would remove it is adjusted
  accordingly.

  Replace the range of characters from *index1* up to but not
  including *index2* with *chars*. This is equivalent to a
  "delete()" followed by an "insert()" at *index1*; *args* is
  interpreted as for "insert()".

  Added in version 3.3.

  Return the text from *index1* up to but not including *index2*
  as a string. If *index2* is omitted, return the single character
  at *index1*. Embedded images and windows are omitted from the
  result.

  Return the position corresponding to *index* in the canonical
  "'line.char'" form.

  Compare the positions of *index1* and *index2* using the
  relational operator *op*, which must be one of "'<'", "'<='",
  "'=='", "'>='", "'>'" or "'!='", and return the boolean result.

  Count the number of items of the requested kinds between
  *index1* and *index2*; the count is negative if *index1* is
  after *index2*. Each of *options* names a kind of item to count:
  "'chars'", "'displaychars'", "'displayindices'",
  "'displaylines'", "'indices'", "'lines'", "'xpixels'" or
  "'ypixels'" (the default, used when no option is given, is
  "'indices'"). The pseudo-option "'update'" forces any out-of-
  date layout information to be recalculated before the following
  options are evaluated. When *return_ints* is true and a single
  counting option is given, return a plain integer; otherwise
  return a tuple with one integer per counting option (or "None"
  if the result is empty).

  Added in version 3.3.

  Distinto en la versión 3.13: Added the *return_ints* parameter.

  Adjust the view so that the character given by *index* is
  visible. If it is already visible the method has no effect; if
  it is a short distance out of view the widget scrolls just
  enough to bring it to the nearest edge, otherwise it scrolls to
  center *index* in the window.

  Return a tuple "(x, y, width, height)" giving the bounding box,
  in pixels, of the visible part of the character at *index*, or
  "None" if that character is not visible on the screen.

  This shadows the inherited "Misc.bbox()"; use "grid_bbox()" for
  the grid bounding box.

  Return a tuple "(x, y, width, height, baseline)" describing the
  display line that contains *index*: the first four values give
  the bounding box of the line in pixels and *baseline* gives the
  offset of the baseline measured down from the top of the area.
  Return "None" if that display line is not visible on the screen.

  Set the mark named *markName* to the position just before the
  character at *index*, creating the mark if it does not already
  exist. A mark created this way has right gravity by default.

  Remove each of the marks named in *markNames*. The special
  "insert" and "current" marks may not be removed.

  Return a tuple of the names of all marks currently set in the
  widget.

  If *direction* is omitted, return the gravity of mark
  *markName*, either "'left'" or "'right'". Otherwise set its
  gravity to *direction*. The gravity determines on which side of
  the mark text inserted at the mark's position appears: a mark
  with right gravity (the default) stays to the right of such
  text.

  Return the name of the first mark at or after *index*, or "None"
  if there is none. When *index* is the name of a mark, the search
  starts just after that mark.

  Return the name of the last mark at or before *index*, or "None"
  if there is none. When *index* is the name of a mark, the search
  starts just before that mark.

  Add the tag *tagName* to the range of characters from *index1*
  up to but not including the next index in *args*. Further pairs
  of indices may follow in *args* to tag additional ranges; a
  trailing single index tags just the character at that index.

  Remove the tag *tagName* from the characters from *index1* up to
  but not including *index2* (or from the single character at
  *index1* if *index2* is omitted). The tag itself continues to
  exist even if no characters carry it.

  Delete each of the tags named in *tagNames*, removing them from
  all characters and discarding their options and bindings.

  Query or modify the configuration options of the tag *tagName*.
  This mirrors "configure()", except that it applies to a tag
  rather than to the widget as a whole: with no options it returns
  a dictionary describing the current options, otherwise it sets
  the given options. Defining a tag this way also gives it a
  priority higher than any existing tag.

  The supported tag options, all controlling the appearance of the
  tagged text, are:

  *font*
     The font to use for the text.

  *foreground*
     The color to use for the text.

  *background*
     The color to use for the area behind the text.

  *fgstipple*, *bgstipple*
     Bitmaps used to stipple the foreground (text) and the
     background; only well supported on X11.

  *borderwidth*
     The width of the border drawn around the text according to
     *relief* (default "0").

  *relief*
     The 3-D appearance of the text's border: "'flat'" (the
     default), "'raised'", "'sunken'", "'ridge'", "'groove'" or
     "'solid'".

  *offset*
     How far the text is raised above (or, if negative, lowered
     below) the baseline, for superscripts and subscripts.

  *underline*
     Whether to underline the text.

  *underlinefg*
     The color of the underline; it defaults to the text color.

  *overstrike*
     Whether to draw a line through the middle of the text.

  *overstrikefg*
     The color of the overstrike line; it defaults to the text
     color.

  *elide*
     Whether the text is elided (hidden).

  *justify*
     How to justify the first character of a display line:
     "'left'" (the default), "'right'" or "'center'".

  *wrap*
     How to wrap lines that are too long: "'char'", "'word'" or
     "'none'".

  *lmargin1*, *lmargin2*
     The indentation, in pixels, of the first display line of a
     logical line and of the remaining display lines.

  *lmargincolor*
     The color of the left margin area.

  *rmargin*
     The right-hand margin, in pixels.

  *rmargincolor*
     The color of the right margin area.

  *spacing1*, *spacing2*, *spacing3*
     Extra space, in pixels, above the first display line of a
     logical line, between its display lines, and below its last
     display line.

  *tabs*
     The set of tab stops, in the same form as the widget's *tabs*
     option.

  *tabstyle*
     How tab stops are interpreted: "'tabular'" or
     "'wordprocessor'".

  *selectbackground*, *selectforeground*
     The background and foreground colors used for the text while
     it is selected.

  Nota:

    Tk 8.6 added the *lmargincolor*, *overstrikefg*,
    *rmargincolor*, *selectbackground*, *selectforeground* and
    *underlinefg* options.

  "tag_config()" is an alias of "tag_configure()".

  Return the current value of the configuration option *option*
  for the tag *tagName*.

  If *index* is omitted, return a tuple of the names of all tags
  defined in the widget; otherwise return only the names of the
  tags applied to the character at *index*. The names are ordered
  from lowest to highest priority.

  Return a tuple of indices describing all ranges of text tagged
  with *tagName*. The result alternates start and end indices, so
  that elements "2*i" and "2*i+1" bound the *i*-th range.

  Search forward from *index1* (up to *index2* if given) for the
  first range of characters tagged with *tagName*, and return a
  two-element tuple of its start and end indices, or an empty
  tuple if there is no such range.

  Search backward from *index1* (down to *index2* if given) for
  the nearest preceding range of characters tagged with *tagName*,
  and return a two-element tuple of its start and end indices, or
  an empty tuple if there is no such range.

  Raise the priority of tag *tagName* so that it is just above the
  priority of *aboveThis*, or to the highest priority of all tags
  if *aboveThis* is omitted. When the display options of
  overlapping tags conflict, the higher-priority tag wins.

  Lower the priority of tag *tagName* so that it is just below the
  priority of *belowThis*, or to the lowest priority of all tags
  if *belowThis* is omitted.

  Bind the event *sequence* on characters tagged with *tagName* to
  the callback *func*, so that *func* is invoked when that event
  occurs over such a character. If *add* is true the binding is
  added alongside any existing bindings for *sequence*, otherwise
  it replaces them. Works like "bind()" and returns the identifier
  of the new binding.

  Remove the bindings of the event *sequence* on characters tagged
  with *tagName*. If *funcid* is given, only that binding (as
  returned by "tag_bind()") is removed and its callback is
  unregistered.

  Distinto en la versión 3.13: If *funcid* is given, only that
  callback is unbound.

  Embed an image at *index* and return the name assigned to this
  image instance, which may then be used as an index or passed to
  the other "image_*" methods. The options, given in *cnf* and
  *kw*, include *image* (the Tk image to display), *name* (a base
  name for the instance), *align*, *padx* and *pady*.

  Return the current value of the configuration option *option*
  for the embedded image at *index*.

  Query or modify the configuration options of the embedded image
  at *index*, like "configure()" but applied to that image.

  Return a tuple of the names of all images embedded in the
  widget.

  Nota:

    This shadows the inherited "Misc.image_names()", which returns
    the names of all images in the Tcl interpreter; that method is
    not available on a "Text".

  Embed a window (any widget) at *index*. The options, given in
  *cnf* and *kw*, include *window* (the widget to embed), *create*
  (a callback that creates the widget on demand), *align*,
  *stretch*, *padx* and *pady*. The embedded widget must be a
  descendant of the text widget's parent.

  Return the current value of the configuration option *option*
  for the embedded window at *index*.

  Query or modify the configuration options of the embedded window
  at *index*, like "configure()" but applied to that window.

  "window_config()" is an alias of "window_configure()".

  Return a tuple of the names of all windows embedded in the
  widget.

  Low-level wrapper around the Tk "edit" widget command that
  controls the undo/redo mechanism and the modified flag; *args*
  is the "edit" subcommand and its arguments. The "edit_*()"
  methods below are thin wrappers around it and are usually more
  convenient.

  If *arg* is omitted, return the current state of the modified
  flag as true or false; the flag is set automatically whenever
  the text is inserted or deleted. Otherwise set the flag to the
  boolean *arg*.

  Undo the most recent edit action, that is, all the inserts and
  deletes recorded on the undo stack since the previous separator,
  and move it to the redo stack. Raises "TclError" if the undo
  stack is empty. Has no effect unless the *undo* option is true.
  Since Tk 9.0, returns a tuple of indices delimiting the ranges
  of text that were changed.

  Reapply the most recently undone edit action, provided no
  further edits have been made since, and move it back to the undo
  stack. Raises "TclError" if the redo stack is empty. Has no
  effect unless the *undo* option is true. Since Tk 9.0, returns a
  tuple of indices delimiting the ranges of text that were
  changed.

  Clear the undo and redo stacks.

  Push a separator onto the undo stack, marking a boundary between
  edit actions for undo and redo. Has no effect unless the *undo*
  option is true. Separators are inserted automatically when the
  *autoseparators* option is true.

  Search for *pattern* starting at *index* and return the index of
  the first character of the first match, or an empty string if
  there is no match. Searching stops at *stopindex* if given;
  otherwise it wraps around the ends of the text until the
  starting position is reached again. The following boolean
  keyword flags control the search: *forwards* or *backwards*
  select the direction (forward is the default); *exact* (the
  default) or *regexp* select literal or regular-expression
  matching; *nocase* makes the match case-insensitive; and *elide*
  causes hidden text to be searched as well. If *count* is a
  "Variable", the number of index positions in the match is stored
  in it.

  Record *x*, *y* and the current view, for use with later
  "scan_dragto()" calls. This is typically bound to a mouse button
  press in the widget.

  Scroll the widget by 10 times the difference between *x*, *y*
  and the coordinates passed to the last "scan_mark()" call. This
  is typically bound to mouse motion events, producing the effect
  of dragging the text at high speed through the window.

  If *boolean* is omitted, return whether internal consistency
  checks of the B-tree data structure are enabled. Otherwise
  enable or disable them. The setting is shared by all text
  widgets and may noticeably slow down widgets holding large
  amounts of text.

  Return the contents of the widget from *index1* up to but not
  including *index2* (or just the segment at *index1* if *index2*
  is omitted), including text and information about marks, tags,
  images and windows. The result is a list of "(key, value,
  index)" triples, where *key* is one of "'text'", "'mark'",
  "'tagon'", "'tagoff'", "'image'" or "'window'". By default all
  kinds are reported; passing any of the keyword arguments *all*,
  *text*, *mark*, *tag*, *image* or *window* as true restricts the
  dump to the selected kinds. If *command* is given, it is called
  once per triple with the three values as arguments and nothing
  is returned.

  Create a peer text widget with the path name *newPathName* that
  shares this widget's underlying data (text, marks, tags, images
  and the undo stack). Changes made through any peer are reflected
  in all of them. By default the peer covers the same lines as
  this widget; standard text options, including *startline* and
  *endline*, may be given to override this.

  Added in version 3.3.

  Return a tuple of the path names of this widget's peers, not
  including the widget itself.

  Added in version 3.3.

  Adjust the view so that the location given by *what* is visible.
  This is an obsolete equivalent of "see()", which should be used
  instead.

 When a "Variable" is garbage collected, its Tcl variable is
 unset. Keep a reference to it for as long as a widget is linked
 to it, for example by storing it as an attribute rather than in a
 local variable. Otherwise Tk recreates the Tcl variable to keep
 the widget working, but it is never unset again, leaking one Tcl
 variable per dropped wrapper.

  Return the current value of the variable. For the base class the
  value is returned as a string; the typed subclasses convert it
  to the appropriate Python type.

  Set the variable to *value*. "initialize()" is an alias of
  "set()".

  Added in version 3.3: The *initialize* spelling.

  Register *callback* to be called when the variable is accessed
  according to *mode*. *mode* is one of the strings "'array'",
  "'read'", "'write'" or "'unset'", or a list or tuple of such
  strings.

  When triggered, *callback* is called with three arguments: the
  name of the Tcl variable, an index (or an empty string if the
  variable is not an element of an array), and the *mode* that
  triggered the call.

  Return the internal name of the registered callback, which can
  be passed to "trace_remove()".

  Added in version 3.6.

  Remove a trace callback from the variable. *mode* must match the
  *mode* that was passed to "trace_add()", and *cbname* is the
  callback name returned by "trace_add()".

  Added in version 3.6.

  Return a list of "(modes, cbname)" pairs describing all traces
  currently set on the variable, where *modes* is a tuple of mode
  strings and *cbname* is the internal callback name.

  Added in version 3.6.

  Register *callback* to be called when the variable is accessed
  according to *mode*. *mode* is one of the strings "'r'", "'w'"
  or "'u'", for read, write or unset. Return the internal name of
  the registered callback. "trace()" is an alias of
  "trace_variable()".

  Obsoleto desde la versión 3.6: Use "trace_add()" instead.  This
  method wraps a Tcl feature that was removed in Tcl 9.0.

  Remove the trace callback named *cbname* registered for *mode*
  with "trace_variable()".

  Obsoleto desde la versión 3.6: Use "trace_remove()" instead.
  This method wraps a Tcl feature that was removed in Tcl 9.0.

  Return a list of "(mode, cbname)" pairs for all traces set on
  the variable with "trace_variable()".

  Obsoleto desde la versión 3.6: Use "trace_info()" instead.  This
  method wraps a Tcl feature that was removed in Tcl 9.0.

  Return the value of the variable as a "str".

  Return the value of the variable as an "int".

  Return the value of the variable as a "float".

 A floating-point value is always parsed with a period (".") as
 the decimal separator, but "Spinbox", "Scale" and "ttk.Spinbox"
 format it according to the "LC_NUMERIC" locale.  Under a locale
 that uses a comma they produce a value that "get()" cannot read,
 raising "TclError".  Set "LC_NUMERIC" to a locale that uses a
 period (such as "'C'") to avoid this.

  Return the value of the variable as a "bool". Raise a
  "ValueError" if the value cannot be interpreted as a boolean.

  Set the variable to *value*, converting it to a boolean.
  "initialize()" is an alias of "set()".

  Added in version 3.3: The *initialize* spelling.

  Modify one or more configuration options of the image. The valid
  options depend on the image type; see "PhotoImage" and
  "BitmapImage". "config()" is an alias of "configure()".

  Return the height of the image, in pixels.

  Return the width of the image, in pixels.

  Return the type of the image, that is the value of *imgtype*
  with which it was created (for example "'photo'" or "'bitmap'").

  Blank the image; that is, set the entire image to have no data,
  so that it is displayed as transparent and the background of
  whatever window it is displayed in shows through.

  Return the current value of the configuration option *option*.

  Return a new "PhotoImage" with a copy of this image.

  *from_coords* specifies a rectangular sub-region of the source
  image to be copied. It must be a tuple or a list of 1 to 4
  integers "(x1, y1, x2, y2)". "(x1, y1)" and "(x2, y2)" specify
  diagonally opposite corners of the rectangle. If *x2* and *y2*
  are not specified, they default to the bottom-right corner of
  the source image. The pixels copied include the left and top
  edges of the rectangle but not the bottom or right edges. If
  *from_coords* is not given, the whole source image is copied.

  If *zoom* or *subsample* are specified, the image is transformed
  as in the "zoom()" or "subsample()" methods. The value must be a
  single integer or a pair of integers.

  Distinto en la versión 3.13: Added the *from_coords*, *zoom* and
  *subsample* parameters.

  Copy a region from *sourceImage* (which must be a "PhotoImage")
  into this image, possibly with pixel zooming and/or subsampling.
  If no options are specified, the whole of *sourceImage* is
  copied into this image, starting at coordinates "(0, 0)".

  *from_coords* specifies a rectangular sub-region of the source
  image to be copied, as in the "copy()" method.

  *to* specifies a rectangular sub-region of the destination image
  to be affected. It must be a tuple or a list of 1 to 4 integers
  "(x1, y1, x2, y2)". If *x2* and *y2* are not specified, they
  default to "(x1, y1)" plus the size of the source region (after
  subsampling and zooming, if specified). If *x2* and *y2* are
  specified, the source region is replicated if necessary to fill
  the destination region in a tiled fashion.

  If *shrink* is true, the size of the destination image is
  reduced, if necessary, so that the region being copied into is
  at the bottom-right corner of the image.

  If *zoom* or *subsample* are specified, the image is transformed
  as in the "zoom()" or "subsample()" methods. The value must be a
  single integer or a pair of integers.

  *compositingrule* specifies how transparent pixels in the source
  image are combined with the destination image. With "'overlay'"
  (the default), the old contents of the destination image remain
  visible, as if the source image were printed on a piece of
  transparent film and placed over the top of the destination.
  With "'set'", the old contents of the destination image are
  discarded and the source image is used as-is.

  Added in version 3.13.

  Return the image data.

  *format* specifies the name of the image file format handler to
  use. If it is not given, the data is returned as a tuple (one
  element per row) of strings containing space-separated (one
  element per pixel/column) colors in "#RRGGBB" format.

  *from_coords* specifies a rectangular region of the image to be
  returned. It must be a tuple or a list of 1 to 4 integers "(x1,
  y1, x2, y2)". If only *x1* and *y1* are specified, the region
  extends from "(x1, y1)" to the bottom-right corner of the image.
  If all four coordinates are given, they specify diagonally
  opposite corners of the region, including "(x1, y1)" and
  excluding "(x2, y2)". If *from_coords* is not given, the whole
  image is returned.

  If *background* is specified, the data does not contain any
  transparency information; in all transparent pixels the color is
  replaced by the specified color.

  If *grayscale* is true, the data does not contain color
  information; all pixel data is transformed into grayscale.

  Added in version 3.13.

  Return the color of the pixel at coordinates (*x*, *y*) as an
  "(r, g, b)" tuple of three integers between 0 and 255,
  representing the red, green and blue components respectively.

  Set pixels of the image to the colors given in *data*, which
  must be a string or a nested sequence of horizontal rows of
  pixel colors (for example ""{red green} {blue yellow}"").

  *to* specifies the coordinates of the region of the image into
  which the data are copied. It must be a tuple or a list of 2 or
  4 integers "(x1, y1)" or "(x1, y1, x2, y2)" giving the top-left
  corner, and optionally the bottom-right corner, of the region.
  The default position is "(0, 0)".

  Read image data from the file named *filename* into the image.

  *format* specifies the format of the image data in the file.

  *from_coords* specifies a rectangular sub-region of the image
  file data to be copied to the destination image. It must be a
  tuple or a list of 1 to 4 integers "(x1, y1, x2, y2)". If only
  *x1* and *y1* are specified, the region extends from "(x1, y1)"
  to the bottom-right corner of the image in the file. If all four
  coordinates are given, they specify diagonally opposite corners
  of the region. If *from_coords* is not given, the whole of the
  image in the file is read.

  *to* specifies the coordinates of the top-left corner of the
  region of the image into which the data are read. The default is
  "(0, 0)".

  If *shrink* is true, the size of the image is reduced, if
  necessary, so that the region into which the file data are read
  is at the bottom-right corner of the image.

  Added in version 3.13.

  Return a new "PhotoImage" based on this image but using only
  every *x*-th pixel in the X direction and every *y*-th pixel in
  the Y direction. If *y* is not given, it defaults to the same
  value as *x*.

  *from_coords* specifies a rectangular sub-region of the source
  image to be copied, as in the "copy()" method.

  Distinto en la versión 3.13: Added the *from_coords* parameter.

  Return "True" if the pixel at coordinates (*x*, *y*) is fully
  transparent, "False" otherwise.

  Added in version 3.8.

  Make the pixel at coordinates (*x*, *y*) fully transparent if
  *boolean* is true, fully opaque otherwise.

  Added in version 3.8.

  Write image data from the image to the file named *filename*.

  *format* specifies the name of the image file format handler to
  use. If it is not given, the format is guessed from the file
  extension.

  *from_coords* specifies a rectangular region of the image to be
  written. It must be a tuple or a list of 1 to 4 integers "(x1,
  y1, x2, y2)". If only *x1* and *y1* are specified, the region
  extends from "(x1, y1)" to the bottom-right corner of the image.
  If all four coordinates are given, they specify diagonally
  opposite corners of the region. If *from_coords* is not given,
  the whole image is written.

  If *background* is specified, the data does not contain any
  transparency information; in all transparent pixels the color is
  replaced by the specified color.

  If *grayscale* is true, the data does not contain color
  information; all pixel data is transformed into grayscale.

  Distinto en la versión 3.13: Added the *background* and
  *grayscale* parameters.

  Return a new "PhotoImage" with this image magnified by a factor
  of *x* in the X direction and *y* in the Y direction. If *y* is
  not given, it defaults to the same value as *x*.

  *from_coords* specifies a rectangular sub-region of the source
  image to be copied, as in the "copy()" method.

  Distinto en la versión 3.13: Added the *from_coords* parameter.

  The serial number of the event.

  The mouse button that was pressed or released (for button
  events).

  Whether the window has the focus (for "Enter" and "Leave"
  events).

  The new height and width of the window (for "Configure" and
  "Expose" events).

  The keycode of the key that was pressed or released.

  The state of the event, as a number (for most events) or a
  string (for "Visibility" events).

  The timestamp of the event, in milliseconds.

  The pointer position relative to the widget, in pixels.

  The pointer position relative to the top-left corner of the
  screen, in pixels.

  The character typed, as a string (for key events).

  "True" if the event was sent by another application.

  The symbolic name of the key that was pressed or released.

  The numeric value of "keysym".

  The "EventType" of the event.

  The widget on which the event occurred.

  The amount the mouse wheel was rotated (for "MouseWheel"
  events).

  callback(file, mask)