A Simple Menu Example

We’ll start with something really simple: a menu with just an Exit MenuItem. Here’s the code:

import wx
 
########################################################################
class MyForm(wx.Frame):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, title="wx.Menu Tutorial")
 
        self.panel = wx.Panel(self, wx.ID_ANY)
 
        menuBar = wx.MenuBar()
        fileMenu = wx.Menu()
        exitMenuItem = fileMenu.Append(wx.NewId(), "Exit",
                                       "Exit the application")
        menuBar.Append(fileMenu, "&File")
        self.Bind(wx.EVT_MENU, self.onExit, exitMenuItem)
        self.SetMenuBar(menuBar)
 
    #----------------------------------------------------------------------
    def onExit(self, event):
        """"""
        self.Close()
 
#----------------------------------------------------------------------
# Run the program
if __name__ == "__main__":
    app = wx.App(False)
    frame = MyForm().Show()
    app.MainLoop()

Let’s break this down a little. To create the menubar, we instantiate an instance of wx.MenuBar. Then we create a an instance of wx.Menu that we call filemenu. Finally, to add the “Exit” item, we append some data to it. In essence, we are appending a wx.MenuItem, but this is kind of a shortcut since we didn’t actually create a wx.MenuItem instance first. We’ll show how to do that in our next example though. Note that when we append the item, we have to pass an id, a label string and a status string. That last one will show up in the Status bar when you hover over the menu item, assuming you have a status bar. Note that to attach an event handler to a menu item, you need use the EVT_MENU event and bind it to the frame. Next we append the Menu itself to the MenuBar object and pass it a string too, which in this case is “File”. Finally we call the frame’s SetMenuBar method to attach the menu bar to the frame.

Adding a Picture to a Menu

That’s all there is to creating a menu! Now let’s look at a more complex example! Note: to follow the example below, you’ll need to use your own image file.

import wx
 
########################################################################
class MyForm(wx.Frame):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, title="wx.Menu Tutorial")
 
        self.panel = wx.Panel(self, wx.ID_ANY)
 
        # create the menubar
        menuBar = wx.MenuBar()
 
        # create the first menu (starting on left)
        carMenu = wx.Menu()
        carMenu.Append(101, "&Ford", "An American Automaker")
        carMenu.Append(102, "&Nissan", "")
        carMenu.Append(103, "&Toyota", "Buy Japanese!")
        carMenu.Append(104, "&Close", "Close the application")
 
        # add a picture to a menu
        picMenu = wx.Menu()
        item = wx.MenuItem(picMenu, wx.ID_ANY, "Snake", "This menu has a picture!")
        img = wx.Image('snake32.bmp', wx.BITMAP_TYPE_ANY)
        item.SetBitmap(wx.BitmapFromImage(img))
        picMenu.AppendItem(item)
 
        # add menus to menubar
        menuBar.Append(carMenu, "&Vehicles")
        menuBar.Append(picMenu, "&Picture")
        self.SetMenuBar(menuBar)
 
    #----------------------------------------------------------------------
    def onExit(self, event):
        """"""
        self.Close()
 
#----------------------------------------------------------------------
# Run the program
if __name__ == "__main__":
    app = wx.App(False)
    frame = MyForm().Show()
    app.MainLoop()

This example is similar to the first one. The main difference is that we add multiple items to out File menu and we have two menus. Note that this time, we actually specify our ID numbers explicitly. This usually isn’t recommended as you might accidentally shadow one of wx’s required IDs. However, you do see examples of this from time to time on the web, so you should be aware of this practice. The next big difference doesn’t come until we get to the picMenu. Here we actually create a wx.MenuItem and add a picture to it via wx.Image and the MenuItem’s SetBitmap method. The rest is pretty much the same.

Now we will spend some time looking at how to add radio and check buttons to our menu.

Adding Radio or Check Buttons

Adding a radio or check button to your menu is actually pretty easy. Let’s take a moment and see how it’s done!

# radiocheck.py
import wx
 
