PyGTK-はじめに

PyGTKは、PythonおよびCでGTK + GUIライブラリ用に記述されたラッパーのセットです。これはGNOMEプロジェクトの一部です。 Pythonでデスクトップアプリケーションを構築するための包括的なツールを提供します。他の一般的なGUIライブラリのPythonバインディングも利用できます。

*PyQt* はQTライブラリのPythonポートです。 PyQtチュートリアルは*こちら*にあります。 同様に、wxPythonツールキットは、別の一般的なクロスプラットフォームGUIライブラリであるwxWidgetsのPythonバインディングです。 wxPythonチュートリアルは*こちら*から入手できます。

*GTK +* 、またはGIMP Toolkitは、グラフィカルユーザーインターフェイスを作成するためのマルチプラットフォームツールキットです。 ウィジェットの完全なセットを提供するGTK +は、小さな1回限りのツールから完全なアプリケーションスイートまでのプロジェクトに適しています。

GTK +は、幅広い言語をサポートするためにゼロから設計されました。 PyGTKはGTK +のPythonラッパーです。

GTK +は、次の4つのライブラリを中心に構築されています-

Glib -GTK +の基礎を形成する低レベルのコアライブラリ。 Cのデータ構造処理を提供します。
Pango -国際化に重点を置いたテキストのレイアウトとレンダリングのためのライブラリ。
Cairo -複数の出力デバイス（X Window System、Win32など）をサポートする2Dグラフィックスのライブラリ
ATK -スクリーンリーダー、拡大鏡、代替入力デバイスなどのアクセシビリティツールを提供する一連のインターフェイスのライブラリ。

Your GTK

PyGTKはプロセスを容易にし、Pythonプログラミング言語を使用したグラフィカルユーザーインターフェイスを備えたプログラムの作成を支援します。基礎となるGTK +ライブラリは、GNOMEデスクトップ用のフル機能アプリケーションを開発するためのあらゆる種類の視覚要素とユーティリティを提供します。 PyGTKはクロスプラットフォームライブラリです。 LGPLライセンスの下で配布されるフリーソフトウェアです。

PyGTKはGTK + 2.xを中心に構築されています。 GTK +3用のアプリケーションを構築するために、PyGObjectバインディングも利用できます。

PyGTK-環境

Microsoft Windows用のPyGTK

Microsoft Windows用のPyGTKのインストールには、次の手順が含まれます-

*ステップ1 *-32ビットPythonインタープリターをインストールする（最新のPython 2.7ディストリビューション）
*ステップ2 *-GTK +ランタイムをダウンロードしてインストールします。
*ステップ3 *-GTK +ランタイムのダウンロードとインストール-https://ftp.gnome.org/pub/GNOME/binaries/win32/pygtk/[https://ftp.gnome.org]
*ステップ4 *-次のURLからPyCairoおよびPyGobjectモジュールをダウンロードすることもお勧めします- https://ftp.gnome.org https://ftp.gnome.org/pub
*ステップ5 *-便宜上、すべてのPyGTK依存関係を処理するオールインワンインストーラーも利用できます。次のURLからWindows用の最新のオールインワンインストーラーをダウンロードしてインストールします-https://ftp.gnome.org/pub/GNOME/binaries/win32/pygtk/2.24/pygtk-2.24.0.win32-py2 7.msi [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-ハローワールド

PyGTKを使用してウィンドウを作成するのは非常に簡単です。続行するには、まずコードにgtkモジュールをインポートする必要があります。

import gtk

gtkモジュールにはgtk.Windowクラスが含まれています。そのオブジェクトは、トップレベルウィンドウを構築します。 gtk.Windowからクラスを派生します。

class PyApp(gtk.Window):

コンストラクターを定義し、gtk.windowクラスの* show_all（）*メソッドを呼び出します。

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

上記のコードの実装は、次の出力を生成します-

Hello World PyGTK

PyGTK-重要なクラス

PyGTKモジュールにはさまざまなウィジェットが含まれています。 gtk.Objectクラスは、ほとんどのウィジェットと一部の非ウィジェットクラスの基本クラスとして機能します。 PyGTKを使用するデスクトップアプリケーションのトップレベルウィンドウは、gtk.Windowクラスによって提供されます。次の表は、重要なウィジェットとその機能を示しています-

S.NO	Classes and Description
1	gtk.Widget これは、すべてのPyGTKウィジェット用のgtk.baseクラスです。 gtk.Widgetは、ウィジェットのメソッドとシグナルの共通セットを提供します。
2	gtk.Window これは、1つの子ウィジェットを保持するトップレベルウィンドウです。 gtk.Windowは、タイトルバーと、ユーザーがウィンドウを閉じたり、サイズを変更したり移動したりできるアイテムで飾られた表示領域です。
3	gtk.Button これは、クリックされるとシグナルを発行するプッシュボタンウィジェットです。 gtk.Buttonは通常、テキストラベル付きのプッシュボタンとして表示され、一般的にコールバック関数をアタッチするために使用されます。
4	gtk.Entry これは、1行のテキスト入力ウィジェットです。
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 これは、水平または垂直に配置された2つのペインを持つウィジェットの基本クラスです。子ウィジェットは、ウィジェットのペインに追加されます。 2つの子の分割は、ユーザーが調整できます。
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 このウィジェットは、より大きなウィジェットの一部を表示します。

PyGTK-ウィンドウクラス

gtk.Windowクラスのオブジェクトは、ユーザーが一般にWwindowと考えるウィジェットを提供します。このウィジェットはコンテナなので、1つの子ウィジェットを保持できます。タイトルバーとサイズ変更コントロールで飾られた表示可能な領域を提供します。

gtk.Windowクラスには、次のコンストラクタがあります-

gtk.Window(type)

型パラメータは、次の値のいずれかを取ります-

gtk.WINDOW_TOPLEVEL (default)	This window has no parent. The Toplevel windows are the main application window and dialogs.
gtk.WINDOW_POPUP	This window has no frame or decorations. A popup window is used for menus and tooltips.

gtk.Windowクラスの重要なメソッドのいくつかを以下に示します-

S.NO	Methods and Description
1	set_title(string) これにより、gtk.windowの「title」プロパティが title で指定された値に設定されます。ウィンドウのタイトルは、タイトルバーに表示されます。
2	get_title() 設定されている場合、これはウィンドウのタイトルを返します。
3	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
3	set_focus()* これにより、指定されたウィジェットがウィンドウのフォーカスウィジェットに設定されます。
4	set_resizable() これはデフォルトで当てはまります。 set_resizable（）は、ユーザーがウィンドウのサイズを設定するのに役立ちます。
5	set_decorated() これはデフォルトで当てはまります。 falseの場合、タイトルバーとウィンドウのサイズ変更コントロールは無効になります。
6	set_modal() trueの場合、ウィンドウはモーダルになり、他のウィンドウとの相互作用が防止されます。これは、Dialogウィジェットに使用されます。
7	set_default_size() これにより、ウィンドウのデフォルトサイズが、ピクセル単位で指定された幅と高さに設定されます。

gtk.Windowウィジェットは、次の信号を発します-

activate-default	This is emitted when the default child widget of window is activated usually by the user pressing the Return or Enter key.
activate-focus	This is emitted when the child widget with the focus is activated usually by the user pressing the Space key.
move-focus	This is emitted when the focus is changed within the window’s child widgets when the user presses the Tab, the Shift+Tab or the Up, Down, Left or Right arrow keys.
set-focus	This is emitted when the focus changes to *widget in** window*.

PyGTK-ボタンクラス

gtk.Buttonウィジェットは、通常、テキストラベル付きのプッシュボタンとして表示されます。通常、ボタンがクリックされたときに呼び出されるコールバック関数またはメソッドをアタッチするために使用されます。

gtk.Buttonクラスには、次のコンストラクタがあります-

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

ここで、

Label -ボタンラベルによって表示されるテキスト
ストック-ボタンで使用されるストック画像とテキストを識別するストックID。デフォルトはなしです。
下線-Trueの場合、テキスト内の下線は、次の文字に下線を付けてニーモニックアクセラレータに使用することを示します。

ストックパラメータの事前定義された定数のいくつかは次のとおりです-

STOCK_OK
STOCK_STOP
STOCK_YES
STOCK_NO
STOCK_QUIT
STOCK_CANCEL *STOCK_CLOSE

Buttonクラスには、次の重要なメソッドがあります-

S.NO	Methods and Description
1	set_label()* これにより、ボタンラベルのテキストがlabelに設定されます。この文字列は、「use_stock」プロパティがTrueの場合、ストックアイテムの選択にも使用されます。
2	get_label() これは、ボタンのラベルからテキストを取得します
3	set_focus_on_click() Trueの場合、マウスでクリックするとボタンがフォーカスを取得します。
4	set_alignment() これは、子ウィジェットの水平および垂直の配置です。値の範囲は0.0〜1.0です。
5	set_image() これにより、imageプロパティがimageの値に設定されます。「gtkbutton-images」プロパティをTrueに設定する必要があります。

