Python reactor.registerWxApp函数代码示例

 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"))