########################################################################
class MyForm(wx.Frame):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, title="wx.Menu Tutorial")
 
        self.panel = wx.Panel(self, wx.ID_ANY)
 
        # Create menu bar
        menuBar = wx.MenuBar()
 
        # Create radio menu
        radioMenu = wx.Menu()
        idleItem = radioMenu.Append(wx.NewId(), "IDLE",
                                   "a Python shell using tcl/tk as GUI",
                                   wx.ITEM_RADIO)
        pyCrustItem = radioMenu.Append(wx.NewId(),"PyCrust",
                                      "a Python shell using wxPython as GUI",
                                      wx.ITEM_RADIO)
        psiItem = radioMenu.Append(wx.NewId(), "psi",
                                  "a simple Python shell using wxPython as GUI",
                                  wx.ITEM_RADIO)
        menuBar.Append(radioMenu, "&Radio")
 
        # create check menu
        checkMenu = wx.Menu()
        wgItem = checkMenu.Append(wx.NewId(), "Wells Fargo", "", wx.ITEM_CHECK)
        citiItem = checkMenu.Append(wx.NewId(), "Citibank", "", wx.ITEM_CHECK)
        geItem = checkMenu.Append(wx.NewId(), "GE Money Bank", "", wx.ITEM_CHECK)
        menuBar.Append(checkMenu, "&Check")
 
        # Attach menu bar to frame
        self.SetMenuBar(menuBar)
 
#----------------------------------------------------------------------
# Run the program
if __name__ == "__main__":
    app = wx.App(False)
    frame = MyForm().Show()
    app.MainLoop()

Yes, as you can see, all you have to do is add a wx.ITEM_RADIO or wx.ITEM_CHECK flag as the kind parameter, which is the 4th parameter. Why is it called “kind” rather than “style” like other widgets? Well, while discussing this on the wxPython IRC channel, Robin Dunn (creator of wxPython) pointed out that it may be because these are different kinds of menu items.

Sub-Menus

The wxPython library also supports sub-menus. Here’s a really simple example to show you how it’s done.

# submenu.py
import wx
 
########################################################################
class MyForm(wx.Frame):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, title="wx.Menu Tutorial")
 
        self.panel = wx.Panel(self, wx.ID_ANY)
 
        menuBar = wx.MenuBar()
        fileMenu = wx.Menu()
        openMenuItem = fileMenu.Append(wx.NewId(), "Open")
 
        # create a submenu
        subMenu = wx.Menu()
        historyMenuItem = subMenu.Append(wx.NewId(), "Show History")
        fileMenu.AppendMenu(wx.NewId(), "History", subMenu)
 
        exitMenuItem = fileMenu.Append(wx.NewId(), "Exit",
                                       "Exit the application")
        menuBar.Append(fileMenu, "&File")
        self.Bind(wx.EVT_MENU, self.onExit, exitMenuItem)
        self.SetMenuBar(menuBar)
 
    #----------------------------------------------------------------------
    def onExit(self, event):
        """"""
        self.Close()
 
#----------------------------------------------------------------------
# Run the program
if __name__ == "__main__":
    app = wx.App(False)
    frame = MyForm().Show()
    app.MainLoop()

The key here is that instead of using the filemenu’s Append method, we instead use its AppendMenu method. As the name implies, it allows the programmer to actually append a menu instead of a menu item. Yup, that’s it!

Pop-up Menus (AKA: ContextMenus)

Pop-up menus are the kind you see when you right-click on a link in a browser or on a file. They are also known as Context Menus. Here is a fairly trivial example for you to study:

# submenu.py
import wx
 
