Beispiel #1
0
 def connectToServer(self, server):
     """
     Launches Urban Terror and connect to the passed server
     
     @param server - the server to connect to 
     """
     Log.log.debug('[GuiController] connectToServer called...')
     
     cm = ConnectionManager()
     cm.connectToServer(server)
Beispiel #2
0
    def __init__(self, debug = False):       
        # Logger
        self.logger = Logger(debug)

        # Setup data handler and config helper
        self.datahandler = MaemoDataHandler(self, self.logger)
        self.config_helper = ConfigHelper(self.datahandler, self.logger)
        
        # Setup ui
        self.ui = UiController(self, debug, self.logger)
        self.logger.set_ui(self.ui)
        self.settings_widget = SettingsWidget(self.ui, self.config_helper, self.logger)

        # Setup connection
        self.connection = ConnectionManager(self, self.ui, self.logger)
        
        # Create transfer managers and widget
        self.sync_manager = SyncManager(self)
        self.transfer_manager = TransferManager(self)
        self.transfer_widget = TransferWidget(self.transfer_manager)

        # Pass objects around
        self.ui.tree_controller.setup(self.connection)
        self.settings_widget.setup(self.connection, self.sync_manager)
        self.ui.set_settings_widget(self.settings_widget)
        self.ui.set_transfer_widget(self.transfer_widget)
        self.transfer_manager.set_transfer_widget(self.transfer_widget)
    def __init__(self):
        super().__init__()
        self.CONNECTIONS_FILE = "wii.motes"
        self.card_id = 0
        self.wiimote = None
        self.ir_callback_count = 0
        self.old_x_coord = 0
        self.old_y_coord = 0
        self.all_cards = []
        self.default_delete_card_style = None

        self.my_vector_transform = VectorTransform()
        self.classifier = GestureClassifier()
        self.connections = ConnectionManager()
        self.classifier.register_callback(self.handle_shake_gesture)

        self.init_ui()
        self.load_available_charts()
        self.display_known_wiimotes()
Beispiel #4
0
    def __init__(self, server_ips, mac=None, f=None):
        if f:
            self.f = f

        self.server_ips = server_ips
        raw_ips = lambda ip: bytes(map(int, ip.split(".")))
        self.server_ips_raw = tuple(map(raw_ips, server_ips))

        self.qi = Queue()
        self.qo = Queue()
        ConnectionManager(self.qi, self.qo, server_ips).start()

        self.ndisapi = windll.ndisapi
        self.kernel32 = windll.kernel32

        self.hnd = self.ndisapi.OpenFilterDriver(DRIVER_NAME_A)
        tmp = TCP_AdapterList()
        self.ndisapi.GetTcpipBoundAdaptersInfo(self.hnd, byref(tmp))

        self.mode = ADAPTER_MODE()
        self.mode.dwFlags = MSTCP_FLAG_SENT_TUNNEL | MSTCP_FLAG_RECV_TUNNEL

        adapter_id = None
        if mac != None:
            for i in range(tmp.m_nAdapterCount):
                if mac == pmac(tmp.m_czCurrentAddress[i]):
                    adapter_id = i + 1
                    break
            else:
                print("Can't find mac = {} in adapters list\n".format(mac))
        if adapter_id == None:
            print("Use 'ipconfig /all' to determine your mac address")
            print("you can write it in 'mac.txt' for more silent run\n")
            for i in range(tmp.m_nAdapterCount):
                print("{}). {}".format(i + 1, pmac(tmp.m_czCurrentAddress[i])))
            adapter_id = int(input("#: "))
            mac = pmac(tmp.m_czCurrentAddress[adapter_id - 1])

        print("\nUsing:\n\tadapter id = {}\n\tmac = {}".format(
            adapter_id, mac))
        self.mode.hAdapterHandle = tmp.m_nAdapterHandle[adapter_id - 1]

        self.hEvent = self.kernel32.CreateEventW(None, True, False, None)
        self.ndisapi.SetPacketEvent(self.hnd, self.mode.hAdapterHandle,
                                    self.hEvent)

        self.request = ETH_REQUEST()
        self.packetbuffer = INTERMEDIATE_BUFFER()
        self.request.EthPacket.Buffer = pointer(self.packetbuffer)
        self.request.hAdapterHandle = self.mode.hAdapterHandle

        self.ndisapi.SetAdapterMode(self.hnd, byref(self.mode))
        register(self.release)
	def messagehandler(self,message):
    		connection_manager = ConnectionManager(self.associated_devices) 
		print('Request received from eventbus')
		print(message)
		thread = None
		if message != None:
			body = message['body']
			action = body['action']
			payload = body['payload']
			if action == "CONNECT":
    				deviceName = payload['deviceName']
				connection_manager.connect_device(deviceName)
			elif action == "INQUIRY":
				print action
				self.devices = []
				thread = inquiryThread(eb, self.devices, body['id'], associated_devices)
			elif action == "READ" or action == "WRITE":
				deviceURI = body['device']
				if connection_manager.contains_name(deviceURI):
    					thread = PersistentConnectionThread(eb, connection_manager.get_btsocket_for_name(deviceURI), body)
				else:
					print action
					for device in self.associated_devices:
						if device['name'] == deviceURI:
							deviceMAC = device['address']
							thread = communicationThread(eb, deviceMAC, body)
			elif action == "disconnect":
				deviceURI = body['device']
				del devices[deviceURI]	
		else:
			print("no msg found")
		thread.start()
