"tkinter" --- Tcl/Tk 파이썬 인터페이스
**************************************

**소스 코드:** 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 서버가 없는 유닉스/리눅스 시스템) 환경에서 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"
   세로 스크롤 막대가 내장된 Text 위젯.

"tkinter.simpledialog"
   기본 대화 상자와 편리 함수.

"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 창에서의 터틀(turtle) 그래픽.


Tkinter 구명조끼
================

이 절은 Tk나 Tkinter에 대한 철저한 자습서가 되고자 하는 것은 아닙니다.
오히려, 시스템에 관한 몇 가지 입문 오리엔테이션을 제공하는 임시방편입
니다.

크레딧:

* Tk는 John Ousterhout이 버클리에 있을 때 쓴 것입니다.

* Tkinter는 Steen Lumholt와 Guido van Rossum이 썼습니다.

* 이 구명조끼는 University of Virginia의 Matt Conway가 썼습니다.

* HTML 렌더링은, 그리고 일부 자유로운 편집과 함께, Ken Manheimer가
  FrameMaker 버전으로 제작했습니다.

* Fredrik Lundh는 클래스 인터페이스 설명을 다듬고 수정하여 Tk 4.2에서
  최신 버전으로 만들었습니다.

* Mike Clarkson은 설명서를 LaTeX로 변환하고, 레퍼런스 설명서의 사용자
  인터페이스 장을 엮었습니다.


이 절을 사용하는 방법
---------------------

이 절은 두 부분으로 구성되어 있습니다: 첫 번째 (대략) 절반은 배경 자료
를 다루고, 두 번째 절반은 따다 쓰기에 간편한 레퍼런스입니다.

"어쩌고를 어떻게 해야 합니까?"와 같은 형식의 질문에 대답하려 할 때, Tk
에서 직접 "어쩌고" 하는 법을 알아내고, 이것을 다시 해당 "tkinter" 호출
로 변환하는 것이 종종 최선입니다. 파이썬 프로그래머는 Tk 설명서를 보고
종종 올바른 파이썬 명령을 추측할 수 있습니다. 이것은 Tkinter를 사용하
려면 Tk에 대해 조금은 알고 있어야 한다는 뜻입니다. 이 문서가 그 소임을
수행하기는 부족하므로, 우리가 할 수 있는 최선은 존재하는 최고의 설명서
를 소개하는 것입니다. 여기 몇 가지 힌트가 있습니다:

* 저자는 Tk 매뉴얼 페이지의 복사본을 얻을 것을 강력히 제안합니다. 특히
  , "manN" 디렉터리의 매뉴얼 페이지가 가장 유용합니다. "man3" 매뉴얼
  페이지는 Tk 라이브러리에 대한 C 인터페이스를 설명하므로 스크립트 작
  성자에게 특별히 도움이 되지는 않습니다.

* Addison-Wesley는 초보자를 위한 Tcl과 Tk에 대한 훌륭한 소개인 John
  Ousterhout의 Tcl and the Tk Toolkit (ISBN 0-201-63337-X)이라는 책을
  출간합니다. 이 책은 모든 것을 다루지는 않으며, 많은 세부 사항은 매뉴
  얼 페이지에 위임합니다.

* "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 위젯은 단지 그것
의 *클래스(class)*, 그것을 구성하는 데 도움이 되는 *옵션(options)* 및
그것이 유용한 일을 하도록 하는 *액션(actions)*일 뿐입니다.

Tk에서 위젯을 만들려면, 명령은 항상 다음과 같은 형식입니다:

   classCommand newPathname options

*classCommand*
   어떤 종류의 위젯(버튼, 레이블, 메뉴...)을 만들지를 나타냅니다

*newPathname*
   이 위젯의 새 이름입니다. Tk의 모든 이름은 고유해야 합니다. 이 기능
   을 강제하기 위해, Tk의 위젯은 파일 시스템의 파일과 마찬가지로, *경
   로명(pathnames)*으로 이름이 지정됩니다. 최상위 수준 위젯, *루트
   (root)*, 는 "."(마침표)로 표현하고, 자식들은 더 많은 마침표로 구분
   합니다. 예를 들어, ".myApp.controlPanel.okButton"은 위젯의 이름일
   수 있습니다.

