def run(self, gui=None):
     reactor.registerWxApp(gui)  # @UndefinedVariable
     bindPort = self.portOpen()
     p = reactor.listenTCP(bindPort, self.server)  # @UndefinedVariable
     self.tryConnect(DUMMY_PUBLIC_IP, DUMMY_SVPORT)
     reactor.callInThread(self.test, p.getHost().port)  # @UndefinedVariable
     reactor.run()  # @UndefinedVariable

def StartServer(log=None):
    if IMPORT_TWISTED == False :
        log.EcritLog(_(u"Erreur : Problème d'importation de Twisted"))
        return
    
    try :
        factory = protocol.ServerFactory()
        factory.protocol = Echo
        factory.protocol.log = log
        reactor.registerWxApp(wx.GetApp())
        port = int(UTILS_Config.GetParametre("synchro_serveur_port", defaut=PORT_DEFAUT))
        reactor.listenTCP(port, factory)
        
        # IP locale
        #ip_local = socket.gethostbyname(socket.gethostname())
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(('jsonip.com', 80))
        ip_local = s.getsockname()[0]
        s.close()
        log.EcritLog(_(u"IP locale : %s") % ip_local)
        
        # IP internet
        ip_internet = json.loads(urlopen("http://jsonip.com").read())["ip"]
        log.EcritLog(_(u"IP internet : %s") % ip_internet)
        
        # Port
        log.EcritLog(_(u"Serveur prêt sur le port %d") % port)
        
        log.SetImage("on")
        reactor.run()
    except Exception, err :
        print ("Erreur lancement serveur nomade :", err)
        log.EcritLog(_(u"Erreur dans le lancement du serveur Nomadhys :") )
        log.EcritLog(err) 

def main():
    log.startLogging(sys.stdout)

    app = MedicalookApp()
    reactor.registerWxApp(app)

    reactor.run()

    def OnInit(self):
        self.SetAppName("rss_downloader")

        # For debugging
        self.SetAssertMode(wx.PYAPP_ASSERT_DIALOG)

        # initialize config before anything else
        self.Config = ConfigManager()

        reactor.registerWxApp(self)

        self.Bind(EVT_NEW_TORRENT_SEEN, self.OnNewTorrentSeen)
        self.Bind(EVT_TORRENT_DOWNLOADED, self.OnTorrentDownloaded)

        self.growler = growler.Growler()

        self.db_engine = db.Database()
        self.db_engine.connect()
        self.db_engine.init()

        self.db = db.DBSession()

        self.icon = wx.IconFromBitmap(self.load_app_image('16-rss-square.png').ConvertToBitmap())

        self.feed_checker = FeedChecker()
        self.download_queue = DownloadQueue()

        self.download_queue.run()
        self.feed_checker.run()

        self.mainwindow = mainwin.MainWindow()

        self.mainwindow.Bind(wx.EVT_CLOSE, self.Shutdown)

        return True

def main():
    """main entry point into MicroView"""

    # Run the main application
    app = MicroViewApp(False)
    reactor.registerWxApp(app)
    reactor.run()

def runClient():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '-s', '--server'
    )
    parser.add_argument(
        '-t', '--teamname'
    )
    args = parser.parse_args()
    if args.server is None:
        args.server = 'localhost'

    log.msg('Client start')

    npc_factory = NPCServer()
    app = wx.App()
    frame_1 = MyFrame(
        None, -1, "", size=(1000, 1000),
        factory = npc_factory,
        teamname=args.teamname
    )
    app.SetTopWindow(frame_1)
    frame_1.Show()

    reactor.registerWxApp(app)
    reactor.connectTCP(args.server, 22517, npc_factory)
    reactor.run()
    log.msg('end client')