########################################################################
class MyForm(wx.Frame):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, title="Popup Menu Tutorial")
 
        panel = wx.Panel(self, wx.ID_ANY)
 
        lbl = wx.StaticText(panel, label="Right click anywhere!")
        self.Bind(wx.EVT_CONTEXT_MENU, self.onContext)
 
    #----------------------------------------------------------------------
    def onContext(self, event):
        """
        Create and show a Context Menu
        """
 
        # only do this part the first time so the events are only bound once 
        if not hasattr(self, "popupID1"):
            self.popupID1 = wx.NewId()
            self.itemTwoId = wx.NewId()
            self.itemThreeId = wx.NewId()
            self.Bind(wx.EVT_MENU, self.onPopup, id=self.popupID1)
            self.Bind(wx.EVT_MENU, self.onPopup, id=self.itemTwoId)
            self.Bind(wx.EVT_MENU, self.onExit, id=self.itemThreeId)
 
        # build the menu
        menu = wx.Menu()
        itemOne = menu.Append(self.popupID1, "ItemOne")
        itemTwo = menu.Append(self.itemTwoId, "ItemTwo")
        itemThree = menu.Append(self.itemThreeId, "Exit")
 
        # show the popup menu
        self.PopupMenu(menu)
        menu.Destroy()
 
    #----------------------------------------------------------------------
    def onExit(self, event):
        """
        Exit program
        """
        self.Close()
 
    #----------------------------------------------------------------------
    def onPopup(self, event):
        """
        Print the label of the menu item selected
        """
        itemId = event.GetId()
        menu = event.GetEventObject()
        menuItem = menu.FindItemById(itemId)
        print menuItem.GetLabel()
 
#----------------------------------------------------------------------
# Run the program
if __name__ == "__main__":
    app = wx.App(False)
    frame = MyForm().Show()
    app.MainLoop()

To begin, we bind wx.EVT_CONTEXT_MENU to the frame. This allows us to right-click anywhere and fire the context menu event, which will create and show our popup menu. The code in the onContext method is based loosely on the wxPython demo for the popup menu. As you can see, we use a conditional statement to check if we’ve already bound the menu events. If we have, we don’t bind them again. Next we create our menu in much the same way as before. Finally, we call the frame’s PopupMenu method and pass it our new menu. This will show the menu to the user. When the user clicks on a menu item, it will fire an event and the menu will be destroyed.

The first two menu items are both bound to our onPopup method. This allows us to see how we can get access to the Menu and the MenuItem attributes. You can get the menu’s id with the event and the Menu itself with the event’s GetEventObject method. Then you can use the menu’s FindItemById method to get a handle to the menu item itself. Finally we print out the menu item’s label.

Wrapping Up

Now you should know most of the menu methods and how to create them, bind events and make different kinds of menu items. You even know how to create popup menus! Now you can make your applications have fancy menus too.

Further Reading

• wxPython: Working with Menus, Toolbars and Accelerators
• Working with Menus – wxPython Wiki
• Menus and Toolbars – Zetcode

Source

• menus.zip
• menus.tar


'Jia_01.Jpg', 'Jia_02.Jpg', 'Jia_09.Jpg', 'Jia_10.Jpg', 'Jia_11.Jpg', 'Jia_101.Jpg'


the Android tablet would reorder them into something like this:


'Jia_01.Jpg', 'Jia_02.Jpg', 'Jia_09.Jpg', 'Jia_10.Jpg', 'Jia_101.Jpg', 'Jia_11.Jpg'


And it got pretty confusing the more files you had that were out of order. Sadly, even Python sorts files this way. I tried using the glob module on the directly and then sorting the result and got the exact same issue. So the first thing I had to do was find some kind of sorting algorithm that could sort them correctly. It should be noted that Windows 7 can sort the files correctly in its file system, even though Python cannot.

After a little searching on Google, I found the following script on StackOverflow:

import re
 
#----------------------------------------------------------------------
def sorted_nicely( l ):
    """
    Sort the given iterable in the way that humans expect.
    """
    convert = lambda text: int(text) if text.isdigit() else text
    alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ]
    return sorted(l, key = alphanum_key)

That worked perfectly! Now I just had to find a way to put each comic page on their own PDF page. Fortunately, the reportlab library makes this pretty easy to accomplish. You just need to iterate over the images and insert them one at a time onto a page. It’s easier to just look at the code, so let’s do that:

import glob
import os
import re
 
from reportlab.lib.pagesizes import letter
from reportlab.platypus import SimpleDocTemplate, Paragraph, Image, PageBreak
from reportlab.lib.units import inch
 