次の信号は、ボタンウィジェットによって放出されます-

activate	This is emitted when the gtk.Widget’s activate() method is called. For a button it causes the "clicked" signal to be emitted.
clicked	This is emitted when the mouse button is pressed and released while the pointer is over the button or when the button is triggered with the keyboard.

PyGTK-ラベルクラス

ラベルウィジェットは、編集できないテキストを表示するのに便利です。ラベルは他の多くのウィジェットによって内部的に使用されます。たとえば、ボタンには、顔にテキストを表示するラベルがあります。同様に、MenuItemオブジェクトにはラベルがあります。ラベルはウィンドウのないオブジェクトなので、イベントを直接受け取ることはできません。

ラベルクラスにはシンプルなコンストラクタがあります-

gtk.Label(str = None)

次の便利なメソッドは、Labelオブジェクトで使用できます-

S.NO	Methods and Description
1	set_text() これにより、新しいテキストがラベルとして設定されます
2	get_text() これはラベルからテキストを返します
3	set_use_underline() trueの場合、テキスト内の下線は、次の文字をニーモニックアクセラレータキーに使用する必要があることを示します。
4	set_justify これにより、ラベルのテキスト内の行の相対的な配置が設定されます。可能な値は– gtk.JUSTIFY_LEFT、gtk.JUSTIFY_RIGHT、gtk.JUSTIFY_CENTER、およびgtk.JUSTIFY_FILLです。
5	Set_line_wrap() trueの場合、行は折り返されます
6	set_selectable() trueの場合、ラベル内のテキストをコピーアンドペースト用に選択できます
7	set_width_chars() これにより、ラベルの幅が設定されます

次の信号は、ラベルウィジェットによって放出されます-

activate-current-link	This gets emitted when the user activates a link in the label.
activate-link	This gets emitted to activate a URI.
copy-clipboard	This gets emitted when text is copied from the label to the clipboard.

PyGTK-エントリークラス

入力ウィジェットは、単一行のテキスト入力ウィジェットです。入力されたテキストがウィジェットの割り当てよりも長い場合、ウィジェットはカーソル位置が見えるようにスクロールします。

入力クラスは、このクラスのset_visibility（）メソッドを使用してパスワードモードで変換できます。入力されたテキストは、invisible_char（）メソッドで選択された文字に置き換えられます。デフォルトは「*」です。

エントリクラスには次のコンストラクタがあります-

gtk.Entry(max = 0)

ここで、maxは入力フィールドの最大長を文字で表しています。パラメータは数値（0〜65536）を取ります。

次の表は、エントリクラスの重要なメソッドを示しています-

S.NO	Methods and Description
1	set_visibility(visible) falseの場合、文字をデフォルトの非表示文字（「*」）に置き換えることにより、内容が隠されます
2	set_invisible_char(char) 入力フィールドのデフォルトの「*」文字はcharに置き換えられます
3	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（）は、Entryフィールド内のコンテンツの水平方向の配置を制御します。

次の信号は、エントリウィジェットによって放出されます-

activate	This is emitted when the entry is activated either by user action or programmatically with the gtk.Widget.activate() method.
backspace	This is emitted when the* Backspace* key is entered from the keyboard.
copy-clipboard	This is emitted when the selection text in the entry is copied to the clipboard.
cut-clipboard	This is emitted when the selection in the entry is cut and placed in the clipboard.
paste-clipboard	This is emitted when the contents of the clipboard are pasted into the entry.

PyGTK-信号処理

順次実行されるコンソールモードアプリケーションとは異なり、GUIベースのアプリケーションはイベント駆動型です。 * gtk.main（）*関数は無限ループを開始します。 GUIで発生するイベントは、適切なコールバック関数に転送されます。

GObjectクラスから派生した各PyGTKウィジェットは、1つ以上のイベントに応じて*「シグナル」*を送信するように設計されています。シグナル自体はアクションを実行しません。代わりに、コールバック関数に「接続」されます。

一部の信号はウィジェットに継承されますが、一部の信号はウィジェット固有です。たとえば、「toggled」信号は、toggleButtonウィジェットによって発行されます。

シグナルハンドラーは、gtk.widgetクラスの* connect（）*メソッドを呼び出すことでセットアップされます。

handler_id = object.connect(name, func, func_data)

最初の引数 name は、キャッチする信号の名前を含む文字列です。
2番目の引数 func は、キャッチされたときに呼び出されるコールバック関数です。
3番目の引数 func_data は、この関数に渡すデータです。
コールバックメソッドを一意に識別するために使用されるハンドラーID。

たとえば、ボタンがクリックされたときにonClicked（）関数を呼び出すには、次の構文を使用します-

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

onClicked（）関数は次のように定義されています-

def onClicked(widget, data=None):

コールバックメソッドがオブジェクトメソッドである場合、追加の引数として自己を受け取ります-

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 finddevguides

PyGTK-イベント処理

シグナルメカニズムに加えて、ウィンドウシステムイベントもコールバック関数に接続できます。ウィンドウのサイズ変更、キーの押下、スクロールイベントなど。一般的なウィンドウシステムイベントの一部です。これらのイベントは、アプリケーションのメインループに報告されます。そこから、それらはシグナルを経由してコールバック関数に渡されます。

システムイベントのいくつかは以下にリストされています-

button_press_event
button_release_event
scroll_event
motion_notify_event
delete_event
destroy_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 finddevguides

PyGTK-コンテナー

PyGTKライブラリは、ウィンドウ内のウィジェットの配置を制御するさまざまなコンテナクラスを提供します。最も簡単な方法は、*固定されたコンテナクラス*を使用し、ピクセル単位で測定された絶対座標を指定して、その中にウィジェットを配置することです。

私たちは今、これらの手順に従ってみましょう-

ステップ1 *-*固定クラス*のオブジェクトを宣言する

fixed = gtk.Fixed()

ステップ2 *-ボタンウィジェットを作成し、xおよびy座標を必要とする put（）*メソッドを使用して、固定コンテナに追加します。ここでは、ボタンは（100,100）の位置に配置されます。

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

ステップ3 *-固定コンテナに複数のコントロールを配置できます。そして、それをトップレベルウィンドウに追加し、 show_all（）*メソッドを呼び出します

self.add(fixed)
self.show_all()

ただし、この絶対レイアウトは次の理由により適切ではありません-

ウィンドウのサイズを変更しても、ウィジェットの位置は変わりません。
解像度が異なるディスプレイデバイスでは、外観が均一でない場合があります。
フォーム全体の再設計が必要になる可能性があるため、レイアウトの変更は困難です。

以下は*元のウィンドウ*です-

Hello World

以下は*サイズ変更されたウィンドウ*です-

PyGTK Hello World

ボタンの位置はここでは変わりません。

PyGTK APIは、コンテナ内のウィジェットの配置の管理を強化するためのコンテナクラスを提供します。絶対配置に対するレイアウトマネージャーの利点は次のとおりです-

ウィンドウ内のウィジェットは自動的にサイズ変更されます。
異なる解像度のディスプレイデバイスで均一な外観を保証します。
再設計することなく、ウィジェットを動的に追加または削除できます。

gtk.Containerは、次のクラスの基本クラスとして機能します-

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

PyGTK-ボックスクラス

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（）

このメソッドは、ボックスの開始を参照してパックされたボックスに*子*を追加します-

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

以下はパラメータです-

子-これはボックスに追加されるウィジェットオブジェクトです
expand -子にボックス内の余分なスペースを与える場合、これはTrueに設定されます。余分なスペースは、すべての子*ウィジェット*に分割されます。
fill -Trueの場合、追加のスペースが子に割り当てられます。それ以外の場合、このパラメーターはパディングとして使用されます。
padding -これは、ボックス内のウィジェット間のピクセル単位のスペースです。

gtk_box_pack_end（）

これにより、ボックスの末尾への参照でパックされたボックスに子が追加されます。

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

以下はパラメータです-

子-これは追加されるウィジェットオブジェクトです
expand -子にボックス内の余分なスペースを与える場合、これはTrueに設定されます。この余分なスペースは、すべての子ウィジェット間で分割されます。
fill -Trueの場合、追加のスペースが子に割り当てられます。
padding -これは、ボックス内のウィジェット間のピクセル単位のスペースです。
set_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()

上記のコードは、次の出力を生成します-

ボックスデモ

PyGTK-ButtonBoxクラス