def main(cmd_args=None):
	parser =optparse.OptionParser()
	parser.add_option('-s','--service', action='store_true', dest='serviceOnly', default=False, help='Start dMilo with only the web service.')
	parser.add_option('-n','--new', action='store_true', dest='newdb', default=False, help='Initialize a new Database')
	if cmd_args:
		(options, args) = parser.parse_args()
	else:
		(options, args) = parser.parse_args(cmd_args)
	#: Set the Preferences.
	if not os.path.exists(dotDmiloPath):
		os.makedirs(dotDmiloPath)
	if options.newdb or not os.path.exists( os.path.join(dotDmiloPath, 'dmilo.db')):
		ModelStore(os.path.join(dotDmiloPath, 'dmilo.db')).newStore()
	ModelStore(os.path.join(dotDmiloPath, 'dmilo.db'))
	#: Start the Application
	if options.serviceOnly:
		app = serviceOnlyApp( False )
	else:
		app = xrcApp(False)
	
	#: Add the Application to the Event Loop.
	reactor.registerWxApp(app)

	#: Start the Event Loop.
	reactor.run()

def demo():
    log.startLogging(sys.stdout)

    # register the App instance with Twisted:
    app = MyApp(0)
    reactor.registerWxApp(app)

    # start the event loop:
    reactor.run()

def serve_udp(engine=None, port=9007, logto=sys.stdout):
    """Serve the `M2UDP` protocol using the given `engine` on the
    specified `port` logging messages to given `logto` which is a
    file-like object.  This function will block till the service is
    closed.  There is no need to call `mlab.show()` after or before
    this.  The Mayavi UI will be fully responsive.

    **Parameters**

     :engine: Mayavi engine to use. If this is `None`,
              `mlab.get_engine()` is used to find an appropriate engine.

     :port: int: port to serve on.

     :logto: file : File like object to log messages to.  If this is
                    `None` it disables logging.

    **Examples**

    Here is a very simple example::

        from mayavi import mlab
        from mayavi.tools import server
        mlab.test_plot3d()
        server.serve_udp()

    Test it like so::

        import socket
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.bind(('', 9008))
        s.sendto('camera.azimuth(10)', ('', 9007))

    **Warning**

    Data sent is exec'd so this is a security hole.
    """

    from mayavi import mlab
    e = engine or mlab.get_engine()
    # Setup the protocol with the right attributes.
    proto = M2UDP()
    proto.engine = e
    proto.scene = e.current_scene.scene
    proto.mlab = mlab

    if logto is not None:
        log.startLogging(logto)
    log.msg('Serving Mayavi2 UDP server on port', port)
    log.msg('Using Engine', e)

    # Register the running wxApp.
    reactor.registerWxApp(wx.GetApp())
    # Listen on port 9007 using above protocol.
    reactor.listenUDP(port, proto)
    # Run the server + app.  This will block.
    reactor.run()

def twist(app, rpc):
    """
    This runs the (optional xml-rpc server)

    Ref: http://code.activestate.com/recipes/298985/
    """
    reactor.registerWxApp(app)
    reactor.listenTCP(RPC_PORT, server.Site(rpc))
    reactor.run()

    def OnInit(self):
        ''' Called by wxWindows to initialize our application

        :returns: Always True
        '''
        log.debug("application initialize event called")
        reactor.registerWxApp(self)
        frame = SimulatorFrame(None, -1, "Pymodbus Simulator")
        frame.CenterOnScreen()
        frame.Show(True)
        self.SetTopWindow(frame)
        return True

def main():
    app = GMApp()
    reactor.registerWxApp(app)

    setLogFunction(LogText)

    # reactor.callLater(.1,ShowLoginDialog,app.mainFrame)

    try:
        reactor.run()
    except:
        traceback.print_exc()

def main():
    #register the app
    app = wx.PySimpleApp()
    reactor.registerWxApp(app)

    #create the application and client
    addressBookApp = AddressBookApplication()
    factory = pb.PBClientFactory()
    reactor.connectTCP("localhost", 8789, factory)
    factory.getRootObject().addCallback(addressBookApp.connected)
    
    #start reactor
    reactor.run(True)

