Quickie: How to Reinstall XP but keep Partitions as Is

I was asked by a friend of mine how to best go about reinstalling Windows while keeping his other partitions intact. It’s really easy, but there are some points where it’s necessary to exercise caution! This little quickie is a guide on how to do exactly that. Read more…

No comments.
***

wxPython Menu Status Text

wxPython isn’t quite as easy to develop for as some other GUI toolkits but the greatest benefit is that it uses native widgets in Windows. I believe the PyQT bindings also support native widgets and have since QT 4, but I personally find that certain simple layouts behave slightly faster in wxPython than PyQT. Perhaps I’ll test this theory and be surprised whenever I put together a QT-based project next!

One of the unfortunate problems with wx is that the toolkit’s documentation requires a significant amount of introspection, some knowledge of what subject in particular is sought after, and a little bit of experimentation. The examples that ship with wxPython are absolutely fantastic and make up for what the documentation lacks. However, some things aren’t very obvious. Here’s a good example.

If you open Windows Explorer (this is the XP version–Vista and Seven both do something similar) and mouse-over each of the menu items, you’ll notice brief snippets of help text on the status bar. Here’s a shot of the status bar before:

screenshot_01

And here’s a shot while leaving the mouse over “File”:

screenshot_02

Something like this is pretty easy to accomplish in .NET and merely requires attaching a method to the appropriate handler. This isn’t so obvious in wxPython (and I’d imagine the wx toolkit in general) and requires a bit of work.

Your first inclination might be to do something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class MyFrame (wx.Frame):
    def __init__ (self):
        wx.Frame.__init__(self, None, -1, "My App", pos=wx.DefaultPosition,
                          size=(300, 300), style=wx.DEFAULT_FRAME_STYLE)
        # In whatever part of your code you're adding the file menu...
        menu = wx.MenuBar()
        file = wx.Menu()
        file.Append(100, "&New\tCtrl+N")
        file.Append(101, "E&xit\tAlt+F4")
        menu.Append(file, "&File")
 
        ##
        # Add some bindings...
 
        # This only works AFTER the menu has been opened
        # and only when we highlight a menu ITEM... oops
        self.Bind(wx.EVT_MENU_HIGHLIGHT, self.OnMenuHighlight)
 
        # Close, but not quite--you'll see why in a minute
        self.Bind(wx.EVT_MENU_OPEN, self.OnMenuOpen)
 
    def OnMenuHighlight (self, event):
        # Do highlight
        pass
 
    def OnMenuOpen (self, event):
        # Process opening a menu
        pass

At first blush it would seem that the wx.EVT_MENU_HIGHLIGHT gives us exactly the event we want. However, once we run our application we’ll be surprised to note that this doesn’t work as expected. The wx.EVT_MENU_HIGHLIGHT is triggered only when a menu item is highlighted. wx.EVT_MENU_OPEN is much closer to what we want, but there’s one small problem. Before I can explain the issue, let’s look into some object introspection.

First, let’s assume that we have the following in our OnMenuOpen() function:

1
2
3
4
5
    def OnMenuOpen (self, event):
        print "event.GetMenu()\n"
        print dir(event.GetMenu())
        print "\nevent.GetMenu().GetMenuBar()\n"
        print dir(event.GetMenu().GetMenuBar())

This will yield something like the following (I’ve snipped out the irrelevant parts):

event.Menu:

['FindItem', 'FindItemById', 'FindItemByPosition', 'GetClassName', 'GetEventHandler',
'GetEvtHandlerEnabled', 'GetHelpString', 'GetInvokingWindow', 'GetLabel', 'GetLabelText',
'GetMenuBar', 'GetMenuItemCount', 'GetMenuItems', 'GetNextHandler', 'GetParent',
'GetPreviousHandler', 'GetStyle', 'GetTitle', 'HelpString']

event.Menu.MenuBar:

['FindFocus', 'FindItemById', 'FindMenu', 'FindMenuItem', 'FindWindowById', 'FindWindowByLabel',
'FindWindowByName', 'Fit', 'FitInside', 'Font', 'ForegroundColour', 'Frame', 'Freeze',
'GetAcceleratorTable', 'GetAdjustedBestSize', 'GetAutoLayout', 'GetAutoWindowMenu',
'GetBackgroundColour', 'GetBackgroundStyle', 'GetBestFittingSize', 'GetBestSize',
'GetBestSizeTuple', 'GetBestVirtualSize', 'GetBorder', 'GetCapture', 'GetCaret', 'GetCharHeight',
'GetCharWidth', 'GetChildren', 'GetClassDefaultAttributes', 'GetClassName','GetClientAreaOrigin',
'GetClientRect', 'GetClientSize', 'GetClientSizeTuple', 'GetConstraints', 'GetContainingSizer',
'GetCursor', 'GetDefaultAttributes', 'GetDefaultBorder', 'GetDropTarget', 'GetEffectiveMinSize',
'GetEventHandler', 'GetEvtHandlerEnabled', 'GetExtraStyle', 'GetFont', 'GetForegroundColour',
'GetFrame', 'GetFullTextExtent', 'GetGrandParent', 'GetGtkWidget', 'GetHandle', 'GetHelpString',
'GetHelpText', 'GetHelpTextAtPoint', 'GetId', 'GetLabel', 'GetLabelTop', 'GetLayoutDirection',
'GetMaxHeight', 'GetMaxSize', 'GetMaxWidth', 'GetMenu', 'GetMenuCount', 'GetMenuLabel',
'GetMenuLabelText', 'GetMenus', 'GetMinHeight', 'GetMinSize', 'GetMinWidth', 'GetName',
'GetNextHandler', 'GetParent', 'GetPosition', 'GetPositionTuple', 'GetPreviousHandler', 'GetRect',
'GetScreenPosition', 'GetScreenPositionTuple', 'GetScreenRect', 'GetScrollPos', 'GetScrollRange',
'GetScrollThumb', 'GetSize', 'GetSizeTuple', 'GetSizer', 'GetSizerProps', 'GetTextExtent',
'GetThemeEnabled', 'GetToolTip', 'GetTopLevelParent', 'GetUpdateClientRect', 'GetUpdateRegion',
'GetValidator', 'GetVirtualSize', 'GetVirtualSizeTuple', 'GetWindowBorderSize', 'GetWindowStyle',
'GetWindowStyleFlag', 'GetWindowVariant']