*options*
   위젯의 모양과 때에 따라 그 동작을 구성합니다. 옵션은 플래그와 값의
   목록 형태로 제공됩니다. 플래그는 유닉스 셸 명령 플래그처럼 '-'가 앞
   에 오고, 값이 두 단어 이상이면 값을 따옴표로 묶습니다.

예를 들면:

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

일단 만들어지면, 위젯에 대한 경로명이 새로운 명령이 됩니다. 이 새로운
*위젯 명령(widget command)*은 *액션(action)*을 수행할 새 위젯을 얻는
데 필요한 프로그래머의 손잡이입니다. C에서, 이것을 someAction(fred,
someOptions)로 표현하고, C++에서는, fred.someAction(someOptions)으로
표현하며, Tk에서는, 다음과 같이 표현합니다:

   .fred someAction someOptions

객체 이름 ".fred"가 점으로 시작함에 유의하십시오.

예상대로, *someAction*의 유효한 값은 위젯의 클래스에 따라 다릅니다:
".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에서 옵션은 인스턴스 생성자에서 키워드 인자로, 구성(configure)
호출에서는 키워드 인자로, 설정된 인스턴스에서는 딕셔너리 스타일의 인스
턴스 인덱스로 지정됩니다. 옵션 설정에 대해서는 옵션 설정 절을 참조하십
시오.

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

패커(packer)(지오메트리 관리자, geometry manager)에게 위젯을 전달하려
면, pack을 선택적 인자로 호출합니다. Tkinter에서, Pack 클래스는 이 모
든 기능을 담고 있으며, 다양한 형태의 pack 명령이 메서드로 구현됩니다.
"tkinter"의 모든 위젯은 Pack의 서브 클래스이므로, 모든 패킹 메서드를
상속받습니다. Form 지오메트리 관리자에 대한 추가 정보는 "tkinter.tix"
모듈 설명서를 참조하십시오.

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


Tk와 Tkinter의 관계
===================

위에서 아래로:

여러분의 응용 프로그램이 여기에 있습니다 (파이썬)
   파이썬 응용 프로그램이 "tkinter" 호출을 합니다.

tkinter (파이썬 패키지)
   이 호출(예를 들어, 버튼 위젯을 만든다고 합시다)은 파이썬으로 작성된
   "tkinter" 패키지에 구현되어 있습니다. 이 파이썬 함수는 명령과 인자
   를 구문 분석하여, 파이썬 스크립트 대신 Tk 스크립트에서 나온 것처럼
   보이는 형식으로 변환합니다.

_tkinter (C)
   이 명령과 인자는 "_tkinter" - 밑줄에 주목하세요 - 확장 모듈의 C 함
   수에 전달됩니다.

Tk 위젯 (C와 Tcl)
   이 C 함수는 Tk 라이브러리를 구성하는 C 함수를 포함하는 다른 C 모듈
   을 호출할 수 있습니다. Tk는 C와 약간의 Tcl로 구현됩니다. Tk 위젯의
   Tcl 부분은 어떤 기본 동작을 위젯에 연결하는 데 사용되며, 파이썬
   "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 매뉴얼 페이
지를 참조하십시오.

매뉴얼 페이지는 각 위젯에 대해 "표준 옵션(STANDARD OPTIONS)"과 "위젯
특정 옵션(WIDGET SPECIFIC OPTIONS)"을 나열합니다. 전자는 많은 위젯에
공통적인 옵션 목록이며, 후자는 그 위젯에만 적용되는 옵션입니다. 표준
옵션은 *options(3)* 매뉴얼 페이지에 설명되어 있습니다.

이 문서에서는 표준과 위젯 특정 옵션을 구분하지 않습니다. 일부 옵션은
일부 위젯에 적용되지 않습니다. 특정 위젯이 특정 옵션에 응답하는지는 위
젯의 클래스에 따라 다릅니다; 버튼에는 "command" 옵션이 있는데, 레이블
은 그렇지 않습니다.

주어진 위젯이 지원하는 옵션은 위젯의 매뉴얼 페이지에 나열되거나, 실행
시간에 인자 없이 "config()" 메서드를 호출하거나 해당 위젯에서 "keys()"
메서드를 호출하여 조회할 수 있습니다. 이러한 호출의 반환 값은 키가 옵
션의 이름인 문자열(예를 들어, "'relief'")이고 값이 5-튜플인 딕셔너리입
니다.