def main():
    log.set_log_file("message.log")
    type_descriptor.load_xml("attributes.xml", "typedescriptors.xml")

    app = wx.App(False)

    # NOTE: frame must exist before run
    frame = MainFrame()
    frame.Show()

    reactor.registerWxApp(app)

    reactor.listenUDP(34888, DestAddressProtocol(frame))
    reactor.run()

 def initdisplay(self):
     # try a wx window control pane
     self.displayapp = wx.PySimpleApp()
     # create a window/frame, no parent, -1 is default ID, title, size
     self.displayframe = wx.Frame(None, -1, "HtmlWindow()", size=(1000, 600))
     # call the derived class, -1 is default ID
     self.display=self.HtmlPanel(self.displayframe,-1,self)
     # show the frame
     #self.displayframe.Show(True)
     myWxAppInstance = self.displayapp
     reactor.registerWxApp(myWxAppInstance)
     splash="<html><body><h2>GLab Python Manager</h2></body></html>"
     print self.xstatus()
     print self.xstatus("html")
     self.display.updateHTML(splash+self.xstatus("html"))

def run_main_view_wx(config):
    """ Runs main UI view based on wx framework. """
    # imports
    import wx
    import socket
    # might be some cross platform (windows) issues reported with wxReactor
    from twisted.internet import wxreactor
    # add twisted / wx interaction support
    wxreactor.install()
    # add logging observer
    from twisted.python.log import PythonLoggingObserver
    observer = PythonLoggingObserver()
    observer.start()

    # then can do normal reactor imports
    from twisted.internet import reactor
    # and wx specific implementations
    from ui.view_model_wx import MainViewController
    from ui.view_model_wx import MainViewModel
    from ui.main_view_wx import MainWindow

    # ip address *much* faster than by device name
    ipaddr = socket.gethostbyname(config.server_name)
    logging.debug("RPC:\tServer name %s resolved to IP address %s" % (config.server_name, ipaddr))

    # create rpc client
    from web.webclient import RPCClient, RPCClientFactory
    rpc_client = RPCClient()
    
    # create view model
    view_model = MainViewModel()
    
    # create view controller
    controller = MainViewController(rpc_client, view_model, config)
    
    # create wxApp and main window
    wxApp = wx.App(False)
    frame = MainWindow(None, "fishpi - Proof Of Concept Vehicle control", controller, ipaddr, config.rpc_port, config.camera_port)
    frame.Show()
    
    # run reactor rather than usual 'wxApp.MainLoop()'
    reactor.registerWxApp(wxApp)
    logging.debug("RPC:\tconnecting to %s (%s) on port %s" % (config.server_name, ipaddr, config.rpc_port))
    reactor.connectTCP(ipaddr, config.rpc_port, RPCClientFactory(controller))
    #reactor.callLater(5, update_callback)
    reactor.run()

def run():
    app = wx.App(False)

    app.path = os.path.dirname(sys.argv[0])

    from window.main import Main
    import prefs
    import worlds

    prefs.Initialize()
    worlds.Initialize()

    frame = Main(None, "wxpymoo")
    frame.Show(True)

    reactor.registerWxApp(app)
    reactor.run()


    app.MainLoop()

def run_main_view_wx(server, rpc_port, camera_port):
    """ Runs main UI view based on wx framework. """
    # imports
    import wx
    import socket
    # might be some cross platform (windows) issues reported with wxReactor
    from twisted.internet import wxreactor
    # add twisted / wx interaction support
    wxreactor.install()
    # add logging observer
    from twisted.python.log import PythonLoggingObserver
    observer = PythonLoggingObserver()
    observer.start()
    # add some extra logging (temp - merge later)
    #from sys import stdout
    #from twisted.python.log import startLogging, err
    #startLogging(stdout)

    # then can do normal reactor imports
    from twisted.internet import reactor
    from ui.main_view_wx import MainWindow

    # ip address *much* faster than by device name
    ipaddr = socket.gethostbyname(server)

    # create rpc client
    from web.webclient import RPCClient, RPCClientFactory
    rpc_client = RPCClient()
    
    # create wxApp and main window
    wxApp = wx.App(False)
    frame = MainWindow(None, "fishpi - Proof Of Concept Vehicle control", ipaddr, rpc_port, camera_port)
    frame.Show()
    
    # run reactor rather than usual 'wxApp.MainLoop()'
    reactor.registerWxApp(wxApp)
    logging.debug("RPC:\tconnecting to %s (%s) on port %s" % (server, ipaddr, rpc_port))
    reactor.connectTCP(ipaddr, rpc_port, RPCClientFactory(frame))
    #reactor.callLater(5, update_callback)
    reactor.run()

        uiDebug( "serverManagerUi OnMenu_aboutMenuItem()")
        info = wx.AboutDialogInfo()
        info.Name = "xdIm"
        info.Version = "0.2.0"
        info.Copyright = "(C) 2008-2010 Programmers and Coders Everywhere"
        info.Description = wordwrap(
            "\n\nxdIm program is a software program \n\n",
            350, wx.ClientDC(self))
        info.WebSite = ("http://www.xdIm.org/", "xdIm home page")
        info.Developers = ["xd"]
        wx.AboutBox(info)
