PyGTK-퀵 가이드

PyGTK는 GTK + GUI 라이브러리를 위해 Python 및 C로 작성된 래퍼 세트입니다. 그놈 프로젝트의 일부입니다. Python으로 데스크톱 애플리케이션을 구축하기위한 포괄적 인 도구를 제공합니다. 다른 인기있는 GUI 라이브러리에 대한 Python 바인딩도 사용할 수 있습니다.

PyQtQT 라이브러리의 Python 포트입니다. PyQt 튜토리얼을 찾을 수 있습니다.here. 마찬가지로 wxPython 툴킷은 또 다른 인기있는 크로스 플랫폼 GUI 라이브러리 인 wxWidgets에 대한 Python 바인딩입니다. wxPython 자습서를 사용할 수 있습니다.here.

GTK+또는 GIMP Toolkit은 그래픽 사용자 인터페이스를 만들기위한 다중 플랫폼 툴킷입니다. 완전한 위젯 세트를 제공하는 GTK +는 작은 일회성 도구에서 완전한 애플리케이션 제품군에 이르는 다양한 프로젝트에 적합합니다.

GTK +는 광범위한 언어를 지원하도록 처음부터 설계되었습니다. PyGTK는 GTK + 용 Python 래퍼입니다.

GTK +는 다음 4 개의 라이브러리를 중심으로 구축됩니다.

  • Glib− GTK +의 기반을 형성하는 저수준 코어 라이브러리. C에 대한 데이터 구조 처리를 제공합니다.

  • Pango − 국제화에 중점을 둔 텍스트 레이아웃 및 렌더링을위한 라이브러리.

  • Cairo − 여러 출력 장치 (X Window System, Win32 포함)를 지원하는 2D 그래픽 용 라이브러리

  • ATK − 화면 판독기, 돋보기 및 대체 입력 장치와 같은 접근성 도구를 제공하는 인터페이스 세트를위한 라이브러리.

PyGTK는 프로세스를 용이하게하고 Python 프로그래밍 언어를 사용하는 그래픽 사용자 인터페이스로 프로그램을 생성하도록 도와줍니다. 기본 GTK + 라이브러리는 그놈 데스크탑을위한 모든 기능을 갖춘 응용 프로그램을 개발할 수 있도록 모든 종류의 시각적 요소와 유틸리티를 제공합니다. PyGTK는 크로스 플랫폼 라이브러리입니다. LGPL 라이선스에 따라 배포되는 무료 소프트웨어입니다.

PyGTK는 GTK + 2.x를 중심으로 구축되었습니다. GTK +3 용 애플리케이션을 빌드하기 위해 PyGObject 바인딩도 사용할 수 있습니다.

Microsoft Windows 용 PyGTK

Microsoft Windows 용 PyGTK 설치에는 다음 단계가 포함됩니다.

  • Step 1 − 32 비트 Python 인터프리터 설치 (최신 Python 2.7 배포)

  • Step 2 − GTK + 런타임을 다운로드하여 설치합니다.

  • Step 3 − GTK + 런타임 다운로드 및 설치 −https://ftp.gnome.org

  • Step 4 − 또한 다음 URL에서 PyCairo 및 PyGobject 모듈을 다운로드하는 것이 좋습니다. − https://ftp.gnome.org https://ftp.gnome.org/pub

  • Step 5− 편의를 위해 모든 PyGTK 종속성을 처리하는 올인원 설치 프로그램도 사용할 수 있습니다. 다음 URL에서 Windows 용 최신 올인원 설치 프로그램을 다운로드하여 설치하십시오.https://ftp.gnome.org/pub/GNOME

Linux 용 PyGTK

PyGTK는 대부분의 Linux 배포판 (Debian, Fedora, Ubuntu, RedHat 등 포함)에 포함되어 있습니다. 다음 URL에서 소스 코드를 다운로드하고 컴파일 할 수도 있습니다.

https://ftp.gnome.org/pub/GNOME/sources/pygtk/2.24/

PyGTK를 사용하여 창을 만드는 것은 매우 간단합니다. 계속하려면 먼저 코드에서 gtk 모듈을 가져와야합니다.

import gtk

gtk 모듈은 gtk.Window 클래스를 포함합니다. 객체는 최상위 창을 구성합니다. gtk.Window에서 클래스를 파생합니다.

class PyApp(gtk.Window):

생성자를 정의하고 show_all() gtk.window 클래스의 메소드.

def __init__(self):
   super(PyApp, self).__init__()
   self.show_all()

이제이 클래스의 객체를 선언하고 main () 메서드를 호출하여 이벤트 루프를 시작해야합니다.

PyApp()
gtk.main()

라벨을 추가하는 것이 좋습니다. “Hello World” 부모 창에서.

label = gtk.Label("Hello World")
self.add(label)

다음은 표시 할 전체 코드입니다. “Hello World”

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_default_size(300,200)
      self.set_title("Hello World in PyGTK")
      label = gtk.Label("Hello World")
      self.add(label)
      self.show_all()
PyApp()
gtk.main()

위의 코드를 구현하면 다음과 같은 출력이 생성됩니다.

PyGTK 모듈에는 다양한 위젯이 포함되어 있습니다. gtk.Object 클래스는 대부분의 위젯과 일부 비 위젯 클래스의 기본 클래스로 작동합니다. PyGTK를 사용하는 데스크톱 애플리케이션의 최상위 창은 gtk.Window 클래스에서 제공합니다. 다음 표는 중요한 위젯과 그 기능을 나열합니다.

S.NO 클래스 및 설명
1

gtk.Widget

이것은 모든 PyGTK 위젯을위한 gtk.base 클래스입니다. gtk.Widget은 위젯에 대한 공통 메소드 및 신호 세트를 제공합니다.

2

gtk.Window

이것은 하나의 하위 위젯을 보유하는 최상위 창입니다. gtk.Window는 제목 표시 줄과 사용자가 창을 닫고 크기를 조정하고 이동할 수있는 항목으로 장식 된 표시 영역입니다.

gtk.Button

클릭하면 신호를 보내는 푸시 버튼 위젯입니다. gtk.Button은 일반적으로 텍스트 레이블이있는 푸시 버튼으로 표시되며 일반적으로 콜백 함수를 첨부하는 데 사용됩니다.

4

gtk.Entry

이것은 한 줄 텍스트 입력 위젯입니다.

5

gtk.Label

이 위젯은 제한된 양의 읽기 전용 텍스트를 표시합니다.

6

gtk.ButtonBox

여러 버튼을 포함하는 위젯의 기본 클래스입니다.

7

gtk.HBox

하위 위젯을 단일 가로 행으로 구성하는 컨테이너입니다.

8

gtk.VBox

하위 위젯을 단일 열로 구성하는 컨테이너입니다.

9

gtk.Fixed

픽셀 단위로 고정 된 위치에 고정 된 크기로 자식 위젯을 배치 할 수있는 컨테이너입니다.

10

gtk.Layout

이는 하위 위젯 및 사용자 정의 도면을 포함하는 무한 스크롤 가능 영역을 제공합니다.

11

gtk.MenuItem

이 위젯은 메뉴 항목의 모양과 동작을 구현합니다. gtk.MenuItem의 파생 된 위젯 하위 클래스는 메뉴의 유일한 유효한 자식입니다. 사용자가 선택하면 팝업 메뉴를 표시하거나 관련 함수 또는 메서드를 호출 할 수 있습니다.

12

gtk.Menu

이것은 사용자가 응용 프로그램 기능을 수행하기 위해 탐색하고 활성화 할 수있는 MenuItem 개체 목록으로 구성된 드롭 다운 메뉴입니다.

13

gtk.MenuBar

이렇게하면 응용 프로그램 창이나 대화 상자에 메뉴 항목이 가로로 표시됩니다.

14

gtk.ComboBox

이 위젯은 항목 목록에서 선택하는 데 사용됩니다.

15

gtk.Scale

숫자 값을 선택하기위한 수평 또는 수직 슬라이더 컨트롤입니다.

16

gtk.Scrollbar

수평 또는 수직 스크롤바를 표시합니다.

17

gtk.ProgressBar

장기 실행 작업의 진행 상황을 표시하는 데 사용됩니다.

18

gtk.Dialog

사용자 정보 및 작업에 대한 팝업 창이 표시됩니다.

19

gtk.Notebook

이 위젯은 탭 레이블 사용간에 전환 할 수있는 겹치는 페이지가있는 하위 컨테이너입니다.

20

gtk.Paned

가로 또는 세로로 배열 된 두 개의 창이있는 위젯의 기본 클래스입니다. 하위 위젯이 위젯 창에 추가됩니다. 두 자녀의 구분은 사용자가 조정할 수 있습니다.

21

gtk.TextView

이 위젯은 TextBuffer 객체의 내용을 표시합니다.

22

gtk.Toolbar

이 컨테이너는 가로 또는 세로 막대에서 일련의 버튼과 위젯을 보유하고 관리합니다.

23

gtk.TreeView

이 위젯은 표준 TreeModel (ListStore, TreeStore, TreeModelSort)의 내용을 표시합니다.

24

gtk.DrawingArea

이 위젯은 사용자 정의 사용자 인터페이스 요소를 만드는 데 도움이됩니다. gtk.DrawingArea는 기본적으로 그릴 수있는 창을 포함하는 빈 위젯입니다.

25

gtk.Calendar

이 위젯은 달력을 표시하고 사용자가 날짜를 선택할 수 있도록합니다.

26

gtk.Viewport

이 위젯은 더 큰 위젯의 일부를 표시합니다.

gtk.Window 클래스의 객체는 사용자가 일반적으로 Wwindow라고 생각하는 위젯을 제공합니다. 이 위젯은 컨테이너이므로 하나의 하위 위젯을 보유 할 수 있습니다. 제목 표시 줄과 크기 조정 컨트롤로 장식 된 표시 가능 영역을 제공합니다.

gtk.Window 클래스에는 다음과 같은 생성자가 있습니다.

gtk.Window(type)

유형 매개 변수는 다음 값 중 하나를 사용합니다.

gtk.WINDOW_TOPLEVEL (기본값) 이 창에는 부모가 없습니다. 최상위 창은 기본 응용 프로그램 창 및 대화 상자입니다.
gtk.WINDOW_POPUP 이 창에는 프레임이나 장식이 없습니다. 팝업 창은 메뉴 및 도구 설명에 사용됩니다.

gtk.Window 클래스의 중요한 메소드는 다음과 같습니다.

S.NO 방법 및 설명
1

set_title(string)

이것은 gtk.window의 "title"속성을 다음에 의해 지정된 값으로 설정합니다. title. 창의 제목이 제목 표시 줄에 표시됩니다.

2

get_title()

설정된 경우 창의 제목을 반환합니다.

set_position()

창의 위치를 ​​설정합니다. 미리 정의 된 위치 상수는-

  • gtk.WIN_POS_NONE

  • gtk.WIN_POS_CENTER

  • gtk.WIN_POS_MOUSE

  • gtk.WIN_POS_CENTER_ALWAYS

  • gtk.WIN_POS_CENTER_ON_PARENT

set_focus()

이는 창에 대한 포커스 위젯으로 지정된 위젯을 설정합니다.

4

set_resizable()

이것은 기본적으로 true입니다. set_resizable ()은 사용자가 창의 크기를 설정하도록 도와줍니다.

5

set_decorated()

이것은 기본적으로 true입니다. false이면 제목 표시 줄과 창의 크기 조정 컨트롤이 비활성화됩니다.

6

set_modal()

true이면 창이 모달이되고 다른 창과의 상호 작용이 차단됩니다. 이것은 Dialog 위젯에 사용됩니다.

7

set_default_size()

이렇게하면 창의 기본 크기가 지정된 너비와 높이 (픽셀)로 설정됩니다.

gtk.Window 위젯은 다음 신호를 내 보냅니다.

활성화 기본값 이는 일반적으로 사용자가 Return 또는 Enter 키를 눌러 창의 기본 자식 위젯을 활성화 할 때 발생합니다.
활성화 초점 일반적으로 사용자가 Space 키를 눌러 포커스가있는 자식 위젯이 활성화 될 때 발생합니다.
이동 초점 이는 사용자가 Tab, Shift + Tab 또는 위쪽, 아래쪽, 왼쪽 또는 오른쪽 화살표 키를 누를 때 창의 자식 위젯 내에서 포커스가 변경 될 때 발생합니다.
세트 포커스 초점이 다음으로 변경 될 때 발생합니다. widgetwindow.

gtk.Button 위젯은 일반적으로 텍스트 레이블이있는 푸시 버튼으로 표시됩니다. 일반적으로 버튼을 클릭 할 때 호출되는 콜백 함수 또는 메서드를 첨부하는 데 사용됩니다.

gtk.Button 클래스에는 다음과 같은 생성자가 있습니다.

gtk.Button(label = None, stock = None, use_underline = True)

여기서

  • Label − 버튼 레이블로 표시 할 텍스트

  • Stock− 버튼에 사용할 스톡 이미지와 텍스트를 식별하는 스톡 ID입니다. 기본값은 없음입니다.

  • Underline − True 인 경우 텍스트의 밑줄은 다음 문자에 밑줄이 표시되고 니모닉 가속기에 사용되어야 함을 나타냅니다.

주식 매개 변수에 대해 미리 정의 된 상수 중 일부는-

  • STOCK_OK
  • STOCK_STOP
  • STOCK_YES
  • STOCK_NO
  • STOCK_QUIT
  • STOCK_CANCEL
  • STOCK_CLOSE

Button 클래스에는 다음과 같은 중요한 메서드가 있습니다.

S.NO 방법 및 설명
1

set_label()

버튼 레이블의 텍스트를 레이블로 설정합니다. 이 문자열은 "use_stock"속성이 True 인 경우 재고 항목을 선택하는데도 사용됩니다.

2

get_label()

버튼의 레이블에서 텍스트를 검색합니다.

set_focus_on_click()

True 인 경우 마우스로 클릭하면 버튼이 포커스를 잡습니다.

4

set_alignment()

이것은 자식 위젯의 수평 및 수직 정렬입니다. 값의 범위는 0.0에서 1.0입니다.

5

set_image()

이것은 image 속성을 image의 값으로 설정합니다. "gtkbutton-images"속성은 True로 설정해야합니다.

다음 신호는 버튼 위젯에 의해 방출됩니다-

활성화 이것은 gtk.Widget이 activate()메서드가 호출됩니다. 버튼의 경우 "클릭 됨"신호가 방출됩니다.
클릭 포인터가 버튼 위에있는 동안 마우스 버튼을 눌렀다 놓을 때 또는 키보드로 버튼을 트리거 할 때 발생합니다.

레이블 위젯은 편집 할 수없는 텍스트를 표시하는 데 유용합니다. 레이블은 내부적으로 다른 많은 위젯에서 사용됩니다. 예를 들어 Button에는 얼굴에 텍스트를 표시하는 레이블이 있습니다. 마찬가지로 MenuItem 개체에는 레이블이 있습니다. 레이블은 창없는 개체이므로 이벤트를 직접받을 수 없습니다.

Label 클래스에는 간단한 생성자가 있습니다.

gtk.Label(str = None)

다음과 같은 유용한 방법은 Label 객체와 함께 사용할 수 있습니다.

S.NO 방법 및 설명
1

set_text()

새 텍스트를 레이블로 설정합니다.

2

get_text()

레이블에서 텍스트를 반환합니다.

set_use_underline()

true 인 경우 텍스트의 밑줄은 니모닉 액셀러레이터 키로 다음 문자를 사용해야 함을 나타냅니다.

4

set_justify

이렇게하면 레이블 텍스트의 줄 정렬이 서로 상대적으로 설정됩니다.

가능한 값은 – gtk.JUSTIFY_LEFT, gtk.JUSTIFY_RIGHT, gtk.JUSTIFY_CENTER 및 gtk.JUSTIFY_FILL입니다.

5

Set_line_wrap()

참이면 줄 바꿈

6

set_selectable()

true 인 경우 레이블의 텍스트를 복사하여 붙여 넣기로 선택할 수 있습니다.

7

set_width_chars()

라벨의 너비를 설정합니다.

다음 신호는 레이블 위젯에 의해 방출됩니다-

현재 링크 활성화 이것은 사용자가 레이블에서 링크를 활성화 할 때 발생합니다.
링크 활성화 이것은 URI를 활성화하기 위해 방출됩니다.
클립 보드 복사 이것은 텍스트가 레이블에서 클립 보드로 복사 될 때 방출됩니다.

입력 위젯은 한 줄 텍스트 입력 위젯입니다. 입력 한 텍스트가 위젯 할당보다 길면 위젯이 스크롤되어 커서 위치가 표시됩니다.

이 클래스의 set_visibility () 메서드를 사용하여 입력 필드를 암호 모드로 변환 할 수 있습니다. 입력 된 텍스트는 invisible_char () 메서드에서 선택한 문자로 대체되며 기본값은 '*'입니다.

Entry 클래스에는 다음과 같은 생성자가 있습니다.

gtk.Entry(max = 0)

여기서 max는 입력 필드의 최대 길이 (문자)를 나타냅니다. 매개 변수는 숫자 값 (0-65536)을 사용합니다.

다음 표는 엔트리 클래스의 중요한 방법을 보여줍니다-

S.NO 방법 및 설명
1

set_visibility(visible)

false 인 경우 문자를 기본 보이지 않는 문자 인 '*'로 대체하여 내용을가립니다.

2

set_invisible_char(char)

입력 필드의 기본 '*'문자는 char로 대체됩니다.

set_max_length(x)

그러면 "max-length"속성이 x 값으로 설정됩니다. (0-65536)

4

set_text(str)

이렇게하면 "text"속성이 다음 값으로 설정됩니다. str. 문자열str 항목의 현재 내용을 바꿉니다.

5

get_text()

이것은 항목의 내용을 포함하는 문자열 인 "text"속성의 값을 반환합니다.

6

set_alignment()

그러면 "xalign"속성이 다음 값으로 설정됩니다. xalign. set_alignment ()는 항목 필드에서 컨텐츠의 수평 위치를 제어합니다.

다음 신호는 항목 위젯에 의해 방출됩니다-

활성화 이것은 항목이 사용자 작업에 의해 활성화되거나 프로그래밍 방식으로 활성화 될 때 발생합니다. gtk.Widget.activate() 방법.
역행 키이 이것은 Backspace 키는 키보드에서 입력됩니다.
클립 보드 복사 항목의 선택 텍스트가 클립 보드에 복사 될 때 발생합니다.
절단 클립 보드 항목의 선택 항목을 잘라내어 클립 보드에 넣을 때 발생합니다.
클립 보드 붙여 넣기 클립 보드의 내용을 항목에 붙여 넣을 때 발생합니다.