The answer seems obvious–at first. All we need to do is add event.GetMenu() to our OnMenuOpen() function and… wait. How are we going to know which menu was opened? There’s no identifier we can use. Maybe if we use event.GetMenu().GetLabelText() we can examine the string for “File” or whichever menu the user has opened…

Traceback (most recent call last):
  File "ui.py", line 37, in OnMenuOpen
    print event.GetMenu().GetLabelText()
  File "D:\Python25\Lib\site-packages\wx-2.8-msw-unicode\wx\_core.py", line 1126
8, in GetLabelText
    return _core_.Menu_GetLabelText(*args, **kwargs)
TypeError: Menu_GetLabelText() takes exactly 2 arguments (1 given)

Damn.

We then try various incantations of this code. We might even wind up with something embarrassingly convoluted like event.GetMen().GetMenuBar().Get… Ugh. I think I’ve lost myself after that one.

Fortunately, the solution isn’t terribly difficult. You can even add some additional features yourself, if you like. But here’s the catch: There isn’t anything in the documentation that indicates if it’s even possible using the existing classes to figure out which menu someone has opened. So, if you’ve got “File,” “Edit,” “View,” and “Help” menus, you’re out of luck–at least with the stock wx classes.

Here’s the quick and dirty solution that worked for me. It may not be optimal, but it sure beats screwing around with object introspection and trying to Get() a clue. (See that pun I did there?)

Simply extend wx.Menu:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#########
# Menu
class Menu (wx.Menu):
    '''Menu
Overrides the default wx.Menu object to provide offset and status text
monitoring.'''
    offset = -1
    statusText = ""
    def __init__ (self, offset=-1, status=""):
        '''constructor
Create a new menu item.
 
``offset`` indicates what offset this menu item lives at in the menu but can
be any ID you prefer.
 
``Status`` indicates the status text you wish to use with this menu item for
retrieval by the status bar.'''
        wx.Menu.__init__(self)
        self.offset = offset
        self.statusText = status
 
    def GetOffset (self):
        '''GetOffset()
Returns the user-defined offset to identify this menu item's position in the
menu bar.'''
        return self.offset
 
    def GetStatusText (self):
        '''GetStatusText()
Returns text associated with this control for shuttling to the status bar.'''
        return self.statusText
## end Menu

And then modify your OnMenuOpen() function to read:

1
2
3
4
5
6
    def OnMenuOpen (self, event):
        '''OnMenuOpen (event)
Triggered whenever a menu itme is opened. Sets the default status text.'''
        print event.GetMenu().GetLabel(1)
        if hasattr(event.GetMenu(), "GetStatusText"):
            self.statusBar.SetStatusText(event.GetMenu().GetStatusText(), 0)

Then when you create a new menu item, just simply pass the offset and the text to your new class:

1
2
3
4
5
        menu = wx.MenuBar()
        file = wx.Menu(0, "Contains file operations")
        file.Append(100, "&New\tCtrl+N")
        file.Append(101, "E&xit\tAlt+F4")
        menu.Append(file, "&File")

The hasattr() call is needed for submenu items otherwise OnMenuOpen() will trigger an exception whenever the user mouses over a submenu. If you don’t have submenus, you probably don’t need to worry about this. In this example, I assume that we’ve added a wx.StatusBar to our initial class.

Combining this trick with the wx.EVT_MENU_CLOSE event will yield a fairly painless method of altering (and resetting) the status bar text whenever the user opens a menu item.

No comments.
***

FreeBSD Ports: Making them Friendlier

The FreeBSD ports collection may be a tough nut to crack if you’re used to easier package distribution systems like those found on Ubuntu or Redhat. In many ways, I find it easier to manage. The ports collection grants you greater control over what is installed, how it is configured, what dependencies you’d like to build (or rebuilt), and what upgrade path you’d like to choose whenever upgrading packages. The ports collection is so good, in fact, that several Linux distributions now borrow from the principles set forth by the FreeBSD foundation what seems like eons ago (Gentoo and its derivatives, specifically). It can be daunting to manage ports at first, but you’ll find that it offers you freedom that simply couldn’t be had from binary packages.

After all, FreeBSD is about freedom. Read more…

No comments.
***
Page 1 of 212