Beispiel #6
0
 def init_gui(self):
     client = self.client
     connection_manager = ConnectionManager(client.manager)
     widgets = {}
     connected_servers = yield connection_manager.get_connected_servers()
     servers = yield self.client.manager.servers()
     def on_disconnect(server_name):
         widget = widgets.pop(server_name)
         self.removeTab(
             self.indexOf(widget)
         )
         widget.deleteLater()
     @inlineCallbacks
     def on_connect(server_name):
         yield client.refresh()
         widget_class = WIDGETS[server_name]
         server = client.servers[server_name]
         widget = widget_class(server)
         widgets[server_name] = widget
         self.addTab(widget,server_name)
     for server_name,server_widget in WIDGETS.items():
         connection_manager.on_server_connect(
             server_name,
             partial(on_connect,server_name)
         )
         connection_manager.on_server_disconnect(
             server_name,
             partial(on_disconnect,server_name)
         )
         if server_name in connected_servers:
             widget = server_widget(
                 client.servers[server_name]
             )
             widgets[server_name] = widget
             self.addTab(widget,server_name)
Beispiel #7
0
class GtkUI(object):
    def __init__(self, args):
        self.daemon_bps = (0, 0, 0)
        # Setup signals
        try:
            import gnome.ui
            import gnome

            #Suppress: Warning: Attempt to add property GnomeProgram::*** after class was initialised
            original_filters = warnings.filters[:]
            warnings.simplefilter("ignore")
            try:
                self.gnome_prog = gnome.init("Deluge",
                                             deluge.common.get_version())
            finally:
                warnings.filters = original_filters

            self.gnome_client = gnome.ui.master_client()

            def on_die(*args):
                reactor.stop()

            self.gnome_client.connect("die", on_die)
            log.debug("GNOME session 'die' handler registered!")
        except Exception, e:
            log.warning(
                "Unable to register a 'die' handler with the GNOME session manager: %s",
                e)

        if deluge.common.windows_check():
            from win32api import SetConsoleCtrlHandler
            from win32con import CTRL_CLOSE_EVENT
            from win32con import CTRL_SHUTDOWN_EVENT

            def win_handler(ctrl_type):
                log.debug("ctrl_type: %s", ctrl_type)
                if ctrl_type in (CTRL_CLOSE_EVENT, CTRL_SHUTDOWN_EVENT):
                    reactor.stop()
                    return 1

            SetConsoleCtrlHandler(win_handler)

        if deluge.common.osx_check() and Gdk.WINDOWING == "quartz":
            import gtkosx_application
            self.osxapp = gtkosx_application.gtkosx_application_get()

            def on_die(*args):
                reactor.stop()

            self.osxapp.connect("NSApplicationWillTerminate", on_die)

        # Set process name again to fix gtk issue
        setproctitle(getproctitle())

        # Attempt to register a magnet URI handler with gconf, but do not overwrite
        # if already set by another program.
        common.associate_magnet_links(False)

        # Make sure gtkui.conf has at least the defaults set
        self.config = deluge.configmanager.ConfigManager(
            "gtkui.conf", DEFAULT_PREFS)

        # We need to check on exit if it was started in classic mode to ensure we
        # shutdown the daemon.
        self.started_in_classic = self.config["classic_mode"]

        # Start the IPC Interface before anything else.. Just in case we are
        # already running.
        self.queuedtorrents = QueuedTorrents()
        self.ipcinterface = IPCInterface(args)

        # Initialize gdk threading
        Gdk.threads_init()
        GObject.threads_init()

        # We make sure that the UI components start once we get a core URI
        client.set_disconnect_callback(self.__on_disconnect)

        self.trackericons = TrackerIcons()
        self.sessionproxy = SessionProxy()
        # Initialize various components of the gtkui
        self.mainwindow = MainWindow()
        self.menubar = MenuBar()
        self.toolbar = ToolBar()
        self.torrentview = TorrentView()
        self.torrentdetails = TorrentDetails()
        self.sidebar = SideBar()
        self.filtertreeview = FilterTreeView()
        self.preferences = Preferences()
        self.systemtray = SystemTray()
        self.statusbar = StatusBar()
        self.addtorrentdialog = AddTorrentDialog()

        if deluge.common.osx_check() and Gdk.WINDOWING == "quartz":

            def nsapp_open_file(osxapp, filename):
                # Will be raised at app launch (python opening main script)
                if filename.endswith('Deluge-bin'):
                    return True
                from deluge.ui.gtkui.ipcinterface import process_args
                process_args([filename])

            self.osxapp.connect("NSApplicationOpenFile", nsapp_open_file)
            from menubar_osx import menubar_osx
            menubar_osx(self, self.osxapp)
            self.osxapp.ready()

        # Initalize the plugins
        self.plugins = PluginManager()

        # Show the connection manager
        self.connectionmanager = ConnectionManager()

        from twisted.internet.task import LoopingCall
        rpc_stats = LoopingCall(self.print_rpc_stats)
        rpc_stats.start(10)

        reactor.callWhenRunning(self._on_reactor_start)
        # Start the gtk main loop
        Gdk.threads_enter()
        reactor.run()
        self.shutdown()
        Gdk.threads_leave()