순차적으로 실행되는 콘솔 모드 애플리케이션과 달리 GUI 기반 애플리케이션은 이벤트 기반입니다. 그만큼gtk.main()함수는 무한 루프를 시작합니다. GUI에서 발생하는 이벤트는 적절한 콜백 함수로 전송됩니다.

GObject 클래스에서 파생 된 각 PyGTK 위젯은 ‘signal’하나 이상의 이벤트에 대한 응답. 신호 자체는 어떤 작업도 수행하지 않습니다. 대신 콜백 함수에 '연결'됩니다.

일부 신호는 위젯에 의해 상속되는 반면 일부 신호는 위젯에 따라 다릅니다. 예를 들어 "toggled"신호는 toggleButton 위젯에서 내 보냅니다.

신호 처리기는 다음을 호출하여 설정됩니다. connect() gtk.widget 클래스의 메소드.

handler_id = object.connect(name, func, func_data)
  • 첫 번째 주장, name, 포착하려는 신호의 이름이 포함 된 문자열입니다.

  • 두 번째 주장은 func, 잡았을 때 호출하고자하는 콜백 함수입니다.

  • 세 번째 주장, func_data,이 함수로 전달할 데이터입니다.

  • 콜백 메소드를 고유하게 식별하는 데 사용되는 핸들러 ID입니다.

예를 들어, 버튼을 클릭 할 때 onClicked () 함수를 호출하려면 다음 구문을 사용하십시오.

btn.connect("clicked",onClicked,None)

onClicked () 함수는 다음과 같이 정의됩니다.

def onClicked(widget, data=None):

콜백 메소드가 객체 메소드이면 self를 추가 인수로받습니다.

def onClicked(self, widget, data=None):

다음 예제에서는 버튼이 gtk.Window에 추가됩니다. 버튼을 클릭하면“Hello World”메시지가 출력됩니다.

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Hello World in PyGTK")
      self.set_default_size(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
		
      self.label = gtk.Label("Enter name")
      self.entry = gtk.Entry()
		
      self.btn = gtk.Button("Say Hello")
      self.btn.connect("clicked",self.hello)
		
      fixed = gtk.Fixed()
      fixed.put(self.label, 100,100)
      fixed.put(self.entry, 100,125)
      fixed.put(self.btn,100,150)
		
      self.add(fixed)
      self.show_all()
		
   def hello(self,widget):
      print "hello",self.entry.get_text()
PyApp()
gtk.main()

Python 프롬프트에서 위 코드를 실행합니다. 다음 출력이 표시됩니다-

버튼을 누르면 다음 출력이 콘솔에 표시됩니다.

Hello TutorialsPoint

신호 메커니즘 외에도 윈도우 시스템 이벤트를 콜백 함수에 연결할 수 있습니다. 창 크기 조정, 키 누르기, 스크롤 이벤트 등은 일반적인 창 시스템 이벤트 중 일부입니다. 이러한 이벤트는 애플리케이션의 메인 루프에보고됩니다. 거기에서 신호를 통해 콜백 함수로 전달됩니다.

시스템 이벤트 중 일부는 다음과 같습니다.

  • button_press_event
  • button_release_event
  • scroll_event
  • motion_notify_event
  • delete_event
  • destroy_event
  • expose_event
  • key_press_event
  • key_release_event

connect () 메서드는 구문에 따라 이벤트를 콜백 함수와 연결하는 데 사용됩니다.

Object.connect(name, function, data)

여기서 name은 캡처 할 이벤트의 이름에 해당하는 문자열을 의미합니다. 과,function 의 이름입니다 callback이벤트 발생시 호출되는 함수입니다. 데이터는 콜백 함수에 전달되는 인수입니다.

따라서 다음 코드는 Button 위젯을 연결하고 button_press 이벤트를 캡처합니다.

self.btn.connect("button_press_event", self.hello)

다음은 hello () 함수의 프로토 타입입니다.

def hello(self,widget,event):

다음은 버튼 이벤트 핸들러의 코드입니다.

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Hello World in PyGTK")
      self.set_default_size(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
		
      self.label = gtk.Label("Enter name")
      self.entry = gtk.Entry()
      self.btn = gtk.Button("Say Hello")
      self.btn.connect("button_press_event", self.hello)
		
      fixed = gtk.Fixed()
      fixed.put(self.label, 100,100)
      fixed.put(self.entry, 100,125)
      fixed.put(self.btn,100,150)
		
      self.add(fixed)
      self.show_all()
		
   def hello(self,widget,event):
      print "hello",self.entry.get_text()

PyApp()
gtk.main()

위의 코드를 실행하면 콘솔에 다음 출력이 표시됩니다.

Hello TutorialsPoint

PyGTK 라이브러리는 창 내부의 위젯 배치를 제어하기 위해 다양한 컨테이너 클래스를 제공합니다. 가장 쉬운 방법은fixed container class 픽셀 단위로 측정 된 절대 좌표를 지정하여 위젯을 그 안에 배치합니다.

이제 다음 단계를 따르십시오.

Step 1 −의 개체를 선언 fixed class

fixed = gtk.Fixed()

Step 2 − 버튼 위젯을 생성하고 다음을 사용하여 고정 컨테이너에 추가합니다. put()x 및 y 좌표가 필요한 메서드. 여기서 버튼은 (100,100) 위치에 배치됩니다.

btn = gtk.Button("Hello")
fixed.put(btn, 100,100)

Step 3− 고정 된 컨테이너에 여러 컨트롤을 배치 할 수 있습니다. 그리고이를 최상위 창에 추가하고show_all() 방법

self.add(fixed)
self.show_all()

그러나이 절대 레이아웃은 다음과 같은 이유로 적합하지 않습니다.

  • 창 크기를 조정해도 위젯의 위치는 변경되지 않습니다.
  • 해상도가 다른 다른 디스플레이 장치에서는 모양이 균일하지 않을 수 있습니다.
  • 전체 양식을 다시 디자인해야 할 수 있으므로 레이아웃 수정이 어렵습니다.

다음은 original window

다음은 resized window

여기서 버튼의 위치는 변경되지 않습니다.

PyGTK API는 컨테이너 내부의 위젯 위치 관리를 강화하기위한 컨테이너 클래스를 제공합니다. 절대 위치보다 레이아웃 관리자의 장점은 다음과 같습니다.

  • 창 안의 위젯은 자동으로 크기가 조정됩니다.
  • 해상도가 다른 디스플레이 장치에서 균일 한 외관을 보장합니다.
  • 재 설계하지 않고도 위젯을 동적으로 추가하거나 제거 할 수 있습니다.

gtk.Container는 다음 클래스의 기본 클래스로 작동합니다.

  • gtk.ButtonBox
  • gtk.Box
  • gtk.Alignment
  • gtk.EventBox
  • gtk.Table

gtk.Box 클래스는 위젯이 직사각형 영역에 배치되는 컨테이너의 기능을 정의하는 추상 클래스입니다. gtk.HBox 및 gtk.VBox 위젯은 여기에서 파생됩니다.

gtk.Hbox의 하위 위젯은 동일한 행에 가로로 배열됩니다. 반면에 gtk.VBox의 자식 위젯은 같은 열에 세로로 배열됩니다.

gtk.Box 클래스는 다음 생성자를 사용합니다.

gtk.Box(homogenous = True, spacing = 0)

동종 속성은 기본적으로 True로 설정됩니다. 결과적으로 모든 하위 위젯에 동일한 할당이 제공됩니다.

gtk.Box는 패킹 메커니즘을 사용하여 시작 또는 끝을 참조하여 특정 위치를 참조하여 하위 위젯을 배치합니다. pack_start () 메서드는 위젯을 처음부터 끝까지 배치합니다. 반대로 pack_end () 메서드는 위젯을 끝에서 시작으로 배치합니다. 또는 pack_start ()와 유사한 add () 메서드를 사용할 수 있습니다.

다음 메소드는 gtk.HBox 및 gtk.VBox에 사용할 수 있습니다.

  • gtk_box_pack_start ()

  • gtk_box_pack_end ()

gtk_box_pack_start ()

이 방법은 child 상자의 시작 부분을 참조하여 포장 됨-

pack_start(child, expand = True, fill = True, padding = 0)

다음은 매개 변수입니다-

  • child − 상자에 추가 할 위젯 개체입니다.

  • expand− 어린이에게 상자에 추가 공간이 주어지면 True로 설정됩니다. 추가 공간은 모든 어린이에게 나뉩니다.widgets.

  • fill− True이면 추가 공간이 자식에게 할당됩니다. 그렇지 않으면이 매개 변수가 패딩으로 사용됩니다.

  • padding − 상자에서 위젯 사이의 픽셀 단위 공간입니다.

gtk_box_pack_end ()

이것은 상자의 끝을 참조하여 포장 된 상자에 자식을 추가합니다.

pack_end (child, expand = True, fill = True, padding = 0)

다음은 매개 변수입니다-

  • child − 추가 할 위젯 개체입니다.

  • expand− 어린이에게 상자에 추가 공간이 주어지면 True로 설정됩니다. 이 추가 공간은 모든 하위 위젯으로 나뉩니다.

  • fill − True이면 추가 공간이 자식에게 할당되며 그렇지 않으면 패딩으로 사용됩니다.

  • padding − 상자에있는 위젯 사이의 공간 (픽셀 단위)입니다.

set_spacing (spacing) 상자의 자식 사이에 배치 할 픽셀 수를 설정하는 함수입니다.

방법 add (widget)gtk.Container 클래스에서 상속됩니다. 컨테이너에 위젯을 추가합니다. 이 메서드는 pack_start () 메서드 대신 사용할 수 있습니다.

아래 주어진 예에서 최상위 창에는 세로 상자 (gtk.VBox 개체 상자)가 있습니다. 차례로 VBox 객체 vb와 HBox 객체 hb가 있습니다. 상단 박스에는 라벨, 엔트리 위젯, 버튼이 세로로 배치되어 있습니다. 아래쪽 상자에는 다른 레이블 세트, 항목 및 단추가 세로로 배치됩니다.

다음 코드를 관찰하십시오-

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
         self.set_title("Box demo")
		
      box = gtk.VBox()
      vb = gtk.VBox()
      lbl = gtk.Label("Enter name")
		
      vb.pack_start(lbl, expand = True, fill = True, padding = 10)
      text = gtk.Entry()
		
      vb.pack_start(text, expand = True, fill = True, padding = 10)
      btn = gtk.Button(stock = gtk.STOCK_OK)
		
      vb.pack_start(btn, expand = True, fill = True, padding = 10)
      hb = gtk.HBox()
		
      lbl1 = gtk.Label("Enter marks")
      hb.pack_start(lbl1, expand = True, fill = True, padding = 5)
      text1 = gtk.Entry()
		
      hb.pack_start(text1, expand = True, fill = True, padding = 5)
      btn1 = gtk.Button(stock = gtk.STOCK_SAVE)
		
      hb.pack_start(btn1, expand = True, fill = True, padding = 5)
      box.add(vb)
      box.add(hb)
      self.add(box)
      self.show_all()
PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

gtk API의 ButtonBox 클래스는 컨테이너가 가로 또는 세로로 여러 버튼을 보유하는 기본 클래스로 사용됩니다. 두 개의 하위 클래스 HButtonBox 및 VButtonBox는 자체적으로 gtk.Box 클래스의 하위 클래스 인 ButtonBox 클래스에서 파생됩니다.

단추 상자는 응용 프로그램 전체에서 일관된 단추 레이아웃을 제공하는 데 사용됩니다. 모든 위젯에서 지속되는 하나의 기본 레이아웃과 기본 간격 값을 제공합니다.

그만큼 set_spacing() gtk.Box 클래스의 메소드를 사용하여 버튼 상자에있는 버튼 사이의 기본 간격을 변경할 수 있습니다.

버튼의 기본 레이아웃은 set_default()방법. 버튼 레이아웃의 가능한 값은 다음과 같습니다.

  • gtk.BUTTONBOX_SPREAD

  • gtk.BUTTONBOX_EDGE

  • gtk.BUTTONBOX_START

  • gtk.BUTTONBOX_END.

다음 예제에서 최상위 창 내부의 VBox 개체에는 내부적으로 VButtonBox 개체 하나와 HButtonBox 개체 하나가 포함되어 있으며, 각각 세로 및 가로로 배열 된 두 개의 버튼이 포함되어 있습니다.

코드 관찰-

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Button Box demo")
      self.set_size_request(200,100)
      self.set_position(gtk.WIN_POS_CENTER)
	  vb = gtk.VBox()
      box1 = gtk.VButtonBox()
      btn1 = gtk.Button(stock = gtk.STOCK_OK)
      btn2 = gtk.Button(stock = gtk.STOCK_CANCEL)
		
      box1.pack_start(btn1, True, True, 0)
      box1.pack_start(btn2, True, True, 0)
      box1.set_border_width(5)
		
      vb.add(box1)
      box2 = gtk.HButtonBox()
      btn3 = gtk.Button(stock = gtk.STOCK_OK)
      btn4 = gtk.Button(stock = gtk.STOCK_CANCEL)
		
      ent = gtk.Entry()
      box2.pack_start(btn3, True, True, 0)
      box2.pack_start(btn4, True, True, 0)
      box1.set_border_width(5)
		
      vb.add(box2)
      self.add(vb)
      self.show_all()

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

이 위젯은 자식 위젯의 정렬과 크기를 제어하는 ​​데 유용합니다. xalign, yalign, xscale 및 yscale이라는 네 가지 속성이 있습니다. scale 속성은 자식 위젯에서 사용할 여유 공간의 양을 지정합니다. 정렬 속성은 사용 가능한 영역 내에 자식 위젯을 배치하는 데 사용됩니다.

네 가지 속성은 모두 0과 1.0 사이의 부동 소수점 값을 사용합니다. xscale 및 yscale 속성이 0으로 설정되면 위젯이 여유 공간을 전혀 흡수하지 않음을 의미하고 1로 설정하면 위젯이 각각 가로 또는 세로로 최대 여유 공간을 흡수 함을 의미합니다.

xalign 및 yalign 속성이 0으로 설정된 경우 왼쪽 또는 위 위젯에 여유 공간이 없음을 의미합니다. 1로 설정하면 위젯 왼쪽 또는 위에 최대 여유 공간이 있습니다.

gtk.alignment 클래스에는 다음과 같은 생성자가 있습니다.

gtk.alignment(xalign = 0.0, yalign = 0.0, xscale = 0.0, yscale = 0.0)

어디,

  • xalign − 하위 위젯 왼쪽에있는 수평 여유 공간의 비율입니다.

  • yalign − 하위 위젯 위의 수직 여유 공간의 비율입니다.

  • xscale − Is는 자식 위젯이 흡수하는 수평 여유 공간의 비율입니다.

  • yscale − Is는 자식 위젯이 흡수하는 수직 여유 공간의 비율입니다.

다음 코드는 gtk.alignment 위젯의 사용을 보여줍니다. 최상위 창의 Vbox에는 상단 Vbox와 하단 Hbox가 있습니다. 상단 수직 상자에는 레이블과 Entry 위젯이 배치되어 왼쪽으로 50 %의 공간이 무료로 유지되고 0.5 xalign 및 0.25를 yalign 속성에 할당하여 25 % 이상을 차지합니다.

하단 HBox에서 사용 가능한 모든 여유 공간은 왼쪽에 있습니다. xalign 속성에 1을 할당하면됩니다. 따라서 가로 상자에있는 두 개의 버튼은 오른쪽 정렬로 표시됩니다.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Alignment demo")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      vb = gtk.VBox()
      hbox = gtk.HBox(True, 3)
      valign = gtk.Alignment(0.5,0.25, 0, 0)
		
      lbl = gtk.Label("Name of student")
      vb.pack_start(lbl, True, True, 10)
      text = gtk.Entry()
		
      vb.pack_start(text, True, True, 10)
      valign.add(vb)
      vbox.pack_start(valign)
		
      ok = gtk.Button("OK")
      ok.set_size_request(70, 30)
		
      close = gtk.Button("Close")
      hbox.add(ok)
      hbox.add(close)
		
      halign = gtk.Alignment(1, 0, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, False, 3)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

PyGTK 도구 키트의 일부 위젯에는 자체 창이 없습니다. 이러한 창없는 위젯은 이벤트 신호를 수신 할 수 없습니다. 예를 들어 레이블과 같은 위젯은 이벤트 상자 안에 넣으면 신호를받을 수 있습니다.

EventBox는 창없는 위젯에 창을 제공하는 보이지 않는 컨테이너입니다. 인수가없는 간단한 생성자가 있습니다.

gtk.EventBox()

다음 예제에서는 gtk.EventBox의 두 위젯이 최상위 창에 배치됩니다. 각 이벤트 상자 안에 레이블이 추가됩니다. 이제 eventbox는 button_press_event를 처리하기 위해 콜백 함수에 연결됩니다. 이벤트 상자 자체가 보이지 않기 때문에 이벤트가 포함 된 레이블에서 효과적으로 발생합니다. 따라서 레이블을 클릭하면 해당 콜백 함수가 호출됩니다.

코드 관찰-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("EventBox demo")
      self.set_size_request(200,100)
      self.set_position(gtk.WIN_POS_CENTER)
      fixed = gtk.Fixed()
      
      event1 = gtk.EventBox()
      label1 = gtk.Label("Label 1")
      event1.add(label1)
      fixed.put(event1, 80,20)
      
      event1.connect("button_press_event",self.hello1)
      event2 = gtk.EventBox()
      label2 = gtk.Label("Label 2")
      event2.add(label2)
      event2.connect("button_press_event",self.hello2)
      fixed.put(event2, 80,70)
      
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def hello1(self, widget, event):
      print "clicked label 1"
		
   def hello2(self, widget, event):
      print "clicked label 2"

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

콘솔에서 Label 1을 클릭하면 "clicked label 1"메시지가 인쇄됩니다. 마찬가지로 Label 2를 클릭하면 "clicked label 2"메시지가 출력됩니다.

gtk.Layout은 gtk.Fixed와 유사한 컨테이너 위젯입니다. 위젯은 절대 좌표를 지정하여 레이아웃 위젯에 배치됩니다. 그러나 레이아웃은 다음과 같은 점에서 고정 위젯과 다릅니다.

  • 레이아웃 위젯은 무한한 너비와 높이를 가질 수 있습니다. 너비와 높이의 최대 값은 부호없는 정수의 크기로 제한됩니다.

  • gtk.DrawingArea 위젯은 레이아웃 컨테이너에 포함될 수 있습니다. DrawingArea는 선, 직사각형 등과 같은 2D 요소를 그릴 수있는 캔버스입니다.

  • 레이아웃 컨테이너를 더 작은 크기의 최상위 창에 배치하려면 스크롤 막대와 연결하거나 ScrolledWindow에 배치 할 수 있습니다.

gtk.Layout 클래스에는 다음과 같은 생성자가 있습니다.

gtk.Layout(hadjustment = None, vadjustment = None)

그만큼 hadjustmentvadjustment 속성은 조정 가능한 경계 값을 가진 객체를 나타냅니다.

다음 표는 자주 사용되는 레이아웃 방법을 나열합니다.

put (위젯, x, y) 지정된 좌표에 자식 위젯을 배치합니다.
세트 _ 크기 (w, h) 레이아웃 컨테이너의 크기를 지정된 너비와 높이로 설정합니다.

Layout 객체는 관련된 조정이 변경 될 때 set_scroll_adjustment 신호를 내 보냅니다.

다음 예제에서 레이블은 레이아웃 컨테이너의 중앙에 배치되며, 차례로 더 작은 크기의 최상위 창에 배치됩니다. 따라서 먼저 ScrolledWindow에 추가되고 ScrolledWindow가 기본 창에 추가됩니다.

코드 관찰-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("layout")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
      sc = gtk.ScrolledWindow()
      lo = gtk.Layout()
      lo.set_size(400,400)
      button = gtk.Button("Press Me")
      lo.put(button, 125,200)
      sc.add(lo)
      self.add(sc)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

ComboBox는 모든 GUI 툴킷에서 강력하고 인기있는 위젯입니다. 사용자가 선택할 수있는 항목의 드롭 다운 목록을 제공합니다. gtk.ComboBox 위젯은 CellLayout 인터페이스를 구현하고 항목 표시를 관리하기위한 여러 메소드를 제공합니다.

gtk.ComboBox 클래스의 객체는 항목 모음을 표시하는 위젯과 함께 사용할 수있는 목록 모델 인 ListSore와 연결됩니다. append () 메서드를 사용하여 ListStore에 항목을 추가합니다. 또한 CellRendererText 객체가 생성되어 콤보 상자에 압축됩니다.

콤보 박스를 설정하려면 다음 단계를 따르세요.

combobox = gtk.ComboBox()
store = gtk.ListStore(gobject.TYPE_STRING)
cell = gtk.CellRendererText()
combobox.pack_start(cell)
combobox.add_attribute(cell, 'text', 0)

PyGTK는 편리한 방법을 제공합니다. gtk.combo_box_new_text()목록 저장소를 사용하는 대신 콤보 상자를 만듭니다. 연관된 편의 메소드 append_text (), prepend_text (), insert_text () 및 remove_text ()는 콤보 상자 내용을 관리하는 데 사용됩니다.

gtk.ComboBox 클래스에는 다음과 같은 메소드가 있습니다.

S.NO 방법 및 설명
1

set_wrap_width()

팝업 테이블 레이아웃에 표시 할 열 수를 설정합니다.

2

get_active()

현재 활성 항목의 모델에서 인덱스 인 "활성"속성 값을 반환합니다.

set_active()

combo_box의 활성 항목을 모델 색인이 지정된 항목으로 설정합니다.

4

set_model()

콤보 상자에서 사용하는 모델을 설정합니다.

5

append_text()

콤보 상자 목록 저장소에 저장된 문자열 목록에 텍스트로 지정된 문자열을 추가합니다.

6

Insert_text()

위치로 지정된 인덱스에 콤보 상자 gtk.ListStore의 텍스트로 지정된 문자열을 삽입합니다.

7

prepend_text()

목록 저장소에 저장된 문자열 목록 앞에 텍스트로 지정된 문자열을 추가합니다.

8

remove_text()

연관된 목록 저장소의 위치로 지정된 색인에서 문자열을 제거합니다.

9

get_active_text()

현재 활성 문자열을 반환합니다.

ComboBox 위젯은 다음 신호를 방출합니다.

변경 콤보 상자의 새 항목이 선택 될 때 발생합니다.
move_active 이것은 활성 선택을 이동하기 위해 방출되는 키 바인딩 신호입니다.
팝 다운 이것은 콤보 상자 목록을 팝업하기 위해 방출되는 키 바인딩 신호입니다. 이 신호의 기본 바인딩은 Alt + Up 및 Escape입니다.
팝업 이것은 콤보 상자 목록을 팝업하기 위해 방출되는 키 바인딩 신호입니다. 이 신호의 기본 바인딩은 Alt + Down입니다.

ComboBox의 데모를위한 두 가지 예제 코드는 다음과 같습니다.

예 1

이 예제에서 ListStore는 인기있는 Python GUI 툴킷의 이름으로 채워지며 ComboBox 위젯과 연결됩니다. 사용자가 선택하면 변경된 신호가 방출됩니다. 사용자의 선택을 표시하는 콜백 함수와 연결됩니다.

import pygtk
pygtk.require('2.0')
import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("ComboBox with ListStore")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      combobox = gtk.ComboBox()
      store = gtk.ListStore(str)
      cell = gtk.CellRendererText()
      combobox.pack_start(cell)
      combobox.add_attribute(cell, 'text', 0)
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      fixed.put(combobox, 125,75)
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,125)
      self.label = gtk.Label("")
      fixed.put(self.label, 125,125)
      self.add(fixed)
      
      store.append (["PyQt"])
      store.append (["Tkinter"])
      store.append (["WxPython"])
      store.append (["PyGTK"])
      store.append (["PySide"])
      combobox.set_model(store)
      combobox.connect('changed', self.on_changed)
      combobox.set_active(0)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      return
   
   def on_changed(self, widget):
      self.label.set_label(widget.get_active_text())
      return
      
if __name__ == '__main__':
PyApp()
gtk.main()

실행시 프로그램은 다음 출력을 표시합니다.

예 2

프로그램의 두 번째 버전은 편의 방법을 사용합니다. combo_box_new_text()콤보 상자를 만들고 그 안에 문자열을 추가하는 append_text () 함수를 만듭니다. 두 프로그램 모두에서get_active_text() 메소드는 사용자의 선택을 가져오고 창의 레이블에 표시하는 데 사용됩니다.

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Simple ComboBox")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      cb = gtk.combo_box_new_text()
      cb.connect("changed", self.on_changed)
      cb.append_text('PyQt')
      cb.append_text('Tkinter')
      cb.append_text('WxPython')
      cb.append_text('PyGTK')
      cb.append_text('PySide')
      
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      
      fixed.put(cb, 125,75)
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,125)
      
      self.label = gtk.Label("")
      fixed.put(self.label, 125,125)
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_changed(self, widget):
      self.label.set_label(widget.get_active_text())
