Changeset 202

Timestamp:

03/17/2008 11:50:41 AM (10 months ago)

Author:

funkiedamouse

Message:

Changed 'my' to 'self' for all class methods.

Location:

trunk

Files:

• examples/plpwm.py (modified) (5 diffs)
• plwm/input.py (modified) (5 diffs)
• plwm/menu.py (modified) (6 diffs)
• plwm/message.py (modified) (5 diffs)
• plwm/pane_utilities.py (modified) (15 diffs)
• plwm/panes.py (modified) (9 diffs)

trunk/examples/plpwm.py

@@ -87 +87 @@
 
 class WMConfig:
-    def __wm_init__(my):
+    def __wm_init__(self):
         "install the panes key map, menus, and try to restore my config."
 
-        my.panekeys = PaneKeys(my)
-        auto_restore(my, my.panekeys.menus.find('paneconfigmenus'))
+        self.panekeys = PaneKeys(self)
+        auto_restore(self, self.panekeys.menus.find('paneconfigmenus'))
 
 
@@ -105 +105 @@
     panes_maxsize_gravity = X.NorthWestGravity
 
-    def __wm_screen_resize__(my):
+    def __wm_screen_resize__(self):
         "install the panes key map, menus, and try to restore my config."
 
-        auto_restore(my, my.panekeys.menus.find('paneconfigmenus'))
+        auto_restore(self, self.panekeys.menus.find('paneconfigmenus'))
        
 
@@ -127 +127 @@
     menu_file = os.path.expanduser('~/.plpwmrc.xml')
 
-    def __init__(my, obj):
-        keys.KeyHandler.__init__(my, obj)
-        my.menus = load_menus(my.menu_file)
+    def __init__(self, obj):
+        keys.KeyHandler.__init__(self, obj)
+        self.menus = load_menus(self.menu_file)
 
     # Commands for navigating and manipulating panes
-    def C_0(my, event):
+    def C_0(self, event):
         "Go to the pane numbered by the keycode."
 
-        my.wm.panes_goto(my.wm.display.keycode_to_keysym(event.detail, 0) - XK.XK_0)
+        self.wm.panes_goto(self.wm.display.keycode_to_keysym(event.detail, 0) - XK.XK_0)
 
     C_1 = C_2 = C_3 = C_4 = C_5 = C_6 = C_7 = C_8 = C_9 = C_0
 
-    def M1_Tab(my, event): my.wm.panes_next()
-    def S_M1_Tab(my, event): my.wm.panes_prev()
-
-    def M1_0(my, event):
-        pane = my.wm.panes_list[my.wm.panes_current]
+    def M1_Tab(self, event): self.wm.panes_next()
+    def S_M1_Tab(self, event): self.wm.panes_prev()
+
+    def M1_0(self, event):
+        pane = self.wm.panes_list[self.wm.panes_current]
         splitpane(pane, pane.horizontal_split, paneWindow)
 
-    def S_M1_0(my, event):
-        pane = my.wm.panes_list[my.wm.panes_current]
+    def S_M1_0(self, event):
+        pane = self.wm.panes_list[self.wm.panes_current]
         splitpane(pane, pane.vertical_split, paneWindow)
 
-    def M1_1(my, event):
-        my.wm.panes_list[my.wm.panes_current].maximize()
-
-    def M1_2(my, event):
-        split_pane(my.wm.display.keycode_to_keysym(event.detail, 0) - XK.XK_0,
-                   my.wm.panes_list[my.wm.panes_current].horizontal_split)
+    def M1_1(self, event):
+        self.wm.panes_list[self.wm.panes_current].maximize()
+
+    def M1_2(self, event):
+        split_pane(self.wm.display.keycode_to_keysym(event.detail, 0) - XK.XK_0,
+                   self.wm.panes_list[self.wm.panes_current].horizontal_split)
 
     M1_3 = M1_4 = M1_5 = M1_6 = M1_7 = M1_8 = M1_9 = M1_2
 