Beispiel #8
0
 def __init__(self, outbound_channel, associated_resources):
     self.resources = []
     self.associated_resources = associated_resources
     self.connection_manager = ConnectionManager(self.associated_resources)
     self.eventbus = None
     self.outbound_channel = outbound_channel
Beispiel #9
0
class EventBusClient(object):
    def __init__(self, outbound_channel, associated_resources):
        self.resources = []
        self.associated_resources = associated_resources
        self.connection_manager = ConnectionManager(self.associated_resources)
        self.eventbus = None
        self.outbound_channel = outbound_channel

    def __get_resource(self, resource_id):
        for resource in self.associated_resources:
            if resource['id'] == resource_id:
                return resource
        return None

    def __get_resource_address(self, resource_id):
        resource = self.__get_resource(resource_id)
        return resource['address'] if resource != None else None

    #Handler for errors and msg
    def messagehandler(self, message):
        print 'Request received from eventbus'
        print message
        thread = None
        if message != None:
            body = message['body']
            action = body['action'].upper()
            if action == 'CONNECT':
                thread = ConnectionThread(self.eventbus, self.outbound_channel,
                                          self.connection_manager, body)
            elif action == 'DISCONNECT':
                thread = DisconnectionThread(self.eventbus,
                                             self.outbound_channel,
                                             self.connection_manager, body)
            elif action == 'INQUIRY':
                self.resources = []
                thread = InquiryThread(self.eventbus, self.outbound_channel,
                                       self.resources, body,
                                       self.associated_resources)
            elif action == 'READ' or action == 'WRITE':
                if 'resourceId' in body:
                    resource_id = body['resourceId']
                    if self.connection_manager.contains_address(
                            self.__get_resource_address(resource_id)):
                        btsocket = self.connection_manager.get_btsocket_by_id(
                            resource_id)
                        thread = PersistentCommunicationThread(
                            self.eventbus, self.outbound_channel, btsocket,
                            body)
                    else:
                        address = self.__get_resource_address(resource_id)
                        if address != None:
                            thread = CommunicationThread(
                                self.eventbus, self.outbound_channel, address,
                                body)
                        else:
                            response = {
                                'message': {
                                    'error':
                                    'Could not find resource with ID equal to '
                                    + resource_id
                                },
                                'id': body['id']
                            }
                            self.eventbus.send(self.outbound_channel, response)
                else:
                    response = {
                        'message': {
                            'resources':
                            list(
                                set(self.connection_manager.
                                    get_connected_resources()))
                        },
                        'id': body['id']
                    }
                    self.eventbus.send(self.outbound_channel, response)
            else:
                response = {
                    'message': {
                        'error': 'Invalid action: ' + action
                    },
                    'id': body['id']
                }
                self.eventbus.send(self.outbound_channel, response)
        else:
            print 'no msg found'
        if thread != None:
            thread.start()
Beispiel #10
0
class GtkUI(object):
    def __init__(self, args):
        self.daemon_bps = (0, 0, 0)
        # Setup signals
        try:
            import gnome.ui
            import gnome
            self.gnome_prog = gnome.init("Deluge", deluge.common.get_version())
            self.gnome_client = gnome.ui.master_client()

            def on_die(*args):
                reactor.stop()

            self.gnome_client.connect("die", on_die)
            log.debug("GNOME session 'die' handler registered!")
        except Exception, e:
            log.warning(
                "Unable to register a 'die' handler with the GNOME session manager: %s",
                e)

        if deluge.common.windows_check():
            from win32api import SetConsoleCtrlHandler
            from win32con import CTRL_CLOSE_EVENT
            from win32con import CTRL_SHUTDOWN_EVENT

            def win_handler(ctrl_type):
                log.debug("ctrl_type: %s", ctrl_type)
                if ctrl_type in (CTRL_CLOSE_EVENT, CTRL_SHUTDOWN_EVENT):
                    reactor.stop()
                    return 1

            SetConsoleCtrlHandler(win_handler)

        # Attempt to register a magnet URI handler with gconf, but do not overwrite
        # if already set by another program.
        common.associate_magnet_links(False)

        # Make sure gtkui.conf has at least the defaults set
        self.config = deluge.configmanager.ConfigManager(
            "gtkui.conf", DEFAULT_PREFS)

        # We need to check on exit if it was started in classic mode to ensure we
        # shutdown the daemon.
        self.started_in_classic = self.config["classic_mode"]

        # Start the IPC Interface before anything else.. Just in case we are
        # already running.
        self.queuedtorrents = QueuedTorrents()
        self.ipcinterface = IPCInterface(args)

        # Initialize gdk threading
        gtk.gdk.threads_init()

        # We make sure that the UI components start once we get a core URI
        client.set_disconnect_callback(self.__on_disconnect)

        self.trackericons = TrackerIcons()
        self.sessionproxy = SessionProxy()
        # Initialize various components of the gtkui
        self.mainwindow = MainWindow()
        self.menubar = MenuBar()
        self.toolbar = ToolBar()
        self.torrentview = TorrentView()
        self.torrentdetails = TorrentDetails()
        self.sidebar = SideBar()
        self.filtertreeview = FilterTreeView()
        self.preferences = Preferences()
        self.systemtray = SystemTray()
        self.statusbar = StatusBar()
        self.addtorrentdialog = AddTorrentDialog()

        # Initalize the plugins
        self.plugins = PluginManager()

        # Late import because of setting up translations
        from connectionmanager import ConnectionManager
        # Show the connection manager
        self.connectionmanager = ConnectionManager()

        from twisted.internet.task import LoopingCall
        rpc_stats = LoopingCall(self.print_rpc_stats)
        rpc_stats.start(10)

        reactor.callWhenRunning(self._on_reactor_start)

        # Initialize gdk threading
        gtk.gdk.threads_enter()
        reactor.run()
        self.shutdown()
        gtk.gdk.threads_leave()