#----------------------------------------------------------------------
def sorted_nicely( l ):
    """
    # http://stackoverflow.com/questions/2669059/how-to-sort-alpha-numeric-set-in-python
 
    Sort the given iterable in the way that humans expect.
    """
    convert = lambda text: int(text) if text.isdigit() else text
    alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ]
    return sorted(l, key = alphanum_key)
 
#----------------------------------------------------------------------
def create_comic(fname, front_cover, back_cover, path):
    """"""
    filename = os.path.join(path, fname + ".pdf")
    doc = SimpleDocTemplate(filename,pagesize=letter,
                            rightMargin=72,leftMargin=72,
                            topMargin=72,bottomMargin=18)
    Story=[]
    width = 7.5*inch
    height = 9.5*inch
 
    pictures = sorted_nicely(glob.glob(path + "\\%s*" % fname))
 
    Story.append(Image(front_cover, width, height))
    Story.append(PageBreak())
 
    x = 0
    page_nums = {100:'%s_101-200.pdf', 200:'%s_201-300.pdf',
                 300:'%s_301-400.pdf', 400:'%s_401-500.pdf',
                 500:'%s_end.pdf'}
    for pic in pictures:
        parts = pic.split("\\")
        p = parts[-1].split("%s" % fname)
        page_num = int(p[-1].split(".")[0])
        print "page_num => ", page_num
 
        im = Image(pic, width, height)
        Story.append(im)
        Story.append(PageBreak())
 
        if page_num in page_nums.keys():
            print "%s created" % filename
            doc.build(Story)
            filename = os.path.join(path, page_nums[page_num] % fname)
            doc = SimpleDocTemplate(filename,
                                    pagesize=letter,
                                    rightMargin=72,leftMargin=72,
                                    topMargin=72,bottomMargin=18)
            Story=[]
        print pic
        x += 1
 
    Story.append(Image(back_cover, width, height))
    doc.build(Story)
    print "%s created" % filename
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    path = r"C:\Users\Mike\Desktop\Sam's Comics"
    front_cover = os.path.join(path, "FrontCover.jpg")
    back_cover = os.path.join(path, "BackCover2.jpg")
    create_comic("Jia_", front_cover, back_cover, path)

Let’s break this down a bit. As usual, you have some necessary imports that are required for this code to work. You’ll note we also have that sorted_nicely function that we talked about earlier is in this code too. The main function is called create_comic and takes four arguments: fname, front_cover, back_cover, path. If you have used the reportlab toolkit before, then you’ll recognize the SimpleDocTemplate and the Story list as they’re straight out of the reportlab tutorial.

Anyway, you loop over the sorted pictures and add the image to the Story along with a PageBreak object. The reason there’s a conditional in the loop is because I discovered that if I tried to build the PDF with all 400+ images, I would run into a memory error. So I broke it up into a series of PDF documents that were 100 pages or less. At the end of the document, you have to call the doc object’s build method to actually create the PDF document.

Now you know how I ended up writing a whole slew of images into multiple PDF documents. Theoretically, you could use PyPdf to knit all the resulting PDFs together into one PDF, but I didn’t try it. You might end up with another memory error. I’ll leave that as an exercise for the reader.

Source Code

• comic_maker.zip
• comic_maker.tar

He spent most of his time talking about the backend stuff behind the website though. Such as why he chose Amazon Web Services, how he uses Puppet, Vagrant and Fabric to manage his server’s settings and back them up.

The second talk was done by myself and I spoke on my MediaLocker project, an open source wxPython application that is supposed to help you track your media library. Most of my time was spent telling the story behind the project and showing a demo. Then I took some questions.

Overall, I’d say that we had a really good meeting with 10 people showing up. Next month, on February 2nd, we’re bringing in the BIG guns though. We have Doug Hellman and Steve Holden scheduled to Skype in and talk to us.

Doug Hellman is the author of The Python Standard Library By Example, is a senior developer with Racemi, Inc., and communications director of the Python Software Foundation. He has programmed with Python since version 1.4, and has worked on multiple platforms in mapping, medical publishing, banking, and data center automation. Hellmann was previously columnist and editor-in-chief for Python Magazine and, since 2007, has blogged the popular Python Module of the Week