-    def S_M1_2(my, event):
-        split_pane(my.wm.display.keycode_to_keysym(event.detail, 0) - XK.XK_0,
-                   my.wm.panes_list[my.wm.panes_current].vertical_split)
+    def S_M1_2(self, event):
+        split_pane(self.wm.display.keycode_to_keysym(event.detail, 0) - XK.XK_0,
+                   self.wm.panes_list[self.wm.panes_current].vertical_split)
 
     S_M1_3 = S_M1_4 = S_M1_5 = S_M1_6 = S_M1_7 = S_M1_8 = S_M1_9 = S_M1_2
 
-    def M1_exclam(my, event):
-        runcommand(my.wm.panes_list[my.wm.panes_current], paneWindow)
-
-    def M1_equal(my, event):
-        numberpane(my.wm.panes_list[my.wm.panes_current], paneWindow)
-
-    def M1_minus(my, event):
+    def M1_exclam(self, event):
+        runcommand(self.wm.panes_list[self.wm.panes_current], paneWindow)
+
+    def M1_equal(self, event):
+        numberpane(self.wm.panes_list[self.wm.panes_current], paneWindow)
+
+    def M1_minus(self, event):
         """Close all the internal windows. Untested"""
 
-        for s in my.wm.screens:
+        for s in self.wm.screens:
             for w in s.windows:
-                if my.wm.is_internal_window(w):
+                if self.wm.is_internal_window(w):
                     w.destroy()
 