gtk APIのButtonBoxクラスは、コンテナの基本クラスとして機能し、複数のボタンを水平または垂直に保持します。 HButtonBoxとVButtonBoxの2つのサブクラスは、ButtonBoxクラスから派生しています。ButtonBoxクラス自体は、gtk.Boxクラスのサブクラスです。

ボタンボックスは、アプリケーション全体で一貫したボタンのレイアウトを提供するために使用されます。すべてのウィジェットにわたって持続する1つのデフォルトレイアウトとデフォルトの間隔値を提供します。

gtk.Boxクラスの* set_spacing（）*メソッドを使用して、ボタンボックス内のボタン間のデフォルトの間隔を変更できます。

ボタンのデフォルトのレイアウトは、* set_default（）*メソッドによって変更できます。ボタンレイアウトの可能な値は次のとおりです-

gtk.BUTTONBOX_SPREAD
gtk.BUTTONBOX_EDGE
gtk.BUTTONBOX_START
gtk.BUTTONBOX_END。

例

次の例では、トップレベルウィンドウ内のVBoxオブジェクトには内部に1つのVButtonBoxオブジェクトと1つのHButtonBoxオブジェクトが含まれ、それぞれに2つのボタンが含まれ、それぞれ垂直と水平に配置されています。

コードを観察します-

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

上記のコードは、次の出力を生成します-

ButtonBox Demo

PyGTK-アライメントクラス

このウィジェットは、子ウィジェットの配置とサイズを制御するのに役立ちます。 xalign、yalign、xscale、yscaleという4つのプロパティがあります。スケールプロパティは、子ウィジェットが使用する空きスペースの量を指定します。 alignプロパティは、使用可能な領域内に子ウィジェットを配置するために使用されます。

4つのプロパティはすべて、0〜1.0の浮動小数点値を取ります。 xscaleプロパティとyscaleプロパティが0に設定されている場合、ウィジェットは空きスペースをまったく吸収せず、1に設定されている場合、ウィジェットは最大空きスペースをそれぞれ水平または垂直に吸収します。

0に設定されている場合、xalignおよびyalignプロパティは、ウィジェットの左または上に空きスペースがないことを意味します。 1に設定すると、ウィジェットの左または上に最大の空きスペースができます。

gtk.alignmentクラスには、次のコンストラクタがあります-

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

どこで、

xalign -子ウィジェットの左側にある水平方向の空き領域の割合です。
yalign -子ウィジェットの上の垂直方向の空き領域の割合です。
xscale -は、子ウィジェットが吸収する水平方向の空き領域の割合です。
yscale -は、子ウィジェットが吸収する垂直方向の空き領域の割合です。

例

次のコードは、gtk.alignmentウィジェットの使用方法を示しています。トップレベルウィンドウのVboxには、上部のVboxと下部のHboxが配置されています。上部の垂直ボックスでは、ラベルと入力ウィジェットが左に向かって配置され、50％のスペースが解放され、25％以上が0.5 xalignおよび0.25をyalignプロパティに割り当てることで占有されます。

下部のHBoxでは、使用可能なすべての空き領域が左側にあります。これは、xalignプロパティに1を割り当てることで実現されます。したがって、水平ボックス内の2つのボタンは右揃えで表示されます。

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クラス

PyGTKツールキットの一部のウィジェットには、独自のウィンドウがありません。このようなウィンドウレスウィジェットは、イベント信号を受信できません。そのようなウィジェット、たとえばラベルは、イベントボックス内に配置されている場合、信号を受信できます。

EventBoxは、ウィンドウを持たないウィジェットにウィンドウを提供する非表示のコンテナーです。それは引数なしのシンプルなコンストラクタを持っています-

gtk.EventBox()

例

次の例では、gtk.EventBoxの2つのウィジェットがトップレベルウィンドウに配置されています。各イベントボックス内に、ラベルが追加されます。これで、イベントボックスはコールバック関数に接続され、そのボタンで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()

上記のコードは、次の出力を生成します-

EventBox Demo

コンソールでラベル1をクリックすると、「ラベル1をクリックしました」というメッセージが印刷されます。同様に、ラベル2をクリックすると、「ラベル2をクリックしました」というメッセージが出力されます。

PyGTK-レイアウトクラス

gtk.Layoutは、gtk.Fixedに似たコンテナウィジェットです。ウィジェットは、絶対座標を指定してレイアウトウィジェットに配置されます。ただし、レイアウトは次の点で固定ウィジェットとは異なります-

レイアウトウィジェットは、無限の幅と高さを持つことができます。幅と高さの最大値は、符号なし整数のサイズによって制限されます。
gtk.DrawingAreaウィジェットは、レイアウトコンテナーで囲むことができます。 DrawingAreaは、線、長方形などの2D要素が配置されたキャンバスです。描くことができます。
レイアウトコンテナをより小さな次元のトップレベルウィンドウに配置するには、スクロールコンテナに関連付けるか、ScrolledWindowに配置します。

gtk.Layoutクラスには、次のコンストラクタがあります-

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

*hadjustment* および *vadjustment* プロパティは、調整可能な境界値を持つオブジェクトを表します。

次の表は、レイアウトで頻繁に使用される方法を示しています-

put(widget, x, y)	Places a child widget at the specified coordinates
set_size(w, h)	Sets the size of the Layout container to the specified width and height

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

上記のコードは、次の出力を生成します-

レイアウト

PyGTK-ComboBoxクラス

ComboBoxは、あらゆるGUIツールキットの強力で人気のあるウィジェットです。ユーザーが選択できるアイテムのドロップダウンリストを提供します。 gtk.ComboBoxウィジェットはCellLayoutインターフェースを実装し、アイテムの表示を管理するための多くのメソッドを提供します。

gtk.ComboBoxクラスのオブジェクトはListSoreに関連付けられています。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	Methods and Description
1	set_wrap_width() ポップアップテーブルレイアウトに表示される列の数を設定します
2	get_active() 現在アクティブなアイテムのモデルのインデックスである「アクティブ」プロパティの値を返します
3	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ウィジェットは次の信号を発します-

changed	This is emitted when a new item in the combo box is selected
move_active	This is a keybinding signal which gets emitted to move the active selection.
Popdown	This is a keybinding signal which gets emitted to popdown the combo box list. The default bindings for this signal are Alt+Up and Escape
Popup	This is a keybinding signal which gets emitted to popup the combo box list. The default bindings for this signal are Alt+Down.

ComboBoxのデモ用の2つのサンプルコードを以下に示します。

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

実行すると、プログラムは次の出力を表示します-

ComboBox

例2

プログラムの2番目のバージョンは、コンボボックスとappend_text（）関数を作成して文字列を追加するために、便利なメソッド* combo_box_new_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()

このプログラムの出力は、前のプログラムの出力に似ています。

ComboBox

PyGTK-ToggleButtonクラス

ToggleButtonウィジェットは、 pressedまたはactive （またはon）状態と* normalまたはinactive（またはoff）*状態の2つの状態を持つgtk.Buttonです。ボタンを押すたびに、状態が切り替わります。トグルボタンの状態は、set_active（）メソッドによってプログラムで変更することもできます。ボタンの状態を切り替えるには、toggled（）メソッドも使用できます。

gtk.ToggleButtonクラスには、次のコンストラクタがあります-

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

ここで、ラベルはボタンに表示されるテストです。 use_underlineプロパティは、Trueの場合、テキスト内の下線は次の文字に下線を付けてニーモニックアクセラレータに使用することを示します。

gtk.ToggleButtonクラスの重要なメソッドのいくつかは、次の表に記載されています-

set_active()	This sets the *active property to the value to True (active or pressed or on) or** False* (inactive or normal or off)
get_active()	This retrieves the state of button
toggled()	This emits the "toggled" signal on the togglebutton.

トグルボタンウィジェットは、次の信号を発します-

Toggled

This is emitted when the togglebutton state changes either programmatically or by the user action.

以下のコードは、ToggleButtonウィジェットの使用方法を示しています。

2つの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()

上記のコードは、次の出力を生成します-

トグルボタン

PyGTK-CheckButtonクラス

CheckButtonウィジェットは、チェックボックスとラベルとしてスタイル設定されたToggleButtonに他なりません。 ToggleButtonクラスからすべてのプロパティとメソッドを継承します。キャプションがボタンの表面にあるトグルボタンとは異なり、CheckButtonはチェック可能な小さな正方形を表示し、その右にラベルがあります。

gtk.CheckButtonに関連付けられているコンストラクター、メソッド、およびシグナルは、gtk.ToggleButtonとまったく同じです。

例

次の例は、CheckButtonウィジェットの使用方法を示しています。 2つのCheckButtonとLabelがVBoxに配置されます。最初のCheckButtonのトグルされた信号はon_checked（）メソッドに接続され、2番目のボタンの状態がfalseの場合は2番目のボタンの状態をtrueに設定します。

