python手记(9)

 

本博客所有内容是原创，未经书面许可，严禁任何形式的转

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("gladexml\startshow.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脚本了。