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