"bg"와 같은 일부 옵션은 긴 이름을 가진 공통 옵션의 동의어입니다 ("bg"
는 "background"의 줄임말입니다). "config()" 메서드에 줄인 옵션을 전달
하면 5-튜플이 아닌 2-튜플을 반환합니다. 전달된 2-튜플에는 동의어의 이
름과 "실제" 옵션이 담겨있습니다 (가령 "('bg', 'background')").

+---------+-----------------------------------+----------------+
| 인덱스  | 의미                              | 예             |
|=========|===================================|================|
| 0       | 옵션 이름                         | "'relief'"     |
+---------+-----------------------------------+----------------+
| 1       | 데이터베이스 조회를 위한 옵션 이  | "'relief'"     |
|         | 름                                |                |
+---------+-----------------------------------+----------------+
| 2       | 데이터베이스 조회를 위한 옵션 클  | "'Relief'"     |
|         | 래스                              |                |
+---------+-----------------------------------+----------------+
| 3       | 기본값                            | "'raised'"     |
+---------+-----------------------------------+----------------+
| 4       | 현재 값                           | "'groove'"     |
+---------+-----------------------------------+----------------+

예:

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

물론, 인쇄된 딕셔너리에는 사용 가능한 모든 옵션과 해당 값이 포함됩니다
. 이것은 예시일뿐입니다.


패커
----

패커(packer)는 Tk의 지오메트리 관리 메커니즘 중 하나입니다. 지오메트리
관리자는 컨테이너(위젯들의 공동 *master*) 내에서의 위젯의 상대 위치를
지정하는 데 사용됩니다. 더 성가신 *placer*(잘 사용되지 않고, 여기서는
다루지 않습니다) 와는 달리, 패커는 *위에*, *왼쪽에*, *채우기* 등의 정
성적(qualitative) 관계 규정을 취하고, 여러분을 위해 정확한 배치 좌표를
결정하기 위한 모든 작업을 수행합니다.

모든 *master* 위젯의 크기는 안에 있는 "슬레이브(slave) 위젯"의 크기에
의해 결정됩니다. 패커는 슬레이브 위젯이 패킹 되는 마스터 내부에 나타나
는 위치를 제어하는 데 사용됩니다. 원하는 배치를 얻기 위해 프레임에 위
젯을 팩하고, 프레임을 다른 프레임에 팩할 수 있습니다. 또한, 일단 팩 되
면, 점진적인 구성의 변경을 수용하기 위해 배치가 동적으로 조정됩니다.

위젯은 지오메트리 관리자로 지오메트리를 지정할 때까지 표시되지 않습니
다. 지오메트리 명세를 빠뜨리는 것은 초기에 흔한 실수이고, 위젯을 만들
었지만, 아무것도 나타나지 않을 때 놀라게 됩니다. 위젯은 예를 들어 패커
의 "pack()" 메서드가 적용된 후에만 나타납니다.

pack() 메서드는 컨테이너 내에서 위젯이 표시되는 위치와 메인 응용 프로
그램 윈도우의 크기가 조정될 때 어떻게 동작할지를 제어하는 키워드 옵션/
값 쌍으로 호출할 수 있습니다. 여기 몇 가지 예가 있습니다:

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


패커 옵션
---------

패커와 그것이 받을 수 있는 옵션에 대한 더 자세한 정보는 매뉴얼 페이지
와 John Ousterhout의 책의 183쪽을 참조하십시오.

anchor
   앵커(anchor)형. 패커가 각 슬레이브를 컨테이너에 넣을 위치를 나타냅
   니다.

expand
   불리언(boolean), "0" 또는 "1".

fill
   유효한 값: "'x'", "'y'", "'both'", "'none'".

ipadx와 ipady
   거리(distance) - 슬레이브 위젯의 각 변의 내부 패딩을 지정합니다.

padx와 pady
   거리(distance) - 슬레이브 위젯의 각 변의 외부 패딩을 지정합니다.

side
   유효한 값: "'left'", "'right'", "'top'", "'bottom'".


위젯 변수 결합하기
------------------

(텍스트 입력 위젯과 같은) 일부 위젯의 현재 값 설정은 특수 옵션을 사용
하여 응용 프로그램 변수에 직접 연결할 수 있습니다. 이 옵션은
"variable", "textvariable", "onvalue", "offvalue" 및 "value"입니다. 이
연결은 양방향으로 작동합니다: 어떤 이유로 든 변수가 변경되면, 연결된
위젯은 새 값을 반영하도록 갱신됩니다.

