def OnInit(self):    
     print wx.version()
     
     frame = ExplorerFrame(None)
     self.SetTopWindow(frame)
     frame.Show()
     return True

    def CreatePopupMenu(self):
        """
        Overrides method in parent class to provide a Popup Menu
        when the user clicks on MyData's system tray (or menubar) icon.
        """
        self.menu = wx.Menu()

        self.myTardisSyncMenuItem = wx.MenuItem(
            self.menu, wx.NewId(), "MyTardis Sync")
        if wx.version().startswith("3.0.3.dev"):
            self.menu.Append(self.myTardisSyncMenuItem)
        else:
            self.menu.AppendItem(self.myTardisSyncMenuItem)
        self.Bind(wx.EVT_MENU, self.OnMyTardisSync,
                  self.myTardisSyncMenuItem, self.myTardisSyncMenuItem.GetId())

        self.menu.AppendSeparator()

        self.myTardisMainWindowMenuItem = wx.MenuItem(
            self.menu, wx.NewId(), "MyData Main Window")
        if wx.version().startswith("3.0.3.dev"):
            self.menu.Append(self.myTardisMainWindowMenuItem)
        else:
            self.menu.AppendItem(self.myTardisMainWindowMenuItem)
        self.Bind(wx.EVT_MENU, self.OnMyDataMainWindow,
                  self.myTardisMainWindowMenuItem)

        self.myTardisSettingsMenuItem = wx.MenuItem(
            self.menu, wx.NewId(), "MyData Settings")
        if wx.version().startswith("3.0.3.dev"):
            self.menu.Append(self.myTardisSettingsMenuItem)
        else:
            self.menu.AppendItem(self.myTardisSettingsMenuItem)
        self.Bind(wx.EVT_MENU, self.OnMyDataSettings,
                  self.myTardisSettingsMenuItem)

        self.menu.AppendSeparator()

        self.myTardisHelpMenuItem = wx.MenuItem(
            self.menu, wx.NewId(), "MyData Help")
        if wx.version().startswith("3.0.3.dev"):
            self.menu.Append(self.myTardisHelpMenuItem)
        else:
            self.menu.AppendItem(self.myTardisHelpMenuItem)
        self.Bind(wx.EVT_MENU, self.OnMyDataHelp, self.myTardisHelpMenuItem)

        self.menu.AppendSeparator()

        self.exitMyDataMenuItem = wx.MenuItem(
            self.menu, wx.NewId(), "Exit MyData")
        if wx.version().startswith("3.0.3.dev"):
            self.menu.Append(self.exitMyDataMenuItem)
        else:
            self.menu.AppendItem(self.exitMyDataMenuItem)
        self.Bind(wx.EVT_MENU, self.OnExit, self.exitMyDataMenuItem)

        return self.menu

    def __init__(self):
        wx.Frame.__init__(self, parent=None, id=wx.ID_ANY,
                          title='wxPython example', size=(WIDTH, HEIGHT))
        self.browser = None

        # Must ignore X11 errors like 'BadWindow' and others by
        # installing X11 error handlers. This must be done after
        # wx was intialized.
        if LINUX:
            WindowUtils.InstallX11ErrorHandlers()

        global g_count_windows
        g_count_windows += 1

        self.setup_icon()
        self.create_menu()
        self.Bind(wx.EVT_CLOSE, self.OnClose)

        # Set wx.WANTS_CHARS style for the keyboard to work.
        # This style also needs to be set for all parent controls.
        self.browser_panel = wx.Panel(self, style=wx.WANTS_CHARS)
        self.browser_panel.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
        self.browser_panel.Bind(wx.EVT_SIZE, self.OnSize)

        if MAC:
            try:
                # noinspection PyUnresolvedReferences
                from AppKit import NSApp
                # Make the content view for the window have a layer.
                # This will make all sub-views have layers. This is
                # necessary to ensure correct layer ordering of all
                # child views and their layers. This fixes Window
                # glitchiness during initial loading on Mac (Issue #371).
                NSApp.windows()[0].contentView().setWantsLayer_(True)
            except ImportError:
                print("[wxpython.py] Warning: PyObjC package is missing, "
                      "cannot fix Issue #371")
                print("[wxpython.py] To install PyObjC type: "
                      "pip install -U pyobjc")

        if LINUX:
            # On Linux must show before embedding browser, so that handle
            # is available (Issue #347).
            self.Show()
            # In wxPython 3.0 and wxPython 4.0 on Linux handle is
            # still not yet available, so must delay embedding browser
            # (Issue #349).
            if wx.version().startswith("3.") or wx.version().startswith("4."):
                wx.CallLater(1000, self.embed_browser)
            else:
                # This works fine in wxPython 2.8 on Linux
                self.embed_browser()
        else:
            self.embed_browser()
            self.Show()

    def __populate_versions(self, control):
        imageType = 'Pillow'
        try:
            imageVer = Image.PILLOW_VERSION
        except AttributeError:
            imageType = 'PIL'
            imageVer = Image.VERSION

        versions = ('Hardware:\n'
                    '\tProcessor: {}, {} cores\n\n'
                    'Software:\n'
                    '\tOS: {}, {}\n'
                    '\tPython: {}\n'
                    '\tmatplotlib: {}\n'
                    '\tNumPy: {}\n'
                    '\t{}: {}\n'
                    '\tpySerial: {}\n'
                    '\twxPython: {}\n'
                    ).format(platform.processor(), multiprocessing.cpu_count(),
                             platform.platform(), platform.machine(),
                             platform.python_version(),
                             matplotlib.__version__,
                             numpy.version.version,
                             imageType, imageVer,
                             serial.VERSION,
                             wx.version())

        control.SetValue(versions)

        dc = wx.WindowDC(control)
        extent = list(dc.GetMultiLineTextExtent(versions, control.GetFont()))
        extent[0] += wx.SystemSettings.GetMetric(wx.SYS_VSCROLL_X) * 2
        extent[1] += wx.SystemSettings.GetMetric(wx.SYS_HSCROLL_Y) * 2
        control.SetMinSize((extent[0], extent[1]))
        self.Layout()

  def _CreateHtmlContent(self):
    """Create content for this About Dialog."""
    try:
      self._content_string = open(self._CONTENT_FILENAME).read()
    except IOError:
      raise AboutBoxException('Cannot open or read about box content')

    # Grab SDK version information
    sdk_version = '???'  # default
    sdk_dir = self._preferences[launcher.Preferences.PREF_APPENGINE]
    if sdk_dir:
      sdk_version_file = os.path.join(sdk_dir, 'VERSION')
      try:
        sdk_version = '<br>'.join(open(sdk_version_file).readlines())
      except IOError:
        pass

    # By default, wx.html windows have a white background.  We'd
    # prefer a standard window background color.  Although there is
    # a wx.html.HtmlWindow.SetBackgroundColour() method, it doesn't
    # help us.  The best we can do is set the background from within
    # the html itself.
    bgcolor = '#%02x%02x%02x' % self._background_color[0:3]

    # Replace some strings with dynamically determined information.
    text = self._content_string
    text = text.replace('{background-color}', bgcolor)
    text = text.replace('{launcher-version}', '???')  # TODO(jrg): add a version
    text = text.replace('{python-version}', sys.version.split()[0])
    text = text.replace('{wxpython-version}', wx.version())
    text = text.replace('{sdk-version}', sdk_version)
    self._content_string = text