class IPlanPy(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()
        self.CONNECTIONS_FILE = "wii.motes"
        self.card_id = 0
        self.wiimote = None
        self.ir_callback_count = 0
        self.old_x_coord = 0
        self.old_y_coord = 0
        self.all_cards = []
        self.default_delete_card_style = None

        self.my_vector_transform = VectorTransform()
        self.classifier = GestureClassifier()
        self.connections = ConnectionManager()
        self.classifier.register_callback(self.handle_shake_gesture)

        self.init_ui()
        self.load_available_charts()
        self.display_known_wiimotes()

    def display_known_wiimotes(self):
        content = self.get_all_known_connections()
        for address in content:
            self.ui.list_available_wiimotes.addItem(address)
        if len(content) > 0:
            self.ui.list_available_wiimotes.setCurrentRow(0)

    def save_connection_address(self, address):
        content = self.get_all_known_connections()
        if address not in content:
            with open(self.CONNECTIONS_FILE, "a") as f:
                f.write("\n" + address)
                f.close()

    def get_all_known_connections(self):
        with open(self.CONNECTIONS_FILE) as f:
            content = f.readlines()
            f.close()
        return [x.strip() for x in content]

    def init_ui(self):
        self.ui = uic.loadUi("iplanpy.ui", self)
        self.setMouseTracking(True)
        self.ui.fr_save_and_load.setVisible(False)
        self.ui.btn_connect_wiimote.clicked.connect(
            self.toggle_wiimote_connection)
        self.ui.btn_scan_wiimotes.clicked.connect(self.scan_for_wiimotes)
        self.ui.btn_toggle_connection_frame.clicked.connect(
            self.toggle_connection_frame)
        self.ui.btn_toggle_save_and_load_frame.clicked.connect(
            self.toggle_save_and_load_frame)
        self.ui.btn_load_chart.clicked.connect(self.load_chart)
        self.ui.btn_save.clicked.connect(self.on_btn_save_chart)
        self.ui.btn_new_chart.clicked.connect(self.on_btn_new_chart)
        self.default_delete_card_style = self.ui.delete_card.styleSheet()
        self.show()

    def on_btn_new_chart(self, event):
        self.remove_all_cards()
        self.connections.connections.clear()
        self.card_id = 0
        self.update()

    def toggle_connection_frame(self, event):
        value = not self.ui.fr_connection.isVisible()
        self.ui.fr_connection.setVisible(value)
        if value is True:
            self.ui.fr_connection.raise_()
            self.ui.fr_save_and_load.setVisible(not value)
        else:
            self.ui.fr_connection.lower()

    def toggle_save_and_load_frame(self, event):
        value = not self.ui.fr_save_and_load.isVisible()
        self.ui.fr_save_and_load.setVisible(value)
        if value is True:
            self.ui.fr_save_and_load.raise_()
            self.ui.fr_connection.setVisible(not value)
        else:
            self.ui.fr_save_and_load.lower()

    def load_chart(self, event):
        file_name = self.ui.list_chart_selection.currentItem()
        if file_name is not None:
            card_infos, conn_info = self.get_card_info_from_file(
                file_name.text())
            if card_infos is not None:
                try:
                    self.card_id = 0
                    self.remove_all_cards()
                    self.connections.connections.clear()
                    self.update()
                    self.create_card_from_file(card_infos)
                    self.create_conn_from_file(conn_info)
                    self.toggle_save_and_load_frame(None)
                except Exception as e:
                    msg = "Could not create chart from file " + file_name.text(
                    ) + "! Sorry!\nInformation: " + str(e)
                    QMessageBox.critical(self, "Error", msg)

    def create_card_from_file(self, card_infos):
        ids = []
        for info in card_infos:
            info = info.split(";")
            ids.append(int(info[0]))
            card = Card(self, int(info[0]), self.string_to_bool(info[5]))
            card.title_field.setText(info[1])
            card.content_field.setText(ast.literal_eval(info[2]))
            card.move_to(int(info[3]), int(info[4]))
            card.set_background_color(card.available_colors[int(info[6])])
            self.all_cards.append(card)
        self.card_id = max(ids) + 1

    def create_conn_from_file(self, conn_info):
        for info in conn_info:
            info = info.split(";")
            id1 = info[0]
            id2 = info[1]
            card1 = None
            card2 = None
            for card in self.all_cards:
                if str(card.id) == id1:
                    card1 = card
                if str(card.id) == id2:
                    card2 = card
            self.connections.connect((card1, card2))
        self.update()

    def string_to_bool(self, str):
        return str == "True"

    def get_card_info_from_file(self, file_name):
        try:
            conn_found = False
            card_info = []
            conn_info = []
            with open(file_name) as file:
                for line in file:
                    if line == "-\n":
                        conn_found = True
                        continue
                    if conn_found is False:
                        card_info.append(line)
                    else:
                        conn_info.append(line)
                return card_info, conn_info
        except Exception as e:
            QMessageBox.warning(
                self, "Warning",
                "Could not load chart!\nAdditional information:\n" + str(e))
            return None

    def remove_all_cards(self):
        for card in self.all_cards:
            card.delete()
        self.all_cards.clear()

    def on_btn_save_chart(self, event):
        file_name = self.ui.le_save_as.text()
        if file_name is not "":
            if os.path.isfile(file_name + ".chart") is True:
                msg = "Overwrite existing file?"
                res = QMessageBox.question(self, "Warning", msg,
                                           QMessageBox.Yes, QMessageBox.No)
                if res == QMessageBox.Yes:
                    self.save_chart(file_name)
                else:
                    return
            else:
                self.save_chart(file_name)
                QMessageBox.information(self, "Success", "Chart saved!")
        else:
            QMessageBox.warning(self, "Warning", "Choose a name first!")

    def save_chart(self, file_name):
        self.ui.le_save_as.setText("")
        try:
            with open(file_name + ".chart", "w") as new_file:
                self.write_card_data(new_file)
        except Exception as e:
            msg = "Could save file " + file_name + "! Sorry!\nInformation: " + str(
                e)
            QMessageBox.critical(self, "Error", msg)
        self.load_available_charts()

    def write_card_data(self, file):
        for card in self.all_cards:
            cid = card.id
            title = card.title_field.text()
            content = repr(card.content_field.toPlainText())
            x_pos = card.pos().x()
            y_pos = card.pos().y()
            card_type = str(card.has_text_field)
            color = card.color_index
            file.write(
                str(cid) + ";" + title + ";" + content + ";" + str(x_pos) +
                ";" + str(y_pos) + ";" + card_type + ";" + str(color) + ";\n")
        file.write("-\n")
        for conn in self.connections.connections:
            c1, c2 = conn
            file.write(str(c1.id) + ";" + str(c2.id) + ";\n")

    def load_available_charts(self):
        self.ui.list_chart_selection.clear()
        for file in os.listdir(os.getcwd()):
            if file.endswith(".chart"):
                self.ui.list_chart_selection.addItem(file)

    def scan_for_wiimotes(self, event):
        self.ui.btn_scan_wiimotes.setText("Scanning...")
        self.ui.list_available_wiimotes.clear()
        results = wiimote.find()
        for mote in results:
            address, name = mote
            self.ui.list_available_wiimotes.addItem(address)
        if len(results) > 0:
            self.ui.list_available_wiimotes.setCurrentRow(0)
        self.ui.btn_scan_wiimotes.setText("Scan")

    def toggle_wiimote_connection(self):
        if self.wiimote is not None:
            self.disconnect_wiimote()
            return
        self.connect_wiimote()

    def connect_wiimote(self):
        self.ui.btn_connect_wiimote.setText("Connecting...")
        current_item = self.ui.list_available_wiimotes.currentItem()
        if current_item is not None:
            address = current_item.text()
            if address is not "":
                try:
                    self.wiimote = wiimote.connect(address)
                except Exception:
                    QMessageBox.critical(
                        self, "Error", "Could not connect to " + address + "!")
                    self.ui.btn_connect_wiimote.setText("Connect")
                    return

                if self.wiimote is None:
                    self.ui.btn_connect_wiimote.setText("Connect")
                else:
                    self.ui.btn_connect_wiimote.setText("Disconnect")
                    self.ui.lbl_wiimote_address.setText("Connected to " +
                                                        address)
                    self.wiimote.buttons.register_callback(
                        self.on_wiimote_button)
                    self.wiimote.ir.register_callback(self.on_wiimote_ir)
                    self.wiimote.accelerometer.register_callback(
                        self.on_wiimote_accelerometer)
                    self.wiimote.rumble()
                    self.ui.fr_connection.setVisible(False)
                    self.save_connection_address(address)

    def disconnect_wiimote(self):
        self.wiimote.disconnect()
        self.wiimote = None
        self.ui.btn_connect_wiimote.setText("Connect")
        self.ui.lbl_wiimote_address.setText("Not connected")

    def on_wiimote_button(self, event):
        if len(event) is not 0:
            button, is_pressed = event[0]
            if is_pressed:
                card = self.get_card_under_mouse()
                if button == "B":
                    mouse_press_event = QtGui.QMouseEvent(
                        QtCore.QEvent.MouseButtonPress,
                        self.mapFromGlobal(
                            QtCore.QPoint(QtGui.QCursor.pos().x(),
                                          QtGui.QCursor.pos().y())),
                        QtCore.Qt.LeftButton, QtCore.Qt.LeftButton,
                        QtCore.Qt.NoModifier)
                    QtCore.QCoreApplication.postEvent(self, mouse_press_event)
                if button == 'Up' and (card is not None):
                    card.next_color()
                if button == "Down" and (card is not None):
                    card.previous_color()
                if (button == "Left" or button == "Right") and (card
                                                                is not None):
                    card.toggle_type()
                    self.update()
                if button == "Minus":
                    self.connections.remove_last_connection()
                    self.update()
                if button == "Plus":
                    self.connections.restore_connection()
                    self.update()
            else:
                if button == "B":
                    mouse_release_event = QtGui.QMouseEvent(
                        QtCore.QEvent.MouseButtonRelease,
                        self.mapFromGlobal(QtGui.QCursor.pos()),
                        QtCore.Qt.LeftButton, QtCore.Qt.LeftButton,
                        QtCore.Qt.NoModifier)
                    QtCore.QCoreApplication.postEvent(self,
                                                      mouse_release_event)

    def on_wiimote_ir(self, event):
        # Only use every fourth output from ir sensor
        if self.ir_callback_count % 4 == 0:
            if len(event) >= 4:
                x, y = self.my_vector_transform.transform(
                    event,
                    self.size().width(),
                    self.size().height())
                QtGui.QCursor.setPos(self.mapToGlobal(QtCore.QPoint(x, y)))
        self.ir_callback_count = self.ir_callback_count + 1

    def on_wiimote_accelerometer(self, event):
        self.classifier.add_accelerometer_data(event[0], event[1], event[2])

    def keyPressEvent(self, event):
        alt_modifier = (event.modifiers() & QtCore.Qt.AltModifier) != 0
        card = self.get_card_under_mouse()
        if card is not None:
            if alt_modifier and event.key() == QtCore.Qt.Key_Up:
                card.next_color()
            if alt_modifier and event.key() == QtCore.Qt.Key_Down:
                card.previous_color()
            if alt_modifier and (event.key() == QtCore.Qt.Key_Right):
                card.toggle_type()
                self.update()
            if alt_modifier and (event.key() == QtCore.Qt.Key_Left):
                card.toggle_type()
                self.update()

        if event.key() == QtCore.Qt.Key_Control:
            self.connections.remove_last_connection()
            self.update()
        if event.key() == QtCore.Qt.Key_Alt:
            self.connections.restore_connection()
            self.update()

    def mousePressEvent(self, event):
        if self.ui.btn_toggle_connection_frame.underMouse() is True:
            self.toggle_connection_frame(event)
        elif self.ui.btn_toggle_save_and_load_frame.underMouse() is True:
            self.toggle_save_and_load_frame(event)
        elif self.ui.btn_new_chart.underMouse() is True:
            self.on_btn_new_chart(event)

        actual_card = self.get_card_under_mouse()
        if actual_card is not None:
            self.clicked_card_pos = actual_card.pos().x(), actual_card.pos().y(
            )
            self.clicked_card_center = actual_card.center()
        self.__mousePressPos = None
        self.__mouseMovePos = None

        if event.button() == QtCore.Qt.LeftButton:
            for c in self.all_cards:
                c.unfocus()

            self.__mousePressPos = event.globalPos()
            self.__mouseMovePos = event.globalPos()
            if self.ui.lbl_new_card.underMouse():
                self.make_new_card(event)

            card = self.get_card_under_mouse()
            if card is not None:
                card.focus()

    def mouseMoveEvent(self, event):
        if (self.wiimote is not None
                and self.wiimote.buttons["B"]) or (event.buttons()
                                                   & QtCore.Qt.LeftButton):
            focused_card = self.get_focused_card()
            if focused_card is not None:
                self.handle_card_movement(event, focused_card)

        if event.buttons() == QtCore.Qt.LeftButton:
            currPos = self.mapToGlobal(self.pos())
            globalPos = event.globalPos()
            diff = globalPos - self.__mouseMovePos
            newPos = self.mapFromGlobal(currPos + diff)
            self.__mouseMovePos = globalPos

        self.old_y_coord = event.pos().y()
        self.old_x_coord = event.pos().x()

    # Returns the card under the mouse if there is one.
    def get_card_under_mouse(self):
        for c in self.all_cards:
            if c.underMouse() is True:
                return c
        return None

    # Returns the focused card if there is one focused.
    def get_focused_card(self):
        for c in self.all_cards:
            if c.is_focused is True:
                return c
        return None

    # Handles the card movement and collisions with the main window frame.
    def handle_card_movement(self, mouse_event, card):
        new_x = card.pos().x() + mouse_event.pos().x() - self.old_x_coord
        new_y = card.pos().y() + mouse_event.pos().y() - self.old_y_coord
        collides_with_ctrl_frame = card.collides_with(
            self.ui.fr_control_container, new_x, new_y)
        collides_with_main_frame = card.hits_window_frame(self, new_x, new_y)
        if not collides_with_ctrl_frame and not collides_with_main_frame:
            card.move_to(new_x, new_y)
        else:
            QtGui.QCursor.setPos(
                self.mapToGlobal(
                    QtCore.QPoint(self.old_x_coord, self.old_y_coord)))
        self.handle_delete_card_visual(card)
        self.update()

    def handle_delete_card_visual(self, card):
        if self.card_over_delete(card):
            self.ui.delete_card.setStyleSheet(
                "background-color:red; font-size:17px; color:white;")
        else:
            self.ui.delete_card.setStyleSheet(self.default_delete_card_style)

    def mouseReleaseEvent(self, event):
        if self.__mousePressPos is not None:
            moved = event.globalPos() - self.__mousePressPos
            self.check_release_position(event.pos().x(), event.pos().y())
            if moved.manhattanLength() > 3:
                event.ignore()
                return

    # Checks if the release position of the Drag and Drop requires a delete action or new connection.
    def check_release_position(self, posX, posY):
        self.check_for_delete()
        self.check_for_new_connection(posX, posY)

    # Builds a new card of the class Card.
    def make_new_card(self, event):
        card = Card(self, self.card_id)
        new_y = self.ui.fr_control_container.size().height() + 3
        card.move_to(event.pos().x(), new_y)
        self.all_cards.append(card)
        self.card_id = self.card_id + 1

    # Checks if card was released over the delete card button.
    def check_for_delete(self):
        card = self.get_card_under_mouse()
        if card is not None:
            # Cards left half has to be over the delete button in order to delete it.
            if self.card_over_delete(card):
                self.connections.delete_all_card_connections(card, False)
                card.delete()
                self.all_cards.remove(card)
                self.ui.delete_card.setStyleSheet(
                    self.default_delete_card_style)
                self.update()

    # Checks if left half of card is colliding with the delete card
    def card_over_delete(self, card):
        card_x = card.pos().x() + (card.size().width() / 2)
        card_y = card.pos().y()
        card_h = card.size().height()
        card_w = card.size().width() / 2
        del_x = self.ui.delete_card.pos().x()
        del_y = self.ui.delete_card.pos().y()
        del_h = self.ui.delete_card.size().height()
        del_w = self.ui.delete_card.size().width()
        return card_x < del_x + del_w and card_x + card_w > del_x and card_y < del_y + del_h and card_y + card_h > del_y

    # Checks if card was released over another card.
    def check_for_new_connection(self, posX, posY):
        current_card = self.get_card_under_mouse()
        if current_card is not None and len(self.all_cards) > 1:
            for c in self.all_cards:
                # Can collide with itself
                if c is current_card:
                    continue
                # Builds a new connection between the two collided cards.
                if current_card.collides(c):
                    self.connections.connect((current_card, c))
                    x, y = self.clicked_card_pos
                    current_card.move_to(x, y)
                    border = "1px solid black"
                    current_card.set_border(border)
                    c.set_border(border)
                    self.update()

    # Draw connections on every update
    def paintEvent(self, event):
        painter = QtGui.QPainter()
        painter.begin(self)
        pen = QPen()
        pen.setWidth(3)
        pen.setColor(QColor(0, 0, 0))
        painter.setPen(pen)
        for conn in self.connections.connections:
            card1, card2 = conn
            x1, y1 = card1.center()
            x2, y2 = card2.center()
            painter.drawLine(x1, y1, x2, y2)
        painter.end()

    # Callback of gestureclassifier. Gets called when classifier detects "shake" gesture.
    # Deletes all connections from currently focued card.
    def handle_shake_gesture(self):
        for card in self.all_cards:
            if card.is_focused is True:
                self.connections.delete_all_card_connections(card, True)
                self.update()
Beispiel #12
0
class DropN900():

    def __init__(self, debug = False):       
        # Logger
        self.logger = Logger(debug)

        # Setup data handler and config helper
        self.datahandler = MaemoDataHandler(self, self.logger)
        self.config_helper = ConfigHelper(self.datahandler, self.logger)
        
        # Setup ui
        self.ui = UiController(self, debug, self.logger)
        self.logger.set_ui(self.ui)
        self.settings_widget = SettingsWidget(self.ui, self.config_helper, self.logger)

        # Setup connection
        self.connection = ConnectionManager(self, self.ui, self.logger)
        
        # Create transfer managers and widget
        self.sync_manager = SyncManager(self)
        self.transfer_manager = TransferManager(self)
        self.transfer_widget = TransferWidget(self.transfer_manager)

        # Pass objects around
        self.ui.tree_controller.setup(self.connection)
        self.settings_widget.setup(self.connection, self.sync_manager)
        self.ui.set_settings_widget(self.settings_widget)
        self.ui.set_transfer_widget(self.transfer_widget)
        self.transfer_manager.set_transfer_widget(self.transfer_widget)
                
    def start(self):
        # Show ui
        self.ui.show()
        # Some validations
        self.authenticator = None
        self.request_token = None
        self.login_done = False
        self.connected = False
        # Start by checking existing auth
        self.check_for_auth(self.datahandler.configpath("token.ini"))
        # Exec QApplication
        os._exit(singleton_app.exec_())
                
    def check_for_auth(self, filename):
        token_config = SafeConfigParser()
        if isinstance(filename, unicode):
            filename = filename.encode("utf-8")
        token_config.read(filename)
        try:
            access_key = token_config.get("token", "key")
            access_secret = token_config.get("token", "secret")
            if access_key != "" and access_secret != "":
                self.logger.config("Found existing access token")
                self.login_done = True
                self.init_dropbox_client(oauth.OAuthToken(access_key, access_secret))
            else:
                self.logger.error("Parsing access token from file failed")
                self.datahandler.reset_auth()
        except NoSectionError:
            self.logger.config("No stored access token found")
            self.start_trusted_auth()
    
    def start_trusted_auth(self):
        self.login_done = False
        self.ui.switch_context("trustedlogin")
    
    def end_trusted_auth(self, email, password):
        self.login_done = False
        if self.connection.connection_available():
            if self.authenticator:
                del self.authenticator
            self.authenticator = auth.Authenticator(self.get_config())
            try:
                access_token = self.authenticator.obtain_trusted_access_token(email, password)
            except AssertionError:
                self.ui.set_trusted_login_error("Email and/or password invalid")
                return
            except socket.gaierror:
                self.ui.set_trusted_login_info("Requesting a network connection...")
                self.connection.request_connection()
                return
            self.login_done = True
            self.datahandler.store_auth(access_token)
            self.init_dropbox_client(access_token)
        else:
            self.ui.set_trusted_login_info("Requesting a network connection...")
            self.connection.request_connection()
    
    def init_dropbox_client(self, access_token):
        dropbox_config = self.get_config()
        server = dropbox_config["server"]
        content_server = dropbox_config["content_server"]
        if not self.authenticator:
            self.authenticator = auth.Authenticator(dropbox_config)
        dropbox_client = client.DropboxClient(server, content_server, 80, self.authenticator, access_token)
        self.connection.set_client(dropbox_client)
        self.ui.switch_context("manager")
        self.connected = True

    def get_config(self):
        return auth.Authenticator.load_config(self.datahandler.datapath(".config"))
 def __init__(self, associated_devices):
     self.devices = []
     self.associated_devices = associated_devices
     self.connection_manager = ConnectionManager(self.associated_devices)
class Client:
    def __init__(self, associated_devices):
        self.devices = []
        self.associated_devices = associated_devices
        self.connection_manager = ConnectionManager(self.associated_devices)

    #Handler for errors and msg
    def messagehandler(self, message):
        print('Request received from eventbus')
        print(message)
        thread = None
        if message != None:
            body = message['body']
            action = body['action']
            if action == "CONNECT" or action == "WRITE":
                payload = body['payload']
            if action == "CONNECT":
                deviceName = payload['deviceName']
                if self.connection_manager.connect_device(deviceName):
                    response = {'message': 'Connected ' + deviceName}
                else:
                    response = {
                        'message': {
                            'error': 'Could not connect ' + deviceName
                        }
                    }
                response['id'] = body['id']
                eb.send(PY2JA, response)
            elif action == "INQUIRY":
                print action
                self.devices = []
                thread = inquiryThread(eb, self.devices, body['id'],
                                       associated_devices)
            elif action == "READ" or action == "WRITE":
                deviceURI = body['device']
                if self.connection_manager.contains_name(deviceURI):
                    thread = PersistentConnectionThread(
                        eb,
                        self.connection_manager.get_btsocket_for_name(
                            deviceURI), body)
                else:
                    print action
                    for device in self.associated_devices:
                        if device['name'] == deviceURI:
                            deviceMAC = device['address']
                            thread = communicationThread(eb, deviceMAC, body)
            elif action == "DISCONNECT":
                deviceURI = body['device']
                if self.connection_manager.disconnect_device(deviceURI):
                    response = {'message': 'Disconnected ' + deviceURI}
                else:
                    response = {
                        'message': {
                            'error': 'Could not disconnect ' + deviceURI
                        }
                    }
                response['id'] = body['id']
                eb.send(PY2JA, response)
        else:
            print("no msg found")
        if thread != None:
            thread.start()
Beispiel #15
0
    def initServer(self):
        self.update_requests = []
        self.trigger_requests = []
        self.temperature_limit_state = BELOW
        self.emission_current_limit_state = BELOW
        self.thermocouple_state = OK

        reg = self.client.registry
        reg.cd(REGISTRY_PATH)
        self.emission_current_limit = yield reg.get('emission current limit')
        self.temperature_limit = yield reg.get('temperature limit')
        self.thermocouple_failure_limit = yield reg.get('thermocouple failure limit')
        self.ramp_rate = yield reg.get('ramp rate')
        self.cooling_ramp_rate = yield reg.get('cooling ramp rate')
        self.filament_control_increment = yield reg.get('filament control increment')
        self.filament_control_fast_increment = yield reg.get('filament control fast increment')
        self.filament_control_threshold = yield reg.get('filament control threshold')
        self.emission_current_threshold = yield reg.get('emission current threshold')
        self.temperature_buffer = yield reg.get('temperature buffer')
        default_temperature_setpoint = yield reg.get('default temperature')
        self._set_temperature_setpoint(default_temperature_setpoint)
        sampling_duration = yield reg.get('sampling duration')
        cm = ConnectionManager(self.client.manager)
        required_servers = [VM_SERVER,AO_SERVER]
        servers = yield cm.get_connected_servers()
        for server in servers:
            if server in required_servers:
                print server, 'connected'
                required_servers.remove(server)
        @inlineCallbacks
        def finish_init():
            voltmeter = self.client.voltmeter
            yield voltmeter.lock_setting(voltmeter.set_active_channels.ID)
            yield voltmeter.lock_setting(voltmeter.set_sampling_duration.ID)
            yield voltmeter.lock_setting(voltmeter.set_triggering.ID)
            yield voltmeter.set_sampling_duration(sampling_duration)
            yield voltmeter.set_active_channels(VOLTMETER_CHANNELS)
            yield voltmeter.set_triggering(False)
            analog_output = self.client.analog_output
            yield analog_output.select_device(FILAMENT_CONTROL)
            yield analog_output.lock()
            self._set_feedback_state(FEEDBACK_OFF)
            self._set_heating_state(COOLING)
            outputs = yield self.get_outputs()
            self.previous_time = clock()
            temperature = self.previous_temperature = outputs[TEMPERATURE]
            emission_current = outputs[EMISSION_CURRENT]
            self.update_temperature_limit_state(temperature)
            self.update_emission_current_limit_state(emission_current)
            self.update_thermocouple_state(temperature)
            self.loop()
            LockServer.initServer(self)
        def on_server_connected(server):
            print server, 'connected'
            required_servers.remove(server)
            cm.on_server_connect(server,None)
            if not required_servers:
                finish_init()
        if required_servers:
            for server in required_servers:
                print 'waiting for', server
                cm.on_server_connect(server,partial(on_server_connected,server))
        else:
            yield finish_init()