コードを観察します-

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

上記のコードは、次の出力を生成します-

チェックボタン

PyGTK-RadioButtonクラス

単一のRadioButtonウィジェットは、CheckButtonと同様の機能を提供します。ただし、同じコンテナに複数のラジオボタンが存在する場合、ユーザーは利用可能なオプションのいずれかを選択するために相互に排他的な選択肢を利用できます。コンテナ内のすべてのラジオボタンが同じグループに属している場合、1つを選択すると、他のボタンは自動的に選択解除されます。

以下は、gtk.RadioButtonクラスのコンストラクタです-

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

ボタングループを作成するには、最初のラジオボタンに group = None を指定し、後続のオプションに最初のボタンのオブジェクトをグループとして指定します。

ToggleButtonおよびCheckButtonの場合と同様に、RadioButtonも*トグル信号*を発します。以下の例では、gtk.RadioButtonウィジェットの3つのオブジェクトが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()

上記のコードは、次の出力を生成します-

ラジオボタン

PyGTK-MenuBar、MenuおよびMenuItem

トップレベルgtk.Windowのタイトルバーのすぐ下にある水平バーは、一連のメニューを表示するために予約されています。 PyGTK APIのgtk.MenuBarクラスのオブジェクトです。

gtk.Menuクラスのオブジェクトがメニューバーに追加されます。また、コンテキストメニューとポップアップメニューの作成にも使用されます。各メニューには、1つ以上の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クラスの1つ以上のウィジェットをメニューに追加できます。

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

これらのMenuItemはメニューウィジェットに追加され、メニューオブジェクトはメニューバーに追加されます。

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

上記のコードは、次の出力を生成します-

メニューデモ

PyGTK-ツールバークラス

ツールバークラスは、gtk.Containerクラスから継承されます。一連のボタンおよびその他のウィジェットを保持および管理します。通常、最上位ウィンドウのメニューバーのすぐ下に、1つ以上の水平方向のボタンが表示されます。ツールバーは、HandleBoxと呼ばれる取り外し可能なウィンドウに配置することもできます。デフォルトでは、gtk.Toolbarウィジェットのボタンは水平に配置されます。方向プロパティを gtk.ORIENTATION_VERTICAL に設定することにより、垂直ツールバーを設定できます。

ツールバーは、アイコン、テキスト、またはその両方でボタンを表示するように構成できます。スタイル列挙子は-

gtk.TOOLBAR_ICONS	These buttons display only icons in the toolbar.
gtk.TOOLBAR_TEXT	These buttons display only text labels in the toolbar.
gtk.TOOLBAR_BOTH	These buttons display text and icons in the toolbar.
gtk.TOOLBAR_BOTH_HORIZ	These buttons display icons and text alongside each other, rather than vertically stacked.

ツールバーウィジェットは、次のコンストラクタを使用して設定されます-

bar = gtk.Toolbar()

ツールバーの構成要素は、gtk.ToolItemのインスタンスです。アイテムは、ToolButton、RadioToolButton、ToggleToolButton、またはSeparatorToolItemです。 ToolItemオブジェクトにアイコンを割り当てるには、事前定義されたstock_IDの画像を使用するか、set_image（）メソッドでカスタム画像を割り当てることができます。

次の例は、さまざまなToolItemsを構築する方法を示しています-

ツールボタン

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-調整クラス

PyGTKツールキットの一部のウィジェットでは、ユーザーがマウスまたはキーボードを使用して、指定した範囲でプロパティを調整できます。 Viewportのようなウィジェットは、TextViewコントロールの複数行テキストなど、大きなデータの調整可能な部分を表示するために使用されます。

PyGTKはgtk.Adjustmentオブジェクトを使用して、このようなウィジェットと関連付けて使用し、ユーザー調整が処理のためにコールバック関数に渡されるようにします。調整オブジェクトには、調整可能な値の下限と上限、およびその増分ステップパラメーターが含まれます。調整オブジェクトのパラメーターが変更されると、changedまたはvalue_changed信号が送信されます。

以下は、gtk.Adjustmentクラスのコンストラクタです-

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

コンストラクタ内の各属性の意味は次のとおりです-

value	The initial value
lower	The minimum value
upper	The maximum value
step_incr	The step increment
page_incr	The page increment
page_size	The page sizes

次の信号は、調整オブジェクトによって放出されます-

Changed	This is emitted when one (or more) of the adjustment attributes (except the value attribute) has changed.
Value-changed	This is emitted when the adjustment value attribute has changed.

前述のように、調整オブジェクトは物理的なウィジェットではありません。むしろ、属性が変更される他のウィジェットと関連して使用されます。範囲ウィジェットは、調整オブジェクトとともに使用されます。

PyGTK-範囲クラス

このクラスは、ユーザーが数値パラメーターの値を下限と上限の間で調整できるウィジェットの基本クラスとして機能します。スケールウィジェット（gtk.Hscaleおよびgtk.Vscale）およびスクロールバーウィジェット（gtk.HScrollbarおよびgtk.VScrollbar）は、Rangeクラスから機能を派生させます。これらの範囲ウィジェットは、調整オブジェクトと連動して機能します。

gtk.Rangeクラスの次の重要な機能は、ScaleおよびScrollbarウィジェットによって実装されます-

* set_update_policy（）*-「update-policy」プロパティに値を設定します。ポリシーには次の値があります-

gtk.UPDATE_CONTINUOUS	anytime the range slider is moved, the range value will change and the "value_changed" signal will be emitted.
gtk.UPDATE_DELAYED	the value will be updated after a brief timeout where no slider motion occurs, so value changes are delayed slightly rather than continuously updated.
gtk.UPDATE_DISCONTINUOUS	the value will only be updated when the user releases the button and ends the slider drag operation.

* set_adjustment（）*-これは「調整」プロパティを設定します。調整オブジェクトは、範囲オブジェクトのモデルとして使用されます。
* set_increments（）*-これは、範囲のステップサイズとページサイズを設定します。
* set_range（）*-これは範囲ウィジェットの最小および最大許容値を設定します
* set_value（）*-これは、範囲の現在の値を指定された値に設定します。

スケールウィジェットクラス-（HScaleおよびVScale）は、gtk.Rangeクラスから派生しています。

PyGTK-スケールクラス

このクラスは、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)

調整オブジェクトには、値と境界へのアクセスを提供する多くの属性が含まれています。

PyGTK-スクロールバークラス

このクラスは、gtk.Hscrollbarおよびgtk.Vscrollbarウィジェットの抽象基本クラスです。どちらも調整オブジェクトに関連付けられています。スクロールバーのつまみの位置は、スクロール調整によって制御されます。調整オブジェクトの属性は次のように使用されます-

lower	The minimum value of the scroll region
upper	The maximum value of the scroll region
value	Represents the position of the scrollbar, which must be between lower and upper
page_size	Represents the size of the visible scrollable area
step_increment	Distance to scroll when the small stepper arrows are clicked
page_increment	Distance to scroll when the *Page Up or** Page Down* keys pressed

次のプログラムは、トップレベルウィンドウに追加された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オブジェクトに関連付けられています。更新ポリシーも「継続」に設定されています。

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

スクロールバーの瞬時値を表示するために、調整オブジェクト— adj2 *の 'value-changed’信号がコールバック関数 on_scrolled（）*に接続されています。この関数は、調整オブジェクトのvalueプロパティを取得し、スクロールバーの下のラベルに表示します。

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ウィジェットは、親ウィンドウの上にあるポップアップウィンドウとして使用されます。ダイアログの目的は、ユーザーからいくつかのデータを収集し、それを親ウィンドウに送信することです。ダイアログは、モーダル（親フレームをブロックする）またはモードレス（ダイアログフレームをバイパスできます）にできます。

PyGTKライブラリのDialogウィジェットは、垂直に分割されたウィンドウです。上部のセクションには、ラベルウィジェットまたはエントリウィジェットがパックされたgtk.VBoxがあります。下部のセクションは、1つ以上のボタンが配置されるaction_areaと呼ばれます。 2つの領域はgtk.HSeparatorで区切られています。

gtk.Dialogクラスには、次のコンストラクタがあります-

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

どこで、

タイトル-ダイアログウィジェットのタイトルバーに表示されるテキストです。
Parent -ダイアログが表示されるトップレベルウィンドウへの参照です。
Flag -Dialogの動作を制御する定数を定義します。定義された定数は-

gtk.DIALOG_MODAL	If set, the dialog grabs all the keyboard events
gtk.DIALOG_DESTROY_WITH_PARENT	If set, the dialog is destroyed when its parent is.
gtk.DIALOG_NO_SEPARATOR	If set, there is no separator bar above the buttons.