def check_versions():
    print("[wxpython.py] CEF Python {ver}".format(ver=cef.__version__))
    print("[wxpython.py] Python {ver} {arch}".format(
            ver=platform.python_version(), arch=platform.architecture()[0]))
    print("[wxpython.py] wxPython {ver}".format(ver=wx.version()))
    # CEF Python version requirement
    assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this"

def EnvironmentInfo():
	"""
	Returns a string of the systems information.


	**Returns:**

	*  System information string

	**Note:**

	*  from Editra.dev_tool
	"""

	info = list()
	info.append("---- Notes ----")
	info.append("Please provide additional information about the crash here")
	info.extend(["", "", ""])
	info.append("---- System Information ----")
	info.append("Operating System: %s" % wx.GetOsDescription())
	if sys.platform == 'darwin':
		info.append("Mac OSX: %s" % platform.mac_ver()[0])
	info.append("Python Version: %s" % sys.version)
	info.append("wxPython Version: %s" % wx.version())
	info.append("wxPython Info: (%s)" % ", ".join(wx.PlatformInfo))
	info.append("Python Encoding: Default = %s  File = %s" % \
				(sys.getdefaultencoding(), sys.getfilesystemencoding()))
	info.append("wxPython Encoding: %s" % wx.GetDefaultPyEncoding())
	info.append("System Architecture: %s %s" % (platform.architecture()[0], \
												platform.machine()))
	info.append("Byte order: %s" % sys.byteorder)
	info.append("Frozen: %s" % str(getattr(sys, 'frozen', 'False')))
	info.append("---- End System Information ----")

	return os.linesep.join(info)

    def __init__(self, *args, **kwargs):
        wx.Frame.__init__(self, *args, **kwargs)

        # There needs to be an "Images" directory with one or more jpegs in it in the
        # current working directory for this to work.
        self.jpgs = GetJpgList("./Images") # Get all the jpegs in the Images directory.
        self.CurrentJpg = 0

        self.MaxImageSize = 200

        b = wx.Button(self, -1, "Display next")
        b.Bind(wx.EVT_BUTTON, self.DisplayNext)

        # Starting with an EmptyBitmap, the real one will get put there
        # by the call to .DisplayNext().
        if 'phoenix' in wx.version():
            bmp = wx.Bitmap(self.MaxImageSize, self.MaxImageSize)
        else:
            bmp = wx.EmptyBitmap(self.MaxImageSize, self.MaxImageSize)
        self.Image = wx.StaticBitmap(self, -1, bmp)

        self.DisplayNext()

        # Using a Sizer to handle the layout: I never  use absolute positioning.
        box = wx.BoxSizer(wx.VERTICAL)
        box.Add(b, 0, wx.CENTER | wx.ALL, 10)

        # Adding stretchable space before and after centers the image.
        box.Add((1, 1), 1)
        box.Add(self.Image, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL | wx.ADJUST_MINSIZE, 10)
        box.Add((1, 1), 1)

        self.SetSizerAndFit(box)

        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)