Steve Holden is chairman of the Python Software Foundation and author of Python Web Programming. He owns Python consulting business and does Python training.

1. A Simple Step-by-Step Reportlab Tutorial

with 16,378 page views, posted 03/08/2010

2. How to Send Email with Python with 11,459 page views, posted 05/14/2010
3. A cx_Freeze Tutorial – Build a Binary Series! with 9,735 page views, posted 08/12/2010
4. Python and Microsoft Office – Using PyWin32 with 9,336 page views, posted 07/16/2010
5. Another Step-by-Step SqlAlchemy Tutorial (part 1 of 2) with 7,990 page views, posted 02/03/2010
6. Python: Parsing XML with minidom with 7,900 page views, posted 11/12/2010
7. Manipulating PDFs with Python and pyPdf with 7,304 page views, posted 05/15/2010
8. wxPython: wx.ListCtrl Tips and Tricks with 7,265 page views, posted 01/04/2011
9. Reportlab Tables – Creating Tables in PDFs with Python with 6,634 page views, posted 09/21/2010
10. Python 101: How to Open a File or Program with 6,440 page views, posted 09/04/2010

Last time, I thought I’d get some articles written about other GUI toolkits during 2011, but I never really got into any. Instead, I wrote a lot of wxPython articles. As you can tell from the list above, they weren’t super popular with only one making the top ten. Maybe this year I’ll spread out a bit and actually look at some of the other GUI toolkits. I’m also planning to write more on the topics that made it into my top ten list two years running such as reportlab and SqlAlchemy. If you can think of anything involving those 3 topics that you’d like to know more about, feel free to ask in the comments and I’ll consider writing about it.

I hope you’re ready for another rocking year of Python programming. I know I am!

1. What’s the coolest Python application, framework or library you have discovered in 2011?

I can’t think of anything new that I’ve really used this year. However, this was the year that I started using the ObjectListView widget in wxPython pretty extensively. It’s a great wrapper around the wx.ListCtrl that just makes it super easy to use. This is also the year that I started working on a big TurboGears 2 project, but I haven’t decided if it’s my favorite yet.

2. What new programming technique did you learn in 2011?

Lately I’ve taken to keeping my code more organized and structured than I have in the past, splitting my components into different modules, refactoring a lot more, trying to follow the Model-View-Controller schema more, etc. I have also started using Mercurial source control and BitBucket much more this year. I’m still not an expert in using them, but I know enough to keep my source mostly safe.

3. What’s the name of the open source project you contributed the most in 2011? What did you do?

wxPython. I write a lot of documentation for it on my wiki and I help lots of people with understanding it on the wxPython mailing list and on StackOverflow.

4. What was the Python blog or website you read the most in 2011?

Umm, this is a tough one. I read Tim Golden’s a lot with a dash of Jesse Noller and Doug Hellman. I like David Beazley too, but he doesn’t write much.

5. What are the three top things you want to learn in 2012?

I need to get a better handle on Mercurial branching and merging. Learning more TurboGears and maybe another Python web framework. Testing (I know some, but not enough, especially as related to GUIs).

6. What are the top software, app or lib you wish someone would write in 2012?

I wish there was a better eBay wrapper. I’d like to write my own sniper script. Another nice one would be some kind of all-in-one script that could create my bit.ly link for my blog post and then submit it to the various major tech sites for me.

Want to do your own list? here’s how:

• copy-paste the questions and answer to them in your blog
• tweet it with the #2012pythonmeme hashtag

• This book was given to me in ebook and physical form directly from Packt Publishing
• I actually don’t think I have enough math to review this

On that second one, I took college Calculus, but this book talks about terms I either don’t remember or they just weren’t covered. I had Statistics I and II as well, but the author deals more with matrix manipulation and linear algebra. I think my old Finance and Accounting classes helped the most, but that was at the end of the book.

The Book’s Audience