ボタンとは何ですか？

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（）-action_areaで *button_text （またはbutton_textがストックIDの場合はストックボタン）で指定されたテキストのボタンを追加します。
* response（）*-response_idで指定された値を持つ「応答」信号を発行します
* run（）*-ダイアログを表示し、delete_eventが発行されるとresponse_idを返します。
* set_default_response（）-ダイアログのデフォルトウィジェットとして指定された *response_id を使用して、ダイアログのアクション領域の最後のウィジェットを設定します。

gtk.Dialogウィジェットは、次の信号を発します-

Close	This is emitted when the dialog is closed.
Response	This is emitted when an action_area widget is activated (button "clicked"), the dialog receives a delete_event or the application calls the response() method.

Dialogウィジェットのaction_areaの2つのボタンは、ストックID gtk.STOCK.CANCELおよびgtk.STOCK_OKを使用します。これらは、応答ID gtkに関連付けられています。 RESPONSE_REJECTおよびgtk。それぞれRESPONSE_ACCEPT。ボタンを押すと、ダイアログが閉じます。 run（）メソッドは、対応する応答IDを返します。これは、さらに処理するために利用できます。

次のコードは、ボタンを含む最上位のgtk.Windowを表示します。ボタンをクリックすると、ラベルと2つのボタンを含むダイアログが表示されます。

例

次のコードを観察してください-

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

上記のコードは、次の出力を生成します-

ダイアログボックス

PyGTK-MessageDialogクラス

Messagedialogウィジェットは、メッセージのタイプ（エラー、質問、または何らかの情報テキスト）を表す画像を表示するように構成されたダイアログウィンドウです。 MessageDialogオブジェクトは、次のコンストラクタを使用して宣言されています-

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

次の事前定義されたメッセージタイプは、メッセージダイアログを設定するために使用されます-

gtk.MESSAGE_INFO	This is an informational message
gtk.MESSAGE_WARNING	This is a nonfatal warning message
gtk.MESSAGE_QUESTION	This question requires a choice
gtk.MESSAGE_ERROR	This is a fatal error message

事前定義されたボタンセットのセットも使用できます。

gtk.BUTTONS_NONE	No buttons at all
gtk.BUTTONS_OK	This is an OK button
gtk.BUTTONS_CLOSE	This is a Close button
gtk.BUTTONS_CANCEL	This is a Cancel button
gtk.BUTTONS_YES_NO	These are the Yes and No buttons
gtk.BUTTONS_OK_CANCEL	These are OK and Cancel buttons

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

上記の機能は、次の出力を生成します-

エラーメッセージ

PyGTK-AboutDialogクラス

ロゴ、名前、著作権、ウェブサイト、ライセンスなどのプログラムに関する情報を表示する簡単な方法は、gtk.AboutDialogウィジェットによって提供されます。通常、ユーザーが Help メニューから About オプションを選択すると、Aboutダイアログが開きます。ダイアログのすべての部分はオプションです。

*About Dialog* にはURLと電子メールアドレスを含めることができます。 gtk.AboutDialogは、ユーザーがURLとメールIDをクリックしたときにグローバルフックを提供します

以下は、gtk.AboutDialogクラスのコンストラクタです-

dlg = gtk.AboutDialog()

*About Dialog* を設定するには、次の方法が使用されます

* set_program_name（）-これは、 *About Dialog に表示される名前を設定します。デフォルトはapplication_name（）です。
* set_version（）*-これは「バージョン」プロパティを設定します
* set_copyright（）*-これは「著作権」を設定します。 [*なし] *の場合、著作権表示は非表示です。
* set_license（）*-これは「ライセンス」を設定します。 [*なし] *の場合、ライセンスボタンは非表示です。
* set_website（）*-これは、「website」プロパティを有効なURLである文字列に設定します。
* set_author（）*-これは、「authors」プロパティを、セカンダリクレジットダイアログの[authors]タブに表示される著者名のリストに設定します。
* set_logo（）*-「logo」プロパティをPixbufオブジェクトに設定します。 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) finddevguides")
   about.set_comments("About Dialog example")
   about.set_website("http://www.finddevguides.com")

   about.run()
   about.destroy()

上記の関数は、次の出力を生成します-

PyGTKダイアログについて

PyGTK-フォント選択ダイアログ

gtk.FontSelectionウィジェットを使用すると、ユーザーは特定の名前、サイズ、スタイルのフォントを選択して適用できます。このダイアログには、選択したフォントの説明に表示されるテキストを含むプレビューボックスと、キャンセルとOKの2つのボタンがあります。

PyGTK APIには、高品質の国際化テキストのレンダリングに必要なクラスと機能を定義するPangoモジュールが含まれています。 gtkでのフォントとテキストの処理は、Pangoでサポートされています。 pango.Fontオブジェクトは、システムに依存しない方法でフォントを表します。 pango.FontDescriptionオブジェクトには、フォントの特性が含まれています。

gtk.FontSelectionDialogは、pango.Fontオブジェクトを返します。選択したフォントを適用するために、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) finddevguides")
   about.set_comments("About Dialog example")
   about.set_website("http://www.finddevguides.com")
   about.run()
   about.destroy()

選択したフォントは、トップレベルウィンドウに配置されたラベルのテキストに適用されます。

フォントの選択

以下は出力です-

フォントダイアログボックス

PyGTK-色選択ダイアログ

これは、ユーザーが色を選択して適用できるPyGTK APIの事前設定されたダイアログです。内部にgtk.ColorSelectionウィジェットを埋め込みます。

gtk.ColorScelectionウィジェットは、コローホイールと、HSVやRGBなどの色パラメーターの入力ボックスを提供します。カラーホイールを操作するか、カラーパラメータを入力して、新しい色を選択できます。その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)

選択した色は、ウィンドウ上のラベルウィジェットのテキストに適用されます-

色を選択

以下は出力です-

カラーダイアログボックス

PyGTK-ファイル選択ダイアログ

このダイアログは、開いたり保存したりする必要があるファイルの場所と名前をユーザーが選択できるようにするのに役立ちます。 FileChooserWidgetを埋め込み、action_areaにOKボタンとCANCELボタンを提供します。

以下は、gtk.FileChooserDialogクラスのコンストラクタです-

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

パラメータは次のとおりです-

title	This is the title of the dialog
parent	The transient parent of the dialog, or None
action	The open or save mode for the dialog
buttons	This is a tuple containing button label-response id pairs or None
backend	The name of the specific filesystem backend to use.

以下は、アクションモードです-

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

ファイルはダイアログから選択されます-

File Chooser Open

選択したファイルは、トップレベルのgtk.Window上のラベルに表示されます-

ファイルダイアログボックス

PyGTK-ノートブッククラス

ノートブックウィジェットはタブ付きのコンテナです。このコンテナの各タブには異なるページがあり、ページは重複して表示されます。タブのラベルをクリックすると、目的のページが表示されます。ラベルは、上または下、または左または右に表示されるように構成できます。他のウィジェットが配置されたコンテナウィジェットまたは単一のウィジェットが各ページの下に配置されます。

表示するデータが1つのビューで大きすぎる場合は、異なるページにグループ化され、それぞれがノートブックウィジェットの1つのタブの下に配置されます。このタイプのコントロールは非常に広く使用されています。たとえば、インターネットブラウザは、このタブ付きディスプレイを使用して、さまざまなタブのさまざまなページをレンダリングします。

以下は、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（）*-falseの場合、タブは表示されません。これはデフォルトで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ウィジェットは、次の信号を発します-

change-current-page	This is emitted when the page forward or page backward request is issued
focus-tab	This is emitted when the focus is changed by tabbing.
page-added	This is emitted when a page is added to the notebook.
page-removed	This is emitted after a page is removed from the notebook.
select-page	This is emitted when a new child page is selected.
switch-page	This is emitted when the notebook page is changed.

例

次の例では、3ページのgtk.Notebookがトップレベルのgtk.Windowに配置されています。最初のページには、ラベルと入力フィールドがパックされたVBoxがあります。「qualifications」というラベルが付いた2番目のページには、相互に排他的な3つのRadioButtonウィジェットが追加されるHButtonBoxがあります。 3番目のページには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ページのノートブックを表示します-

画像：/pygtk/images/notebook_demo.jpg [NoteBook Demo]画像：/pygtk/images/notebook.jpg [NoteBook]

PyGTK-フレームクラス

フレームクラスは、gtk.Binクラスのサブクラスです。配置された子ウィジェットの周りに装飾的な境界線を描画します。フレームには、位置をカスタマイズできるラベルを含めることができます。

gtk.Frameオブジェクトは、次のコンストラクタの助けを借りて構築されます-

frame = gtk.Frame(label = None)

以下は、gtk.Frame（）クラスのメソッドです-

