def main(width, height, path, timeout, hosts):
    """
    @summary: main algorithm
    @param height: {integer} height of screenshot
    @param width: {integer} width of screenshot
    @param timeout: {float} in sec
    @param hosts: {list(str(ip[:port]))}
    @return: {list(tuple(ip, port, Failure instance)} list of connection state
    """
    #create application
    app = QtGui.QApplication(sys.argv)
    
    #add qt4 reactor
    import qt4reactor
    qt4reactor.install()
    
    from twisted.internet import reactor
        
    for host in hosts:      
        if ':' in host:
            ip, port = host.split(':')
        else:
            ip, port = host, "3389"
            
        reactor.connectTCP(ip, int(port), RDPScreenShotFactory(reactor, app, width, height, path + "%s.jpg"%ip, timeout))
        
    reactor.runReturn()
    app.exec_()
    return RDPScreenShotFactory.__STATE__

def main():
	print ('Receptor de Senales de Alarma Version 1.65')
	Lic = LicCheck()
	if Lic == True:
		if Modo != None:
			t = threading.Thread(target=AvisodeApertura,args=[Lic])
			t.setDaemon(False)
			t.start()

			#AvisodeApertura(Lic)
			app = QApplication(sys.argv)
			import qt4reactor
			qt4reactor.install()
			from twisted.internet import reactor
			#app.setStyle(QStyleFactory.create("plastique"))
			w = MainWindow(reactor)
			#Retornamos en BD 'No hay BD' en caso de que no se consiga la BD
			#Si el receptor esta en MODO de BD. Para que no muestre nunca la 
			#Ventana.

			bd = w.IniciarReceptores()
			w.show()
			a = Remote(w)
			a.Iniciar()
			if bd == 'No hay BD':
				pass
			else:

				reactor.run()
				#sys.exit(app.exec_())

	else:
		AvisodeApertura(Lic)
		pass

    def __init__(self, args):
        from deluge import configmanager

        self.ui_config = configmanager.ConfigManager("qtui.conf", self.default_ui_config)

#        if self.ui_config["style"] and '-style' not in args:
#            QtGui.QApplication.setStyle(self.ui_config["style"])
        app = QtGui.QApplication(args, applicationName="Deluge", quitOnLastWindowClosed=False)

        import qt4reactor
        qt4reactor.install()
        from twisted.internet import reactor

        self.locale_dir = pkg_resources.resource_filename("deluge", "i18n")

        from ui_tools import IconLoader
        app.setWindowIcon(IconLoader.themeIcon("deluge"))
        self.ui_config.register_set_function("language", self.on_language_change, apply_now=True)

        from .tracker_icons import TrackerIcons
        from deluge.ui.sessionproxy import SessionProxy
        from .connection_manager import ConnectionManager
        from .main_window import MainWindow
        from .plugin_manager import PluginManager

        TrackerIcons()
        SessionProxy()
        PluginManager()
        connection_manager = ConnectionManager()
        main_window = MainWindow()
        main_window.show()

        app.aboutToQuit.connect(self.on_quit)
        reactor.callLater(0, connection_manager.first_time)
        reactor.run() # calls app.exec_()

def install_qtreactor():
    global qtapp

    from PyQt4.QtGui import QApplication
    qtapp = QApplication(sys.argv)
    import qt4reactor
    qt4reactor.install()

def main():
    app = QtGui.QApplication(sys.argv)
    qt4reactor.install() # requires QApplication to exist
    ex = MainWindow() # requires qt4reactor to be installed
    # late import because installReactor is being used
    from twisted.internet import reactor
    reactor.run()

def mytest(ip, port, username, password):
    domain = ""
    width = 1024
    height = 800
    fullscreen = False
    optimized = False
    recodedPath = None
    keyboardLayout = 'en'
    app = QtGui.QApplication(sys.argv)

    #add qt4 reactor
    import qt4reactor
    qt4reactor.install()

    if fullscreen:
        width = QtGui.QDesktopWidget().screenGeometry().width()
        height = QtGui.QDesktopWidget().screenGeometry().height()

    log.info("keyboard layout set to %s"%keyboardLayout)

    from twisted.internet import reactor
    ret = {"connected": False}
    mytimer = TimerThread(app, reactor, ret)
    mytimer.start()

    reactor.connectTCP(ip, int(port), RDPClientQtFactory(width, height, username, password, domain, fullscreen, keyboardLayout, optimized, "nego", recodedPath, mytimer))
    reactor.runReturn()
    app.exec_()
    return ret["connected"]

def install_qtreactor(verbose):
    global qtapp

    from twisted.python import log
    from PyQt4.QtGui import QApplication
    from PyQt4.QtCore import QAbstractEventDispatcher

    class QApp(QApplication):

        blockedAt = 0

        def __init__(self, *args):
            super(QApp, self).__init__(*args)
            if verbose:
                disp = QAbstractEventDispatcher.instance()
                disp.aboutToBlock.connect(self.aboutToBlock)
                disp.awake.connect(self.awake)

        def aboutToBlock(self):
            self.blockedAt = time.time()
            log.msg("aboutToBlock", system="QAbstractEventDispatcher")

        def awake(self):
            diff = time.time() - self.blockedAt
            log.msg("awake; block time: %0.4f" % diff, system="QAbstractEventDispatcher")

    qtapp = QApp(sys.argv)
    import qt4reactor
    qt4reactor.install()

