本博客所有内容是原创，未经书面许可，严禁任何形式的转
http://blog.csdn.net/u010255642
tab
#!/usr/bin/env python
# example notebook.py
import pygtk
pygtk.require('2.0')
import gtk
class NotebookExample:
# This method rotates the position of the tabs
def rotate_book(self, button, notebook):
notebook.set_tab_pos((notebook.get_tab_pos()+1) %4)
# Add/Remove the page tabs and the borders
def tabsborder_book(self, button, notebook):
tval = False
bval = False
if self.show_tabs == False:
tval = True
if self.show_border == False:
bval = True
notebook.set_show_tabs(tval)
self.show_tabs = tval
notebook.set_show_border(bval)
self.show_border = bval
# Remove a page from the notebook
def remove_book(self, button, notebook):
page = notebook.get_current_page()
notebook.remove_page(page)
# Need to refresh the widget --
# This forces the widget to redraw itself.
notebook.queue_draw_area(0,0,-1,-1)
def delete(self, widget, event=None):
gtk.main_quit()
return False
def __init__(self):
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("delete_event", self.delete)
window.set_border_width(10)
table = gtk.Table(3,6,False)
window.add(table)
# Create a new notebook, place the position of the tabs
notebook = gtk.Notebook()
notebook.set_tab_pos(gtk.POS_TOP)
table.attach(notebook, 0,6,0,1)
notebook.show()
self.show_tabs = True
self.show_border = True
# Let’s append a bunch of pages to the notebook
for i in range(5):
bufferf = "Append Frame %d" % (i+1)
bufferl = "Page %d" % (i+1)
frame = gtk.Frame(bufferf)
frame.set_border_width(10)
frame.set_size_request(100, 75)
frame.show()
label = gtk.Label(bufferf)
frame.add(label)
label.show()
label = gtk.Label(bufferl)
notebook.append_page(frame, label)
# Now let’s add a page to a specific spot
checkbutton = gtk.CheckButton("Check me please!")
checkbutton.set_size_request(100, 75)
checkbutton.show ()
label = gtk.Label("Add page")
notebook.insert_page(checkbutton, label, 2)
# Now finally let’s prepend pages to the notebook
for i in range(5):
bufferf = "Prepend Frame %d" % (i+1)
bufferl = "PPage %d" % (i+1)
frame = gtk.Frame(bufferf)
frame.set_border_width(10)
frame.set_size_request(100, 75)
frame.show()
label = gtk.Label(bufferf)
frame.add(label)
label.show()
label = gtk.Label(bufferl)
notebook.prepend_page(frame, label)
# Set what page to start at (page 4)
notebook.set_current_page(3)
# Create a bunch of buttons
button = gtk.Button("close")
button.connect("clicked", self.delete)
table.attach(button, 0,1,1,2)
button.show()
button = gtk.Button("next page")
button.connect("clicked", lambda w: notebook.next_page())
table.attach(button, 1,2,1,2)
button.show()
button = gtk.Button("prev page")
button.connect("clicked", lambda w: notebook.prev_page())
table.attach(button, 2,3,1,2)
button.show()
button = gtk.Button("tab position")
button.connect("clicked", self.rotate_book, notebook)
table.attach(button, 3,4,1,2)
button.show()
button = gtk.Button("tabs/border on/off")
button.connect("clicked", self.tabsborder_book, notebook)
table.attach(button, 4,5,1,2)
button.show()
button = gtk.Button("remove page")
button.connect("clicked", self.remove_book, notebook)
table.attach(button, 5,6,1,2)
button.show()
table.show()
window.show()
def main():
gtk.main()
return 0
if __name__ == "__main__":
NotebookExample()
main()
menu
#!/usr/bin/env python
# example itemfactory.py
import pygtk
pygtk.require(’2.0’)
import gtk
class ItemFactoryExample:
# Obligatory basic callback
def print_hello(self, w, data):
print "Hello, World!"
# This is the ItemFactoryEntry structure used to generate new menus.
# Item 1: The menu path. The letter after the underscore indicates an
# accelerator key once the menu is open.
# Item 2: The accelerator key for the entry
# Item 3: The callback.
# Item 4: The callback action. This changes the parameters with
# which the callback is called. The default is 0.
# Item 5: The item type, used to define what kind of an item it is.
# Here are the possible values:
# NULL -> "<Item>"
# "" -> "<Item>"
# "<Title>" -> create a title item
# "<Item>" -> create a simple item
# "<CheckItem>" -> create a check item
# "<ToggleItem>" -> create a toggle item
# "<RadioItem>" -> create a radio item
# <path> -> path of a radio item to link against
# "<Separator>" -> create a separator
# "<Branch>" -> create an item to hold sub items (optional)
# "<LastBranch>" -> create a right justified branch
def get_main_menu(self, window):
accel_group = gtk.AccelGroup()
# This function initializes the item factory.
# Param 1: The type of menu - can be MenuBar, Menu,
# or OptionMenu.
# Param 2: The path of the menu.
# Param 3: A reference to an AccelGroup. The item factory sets up
# the accelerator table while generating menus.
item_factory = gtk.ItemFactory(gtk.MenuBar, "<main>", accel_group)
# This method generates the menu items. Pass to the item factory
# the list of menu items
item_factory.create_items(self.menu_items)
# Attach the new accelerator group to the window.
window.add_accel_group(accel_group)
# need to keep a reference to item_factory to prevent its destruction
self.item_factory = item_factory
# Finally, return the actual menu bar created by the item factory.
return item_factory.get_widget("<main>")
def __init__(self):
self.menu_items = (
( "/_File", None, None, 0, "<Branch>" ),
( "/File/_New", "<control>N", self.print_hello, 0, None ),
( "/File/_Open", "<control>O", self.print_hello, 0, None ),
( "/File/_Save", "<control>S", self.print_hello, 0, None ),
( "/File/Save _As", None, None, 0, None ),
( "/File/sep1", None, None, 0, "<Separator>" ),
( "/File/Quit", "<control>Q", gtk.main_quit, 0, None ),
( "/_Options", None, None, 0, "<Branch>" ),
( "/Options/Test", None, None, 0, None ),
( "/_Help", None, None, 0, "<LastBranch>" ),
( "/_Help/About", None, None, 0, None ),
)
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("destroy", lambda w: gtk.main_quit(), "WM destroy")
window.set_title("Item Factory")
window.set_size_request(300, 200)
main_vbox = gtk.VBox(False, 1)
main_vbox.set_border_width(1)
window.add(main_vbox)
main_vbox.show()
menubar = self.get_main_menu(window)
main_vbox.pack_start(menubar, False, True, 0)
menubar.show()
window.show()
def main():
gtk.main()
return 0
if __name__ == "__main__":
ItemFactoryExample()
main()
#!/usr/bin/env python
# example menu.py
import pygtk
pygtk.require('2.0')
import gtk
class MenuExample:
def __init__(self):
# create a new window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_size_request(200, 100)
window.set_title("GTK Menu Test")
window.connect("delete_event", lambda w,e: gtk.main_quit())
# Init the menu-widget, and remember -- never
# show() the menu widget!!
# This is the menu that holds the menu items, the one that
# will pop up when you click on the "Root Menu" in the app
menu = gtk.Menu()
# Next we make a little loop that makes three menu-entries for
# "test-menu". Notice the call to gtk_menu_append. Here we are
# adding a list of menu items to our menu. Normally, we’d also
# catch the "clicked" signal on each of the menu items and setup a
# callback for it, but it’s omitted here to save space.
for i in range(3):
# Copy the names to the buf.
buf = "Test-undermenu - %d" % i
# Create a new menu-item with a name...
menu_items = gtk.MenuItem(buf)
# ...and add it to the menu.
menu.append(menu_items)
# Do something interesting when the menuitem is selected
menu_items.connect("activate", self.menuitem_response, buf)
# Show the widget
menu_items.show()
# This is the root menu, and will be the label
# displayed on the menu bar. There won’t be a signal handler attached,
# as it only pops up the rest of the menu when pressed.
root_menu = gtk.MenuItem("Root Menu")
root_menu.show()
# Now we specify that we want our newly created "menu" to be the
# show() the menu widget!!
# This is the menu that holds the menu items, the one that
# will pop up when you click on the "Root Menu" in the app
menu = gtk.Menu()
# Next we make a little loop that makes three menu-entries for
# "test-menu". Notice the call to gtk_menu_append. Here we are
# adding a list of menu items to our menu. Normally, we’d also
# catch the "clicked" signal on each of the menu items and setup a
# callback for it, but it’s omitted here to save space.
for i in range(3):
# Copy the names to the buf.
buf = "Test-undermenu - %d" % i
# Create a new menu-item with a name...
menu_items = gtk.MenuItem(buf)
# ...and add it to the menu.
menu.append(menu_items)
# Do something interesting when the menuitem is selected
menu_items.connect("activate", self.menuitem_response, buf)
# Show the widget
menu_items.show()
# This is the root menu, and will be the label
# displayed on the menu bar. There won’t be a signal handler attached,
# as it only pops up the rest of the menu when pressed.
root_menu = gtk.MenuItem("Root Menu")
root_menu.show()
# menu for the "root menu"
root_menu.set_submenu(menu)
# A vbox to put a menu and a button in:
vbox = gtk.VBox(False, 0)
window.add(vbox)
vbox.show()
# Create a menu-bar to hold the menus and add it to our main window
menu_bar = gtk.MenuBar()
vbox.pack_start(menu_bar, False, False, 2)
menu_bar.show()
# Create a button to which to attach menu as a popup
button = gtk.Button("press me")
button.connect_object("event", self.button_press, menu)
vbox.pack_end(button, True, True, 2)
button.show()
# And finally we append the menu-item to the menu-bar -- this is th
# Now we specify that we want our newly created "menu" to be the
# "root" menu-item I have been raving about =)
menu_bar.append (root_menu)
# always display the window as the last step so it all splashes on
# the screen at once.
window.show()
# Respond to a button-press by posting a menu passed in as widget.
#
# Note that the "widget" argument is the menu being posted, NOT
# the button that was pressed.
def button_press(self, widget, event):
if event.type == gtk.gdk.BUTTON_PRESS:
widget.popup(None, None, None, event.button, event.time)
# Tell calling code that we have handled this event the buck
# stops here.
return True
# Tell calling code that we have not handled this event pass it on.
return False
# Print a string when a menu item is selected
def menuitem_response(self, widget, string):
print "%s" % string
def main():
gtk.main()
return 0
if __name__ == "__main__":
MenuExample()
main()
file_menu = gtk.Menu()
将file_item做为子菜单加入到file_menu
file_item.set_submenu(file_menu)
在menubar中加入菜单项
menu_bar.append(child)
比如：
menu_bar.append(file_item)
在menubar中右调整，比如help菜单等，我们使用下面的方法：
menu_item.set_right_justified(right_justified)
=========================
1.使用gtk.Menu()创建新的menu
2.gtk.MenuItem() 创建子菜单项，然后使用append()
3. set_submenu() 将子菜单项加入menu中
4.使用gtk.MenuBar()创建menubar
5.append()加入菜单项
6.设置事件
widget.connect_object("event", handler, menu)
webbrowser-打开浏览器
#!/usr/bin/env python import webbrowser url='deepfuture.iteye.com' webbrowser.open_new(url) url='http://www.google.com.hk/search?hl=zh-CN&newwindow=1&safe=strict&client=aff-cs-360se&hs=kma&q=pygtk+deepfuture&oq=pygtk+deepfuture&aq=f&aqi=&aql=&gs_sm=e&gs_upl=3960l5390l0l5930l11l6l0l0l0l0l0l0ll0l0' webbrowser.open_new_tab(url)
TreeStore提供分等级，分层次的数据存储，而ListStore提供表格的数据存储,TreeModelSort提供一个排序的模型，TreeModelFilter提供数据子集。通常有以下几个步骤：
1.创建一个tree model对象，通过ListStore或TreeStore
2.TreeView widget 创建并与tree model关联
3.一个或多个TreeViewColumns被创建并插入到TreeView，每个代表一列
4.对于每个TreeViewColumn，CellRenderers被创建并加入TreeViewColumn
5.设置每个CellRenderer的属性
6.TreeView被插入并显示在Window或ScrolledWindow中
7.响应用户的操作
#!/usr/bin/env python
# example basictreeview.py
import pygtk
pygtk.require('2.0')
import gtk
class BasicTreeViewExample:
# close the window and quit
def delete_event(self, widget, event, data=None):
gtk.main_quit()
return False
def __init__(self):
# Create a new window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Basic TreeView Example")
self.window.set_size_request(200, 200)
self.window.connect("delete_event", self.delete_event)
# create a TreeStore with one string column to use as the model
self.treestore = gtk.TreeStore(str)
# we'll add some data now - 4 rows with 3 child rows each
for parent in range(4):
piter = self.treestore.append(None, ['parent %i' % parent])
for child in range(3):
self.treestore.append(piter, ['child %i of parent %i' %(child, parent)])
# create the TreeView using treestore
self.treeview = gtk.TreeView(self.treestore)
# create the TreeViewColumn to display the data
self.tvcolumn = gtk.TreeViewColumn('Column 0')
# add tvcolumn to treeview
self.treeview.append_column(self.tvcolumn)
# create a CellRendererText to render the data
self.cell = gtk.CellRendererText()
# add the cell to the tvcolumn and allow it to expand
self.tvcolumn.pack_start(self.cell, True)
# set the cell "text" attribute to column 0 - retrieve text
# from that column in treestore
self.tvcolumn.add_attribute(self.cell, 'text', 0)
# make it searchable
self.treeview.set_search_column(0)
# Allow sorting on the column
self.tvcolumn.set_sort_column_id(0)
# Allow drag and drop reordering of rows
self.treeview.set_reorderable(True)
self.window.add(self.treeview)
self.window.show_all()
def main():
gtk.main()
if __name__ == "__main__":
tvexample = BasicTreeViewExample()
main()
glade
import pygtk
pygtk.require("2.0")
import gtk
class startlogin(object):
def close_app(self):
gtk.main_quit()
def exit_app(self):
gtk.Widget.destroy(self.window)
def on_startshow_destroy(self, widget,data=None):
self.close_app()
def on_exitbutton_clicked(self, widget,data=None):
self.exit_app()
def __init__(self):
builder = gtk.Builder()
builder.add_from_file("gladexmlstartshow.glade")
builder.connect_signals(self)
self.window = builder.get_object("startshow")
if __name__ == "__main__":
startlogin = startlogin()
startlogin.window.show()
gtk.main()
此外,py在WIN下需要配置环境变量:
假设python的安装路径为c:python2.6，则修改我的电脑->属性->高级->环境变量->系统变量中的PATH为:
(为了在命令行模式下运行
Python命令，需要将python.exe所在的目录附加到PATH这个环境变量中。)
PATH=PATH;c:python26
上述环境变量设置成功之后，就可以在命令行直接使用python命令。或执行"python *.py"运行python脚本了。