* set_label（text）-これは、 *text で指定されたラベルを設定します。 *なし*の場合、現在のラベルは削除されます。
* 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

次のコードは、Frameウィジェットの機能を示しています。 gtk.RadioButtonの3つのオブジェクトのグループは、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()

上記のコードは、次の出力を生成します-

フレームデモ

PyGTK-AspectFrameクラス

gtk.AspectFrameクラスは、Frameクラスのサブクラスです。このフレームの子ウィジェットは、メインウィンドウのサイズが変更されても、常に縦横比（幅と高さ）を保持します。

gtk.AspectFrameウィジェットのratioプロパティは、ウィジェットの幅と高さの比率を決定します。アスペクト比0.5は、幅が高さの半分であることを意味します。アスペクト比2.0は、幅が高さの2倍であることを意味します。「比率」プロパティのデフォルト値は1.0です。

次の構文はgtk.AspectFrameクラスのコンストラクタに使用されます-

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

*xalign* プロパティは、子の左側の水平方向の空き領域の割合を決定します。 0.0は左側に_free_スペースがないことを意味し、1.0は左側にすべての_free_スペースがあることを意味します。

*yalign* プロパティは、子の上にある垂直方向の空き領域の割合を決定します。 0.0は_free_スペースがないことを意味し、1.0はすべての_free_スペースがあることを意味します。

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

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

上記のコードは、次の元のサイズ変更されたウィンドウを生成します-

アスペクトフレームデモ

元のウィンドウ

アスペクトフレームデモ

サイズ変更されたウィンドウ

PyGTK-TreeViewクラス

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は、複数列のTreeウィジェットのモデルです。たとえば、次のステートメントは、文字列項目を持つ1つの列を持つストアを作成します。

Store = gtk.TreeStore(gobject.TYPE_STRING)

TreeStoreにアイテムを追加するには、append（）メソッドを使用します。 append（）メソッドには、親と行の2つのパラメーターがあります。トップレベルのアイテムを追加するには、親は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オブジェクトを開始列にパックします。 expandパラメータがTrueに設定されている場合、割り当てられたスペース全体がセルに割り当てられます。 TreeViewColumn.add_attribute（cell、attribute、column）-このメソッドは、属性マッピングをツリー列のリストに追加します。 column *はツリーモデルの列です。
TreeViewColumn.set_attributes（）−このメソッドは、 attribute = column のペアを使用して*レンダラー*の属性の場所を設定します TreeViewColumn.set_visible（）− Trueの場合、*ツリービュー列が表示されます
TreeViewColumn.set_title（）-このメソッドは、「title」プロパティを指定された値に設定します。
TreeViewColumn.set_lickable（）-Trueに設定されている場合、ヘッダーはキーボードフォーカスを取得してクリックできます。
TreeViewColumn.set_alignment（xalign）-このメソッドは、「alignment」プロパティを xalign の値に設定します。

ユーザーが_treeviewcolumn_ヘッダーボタンをクリックすると、「クリックされた」シグナルが発行されます。

TreeViewColumnオブジェクトを構成すると、append_column（）メソッドを使用してTreeViewウィジェットに追加されます。

以下は、TreeViewクラスの重要なメソッドです-

 *TreevVew.set_model（）-これは、ツリービューの「モデル」プロパティを設定します。 ツリービューにモデルセットが既にある場合、このメソッドは新しいモデルを設定する前にそれを削除します。* model *が *None* の場合、古いモデルは設定解除されます。
* TreeView.set_header_clickable（）-Trueに設定されている場合、列タイトルボタンをクリックできます。
* TreeView.append_column（）-これは、指定された *TreeViewColumn* を列のリストに追加します。
* TreeView.remove_column（）-これは、指定された列をツリービューから削除します。
* TreeView.insert_column（）-これは、指定された *column* をツリービューの *position* で指定された場所に挿入します。

TreeViewウィジェットは、次の信号を発します-

cursor-changed	This is emitted when the cursor moves or is set.
expand-collapse-cursor-row	This is emitted when the row at the cursor needs to be expanded or collapsed.
row-activated	This is emitted when the user double clicks a treeview row
row-collapsed	This is emitted when a row is collapsed by the user or programmatic action.
row-expanded	This is emitted when a row is expanded via the user or programmatic action.

TreeViewウィジェットの2つの例を以下に示します。最初の例では、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コールバック*関数が呼び出されると、ウィンドウのラベルに表示されます。

ListStoreのあるTreeView

例2

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のあるTreeView

PyGTK-ペインクラス

Panedクラスは、2つの調整可能なペインを水平（gtk.Hpaned）または垂直（gtk.Vpaned）に表示できるウィジェットの基本クラスです。ペインに子ウィジェットを追加するには、pack1（）およびpack2（）メソッドを使用します。

パンウィジェットは、2つのペインの間にセパレータスライダーを描画し、相対的な幅/高さを調整するためのハンドルを提供します。ペイン内の子ウィジェットのサイズ変更プロパティが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）-これは、2つのペイン間の仕切りの位置を設定します。

Panedウィジェットの両方のタイプは、次の信号を発します-

accept-position	This is emitted when* paned *has the focus causing the child widget with the focus to be activated.
cancel-position	This is emitted when the* Esc key is pressed while paned *has the focus.
move-handle	This is emitted when* paned *has the focus and the separator is moved.

例

次の例では、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()

上記のコードは、次の出力を生成します-

Hpaned Widget Demo

PyGTK-ステータスバークラス

通常、ウィンドウの下部にある通知領域は、ステータスバーと呼ばれます。あらゆる種類のステータス変更メッセージをステータスバーに表示できます。また、グリップを使用してサイズを変更できます。

gtk.Statusbarウィジェットは、メッセージのスタックを維持します。したがって、現在のメッセージの上に新しいメッセージが表示されます。ポップされると、以前のメッセージが再び表示されます。メッセージのソースは、context_idで識別して一意に識別する必要があります。

以下は、gtk.Statusbarウィジェットのコンストラクタです-

bar = gtk.Statusbar()

以下は、gtk.Statusbarクラスのメソッドです-

* Statusbar.push（context_id、text）*-これは新しいメッセージをステータスバーのスタックにプッシュします。
* Statusbar.pop（context_id）-これは、ステータスバーのスタックから指定された *context_id を持つトップメッセージを削除します。

次の信号は、Statusbarウィジェットによって発行されます-

text-popped	This is emitted when a message is removed from the statusbar message stack.
text-pushed	This is emitted when a message is added to the statusbar message stack.

次の例は、ステータスバーの機能を示しています。トップレベルウィンドウには、2行のVBoxが含まれています。上の行には、ラベル、入力ウィジェット、およびボタンが配置される固定ウィジェットがあります。一方、一番下の行には、gtk.Statusbarウィジェットが追加されています。

メッセージをステータスバーに送信するには、context_idを取得する必要があります。

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

Buttonオブジェクトの「クリック」信号は、ステータスバーにメッセージがプッシュされるコールバック関数に接続されます。また、入力ウィジェット内でEnterキーが押されると、「アクティブ化」シグナルが発行されます。このウィジェットは別のコールバックに接続されています。

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キーを押すと、ステータスバーに「テキストが入力されました」というメッセージが表示されます。

PyGTK-ProgressBarクラス

進行状況バーは、ユーザーに実行時間の長いプロセスを視覚的に示すために使用されます。 gtk.ProgressBarウィジェットは、パーセンテージモードとアクティビティモードの2つのモードで使用できます。

完了が保留されている作業の量を正確に推定できる場合、進行状況バーはパーセントモードで使用でき、ユーザーには完了したジョブの割合を示す増分バーが表示されます。一方、完了すべき作業量を正確に決定できる場合、進行状況バーはアクティビティモードで使用され、バーは前後に移動するブロックを表示してアクティビティを表示します。

次のコンストラクタは、gtk.ProgressBarクラスのウィジェットを初期化します-

pb = gtk.ProgressBar()

gtk.ProgressBarは機能を管理するために次のメソッドを使用します-

* ProgressBar.pulse（）*-これはプログレスバーをナッジして、ある程度の進行が行われたことを示しますが、その程度はわかりません。このメソッドは、プログレスバーモードを「アクティビティモード」に変更します。このモードでは、ブロックが前後にバウンドします。
* ProgressBar.set_fraction（fraction）-これにより、進行状況バーが *fraction で指定されたバーの部分を「埋める」ようになります。 fraction の値は0.0から1.0の間でなければなりません。
* ProgressBar.set_pulse_setup（）-これは、 pulse（）メソッドの呼び出しごとにバウンスブロックを移動するために、プログレスバーの合計長の（ *fraction で指定される）部分を設定します。
* 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ウィジェットがアクティビティモードで使用されています。したがって、進行状況の初期位置は* set_fraction（）*メソッドによって0.0に設定されます。

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