So who is this book actually aimed at? I think it’s aimed at high level mathematicians, scientists and stock market number crunchers. The prose is pretty good, if a bit dry. Most of the book is made up of a section introduction, a problem, how to solve it with NumPy / Matplotlib and some code examples. The code examples are snippets instead of full fledged runnable code, but you should be able to piece together most of it easily. The author doesn’t spend time importing libraries or creating fancy classes, so all the examples are very straight-forward, especially if you already understand the math equations. Note that the equations are not explained, so if you don’t know them, you’ll have to do some digging yourself.

What is Covered

Oodles and oodles of equations and math terms. For example, you’ll learn how to do various moving averages, Bollinger bands, trend lines, factorials, matrices (lots and lots of ‘em), hanning, hamming, ufuncs, Lissajous curves, determinants, Fourier transforms, various logarithms, matrice sorting and lots more. All of that is within NumPy with occasional SciPy stuff thrown in. The examples focused on the stock market and finance and seemed to work well within that context.

Near the end of the book, in chapter 9, the author switches gears slightly and discusses Matplotlib a little more in depth. He had been using it off and on in previous chapters, but he covers a lot more of its basic functions in this chapter. Then in the 10th and final chapter, he delves in SciPy and even manages to mention SciKits.

I noticed a few minor grammatical or sentence structure issues here and there, but this is one of the better written Packt books.

Wrapping Up

As I mentioned, I don’t really understand a lot of this book due to the high level math. It saddens me that I either didn’t cover this when I was in high school or college or that I’ve managed to forget so much of it. However, while the author doesn’t spend much time explaining the examples, I think that the quick nature in which it is written, works. Feel free to download Chapter 3 to get a taste of what it’s like. If you’re into this sort of thing or want to learn how to apply this sort of thing in Python, than I think this book may be right up your alley.

Numpy 1.5 Beginner’s Guide By Ivan Idris Buy from Amazon Packt

For those of you who are brave, you can also read about a snapshot build of Phoenix here or download the a tarball here. Note: These tarballs are only for Mac and Window users and they are not completely working.

For those of you who don’t know anything about Project Phoenix, you can read about it on the wxPython wiki.

Working the Code

For reasons I don’t quite understand, the wx component we want is wx.TaskBarIcon. I assume it’s called that because the System Tray is part of the TaskBar or maybe they don’t differentiate between the TaskBar and the tray area in other operating systems. Anyway, first you need an icon to use. You can get your image wherever you like. In this example, we’re going to use an an “envelope” image that I turned into Python code using wxPython’s handy img2py utility. When you run an image through img2py, you’ll end up with something like this:

#----------------------------------------------------------------------
# This file was generated by img2py.py
#
from wx import ImageFromStream, BitmapFromImage
from wx import EmptyIcon
import cStringIO, zlib
 
 
def getData():
    return zlib.decompress(
'x\xda\x01\x86\x01y\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\
\x00\x00 \x08\x06\x00\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\
\x08d\x88\x00\x00\x01=IDATX\x85\xed\x97[\x9a\x83 \x0c\x85Ol\xf7\x1566#\xec\
\xac,\xace\x1e\xe4b \xfa\xa9\xa3\xe5\xc5<\x15$9\x7fO\xc0\x0b\xd1\xf0@\xcf\
\x18\xba\xaa\xdf\x007\x00\x80g\xfa1\xfe\xfe\x84o\x89ZkA\xc3\x83\x04\x00\x00\
\x8c\xe3x\xa1,\x01\x08p\xce\x89Y\xd1\x82\xfa\xe2y\xc2P\xc5\x1b\x00c\xcc\x05\
\x10Sg\x9ds0\xc6\xac\x030\xf3\x05\x10\x94\xc5\x99y\x1d\xe0\\\x88\xc9z\xe7l\
\x147\xea*\xf5\x18\xfe\x0fB\xf6\xbc\xfcs\xfd\x90-\xde\x07\x8eC\xc8\x9e\x17\
\xdbI]\xbdz#:\x06Q\xf7\xbc8\xb2\x1b`\x1f\xc4R\xcf\x83\xb8\xbe\x1b %\x16\x08\
\x12\xf3Z\xcfu\xe1\xdd\x0eL\x89\xde\xbf\xc0\xcc3\'lU\xb0=\xe7\xcc\x0c\xef\
\xfd\x02\x88\x8c\xa7:\x1b\x13\xbd\xf7\xd1\xca\x90\x0b\'\xb1:\x8a\xf8\xb4>A\
\x94|\xdd\x81E\x80)y~|(\x17\xd6\xa2\x15"0\x87\xe8`\xc9\xdf\x00@\xd9v\x19\xb2\
\xf0|}-<\x1f3\x9bXo\xe3\x1e(\xe2u\xcf\xea\xcd\xb4},\xf7\xc4\n@\xb1\xfd\x98\
\xd0\xdax\t\xa2y\x18\xb5q\x1e\xc8\xa6\x87\xd1\x99\xd6\xeb\xe3\xaaz\xfa0\xe9\
\xf5J\x96\x01\xc2\xe7\xfd5\x00\x00-@\xaf\xe8\xfeZ~\x03t\x07\xf8\x03\x82\xac\
\xa4VT\xfd\xcd\xa3\x00\x00\x00\x00IEND\xaeB`\x82\n\xa7\xa9\xa8' )
 
