wxPython 4.3.2__cp315-cp315-win_amd64.whl

wx/py/editwindow.py

@@ -0,0 +1,316 @@
+"""EditWindow class."""
+
+__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
+
+import wx
+from wx import stc
+
+import keyword
+import os
+import sys
+import time
+
+from . import dispatcher
+from .version import VERSION
+
+
+def get_faces():
+    
+    try:
+        is_dark = wx.SystemSettings.GetAppearance().IsDark()
+    except wx.PyNoAppError:
+        is_dark = False
+        
+    if 'wxMSW' in wx.PlatformInfo:
+        # Safely evaluate IsDark() inside a try-except fallback block
+        return { 
+            'times'     : 'Times New Roman',
+            'mono'      : 'Courier New',
+            'helv'      : 'Arial',
+            'lucida'    : 'Lucida Console',
+            'other'     : 'Comic Sans MS',
+            'size'      : 10,
+            'lnsize'    : 8,
+            'backcol'   : '#202020' if is_dark else '#FFFFFF',
+            'calltipbg' : '#2D2D2D' if is_dark else '#FFFFB8',
+            'calltipfg' : '#E0E0E0' if is_dark else '#404040',
+        }
+
+    elif 'wxGTK' in wx.PlatformInfo and ('gtk2' in wx.PlatformInfo or 'gtk3' in wx.PlatformInfo):
+        return { 
+            'times'     : 'Serif',
+            'mono'      : 'Monospace',
+            'helv'      : 'Sans',
+            'other'     : 'new century schoolbook',
+            'size'      : 10,
+            'lnsize'    : 9,
+            'backcol'   : '#202020' if is_dark else '#FFFFFF',
+            'calltipbg' : '#2D2D2D' if is_dark else '#FFFFB8',
+            'calltipfg' : '#E0E0E0' if is_dark else '#404040',
+        }
+
+    elif 'wxMac' in wx.PlatformInfo:
+        return { 
+            'times'     : 'Lucida Grande',
+            'mono'      : 'Monaco',
+            'helv'      : 'Geneva',
+            'other'     : 'new century schoolbook',
+            'size'      : 12,
+            'lnsize'    : 10,
+            'backcol'   : '#202020' if is_dark else '#FFFFFF',
+            'calltipbg' : '#2D2D2D' if is_dark else '#FFFFB8',
+            'calltipfg' : '#E0E0E0' if is_dark else '#404040',
+        }
+
+    else: # GTK1, etc.
+        return { 
+            'times'     : 'Times',
+            'mono'      : 'Courier',
+            'helv'      : 'Helvetica',
+            'other'     : 'new century schoolbook',
+            'size'      : 12,
+            'lnsize'    : 10,
+            'backcol'   : '#FFFFFF',
+            'calltipbg' : '#FFFFB8',
+            'calltipfg' : '#404040',
+        }
+
+
+class EditWindow(stc.StyledTextCtrl):
+    """EditWindow based on StyledTextCtrl."""
+
+
+    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER):
+        """Create EditWindow instance."""
+        self.FACES = get_faces()
+        stc.StyledTextCtrl.__init__(self, parent, id, pos, size, style)
+        self.__config()
+        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
+        dispatcher.connect(receiver=self._fontsizer, signal='FontIncrease')
+        dispatcher.connect(receiver=self._fontsizer, signal='FontDecrease')
+        dispatcher.connect(receiver=self._fontsizer, signal='FontDefault')
+
+    def _fontsizer(self, signal):
+        """Receiver for Font* signals."""
+        if not self:
+            dispatcher.disconnect(receiver=self._fontsizer, signal='FontIncrease')
+            dispatcher.disconnect(receiver=self._fontsizer, signal='FontDecrease')
+            dispatcher.disconnect(receiver=self._fontsizer, signal='FontDefault')
+            return
+        size = self.GetZoom()
+        if signal == 'FontIncrease':
+            size += 1
+        elif signal == 'FontDecrease':
+            size -= 1
+        elif signal == 'FontDefault':
+            size = 0
+        self.SetZoom(size)
+
+
+    def __config(self):
+        self.setDisplayLineNumbers(False)
+
+        self.SetLexer(stc.STC_LEX_PYTHON)
+        self.SetKeyWords(0, ' '.join(keyword.kwlist))
+
+        self.setStyles(self.FACES)
+        self.SetViewWhiteSpace(False)
+        self.SetTabWidth(4)
+        self.SetUseTabs(False)
+        # Do we want to automatically pop up command completion options?
+        self.autoComplete = True
+        self.autoCompleteIncludeMagic = True
+        self.autoCompleteIncludeSingle = True
+        self.autoCompleteIncludeDouble = True
+        self.autoCompleteCaseInsensitive = True
+        self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive)
+        self.autoCompleteAutoHide = False
+        self.AutoCompSetAutoHide(self.autoCompleteAutoHide)
+        self.AutoCompStops(' .,;:([)]}\'"\\<>%^&+-=*/|`')
+        # Do we want to automatically pop up command argument help?
+        self.autoCallTip = True
+        self.callTipInsert = True
+        self.CallTipSetBackground(self.FACES['calltipbg'])
+        self.CallTipSetForeground(self.FACES['calltipfg'])
+        self.SetWrapMode(False)
+        try:
+            self.SetEndAtLastLine(False)
+        except AttributeError:
+            pass
+
+    def setDisplayLineNumbers(self, state):
+        self.lineNumbers = state
+        if state:
+            self.SetMarginType(1, stc.STC_MARGIN_NUMBER)
+            self.SetMarginWidth(1, 40)
+        else:
+            # Leave a small margin so the feature hidden lines marker can be seen
+            self.SetMarginType(1, 0)
+            self.SetMarginWidth(1, 10)
+
+    def setStyles(self, faces):
+        """Configure font size, typeface and color for lexer."""
+
+        # Default style
+        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
+                          "face:%(mono)s,size:%(size)d,back:%(backcol)s" % \
+                          faces)
+
+        self.StyleClearAll()
+        self.SetSelForeground(True, wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHTTEXT))
+        self.SetSelBackground(True, wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHT))
+
+        # Built in styles
+        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,
+                          "back:#C0C0C0,face:%(mono)s,size:%(lnsize)d" % faces)
+        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR,
+                          "face:%(mono)s" % faces)
+        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,
+                          "fore:#0000FF,back:#FFFF88")
+        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
+                          "fore:#FF0000,back:#FFFF88")
+
+        # Python styles
+        self.StyleSetSpec(stc.STC_P_DEFAULT,
+                          "face:%(mono)s" % faces)
+        self.StyleSetSpec(stc.STC_P_COMMENTLINE,
+                          "fore:#007F00,face:%(mono)s" % faces)
+        self.StyleSetSpec(stc.STC_P_NUMBER,
+                          "")
+        self.StyleSetSpec(stc.STC_P_STRING,
+                          "fore:#7F007F,face:%(mono)s" % faces)
+        self.StyleSetSpec(stc.STC_P_CHARACTER,
+                          "fore:#7F007F,face:%(mono)s" % faces)
+        self.StyleSetSpec(stc.STC_P_WORD,
+                          "fore:#00007F,bold")
+        self.StyleSetSpec(stc.STC_P_TRIPLE,
+                          "fore:#7F0000")
+        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE,
+                          "fore:#000033,back:#FFFFE8")
+        self.StyleSetSpec(stc.STC_P_CLASSNAME,
+                          "fore:#0000FF,bold")
+        self.StyleSetSpec(stc.STC_P_DEFNAME,
+                          "fore:#007F7F,bold")
+        self.StyleSetSpec(stc.STC_P_OPERATOR,
+                          "")
+        self.StyleSetSpec(stc.STC_P_IDENTIFIER,
+                          "")
+        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK,
+                          "fore:#7F7F7F")
+        self.StyleSetSpec(stc.STC_P_STRINGEOL,
+                          "fore:#000000,face:%(mono)s,back:#E0C0E0,eol" % faces)
+
+    def OnUpdateUI(self, event):
+        """Check for matching braces."""
+        # If the auto-complete window is up let it do its thing.
+        if self.AutoCompActive() or self.CallTipActive():
+            return
+        braceAtCaret = -1
+        braceOpposite = -1
+        charBefore = None
+        caretPos = self.GetCurrentPos()
+        if caretPos > 0:
+            charBefore = self.GetCharAt(caretPos - 1)
+            styleBefore = self.GetStyleAt(caretPos - 1)
+
+        # Check before.
+        if charBefore and chr(charBefore) in '[]{}()' \
+        and styleBefore == stc.STC_P_OPERATOR:
+            braceAtCaret = caretPos - 1
+
+        # Check after.
+        if braceAtCaret < 0:
+            charAfter = self.GetCharAt(caretPos)
+            styleAfter = self.GetStyleAt(caretPos)
+            if charAfter and chr(charAfter) in '[]{}()' \
+            and styleAfter == stc.STC_P_OPERATOR:
+                braceAtCaret = caretPos
+
+        if braceAtCaret >= 0:
+            braceOpposite = self.BraceMatch(braceAtCaret)
+
+        if braceAtCaret != -1  and braceOpposite == -1:
+            self.BraceBadLight(braceAtCaret)
+        else:
+            self.BraceHighlight(braceAtCaret, braceOpposite)
+
+    def CanCopy(self):
+        """Return True if text is selected and can be copied."""
+        return self.GetSelectionStart() != self.GetSelectionEnd()
+
+    def CanCut(self):
+        """Return True if text is selected and can be cut."""
+        return self.CanCopy() and self.CanEdit()
+
+    def CanEdit(self):
+        """Return True if editing should succeed."""
+        return not self.GetReadOnly()
+
+    def CanPaste(self):
+        """Return True if pasting should succeed."""
+        return stc.StyledTextCtrl.CanPaste(self) and self.CanEdit()
+
+
+    def GetLastPosition(self):
+        return self.GetLength()
+
+    def GetRange(self, start, end):
+        return self.GetTextRange(start, end)
+
+    def GetSelection(self):
+        return self.GetAnchor(), self.GetCurrentPos()
+
+    def ShowPosition(self, pos):
+        line = self.LineFromPosition(pos)
+        self.EnsureVisible(line)  # Expand the line if folded.
+        self.GotoLine(line)
+
+    def DoFindNext(self, findData, findDlg=None):
+        backward = not (findData.GetFlags() & wx.FR_DOWN)
+        matchcase = findData.GetFlags() & wx.FR_MATCHCASE
+        wholeword = findData.GetFlags() & wx.FR_WHOLEWORD
+        findstring = findData.GetFindString().encode()
+        self.SetSearchFlags(0
+            | (wx.stc.STC_FIND_MATCHCASE if matchcase else 0)
+            | (wx.stc.STC_FIND_WHOLEWORD if wholeword else 0)
+        )
+        if backward:
+            self.TargetStart = self.GetAnchor()  # backward anchor
+            self.TargetEnd = 0
+        else:
+            self.TargetStart = self.GetCurrentPos()  # forward anchor
+            self.TargetEnd = self.TextLength
+        loc = self.SearchInTarget(findstring)
+
+        # if it wasn't found then restart at beginning
+        if loc == -1:
+            self.TargetStart = self.TextLength if backward else 0
+            loc = self.SearchInTarget(findstring)
+
+        # was it still not found?
+        if loc == -1:
+            dlg = wx.MessageDialog(self, 'Unable to find the search text.',
+                          'Not found!',
+                          wx.OK | wx.ICON_INFORMATION)
+            dlg.ShowModal()
+            dlg.Destroy()
+        if findDlg:
+            if loc == -1:
+                wx.CallAfter(findDlg.SetFocus)
+                return
+            else:
+                findDlg.Close()
+
+        # show and select the found text
+        self.ShowPosition(loc)
+        self.SetSelection(loc, loc + len(findstring))
+
+    def SetSelection(self, from_, to_):
+        """Selects the text starting at the first position up to
+        (but not including) the character at the last position.
+        """
+        # (override) Patch for miss-insertion position when from_ > to_.
+        # Note: This is needed until the stc SetSelection bug is fixed.
+        self.SetAnchor(from_)
+        self.SetCurrentPos(to_)