def main():
    dut_address = None
    playback_filename = None
    developer_menu = False
    if '-p' in sys.argv:
        f_index = sys.argv.index('-p')
        playback_filename = sys.argv[f_index + 1]
        del sys.argv[f_index:f_index + 2]
    if '-v' in sys.argv:
        sys.argv.remove('-v')
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig()
    if '-d' in sys.argv:
        developer_menu = True
        sys.argv.remove('-d')
    if len(sys.argv) > 1:
        dut_address = sys.argv[1]
    app = QtGui.QApplication(sys.argv)
    qt4reactor.install() # requires QApplication to exist
    # requires qt4reactor to be installed
    ex = MainWindow(dut_address, playback_filename, developer_menu)
    # late import because installReactor is being used
    from twisted.internet import reactor
    reactor.run()

    def start(self):
        import qt4reactor
        app = get_app_qt4()
        qt4reactor.install()

        from twisted.internet import reactor
        self.reactor = reactor
        reactor.runReturn()

def main():
    app = QCoreApplication.instance()
    if app == None:
        app = KinectPlanes(sys.argv)
        qt4reactor.install()
        from twisted.internet import reactor
        app.set_reactor(reactor)
    sys.exit(app.start())

 def __init__(self, appName):
     QApplication.__init__(self, sys.argv)
     if self._initialized:
         return
     qt4reactor.install()
     OTPApplication._appName = appName
     OTPApplication._nodeName = buildNodeName(self._appName, randomize=True)
     OTPApplication._process = twotp.Process(self._nodeName, self._cookie)
     QTimer.singleShot(0, self._startup)
     OTPApplication._initialized = True

def main():
    if '-v' in sys.argv:
        sys.argv.remove('-v')
        logging.basicConfig(level=logging.DEBUG)
    app = QtGui.QApplication(sys.argv)
    qt4reactor.install() # requires QApplication to exist
    ex = MainWindow() # requires qt4reactor to be installed
    # late import because installReactor is being used
    from twisted.internet import reactor
    reactor.run()

 def runQtGui(self):
     import qt4reactor
     from PyQt4.QtGui import QApplication
     app = QApplication(sys.argv)
     qt4reactor.install()
     from .gui import SimulatorWidget
     win = SimulatorWidget()
     win.setWindowTitle("Simulador Profile: %s" % self.profile.name)
     win.add_di()
     win.show()
     return app.exec_()

def main(args):
    app = Qt.QApplication(args)
    
    import qt4reactor
    qt4reactor.install()
    from twisted.internet import reactor
    import labrad, labrad.util, labrad.types
    
    demo = make()
    reactor.runReturn()
    sys.exit(app.exec_())

def main(args):
    app = Qt.QApplication(args)

    import qt4reactor
    qt4reactor.install()
    from twisted.internet import reactor

    reactor.runReturn()
    demo = make()
    v = app.exec_()
    reactor.threadpool.stop()
    sys.exit(v)

def install_reactor():
    # https://github.com/ghtdak/qtreactor/issues/21
    # from qtreactor import pyside4reactor as reactor
    # from qtreactor import qt4reactor as reactor
    import sys
    if 'qt4reactor' in sys.modules:
        print "qt4reactor already in sys.modules!!"
    if 'twisted.internet.reactor' not in sys.modules:
        import qt4reactor
        qt4reactor.install()
        print "Installed qt4reactor"
    else:
        from twisted.internet import reactor
        print "Reactor already installed: %s" % reactor

def capture_host(cli_parsed, vnc_object):
    log._LOG_LEVEL = log.Level.ERROR
    app = QtGui.QApplication(sys.argv)

    # add qt4 reactor
    import qt4reactor
    qt4reactor.install()
    from twisted.internet import reactor
    reactor.connectTCP(
        vnc_object.remote_system, vnc_object.port, RFBScreenShotFactory(
            vnc_object.screenshot_path, reactor, app, vnc_object))

    reactor.runReturn()
    app.exec_()

def run():
    app = QtGui.QApplication(sys.argv)
    app.setApplicationName('l3_client_qt')
    connDialog = ConnectionDialog()
    connDialog.exec_()
    if connDialog.result() == QtGui.QDialog.Accepted:
        factory = Client()
        main = GUI(factory)
        import qt4reactor
        qt4reactor.install()
        from twisted.internet import reactor
        main.show()
        reactor.connectTCP(connDialog.getHost(), connDialog.getPort(), factory)
        reactor.run()

def main():
    """Main function"""
    app = QtGui.QApplication(sys.argv)
    import qt4reactor
    qt4reactor.install()
    from twisted.internet import reactor

    if len(sys.argv) > 1 and sys.argv[1] == "-t":
        interface = terminal.TerminalInterface()
        stdio.StandardIO(interface)
    else:
        interface = gui.GuiInterface()
    server = Server.Server(reactor, interface)
    interface.start(server)
    reactor.runReturn()
    app.exec_()
    reactor.stop()

def main():
    global reactor
    app = Stabilizer()

    # Set up twisted events
    import qt4reactor
    qt4reactor.install()
    from twisted.internet import reactor
    ## print all loaded modules:
    reactor.addSystemEventTrigger('before', 'shutdown', reactor.stop)
    app.start_sending()
    app.start_listening()
    # Create gui
    main_window = MainWindow(app)
    main_window.show()
    # main_window.start_or_stop_listening(True)
    # start event loop
    app.exec_()
    app.settings.save()