def getBitmap():
    return BitmapFromImage(getImage())
 
def getImage():
    stream = cStringIO.StringIO(getData())
    return ImageFromStream(stream)
 
def getIcon():
    icon = EmptyIcon()
    icon.CopyFromBitmap(getBitmap())
    return icon

The image data is all in the getData function. I am going to call this file “email_ico.py”. We’ll import it into our main program and call its getIcon method to acquire the icon we want to use. Let’s take a look at the main application now:

import wx
from mail_ico import getIcon
 
########################################################################
class MailIcon(wx.TaskBarIcon):
    TBMENU_RESTORE = wx.NewId()
    TBMENU_CLOSE   = wx.NewId()
    TBMENU_CHANGE  = wx.NewId()
    TBMENU_REMOVE  = wx.NewId()
 
    #----------------------------------------------------------------------
    def __init__(self, frame):
        wx.TaskBarIcon.__init__(self)
        self.frame = frame
 
        # Set the image
        self.tbIcon = getIcon()
 
        self.SetIcon(self.tbIcon, "Test")
 
        # bind some events
        self.Bind(wx.EVT_MENU, self.OnTaskBarClose, id=self.TBMENU_CLOSE)
        self.Bind(wx.EVT_TASKBAR_LEFT_DOWN, self.OnTaskBarLeftClick)
 
    #----------------------------------------------------------------------
    def CreatePopupMenu(self, evt=None):
        """
        This method is called by the base class when it needs to popup
        the menu for the default EVT_RIGHT_DOWN event.  Just create
        the menu how you want it and return it from this function,
        the base class takes care of the rest.
        """
        menu = wx.Menu()
        menu.Append(self.TBMENU_RESTORE, "Open Program")
        menu.Append(self.TBMENU_CHANGE, "Show all the Items")
        menu.AppendSeparator()
        menu.Append(self.TBMENU_CLOSE,   "Exit Program")
        return menu
 
    #----------------------------------------------------------------------
    def OnTaskBarActivate(self, evt):
        """"""
        pass
 
    #----------------------------------------------------------------------
    def OnTaskBarClose(self, evt):
        """
        Destroy the taskbar icon and frame from the taskbar icon itself
        """
        self.frame.Close()
 
    #----------------------------------------------------------------------
    def OnTaskBarLeftClick(self, evt):
        """
        Create the right-click menu
        """
        menu = self.tbIcon.CreatePopupMenu()
        self.PopupMenu(menu)
        menu.Destroy()
 
########################################################################
class MyForm(wx.Frame):
 
    #----------------------------------------------------------------------
    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, "Tutorial", size=(500,500))
        panel = wx.Panel(self)
        self.tbIcon = MailIcon(self)
        self.Bind(wx.EVT_CLOSE, self.onClose)
 
    #----------------------------------------------------------------------
    def onClose(self, evt):
        """
        Destroy the taskbar icon and the frame
        """
        self.tbIcon.RemoveIcon()
        self.tbIcon.Destroy()
        self.Destroy()
 