#!XRCED:end-block:xrcserverManagerFrame.OnMenu_aboutMenuItem        
        
          
if __name__ == '__main__':
#    app = wx.PySimpleApp()
#    frame = serverManager(None)
#    frame.Show()
#    app.MainLoop()
    
#    app = MyApp(0)
#    app.MainLoop()

    app = wx.App()
    server_twisted.frame = serverManager(None)
    server_twisted.frame.Show()
    reactor.registerWxApp(app)
    reactor.run()


        

#.........这里部分代码省略.........
        menu.AppendItem(item)
        return item

    class MyTaskBarIcon(wx.TaskBarIcon):

        def __init__(self, icons_path, current_icon_name=None):
            super(MyTaskBarIcon, self).__init__()
            self.icons_path = icons_path
            self.icons = {}
            self.popup_icons = {}
            for name, filename in icons_dict().items():
                self.icons[name] = wx.IconFromBitmap(wx.Bitmap(os.path.join(icons_path, filename)))
            for name, filename in popup_icons_dict().items():
                self.popup_icons[name] = wx.Bitmap(os.path.join(icons_path, filename))
            if len(self.icons) == 0:
                self.icons['default'] = ''
            if current_icon_name is not None and current_icon_name in self.icons.keys():
                self.current = current_icon_name
            else:
                self.current = self.icons.keys()[0]
            self.Bind(wx.EVT_TASKBAR_LEFT_DOWN, self.on_left_down)
            self.select_icon(self.current)

        def CreatePopupMenu(self):
            menu = wx.Menu()
            create_menu_item(menu, 'open', self.on_show, self.popup_icons.get('open', None))
            create_menu_item(menu, 'synchronize', self.on_sync, self.popup_icons.get('sync', None))
            create_menu_item(menu, 'reconnect', self.on_reconnect, self.popup_icons.get('reconnect', None))
            create_menu_item(menu, 'restart', self.on_restart, self.popup_icons.get('restart', None))
            create_menu_item(menu, 'exit', self.on_exit, self.popup_icons.get('shutdown', None))
            self.menu = menu
            return menu

        def on_left_down(self, event):
            control('show')

        def on_show(self, event):
            control('show')

        def on_sync(self, event):
            control('sync')

        def on_hide(self, event):
            control('hide')

        def on_restart(self, event):
            control('restart')

        def on_exit(self, event):
            control('exit')

        def on_reconnect(self, event):
            control('reconnect')

        def on_toolbar(self, event):
            control('toolbar')

        def select_icon(self, icon_name):
            # print 'select_icon', icon_name, self.icons
            if icon_name in self.icons.keys():
                self.current = icon_name
                self.SetIcon(self.icons.get(self.current, self.icons.values()[0]), LABEL)

        def clear_icon(self):
            self.RemoveIcon()

    class MyApp(wx.App):

        def __init__(self, icons_path):
            self.icons_path = icons_path
            wx.App.__init__(self, False)

        def OnInit(self):
            self.trayicon = MyTaskBarIcon(self.icons_path)
            print 'OnInit'
            return True

        def OnExit(self):
            print 'OnExit'
            try:
                self.trayicon.Destroy()
            except:
                pass

        def SetIcon(self, name):
            # if self.trayicon.IsAvailable():
            print 'try'
            self.trayicon.select_icon(name)
            print 'ok'

        def Stop(self):
            self.trayicon.clear_icon()
            try:
                self.trayicon.Destroy()
            except:
                pass

    _IconObject = MyApp(icons_path)
    reactor.registerWxApp(_IconObject)
    reactor.addSystemEventTrigger('before', 'shutdown', main_porcess_stopped)