-    def M1_quoteright(my, event):
-        pullwindow(my.wm.panes_list[my.wm.panes_current], paneWindow)
-
-    def M1_quotedbl(my, event):
-        gotowindow(my.wm.panes_list[my.wm.panes_current], screenWindow)
-
-    def M1_space(my, event):
-        my.wm.panes_list[my.wm.panes_current].prev_window()
-
-    def S_M1_space(my, event):
-        my.wm.panes_list[my.wm.panes_current].next_window()
-
-    def _getapp(my, node):
-        getapp(my.wm.panes_list[my.wm.panes_current], node.get('title'),
+    def M1_quoteright(self, event):
+        pullwindow(self.wm.panes_list[self.wm.panes_current], paneWindow)
+
+    def M1_quotedbl(self, event):
+        gotowindow(self.wm.panes_list[self.wm.panes_current], screenWindow)
+
+    def M1_space(self, event):
+        self.wm.panes_list[self.wm.panes_current].prev_window()
+
+    def S_M1_space(self, event):
+        self.wm.panes_list[self.wm.panes_current].next_window()
+
+    def _getapp(self, node):
+        getapp(self.wm.panes_list[self.wm.panes_current], node.get('title'),
                node.get('command'))
 
-    def M1_a(my, event):
-        view_menu(my.wm.panes_list[my.wm.panes_current],
-                  XML_controller(my.menus.find('functionmenu'),
-                                 dict(getapp=my._getapp)))
-
-    def M1_A(my, event):
-        def run(node): my.wm.system('%s &' % node.get('command'))
-        view_menu(my.wm.panes_list[my.wm.panes_current],
-                  XML_controller(my.menus.find('namemenu'),
-                                 dict(getapp=my._getapp, run=run)))
-
-    def M1_c(my, event):
-        my.wm.panes_list[my.wm.panes_current].window.delete(1)
-
-    def M1_l(my, event):
-        my.wm.system('xscreensaver-command -activate')
-
-    def M1_i(my, event):
-        windowmenu(my.wm.panes_list[my.wm.panes_current], cfilter.iconified)
-
-    def M1_I(my, event):
-        my.wm.inspect_enable()
-        my.wm.system('xterm -title Inspector -e inspect_plwm &')
-
-    def M1_k(my, event):
-        my.wm.panes_list[my.wm.panes_current].window.delete(1)
-
-    def M1_K(my, event):
-        my.wm.panes_list[my.wm.panes_current].window.destroy()
-
-    def M1_m(my, event):
+    def M1_a(self, event):
+        view_menu(self.wm.panes_list[self.wm.panes_current],
+                  XML_controller(self.menus.find('functionmenu'),
+                                 dict(getapp=self._getapp)))
+
+    def M1_A(self, event):
+        def run(node): self.wm.system('%s &' % node.get('command'))
+        view_menu(self.wm.panes_list[self.wm.panes_current],
+                  XML_controller(self.menus.find('namemenu'),
+                                 dict(getapp=self._getapp, run=run)))
+
+    def M1_c(self, event):
+        self.wm.panes_list[self.wm.panes_current].window.delete(1)
+
+    def M1_l(self, event):
+        self.wm.system('xscreensaver-command -activate')
+
+    def M1_i(self, event):
+        windowmenu(self.wm.panes_list[self.wm.panes_current], cfilter.iconified)
+
+    def M1_I(self, event):
+        self.wm.inspect_enable()
+        self.wm.system('xterm -title Inspector -e inspect_plwm &')
+
+    def M1_k(self, event):
+        self.wm.panes_list[self.wm.panes_current].window.delete(1)
+
+    def M1_K(self, event):
+        self.wm.panes_list[self.wm.panes_current].window.destroy()
+
+    def M1_m(self, event):
         def itunes(node): os.system('itunes "%s" &' % node.get('command'))
-        view_menu(my.wm.panes_list[my.wm.panes_current],
-                  XML_controller(my.menus.find('itunesmenu'),
+        view_menu(self.wm.panes_list[self.wm.panes_current],
+                  XML_controller(self.menus.find('itunesmenu'),
                                  dict(itunes=itunes)))
 
-    def M1_n(my, event):
-        pane = my.wm.panes_list[my.wm.panes_current]
+    def M1_n(self, event):
+        pane = self.wm.panes_list[self.wm.panes_current]
         width, height = pane.screen.message_make("Current pane %d" % \
-                                                 my.wm.panes_current)
+                                                 self.wm.panes_current)
         pane.screen.message_display((pane.width - width) / 2 + pane.x,
                                    (pane.height - height) / 2 + pane.y)
 
-    def M1_p(my, event):
-        panesmenu(my.wm.current_screen)
-
-    def M1_r(my, event):
-        my.wm.panes_list[my.wm.panes_current].force_window()
-
-    def M1_R(my, event):
+    def M1_p(self, event):
+        panesmenu(self.wm.current_screen)
+
+    def M1_r(self, event):
+        self.wm.panes_list[self.wm.panes_current].force_window()
+
+    def M1_R(self, event):
         def reload_menus():
-            my.menus = load_menus(my.menu_file)
-            auto_restore(my.wm, my.menus.find('paneconfigmenus'))
+            self.menus = load_menus(self.menu_file)
+            auto_restore(self.wm, self.menus.find('paneconfigmenus'))
 
         def restore_menu(wm):
-            view_menu(pane, XML_controller(my.menus.find('paneconfigmenus'),
+            view_menu(pane, XML_controller(self.menus.find('paneconfigmenus'),
                                            dict(paneconfig=lambda x: restore(wm, x))))
 
-        pane = my.wm.panes_list[my.wm.panes_current]
-        codemenu(pane, {'1: Restore': (restore_menu, (my.wm,)),
+        pane = self.wm.panes_list[self.wm.panes_current]
+        codemenu(pane, {'1: Restore': (restore_menu, (self.wm,)),
                         '2: Reload': (reload_menus, ()),
                         '3: Restart': (os.execvp, (sys.executable,
                                                    [sys.executable] + sys.argv)),
-                        '4: Quit': (my.wm.quit, ())
+                        '4: Quit': (self.wm.quit, ())
                         })
 
-    def M1_s(my, event):
+    def M1_s(self, event):
         def dillo(url):
-            my.wm.system("dillo '%s' &" % url)
+            self.wm.system("dillo '%s' &" % url)
 
         def dowebsearch(node):
@@ -272 +272 @@
                 websearch(pane, node.get('label'), paneWindow, node.get('url'))
 
-        pane = my.wm.panes_list[my.wm.panes_current]
-        menu = XML_controller(my.menus.find('websearches'), dict(search=dowebsearch))
+        pane = self.wm.panes_list[self.wm.panes_current]
+        menu = XML_controller(self.menus.find('websearches'), dict(search=dowebsearch))
         add_keys(menu)
         view_menu(pane, menu)
 
-    def M1_S(my, event):
-        my.wm.panes_save()
-        pane = my.wm.panes_list[my.wm.panes_current]
+    def M1_S(self, event):
+        self.wm.panes_save()
+        pane = self.wm.panes_list[self.wm.panes_current]
         width, height = pane.screen.message_make("Saved panes configuration")
         pane.screen.message_display((pane.screen.root_width - width)
@@ -286 +286 @@
                                      / 2 + pane.screen.root_y)
 
-    def M1_w(my, event):
-        windowmenu(my.wm.panes_list[my.wm.panes_current])
-
-    def M1_W(my, event):
-        pane = my.wm.panes_list[my.wm.panes_current]
+    def M1_w(self, event):
+        windowmenu(self.wm.panes_list[self.wm.panes_current])
+
+    def M1_W(self, event):
+        pane = self.wm.panes_list[self.wm.panes_current]
         windowmenu(pane, panes.panefilter(pane))
 
-    def M1_x(my, event):
-        my.wm.panes_list[my.wm.panes_current].iconify_window()
+    def M1_x(self, event):
+        self.wm.panes_list[self.wm.panes_current].iconify_window()
 
 

trunk/plwm/input.py

@@ -54 +54 @@
     timeout = None
 
-    def __init__(my, handler, display, history):
+    def __init__(self, handler, display, history):
         """Init with a handler and display.
 
@@ -62 +62 @@
         history is a list of strings we let the user scroll through."""
 
-        KeyGrabKeyboard.__init__(my, handler, X.CurrentTime)
-        my.display = display
-        my.handler = handler
-        my.history = history
-        my.history_index = len(history)
-        my.left = ""
-        my.right = ""
+        KeyGrabKeyboard.__init__(self, handler, X.CurrentTime)
+        self.display = display
+        self.handler = handler
+        self.history = history
+        self.history_index = len(history)
+        self.left = ""
+        self.right = ""
         if isinstance(handler, Window):
-            my.selection = my.wm.display.intern_atom("SELECTION")
-            my.wm.dispatch.add_handler(X.SelectionNotify,
-                                       my._paste_selection, handlerid = my)
-        display.show(my.left, my.right)
-
-    def _paste_selection(my, event):
+            self.selection = self.wm.display.intern_atom("SELECTION")
+            self.wm.dispatch.add_handler(X.SelectionNotify,
+                                       self._paste_selection, handlerid = self)
+        display.show(self.left, self.right)
+
+    def _paste_selection(self, event):
         if event.property:
-            sel = my.handler.window.get_full_property(my.selection, Xatom.STRING)
+            sel = self.handler.window.get_full_property(self.selection, Xatom.STRING)
             if sel and sel.format == 8:
-                my.left = my.left + sel.value
-                my.display.show(my.left, my.right)
-
-    def _paste(my, event):
-        if isinstance(my.handler, Window):
-            my.handler.window.convert_selection(Xatom.PRIMARY, Xatom.STRING,
-                                                my.selection, X.CurrentTime)
-
-    def _insert(my, event):
+                self.left = self.left + sel.value
+                self.display.show(self.left, self.right)
+
+    def _paste(self, event):
+        if isinstance(self.handler, Window):
+            self.handler.window.convert_selection(Xatom.PRIMARY, Xatom.STRING,
+                                                self.selection, X.CurrentTime)
+
+    def _insert(self, event):
         if event.type != X.KeyPress: return
-        sym = my.wm.display.keycode_to_keysym(event.detail,
+        sym = self.wm.display.keycode_to_keysym(event.detail,
                                                 event.state & X.ShiftMask != 0)
-        chr = my.wm.display.lookup_string(sym)
-        if chr: my.left = my.left + chr
-        my.display.show(my.left, my.right)
-
-    def _forw(my, event):
-        if my.right:
-            my.left = my.left + my.right[0]
-            my.right = my.right[1:]
-        my.display.show(my.left, my.right)
-
-    def _back(my, event):
-        if my.left:
-            my.right = my.left[-1] + my.right
-            my.left = my.left[:-1]
-        my.display.show(my.left, my.right)
-
-    def _delforw(my, event):
-        if my.right:
-            my.right = my.right[1:]
-        my.display.show(my.left, my.right)
-
-    def _delback(my, event):
-        if my.left:
-            my.left = my.left[:-1]
-        my.display.show(my.left, my.right)
-
-    def _deltoend(my, event):
-        my.right = ""
-        my.display.show(my.left, my.right)
-
-    def _end(my, event):
-        my.left = my.left + my.right
-        my.right = ""
-        my.display.show(my.left, my.right)
-
-    def _begin(my, event):
-        my.right = my.left + my.right
-        my.left = ""
-        my.display.show(my.left, my.right)
-
-    def _done(my, event):
-        res = my.left + my.right
-        my.history.append(res)
-        my.display.do(res)
-        my.wm.dispatch.remove_handler(my)
-        my._cleanup()
-
-    def _abort(my, event):
-        my.display.abort()
-        my.wm.dispatch.remove_handler(my)
-        my._cleanup()
-
-    def _history_up(my, event):
-        if len(my.history):
-            if my.history_index > 0:
-                my.history_index -= 1
-                my.left = my.history[my.history_index]
-                my.right = ""
-                my.display.show(my.left, my.right)
-
-    def _history_down(my, event):
-        if len(my.history):
-            if my.history_index <(len(my.history)-1):
-                my.history_index += 1
-                my.left = my.history[my.history_index]
-                my.right = ""
-                my.display.show(my.left, my.right)
+        chr = self.wm.display.lookup_string(sym)
+        if chr: self.left = self.left + chr
+        self.display.show(self.left, self.right)
+
+    def _forw(self, event):
+        if self.right:
+            self.left = self.left + self.right[0]
+            self.right = self.right[1:]
+        self.display.show(self.left, self.right)
+
+    def _back(self, event):
+        if self.left:
+            self.right = self.left[-1] + self.right
+            self.left = self.left[:-1]
+        self.display.show(self.left, self.right)
+
+    def _delforw(self, event):
+        if self.right:
+            self.right = self.right[1:]
+        self.display.show(self.left, self.right)
+
+    def _delback(self, event):
+        if self.left:
+            self.left = self.left[:-1]
+        self.display.show(self.left, self.right)
+
+    def _deltoend(self, event):
+        self.right = ""
+        self.display.show(self.left, self.right)
+
+    def _end(self, event):
+        self.left = self.left + self.right
+        self.right = ""
+        self.display.show(self.left, self.right)
+
+    def _begin(self, event):
+        self.right = self.left + self.right
+        self.left = ""
+        self.display.show(self.left, self.right)
+
+    def _done(self, event):
+        res = self.left + self.right
+        self.history.append(res)
+        self.display.do(res)
+        self.wm.dispatch.remove_handler(self)
+        self._cleanup()
+
+    def _abort(self, event):
+        self.display.abort()
+        self.wm.dispatch.remove_handler(self)
+        self._cleanup()
+
+    def _history_up(self, event):
+        if len(self.history):
+            if self.history_index > 0:
+                self.history_index -= 1
+                self.left = self.history[self.history_index]
+                self.right = ""
+                self.display.show(self.left, self.right)
+
+    def _history_down(self, event):
+        if len(self.history):
+            if self.history_index <(len(self.history)-1):
+                self.history_index += 1
+                self.left = self.history[self.history_index]
+                self.right = ""
+                self.display.show(self.left, self.right)
 
 allmap(InputKeyHandler, InputKeyHandler._insert)
@@ -171 +171 @@
     history = []
 
-    def __init__(my, prompt, screen, length=30):
+    def __init__(self, prompt, screen, length=30):
 
         if not prompt: prompt = ' '        # We have problems if there's no prompt, so add one.
-        my.string = my.prompt = prompt
-        my.offset = len(my.prompt)
-        my.length = length + my.offset
-        my.start = 0
-        fg = screen.get_color(my.foreground)
-        bg = screen.get_color(my.background)
-        bc = screen.get_color(my.bordercolor)
-        font = screen.wm.get_font(my.fontname, 'fixed')
+        self.string = self.prompt = prompt
+        self.offset = len(self.prompt)
+        self.length = length + self.offset
+        self.start = 0
+        fg = screen.get_color(self.foreground)
+        bg = screen.get_color(self.background)
+        bc = screen.get_color(self.bordercolor)
+        font = screen.wm.get_font(self.fontname, 'fixed')
         size = font.query()
-        my.height = size.font_ascent + size.font_descent + 1
-        my.width = font.query_text_extents(prompt).overall_width + \
+        self.height = size.font_ascent + size.font_descent + 1
+        self.width = font.query_text_extents(prompt).overall_width + \
                    font.query_text_extents(length * 'm').overall_width
-        my.baseline = size.font_ascent + 1
-
-        window = screen.root.create_window(0, 0, my.width, my.height,
-                                           my.borderwidth,
+        self.baseline = size.font_ascent + 1
+
+        window = screen.root.create_window(0, 0, self.width, self.height,
+                                           self.borderwidth,
                                            X.CopyFromParent, X.InputOutput,
                                            X.CopyFromParent,
@@ -197 +197 @@
                                                          X.ExposureMask))
 
-        my.gc = window.create_gc(font = font, function = X.GXinvert,
+        self.gc = window.create_gc(font = font, function = X.GXinvert,
                                  foreground = fg, background = bg)
 
-        my.font = font
-        my.window = screen.add_internal_window(window)
-        my.window.dispatch.add_handler(X.VisibilityNotify, my.raisewindow)
-        my.window.dispatch.add_handler(X.Expose, my.redraw)
-
-    def read(my, action, handlertype, x=0, y=0):
+        self.font = font
+        self.window = screen.add_internal_window(window)
+        self.window.dispatch.add_handler(X.VisibilityNotify, self.raisewindow)
+        self.window.dispatch.add_handler(X.Expose, self.redraw)
+
+    def read(self, action, handlertype, x=0, y=0):
         "Open the window at x, y, using handlertype, and doing action."
 
-        my.action = action
-        x, y, width, height = my.window.keep_on_screen(x, y, my.width, my.height)
-        my.window.configure(x = x, y = y, width = width, height = height)
-        my.window.map()
-        my.window.get_focus(X.CurrentTime)
-        handlertype(my.window, my, my.history)
-
-    def raisewindow(my, event):
-        my.window.raisewindow()
-
-    def redraw(my, event = None):
-        length = len(my.string)
-
-        if my.offset < length:
-            wide = my.font.query_text_extents(my.string[my.offset]).overall_width
+        self.action = action
+        x, y, width, height = self.window.keep_on_screen(x, y, self.width, self.height)
+        self.window.configure(x = x, y = y, width = width, height = height)
+        self.window.map()
+        self.window.get_focus(X.CurrentTime)
+        handlertype(self.window, self, self.history)
+
+    def raisewindow(self, event):
+        self.window.raisewindow()
+
+    def redraw(self, event = None):
+        length = len(self.string)
+
+        if self.offset < length:
+            wide = self.font.query_text_extents(self.string[self.offset]).overall_width
         else:
-            wide = my.font.query_text_extents(' ').overall_width
-
-        if my.start >= my.offset: my.start = my.offset - 1
-        left = my.font.query_text_extents(my.string[my.start:my.offset]).overall_width
-
-        if left + wide >= my.width:
-            my.start = my.offset - my.length + 1
-            left = my.font.query_text_extents(my.string[my.start:my.offset]).overall_width
-
-        my.window.clear_area(width = my.width, height = my.height)
-        my.window.image_text(my.gc, 0, my.baseline, my.string[my.start:])
-        my.window.fill_rectangle(my.gc, left, 0, wide, my.height)
-
-
-    def show(my, left, right):
+            wide = self.font.query_text_extents(' ').overall_width
+
+        if self.start >= self.offset: self.start = self.offset - 1
+        left = self.font.query_text_extents(self.string[self.start:self.offset]).overall_width
+
+        if left + wide >= self.width:
+            self.start = self.offset - self.length + 1
+            left = self.font.query_text_extents(self.string[self.start:self.offset]).overall_width
+
+        self.window.clear_area(width = self.width, height = self.height)
+        self.window.image_text(self.gc, 0, self.baseline, self.string[self.start:])
+        self.window.fill_rectangle(self.gc, left, 0, wide, self.height)
+
+
+    def show(self, left, right):
         if left:
-            my.string = my.prompt + left
+            self.string = self.prompt + left
       &