def software_stack():
    """
    Import all the hard dependencies.
    Returns a dict with the version.
    """
    # Mandatory
    import numpy, scipy

    d = dict(
        numpy=numpy.version.version,
        scipy=scipy.version.version,
    )

    # Optional but strongly suggested.
    try:
        import netCDF4, matplotlib
        d.update(dict(
            netCDF4=netCDF4.getlibversion(),
            matplotlib="Version: %s, backend: %s" % (matplotlib.__version__, matplotlib.get_backend()),
            ))
    except ImportError:
        pass

    # Optional (GUIs).
    try:
        import wx
        d["wx"] = wx.version()
    except ImportError:
        pass

    return d

def CheckForWx():
    """Try to import wx module and check its version"""
    if 'wx' in sys.modules.keys():
        return

    minVersion = [2, 8, 10, 1]
    try:
        try:
            import wxversion
        except ImportError as e:
            raise ImportError(e)
        # wxversion.select(str(minVersion[0]) + '.' + str(minVersion[1]))
        wxversion.ensureMinimal(str(minVersion[0]) + '.' + str(minVersion[1]))
        import wx
        version = wx.version().split(' ')[0]

        if map(int, version.split('.')) < minVersion:
            raise ValueError('Your wxPython version is %s.%s.%s.%s' % tuple(version.split('.')))

    except ImportError as e:
        print >> sys.stderr, 'ERROR: wxGUI requires wxPython. %s' % str(e)
        sys.exit(1)
    except (ValueError, wxversion.VersionError) as e:
        print >> sys.stderr, 'ERROR: wxGUI requires wxPython >= %d.%d.%d.%d. ' % tuple(minVersion) + \
            '%s.' % (str(e))
        sys.exit(1)
    except locale.Error as e:
        print >> sys.stderr, "Unable to set locale:", e
        os.environ['LC_ALL'] = ''

 def __init__(self, parent, exception=''):
     wx.Dialog.__init__(self, parent, -1, 'Application Error', style=wx.DEFAULT_DIALOG_STYLE|wx.STAY_ON_TOP)
     
     # get system information
     self.exception = ''
     self.exception += exception
     self.exception += '\n-------------------------'
     self.exception += '\nmMass: %s' % (config.version)
     self.exception += '\nPython: %s' % str(platform.python_version_tuple())
     self.exception += '\nwxPython: %s' % str(wx.version())
     self.exception += '\nNumPy: %s' % str(numpy.version.version)
     self.exception += '\n-------------------------'
     self.exception += '\nArchitecture: %s' % str(platform.architecture())
     self.exception += '\nMachine: %s' % str(platform.machine())
     self.exception += '\nPlatform: %s' % str(platform.platform())
     self.exception += '\nProcessor: %s' % str(platform.processor())
     self.exception += '\nSystem: %s' % str(platform.system())
     self.exception += '\nMac: %s' % str(platform.mac_ver())
     self.exception += '\nMSW: %s' % str(platform.win32_ver())
     self.exception += '\nLinux: %s' % str(platform.dist())
     self.exception += '\n-------------------------\n'
     self.exception += 'Add your comments:\n'
     
     # make GUI
     sizer = self.makeGUI()
     
     # fit layout
     self.Layout()
     sizer.Fit(self)
     self.SetSizer(sizer)
     self.SetMinSize(self.GetSize())
     self.Centre()

    def __init__(self, WindowUtils, OS_PLATFORM, WIDTH=1400, HEIGHT=800):

        wx.Frame.__init__(self, parent=None, id=wx.ID_ANY,
                          title="wxPython example", size=(WIDTH, HEIGHT))
        self.browser = None
        self.WindowUtils = WindowUtils
        self.OS_PLATFORM = OS_PLATFORM

        if OS_PLATFORM == "LINUX":
            self.WindowUtils.InstallX11ErrorHandlers()

        global g_count_windows
        g_count_windows += 1

        self.setup_icon()
        self.create_menu()
        self.Bind(wx.EVT_CLOSE, self.OnClose)

        self.browser_panel = wx.Panel(self, style=wx.WANTS_CHARS)
        self.browser_panel.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
        self.browser_panel.Bind(wx.EVT_SIZE, self.OnSize)

        if OS_PLATFORM == "LINUX":
            self.Show()
            if wx.version.startswith("3.") or wx.version().startswith("4."):
                wx.CallLater(20, self.embed_browser)
            else:
                self.embed_browser()
        else:
            self.embed_browser()
            self.Show()

    def GetEnvironmentInfo(self):
        """Get the enviromental info / Header of error report
        @return: string

        """
        system_language = wx.Locale.GetLanguageName(wx.Locale.GetSystemLanguage())
        running_language = wx.Locale.GetLanguageName(wx.GetLocale().GetLanguage())
        res = wx.Display().GetGeometry()
        info = list()
        info.append(self.GetProgramName())
        info.append(u"Operating System: %s" % wx.GetOsDescription())
        if sys.platform == 'darwin':
            info.append(u"Mac OSX: %s" % platform.mac_ver()[0])
        info.append(u"System Lanauge: %s" % system_language)
        info.append(u"Running Lanauge: %s" % running_language)
        info.append(u"Screen Resolution: %ix%i" % (res[2], res[3]))
        info.append(u"Python Version: %s" % sys.version)
        info.append(u"wxPython Version: %s" % wx.version())
        info.append(u"wxPython Info: (%s)" % ", ".join(wx.PlatformInfo))
        info.append(u"Python Encoding: Default=%s  File=%s" % \
                    (sys.getdefaultencoding(), sys.getfilesystemencoding()))
        info.append(u"wxPython Encoding: %s" % wx.GetDefaultPyEncoding())
        info.append(u"System Architecture: %s %s" % (platform.architecture()[0], \
                                                    platform.machine()))
        info.append(u"Frozen: %s" % str(getattr(sys, 'frozen', 'False')))
        info.append(u"")
        info.append(u"")

        return info#os.linesep.join(info)

 def layout_all(self,dc=None):
     #settingbackgroundcolors
     #background = wx.NamedColour(self.background_color)
     #if self.GetBackgroundColour() != background:
     #   self.SetBackgroundColour(background) 
        #self.Clear()
     #   print 'refreshing'  
     if not dc:
         dc = wx.ClientDC(self)
     if wx.version().startswith('3'):
         self.client_size = self.GetClientSizeTuple()#seb An array doesn't make sense as a truth value: array(self.GetClientSizeTuple())
     else:
         self.client_size = self.GetClientSize()
     # set the device context for all titles so they can
     # calculate their size
     for text_obj in self.all_titles:
         text_obj.set_dc(dc)
         
     graph_area = box_object((0,0),self.client_size)
     graph_area.inflate(.95) # shrink box slightly
     
     # shrink graph area to make room for titles
     graph_area = self.layout_border_text(graph_area)        
     # layout axis and graph data
     graph_area = self.layout_graph(graph_area,dc)
     # center titles around graph area.
     self.finalize_border_text(graph_area,dc)   
     self.graph_box = graph_area
     # clear the dc for all titles
     # ? neccessary ?
     for text_obj in self.all_titles:
         text_obj.clear_dc()
     self.layout_data()

 def format_popup(self,pos):
     menu = wx.Menu()
     menu.Append(505, 'previous zoom', 'previous zoom')
     menu.Enable(505, len(self.zoom_hist) and self.zoom_hist_i>0)
     menu.Append(500, 'Auto Zoom', 'Auto Zoom')
     menu.Append(506, 'next zoom', 'next zoom')
     menu.Enable(506, len(self.zoom_hist) and self.zoom_hist_i<len(self.zoom_hist)-1)
     menu.Append(507, 'clear zoom history', 'clear zoom history')
     menu.Append(501, 'X-Y equal aspect ratio', 'X-Y equal - set aspect ratio to 1')
     menu.Append(502, 'X-Y any aspect ratio', 'X-Y equal - set aspect ratio to "normal"')
     menu.Append(503, 'make X-Y axes a tight fit', 'fit X-Y axes to a fraction of the grid spacing"')
     menu.Append(504, 'freeze X-Y axes bounds', 'freeze X-Y axes grid"')
     self.Bind(wx.EVT_MENU, self.on_prev_zoom, id=505)
     self.Bind(wx.EVT_MENU, self.on_next_zoom, id=506)
     self.Bind(wx.EVT_MENU, self.on_zoom_forget, id=507)
     self.Bind(wx.EVT_MENU, self.on_auto_zoom, id=500)
     self.Bind(wx.EVT_MENU, self.on_equal_aspect_ratio, id=501)
     self.Bind(wx.EVT_MENU, self.on_any_aspect_ratio, id=502)
     self.Bind(wx.EVT_MENU, self.on_axis_tight, id=503)
     self.Bind(wx.EVT_MENU, self.on_axis_freeze, id=504)
     #20090603 (called by default) menu.UpdateUI()
     if wx.version().startswith('3'):
         self.PopupMenuXY(menu) #20090603 (default mouse cursor pos) ,pos[0],pos[1])
     else:
         self.PopupMenu(menu)