if __name__ == '__main__':
   PyApp()
   gtk.main()

이 프로그램의 출력은 이전 프로그램의 출력과 유사합니다.

ToggleButton 위젯은 두 가지 상태가있는 gtk.Button입니다. pressed or active (또는 켜짐) 상태 및 normal or inactive (or off)상태. 버튼을 누를 때마다 상태가 번갈아 나타납니다. ToggleButton의 상태는 set_active () 메서드를 사용하여 프로그래밍 방식으로 변경할 수도 있습니다. 버튼 상태를 전환하기 위해 toggled () 메서드도 사용할 수 있습니다.

gtk.ToggleButton 클래스에는 다음과 같은 생성자가 있습니다.

gtk.ToggleButton(label = None, use_underline = True)

여기서 라벨은 버튼에 표시되는 테스트입니다. use_underline 속성이 True 인 경우 텍스트의 밑줄은 다음 문자에 밑줄이 표시되고 니모닉 가속기에 사용되어야 함을 나타냅니다.

gtk.ToggleButton 클래스의 중요한 메서드 중 일부는 다음 표에 나와 있습니다.

set_active () 이것은 active 속성을 값으로 True (활성 또는 누름 또는 켜짐) 또는 False (비활성 또는 정상 또는 꺼짐)
get_active () 이것은 버튼의 상태를 검색합니다.
toggled () 이것은 토글 버튼에 "toggled"신호를 방출합니다.

ToggleButton 위젯은 다음 신호를 방출합니다.

전환됨 이것은 토글 버튼 상태가 프로그래밍 방식으로 또는 사용자 작업에 의해 변경 될 때 발생합니다.

아래에 주어진 코드는 ToggleButton 위젯의 사용을 보여줍니다.

두 개의 ToggleButtons 및 Label 위젯이 VBox 컨테이너에 배치됩니다. Button1에 의해 방출되는 토글 된 신호는 콜백 함수 on_toggled ()에 연결됩니다. 이 함수에서 Button1의 상태가 False이면 Button2의 상태가 True로 설정되고 그 반대의 경우도 마찬가지입니다.

if self.btn1.get_active() == True:
   self.btn2.set_active(False)
else:
   self.btn2.set_active(True)

라벨에 버튼의 순간 상태를 표시합니다.

다음 코드를 관찰하십시오-

import gtk

 PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Toggle Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      vbox = gtk.VBox()
      self.btn1 = gtk.ToggleButton("Button 1")
      self.btn1.connect("toggled", self.on_toggled)
      self.btn2 = gtk.ToggleButton("Button 2")
      self.lbl = gtk.Label()
      
      vbox.add(self.btn1)
      vbox.add(self.btn2)
      vbox.add(self.lbl)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_toggled(self, widget, data = None):
      if self.btn1.get_active() == True:
         self.btn2.set_active(False)
      else:
         self.btn2.set_active(True)
         state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
         self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

CheckButton 위젯은 체크 박스와 레이블로 스타일이 지정된 ToggleButton 일뿐입니다. ToggleButton 클래스의 모든 속성과 메서드를 상속합니다. 캡션이 버튼의 얼굴에있는 ToggleButton과 달리 CheckButton은 체크 할 수 있고 오른쪽에 레이블이있는 작은 사각형을 표시합니다.

gtk.CheckButton과 관련된 생성자, 메서드 및 신호는 gtk.ToggleButton과 정확히 동일합니다.

다음 예제는 CheckButton 위젯의 사용을 보여줍니다. 두 개의 CheckButton과 레이블이 VBox에 배치됩니다. 첫 번째 CheckButton의 토글 된 신호는 첫 번째 버튼의 상태가 거짓이면 두 번째 버튼의 상태를 True로 설정하는 on_checked () 메서드에 연결되고 그 반대의 경우도 마찬가지입니다.

코드 관찰-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Check Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)

      vbox = gtk.VBox()
      self.btn1 = gtk.CheckButton("Button 1")
      self.btn1.connect("toggled", self.on_checked)
      self.btn2 = gtk.CheckButton("Button 2")
      self.btn2.connect("toggled", self.on_checked)
      self.lbl = gtk.Label()
		
      vbox.add(self.btn1)
      vbox.add(self.btn2)
      vbox.add(self.lbl)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_checked(self, widget, data = None):
      state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
      self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

단일 RadioButton 위젯은 CheckButton과 유사한 기능을 제공합니다. 그러나 동일한 컨테이너에 하나 이상의 라디오 버튼이있는 경우 사용자가 사용 가능한 옵션 중 하나를 선택할 수 있도록 상호 배타적 인 선택을 사용할 수 있습니다. 컨테이너의 모든 라디오 버튼이 동일한 그룹에 속하는 경우 하나가 선택되면 다른 버튼은 자동으로 선택 취소됩니다.

다음은 gtk.RadioButton 클래스의 생성자입니다.

gtk.RadioButton(group = None, Label = None, unerline = None)

버튼 그룹을 생성하려면 group=None 첫 번째 라디오 버튼 및 후속 옵션의 경우 첫 번째 버튼의 개체를 그룹으로 제공합니다.

ToggleButton 및 CheckButton의 경우와 마찬가지로 RadioButton도 the toggled signal. 아래 주어진 예에서, gtk.RadioButton 위젯의 세 객체는 VBox에 배치됩니다. 이들 모두는 토글 된 신호를 처리하기 위해 콜백 함수 on_selected ()에 연결됩니다.

콜백 함수는 소스 RadioButton 위젯의 레이블을 식별하고 VBox에있는 레이블에 표시합니다.

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):

   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Radio Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      vbox = gtk.VBox()
      
      btn1 = gtk.RadioButton(None, "Button 1")
      btn1.connect("toggled", self.on_selected)
      btn2 = gtk.RadioButton(btn1,"Button 2")
      btn2.connect("toggled", self.on_selected)
      btn3 = gtk.RadioButton(btn1,"Button 3")
      btn3.connect("toggled", self.on_selected)
      
      self.lbl = gtk.Label()
      vbox.add(btn1)
      vbox.add(btn2)
      vbox.add(btn3)
      vbox.add(self.lbl)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_selected(self, widget, data=None):
      self.lbl.set_text(widget.get_label()+" is selected")
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

최상위 gtk.Window의 제목 표시 줄 바로 아래에있는 가로 막대는 일련의 메뉴를 표시하도록 예약되어 있습니다. PyGTK API에서 gtk.MenuBar 클래스의 객체입니다.

gtk.Menu 클래스의 객체가 메뉴 모음에 추가됩니다. 컨텍스트 메뉴 및 팝업 메뉴를 만드는데도 사용됩니다. 각 메뉴에는 하나 이상의 gtk.MenuItem 위젯이 포함될 수 있습니다. 그들 중 일부는 하위 메뉴가 될 수 있으며 계단식 MenuItem 버튼이 있습니다.

gtk.MenuBar는 gtk.MenuShell 클래스에서 서브 클래 싱됩니다. 간단한 기본 생성자가 있습니다.

gtk.MenuBar()

MenuBar에 메뉴를 추가하려면 MenuBar 클래스의 append () 메서드가 사용됩니다.

메뉴를 구성하기 위해서는 메뉴 바에 표시하고자하는 라벨이있는 MenuItem 위젯을 생성하여 하위 메뉴로 설정합니다.

예를 들어, 다음 코드는 파일 메뉴를 설정하는 데 사용됩니다-

menu1 = gtk.Menu()
file = gtk.MenuItem("_File")
file.set_submenu(menu1)

이제 MenuItem 클래스의 위젯을 하나 이상 메뉴에 추가 할 수 있습니다.

item1 = gtk.MenuItem("New")
item2 = gtk.MenuItem("Open")

이러한 메뉴 항목은 메뉴 위젯에 추가되고 메뉴 개체는 차례로 메뉴 모음에 추가됩니다.

menu1.append(item1)
menu1.append(item2)
mb.append(menu1)

PyGTK 툴킷은 다양한 유형의 MenuItem 위젯을 제공합니다. ImageMenuItem은 연관된 이미지가있는 메뉴 항목입니다. Stock ID 매개 변수를 사용하여 스톡 이미지를 사용하거나 set_image () 메소드로 다른 이미지를 할당 할 수 있습니다.

예를 들어, 이미지가있는 '새로 만들기'메뉴 항목은 다음과 같이 생성됩니다.

new = gtk.ImageMenuItem(gtk.STOCK_NEW)
menu1.append(new)

마찬가지로 다음 코드를 사용하여 CheckMenuItem을 추가 할 수도 있습니다.

chk = gtk.CheckMenuItem("Checkable")
menu1.append(chk)

이 코드를 사용하여 라디오 항목 그룹을 추가 할 수도 있습니다.

radio1 = gtk.RadioMenuItem(None,"Radio1")
radio2 = gtk.RadioMenuItem(radio1, "Radio2")
menu1.append(radio1)
menu1.append(radio2)

때로는 메뉴 항목 사이에 구분선을 추가 할 수 있습니다. 이를 위해SeparatorMenuItem 또한 사용할 수 있습니다.

sep = gtk.SeparatorMenuItem()
menu1.append(sep)

메뉴 항목에 키보드 단축키를 할당 할 수도 있습니다. PyGTK에는 가속기가 있습니다. 액셀러레이터 그룹을 생성하여 시작하여 최상위 창에 연결합니다.

acgroup = gtk.AccelGroup()
self.add_accel_group(acgroup)

바로 가기를 지정하려면 add_accelerator() 다음 프로토 타입으로 기능-

Item1.add_accelerator(signal, group, key, modifier, flags)

다음은 미리 정의 된 수정 자 중 일부입니다-

  • SHIFT_MASK
  • LOCK_MASK
  • CONTROL_MASK
  • BUTTON1_MASK
  • BUTTON1_MASK

새 메뉴 항목에 Ctrl + N 단축키를 지정하려면 다음 구문을 사용하십시오.

new = gtk.ImageMenuItem(gtk.STOCK_NEW,acgroup)
new.add_accelerator("activate", acgroup, ord('N'), 
   gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)

