"tkinter" --- Tcl/Tk の Python インターフェース
***********************************************

**ソースコード:** Lib/tkinter/__init__.py

======================================================================

The "tkinter" package ("Tk interface") is the standard Python
interface to the Tcl/Tk GUI toolkit.  Both Tk and "tkinter" are
available on most Unix platforms, including macOS, as well as on
Windows systems.

コマンドラインから  "python -m tkinter" を実行すると簡素な Tk インター
フェースを表示するウィンドウが開き、システムに "tkinter" が正しくイン
ストールされたことが分かり、さらにインストールされた Tcl/Tk がどのバー
ションなのかが表示されるので、そのバージョンの Tcl/Tk ドキュメントを選
んで読めます。

参考:

  * TkDocs
       Extensive tutorial on creating user interfaces with Tkinter.
       Explains key concepts, and illustrates recommended approaches
       using the modern API.

  * Tkinter 8.5 reference: a GUI for Python
       Reference documentation for Tkinter 8.5 detailing available
       classes, methods, and options.

  Tcl/Tk Resources:

  * Tk commands
       Comprehensive reference to each of the underlying Tcl/Tk
       commands used by Tkinter.

  * Tcl/Tk Home Page
       Additional documentation, and links to Tcl/Tk core development.

  Books:

  * Modern Tkinter for Busy Python Developers
       By Mark Roseman. (ISBN 978-1999149567)

  * Python and Tkinter Programming
       By Alan Moore. (ISBN 978-1788835886)

  * Programming Python
       By Mark Lutz; has excellent coverage of Tkinter. (ISBN
       978-0596158101)

  * Tcl and the Tk Toolkit (2nd edition)
       By John Ousterhout, inventor of Tcl/Tk, and Ken Jones; does not
       cover Tkinter. (ISBN 978-0321336330)


Tkinter モジュール
==================

Support for Tkinter is spread across several modules. Most
applications will need the main "tkinter" module, as well as the
"tkinter.ttk" module, which provides the modern themed widget set and
API:

   from tkinter import *
   from tkinter import ttk