100ミリ秒後に進行状況を1％増加させるために、タイマーオブジェクトが宣言され、100ミリ秒ごとにコールバック関数が呼び出されるように設定され、進行状況バーが更新されます。

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

上記のコードは、次の出力を生成します-

ProgressBar Demo

アクティビティモードでプログレスバーを使用するには、コールバック関数を次のように変更して実行します-

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

進行状況バー内のブロックの前後の動きは、アクティビティの進行状況を示します。

ProgressBar Demo

PyGTK-ビューポートクラス

ウィジェットにトップレベルウィンドウよりも大きい領域がある場合、ViewPortコンテナに関連付けられます。 gtk.Viewportウィジェットは、ScrolledWindowで使用される調整機能を提供します。たとえば、ラベルウィジェットには調整はありません。したがって、ビューポートが必要です。一部のウィジェットには、ネイティブのスクロールサポートがあります。ただし、Labelまたはgtk.Tableウィジェットには、組み込みのスクロールサポートがありません。したがって、ビューポートを使用する必要があります。

ViewPortクラスには次のコンストラクタがあります-

gtk.Viewport(hadj, vadj)

ここで、 hadj および vadj は、ビューポートに関連付けられた調整オブジェクトです。

gtk.ViewPortクラスは次のメソッドを使用します-

* Viewport.set_hadjustment（）*-これは「hadjustment」プロパティを設定します
* Viewport.set_vadjustment（）*-これは「vadjustment」プロパティを設定します
* Viewport.set_shadow_type（）-これは、「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信号を発信します。

PyGTK-ScrolledWindowクラス

スクロールウィンドウは、親ウィンドウよりも大きい領域の他のウィジェットにアクセスするために作成されます。スクロールのネイティブサポートの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 ）-このメソッドは、ネイティブのスクロール機能を持たないウィジェット（子によって指定された）をスクロールされたウィンドウに追加するために使用されます。これは、 *gtk.Viewport に child を追加し、スクロールウィンドウにビューポートを追加するのと同等の便利な関数です。

次のコードは、10 x 10の次元を持つgtk.Tableオブジェクトの周りにスクロールウィンドウを追加します。 Tableオブジェクトは調整を自動的にサポートしないため、ビューポートに追加されます。

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

2つのネストされたループを使用して、それぞれ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()

上記のコードは、次の出力を生成します-

ScrolledWindow

PyGTK-Arrowクラス

gtk.Arrowオブジェクトは、4つの基本的な方向を指す単純な矢印を描くために使用されます。このクラスは gtk.Misc クラスから継承され、オブジェクトはラベルやボタンウィジェットなど、割り当てられたスペースを占有します。

通常、矢印オブジェクトは次のコンストラクタを使用して作成されます-

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	No outline.
gtk.SHADOW_IN	The outline is beveled inward.
gtk.SHADOW_OUT	The outline is beveled outward like a button.
gtk.SHADOW_ETCHED_IN	The outline itself is an inward bevel, but the frame bevels outward.
gtk.SHADOW_ETCHED_OUT	The outline is an outward bevel, frame bevels inward.

例

次の例では、4つのButtonウィジェットがHboxに追加されます。各ボタンの上部には、それぞれ上、下、左、右を指すgtk.Arrowオブジェクトが配置されます。 HBOXコンテナは、Alignmentコンテナの助けを借りて、トップレベルウィンドウの下部に配置されます。

コードを観察します-

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

上記のコードは、次の出力を生成します-

矢印デモ

PyGTK-画像クラス

このクラスは、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（）*-これは、現在のディスプレイのピクセル形式でクライアント側の画像バッファから画像データを設定します。画像が*なし*の場合、現在の画像データは削除されます。

例

次のプログラムでは、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()

上記のコードは、次の出力を生成します-

画像デモ

PyGTK-DrawingAreaクラス

DrawingAreaウィジェットは、線、長方形、円弧などのオブジェクトが置かれるgtk.gdk.Windowを含む空白のキャンバスを表示します。描くことができます。

PyGTKは、このような描画操作に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ウィジェットは、それによって発行される次の信号に基づいてコールバックに接続できます-

Realize	To take any necessary actions when the widget is instantiated on a particular display.
configure_event	To take any necessary actions when the widget changes size.
expose_event	To handle redrawing the contents of the widget when a drawing area first comes on screen, or when it’s covered by another window and then uncovered (exposed).

マウスイベントとキーボードイベントは、* gtk.Widgetクラス*の* add_events（）メソッド*によってコールバックを呼び出すためにも使用できます。

特に興味深いのは、DrawingAreaキャンバスが最初に起動したときに発行される露出イベント信号です。 Cairoライブラリで定義されている2Dオブジェクトを描画するためのさまざまなメソッドは、expose-eventシグナルに接続されたこのコールバックから呼び出されます。これらのメソッドは、Cairoデバイスコンテキストに対応するオブジェクトを描画します。

以下は、利用可能な描画方法です-

dc.rectangle（x、y、w、h）-これは、指定された左上の座標で、幅と高さがgivwnの長方形を描画します。
dc.arc（x、y、r、a1、a2）-これは、指定された半径と2つの角度で円弧を描きます。
dc.line（x1、y1、x2、y2）-これは、2つの座標ペアの間に線を引きます。
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()

上記のスクリプトは、次の出力を生成します-

基本形状カイロ

PyGTK-SpinButtonクラス

しばしばSpinnerと呼ばれるSpinnButtonウィジェットは、右に上下の矢印があるgtk.Entryウィジェットです。ユーザーは、数値を直接入力するか、上下の矢印を使用して増減できます。 gtk.SpinButtonクラスは、gtk.Entryクラスから継承されます。スピナーの数値の範囲とステップを制限できるgtk.Adjustmentオブジェクトを使用します。

SpinButtonウィジェットは、次のコンストラクタを使用して作成されます-

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

ここで、adjは範囲を制御する* gtk.Adjustmentオブジェクトを表し、 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）-これは、指定された方向にスピナーの値を増分または減分します。

以下は、事前定義された方向定数です-

gtk.SPIN_STEP_FORWARD	forward by step_increment
gtk.SPIN_STEP_BACKWARD	backward by step_increment
gtk.SPIN_PAGE_FORWARD	forward by step_increment
gtk.SPIN_PAGE_BACKWARD	backward by step_increment
gtk.SPIN_HOME	move to minimum value
gtk.SPIN_END	move to maximum value
gtk.SPIN_USER_DEFINED	add increment to the value

*SpinButton.set_wrap（）— wrapがTrueの場合、範囲の上限または下限を超えると、スピンボタンの値は反対の制限まで折り返します。

gtk.SpinButtonウィジェットは、次の信号を発します-

change-value	This is emitted when the spinbutton value is changed by keyboard action
input	This is emitted when the value changes.
output	This is emitted when the spinbutton display value is changed. Returns* True* if the handler successfully sets the text and no further processing is required.
value-changed	This is emitted when any of the settings that change the display of the spinbutton is changed.
wrapped	This is emitted right after the spinbutton wraps from its maximum to minimum value or vice-versa.

例

次の例では、3つのSpinButtonウィジェットを使用して、単純な Date Selector を構築します。 Day Selectorは、1〜31の値を制限する調整オブジェクトに適用されます。 2番目のセレクターは、月1〜12の数用です。 3番目のセレクタは、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()

実行すると、上記のコードは次の出力を生成します-

SpinButton Demo

PyGTK-カレンダークラス

PyGTKツールキットのカレンダーウィジェットは、一度に1か月表示のシンプルなカレンダーを表示します。月と年を変更するためのナビゲーションコントロールがデフォルトで表示されます。表示オプションは適切に構成できます。

monthプロパティの値は0〜11、dateプロパティの値は1〜31です。

gtk.Calendarオブジェクトを作成する簡単なコンストラクタがあります-

cal = gtk.Calendar()

デフォルトの表示スタイルでは、現在の月と年、および曜日の名前が表示されます。

gtk.Calendarクラスには次のメソッドがあります-

Calendar.select_month（mm、yy）—これにより、カレンダー表示が指定された mm および yy に変更されます。
Calendar.select_day（dd）—これは、カレンダーの値が1から31の間である場合、カレンダーで指定された dd を選択します dd が0の場合、現在の日の選択は削除されます。
Calendar.display_options（）—これは、カレンダー表示オプションを flags で指定された値に設定します。可能な表示オプションは次の組み合わせです。