def create_versions_message():
    return "\n".join([
        "Timeline version: %s" % get_full_version(),
        "System version: %s" % ", ".join(platform.uname()),
        "Python version: %s" % python_version.replace("\n", ""),
        "wxPython version: %s" % wx.version(),
    ])

def wxVerCheck(self,VerbosityLevel=0):
    """VerbosityLevel (0=OFF) (!0=ON)"""
    try:
        import wx
        minVer = [2,8,9]
        ver = wx.version()
        p = re.compile(r'[.]+')
        m = p.split( ver )
        n = [int(m[0]),int(m[1]),int(m[2])]
        if n < minVer:
            generate_except
    except:
        # use TK for questions        
        response = askquestion('Error', 'wxPython upgrade required. \nDo you want to install now?')
        if response == "yes":
            folder = _os.path.abspath("..\..\..\utilities\python")
            cmd = "%s\checkAndinstall.py --wxPython --path=%s" %(folder,folder)
            stat = _os.system(cmd)
            response = showwarning('Restart', "You must now restart script")
        else:
            print" wxPython must be installed/upgraded in order to use run this script"
            print" See www.wxPython.org"
        print
        return _FAIL
            
    return _SUCCESS

def main():
    load_plugins()
    global app
    print "(2) wxPython version %s" % wx.version()
    #create the mandatory wx application object
    if config.isMac():
        import tc_mac
        app = tc_mac.App(redirect=False)
    else:
        app = wx.App(redirect=False)
    
    #test for availability of our listening port
    interface = config.get("client", "listen_interface")
    port = config.getint("client", "listen_port")
    print "(1) opening TorChat listener on %s:%s" % (interface, port)
    listen_socket = tc_client.tryBindPort(interface, port)
    if not listen_socket:
        print "(1) opening TorChat listener on %s, any port" % interface
        listen_socket = tc_client.tryBindPort(interface, 0)
    if not listen_socket:
        print "(1) %s:%s is already in use" % (interface, port)
        wx.MessageBox(tc_gui.lang.D_WARN_USED_PORT_MESSAGE % (interface, port),
                      tc_gui.lang.D_WARN_USED_PORT_TITLE)
        return
    else:
        print "(1) TorChat is listening on %s:%s" % (interface, port)
    
    #now continue with normal program startup 
    print "(1) start initializing main window"
    app.mw = tc_gui.MainWindow(listen_socket)
    app.SetTopWindow(app.mw)
    print "(1) main window initialized"
    print "(1) entering main loop"
    app.MainLoop()

    def after_show(self):
        from . import signal
        from .. import cli
        sys.excepthook = excepthook

        # Process options
        cli.BumpsOpts.FLAGS |= set(('inspect','syspath'))
        opts = cli.getopts()

        # For wx debugging, load the wxPython Widget Inspection Tool if requested.
        # It will cause a separate interactive debugger window to be displayed.
        if opts.inspect: inspect()

        if opts.syspath:
            print("*** Resource directory:  "+resource_dir())
            print("*** Python path is:")
            for i, p in enumerate(sys.path):
                print("%5d  %s" %(i, p))

        # Put up the initial model
        model,output = initial_model(opts)
        if not model: model = plugin.new_model()
        signal.log_message(message=output)
        #self.frame.panel.show_view('log')
        self.frame.panel.set_model(model=model)

        # When setting initial aui panel split:
        #     mac layout fails if frame is already shown
        #     windows/unix layout fails if frame is not shown
        isMac = "cocoa" in wx.version()
        if not isMac: self.frame.Show()
        self.frame.panel.Layout()
        self.frame.panel.aui.Split(0, wx.TOP)
        if isMac: self.frame.Show()

 def clone_key_event(self, event):
     if wx.version().split('.')[:2] > ['2', '8']:
         evt = MyKeyEvent()
         evt.altDown = event.altDown
         evt.controlDown = event.controlDown
         evt.KeyCode = event.KeyCode
         evt.metaDown = event.metaDown
         if wx.Platform == '__WXMSW__':
             evt.RawKeyCode = event.RawKeyCode
             evt.RawKeyFlags = event.RawKeyFlags
         #evt.m_scanCode = event.m_scanCode
         evt.shiftDown = event.shiftDown
         evt.X = event.X
         evt.Y = event.Y
     else:
         evt = wx.KeyEvent()
         evt.m_altDown = event.m_altDown
         evt.m_controlDown = event.m_controlDown
         evt.m_keyCode = event.m_keyCode
         evt.m_metaDown = event.m_metaDown
         if wx.Platform == '__WXMSW__':
             evt.m_rawCode = event.m_rawCode
             evt.m_rawFlags = event.m_rawFlags
         #evt.m_scanCode = event.m_scanCode
         evt.m_shiftDown = event.m_shiftDown
         evt.m_x = event.m_x
         evt.m_y = event.m_y
         evt.SetEventType(event.GetEventType())
         evt.SetId(event.GetId())
     return evt