class tkinter.Tk(screenName=None, baseName=None, className='Tk', useTk=True, sync=False, use=None)

   Construct a toplevel Tk widget, which is usually the main window of
   an application, and initialize a Tcl interpreter for this widget.
   Each instance has its own associated Tcl interpreter.

   The "Tk" class is typically instantiated using all default values.
   However, the following keyword arguments are currently recognized:

   *screenName*
      When given (as a string), sets the "DISPLAY" environment
      variable. (X11 only)

   *baseName*
      Name of the profile file.  By default, *baseName* is derived
      from the program name ("sys.argv[0]").

   *className*
      Name of the widget class.  Used as a profile file and also as
      the name with which Tcl is invoked (*argv0* in *interp*).

   *useTk*
      If "True", initialize the Tk subsystem.  The "tkinter.Tcl()"
      function sets this to "False".

   *sync*
      If "True", execute all X server commands synchronously, so that
      errors are reported immediately.  Can be used for debugging.
      (X11 only)

   *use*
      Specifies the *id* of the window in which to embed the
      application, instead of it being created as an independent
      toplevel window. *id* must be specified in the same way as the
      value for the -use option for toplevel widgets (that is, it has
      a form like that returned by "winfo_id()").

      Note that on some platforms this will only work correctly if
      *id* refers to a Tk frame or toplevel that has its -container
      option enabled.

   "Tk" reads and interprets profile files, named ".*className*.tcl"
   and ".*baseName*.tcl", into the Tcl interpreter and calls "exec()"
   on the contents of ".*className*.py" and ".*baseName*.py".  The
   path for the profile files is the "HOME" environment variable or,
   if that isn't defined, then "os.curdir".

   tk

      The Tk application object created by instantiating "Tk".  This
      provides access to the Tcl interpreter.  Each widget that is
      attached the same instance of "Tk" has the same value for its
      "tk" attribute.

   master

      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*/*slave* reflects the container
      structure.

   children

      The immediate descendants of this widget as a "dict" with the
      child widget names as the keys and the child instance objects as
      the values.

tkinter.Tcl(screenName=None, baseName=None, className='Tk', useTk=False)

   "Tcl()" はファクトリ関数で、 "Tk" クラスで生成するオブジェクトとよ
   く似たオブジェクトを生成します。ただし Tk サブシステムを初期化しま
   せん。この関数は、余分なトップレベルウィンドウを作る必要がなかった
   り、 (X サーバを持たない Unix/Linux システムなどのように) 作成でき
   ない環境において Tcl インタプリタを駆動したい場合に便利です。
   "Tcl()" で生成したオブジェクトに対して "loadtk()" メソッドを呼び出
   せば、トップレベルウィンドウを作成 (して、Tk サブシステムを初期化)
   します。

The modules that provide Tk support include:

"tkinter"
   Main Tkinter module.

"tkinter.colorchooser"
   ユーザに色を選択させるためのダイアログです。

"tkinter.commondialog"
   このリストの他のモジュールが定義しているダイアログの基底クラスです
   。

"tkinter.filedialog"
   ユーザが開きたいファイルや保存したいファイルを指定できるようにする
   共通のダイアログです。

"tkinter.font"
   フォントの扱いを補助するためのユーティリティです。

"tkinter.messagebox"
   標準的な Tk のダイアログボックスにアクセスします。

"tkinter.scrolledtext"
   垂直スクロールバー付きのテキストウィジェットです。

"tkinter.simpledialog"
   基本的なダイアログと便宜関数 (convenience function) です。

"tkinter.ttk"
   Themed widget set introduced in Tk 8.5, providing modern
   alternatives for many of the classic widgets in the main "tkinter"
   module.

Additional modules:

"_tkinter"
   A binary module that contains the low-level interface to Tcl/Tk. It
   is automatically imported by the main "tkinter" module, and should
   never be used directly by application programmers. It is usually a
   shared library (or DLL), but might in some cases be statically
   linked with the Python interpreter.

"idlelib"
   Python's Integrated Development and Learning Environment (IDLE).
   Based on "tkinter".

"tkinter.constants"
   Symbolic constants that can be used in place of strings when
   passing various parameters to Tkinter calls. Automatically imported
   by the main "tkinter" module.

"tkinter.dnd"
   (experimental) Drag-and-drop support for "tkinter". This will
   become deprecated when it is replaced with the Tk DND.

"tkinter.tix"
   (deprecated) An older third-party Tcl/Tk package that adds several
   new widgets. Better alternatives for most can be found in
   "tkinter.ttk".

"turtle"
   Tk ウィンドウ上でタートルグラフィックスを実現します。


Tkinter お助け手帳
==================

この節は、 Tk や Tkinter を全て網羅したチュートリアルを目指しているわ
けではありません。むしろ、Tkinter のシステムを学ぶ上での指針を示すため
の、その場しのぎ的なマニュアルです。

謝辞:

* Tk は John Ousterhout が Berkeley の在籍中に作成しました。

* Tkinter は Steen Lumholt と Guido van Rossum が作成しました。

* この Life Preserver は Virginia 大学の Matt Conway 他が執筆しました
  。

* HTML レンダリングやたくさんの編集は、Ken Manheimer が FrameMaker 版
  から行いました。

* Fredrik Lundh はクラスインターフェース詳細な説明を書いたり内容を改訂
  したりして、現行の Tk 4.2 に合うようにしました。

* Mike Clarkson はドキュメントを LaTeX 形式に変換し、リファレンスマニ
  ュアルのユーザインターフェースの章をコンパイルしました。


この節の使い方
--------------

この節は二つの部分で構成されています: 前半では、背景となることがらを (
大雑把に) 網羅しています。後半は、キーボードの横に置けるような手軽なリ
ファレンスになっています。

「○○するにはどうしたらよいですか」という形の問いに答えようと思うなら、
まず Tk で「○○する」方法を調べてから、このドキュメントに戻ってきてその
方法に対応する "tkinter" の関数呼び出しに変換するのが多くの場合最善の
方法になります。Python プログラマが Tk ドキュメンテーションを見れば、
たいてい正しい Python コマンドの見当をつけられます。従って、Tkinter を
使うには Tk についてほんの少しだけ知っていればよいということになります
。このドキュメントではその役割を果たせないので、次善の策として、すでに
ある最良のドキュメントについていくつかヒントを示しておくことにしましょ
う:

* Tk の man ページのコピーを手に入れるよう強く勧めます。とりわけ最も役
  立つのは "manN" ディレクトリ内にあるマニュアルです。"man3" のマニュ
  アルページは Tk ライブラリに対する C インターフェースについての説明
  なので、スクリプト書きにとって取り立てて役に立つ内容ではありません。

* Addison-Wesley は John Ousterhout の書いた Tcl and the Tk Toolkit
  (ISBN 0-201-63337-X) という名前の本を出版しています。この本は初心者
  向けの Tcl と Tk の良い入門書です。内容は網羅的ではなく、詳細の多く
  は man ページ任せにしています。

* たいていの場合、"tkinter/__init__.py" は参照先としての最後の手段です
  が、それ以外の手段で調べても分からない場合には救いの地になるかもしれ
  ません。


簡単な Hello World プログラム
-----------------------------

   import tkinter as tk

   class Application(tk.Frame):
       def __init__(self, master=None):
           super().__init__(master)
           self.master = master
           self.pack()
           self.create_widgets()

       def create_widgets(self):
           self.hi_there = tk.Button(self)
           self.hi_there["text"] = "Hello World\n(click me)"
           self.hi_there["command"] = self.say_hi
           self.hi_there.pack(side="top")

           self.quit = tk.Button(self, text="QUIT", fg="red",
                                 command=self.master.destroy)
           self.quit.pack(side="bottom")

       def say_hi(self):
           print("hi there, everyone!")

   root = tk.Tk()
   app = Application(master=root)
   app.mainloop()


Tcl/Tk を (本当に少しだけ) 見渡してみる
=======================================

クラス階層は複雑に見えますが、実際にプログラムを書く際には、アプリケー
ションプログラマはほとんど常にクラス階層の最底辺にあるクラスしか参照し
ません。

注釈:

* クラスのいくつかは、特定の関数を一つの名前空間下にまとめるために提供
  されています。こうしたクラスは個別にインスタンス化するためのものでは
  ありません。

* "Tk" クラスはアプリケーション内で一度だけインスタンス化するようにな
  っています。アプリケーションプログラマが明示的にインスタンス化する必
  要はなく、他のクラスがインスタンス化されると常にシステムが作成します
  。

* "Widget" クラスもまた、インスタンス化して使うようにはなっていません
  。このクラスはサブクラス化して「実際の」ウィジェットを作成するための
  ものです。(C++ で言うところの、 '抽象クラス (abstract class)' です)
  。

このリファレンス資料を活用するには、Tk の短いプログラムを読んだり、 Tk
コマンドの様々な側面を知っておく必要がままあるでしょう。(下の説明の
"tkinter" 版は、基本的な Tk プログラムと Tkinter との対応関係 節を参照
してください。)

Tk スクリプトは Tcl プログラムです。全ての Tcl プログラムに同じく、 Tk
スクリプトはトークンをスペースで区切って並べます。 Tk ウィジェットとは
、ウィジェットの *クラス* 、ウィジェットの設定を行う *オプション* 、そ
してウィジェットに役立つことをさせる *アクション* を組み合わせたものに
過ぎません。

Tk でウィジェットを作るには、常に次のような形式のコマンドを使います:

   classCommand newPathname options

*classCommand*
   どの種類のウィジェット (ボタン、ラベル、メニュー、...) を作るかを表
   します。

*newPathname*
   作成するウィジェットにつける新たな名前です。Tk 内の全ての名前は一意
   になっていなければなりません。一意性を持たせる助けとして、 Tk 内の
   ウィジェットは、ファイルシステムにおけるファイルと同様、 *パス名
   (pathname)* を使って名づけられます。トップレベルのウィジェット、す
   なわち *ルート* は "." (ピリオド) という名前になり、その子ウィジェ
   ット階層もピリオドで区切ってゆきます。ウィジェットの名前は、例えば
   ".myApp.controlPanel.okButton" のようになります。

*options*
   ウィジェットの見た目を設定します。場合によってはウィジェットの挙動
   も設定します。オプションはフラグと値がリストになった形式をとります
   。 Unix のシェルコマンドのフラグと同じように、フラグの前には '-' が
   つき、複数の単語からなる値はクオートで囲まれます。

例えば:

   button   .fred   -fg red -text "hi there"
      ^       ^     \______________________/
      |       |                |
    class    new            options
   command  widget  (-opt val -opt val ...)

ウィジェットを作成すると、ウィジェットへのパス名は新しいコマンドになり
ます。この新たな *widget command* は、プログラマが新たに作成したウィジ
ェットに *action* を実行させる際のハンドル (handle) になります。C では
someAction(fred, someOptions) と表し、 C++ では
fred.someAction(someOptions) と表すでしょう。Tkでは:

   .fred someAction someOptions

のようにします。オブジェクト名 ".fred" はドットから始まっている点に注
意してください。

読者の想像の通り、 *someAction* に指定できる値はウィジェットのクラスに
依存しています: fred がボタンなら ".fred disable" はうまくいきます
(fred はグレーになります) が、fred がラベルならうまくいきません (Tkで
はラベルの無効化をサポートしていないからです)。

*someOptions* に指定できる値はアクションの内容に依存しています。
"disable" のようなアクションは引数を必要としませんが、テキストエントリ
ボックスの "delete" コマンドのようなアクションにはテキストを削除する範
囲を指定するための引数が必要になります。


基本的な Tk プログラムと Tkinter との対応関係
=============================================

Tk のクラスコマンドは、Tkinter のクラスコンストラクタに対応しています
。

   button .fred                =====>  fred = Button()

オブジェクトの親 (master) は、オブジェクトの作成時に指定した新たな名前
から非明示的に決定されます。Tkinter では親を明示的に指定します。

   button .panel.fred          =====>  fred = Button(panel)

Tk の設定オプションは、ハイフンをつけたタグと値の組からなるリストで指
定します。Tkinter では、オプションはキーワード引数にしてインスタンスの
コンストラクタに指定したり、 "config()" にキーワード引数を指定して呼び
出したり、インデクス指定を使ってインスタンスに代入したりして設定します
。オプションの設定については オプションの設定 節を参照してください。

   button .fred -fg red        =====>  fred = Button(panel, fg="red")
   .fred configure -fg red     =====>  fred["fg"] = red
                               OR ==>  fred.config(fg="red")

Tk でウィジェットにアクションを実行させるには、ウィジェット名をコマン
ドにして、その後にアクション名を続け、必要に応じて引数 (オプション) を
続けます。Tkinter では、クラスインスタンスのメソッドを呼び出して、ウィ
ジェットのアクションを呼び出します。あるウィジェットがどんなアクション
(メソッド) を実行できるかは、"tkinter/__init__.py" モジュール内にリス
トされています。

   .fred invoke                =====>  fred.invoke()

Tk でウィジェットを packer (ジオメトリマネージャ) に渡すには、pack コ
マンドをオプション引数付きで呼び出します。Tkinter では Pack クラスがこ
の機能すべてを握っていて、様々な pack の形式がメソッドとして実装されて
います。"tkinter" のウィジェットはすべて packer からサブクラス化されて
いるため、pack 操作にまつわるすべてのメソッドを継承しています。Form ジ
オメトリマネージャに関する詳しい情報については "tkinter.tix" モジュー
ルのドキュメントを参照してください。

   pack .fred -side left       =====>  fred.pack(side="left")


Tk と Tkinter はどのように関わっているのか
==========================================

上から下に、呼び出しの階層構造を説明してゆきます:

あなたのアプリケーション (Python)
   まず、Python アプリケーションが "tkinter" を呼び出します。

tkinter (Python パッケージ)
   上記の呼び出し (例えば、ボタンウィジェットの作成) は、"tkinter" パ
   ッケージ内で実装されており、Python で書かれています。この Python で
   書かれた関数は、コマンドと引数を解析して変換し、あたかもコマンドが
   Python スクリプトではなく Tk スクリプトから来たようにみせかけます。

_tkinter (C)
   上記のコマンドと引数は "_tkinter" (先頭にアンダースコアです) 拡張モ
   ジュール内の C 関数に渡されます。

Tk ウィジェット (C および Tcl)
   上記の C 関数は、Tk ライブラリを構成する C 関数の入った別の C モジ
   ュールへの呼び出しを行えるようになっています。Tk は C と少しの Tcl
   を使って実装されています。Tk ウィジェットの Tcl 部分は、ウィジェッ
   トのデフォルト動作をバインドするために使われ、Python "tkinter" パッ
   ケージがインポートされた時に一度だけ実行されます (ユーザがこの過程
   を目にすることはありません)。

Tk (C)
   Tk ウィジェットの Tk 部分で実装されている最終的な対応付け操作によっ
   て...

Xlib (C)
   Xlib ライブラリがスクリーン上にグラフィックスを描きます。


簡単なリファレンス
==================


オプションの設定
----------------

オプションは、色やウィジェットの境界線幅などを制御します。オプションの
設定には三通りの方法があります:

オブジェクト生成時、キーワード引数を使用する
      fred = Button(self, fg="red", bg="blue")

オブジェクト生成後、オプション名を辞書インデックスのように扱う
      fred["fg"] = "red"
      fred["bg"] = "blue"

オブジェクト生成後に、config()メソッドを使って複数の属性を更新する
      fred.config(fg="red", bg="blue")

オプションとその振る舞いに関する詳細な説明は、該当するウィジェットの
Tk の man ページを参照してください。

man ページには、各ウィジェットの "STANDARD OPTIONS (標準オプション)"
と "WIDGET SPECIFIC OPTIONS (ウィジェット固有のオプション)" がリストさ
れていることに注意してください。前者は多くのウィジェットに共通のオプシ
ョンのリストで、後者は特定のウィジェットに特有のオプションです。標準オ
プションの説明は man ページの *options(3)* にあります。

このドキュメントでは、標準オプションとウィジェット固有のオプションを区
別していません。オプションによっては、ある種のウィジェットに適用できま
せん。あるウィジェットがあるオプションに対応しているかどうかは、ウィジ
ェットのクラスによります。例えばボタンには "command" オプションがあり
ますが、ラベルにはありません。

あるウィジェットがどんなオプションをサポートしているかは、ウィジェット
の man ページにリストされています。また、実行時にウィジェットの
"config()" メソッドを引数なしで呼び出したり、 "keys()" メソッドを呼び
出したりして問い合わせることもできます。メソッド呼び出しを行うと辞書型
の値を返します。この辞書は、オプションの名前がキー (例えば "'relief'")
になっていて、値が 5 要素のタプルになっています。

"bg" のように、いくつかのオプションはより長い名前を持つ共通のオプショ
ンに対する同義語になっています ("bg" は "background" を短縮したもので
す)。短縮形のオプション名を "config()" に渡すと、 5 要素ではなく 2 要
素のタプルを返します。このタプルには、同義語の名前と「本当の」オプショ
ン名が入っています (例えば "('bg', 'background')")。

+---------+-----------------------------------+----------------+
| インデ  | 意味                              | 使用例         |
| ックス  |                                   |                |
|=========|===================================|================|
| 0       | オプション名                      | "'relief'"     |
+---------+-----------------------------------+----------------+
| 1       | データベース検索用のオプション名  | "'relief'"     |
+---------+-----------------------------------+----------------+
| 2       | データベース検索用のオプションク  | "'Relief'"     |
|         | ラス                              |                |
+---------+-----------------------------------+----------------+
| 3       | デフォルト値                      | "'raised'"     |
+---------+-----------------------------------+----------------+
| 4       | 現在の値                          | "'groove'"     |
+---------+-----------------------------------+----------------+

以下はプログラム例です:

   >>> print(fred.config())
   {'relief': ('relief', 'relief', 'Relief', 'raised', 'groove')}

もちろん、実際に出力される辞書には利用可能なオプションが全て表示されま
す。上の表示例は単なる例にすぎません。


Packer
------

packer は Tk のジオメトリ管理メカニズムの一つです。ジオメトリマネージ
ャは、複数のウィジェットの位置を、それぞれのウィジェットを含むコンテナ
- 共通の *マスタ (master)* からの相対で指定するために使います。やや扱
いにくい *placer* (あまり使われないのでここでは取り上げません) と違い
、packer は定性的な関係を表す指定子 - *上 (above)* 、 *〜の左 (to the
left of)* 、 *引き延ばし (filling)* など - を受け取り、厳密な配置座標
の決定を全て行ってくれます。

どんな *マスタ* ウィジェットでも、大きさは内部の "スレイブ (slave) ウ
ィジェット" の大きさで決まります。 packer は、スレイブウィジェットを
pack 先のマスタウィジェット中のどこに配置するかを制御するために使われ
ます。望みのレイアウトを達成するには、ウィジェットをフレームにパックし
、そのフレームをまた別のフレームにパックできます。さらに、一度パックを
行うと、それ以後の設定変更に合わせて動的に並べ方を調整します。

ジオメトリマネージャがウィジェットのジオメトリを確定するまで、ウィジェ
ットは表示されないので注意してください。初心者のころにはよくジオメトリ
の確定を忘れてしまい、ウィジェットを生成したのに何も表示されず驚くこと
になります。ウィジェットは、(例えば packer の "pack()" メソッドを適用
して) ジオメトリを確定した後で初めて表示されます。

pack() メソッドは、キーワード引数つきで呼び出せます。キーワード引数は
、ウィジェットをコンテナ内のどこに表示するか、メインのアプリケーション
ウィンドウをリサイズしたときにウィジェットがどう振舞うかを制御します。
以下に例を示します:

   fred.pack()                     # defaults to side = "top"
   fred.pack(side="left")
   fred.pack(expand=1)


Packer のオプション
-------------------

packer と packer の取りえるオプションについての詳細は、man ページや
John Ousterhout の本の183ページを参照してください。

anchor
   アンカーの型です。 packer が区画内に各スレイブを配置する位置を示し
   ます。

expand
   ブール値で、 "0" または "1" になります。

fill
   指定できる値は "'x'" 、 "'y'" 、 "'both'" 、 "'none'" です。

ipadx および ipady
   スレイブウィジェットの各側面の内側に行うパディング幅を表す長さを指
   定します。

padx および pady
   スレイブウィジェットの各側面の外側に行うパディング幅を表す長さを指
   定します。

side
   指定できる値は "'left'", "'right'", "'top'", "'bottom'" です。


ウィジェット変数を関連付ける
----------------------------

ウィジェットによっては、(テキスト入力ウィジェットのように) 特殊なオプ
ションを使って、現在設定されている値をアプリケーション内の変数に直接関
連付けできます。このようなオプションには "variable", "textvariable",
"onvalue", "offvalue" および "value" があります。この関連付けは双方向
に働きます: 変数の値が何らかの理由で変更されると、関連付けされているウ
ィジェットも更新され、新しい値を反映します。

残念ながら、現在の "tkinter" の実装では、"variable" や "textvariable"
オプションでは任意の Python の値をウィジェットに渡せません。この関連付
け機能がうまく働くのは、"tkinter" 内で Variable というクラスからサブク
ラス化されている変数によるオプションだけです。

Variable には、 "StringVar", "IntVar", "DoubleVar", "BooleanVar" とい
った便利なサブクラスがすでにすでに数多く定義されています。こうした変数
の現在の値を読み出したければ、 "get()" メソッドを呼び出します。また、
値を変更したければ "set()" メソッドを呼び出します。このプロトコルに従
っている限り、それ以上なにも手を加えなくてもウィジェットは常に現在値に
追従します。

例えば:

   import tkinter as tk

   class App(tk.Frame):
       def __init__(self, master):
           super().__init__(master)
           self.pack()

           self.entrythingy = tk.Entry()
           self.entrythingy.pack()

           # Create the application variable.
           self.contents = tk.StringVar()
           # Set it to some value.
           self.contents.set("this is a variable")
           # Tell the entry widget to watch this variable.
           self.entrythingy["textvariable"] = self.contents

           # Define a callback for when the user hits return.
           # It prints the current value of the variable.
           self.entrythingy.bind('<Key-Return>',
                                self.print_contents)

       def print_contents(self, event):
           print("Hi. The current entry content is:",
                 self.contents.get())

   root = tk.Tk()
   myapp = App(root)
   myapp.mainloop()


ウィンドウマネージャ
--------------------

Tk には、ウィンドウマネジャとやり取りするための "wm" というユーティリ
ティコマンドがあります。"wm" コマンドにオプションを指定すると、タイト
ルや配置、アイコンビットマップなどを操作できます。"tkinter" では、こう
したコマンドは "Wm" クラスのメソッドとして実装されています。トップレベ
ルウィジェットは "Wm" クラスからサブクラス化されているので、"Wm" のメ
ソッドを直接呼び出せます。

あるウィジェットの入っているトップレベルウィンドウを取得したい場合、大
抵は単にウィジェットのマスタを参照するだけですみます。とはいえ、ウィジ
ェットがフレーム内にパックされている場合、マスタはトップレベルウィンド
ウではありません。任意のウィジェットの入っているトップレベルウィンドウ
を知りたければ "_root()" メソッドを呼び出してください。このメソッドは
アンダースコアがついていますが、これはこの関数が "Tkinter" の実装の一
部であり、Tk の機能に対するインターフェースではないことを示しています
。

以下に典型的な使い方の例をいくつか挙げます:

   import tkinter as tk

   class App(tk.Frame):
       def __init__(self, master=None):
           super().__init__(master)
           self.pack()

   # create the application
   myapp = App()

   #
   # here are method calls to the window manager class
   #
   myapp.master.title("My Do-Nothing Application")
   myapp.master.maxsize(1000, 400)

   # start the program
   myapp.mainloop()


Tk オプションデータ型
---------------------

anchor
   指定できる値はコンパスの方位です: ""n"" 、 ""ne"" 、 ""e"" 、
   ""se"" 、 ""s"" 、 ""sw"" 、 ""w"" 、 ""nw"" 、および ""center"" 。

bitmap
   八つの組み込み、名前付きビットマップ: "'error'" 、 "'gray25'" 、
   "'gray50'" 、 "'hourglass'" 、 "'info'" 、 "'questhead'" 、
   "'question'" 、 "'warning'" 。 X ビットマップファイル名を指定するた
   めに、 ""@/usr/contrib/bitmap/gumby.bit"" のような "@" を先頭に付け
   たファイルへの完全なパスを与えてください。

boolean
   整数 0 または 1 、あるいは、文字列 ""yes"" または ""no"" を渡すこと
   ができます。

callback
   これは引数を取らない Python 関数ならどれでも構いません。例えば:

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

color
   Colors can be given as the names of X colors in the rgb.txt file,
   or as strings representing RGB values in 4 bit: ""#RGB"", 8 bit:
   ""#RRGGBB"", 12 bit: ""#RRRGGGBBB"", or 16 bit: ""#RRRRGGGGBBBB""
   ranges, where R,G,B here represent any legal hex digit.  See page
   160 of Ousterhout's book for details.

cursor
   "cursorfont.h" の標準Xカーソル名を、接頭語 "XC_" 無しで使うことがで
   きます。例えば、handカーソル("XC_hand2")を得るには、文字列
   ""hand2"" を使ってください。あなた自身のビットマップとマスクファイ
   ルを指定することもできます。 Ousterhout の本の179ページを参照してく
   ださい。

distance
   スクリーン上の距離をピクセルか絶対距離のどちらかで指定できます。ピ
   クセルは数値として与えられ、絶対距離は文字列として与えられます。絶
   対距離を表す文字列は、単位を表す終了文字 (センチメートルには "c" 、
   インチには "i" 、ミリメートルには "m" 、プリンタのポイントには "p")
   を伴います。例えば、3.5インチは ""3.5i"" と表現します。

font
   Tkはフォント名の形式に "{courier 10 bold}" のようなリストを使います
   。正の数のフォントサイズはポイント単位で使用され、負の数のサイズは
   ピクセル単位と見なされます。

geometry
   これは "widthxheight" 形式の文字列です。ここでは、ほとんどのウィジ
   ェットに対して幅と高さピクセル単位で (テキストを表示するウィジェッ
   トに対しては文字単位で)表されます。例えば: "fred["geometry"] =
   "200x100"" 。

justify
   指定できる値は文字列です: ""left"" 、 ""center"" 、 ""right"" 、そ
   して ""fill"" 。

region
   これは空白で区切られた四つの要素をもつ文字列です。各要素は指定可能
   な距離です(以下を参照)。例えば: ""2 3 4 5"" と ""3i 2i 4.5i 2i"" と
   ""3c 2c 4c 10.43c"" は、すべて指定可能な範囲です。

relief
   ウィジェットのボーダのスタイルが何かを決めます。指定できる値は:
   ""raised"" 、 ""sunken"" 、 ""flat"" 、 ""groove"" 、と ""ridge""
   。

scrollcommand
   これはほとんどの場合スクロールバーウィジェットの "set()" メソッドで
   すが、1 個の引数を取るあらゆるウィジェットにもなりえます。

wrap
   次の中の一つでなければなりません: ""none"" 、 ""char"" 、あるいは
   ""word"" 。


バインドとイベント
------------------

ウィジェットコマンドからの bind メソッドによって、あるイベントを待つこ
とと、そのイベント型が起きたときにコールバック関数を呼び出すことができ
るようになります。 bind メソッドの形式は:

   def bind(self, sequence, func, add=''):

ここでは:

sequence
   は対象とするイベントの型を示す文字列です (詳細については、bind の
   man ページと John Ousterhout の本の201ページを参照してください)。

func
   は一引数を取り、イベントが起きるときに呼び出される Python 関数です
   。イベント・インスタンスが引数として渡されます。 (このように実施さ
   れる関数は、一般に *callbacks* として知られています。)

add
   はオプションで、 "''" か "'+'" のどちらかです。空文字列を渡すことは
   、このイベントが関係する他のどんなバインドをもこのバインドが置き換
   えることを意味します。 "'+'" を使う仕方は、この関数がこのイベント型
   にバインドされる関数のリストに追加されることを意味しています。

例えば:

   def turn_red(self, event):
       event.widget["activeforeground"] = "red"

   self.button.bind("<Enter>", self.turn_red)

イベントのウィジェットフィールドが "turn_red()" コールバック内でどのよ
うにアクセスされているかに注目してください。このフィールドは X イベン
トを捕らえたウィジェットを含んでいます。以下の表はアクセスできる他のイ
ベントフィールドとそれらの Tk での表現方法の一覧です。Tk man ページを
参照するときに役に立つでしょう。

+------+-----------------------+------+-----------------------+
| Tk   | Tkinter イベントフィ  | Tk   | Tkinter イベントフィ  |
|      | ールド                |      | ールド                |
|======|=======================|======|=======================|
| %f   | focus                 | %A   | char                  |
+------+-----------------------+------+-----------------------+
| %h   | 高さ                  | %E   | send_event            |
+------+-----------------------+------+-----------------------+
| %k   | keycode               | %K   | keysym                |
+------+-----------------------+------+-----------------------+
| %s   | state                 | %N   | keysym_num            |
+------+-----------------------+------+-----------------------+
| %t   | time                  | %T   | type                  |
+------+-----------------------+------+-----------------------+
| %w   | 幅                    | %W   | widget                |
+------+-----------------------+------+-----------------------+
| %x   | x                     | %X   | x_root                |
+------+-----------------------+------+-----------------------+
| %y   | y                     | %Y   | y_root                |
+------+-----------------------+------+-----------------------+


index パラメータ
----------------

多くのウィジェットにはパラメータ "index" を渡す必要があります。これら
はテキストウィジェット内の特定の位置や、エントリウィジェット内の特定の
文字、あるいはメニューウィジェット内の特定のメニューアイテムを指定する
ために使用されます。

エントリウィジェットのインデックス(インデックス、ビューインデックスな
ど)
   エントリウィジェットは表示されているテキスト内の文字位置を参照する
   オプションを持っています。テキストウィジェットにおけるこれらの特別
   な位置にアクセスするために、次の "tkinter" 関数を使うことができます
   :

テキストウィジェットのインデックス
   テキストウィジェットに対するインデックス記法はとても機能が豊富で、
   Tk manページでよく説明されています。

メニューのインデックス(menu.invoke()、menu.entryconfig()など)
   メニューに対するいくつかのオプションとメソッドは特定のメニュー項目
   を操作します。メニューインデックスはオプションまたはパラメータのた
   めに必要とされるときはいつでも、以下のものを渡すことができます:

   * ウィジェット内の数字の先頭からの位置を指す整数。先頭は 0。

   * 文字列 ""active""。現在カーソルがあるメニューの位置を指します。

   * 文字列 ""last"" 。最後のメニューを指します。

   * "@6" のような "@" が前に来る整数。ここでは、整数がメニューの座標
     系における y ピクセル座標として解釈されます。

   * 文字列 ""none""。どんなメニューエントリもまったく指しておらず、ほ
     とんどの場合、すべてのエントリの動作を停止させるために
     menu.activate() と一緒に使われます。そして、最後に、

   * メニューの先頭から一番下までスキャンしたときに、メニューエントリ
     のラベルに一致したパターンであるテキスト文字列。このインデックス
     型は他すべての後に考慮されることに注意してください。その代わりに
     、それは "last" 、 "active" または "none" とラベル付けされたメニ
     ュー項目への一致は上のリテラルとして解釈されることを意味します。


画像
----

様々な形式の画像を、それに対応する "tkinter.Image" のサブクラスを使っ
て作成できます:

* XBM 形式の画像のための "BitmapImage" 。

* PGM, PPM, GIF, PNG 形式の画像のための "PhotoImage" 。 最後のは Tk
  8.6 からサポートされるようになりました。

画像のどちらの型でも "file" または "data" オプションを使って作られます
(その上、他のオプションも利用できます)。

"image" オプションがウィジェットにサポートされるところならどこでも、画
像オブジェクトを使うことができます (例えば、ラベル、ボタン、メニュー)
。これらの場合では、Tk は画像への参照を保持しないでしょう。画像オブジ
ェクトへの最後の Python の参照が削除されたときに、画像データも削除され
ます。そして、どこで画像が使われていようとも、Tk は空の箱を表示します
。

参考: Pillow パッケージにより、 BMP, JPEG, TIFF, WebP などの形式のサポート
    が追加されました。


ファイルハンドラ
================

Tk を使うとコールバック関数の登録や解除ができ、ファイルディスクリプタ
に対する入出力が可能なときに、Tk のメインループからその関数が呼ばれま
す。 ファイルディスクリプタ1つにつき、1つだけハンドラは登録されます。
コード例です:

   import tkinter
   widget = tkinter.Tk()
   mask = tkinter.READABLE | tkinter.WRITABLE
   widget.tk.createfilehandler(file, mask, callback)
   ...
   widget.tk.deletefilehandler(file)

これらの機能は Windows では利用できません。

読み込みに使えるバイト数は分からないので、 "BufferedIOBase" クラスや
"TextIOBase" クラスの "read()" メソッドおよび "readline()" メソッドを
使おうとしないでください。これらは読み込みの際に、あらかじめ決められた
バイト数を要求するのです。ソケットには、 "recv()" や "recvfrom()" メソ
ッドを使うといいです。その他のファイルには、 raw 読み込みか
"os.read(file.fileno(), maxbytecount)" を使ってください。

Widget.tk.createfilehandler(file, mask, func)

   ファイルハンドラであるコールバック関数 *func* を登録します。 *file*
   引数は、 (ファイルやソケットオブジェクトのような) "fileno()" メソッ
   ドを持つオブジェクトか、整数のファイルディスクリプタとなります。
   *mask* 引数は、以下にある3つの定数の組み合わせの OR を取ったもので
   す。コールバックは次のように呼ばれます:

      callback(file, mask)

Widget.tk.deletefilehandler(file)

   ファイルハンドラの登録を解除します。

tkinter.READABLE
tkinter.WRITABLE
tkinter.EXCEPTION

   *mask* 引数で使う定数です。