wx/py/filling.py

@@ -0,0 +1,358 @@
+"""Filling is the gui tree control through which a user can navigate
+the local namespace or any object."""
+
+__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
+
+import wx
+
+from . import dispatcher
+from . import editwindow
+from . import images
+import inspect
+from . import introspect
+import types
+
+
+COMMONTYPES = [getattr(types, t) for t in dir(types) \
+               if not t.startswith('_') \
+               and t not in ('ClassType', 'InstanceType', 'ModuleType')]
+
+DOCTYPES = ('BuiltinFunctionType', 'BuiltinMethodType', 'ClassType',
+            'FunctionType', 'GeneratorType', 'InstanceType',
+            'LambdaType', 'MethodType', 'ModuleType',
+            'UnboundMethodType', 'method-wrapper')
+
+SIMPLETYPES = [getattr(types, t) for t in dir(types) \
+               if not t.startswith('_') and t not in DOCTYPES]
+
+#del t
+
+try:
+    COMMONTYPES.append(type(''.__repr__))  # Method-wrapper in version 2.2.x.
+except AttributeError:
+    pass
+
+
+class FillingTree(wx.TreeCtrl):
+    """FillingTree based on TreeCtrl."""
+
+    name = 'Filling Tree'
+
+    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=wx.TR_DEFAULT_STYLE,
+                 rootObject=None, rootLabel=None, rootIsNamespace=False,
+                 static=False):
+        """Create FillingTree instance."""
+        wx.TreeCtrl.__init__(self, parent, id, pos, size, style)
+        self.rootIsNamespace = rootIsNamespace
+        import __main__
+        if rootObject is None:
+            rootObject = __main__.__dict__
+            self.rootIsNamespace = True
+        if rootObject is __main__.__dict__ and rootLabel is None:
+            rootLabel = 'locals()'
+        if not rootLabel:
+            rootLabel = 'Ingredients'
+        self.item = self.root = self.AddRoot(rootLabel, -1, -1, rootObject)
+        self.SetItemHasChildren(self.root, self.objHasChildren(rootObject))
+        self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnItemExpanding, id=self.GetId())
+        self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, id=self.GetId())
+        self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, id=self.GetId())
+        self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnItemActivated, id=self.GetId())
+        if not static:
+            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
+
+    def push(self, command, more):
+        """Receiver for Interpreter.push signal."""
+        if not self:
+            dispatcher.disconnect(receiver=self.push, signal='Interpreter.push')
+            return
+        self.display()
+
+    def OnItemExpanding(self, event):
+        """Add children to the item."""
+        busy = wx.BusyCursor()
+        item = event.GetItem()
+        if self.IsExpanded(item):
+            return
+        self.addChildren(item)
+#        self.SelectItem(item)
+
+    def OnItemCollapsed(self, event):
+        """Remove all children from the item."""
+        busy = wx.BusyCursor()
+        item = event.GetItem()
+#        self.CollapseAndReset(item)
+#        self.DeleteChildren(item)
+#        self.SelectItem(item)
+
+    def OnSelChanged(self, event):
+        """Display information about the item."""
+        busy = wx.BusyCursor()
+        self.item = event.GetItem()
+        self.display()
+
+    def OnItemActivated(self, event):
+        """Launch a DirFrame."""
+        item = event.GetItem()
+        text = self.getFullName(item)
+        obj = self.GetItemData(item)
+        frame = FillingFrame(parent=self, size=(600, 100), rootObject=obj,
+                             rootLabel=text, rootIsNamespace=False)
+        frame.Show()
+
+    def objHasChildren(self, obj):
+        """Return true if object has children."""
+        if self.objGetChildren(obj):
+            return True
+        else:
+            return False
+
+    def objGetChildren(self, obj):
+        """Return dictionary with attributes or contents of object."""
+        busy = wx.BusyCursor()
+        otype = type(obj)
+        if (isinstance(obj, dict)
+            or 'BTrees' in str(otype)
+            and hasattr(obj, 'keys')):
+            return obj
+        d = {}
+        if isinstance(obj, (list, tuple)):
+            for n in range(len(obj)):
+                key = '[' + str(n) + ']'
+                d[key] = obj[n]
+        if otype not in COMMONTYPES:
+            for key in introspect.getAttributeNames(obj):
+                if wx.Platform == '__WXMSW__':
+                    if key == 'DropTarget': # Windows bug fix.
+                        continue
+                # Believe it or not, some attributes can disappear,
+                # such as the exc_traceback attribute of the sys
+                # module. So this is nested in a try block.
+                try:
+                    d[key] = getattr(obj, key)
+                except Exception:
+                    pass
+        return d
+
+    def addChildren(self, item):
+        self.DeleteChildren(item)
+        obj = self.GetItemData(item)
+        children = self.objGetChildren(obj)
+        if not children:
+            return
+        keys = sorted(children, key=lambda x: str(x).lower())
+        for key in keys:
+            itemtext = str(key)
+            # Show string dictionary items with single quotes, except
+            # for the first level of items, if they represent a
+            # namespace.
+            if isinstance(obj, dict) \
+            and isinstance(key, str) \
+            and (item != self.root
+                 or (item == self.root and not self.rootIsNamespace)):
+                itemtext = repr(key)
+            child = children[key]
+            branch = self.AppendItem(parent=item, text=itemtext, data=child)
+            self.SetItemHasChildren(branch, self.objHasChildren(child))
+
+    def display(self):
+        item = self.item
+        if not item:
+            return
+        if self.IsExpanded(item):
+            self.addChildren(item)
+        self.setText('')
+        obj = self.GetItemData(item)
+        if wx.Platform == '__WXMSW__':
+            if obj is None: # Windows bug fix.
+                return
+        self.SetItemHasChildren(item, self.objHasChildren(obj))
+        otype = type(obj)
+        text = ''
+        text += self.getFullName(item)
+        text += '\n\nType: ' + str(otype)
+        try:
+            value = str(obj)
+        except Exception:
+            value = ''
+        if isinstance(obj, str):
+            value = repr(obj)
+        text += u'\n\nValue: ' + value
+        if otype not in SIMPLETYPES:
+            try:
+                text += '\n\nDocstring:\n\n"""' + \
+                        inspect.getdoc(obj).strip() + '"""'
+            except Exception:
+                pass
+        if isinstance(obj, type):
+            try:
+                text += '\n\nClass Definition:\n\n' + \
+                        inspect.getsource(obj.__class__)
+            except Exception:
+                pass
+        else:
+            try:
+                text += '\n\nSource Code:\n\n' + \
+                        inspect.getsource(obj)
+            except Exception:
+                pass
+        self.setText(text)
+
+    def getFullName(self, item, partial=''):
+        """Return a syntactically proper name for item."""
+        name = self.GetItemText(item)
+        parent = None
+        obj = None
+        if item != self.root:
+            parent = self.GetItemParent(item)
+            obj = self.GetItemData(parent)
+        # Apply dictionary syntax to dictionary items, except the root
+        # and first level children of a namespace.
+        if ((isinstance(obj, dict)
+            or 'BTrees' in str(type(obj))
+            and hasattr(obj, 'keys'))
+            and ((item != self.root and parent != self.root)
+            or (parent == self.root and not self.rootIsNamespace))):
+            name = '[' + name + ']'
+        # Apply dot syntax to multipart names.
+        if partial:
+            if partial[0] == '[':
+                name += partial
+            else:
+                name += '.' + partial
+        # Repeat for everything but the root item
+        # and first level children of a namespace.
+        if (item != self.root and parent != self.root) \
+        or (parent == self.root and not self.rootIsNamespace):
+            name = self.getFullName(parent, partial=name)
+        return name
+
+    def setText(self, text):
+        """Display information about the current selection."""
+
+        # This method will likely be replaced by the enclosing app to
+        # do something more interesting, like write to a text control.
+        print(text)
+
+    def setStatusText(self, text):
+        """Display status information."""
+
+        # This method will likely be replaced by the enclosing app to
+        # do something more interesting, like write to a status bar.
+        print(text)
+
+
+class FillingText(editwindow.EditWindow):
+    """FillingText based on StyledTextCtrl."""
+
+    name = 'Filling Text'
+
+    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
+                 static=False):
+        """Create FillingText instance."""
+        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
+        # Configure various defaults and user preferences.
+        self.SetReadOnly(True)
+        self.SetWrapMode(True)
+        self.SetMarginWidth(1, 0)
+        if not static:
+            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
+
+    def push(self, command, more):
+        """Receiver for Interpreter.push signal."""
+        if not self:
+            dispatcher.disconnect(receiver=self.push, signal='Interpreter.push')
+            return
+        self.Refresh()
+
+    def SetText(self, *args, **kwds):
+        self.SetReadOnly(False)
+        editwindow.EditWindow.SetText(self, *args, **kwds)
+        self.SetReadOnly(True)
+
+
+class Filling(wx.SplitterWindow):
+    """Filling based on wxSplitterWindow."""
+
+    name = 'Filling'
+
+    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
+                 size=wx.DefaultSize, style=wx.SP_3D|wx.SP_LIVE_UPDATE,
+                 name='Filling Window', rootObject=None,
+                 rootLabel=None, rootIsNamespace=False, static=False):
+        """Create a Filling instance."""
+        wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
+
+        self.tree = FillingTree(parent=self, rootObject=rootObject,
+                                rootLabel=rootLabel,
+                                rootIsNamespace=rootIsNamespace,
+                                static=static)
+        self.text = FillingText(parent=self, static=static)
+
+        wx.CallLater(25, self.SplitVertically, self.tree, self.text, 200)
+
+        self.SetMinimumPaneSize(1)
+
+        # Override the filling so that descriptions go to FillingText.
+        self.tree.setText = self.text.SetText
+
+        # Display the root item.
+        self.tree.SelectItem(self.tree.root)
+        self.tree.display()
+
+        self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED, self.OnChanged)
+
+    def OnChanged(self, event):
+        #this is important: do not evaluate this event=> otherwise,
+        # splitterwindow behaves strangely
+        #event.Skip()
+        pass
+
+    def LoadSettings(self, config):
+        pos = config.ReadInt('Sash/FillingPos', 200)
+        if not self.IsSplit():
+            self.SplitVertically(self.tree, self.text)
+        wx.CallLater(250, self.SetSashPosition, pos)
+        zoom = config.ReadInt('View/Zoom/Filling', -99)
+        if zoom != -99:
+            self.text.SetZoom(zoom)
+
+    def SaveSettings(self, config):
+        config.WriteInt('Sash/FillingPos', self.GetSashPosition())
+        config.WriteInt('View/Zoom/Filling', self.text.GetZoom())
+
+
+
+class FillingFrame(wx.Frame):
+    """Frame containing the namespace tree component."""
+
+    name = 'Filling Frame'
+
+    def __init__(self, parent=None, id=-1, title='PyFilling',
+                 pos=wx.DefaultPosition, size=(600, 400),
+                 style=wx.DEFAULT_FRAME_STYLE, rootObject=None,
+                 rootLabel=None, rootIsNamespace=False, static=False):
+        """Create FillingFrame instance."""
+        wx.Frame.__init__(self, parent, id, title, pos, size, style)
+        intro = 'PyFilling - The Tastiest Namespace Inspector'
+        self.CreateStatusBar()
+        self.SetStatusText(intro)
+        self.SetIcon(images.getPyIcon())
+        self.filling = Filling(parent=self, rootObject=rootObject,
+                               rootLabel=rootLabel,
+                               rootIsNamespace=rootIsNamespace,
+                               static=static)
+        # Override so that status messages go to the status bar.
+        self.filling.tree.setStatusText = self.SetStatusText
+
+
+class App(wx.App):
+    """PyFilling standalone application."""
+
+    def OnInit(self):
+        self.fillingFrame = FillingFrame()
+        self.fillingFrame.Show(True)
+        self.SetTopWindow(self.fillingFrame)
+        return True