불행히도, "tkinter"의 현재 구현에서는 "variable" 또는 "textvariable"
옵션을 통해 임의의 파이썬 변수를 위젯으로 넘길 수 없습니다. 작동하는
유일한 종류의 변수는 "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()" 메서드를 호출하면 됩니다. 이 메서드는 이 함
수가 구현 일부이며, 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
   8개의 내장된, 이름있는 비트맵이 있습니다: "'error'", "'gray25'",
   "'gray50'", "'hourglass'", "'info'", "'questhead'", "'question'",
   "'warning'". X 비트맵 파일명을 지정하려면
   ""@/usr/contrib/bitmap/gumby.bit""처럼 "@"를 앞에 붙인 파일의 전체
   경로를 지정하십시오.

boolean
   정수 0이나 1 또는 문자열 ""yes""나 ""no""를 전달할 수 있습니다.

callback
   인자를 취하지 않는 파이썬 함수입니다. 예를 들면:

      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
   "XC_" 접두사 없이 "cursorfont.h"의 표준 X 커서 이름을 사용할 수 있
   습니다. 예를 들어, 손 모양 커서("XC_hand2")를 얻으려면, ""hand2""
   문자열을 사용하십시오. 여러분 자신의 비트맵과 마스크 파일을 지정할
   수도 있습니다. Ousterhout의 책 179쪽을 보십시오.

distance
   화면 거리는 픽셀이나 절대 거리로 지정할 수 있습니다. 픽셀은 숫자로
   절대 거리는 문자열로 지정되며, 끝에 붙는 문자는 단위를 나타냅니다:
   "c"는 센티미터, "i"는 인치, "m"은 밀리미터, "p"는 프린터의 포인트입
   니다. 예를 들어, 3.5 인치는 ""3.5i""로 표현됩니다.

font
   Tk는 "{courier 10 bold}"와 같은, 목록 글꼴 이름 형식을 사용합니다.
   양수로 표현된 글꼴 크기는 포인트로 측정됩니다; 음수로 표현된 크기는
   픽셀 단위로 측정됩니다.

geometry
   이것은 "너비x높이" 형식의 문자열로, 대부분의 위젯에서 너비와 높이는
   픽셀 단위로 측정됩니다 (텍스트를 표시하는 위젯에서는 문자 단위). 예
   를 들어: "fred["geometry"] = "200x100"".

justify
   유효한 값은 문자열입니다: ""left"", ""center"", ""right"" 및
   ""fill"".

region
   이것은 스페이스로 구분된 네 개의 요소가 있는 문자열이며, 각 요소는
   유효한 거리(위를 참조하세요)입니다. 예를 들어: ""2 3 4 5""와 ""3i
   2i 4.5i 2i""와 ""3c 2c 4c 10.43c""는 모두 유효한 영역(region)입니다
   .

relief
   위젯의 테두리 스타일을 결정합니다. 유효한 값은 다음과 같습니다:
   ""raised"", ""sunken"", ""flat"", ""groove"" 및 ""ridge"".

scrollcommand
   이것은 거의 항상 어떤 스크롤 막대 위젯의 "set()" 메서드이지만, 단일
   인자를 취하는 어떤 위젯 메서드도 가능합니다.

wrap
   ""none"", ""char"" 또는 ""word"" 중 하나여야 합니다.


바인딩과 이벤트
---------------

위젯 명령의 bind 메서드를 사용하면 특정 이벤트를 감시하고 해당 이벤트
유형이 발생할 때 콜백 함수가 트리거 되도록 할 수 있습니다. bind 메서드
의 형식은 다음과 같습니다:

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

여기에서:

sequence
   는 대상 이벤트의 종류를 나타내는 문자열입니다. (자세한 내용은 bind
   매뉴얼 페이지와 John Ousterhout의 책의 201쪽을 참조하십시오).

func
   는 하나의 인자를 취하는 파이썬 함수로, 이벤트가 발생할 때 호출됩니
   다. 이벤트 인스턴스가 인자로 전달됩니다. (이런 식으로 설치되는 함수
   를 흔히 *콜백(callbacks)*이라고 합니다.)

add
   는 선택적이고, "''"나 "'+'"입니다. 빈 문자열을 전달하면 이 바인딩이
   이 이벤트와 연관된 다른 바인딩을 대체 함을 나타냅니다. "'+'"를 전달
   하면 이 함수가 이 이벤트 유형에 바인딩 된 함수 목록에 추가됩니다.