gtk.CALENDAR_SHOW_HEADING	Specifies that the month and year should be displayed.
gtk.CALENDAR_SHOW_DAY_NAMES	Specifies that three letter day descriptions should be present.
gtk.CALENDAR_NO_MONTH_CHANGE	Prevents the user from switching months with the calendar.
gtk.CALENDAR_SHOW_WEEK_NUMBERS	Displays each week numbers of the current year, down the left side of the calendar.
gtk.CALENDAR_WEEK_START_MONDAY	Starts the calendar week on Monday, instead of the default Sunday.

Calendar.get_date（）—カレンダーの現在の年、月、および選択された日番号をタプル（年、月、日）として取得します。

gtk.Calendarウィジェットは、次の信号を発します-

day-selected	This is emitted when a day is selected either by the user or programmatically.
month-changed	This is emitted when the calendar month is changed programmatically or by the user.
next-month	This is emitted when the user clicks the "next-month" navigation control in the calendar header.
next-year	This is emitted when the user clicks the "next-year" navigation control in the calendar header.
prev-month	This is emitted when the user clicks the "prev-month" navigation control in the calendar header.
prev-year	This is emitted when the user clicks the "prev-year" navigation control in the calendar header.

次の例では、gtk.Calendarコントロールと4つのボタンがトップレベルウィンドウに配置されています。

「見出し」ボタンをクリックすると、カレンダーの表示オプションが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)

「両方」ボタンを押すと、両方の表示オプションが有効になります。まず、表示オプションのすべてのフラグを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()

上記のコードは、次の出力を生成します-

カレンダーデモ

PyGTK-クリップボードクラス

クリップボードオブジェクトは、同じアプリケーションの2つのプロセスまたは2つのウィジェット間で共有データを保持します。 gtk.Clipboardは、gtk.SelectionDataクラスの高レベルインターフェイスです。

以下は、gtk.Clipboardコンストラクタのプロトタイプです-

gtk.Clipboard(display,selction)

ここで、表示パラメーターは、クリップボードを作成または取得する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 の署名は次のとおりです。
defコールバック（クリップボード、テキスト、データ）-テキストには、クリップボードから取得した*テキスト*が含まれます。

クリップボードのデモとして、次のコードではトップレベルのgtk.Windowで2つのTextViewと2つのボタンを使用しています。「設定」ボタンは、クリップボードの最初のtextViewからテキストを配置する* on_set（）*関数を呼び出します。

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

2番目のボタン（「取得」）が押されると、クリップボードからのデータがrequest_text（）メソッドによってフェッチされます-

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

*user_data* のコンテンツは、コールバックメソッド* readclipboard（）*に送られ、2番目の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()

上記のコードは、次の出力を生成します-

Clipboard Demo

PyGTK-ルーラークラス

これは、ウィンドウ内のマウスポインターの位置を表示するのに役立つ水平（gtk.Hruler）および垂直（gtk.Vruler）ルーラーの基本クラスです。ルーラーの小さな三角形は、ポインターの位置を示します。

定規オブジェクトは、それぞれのコンストラクタで作成されます-

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-タイムアウト

PyGTK APIのgobjectモジュールには、定期的に呼び出されるタイムアウト関数を作成する便利な関数があります。

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

2番目の引数は、最初の引数の間隔であるミリ秒ごとに呼び出すコールバック関数です。追加の引数を関数データとしてコールバックに渡すことができます。

この関数の戻り値は source_id です。これを使用すると、コールバック関数は呼び出しを停止します。

gobject.source_remove(source_id)

コールバック関数は、繰り返し続けるためにTrueを返す必要があります。したがって、Falseを返すことで停止できます。

次のプログラムでは、2つのボタンと2つのラベルがトップレベルウィンドウに配置されています。 1つのラベルには、増分する番号が表示されます。 btn1は、 on_click を呼び出して、1000ミリ秒（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

2番目のボタンのコールバックは、タイムアウト機能を削除します。

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

例

以下は、タイムアウトの例の完全なコードです-

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

実行すると、ウィンドウの下部に2つのボタンが表示されます。ラベルの番号は、[開始]ボタンをクリックすると定期的に増加し、[停止]ボタンをクリックすると増加を停止します。

出力を観察します-

タイムアウトデモ

PyGTK-ドラッグアンドドロップ

X Windowが関連付けられているウィジェットは、ドラッグアンドドロップが可能です。プログラムでは、最初にドラッグアンドドロップのソースまたは宛先としてウィジェットを指定する必要があります。ソースとして定義されたウィジェットは、ドラッグされたデータを送信できます。目的のウィジェットは、ドラッグされたデータがドロップされたときに受け入れます。

次の手順は、ドラッグアンドドロップ対応のアプリケーションのセットアップに関係しています-

ステップ1 *-ソースウィジェットのセットアップ。

ステップ2 *-drag_source_set（）メソッドは、ドラッグ操作のターゲットタイプを指定します-

widget.drag_source_set(start_button_mask, targets, info)

ステップ3 *-start_button_mask引数は、ドラッグ操作を開始するボタンのビットマスクを指定します。

ステップ4 *-ターゲット引数は、この構造のタプルのリストです-

(target, flags, info)

ターゲット引数は、text/plainやimage/x-xpixmapなどのドラッグタイプを表す文字列です。

ステップ6 *-次のフラグが事前に定義されています-

gtk.TARGET_SAME_APP
gtk.TARGET_SAME_WIDGET

ステップ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)

フラグパラメータは、次の定数のいずれかを取ることができます-

gtk.DEST_DEFAULT_MOTION	This checks if the drag matches this widget’s list of possible targets and actions, then calls the drag_status() as appropriate.
gtk.DEST_DEFAULT_HIGHLIGHT	This draws a highlight on this widget as long as a drag is over this widget
gtk.DEST_DEFAULT_DROP	When a drop occurs, if the drag matches this widget’s list of possible targets and actions call *drag_get_data() on behalf of the widget. Whether or not the drop is successful, call drag_finish(). If the action was a move and the drag was successful, then TRUE will be passed for the delete parameter to drag_finish()*.
gtk.DEST_DEFAULT_ALL	If set, specifies that all default actions should be taken.

ターゲットは、ターゲット情報を含むタプルのリストです。アクション引数は、次の値のビットマスクまたは1つ以上の組み合わせです-

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

「ドラッグモーション」ハンドラーは、宛先のターゲットを gtk.gdk.DragContext ターゲットと一致させ、オプションで* drag_get_data（）メソッドを呼び出してドラッグデータを調べることにより、ドラッグデータが適切かどうかを判断する必要があります。 *gtk.gdk.DragContext 。 drag_context ステータスを更新するには、* drag_status（*）メソッドを呼び出す必要があります。

「ドラッグドロップ」ハンドラーは、* drag_dest_find_target（）メソッドを使用して一致するターゲットを決定し、 drag_get_data（）*メソッドを使用してドラッグデータを要求する必要があります。データは、「drag-data-received」ハンドラーで使用可能になります。

Pygtk-quick-guide

PyGTK-はじめに

PyGTK-環境

Microsoft Windows用のPyGTK

Linux用のPyGTK

PyGTK-ハローワールド

PyGTK-重要なクラス

PyGTK-ウィンドウクラス

PyGTK-ボタンクラス

PyGTK-ラベルクラス

PyGTK-エントリークラス

PyGTK-信号処理

例

PyGTK-イベント処理

例

PyGTK-コンテナー

PyGTK-ボックスクラス

gtk_box_pack_start（）

gtk_box_pack_end（）

例

PyGTK-ButtonBoxクラス

例

PyGTK-アライメントクラス

例

PyGTK-EventBoxクラス

例

PyGTK-レイアウトクラス

例

PyGTK-ComboBoxクラス

例1

例2

PyGTK-ToggleButtonクラス

例

PyGTK-CheckButtonクラス

例

PyGTK-RadioButtonクラス

例

PyGTK-MenuBar、MenuおよびMenuItem

例

PyGTK-ツールバークラス

ツールボタン

RadioToolButton

SeparatorToolItem

例

PyGTK-調整クラス

PyGTK-範囲クラス

PyGTK-スケールクラス

PyGTK-スクロールバークラス

例

PyGTK-ダイアログクラス

ボタンとは何ですか？

例

事前構成されたダイアログウィジェット

例

PyGTK-MessageDialogクラス

PyGTK-AboutDialogクラス

PyGTK-フォント選択ダイアログ

PyGTK-色選択ダイアログ

PyGTK-ファイル選択ダイアログ

PyGTK-ノートブッククラス

例

PyGTK-フレームクラス

例

PyGTK-AspectFrameクラス

例

PyGTK-TreeViewクラス

例1

例2

PyGTK-ペインクラス

例

PyGTK-ステータスバークラス

例

PyGTK-ProgressBarクラス

例

PyGTK-ビューポートクラス

PyGTK-ScrolledWindowクラス

例

PyGTK-Arrowクラス

例

PyGTK-画像クラス