다음 예제는 위에서 설명한 기능을 보여줍니다.

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      
      super(PyApp, self).__init__()
      self.set_title("Menu Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      mb = gtk.MenuBar()
      
	  menu1 = gtk.Menu()
      file = gtk.MenuItem("_File")
      file.set_submenu(menu1)
      acgroup = gtk.AccelGroup()
      self.add_accel_group(acgroup)
      new = gtk.ImageMenuItem(gtk.STOCK_NEW,acgroup)
      new.add_accelerator("activate", acgroup, ord('N'), 
         gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
      
      menu1.append(new)
      open = gtk.ImageMenuItem(gtk.STOCK_OPEN)
      
      menu1.append(open)
      chk = gtk.CheckMenuItem("Checkable")
      
      menu1.append(chk)
      radio1 = gtk.RadioMenuItem(None,"Radio1")
      radio2 = gtk.RadioMenuItem(radio1, "Radio2")
      
      menu1.append(radio1)
      menu1.append(radio2)
      sep = gtk.SeparatorMenuItem()
      
      menu1.append(sep)
      exit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
      
      menu1.append(exit)
      menu2 = gtk.Menu()
      edit = gtk.MenuItem("_Edit")
      edit.set_submenu(menu2)
      copy = gtk.ImageMenuItem(gtk.STOCK_COPY)
      
      menu2.append(copy)
      cut = gtk.ImageMenuItem(gtk.STOCK_CUT)
      
      menu2.append(cut)
      paste = gtk.ImageMenuItem(gtk.STOCK_PASTE)
      
      menu2.append(paste)
      mb.append(file)
      mb.append(edit)
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(mb, False, False, 0)
      
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

툴바 클래스는 gtk.Container 클래스에서 상속됩니다. 일련의 버튼 및 기타 위젯을 보유하고 관리합니다. 하나 이상의 가로 단추 스트립은 일반적으로 최상위 창의 메뉴 표시 줄 바로 아래에 표시됩니다. 툴바는 HandleBox라는 분리 가능한 창에 넣을 수도 있습니다. 기본적으로 gtk.Toolbar 위젯의 버튼은 수평으로 배치됩니다. 세로 도구 모음은 방향 속성을 다음으로 설정하여 설정할 수 있습니다.gtk.ORIENTATION_VERTICAL.

도구 모음은 아이콘, 텍스트 또는 둘 다가있는 단추를 표시하도록 구성 할 수 있습니다. 스타일 열거자는-

gtk.TOOLBAR_ICONS 이 버튼은 도구 모음에 아이콘 만 표시합니다.
gtk.TOOLBAR_TEXT 이 버튼은 도구 모음에 텍스트 레이블 만 표시합니다.
gtk.TOOLBAR_BOTH 이 버튼은 도구 모음에 텍스트와 아이콘을 표시합니다.
gtk.TOOLBAR_BOTH_HORIZ 이 버튼은 아이콘과 텍스트를 세로로 쌓는 것이 아니라 나란히 표시합니다.

툴바 위젯은 다음 생성자를 사용하여 설정됩니다.

bar = gtk.Toolbar()

툴바의 구성 요소는 gtk.ToolItem의 인스턴스입니다. 항목은 ToolButton, RadioToolButton, ToggleToolButton 또는 SeparatorToolItem 일 수 있습니다. ToolItem 개체에 아이콘을 할당하기 위해 미리 정의 된 stock_ID가있는 이미지를 사용하거나 set_image () 메서드를 통해 사용자 지정 이미지를 할당 할 수 있습니다.

다음 예제는 다른 ToolItem을 구성하는 방법을 보여줍니다-

도구 버튼

newbtn = gtk.ToolButton(gtk.STOCK_NEW)

RadioToolButton

rb1 = gtk.RadioToolButton(None,gtk.STOCK_JUSTIFY_LEFT) 
rb2 = gtk.RadioToolButton(rb1,gtk.STOCK_JUSTIFY_RIGHT)

여러 라디오 버튼이 같은 그룹에 있습니다.

SeparatorToolItem

sep = gtk.SeparatorToolItem()

이러한 항목은 다음을 호출하여 도구 모음에 배치됩니다. insert 방법.

gtk.Toolbar.insert(item, index)

예를 들면

bar.insert(new,0)

set_tooltip_text () nethod를 사용하여 도구 설명을 도구 단추에 할당 할 수도 있습니다. 예를 들면New 툴팁이 새 ToolButton에 할당됩니다.

newbtn.set_tooltip_text("New")

다음 코드는 일반 도구 항목, 라디오 항목 및 구분 항목을 포함하도록 설정된 도구 모음이있는 최상위 창을 보여줍니다.

import gtk

class PyApp(gtk.Window):

   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Toolbar Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      toolbar = gtk.Toolbar()
      toolbar.set_style(gtk.TOOLBAR_ICONS)
      toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
      
      newbtn = gtk.ToolButton(gtk.STOCK_NEW)
      newbtn.set_tooltip_text("New")
      openbtn = gtk.ToolButton(gtk.STOCK_OPEN)
      savebtn = gtk.ToolButton(gtk.STOCK_SAVE)
      sep = gtk.SeparatorToolItem()
      
      rb1 = gtk.RadioToolButton(None,gtk.STOCK_JUSTIFY_LEFT)
      53
      rb2 = gtk.RadioToolButton(rb1,gtk.STOCK_JUSTIFY_RIGHT)
      
      prv = gtk.ToggleToolButton(gtk.STOCK_PRINT_PREVIEW)
      quitbtn = gtk.ToolButton(gtk.STOCK_QUIT)
      
      toolbar.insert(newbtn, 0)
      toolbar.insert(openbtn, 1)
      toolbar.insert(savebtn, 2)
      toolbar.insert(sep, 3)
      toolbar.insert(rb1,4)
      toolbar.insert(rb2,5)
      toolbar.insert(prv,6)
      toolbar.insert(quitbtn, 7)
      
      quitbtn.connect("clicked", gtk.main_quit)
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(toolbar, False, False, 0)
      
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_checked(self, widget, data = None):
      state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
      self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

PyGTK 툴킷의 일부 위젯은 사용자가 마우스 또는 키보드를 사용하여 지정된 범위에서 속성을 조정할 수 있습니다. Viewport와 같은 위젯은 큰 데이터의 일부 조정 가능한 부분을 표시하는 데 사용됩니다 (예 : TextView 컨트롤의 여러 줄 텍스트).

PyGTK는 이러한 위젯과 관련하여 gtk.Adjustment 객체를 사용하여 사용자 조정이 처리를 위해 일부 콜백 함수로 전달되도록합니다. 조정 개체에는 조정 가능한 값의 하한 및 상한과 증분 단계 매개 변수가 포함됩니다. 조정 대상의 파라미터가 변경되면 변경되거나 값이 변경된 신호를 방출합니다.

다음은 gtk.Adjustment 클래스의 생성자입니다.

gtk.Adjustment(value = 0, lower = 0, upper = 0, step_incr = 0, 
   page_incr = 0, page_size = 0)

생성자의 각 속성의 의미는 다음과 같습니다.

초기 값
보다 낮은 최소값
높은 최대 값
step_incr 단계 증가
page_incr 페이지 증가
페이지 크기 페이지 크기

다음 신호는 조정 개체에 의해 방출됩니다-

변경됨 이는 하나 이상의 조정 속성 (값 속성 제외)이 변경된 경우에 발생합니다.
가치 변화 조정 값 속성이 변경 될 때 발생합니다.

위에서 언급했듯이 조정 개체는 물리적 위젯이 아닙니다. 오히려 속성이 변경되는 다른 위젯과 관련하여 사용됩니다. 범위 위젯은 조정 개체와 함께 사용됩니다.

이 클래스는 사용자가 하한과 상한 사이의 숫자 매개 변수 값을 조정할 수있는 위젯의 기본 클래스 역할을합니다. 스케일 위젯 (gtk.Hscale 및 gtk.Vscale) 및 스크롤바 위젯 (gtk.HScrollbar 및 gtk.VScrollbar)은 Range 클래스에서 기능을 파생합니다. 이러한 범위 위젯은 조정 개체와 함께 작동합니다.

gtk.Range 클래스의 다음과 같은 중요한 기능은 Scale 및 Scrollbar 위젯에 의해 구현됩니다.

  • set_update_policy()− "update-policy"속성을 값으로 설정합니다. 정책에는 다음과 같은 값이 있습니다.

gtk.UPDATE_CONTINUOUS 범위 슬라이더를 움직일 때마다 범위 값이 변경되고 "value_changed"신호가 방출됩니다.
gtk.UPDATE_DELAYED 슬라이더 동작이 발생하지 않는 짧은 시간 초과 후에 값이 업데이트되므로 값 변경은 지속적으로 업데이트되지 않고 약간 지연됩니다.
gtk.UPDATE_DISCONTINUOUS 값은 사용자가 버튼을 놓고 슬라이더 드래그 작업을 종료 할 때만 업데이트됩니다.
  • set_adjustment()− "조정"속성을 설정합니다. 조정 개체는 Range 개체의 모델로 사용됩니다.

  • set_increments() − 범위에 대한 단계 및 페이지 크기를 설정합니다.

  • set_range() − Range 위젯에 대한 최소 및 최대 허용 값을 설정합니다.

  • set_value() − 범위의 현재 값을 지정된 값으로 설정합니다.

스케일 위젯 클래스-(HScale 및 VScale)은 gtk.Range 클래스에서 파생됩니다.

이 클래스는 HScale 및 VScale 위젯의 추상 기본 클래스 역할을합니다. 이러한 위젯은 슬라이더 컨트롤로 작동하며 숫자 값을 선택합니다.

이 추상 클래스의 다음 메서드는 HScale 클래스와 VScale 클래스에 의해 구현됩니다-

  • set_digits() − 위젯의 순간 값을 표시하는 데 사용할 소수점 이하 자릿수를 설정합니다.

  • set_draw_value() − True로 설정하면 슬라이더 옆에 현재 값이 표시됩니다.

  • set_value_pos()− 이것은 값이 그려지는 위치입니다. 이것은 gtk.POS_LEFT, gtk.POS_RIGHT, gtk.POS_TOP 또는 gtk.POS_BOTTOM 일 수 있습니다.

gtk.HScale 클래스의 객체는 수평 슬라이더를 제공하는 반면, gtk.VScale 클래스의 객체는 수직 슬라이더를 제공합니다. 두 클래스 모두 동일한 생성자를 가지고 있습니다.

gtk.HScale(Adjustment = None)
gtk.VScale(Adjustment = None)

조정 개체에는 값 및 경계에 대한 액세스를 제공하는 많은 속성이 포함되어 있습니다.

이 클래스는 gtk.Hscrollbar 및 gtk.Vscrollbar 위젯에 대한 추상 기본 클래스입니다. 둘 다 조정 개체와 연결되어 있습니다. 스크롤 막대의 썸 위치는 스크롤 조정으로 제어됩니다. 조정 개체의 속성은 다음과 같이 사용됩니다-

보다 낮은 스크롤 영역의 최소값
높은 스크롤 영역의 최대 값
스크롤바의 위치를 ​​나타내며 하단과 상단 사이에 있어야합니다.
페이지 크기 보이는 스크롤 가능 영역의 크기를 나타냅니다.
step_increment 작은 스테퍼 화살표를 클릭 할 때 스크롤 할 거리
page_increment 스크롤 할 거리 Page Up 또는 Page Down 누른 키

다음 프로그램은 최상위 창에 추가 된 VBox에 배치 된 HScale 및 HScrollbar 위젯을 보여줍니다. 각각은 조정 개체와 연결되어 있습니다.

adj1 = gtk.Adjustment(0, 0, 101, 0.1, 1, 1)
self.adj2 = gtk.Adjustment(10,0,101,5,1,1)

gtk.HScale 위젯은 adj1에 첨부 된 슬라이더 컨트롤입니다. 업데이트 정책, 도면 값의 수 및 위치는 다음과 같이 설정됩니다.

scale1 = gtk.HScale(adj1)
scale1.set_update_policy(gtk.UPDATE_CONTINUOUS)
scale1.set_digits(1)
scale1.set_value_pos(gtk.POS_TOP)
scale1.set_draw_value(True)

gtk.HScrollbar는 수평 스크롤바를 제공합니다. adj2 객체와 연관됩니다. 업데이트 정책도 CONTINUOUS로 설정됩니다.

self.bar1 = gtk.HScrollbar(self.adj2)
self.bar1.set_update_policy(gtk.UPDATE_CONTINUOUS)

스크롤바의 순시 값을 표시하기 위해서는 the adjustment object — adj2 콜백 함수에 연결됨 on_scrolled(). 이 함수는 조정 개체의 값 속성을 검색하여 스크롤 막대 아래의 레이블에 표시합니다.

self.adj2.connect("value_changed", self.on_scrolled)
   def on_scrolled(self, widget, data = None):
   self.lbl2.set_text("HScrollbar value: "+str(int(self.adj2.value)))

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Range widgets Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      adj1 = gtk.Adjustment(0.0, 0.0, 101.0, 0.1, 1.0, 1.0)
      self.adj2 = gtk.Adjustment(10,0,101,5,1,1)
      
      scale1 = gtk.HScale(adj1)
      scale1.set_update_policy(gtk.UPDATE_CONTINUOUS)
      scale1.set_digits(1)
      scale1.set_value_pos(gtk.POS_TOP)
      scale1.set_draw_value(True)
      
      vb = gtk.VBox()
      vb.add(scale1)
      lbl1 = gtk.Label("HScale")
      
      vb.add(lbl1)
      self.bar1 = gtk.HScrollbar(self.adj2)
      self.bar1.set_update_policy(gtk.UPDATE_CONTINUOUS)
      vb.add(self.bar1)
      self.lbl2 = gtk.Label("HScrollbar value: ")
      
      vb.add(self.lbl2)
      self.adj2.connect("value_changed", self.on_scrolled)
      self.add(vb)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_scrolled(self, widget, data=None):
      self.lbl2.set_text("HScrollbar value: "+str(int(self.adj2.value)))
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

대화 창 위젯은 일반적으로 상위 창 위에 팝업 창으로 사용됩니다. 대화 상자의 목적은 사용자로부터 일부 데이터를 수집하여 상위 창으로 보내는 것입니다. 대화 상자는 모달 (상위 프레임을 차단) 또는 모달 (대화 프레임을 우회 할 수 있음) 일 수 있습니다.

PyGTK 라이브러리의 Dialog 위젯은 세로로 분할 된 창입니다. 상단 섹션에는 레이블 또는 항목 위젯이 패킹 된 gtk.VBox가 있습니다. 하단 섹션은 하나 이상의 버튼이 배치 된 action_area라고합니다. 두 영역은 gtk.HSeparator로 구분됩니다.

gtk.Dialog 클래스에는 다음과 같은 생성자가 있습니다.

dlg = gtk.Dialog (Title = None, parent = None, flags = 0, buttons = None)

어디,

  • Title − Dialog 위젯의 제목 표시 줄에 나타나는 텍스트입니다.

  • Parent − 대화 상자가 팝업되는 최상위 창에 대한 참조입니다.

  • Flag− Dialog의 동작을 제어하는 ​​상수를 정의합니다. 정의 된 상수는-

gtk.DIALOG_MODAL 설정하면 대화 상자가 모든 키보드 이벤트를 가져옵니다.
gtk.DIALOG_DESTROY_WITH_PARENT 설정되면 대화 상자는 부모가 될 때 파괴됩니다.
gtk.DIALOG_NO_SEPARATOR 설정된 경우 버튼 위에 구분선이 없습니다.

버튼이란?

Button은 스톡 ID (또는 텍스트)와 그 응답 ID가있는 gtk.Button 쌍을 포함하는 튜플 객체입니다.

응답 ID는 임의의 숫자 또는 미리 정의 된 응답 ID 상수 중 하나 일 수 있습니다.

  • gtk.RESPONSE_NONE
  • gtk.RESPONSE_REJECT
  • gtk.RESPONSE_ACCEPT
  • gtk.RESPONSE_DELETE_EVENT
  • gtk.RESPONSE_OK
  • gtk.RESPONSE_CANCEL
  • gtk.RESPONSE_CLOSE
  • gtk.RESPONSE_YES
  • gtk.RESPONSE_NO
  • gtk.RESPONSE_APPLY
  • gtk.RESPONSE_HELP

gtk.Dialog 클래스의 중요한 메소드는 다음과 같습니다.

  • add_button() − 지정된 텍스트로 버튼을 추가합니다. button_text (또는 button_text가 주식 ID 인 경우 주식 버튼) action_area에 있습니다.

  • response() − response_id에 지정된 값으로 "응답"신호를 내 보냅니다.

  • run() − 대화 상자를 표시하고 delete_event가 발생하면 response_id를 반환합니다.

  • set_default_response() − 대화 상자의 작업 영역에서 마지막 위젯을 지정된 response_id 대화 상자의 기본 위젯으로.

gtk.Dialog 위젯은 다음 신호를 내 보냅니다.

닫기 대화 상자를 닫을 때 발생합니다.
응답 이것은 action_area 위젯이 활성화되고 (버튼 "클릭 됨") 대화 상자가 delete_event를 수신하거나 응용 프로그램이 response () 메서드를 호출 할 때 발생합니다.

Dialog 위젯의 action_area에있는 두 개의 버튼은 Stock ID gtk.STOCK.CANCEL 및 gtk.STOCK_OK를 사용합니다. 응답 ID gtk와 연관됩니다. RESPONSE_REJECT 및 gtk. 각각 RESPONSE_ACCEPT입니다. 아무 버튼이나 누르면 대화 상자가 닫힙니다. run () 메서드는 추가 처리에 사용할 수있는 해당 응답 ID를 반환합니다.

다음 코드는 버튼이있는 최상위 gtk.Window를 표시합니다. 버튼을 클릭하면 레이블과 두 개의 버튼이있는 대화 상자가 나타납니다.

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Dialog Demo")
      self.set_default_size(250, 200)
      fixed = gtk.Fixed()
      btn = gtk.Button("Show")
      btn.connect("clicked",self.show_sialog)
      fixed.put(btn,100,100)
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      
   def show_sialog(self, widget, data=None):
      dialog = gtk.Dialog("My dialog",
         self,
         gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
         (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
         gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
      label = gtk.Label("Simple dialog")
      dialog.vbox.add(label)
      label.show()
      res = dialog.run()
      print res
      dialog.destroy()
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

사전 구성된 대화 위젯

PyGTK API에는 미리 구성된 대화 위젯이 많이 있습니다.

  • MessageDialog
  • AboutDialog
  • ColorSelectionDialog
  • FontSelectionDialog
  • FileChooserDialog

PyGTK에서 위의 표준 대화 상자의 기능을 보여주기 위해 다음 프로그램의 gtk.Window에 각각 대화 상자를 호출하는 메뉴 항목이있는 메뉴를 넣습니다. 각 메뉴 항목의 신호 활성화에 응답하는 콜백 기능이 나열됩니다. 또한 각 유형의 대화 상자 위젯에 대해 제공된 설명을 이해할 수 있습니다.

다음 코드를 관찰하십시오-

import gtk, pango

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Dialog Boxes")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      mb = gtk.MenuBar()
      menu1 = gtk.Menu()
      file = gtk.MenuItem("_File")
      file.set_submenu(menu1)
      msg = gtk.MenuItem("MessageDialog")
      
      menu1.append(msg)
      abt = gtk.MenuItem("AboutDialog")
      menu1.append(abt)
      colo = gtk.MenuItem("colorDialog")
      menu1.append(colo)
      font = gtk.MenuItem("FontSelectionDialog")
      menu1.append(font)
      fl = gtk.MenuItem("FileChooserDialog")
      menu1.append(fl)
      mb.append(file)
      
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(mb, False, False, 0)
      self.add(vbox)
      self.text = gtk.Label("TutorialsPoint")
      vbox.pack_start(self.text, True, True, 0)
      msg.connect("activate",self.on_msgdlg)
      abt.connect("activate",self.on_abtdlg)
      font.connect("activate",self.on_fntdlg)
      colo.connect("activate",self.on_color)
      
      fl.connect("activate", self.on_file)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   def on_msgdlg(self, widget):
      #MessageDialog usage code
   def on_abtdlg(self, widget):
      #AboutDialog usage code
   def on_fntdlg(self,widget):
      #FontSelectionDialog usage code
   def on_color(self, widget):
      #ColorChooserDialog usage cde
   Def on_file(self, widget):
      #FileChooserDialog usage code
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

Messagedialog 위젯은 메시지 유형 (예 : 오류, 질문 또는 일부 정보 텍스트)을 나타내는 이미지를 표시하도록 구성된 대화 상자 창입니다. MessageDialog 객체는 다음 생성자를 사용하여 선언됩니다.

gtk.MessageDialog(parent = None, flags = 0, type = gtk.MESSAGE_INFO, 
   buttons = gtk.BUTTONS_NONE, message_format = None)

다음 미리 정의 된 메시지 유형은 메시지 대화 상자를 구성하는 데 사용됩니다-

gtk.MESSAGE_INFO 이것은 정보 메시지입니다
gtk.MESSAGE_WARNING 치명적이지 않은 경고 메시지입니다.
gtk.MESSAGE_QUESTION 이 질문은 선택이 필요합니다
gtk.MESSAGE_ERROR 이것은 치명적인 오류 메시지입니다.

사전 정의 된 버튼 세트 세트도 사용할 수 있습니다.

gtk.BUTTONS_NONE 전혀 버튼 없음
gtk.BUTTONS_OK 이것은 확인 버튼입니다
gtk.BUTTONS_CLOSE 닫기 버튼입니다
gtk.BUTTONS_CANCEL 취소 버튼입니다
gtk.BUTTONS_YES_NO 예 및 아니요 버튼입니다.
gtk.BUTTONS_OK_CANCEL 확인 및 취소 버튼입니다.

MessageBox 메뉴 항목이 활성화되면 다음 콜백 함수가 호출되고 메시지 상자가 출력으로 팝업됩니다.

def on_msgdlg(self, widget):
   md = gtk.MessageDialog(self,
      gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR,
      gtk.BUTTONS_CLOSE, "Error message")
   md.run()

위의 함수는 다음과 같은 출력을 생성합니다.

gtk.AboutDialog 위젯은 로고, 이름, 저작권, 웹 사이트 및 라이센스와 같은 프로그램에 대한 정보를 표시하는 간단한 방법을 제공합니다. 정보 대화 상자는 일반적으로 사용자가About 옵션에서 Help메뉴. 대화 상자의 모든 부분은 선택 사항입니다.

그만큼 About DialogURL과 이메일 주소를 포함 할 수 있습니다. gtk.AboutDialog는 사용자가 URL과 이메일 ID를 클릭 할 때 전역 후크를 제공합니다.

다음은 gtk.AboutDialog 클래스의 생성자입니다.

dlg = gtk.AboutDialog()

다음 방법을 사용하여 About Dialog

  • set_program_name() − 이것은 화면에 표시 될 이름을 설정합니다. About Dialog. 기본값은 application_name ()입니다.

  • set_version() − "버전"속성을 설정합니다.

  • set_copyright()− "저작권"을 설정합니다. 만약None, 저작권 고지가 숨겨져 있습니다.

  • set_license()− "라이센스"를 설정합니다. 만약None, 라이센스 버튼이 숨겨져 있습니다.

  • set_website() − "website"속성이 유효한 URL이어야하는 문자열로 설정됩니다.

  • set_author() − 이것은 "저자"속성을 2 차 학점 대화 상자의 저자 탭에 표시되는 저자 이름 목록으로 설정합니다.

  • set_logo()− 이것은 Pixbuf 개체에 "logo"속성을 설정합니다. None이면 기본 창 아이콘 세트가 사용됩니다.

AboutDialog 메뉴 버튼을 클릭하면 다음 콜백 함수가 호출됩니다. 이 기능은 정보 대화 상자를 생성합니다-

def on_abtdlg(self, widget):
   
   about = gtk.AboutDialog()
   about.set_program_name("PyGTK Dialog")
   about.set_version("0.1")
   about.set_authors("M.V.Lathkar")
   about.set_copyright("(c) TutorialsPoint")
   about.set_comments("About Dialog example")
   about.set_website("http://www.tutorialspoint.com")
   
   about.run()
   about.destroy()

위의 함수는 다음과 같은 출력을 생성합니다.

gtk.FontSelection 위젯을 통해 사용자는 특정 이름, 크기 및 스타일의 글꼴을 선택하고 적용 할 수 있습니다. 대화 상자에는 선택한 글꼴 설명에 표시 될 텍스트가 포함 된 미리보기 상자와 취소 및 확인 버튼이 두 개 있습니다.

PyGTK API에는 고품질 국제화 된 텍스트를 렌더링하는 데 필요한 클래스 및 기능을 정의하는 Pango 모듈이 포함되어 있습니다. gtk의 글꼴 및 텍스트 처리는 Pango에서 지원합니다. pango.Font 객체는 시스템 독립적 인 방식으로 글꼴을 나타냅니다. pango.FontDescription 객체는 글꼴의 특성을 포함합니다.

gtk.FontSelectionDialog는 pango.Font 객체를 반환합니다. 선택한 글꼴을 적용하기 위해 fontmetrics는 pango.FontDescription 객체를 가져 와서 가져옵니다.

다음은 FontSelectionDialog 클래스의 생성자입니다-

dlg = gtk.FontSelectionDialog(title)

다음은이 클래스에서 자주 사용되는 방법입니다.

  • get_font_name() − 현재 선택된 글꼴 이름을 포함하는 문자열을 반환하거나 글꼴 이름이 선택되지 않은 경우 None을 반환합니다.

  • set_font_name() − 현재 글꼴을 설정합니다.

  • set_preview_text() − 미리보기 영역 항목의 텍스트를 설정합니다.

선택한 글꼴은 modify_font () 메서드를 사용하여 위젯의 텍스트에 적용됩니다.

FontSelectionDialog 메뉴 항목이 활성화되면 다음 콜백 함수가 호출됩니다.

def on_abtdlg(self, widget):
   about = gtk.AboutDialog()
   about.set_program_name("PyGTK Dialog")
   about.set_version("0.1")
   about.set_authors("M.V.Lathkar")
   about.set_copyright("(c) TutorialsPoint")
   about.set_comments("About Dialog example")
   about.set_website("http://www.tutorialspoint.com")
   about.run()
   about.destroy()

선택한 글꼴은 최상위 창에 배치 된 레이블의 텍스트에 적용됩니다.

다음은 출력입니다-

이것은 사용자가 색상을 선택하고 적용 할 수있는 PyGTK API의 미리 구성된 대화 상자입니다. 내부적으로 gtk.ColorSelection 위젯을 포함합니다.

gtk.ColorScelection 위젯은 HSV 및 RGB와 같은 색상 매개 변수에 대한 입력 상자와 colow wheel을 제공합니다. 색상환을 조작하거나 색상 매개 변수를 입력하여 새 색상을 선택할 수 있습니다. get_current_color는 추가 처리에 유용합니다.

다음은 gtk.ColorSelectionDialog 클래스 생성자의 프로토 타입입니다.

dlg = gtk.ColorSelectionDialog(title)

현재 선택된 색상은 colorsel 속성에서 가져옵니다. 선택한 색상은 modify_fg () 또는 modify_bg () 메서드를 사용하여 위젯에 적용됩니다.

ColorDialog 메뉴 버튼이 활성화되면 다음 콜백 기능이 실행됩니다.

def on_color(self, widget):
   dlg = gtk.ColorSelectionDialog("Select color")
   col = dlg.run()
   sel = dlg.colorsel.get_current_color()
   self.text.modify_fg(gtk.STATE_NORMAL, sel)

선택한 색상이 창에있는 레이블 위젯의 텍스트에 적용됩니다.

다음은 출력입니다-

이 대화 상자는 사용자가 열거 나 저장해야하는 파일의 위치와 이름을 선택할 수 있도록하는 데 유용합니다. FileChooserWidget을 포함하고 action_area에 OK 및 CANCEL 버튼을 제공합니다.

다음은 gtk.FileChooserDialog 클래스의 생성자입니다.

Dlg=gtk.FileChooserDialog (title = None, parent = None, 
   action = gtk.FILE_CHOOSER_ACTION_OPEN,  buttons = None, backend = None)

매개 변수는-

표제 이것은 대화의 제목입니다
부모의 대화 상자의 임시 부모 또는 없음
동작 대화 상자의 열기 또는 저장 모드
버튼 버튼 레이블-응답 ID 쌍 또는 없음을 포함하는 튜플입니다.
백엔드 사용할 특정 파일 시스템 백엔드의 이름입니다.

다음은 액션 모드입니다-

  • gtk.FILE_CHOOSER_ACTION_OPEN
  • gtk.FILE_CHOOSER_ACTION_SAVE
  • gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER
  • gtk.FILE_CHOOSER_ACTION_CREATE_FOLDER

표시 할 수있는 파일 유형을 제한하려면 add_filter () 메서드를 사용하여 gtk.FileFilter의 객체를 적용 할 수 있습니다.

FileChooserDialog 메뉴 버튼을 클릭하면 다음 콜백 함수가 실행됩니다.

def on_file(self, widget):
   dlg = gtk.FileChooserDialog("Open..", None, gtk.FILE_CHOOSER_ACTION_OPEN,
      (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
   response = dlg.run()
   self.text.set_text(dlg.get_filename())
   dlg.destroy()

파일은 대화 상자에서 선택됩니다-

선택한 파일은 최상위 gtk.Window의 레이블에 표시됩니다.

노트북 위젯은 탭이있는 컨테이너입니다. 이 컨테이너의 각 탭에는 서로 다른 페이지가 있으며 페이지는 겹치는 방식으로 표시됩니다. 탭의 레이블을 클릭하면 원하는 페이지가 표시됩니다. 레이블은 상단 또는 하단 또는 왼쪽 또는 오른쪽에 표시되도록 구성 할 수 있습니다. 다른 위젯이있는 컨테이너 위젯 또는 단일 위젯이 각 페이지 아래에 배치됩니다.

표시 할 데이터가 하나의보기에서 너무 크면 각 페이지가 노트북 위젯의 한 탭 아래에 배치되는 다른 페이지로 그룹화됩니다. 이 유형의 제어는 매우 널리 사용됩니다. 예를 들어 인터넷 브라우저는이 탭 표시를 사용하여 다른 탭에서 다른 페이지를 렌더링합니다.

다음은 gtk.Notebook 클래스의 생성자입니다.

gtk.Notebook()

다음은 gtk.Notebook 클래스에서 자주 사용되는 메소드입니다.

  • append_page(child, label)− 탭의 레이블로 tab_label로 지정된 위젯이 포함 된 노트북에 페이지를 추가합니다. tab_label이 None이면 기본 레이블을 사용합니다.

  • insert_page(child, label, position) − 노트북의 위치에 지정된 위치에 페이지를 삽입합니다.

  • remove_page(index) − 지정된 인덱스에서 페이지를 제거합니다.

  • get_current_page() − 현재 페이지의 페이지 인덱스를 반환합니다.

  • set_current_page(index) − 인덱스에 의해 지정된 페이지 번호로 전환됩니다.

  • set_show_tabs()− 거짓이면 탭이 보이지 않습니다. 기본적으로 True입니다.

  • set_tab_pos(pos)− 노트북에서 페이지 전환을위한 탭이 그려지는 가장자리를 설정합니다. 미리 정의 된 상수는-

    • gtk.POS_LEFT

    • gtk.POS_RIGHT

    • gtk.POS_TOP

    • gtk.POS_BOTTOM

  • set_tab_label_text(child, text) − 지정된 텍스트로 새 레이블을 생성하고 자식을 포함하는 페이지의 탭 레이블로 설정합니다.

gtk.Notebook 위젯은 다음 신호를 방출합니다.

현재 페이지 변경 페이지 앞으로 또는 페이지 뒤로 요청이 발행 될 때 방출됩니다.
초점 탭 탭으로 초점이 변경되면 발생합니다.
페이지 추가 노트북에 페이지를 추가 할 때 발생합니다.
페이지 제거됨 이것은 노트북에서 페이지가 제거 된 후에 생성됩니다.
선택 페이지 새 하위 페이지가 선택되면 발생합니다.
페이지 전환 노트북 페이지가 변경되면 발생합니다.

다음 예제에서 세 페이지가있는 gtk.Notebook은 최상위 gtk.Window에 배치됩니다. 첫 번째 페이지에는 레이블 및 항목 필드가 패킹 된 VBox가 있습니다. 'qualifications'라고 표시된 두 번째 페이지에는 상호 배타적 인 세 개의 RadioButton 위젯이 추가 된 HButtonBox가 있습니다. 세 번째 페이지에는 TextView 개체가 있습니다. 페이지 레이블이 맨 위에 표시됩니다.

코드 관찰-

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Notebook Demo")
      self.set_default_size(250, 200)
		
      nb = gtk.Notebook()
      nb.set_tab_pos(gtk.POS_TOP)
      vbox = gtk.VBox(False, 5)
		
      vb = gtk.VBox()
      hbox = gtk.HBox(True, 3)
		
      valign = gtk.Alignment(0.5,0.25, 0, 0)
      lbl = gtk.Label("Name of student")
		
      vb.pack_start(lbl, True, True, 10)
      text = gtk.Entry()
		
      vb.pack_start(text, True, True, 10)
      valign.add(vb)
		
      vbox.pack_start(valign)
      nb.append_page(vbox)
      nb.set_tab_label_text(vbox, "Name")
      hb = gtk.HButtonBox()
		
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
		
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
		
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
		
      nb.append_page(hb)
      nb.set_tab_label_text(hb, "Qualification")
		
      tv = gtk.TextView()
      nb.append_page(tv)
      nb.set_tab_label_text(tv, "about")
		
      self.add(nb)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
if __name__ == '__main__':
   PyApp()
   gtk.main()

실행시 위의 코드는 3 페이지의 노트북을 표시합니다.

프레임 클래스는 gtk.Bin 클래스의 하위 클래스입니다. 그 안에 배치 된 하위 위젯 주위에 장식 테두리를 그립니다. 프레임에는 위치를 사용자 지정할 수있는 레이블이 포함될 수 있습니다.

gtk.Frame 객체는 다음 생성자의 도움으로 생성됩니다.

frame = gtk.Frame(label = None)

다음은 gtk.Frame () 클래스의 메소드입니다.

  • set_label(text) − 이것은 다음에 의해 지정된 라벨을 설정합니다. text. 만약None, 현재 레이블이 제거됩니다.

  • set_label_widget() − gtk.Label 이외의 위젯을 프레임 레이블로 설정합니다.

  • set_label_align(x, y) − 프레임의 라벨 위젯 및 장식의 정렬을 설정합니다 (기본값은 0.0 및 0.5).

  • set_shadow_type() -프레임의 그림자 유형을 설정합니다.

가능한 값은-

  • gtk.SHADOW_NONE
  • gtk.SHADOW_IN
  • gtk.SHADOW_OUT
  • gtk.SHADOW_ETCHED_IN
  • tk.SHADOW_ETCHED_OUT

다음 코드는 프레임 위젯의 기능을 보여줍니다. gtk.RadioButton의 세 개체 그룹이 HButtonBox에 배치됩니다.

btn1 = gtk.RadioButton(None,"Degree")
btn2 = gtk.RadioButton(btn1,"P.G.")
btn3 = gtk.RadioButton(btn1,"Doctorate")
hb = gtk.HButtonBox()
hb.add(btn1)
hb.add(btn2)
hb.add(btn3)

상자 주위에 테두리를 그리기 위해 프레임 위젯에 배치하고 최상위 창에 추가합니다.

frm = gtk.Frame()
frm.add(hb)
self.add(frm)

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Frame Demo")
      self.set_default_size(250, 200)
      self.set_border_width(5)
      frm = gtk.Frame()
      hb = gtk.HButtonBox()
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
      frm.add(hb)
      frm.set_label("Qualifications")
      self.add(frm)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

gtk.AspectFrame 클래스는 Frame 클래스의 하위 클래스입니다. 이 프레임의 자식 위젯은 기본 창의 크기가 조정 되더라도 항상 가로 세로 비율 (너비 및 높이)을 유지합니다.

gtk.AspectFrame 위젯의 ratio 속성은 위젯 너비 : 높이 비율을 결정합니다. 종횡비 0.5는 너비가 높이의 절반임을 의미합니다. 가로 세로 비율 2.0은 너비가 높이의 두 배임을 의미합니다. "비율"속성의 기본값은 1.0입니다.

다음 구문은 gtk.AspectFrame 클래스의 생성자에 사용됩니다.

gtk.AspectFrame (label = None, xalign = 0.5, yalign = 0.5, ratio = 1.0, obey_child = True)

그만큼 xalign속성 은 자식의 왼쪽에있는 수평 여유 공간 의 비율을 결정합니다 . 0.0은 왼쪽에 여유 공간이 없음을 의미하고 1.0은 왼쪽에 모든 여유 공간을 의미합니다 .

그만큼 yalign속성 은 자식 위 의 수직 여유 공간 비율을 결정합니다 . 0.0은 위의 여유 공간이 없음을 의미하고 1.0은 위의 모든 여유 공간을 의미합니다 .

프레임 높이에 대한 너비 비율은 다음과 같은 경우 유지됩니다. obey_child 속성은 False입니다.

obey_child 속성은 비율을 무시할지 여부를 결정합니다. 기본값은 True입니다.

다음 코드는 Frame 클래스에 사용되는 코드와 유사합니다. 유일한 차이점은 ButonBox가 AspectFrame 위젯에 있다는 것입니다.

frm = gtk.AspectFrame(label = None, xalign = 0.5, yalign = 0.5, 
   ratio = 5.0, obey_child = False)

Note − obey_child 속성은 창 크기를 조정하더라도 가로 세로 비율을 유지하기를 원하기 때문에 False로 설정됩니다.

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Aspect Frame Demo")
      self.set_default_size(250, 200)
      self.set_border_width(5)
      frm = gtk.AspectFrame(label = None, xalign = 0.5, yalign = 0.5, 
         ratio = 5.0, obey_child = False)
      hb = gtk.HButtonBox()
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
      frm.add(hb)
      frm.set_label("Qualifications")
      self.add(frm)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      
if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음과 같은 원본 및 크기 조정 된 창을 생성합니다.

Original Window

Resized Window

Treeview 위젯은 gtk.TreeModel 인터페이스를 구현하는 모델의 내용을 표시합니다. PyGTK는 다음 유형의 모델을 제공합니다.

  • gtk.ListStore
  • gtk.TreeStore
  • gtk.TreeModelSort

ListStore는 목록 모델입니다. gtk.TreeView 위젯과 연결되면 선택할 항목을 포함하는 목록 상자를 생성합니다. gtk.ListStore 객체는 다음 구문으로 선언됩니다.

store = gtk.ListStore(column_type)

목록에는 여러 열이있을 수 있으며 미리 정의 된 유형 상수는 다음과 같습니다.

  • gobject.TYPE_BOOLEAN
  • gobject.TYPE_BOXED
  • gobject.TYPE_CHAR
  • gobject.TYPE_DOUBLE
  • gobject.TYPE_ENUM
  • gobject.TYPE_FLOAT
  • gobject.TYPE_INT
  • gobject.TYPE_LONG
  • gobject.TYPE_NONE
  • gobject.TYPE_OBJECT
  • gobject.TYPE_STRING
  • gobject.TYPE_UCHAR
  • gobject.TYPE_UINT
  • gobject.TYPE_ULONG
  • gtk.gdk.pixbuf 등

예를 들어, 문자열 항목을 저장하는 ListStore 객체는 다음과 같이 선언됩니다.

store = gtk.ListStore(gobject.TYPE_STRING

상점에 항목을 추가하기 위해 append () 메소드가 사용됩니다.

store.append (["item 1"])

TreeStore는 다중 열 트리 위젯의 모델입니다. 예를 들어, 다음 문은 문자열 항목이있는 하나의 열이있는 상점을 만듭니다.

Store = gtk.TreeStore(gobject.TYPE_STRING)

TreeStore에 항목을 추가하려면 append () 메서드를 사용하십시오. append () 메서드에는 parent와 row라는 두 개의 매개 변수가 있습니다. 최상위 항목을 추가하려면 parent가 None입니다.

row1 = store.append(None, ['row1'])

여러 행을 추가하려면이 문을 반복해야합니다.

자식 행을 추가하려면 최상위 행을 append () 메서드에 부모 매개 변수로 전달합니다.

childrow = store.append(row1, ['child1'])

여러 하위 행을 추가하려면이 문을 반복해야합니다.

이제 TreeView 위젯을 만들고 위의 TreeStore 개체를 모델로 사용합니다.

treeview = gtk.TreeView(store)

이제 상점 데이터를 표시하기 위해 TreeViewColumn을 만들어야합니다. gtk.TreeViewColumn의 객체는 gtk.CelRenderer를 사용하여 헤더와 셀을 관리합니다. TreeViewColumn 객체는 다음 생성자를 사용하여 생성됩니다-

gtk.TreeViewColumn(title, cell_renderer,…)

제목 및 렌더러 외에도 속성 값을 검색 할 트리 모델 열을 지정하려면 0 개 이상의 attribute = column 쌍이 필요합니다. 이러한 매개 변수는 아래에 주어진 TreeViewColumn 클래스의 메서드를 사용하여 설정할 수도 있습니다.

gtk.CellRenderer는 다양한 유형의 데이터를 렌더링하기위한 객체 세트의 기본 클래스입니다. 파생 클래스는 CellRendererText, CellRendererPixBuf 및 CellRendererToggle입니다.

TreeViewColumn 클래스의 다음 메서드는 개체를 구성하는 데 사용됩니다-

  • TreeViewColumn.pack_start (cell, expand = True)-이 메서드는 CellRenderer 객체를 시작 열에 압축합니다. 확장 매개 변수를 True로 설정하면 할당 된 전체 공간이 셀에 할당됩니다.

  • TreeViewColumn.add_attribute (cell, attribute, column)-이 메서드는 트리 열의 목록에 속성 매핑을 추가합니다. 그만큼column 트리 모델의 열입니다.

  • TreeViewColumn.set_attributes ()-이 메소드는 renderer 사용하여 attribute = column 한 쌍

  • TreeViewColumn.set_visible ()-If True, treeview 열이 표시됩니다.

  • TreeViewColumn.set_title ()-이 메서드는 "title"속성을 지정된 값으로 설정합니다.

  • TreeViewColumn.set_lickable ()-True로 설정하면 헤더가 키보드 포커스를 가져와 클릭 할 수 있습니다.

  • TreeViewColumn.set_alignment (xalign)-이 메서드는 "alignment"속성을 다음 값으로 설정합니다. xalign.

"clicked"신호는 사용자가 treeviewcolumn 헤더 버튼을 클릭 할 때 발생 합니다.

TreeViewColumn 개체를 구성한 후 append_column () 메서드를 사용하여 TreeView 위젯에 추가합니다.

다음은 TreeView 클래스의 중요한 메서드입니다-

  • TreevVew.set_model ()-이것은 treeview에 대한 "model"속성을 설정합니다. 트 리뷰에 이미 모델 세트가있는 경우이 메소드는 새 모델을 설정하기 전에이를 제거합니다. 만약model 이다 None, 이전 모델을 설정 해제합니다.

  • TreeView.set_header_clickable () − True로 설정하면 칼럼 제목 버튼을 클릭 할 수 있습니다.

  • TreeView.append_column ()-이것은 지정된 TreeViewColumn 열 목록에.

  • TreeView.remove_column ()-이것은 트 리뷰에서 지정된 열을 제거합니다.

  • TreeView.insert_column ()-이것은 지정된 column 지정된 위치의 트리 뷰로 position.

TreeView 위젯은 다음 신호를 방출합니다.

커서 변경 이것은 커서가 이동하거나 설정 될 때 방출됩니다.
확장-축소-커서-행 커서의 행을 확장하거나 축소해야 할 때 발생합니다.
행 활성화 사용자가 두 번 클릭하면 발생합니다. treeview
행 접힘 사용자 또는 프로그래밍 작업에 의해 행이 축소 될 때 발생합니다.
행 확장 이는 사용자 또는 프로그래밍 방식 작업을 통해 행이 확장 될 때 내 보냅니다.

TreeView 위젯의 두 가지 예가 아래에 나와 있습니다. 첫 번째 예제는 ListStore를 사용하여 간단한 ListView를 생성합니다.

여기에 ListStore 객체가 생성되고 여기에 문자열 항목이 추가됩니다. 이 ListStore 객체는 TreeView 객체의 모델로 사용됩니다-

store = gtk.ListStore(str)

treeView = gtk.TreeView()
treeView.set_model(store)

그런 다음 CellRendererText가 TreeViewColumn 개체에 추가되고 동일한 개체가 TreeView에 추가됩니다.

rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", rendererText, text = 0)
treeView.append_column(column)

TreeView 개체는 고정 컨테이너에 추가하여 최상위 창에 배치됩니다.

예 1

다음 코드를 관찰하십시오-

import pygtk
pygtk.require('2.0')
import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("TreeView with ListStore")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      store = gtk.ListStore(str)
      store.append (["PyQt"])
      store.append (["Tkinter"])
      store.append (["WxPython"])
      store.append (["PyGTK"])
      store.append (["PySide"])
      
      treeView = gtk.TreeView()
      treeView.set_model(store)
		
      rendererText = gtk.CellRendererText()
      column = gtk.TreeViewColumn("Python GUI Libraries", rendererText, text=0)
      treeView.append_column(column)
      
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      fixed.put(treeView, 125,15)
		
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,175)
      self.label = gtk.Label("")
		
      fixed.put(self.label, 125,175)
      self.add(fixed)
      
      treeView.connect("row-activated", self.on_activated)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_activated(self, widget, row, col):
      
	  model = widget.get_model()
      text = model[row][0]
      self.label.set_text(text)
		
def main():
   gtk.main()
   return

if __name__ == "__main__":
   bcb = PyApp()
   main()

사용자가 선택한 항목은 창의 레이블에 on_activated callback 함수가 호출됩니다.

예 2

두 번째 예제는 TreeStore에서 계층 적 TreeView를 빌드합니다. 이 프로그램은 저장소를 빌드하고이를 TreeView의 모델로 설정하고 TreeViewColumn을 디자인하고이를 TreeView에 추가하는 동일한 순서를 따릅니다.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("TreeView with TreeStore")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
      vbox = gtk.VBox(False, 5)
      
      # create a TreeStore with one string column to use as the model
      store = gtk.TreeStore(str)
      
      # add row
      row1 = store.append(None, ['JAVA'])
      
      #add child rows
      store.append(row1,['AWT'])
      store.append(row1,['Swing'])
      store.append(row1,['JSF'])
      
      # add another row
      row2 = store.append(None, ['Python'])
      store.append(row2,['PyQt'])
      store.append(row2,['WxPython'])
      store.append(row2,['PyGTK'])
      
      # create the TreeView using treestore
      treeview = gtk.TreeView(store)
      tvcolumn = gtk.TreeViewColumn('GUI Toolkits')
      treeview.append_column(tvcolumn)
		
      cell = gtk.CellRendererText()
      tvcolumn.pack_start(cell, True)
      tvcolumn.add_attribute(cell, 'text', 0)
      vbox.add(treeview)
		
      self.add(vbox)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

다음 TreeView는 출력으로 표시됩니다-

Paned 클래스는 두 개의 조정 가능한 창을 가로 (gtk.Hpaned) 또는 세로 (gtk.Vpaned)로 표시 할 수있는 위젯의 기본 클래스입니다. pack1 () 및 pack2 () 메서드를 사용하여 창에 자식 위젯을 추가합니다.

패닝 된 위젯은 두 창 사이에 구분 슬라이더를 그리고 상대적인 너비 / 높이를 조정하는 핸들을 제공합니다. 창 안에있는 자식 위젯의 크기 조정 속성이 True로 설정되어 있으면 창 크기에 따라 크기가 조정됩니다.

다음 방법은 HPaned 및 VPaned 클래스에서 사용할 수 있습니다.

  • Paned.add1 (child)-지정된 위젯을 추가합니다. child 상단 또는 왼쪽 창으로

  • Paned.add2 (child)-지정된 위젯을 추가합니다. child 아래쪽 또는 오른쪽 창에.

  • Paned.pack1 (child, resize, shrink)-지정된 위젯을 추가합니다. child매개 변수가있는 상단 또는 왼쪽 창으로 이동합니다. 만약resize 이다 True, child패닝 된 위젯의 크기가 조정될 때 크기가 조정되어야합니다. 만약shrink 이다 True, child 최소 크기 요청보다 작게 만들 수 있습니다.

  • Paned.pack2 (child, resize, shrink)-두 창 사이의 구분선 위치를 설정합니다.

두 유형의 Paned 위젯은 다음 신호를 방출합니다.

수용 위치 이것은 다음과 같은 경우에 방출됩니다. paned 포커스가있는 자식 위젯이 활성화되도록합니다.
취소 위치 이것은 Esc 키를 누른 상태에서 paned 초점이 있습니다.
이동 핸들 이것은 다음과 같은 경우에 방출됩니다. paned 포커스가 있고 구분 기호가 이동합니다.

다음 예제는 gtk.Hpaned 위젯을 사용합니다. 왼쪽 창에는 TreeView 위젯이 추가되고 오른쪽 창에는 TextView 위젯이 있습니다. TreeView에서 임의의 행을 선택하면 콜백 함수에 연결된 row_activated 신호를 내 보냅니다. 그만큼on_activated()function 행의 텍스트를 검색하고 텍스트보기 패널에 표시합니다.

코드 관찰-

import gtk, gobject

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("HPaned widget Demo")
      self.set_default_size(250, 200)
      vp = gtk.HPaned()
      sw = gtk.ScrolledWindow()
      sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) 
		
      tree = gtk.TreeView()
      languages = gtk.TreeViewColumn()
      languages.set_title("GUI Toolkits")
      cell = gtk.CellRendererText()
      languages.pack_start(cell, True)
      languages.add_attribute(cell, "text", 0)
      treestore = gtk.TreeStore(str)
      it = treestore.append(None, ["Python"])
		
      treestore.append(it, ["PyQt"])
      treestore.append(it, ["wxPython"])
      treestore.append(it, ["PyGTK"])
      treestore.append(it, ["Pydide"])
		
      it = treestore.append(None, ["Java"])
      treestore.append(it, ["AWT"])
      treestore.append(it, ["Swing"])
      treestore.append(it, ["JSF"])
      treestore.append(it, ["SWT"])
		
      tree.append_column(languages)
      tree.set_model(treestore)
		
      vp.add1(tree)
      self.tv = gtk.TextView()
      vp.add2(self.tv)
      vp.set_position(100)
      self.add(vp)
		
      tree.connect("row-activated", self.on_activated)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_activated(self, widget, row, col):
      model = widget.get_model()
      text = model[row][0]
      print text
		
      buffer = gtk.TextBuffer()
      buffer.set_text(text+" is selected")
      self.tv.set_buffer(buffer)

if __name__ == '__main__':
   PyApp()
   gtk.main()

위의 코드는 다음 출력을 생성합니다.

일반적으로 창 하단에있는 알림 영역을 상태 표시 줄이라고합니다. 모든 유형의 상태 변경 메시지는 상태 표시 줄에 표시 될 수 있습니다. 또한 크기를 조정할 수있는 그립이 있습니다.

gtk.Statusbar 위젯은 메시지 스택을 유지합니다. 따라서 현재 메시지 위에 새 메시지가 표시됩니다. 팝업되면 이전 메시지가 다시 표시됩니다. 메시지 소스는 고유하게 식별하기 위해 context_id로 식별되어야합니다.

다음은 gtk.Statusbar 위젯의 생성자입니다.

bar = gtk.Statusbar()

다음은 gtk.Statusbar 클래스의 메소드입니다.

  • Statusbar.push(context_id, text) − 이것은 상태 표시 줄의 스택에 새 메시지를 푸시합니다.

  • Statusbar.pop(context_id) − 이것은 지정된 최상위 메시지를 제거합니다. context_id 상태 표시 줄의 스택에서.

다음 신호는 상태 표시 줄 위젯에 의해 방출됩니다-

텍스트 팝업 상태 표시 줄 메시지 스택에서 메시지가 제거 될 때 발생합니다.
텍스트 푸시 상태 표시 줄 메시지 스택에 메시지가 추가 될 때 발생합니다.

다음 예제는 상태 표시 줄의 기능을 보여줍니다. 최상위 창에는 두 개의 행이있는 VBox가 있습니다. 상단 행에는 레이블, 항목 위젯 및 버튼이 놓인 고정 위젯이 있습니다. 반면 맨 아래 행에는 gtk.Statusbar 위젯이 추가됩니다.

상태 표시 줄에 메시지를 보내려면 해당 context_id를 가져와야합니다.

id1 = self.bar.get_context_id("Statusbar")

Button 객체의 'clicked'신호는 상태 표시 줄에 메시지가 푸시되는 콜백 함수에 연결됩니다. 그리고 Entry 위젯 내에서 Enter 키를 누르면 'activate'신호가 발생합니다. 이 위젯은 다른 콜백에 연결되어 있습니다.

btn.connect("clicked", self.on_clicked, id1)
txt.connect("activate", self.on_entered, id1)

두 콜백 모두 push() 알림 영역에서 메시지를 깜박이는 방법.

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Statusbar demo")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox()
      fix = gtk.Fixed()
      lbl = gtk.Label("Enter name")
		
      fix.put(lbl, 175, 50)
      txt = gtk.Entry()
      fix.put(txt, 150, 100)
		
      btn = gtk.Button("ok")
      fix.put(btn, 200,150)
		
      vbox.add(fix)
      self.bar = gtk.Statusbar()
      vbox.pack_start(self.bar, True, False, 0)
		
      id1 = self.bar.get_context_id("Statusbar")
      btn.connect("clicked", self.on_clicked, id1)
      txt.connect("activate", self.on_entered, id1)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
      def on_clicked(self, widget, data=None):
         self.bar.push(data, "Button clicked
		
      def on_entered(self, widget, data):
         self.bar.push(data, "text entered")

PyApp()
gtk.main()

실행시 위의 코드는 다음과 같은 출력을 표시합니다.

텍스트 상자에 입력하고 Enter 키를 누르면 상태 표시 줄에 '텍스트 입력'메시지가 표시됩니다.

진행률 표시 줄은 사용자에게 장기 실행 프로세스를 시각적으로 표시하는 데 사용됩니다. gtk.ProgressBar 위젯은 백분율 모드와 활동 모드의 두 가지 모드에서 사용할 수 있습니다.

완료 대기중인 작업의 양을 정확하게 예측할 수있는 경우 진행률 표시 줄을 백분율 모드로 사용할 수 있으며 사용자는 완료된 작업의 백분율을 표시하는 증분 막대를 볼 수 있습니다. 반면에 완료해야 할 작업량을 정확하게 결정할 수 있다면 진행률 표시 줄을 활동 모드로 사용하고, 바는 앞뒤로 움직이는 블록을 표시하여 활동을 표시합니다.

다음 생성자는 gtk.ProgressBar 클래스의 위젯을 초기화합니다.

pb = gtk.ProgressBar()

gtk.ProgressBar는 다음 메소드를 사용하여 기능을 관리합니다.

  • ProgressBar.pulse()− 진행률 표시 줄을 조금 움직여서 진행 상황이 어느 정도 진행되었음을 나타내지 만 얼마나 많이 알 수는 없습니다. 이 방법은 또한 진행률 표시 줄 모드를 블록이 앞뒤로 바운스되는 "활동 모드"로 변경합니다.

  • ProgressBar.set_fraction(fraction) − 이렇게하면 진행률 표시 줄이 다음으로 지정된 표시 줄의 부분을 "채 웁니다". fraction. 의 가치fraction 0.0에서 1.0 사이 여야합니다.

  • ProgressBar.set_pulse_setup() − 이것은 부분을 설정합니다 ( fraction)의 총 진행률 표시 줄 길이의 각 호출에 대한 바운싱 블록을 pulse() 방법.

  • ProgressBar.set_orientation()− 진행률 표시 줄의 방향을 설정합니다. 다음 상수 중 하나로 설정할 수 있습니다.

    • gtk.PROGRESS_LEFT_TO_RIGHT

    • gtk.PROGRESS_RIGHT_TO_LEFT

    • gtk.PROGRESS_BOTTOM_TO_TOP

    • gtk.PROGRESS_TOP_TO_BOTTOM

다음 프로그램에서 gtk.ProgressBar 위젯은 활동 모드에서 사용됩니다. 따라서 진행 초기 위치는 0.0으로 설정됩니다.set_fraction() 방법.

self.pb = gtk.ProgressBar()
self.pb.set_text("Progress")
self.pb.set_fraction(0.0)

100 밀리 초 후에 진행률을 1 % 씩 증가시키기 위해 타이머 개체를 선언하고 진행률 표시 줄이 업데이트되도록 100ms마다 호출되도록 콜백 함수를 설정합니다.

self.timer = gobject.timeout_add (100, progress_timeout, self)

여기, progress_timeout()콜백 함수입니다. 매개 변수를 증가시킵니다.set_fraction() 방법을 1 % 씩 변경하고 진행률 표시 줄의 텍스트를 업데이트하여 완료율을 표시합니다.

def progress_timeout(pbobj):
   new_val = pbobj.pb.get_fraction() + 0.01
   pbobj.pb.set_fraction(new_val)
   pbobj.pb.set_text(str(new_val*100)+" % completed")
   return True

다음 코드를 관찰하십시오-

import gtk, gobject
   
def progress_timeout(pbobj):
   new_val = pbobj.pb.get_fraction() + 0.01
   pbobj.pb.set_fraction(new_val)
   pbobj.pb.set_text(str(new_val*100)+" % completed")
   return True

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Progressbar demo")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      fix = gtk.Fixed()
      self.pb = gtk.ProgressBar()
      self.pb.set_text("Progress")
      self.pb.set_fraction(0.0)
		
      fix.put(self.pb,80,100)
      self.add(fix)
      self.timer = gobject.timeout_add (100, progress_timeout, self)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

활동 모드에서 진행률 표시 줄을 사용하려면 콜백 함수를 다음과 같이 변경하고 실행하십시오.

def progress_timeout(pbobj):
   pbobj.pb.pulse()
   return True

진행률 표시 줄 내부의 블록을 앞뒤로 이동하면 활동의 진행 상황이 표시됩니다.

위젯에 최상위 창보다 큰 영역이있는 경우 ViewPort 컨테이너와 연결됩니다. gtk.Viewport 위젯은 ScrolledWindow에서 사용할 조정 기능을 제공합니다. 예를 들어 Label 위젯에는 조정이 없습니다. 따라서 뷰포트가 필요합니다. 일부 위젯에는 기본 스크롤 지원이 있습니다. 그러나 Label 또는 gtk.Table 위젯에는 내장 스크롤 지원이 없습니다. 따라서 그들은 뷰포트를 사용해야합니다.

ViewPort 클래스에는 다음 생성자가 있습니다.

gtk.Viewport(hadj, vadj)

여기, hadjvadj 뷰포트와 연관된 조정 오브젝트입니다.

gtk.ViewPort 클래스는 다음 메소드를 사용합니다.

  • Viewport.set_hadjustment() − "hadjustment"속성을 설정합니다.

  • Viewport.set_vadjustment() − "vadjustment"속성을 설정합니다.

  • Viewport.set_shadow_type() − "그림자 유형"속성을 다음 값으로 설정합니다. type. 의 가치type 다음 중 하나 여야합니다.

    • gtk.SHADOW_NONE

    • gtk.SHADOW_IN

    • gtk.SHADOW_OUT

    • gtk.SHADOW_ETCHED_IN

    • gtk.SHADOW_ETCHED_OUT

gtk.Viewport 객체는 수평 및 수직 gtk.Adjustment 객체 중 하나 또는 둘 모두가 변경 될 때 set-scroll-adjustments 신호를 내 보냅니다.

상위 창보다 큰 영역의 다른 위젯에 접근하기 위해 스크롤 된 창이 생성됩니다. TreeView 및 TextView와 같은 일부 위젯은 스크롤을 기본적으로 지원합니다. 레이블 또는 테이블과 같은 다른 경우에는 뷰포트를 제공해야합니다.

다음 구문은 gtk.ScrolledWindow 클래스의 생성자에 사용됩니다.

sw = gtk.ScrolledWindow(hadj, vadj)

다음은 gtk.ScrolledWindow 클래스의 메소드입니다.

  • ScrolledWindow.set_hadjustment() − 이것은 gtk.Adjustment 객체에 수평 조정을 설정합니다.

  • ScrolledWindow.set_vadjustment() − 이것은 gtk.Adjustment 객체에 대한 수직 조정을 설정합니다.

  • ScrolledWindow.set_Policy (hpolicy, vpolicy)− "hscrollbar_policy"및 "vscrollbar_policy"속성을 설정합니다. 다음 사전 정의 된 상수 중 하나가 사용됩니다.

    • gtk.POLICY_ALWAYS − 스크롤바는 항상 존재합니다.

    • gtk.POLICY_AUTOMATIC − 스크롤바는 필요한 경우에만 표시됩니다. 즉, 내용이 창보다 큽니다.

    • gtk.POLICY_NEVER − 스크롤바가 존재하지 않습니다.

  • ScrolledWindow.add_with_viewport(child) −이 방법은 스크롤 된 창에 기본 스크롤 기능없이 위젯 (자식에 의해 지정됨)을 추가하는 데 사용됩니다. 이것은 추가하는 것과 동일한 편의 기능입니다.childgtk.Viewport, 스크롤 된 창에 뷰포트를 추가합니다.

다음 코드는 10 x 10 차원의 gtk.Table 객체 주위에 스크롤 된 창을 추가합니다. 테이블 오브젝트는 자동으로 조정을 지원하지 않으므로 뷰포트에 추가됩니다.

sw = gtk.ScrolledWindow()
table = gtk.Table(10,10)

두 개의 중첩 된 루프를 사용하여 각각 10 개 열의 10 개 행을 추가합니다. gtk.Button 위젯은 각 셀에 배치됩니다.

for i in range(1,11):
   for j in range(1,11):
      caption = "Btn"+str(j)+str(i)
      btn = gtk.Button(caption)
      table.attach(btn, i, i+1, j, j+1)

이 충분히 큰 테이블이 이제 뷰포트와 함께 스크롤 된 창에 추가됩니다.

sw.add_with_viewport(table)

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("ScrolledWindow and Viewport")
      self.set_size_request(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
      sw = gtk.ScrolledWindow()
      table = gtk.Table(10,10)
      table.set_row_spacings(10)
      table.set_col_spacings(10)
      for i in range(1,11):
         for j in range(1,11):
            caption = "Btn"+str(j)+str(i)
            btn = gtk.Button(caption)
            table.attach(btn, i, i+1, j, j+1)
      sw.add_with_viewport(table)
      self.add(sw)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

gtk.Arrow 객체는 네 가지 기본 방향을 가리키는 간단한 화살표를 그리는 데 사용됩니다. 이 클래스는gtk.Misc 클래스와 객체는 할당 된 공간 (예 : Label 또는 Button 위젯)을 차지합니다.

일반적으로 Arrow 객체는 다음 생성자를 사용하여 생성됩니다.

Arr = gtk.Arrow(arrow_type, shadow_type)

미리 정의 된 arrow_type 상수는 다음과 같습니다.

  • gtk.ARROW_UP
  • gtk.ARROW_DOWN
  • gtk.ARROW_LEFT
  • gtk.ARROW_RIGHT

미리 정의 된 shadow_type 상수는 다음 표에 나열되어 있습니다.

gtk.SHADOW_NONE 개요가 없습니다.
gtk.SHADOW_IN 윤곽선은 안쪽으로 경사져 있습니다.
gtk.SHADOW_OUT 외곽선은 버튼처럼 바깥쪽으로 기울어집니다.
gtk.SHADOW_ETCHED_IN 외곽선 자체는 안쪽으로 기울어 지지만 프레임은 바깥쪽으로 기울어집니다.
gtk.SHADOW_ETCHED_OUT 윤곽선은 바깥 쪽 경사이고 프레임은 안쪽으로 경사집니다.

다음 예제에서는 4 개의 Button 위젯이 Hbox에 추가됩니다. 각 버튼 위에 각각 UP, DOWN, LEFT 및 RIGHT를 가리키는 gtk.Arrow 객체가 배치됩니다. HBOX 컨테이너는 정렬 컨테이너의 도움으로 최상위 창의 맨 아래에 배치됩니다.

코드 관찰-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Arrow Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
      valign = gtk.Alignment(0, 1, 0, 0)
      vbox.pack_start(valign)
		
      arr1 = gtk.Arrow(gtk.ARROW_UP, gtk.SHADOW_NONE)
      arr2 = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_NONE)
      arr3 = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
      arr4 = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
		
      btn1 = gtk.Button()
      btn1.add(arr1)
      btn2 = gtk.Button()
      btn2.add(arr2)
      btn3 = gtk.Button()
      btn3.add(arr3)
      btn4 = gtk.Button()
      btn4.add(arr4)
		
      hbox.add(btn1)
      hbox.add(btn2)
      hbox.add(btn3)
      hbox.add(btn4)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

이 클래스는 gtk.Misc 클래스에서도 상속됩니다. gtk.Image 클래스의 객체는 이미지를 표시합니다. 일반적으로 이미지는 gtk.gdk.Pixbuf 클래스를 나타내는 픽셀 버퍼의 파일에서로드됩니다. 대신 편의 기능set_from_file() 일반적으로 gk.Image 위젯의 파일에서 이미지 데이터를 표시하는 데 사용됩니다.

gtk.Image 객체를 생성하는 가장 쉬운 방법은 다음 생성자를 사용하는 것입니다.

img = gtk.Image()

다음은 gtk.Image 클래스의 메소드입니다.

  • Image.set_from_file() − 파일 내용에서 이미지 데이터를 설정합니다.

  • Image.set_from_pixbuf() − 이것은 이미지 데이터를 설정합니다. pixmap 오프 스크린 조작을 위해 이미지 데이터가로드됩니다.

  • Image.set_from_pixbuf() − 다음을 사용하여 이미지 데이터를 설정합니다. pixbuf 클라이언트 측 리소스를 사용하여 이미지를 설명하는 데이터가 포함 된 개체입니다.

  • Image.set_from_stock() − 다음으로 식별되는 재고 항목의 이미지 데이터를 설정합니다. stock_id.

  • Image.clear() − 현재 이미지를 제거합니다.

  • Image.set_from_image()− 현재 디스플레이의 픽셀 형식으로 클라이언트 측 이미지 버퍼의 이미지 데이터를 설정합니다. 이미지가None, 현재 이미지 데이터가 제거됩니다.

다음 프로그램에서 gtk.Image 객체는 이미지 파일에서 가져옵니다. 최상위 창에 추가됩니다.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("PyGtk Image demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
	  image1 = gtk.Image()
      image1.set_from_file("python.png")
      self.add(image1)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

DrawingArea 위젯은 선, 직사각형, 호 등과 같은 객체를 그릴 수있는 gtk.gdk.Window를 포함하는 빈 캔버스를 제공합니다.

PyGTK는 이러한 그리기 작업에 Cairo 라이브러리를 사용합니다. Cairo는 인기있는 2D 벡터 그래픽 라이브러리입니다. C로 작성되었지만 C ++, Java, Python, PHP 등과 같은 대부분의 언어로 바인딩되어 있습니다. Cairo 라이브러리는 다양한 운영 체제의 표준 출력 장치에 그릴 수 있습니다. 또한 PDF, SVG 및 포스트 스크립트 파일을 만드는 데 사용할 수 있습니다.

다른 그리기 작업을 수행하려면 대상 출력 개체의 텍스트에서 장치를 가져와야합니다. 이 경우 드로잉이 gtk.DrawingArea 위젯에 나타나기 때문에 그 안에 포함 된 gdk.Window의 디바이스 컨텍스트를 얻습니다. 이 수업에는cairo-create() 장치 컨텍스트를 반환하는 메서드입니다.

area = gtk.DrawingArea()
dc = area.window.cairo_create()

DrawingArea 위젯은 자신이 방출하는 다음 신호를 기반으로 콜백에 연결할 수 있습니다.

깨닫다 위젯이 특정 디스플레이에서 인스턴스화 될 때 필요한 조치를 취합니다.
configure_event 위젯 크기가 변경 될 때 필요한 조치를 취합니다.
노출 _ 이벤트 그리기 영역이 처음 화면에 표시되거나 다른 창으로 가려진 다음 가려지지 않은 (노출됨) 위젯의 내용 다시 그리기를 처리합니다.

마우스 및 키보드 이벤트를 사용하여 콜백을 호출 할 수도 있습니다. add_events() methodgtk.Widget class.

특히 흥미로운 것은 DrawingArea 캔버스가 처음 나타날 때 방출되는 노출 이벤트 신호입니다. Cairo 라이브러리에 정의 된 2D 객체 그리기를위한 다양한 메서드는 노출 이벤트 신호에 연결된이 콜백에서 호출됩니다. 이러한 메서드는 Cairo 장치 컨텍스트에서 해당 개체를 그립니다.

다음은 사용 가능한 그리기 방법입니다-

  • dc.rectangle (x, y, w, h)-지정된 왼쪽 상단 좌표에 너비와 높이가 지정된 사각형을 그립니다.

  • dc.arc (x, y, r, a1, a2)-주어진 반지름과 두 개의 각도를 가진 원호를 그립니다.

  • dc.line (x1, y1, x2, y2)-두 쌍의 좌표 사이에 선을 그립니다.

  • dc.line_to (x, y)-현재 위치에서 (x, y)까지 선을 그립니다.

  • dc.show_text (str)-현재 커서 위치에 문자열을 그립니다.

  • dc.stroke ()-윤곽을 그립니다

  • dc.fill ()-현재 색상으로 모양을 채 웁니다.

  • dc.set_color_rgb (r, g, b) − 외곽선을 설정하고 0.0에서 1.0 사이의 r, g 및 b 값으로 채울 색상을 설정합니다.

다음 스크립트는 다양한 모양을 그리고 Cairo 방법을 사용하여 테스트합니다.

import gtk
import math

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Basic shapes using Cairo")
      self.set_size_request(400, 250)
      self.set_position(gtk.WIN_POS_CENTER)
      
	  self.connect("destroy", gtk.main_quit)
		
      darea = gtk.DrawingArea()
      darea.connect("expose-event", self.expose)
		
      self.add(darea)
      self.show_all()
		
      def expose(self, widget, event):
      cr = widget.window.cairo_create()
		
      cr.set_line_width(2)
      cr.set_source_rgb(0,0,1)
      cr.rectangle(10,10,100,100)
      cr.stroke()
		
      cr.set_source_rgb(1,0,0)
      cr.rectangle(10,125,100,100)
      cr.stroke()
		
      cr.set_source_rgb(0,1,0)
      cr.rectangle(125,10,100,100)
      cr.fill()
		
      cr.set_source_rgb(0.5,0.6,0.7)
      cr.rectangle(125,125,100,100)
      cr.fill()
		
      cr.arc(300, 50, 50,0, 2*math.pi)
      cr.set_source_rgb(0.2,0.2,0.2)
      cr.fill()
		
      cr.arc(300, 200, 50, math.pi,0)
      cr.set_source_rgb(0.1,0.1,0.1)
      cr.stroke()
		
      cr.move_to(50,240)
      cr.show_text("Hello PyGTK")
      cr.move_to(150,240)
      cr.line_to(400,240)
      cr.stroke()

PyApp()
gtk.main()

위의 스크립트는 다음 출력을 생성합니다.

Spinner라고도하는 SpinnButton 위젯은 오른쪽에 위쪽 및 아래쪽 화살표가있는 gtk.Entry 위젯입니다. 사용자는 숫자 값을 직접 입력하거나 위쪽 및 아래쪽 화살표를 사용하여 증가 또는 감소 할 수 있습니다. gtk.SpinButton 클래스는 gtk.Entry 클래스에서 상속됩니다. 스피너에서 숫자 값의 범위와 단계를 제한 할 수있는 gtk.Adjustment 객체를 사용합니다.

SpinButton 위젯은 다음 생성자를 사용하여 생성됩니다.

sp = gtk.SpinButton(adj, climb_rate, digits)

여기서 adj는 gtk.Adjustment object controlling range, climb_rate 가속 계수 및 자릿수로 지정된 소수 자릿수입니다.

gtk.SpinButton 클래스에는 다음과 같은 메소드가 있습니다.

  • SpinButton.set_adjustment ()- "조정"속성을 설정합니다.

  • SpinButton.set_digits ()-이것은 스핀 버튼에 의해 표시 될 소수 자릿수를 결정하는 값으로 "digits"속성을 설정합니다.

  • SpinButton.set_increments (step, page) − 마우스 왼쪽 버튼을 누를 때마다 증분이 적용되는 단계 값과 마우스 가운데 버튼을 누를 때마다 증분이 적용되는 페이지 값을 설정합니다.

  • SpinButton.set_range ()-이것은 스핀 버튼의 최소 및 최대 허용 값을 설정합니다.

  • SpinButton.set_value ()-이것은 프로그래밍 방식으로 스핀 버튼을 새 값으로 설정합니다.

  • SpinButton.update_policy () − 유효한 값은 gtk.UPDATE_ALWAYS 및 gtk.UPDATE_VALID입니다.

  • SpinButton.spin (direction, increment = 1)-Spinner의 값을 지정된 방향으로 증가 또는 감소시킵니다.

다음은 미리 정의 된 방향 상수입니다-

gtk.SPIN_STEP_FORWARD step_increment로 앞으로
gtk.SPIN_STEP_BACKWARD step_increment 뒤로
gtk.SPIN_PAGE_FORWARD step_increment로 앞으로
gtk.SPIN_PAGE_BACKWARD step_increment 뒤로
gtk.SPIN_HOME 최소값으로 이동
gtk.SPIN_END 최대 값으로 이동
gtk.SPIN_USER_DEFINED 값에 증분 추가
  • SpinButton.set_wrap () — wrap이 True 인 경우 범위의 상한 또는 하한이 초과되면 스핀 버튼 값이 반대 한계로 래핑됩니다.

gtk.SpinButton 위젯은 다음 신호를 내 보냅니다.

변화 가치 이것은 키보드 동작으로 스핀 버튼 값이 변경 될 때 발생합니다.
입력 값이 변경 될 때 발생합니다.
산출 스핀 버튼 표시 값이 변경 될 때 발생합니다. 보고True 핸들러가 텍스트를 성공적으로 설정하고 추가 처리가 필요하지 않은 경우.
가치 변화 스핀 버튼의 표시를 변경하는 설정이 변경 될 때 발생합니다.
포장 이것은 스핀 버튼이 최대 값에서 최소값으로 또는 그 반대로 랩핑 한 직후에 방출됩니다.

다음 예제는 간단한 Date Selector세 개의 SpinButton 위젯을 사용합니다. Day Selector는 조정 개체를 적용하여 1 ~ 31 사이의 값을 제한합니다. 두 번째 선택기는 1-12 개월 수입니다. 세 번째 선택기는 2000-2020 년 범위를 선택합니다.

코드 관찰-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("SpinButton Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      self.set_border_width(20)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
      lbl1 = gtk.Label("Date")
      hbox.add(lbl1)
		
      adj1 = gtk.Adjustment(1.0, 1.0, 31.0, 1.0, 5.0, 0.0)
      spin1 = gtk.SpinButton(adj1, 0, 0)
      spin1.set_wrap(True)
		
      hbox.add(spin1)
      lbl2 = gtk.Label("Month")
      hbox.add(lbl2)
		
      adj2 = gtk.Adjustment(1.0, 1.0, 12.0, 1.0, 5.0, 0.0)
      spin2 = gtk.SpinButton(adj2, 0, 0)
      spin2.set_wrap(True)
		
      hbox.add(spin2)
      lbl3 = gtk.Label("Year")
      hbox.add(lbl3)
		
      adj3 = gtk.Adjustment(1.0, 2000.0, 2020.0, 1.0, 5.0, 0.0)
      spin3 = gtk.SpinButton(adj3, 0, 0)
      spin3.set_wrap(True)
      hbox.add(spin3)
		
      frame = gtk.Frame()
      frame.add(hbox)
      frame.set_label("Date of Birth")
		
      vbox.add(frame)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

실행시 위의 코드는 다음과 같은 출력을 생성합니다.

PyGTK 툴킷의 캘린더 위젯은 한 번에 한 달보기로 간단한 캘린더를 표시합니다. 월 및 연도를 변경하는 탐색 컨트롤이 기본적으로 표시됩니다. 표시 옵션을 적절하게 구성 할 수 있습니다.

월 속성 값은 0에서 11 사이이고 날짜 속성의 값은 1에서 31 사이입니다.

gtk.Calendar 객체를 생성하는 간단한 생성자가 있습니다.

cal = gtk.Calendar()

기본 표시 스타일은 현재 월, 연도 및 날짜 이름을 표시합니다.

gtk.Calendar 클래스에는 다음과 같은 메소드가 있습니다.

  • Calendar.select_month (mm, yy) — 달력 표시를 지정된 mmyy.

  • Calendar.select_day (dd) — 지정된 dd 1에서 31 사이의 값이있을 때 달력에 표시됩니다. dd 0이면 현재 날짜 선택이 제거됩니다.

  • Calendar.display_options () — 달력 표시 옵션을 다음에 지정된 값으로 설정합니다. flags. 가능한 표시 옵션은 다음의 조합입니다.

gtk.CALENDAR_SHOW_HEADING 월과 연도가 표시되도록 지정합니다.
gtk.CALENDAR_SHOW_DAY_NAMES 세 글자의 요일 설명이 있어야 함을 지정합니다.
gtk.CALENDAR_NO_MONTH_CHANGE 사용자가 달력으로 월을 전환하지 못하도록합니다.
gtk.CALENDAR_SHOW_WEEK_NUMBERS 달력 왼쪽 아래에 현재 연도의 각 주 번호를 표시합니다.
gtk.CALENDAR_WEEK_START_MONDAY 기본 일요일 대신 월요일에 달력 주를 시작합니다.
  • Calendar.get_date () — 달력의 현재 연도, 월 및 선택한 일 번호를 튜플 (년, 월, 일)로 검색합니다.

gtk.Calendar 위젯은 다음 신호를 내 보냅니다.

요일 선택 이는 사용자가 또는 프로그래밍 방식으로 하루를 선택했을 때 내 보냅니다.
월 변경 이것은 달력 월이 프로그래밍 방식으로 또는 사용자에 의해 변경 될 때 내 보냅니다.
다음 달 사용자가 달력 헤더에서 "다음 달"탐색 컨트롤을 클릭하면 발생합니다.
내년 사용자가 달력 헤더에서 "다음 해"탐색 컨트롤을 클릭하면 발생합니다.
이전 달 사용자가 달력 헤더에서 "이전 월"탐색 컨트롤을 클릭 할 때 발생합니다.
전년도 사용자가 달력 헤더에서 "전년"탐색 컨트롤을 클릭 할 때 발생합니다.

다음 예제에서는 gtk.Calendar 컨트롤과 4 개의 버튼이 최상위 창에 배치됩니다.

'heading'버튼을 클릭하면 캘린더의 표시 옵션이 SHOW_HEADING으로 설정됩니다.

def heading(self, widget):
   self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING)

사용자가 '요일 이름'버튼을 클릭하면 콜백이 표시 옵션을 SHOW_DAY_NAMES로 설정합니다.

def dayname(self, widget):
self.cal.set_display_options(gtk.CALENDAR_SHOW_DAY_NAMES)

'both'버튼을 누르면 두 디스플레이 옵션이 모두 활성화됩니다. 우선, 표시 옵션의 모든 플래그를 0으로 설정하여 제거합니다.

self.cal.set_display_options(0)

'설정'버튼은 현재 표시된 날짜를 표시하는 메시지 상자를 팝업합니다.

tp = self.cal.get_date()
str1 = str(tp[0])
str2 = str(tp[1]+1)
str3 = str(tp[2])
label = gtk.Label("Date selected:"+str3+"-"+str2+"-"+str1)
dialog.vbox.add(label)
label.show()

다음 코드를 관찰하십시오-

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Calendar Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      self.cal = gtk.Calendar()
      halign1 = gtk.Alignment(0.5, 0.5, 0, 0)
      halign1.add(self.cal)
		
      self.cal.set_display_options(0)
      valign = gtk.Alignment(0, 1, 0, 0)
      vbox.pack_start(halign1)
		
      self.btn1 = gtk.Button("set")
      self.btn2 = gtk.Button("heading")
      self.btn3 = gtk.Button("day name")
      self.btn4 = gtk.Button("Both")
		
      hbox = gtk.HBox(True, 3)
      hbox.add(self.btn1)
      hbox.add(self.btn2)
      hbox.add(self.btn3)
      hbox.add(self.btn4)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
		
      self.btn1.connect("clicked", self.selectdate)
      self.btn2.connect("clicked", self.heading)
      self.btn3.connect("clicked", self.dayname)
      self.btn4.connect("clicked", self.bothflags)
		
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def heading(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING)
		
   def dayname(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_DAY_NAMES)
		
   def bothflags(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING|gtk.CALENDAR_SHOW_DAY_NAMES)
   def selectdate(self, widget):
      tp = self.cal.get_date()
      dialog = gtk.Dialog("My dialog",
      self,
      gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
      (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
		
      str1 = str(tp[0])
      str2 = str(tp[1]+1)
      str3 = str(tp[2])
		
      label = gtk.Label("Date selected:"+str3+"-"+str2+"-"+str1)
      dialog.vbox.add(label)
      label.show()
      res = dialog.run()
      dialog.destroy()

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

Clipboard 객체는 동일한 애플리케이션의 두 프로세스 또는 두 위젯간에 공유 데이터를 보유합니다. gtk.Clipboard는 gtk.SelectionData 클래스를위한 고급 인터페이스입니다.

다음은 gtk.Clipboard 생성자의 프로토 타입입니다.

gtk.Clipboard(display,selction)

여기서 display 매개 변수는 클립 보드를 생성하거나 검색 할 gtk.gdk.Display 객체에 해당합니다. 기본적으로 표준 출력 장치입니다. 선택 매개 변수의 기본값은 인턴 문자열을 나타내는 오브젝트 인 CLIPBOARD입니다.

PyGTK는 기본값으로 클립 보드 객체를 생성하는 편리한 기능을 제공합니다.

gtk.clipboard.get()

gtk.Clipboard 클래스에는 다음과 같은 메소드가 있습니다.

  • Clipboard.store ()-현재 클립 보드 데이터를 어딘가에 저장하여 응용 프로그램이 종료 된 후에도 계속 유지됩니다.

  • Clipboard.clear ()-클립 보드의 내용을 제거합니다.

  • Clipboard.set_text (text)-클립 보드의 내용을 문자열로 설정합니다.

  • Clipboard.request_text ()-클립 보드의 내용을 텍스트로 요청합니다. 나중에 문자를 받으면callback 지정된 데이터로 호출됩니다. user_data. 의 서명callback is :

    • def callback (clipboard, text, data)-text will contain the text 클립 보드에서 가져 왔습니다.

클립 보드의 데모로 다음 코드는 최상위 gtk.Window에서 두 개의 TextView와 두 개의 버튼을 사용합니다. '설정'버튼은on_set() 첫 번째 textView의 텍스트를 클립 보드에 넣는 함수입니다.

buf = self.tv1.get_buffer()
text = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
self.clipboard = gtk.clipboard_get()
self.clipboard.set_text(text)
self.clipboard.store()

두 번째 버튼 ( '검색')을 누르면 클립 보드에서 데이터를 request_text () 메서드에 의해 가져옵니다.

self.clipboard.request_text(self.readclipboard,        user_data = None)

내용 user_data 콜백 메소드로 이동 readclipboard() 두 번째 textview에 표시됩니다.

def readclipboard(self, clipboard, text, data):
   buffer = gtk.TextBuffer()
   buffer.set_text(text)
   self.tv2.set_buffer(buffer)

다음은 클립 보드 작업에 대한 전체 코드입니다.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Clipboard demo")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      self.tv1 = gtk.TextView()
		
      vbox.add(self.tv1)
      self.tv2 = gtk.TextView()
		
      vbox.add(self.tv2)
      hbox = gtk.HBox(True, 3)
		
      Set = gtk.Button("set")
      Set.set_size_request(70, 30)
		
      retrieve = gtk.Button("retrieve")
      hbox.add(Set)
      hbox.add(retrieve)
      halign = gtk.Alignment(1, 0, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, False, 3)
      self.add(vbox)
      Set.connect("clicked", self.on_set)
      retrieve.connect("clicked", self.on_retrieve)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_set(self, widget):
      buf = self.tv1.get_buffer()
      text = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
      self.clipboard = gtk.clipboard_get()
      self.clipboard.set_text(text)
      self.clipboard.store()
		
   def on_retrieve(self, widget):
      self.clipboard.request_text(self.readclipboard, user_data=None)
		
   def readclipboard(self, clipboard, text, data):
      buffer = gtk.TextBuffer()
      buffer.set_text(text)
      self.tv2.set_buffer(buffer)

PyApp()
gtk.main()

위의 코드는 다음 출력을 생성합니다.

창에서 마우스 포인터의 위치를 ​​표시하는 데 유용한 가로 (gtk.Hruler) 및 세로 (gtk.Vruler) 눈금자의 기본 클래스입니다. 눈금자의 작은 삼각형은 포인터의 위치를 ​​나타냅니다.

Ruler 객체는 각각의 생성자로 생성됩니다-

hrule = gtk.Hruler()
vrule = gtk.Vruler()

다음 gtk.Ruler 클래스 메소드는 두 파생 클래스 모두에 사용할 수 있습니다.

  • Ruler.set_metric ()-측정 단위를 설정합니다. 사전 정의 된 메트릭 상수는 gtk.PIXELS (기본값), gtk.INCHES 및 gtk.CENTIMETERS입니다.

  • Ruler.set_range ()-이것은 눈금자의 하한과 상한, 위치 및 최대 크기를 설정합니다.

아래 주어진 예에서 가로 및 세로 눈금자는 gtk.TextView 위젯의 위와 왼쪽에 배치됩니다.

가로 눈금자의 측정 단위는 픽셀입니다. 최소값과 최대 값은 각각 0과 400입니다. gtk.VBox의 윗줄에 위치합니다.

hrule = gtk.HRuler()
hrule.set_metric(gtk.PIXELS)
hrule.set_range(0, 4,0,0.5)
vbox.pack_start(hrule)

Vbox의 아래쪽 행에는 HBox가 있습니다. 여러 줄 텍스트를 입력 할 수있는 세로 눈금자와 TextView 위젯이 압축되어 있습니다.

vrule=gtk.VRuler()
vrule.set_metric(gtk.PIXELS)
vrule.set_range(0, 4, 10, 0.5)
hbox.pack_start(vrule)

다음 코드를 관찰하십시오-

import gtk
class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Ruler demo")
      self.set_size_request(400,400)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox()
      tv = gtk.TextView()
      tv.set_size_request(350,350)
		
      hrule = gtk.HRuler()
      hrule.set_metric(gtk.PIXELS)
      hrule.set_range(0, 4,0,0.5)
		
      vbox.pack_start(hrule)
      hbox = gtk.HBox()
      vrule = gtk.VRuler()
		
      vrule.set_metric(gtk.PIXELS)
      vrule.set_range(0, 4, 10, 0.5)
		
      hbox.pack_start(vrule)
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(tv)
		
      hbox.pack_start(halign, False, True, 10)
      vbox.add(hbox)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

위의 프로그램에서 생성 된 출력은 MS Word 문서와 유사합니다.

PyGTK API의 gobject 모듈에는 주기적으로 호출되는 타임 아웃 함수를 생성하는 유용한 기능이 있습니다.

source_id = gobject.timeout_add(interval, function, …)

두 번째 인수는 첫 번째 인수 인 interval의 값인 밀리 초마다 호출하려는 콜백 함수입니다. 추가 인수는 함수 데이터로 콜백에 전달 될 수 있습니다.

이 함수의 반환 값은 다음과 같습니다. source_id. 이를 사용하면 콜백 함수 호출이 중지됩니다.

gobject.source_remove(source_id)

반복을 계속하려면 콜백 함수가 True를 반환해야합니다. 따라서 False를 반환하여 중지 할 수 있습니다.

다음 프로그램에서는 두 개의 버튼과 두 개의 레이블이 최상위 창에 배치됩니다. 하나의 레이블은 증가하는 숫자를 표시합니다. btn1 호출on_click 1000ms (1 초) 간격으로 타임 아웃 기능을 설정합니다.

btn1.connect("clicked", self.on_click)

def on_click(self, widget):
   self.source_id = gobject.timeout_add(1000, counter, self)

타임 아웃 함수의 이름은 다음과 같습니다. counter(). 1 초마다 레이블의 숫자가 증가합니다.

def counter(timer):
   c=timer.count+1
   print c
   timer.count=c
   timer.lbl.set_label(str(c))
   return True

두 번째 버튼의 콜백은 시간 제한 기능을 제거합니다.

btn2.connect("clicked", self.on_stop)
def on_stop(self, widget):
gobject.source_remove(self.source_id)

다음은 Timeout 예제의 전체 코드입니다.

import gtk, gobject

def counter(timer):
      c = timer.count+1
      print c
      timer.count = c
      timer.lbl.set_label(str(c))
      return True
      class PyApp(gtk.Window):
		
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Timeout Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
		
      hb = gtk.HBox()
      lbl1 = gtk.Label("Counter: ")
		
      hb.add(lbl1)
      self.lbl = gtk.Label("")
      hb.add(self.lbl)
      valign = gtk.Alignment(0.5, 0.5, 0, 0)
      valign.add(hb)
      vbox.pack_start(valign, True, True, 10)
		
      btn1 = gtk.Button("start")
      btn2 = gtk.Button("stop")
		
      self.count = 0
      self.source_id = 0
		
      hbox.add(btn1)
      hbox.add(btn2)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
		
      btn1.connect("clicked", self.on_click)
      btn2.connect("clicked", self.on_stop)
		
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_click(self, widget):
      self.source_id = gobject.timeout_add(1000, counter, self)
		
   def on_stop(self, widget):
      gobject.source_remove(self.source_id)

PyApp()
gtk.main()

실행되면 창 하단에 두 개의 버튼이 표시됩니다. 레이블의 숫자는 시작 버튼을 클릭하면 주기적으로 증가하고 중지 버튼을 클릭하면 증가를 중지합니다.

출력 관찰-

연관된 X Window가있는 위젯은 끌어서 놓을 수 있습니다. 프로그램에서 드래그 앤 드롭을위한 소스 및 / 또는 대상으로 위젯을 먼저 지정해야합니다. 소스로 정의 된 위젯은 드래그 된 데이터를 보낼 수 있습니다. 대상 위젯은 끌어온 데이터를 끌어 놓을 때이를 수락합니다.

다음 단계는 끌어서 놓기 가능 응용 프로그램을 설정하는 데 관여합니다.

Step 1 − 소스 위젯 설정.

Step 2 − drag_source_set () 메서드는 드래그 작업의 대상 유형을 지정합니다 −

widget.drag_source_set(start_button_mask, targets, info)

Step 3 − start_button_mask 인수는 드래그 작업을 시작하는 버튼의 비트 마스크를 지정합니다.

Step 4 − 대상 인수는이 구조의 튜플 목록입니다 −

(target, flags, info)

target 인수는 드래그 유형을 나타내는 문자열입니다 (예 : text / plain 또는 image / x-xpixmap).

Step 6 − 다음 플래그가 미리 정의되어 있습니다 −

  • gtk.TARGET_SAME_APP
  • gtk.TARGET_SAME_WIDGET

Step 7 − 플래그가 0으로 설정되어 있으므로 제한이 없습니다.

위젯이 소스로 작동 할 필요가없는 경우 설정을 해제 할 수 있습니다.

widget.drag_source_unset()

소스 신호는 신호를 방출합니다. 다음 표에는 신호와 해당 콜백이 나열되어 있습니다.

drag_begin def drag_begin_cb (widget, drag_context, data) :
drag_data_get def drag_data_get_cb (widget, drag_context, selection_data, info, time, data) :
drag_data_delete def drag_data_delete_cb (widget, drag_context, data) :
drag_end def drag_end_cb (widget, drag_context, data) :

대상 위젯 설정

drag_dest_set () 메서드는 드래그 된 데이터를받을 수있는 위젯을 지정합니다.

widget.drag_dest_set(flags, targets, action)

flags 매개 변수는 다음 상수 중 하나를 취할 수 있습니다.

gtk.DEST_DEFAULT_MOTION 드래그가이 위젯의 ​​가능한 대상 및 작업 목록과 일치하는지 확인한 다음 적절하게 drag_status ()를 호출합니다.
gtk.DEST_DEFAULT_HIGHLIGHT 드래그가이 위젯 위에있는 한이 위젯에 하이라이트를 그립니다.
gtk.DEST_DEFAULT_DROP 드롭이 발생할 때 드래그가이 위젯의 ​​가능한 대상 및 작업 목록과 일치하면 drag_get_data()위젯 대신. 드롭 성공 여부에 관계없이 전화drag_finish(). 동작이 이동이고 드래그가 성공한 경우 삭제 매개 변수에 대해 TRUE가 전달됩니다.drag_finish().
gtk.DEST_DEFAULT_ALL 설정된 경우 모든 기본 작업을 수행하도록 지정합니다.

대상은 대상 정보를 포함하는 튜플 목록입니다. actions 인수는 다음 값 중 하나 이상의 비트 마스크 또는 조합입니다.

  • gtk.gdk.ACTION_DEFAULT
  • gtk.gdk.ACTION_COPY
  • gtk.gdk.ACTION_MOVE
  • gtk.gdk.ACTION_LINK
  • gtk.gdk.ACTION_PRIVATE
  • gtk.gdk.ACTION_ASK

"drag-motion"핸들러는 대상 대상을 다음 항목과 일치시켜 드래그 데이터가 적절한 지 확인해야합니다. gtk.gdk.DragContext 선택적으로 드래그 데이터를 검사하여 drag_get_data()방법. 그만큼gtk.gdk.DragContext. drag_status() 메서드를 호출하여 drag_context 상태.

"드래그-드롭"핸들러는 다음을 사용하여 일치하는 대상을 결정해야합니다. drag_dest_find_target() 방법을 사용하여 드래그 데이터를 요청하십시오. drag_get_data()방법. 데이터는 "drag-data-received"핸들러에서 사용할 수 있습니다.