예를 들면:

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

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

이벤트의 widget 필드가 "turn_red()" 콜백에서 어떻게 액세스 되는지 주목
하십시오. 이 필드는 X 이벤트를 포착한 위젯을 포함합니다. 다음 표에는
사용자가 액세스할 수 있는 다른 이벤트 필드와 Tk에서 이들을 표시하는 방
법이 나열되어 있습니다. Tk 매뉴얼 페이지를 참조할 때 유용할 수 있습니
다.

+------+-----------------------+------+-----------------------+
| Tk   | Tkinter 이벤트 필드   | Tk   | Tkinter 이벤트 필드   |
|======|=======================|======|=======================|
| %f   | focus                 | %A   | char                  |
+------+-----------------------+------+-----------------------+
| %h   | height                | %E   | send_event            |
+------+-----------------------+------+-----------------------+
| %k   | keycode               | %K   | keysym                |
+------+-----------------------+------+-----------------------+
| %s   | state                 | %N   | keysym_num            |
+------+-----------------------+------+-----------------------+
| %t   | time                  | %T   | type                  |
+------+-----------------------+------+-----------------------+
| %w   | width                 | %W   | widget                |
+------+-----------------------+------+-----------------------+
| %x   | x                     | %X   | x_root                |
+------+-----------------------+------+-----------------------+
| %y   | y                     | %Y   | y_root                |
+------+-----------------------+------+-----------------------+


index 매개 변수
---------------

많은 위젯에는 "index" 매개 변수가 전달되어야 합니다. 이들은 Text 위젯
의 특정 위치, Entry 위젯의 특정 문자 또는 Menu 위젯의 특정 메뉴 항목을
가리키는 데 사용됩니다.

Entry 위젯 인덱스 (인덱스, 뷰 인덱스 등)
   Entry 위젯에는 표시되는 텍스트의 문자 위치를 참조하는 옵션이 있습니
   다. 다음 "tkinter" 함수를 사용하여 텍스트 위젯에서 이러한 특수 지점
   에 액세스할 수 있습니다:

Text 위젯 인덱스
   Text 위젯의 인덱스 표기법은 매우 풍부하며 Tk 매뉴얼 페이지에 자세히
   설명되어 있습니다.

메뉴 인덱스 (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는
이미지에 대한 참조를 유지하지 않습니다. 이미지 객체에 대한 마지막 파이
썬 참조가 삭제되면 이미지 데이터도 삭제되고, Tk는 이미지가 사용된 곳마
다 빈 상자를 표시합니다.

더 보기: Pillow 패키지는 BMP, JPEG, TIFF 및 WebP와 같은 형식을 위한 지원을 추
      가합니다.


파일 처리기
===========

Tk는 파일 기술자에서 I/O가 가능할 때 Tk 메인 루프에서 호출할 콜백 함수
를 등록하고 등록 취소할 수 있도록 합니다. 파일 기술자당 하나의 처리기
만 등록 될 수 있습니다. 예제 코드:

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

윈도우에서는 이 기능을 사용할 수 없습니다.

얼마나 많은 바이트를 읽을 수 있는지 모르므로, "BufferedIOBase"나
"TextIOBase" "read()"나 "readline()" 메서드를 사용하고 싶지 않을것입니
다, 이것들은 미리 정의 된 바이트 수를 읽으려고하기 때문입니다. 소켓의
경우, "recv()" 또는 "recvfrom()" 메서드가 제대로 작동합니다; 다른 파일
의 경우, 날(raw) 읽기나 "os.read(file.fileno(), maxbytecount)"를 사용
하십시오.

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

   파일 처리기 콜백 함수 *func*를 등록합니다. *file* 인자는 "fileno()"
   메서드가 있는 객체이거나(가령 파일이나 소켓 객체), 정수 파일 기술자
   일 수 있습니다. *mask* 인자는 아래의 세 가지 상수들을 OR로 조합한
   것입니다. 콜백은 다음과 같이 호출됩니다:

      callback(file, mask)

Widget.tk.deletefilehandler(file)

   파일 처리기를 등록 취소합니다.

tkinter.READABLE
tkinter.WRITABLE
tkinter.EXCEPTION

   *mask* 인자에 사용되는 상수입니다.