#----------------------------------------------------------------------
# Run the program
if __name__ == "__main__":
    app = wx.App(False)
    frame = MyForm().Show()
    app.MainLoop()

The first class is basically copied straight out of the wxPython demo and simplified slightly. You can look there if you need a more complete example. Anyway, we bind a couple events in our sub-classed TaskBarIcon that allow us to close the application and show a menu, respectively. You will also note that we set the icon we created in the __init__ simply by calling its SetIcon method and passing in a string for its tooltip.

In the close method, we call the frame directly that we want it to close. A better method would be to use pubsub here. If you want to pause a moment and read about pubsub, I’ve written a little post about it too. The rest of the code is pretty self-explanatory.

Now we can move on to the wx.Frame sub-class. Here we basically just instantiate the TaskBarIcon class that we created earlier and we bind the frame to EVT_CLOSE. You might wonder about this. There are some got’chas with using the TaskBarIcon on Windows. If I just tell the frame to close, it closes just fine, but the icon remains and Python just kind of hangs in lala land. If you only allow the user to close using the task bar icon’s right-click menu, then you could just add a RemoveIcon method and a self.Destroy() there and you’d be good to go (for some reason, RemoveIcon isn’t enough to get rid of the TaskBarIcon, so you also need to tell it to Destroy itself too) But if you allow the user to press the little “x” in the upper right-hand corner, then you’ll need to catch EVT_CLOSE and deal with it appropriately. When you do catch this event, you can NOT just call self.Close() or you’ll end up in an infinite loop, which is why we call self.Destroy() instead.

Wrapping Up

Now you should be able to create your own TaskBarIcon application. I highly recommend looking at the wxPython demo to see what else you can do with it. I think adding an icon can add a bit of polish to your application, especially if you need to have it running hidden for a while and then make it pop-up at the user’s command.

Further Reading

• Create a Flashing TaskBarIcon
• Another blog’s take on this subject
• The TaskBarIcon documentation

Source

• TBI_src.tar
• TBI_src.zip

The complete schedule isn’t done yet, but you can whet your appetite by checking out the list of tutorials that were released last week.

I have enjoyed all the PyCons I’ve attended so far. They are a great place to learn new things, show others your talent, network with like-minded people and just relax too. This year, the conference will be in Santa Clara, California. If you can’t afford to go, they even offer Financial Assistance. So why are you waiting?

Background
================

This is the first release of a real project that I’ve been involved in. I had written an article last month that inspired Werner Bruhin to want to take it and make it into a demonstration program for new wxPython programmers in how to do MVC and CRUD while interfacing with a database. Thus, MediaLocker was born. We hope you like it.

Description
================

A wxPython database application that can help you keep track of your media. Currently, it only tracks your Book library. You can read more about the project’s development in the following two articles:

• Improving MediaLocker: wxPython, SQLAlchemy and MVC
• wxPython and SQLAlchemy: An Intro to MVC and CRUD

Requirements
================

- Python 2.6+
- wxPython 2.8.11+ with the new pubsub (download here) or wxPython 2.9.3
- SQLAlchemy 0.7.3+
- ObjectListView 1.2

Configuration
================

After you have downloaded the source, run “python setup_lib.py develop” in the main folder before you try to run “mediaLocker.py”. If you are on wxPython 2.8, download the pubsub path (above) and extract it to “C:\Python27\Lib\site-packages\wx-2.9.2-msw\wx\lib” (or wherever your wxPython is installed).

Source
================

You can download the source from BitBucket: https://bitbucket.org/driscollis/medialocker

You can also just download a snapshot of the current files here (uploaded 2011.12.09 @ 1138 hrs CST):

• medialocker.zip
• medialocker.tar
• Or just download from the tip on bitbucket

How you can help
================

Download the software and report bugs on BitBucket. We also happily accept feature requests, especially if they include patches or code.

Note: This has only been tested on Windows XP and 7