def __init__(self, data, min, max, settings, type): super(SelectPlottedPoints, self).__init__() self.ui = Ui_SelectPlottedPoints() self.ui.setupUi(self) self.type = type self.min = min self.y_axis = data[min:max] self.x_axis = np.arange(min, min + len(self.y_axis)) self.ui.x_coordinate.setRange(self.x_axis[0], self.x_axis[-1]) self.plot = QtCommons.nestWidget(self.ui.plot_widget, QMathPlotWidget()) self.finished.connect(lambda: self.deleteLater()) self.ui.smoothing_factor.valueChanged.connect(self.factor_valueChanged) self.ui.smoothing_degree.valueChanged.connect(lambda v: self.draw()) self.ui.smoothing_factor_auto.toggled.connect(lambda v: self.draw()) self.ui.smoothing_factor_auto.toggled.connect( lambda v: self.ui.smoothing_factor.setEnabled(not v)) self.restoreGeometry( settings.value('select_plotted_points_geometry', QByteArray())) self.finished.connect(lambda: settings.setValue( 'select_plotted_points_geometry', self.saveGeometry())) self.ui.x_coordinate.valueChanged.connect(self.set_point) QTimer.singleShot(100, self.draw)
def set_window_settings(self, hexstate, window_size, prefs_dialog_size, pos, is_maximized, is_fullscreen): """Set window settings Symetric to the 'get_window_settings' accessor""" self.setUpdatesEnabled(False) self.window_size = QSize(window_size[0], window_size[1]) # w, h self.prefs_dialog_size = QSize(prefs_dialog_size[0], prefs_dialog_size[1]) # w, h self.window_position = QPoint(pos[0], pos[1]) # x,y self.setWindowState(Qt.WindowNoState) self.resize(self.window_size) self.move(self.window_position) # Window layout if hexstate: self.restoreState(QByteArray().fromHex( str(hexstate).encode('utf-8'))) # [Workaround for Issue 880] # QDockWidget objects are not painted if restored as floating # windows, so we must dock them before showing the mainwindow. for widget in self.children(): if isinstance(widget, QDockWidget) and widget.isFloating(): self.floating_dockwidgets.append(widget) widget.setFloating(False) # Is fullscreen? if is_fullscreen: self.setWindowState(Qt.WindowFullScreen) # self.__update_fullscreen_action() # Is maximized? if is_fullscreen: self.maximized_flag = is_maximized elif is_maximized: self.setWindowState(Qt.WindowMaximized) self.setUpdatesEnabled(True)
def start_drag(self, mouse_event): """ starts a drag event and sends necessary data via mime types called from mouseMoveEvent() when mouse leaves current track, deletes the current timeable if drop was succesfull """ # hide timeable while dragging self.setVisible(False) # write timeable data item_data = QByteArray() data_stream = QDataStream(item_data, QIODevice.WriteOnly) QDataStream.writeString(data_stream, str.encode(self.view_id)) mimeData = QMimeData() mimeData.setData('ubicut/timeable', item_data) if self.model.is_video or (self.model.is_video is None): mimeData.setText("is_video") else: mimeData.setText("is_audio") # set first frame as pixmap frame = self.model.get_first_frame() pixmap = get_pixmap_from_file(self.model.file_name, frame) # start drag drag = QDrag(self.scene()) drag.setMimeData(mimeData) drag.setPixmap(pixmap.scaled(QSize(100, 100), Qt.KeepAspectRatio)) # delete the timeable if the the item was succesfully dropped if (drag.exec_(Qt.MoveAction) == Qt.MoveAction): self.delete(hist=False) else: self.setVisible(True)
def image_to_data(img, compression_quality=95, fmt='JPEG', png_compression_level=9, jpeg_optimized=True, jpeg_progressive=False): ''' Serialize image to bytestring in the specified format. :param compression_quality: is for JPEG and goes from 0 to 100. 100 being lowest compression, highest image quality :param png_compression_level: is for PNG and goes from 0-9. 9 being highest compression. :param jpeg_optimized: Turns on the 'optimize' option for libjpeg which losslessly reduce file size :param jpeg_progressive: Turns on the 'progressive scan' option for libjpeg which allows JPEG images to be downloaded in streaming fashion ''' fmt = fmt.upper() ba = QByteArray() buf = QBuffer(ba) buf.open(QBuffer.WriteOnly) if fmt == 'GIF': w = QImageWriter(buf, b'PNG') w.setQuality(90) if not w.write(img): raise ValueError('Failed to export image as ' + fmt + ' with error: ' + w.errorString()) return png_data_to_gif_data(ba.data()) is_jpeg = fmt in ('JPG', 'JPEG') w = QImageWriter(buf, fmt.encode('ascii')) if is_jpeg: if img.hasAlphaChannel(): img = blend_image(img) # QImageWriter only gained the following options in Qt 5.5 if jpeg_optimized: w.setOptimizedWrite(True) if jpeg_progressive: w.setProgressiveScanWrite(True) w.setQuality(compression_quality) elif fmt == 'PNG': cl = min(9, max(0, png_compression_level)) w.setQuality(10 * (9-cl)) if not w.write(img): raise ValueError('Failed to export image as ' + fmt + ' with error: ' + w.errorString()) return ba.data()
def on_caDeleteButton_clicked(self): """ Private slot to delete the selected CA certificate. """ itm = self.caCertificatesTree.currentItem() res = E5MessageBox.yesNo( self, self.tr("Delete CA Certificate"), self.tr( """<p>Shall the CA certificate really be deleted?</p>""" """<p>{0}</p>""" """<p>If the CA certificate is deleted, the browser""" """ will not trust any certificate issued by this CA.</p>"""). format(itm.text(0))) if res: cert = self.caCertificatesTree.currentItem().data(0, self.CertRole) # delete the selected entry and its parent entry, # if it was the only one parent = itm.parent() parent.takeChild(parent.indexOfChild(itm)) if parent.childCount() == 0: self.caCertificatesTree.takeTopLevelItem( self.caCertificatesTree.indexOfTopLevelItem(parent)) # delete the certificate from the CA certificate store caCerts = self.__getSystemCaCertificates() if cert in caCerts: caCerts.remove(cert) pems = QByteArray() for cert in caCerts: pems.append(cert.toPem() + '\n') Preferences.Prefs.settings.setValue("Help/SystemCertificates", pems) # delete the certificate from the default certificates self.__updateDefaultConfiguration()
def __init__(self, parent=None): QWidget.__init__(self, parent) # setGeometry(x_pos, y_pos, width, height) self.setGeometry(200, 200, 400, 400) self.setWindowTitle("QMovie to show animated gif") # set up the movie screen on a label self.movie_screen = QLabel() # expand and center the label self.movie_screen.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.movie_screen.setAlignment(Qt.AlignCenter) main_layout = QVBoxLayout() main_layout.addWidget(self.movie_screen) self.setLayout(main_layout) # use an animated gif file you have in the working folder # or give the full file path self.movie = QMovie("giphy.gif", QByteArray(), self) self.movie.setCacheMode(QMovie.CacheAll) self.movie.setSpeed(100) self.movie_screen.setMovie(self.movie) self.movie.start()
def setupCRS_customPage(self): self.recordingActive = False self.elapsed_time = 0 self.isICMReceived = False self.currentHeartRate = 0 self.maxHeartRate = 100 #graph setup self.max30001_graph.setBackground('w') self.RXvaluesArray = [0.0] #Recieved values for plotting self.timevaluesArray = [0.0] #Time values for plotting self.start_time = time.perf_counter() #Start collecting time value pen = mkPen(color=(255, 0, 0)) self.data_line = self.max30001_graph.plot(self.timevaluesArray, self.RXvaluesArray, pen=pen) # Subscribe to notification for CRS RX value changes via descriptor writing self.RXMeasurChar = self.ble_controller.openedService.characteristic( QBluetoothUuid("{0000fe62-8e22-4541-9d4c-21edae82ed19}") ) #uuid RX karakteristike if (self.RXMeasurChar.isValid() == False): print("ERR: Cannot read RX characteristic\n") self.RXCharCfg = QBluetoothUuid( QBluetoothUuid.ClientCharacteristicConfiguration) self.RXdescript = self.RXMeasurChar.descriptor(self.RXCharCfg) if (self.RXdescript.isValid() == False): print("ERR: Cannot create notification for CRS RX value\n") self.array = QByteArray( b'\x01\x00') #turn on NOTIFY for characteristic self.ble_controller.openedService.characteristicChanged.connect( self.handleRXValueChanged) self.ble_controller.openedService.writeDescriptor( self.RXdescript, self.array) #turn on NOTIFY
def mouseMoveEvent(self, event): """ Starts the drag to the timeline """ # do nothing if there is no item at the event position item = self.itemAt(event.pos()) if item is None: return # write the path to the dragevent item_data = QByteArray() data_stream = QDataStream(item_data, QIODevice.WriteOnly) path = item.statusTip() QDataStream.writeString(data_stream, str.encode(path)) # get width of timeable that would be created width = get_width_from_file(path) # do nothing if width is 0 because something went wrong if width == 0: return QDataStream.writeInt(data_stream, width) mime_data = QMimeData() mime_data.setData('ubicut/file', item_data) # set first frame as pixmap pixmap = get_pixmap_from_file(path, 1) # create and execute drag drag = QDrag(self) drag.setMimeData(mime_data) if pixmap is not None: drag.setPixmap(pixmap.scaled(QSize(100, 100), Qt.KeepAspectRatio)) drag.exec_(Qt.MoveAction)
def fromQImage(layerNode, image, position=None): """Paste given `image` to `position` in '`layerNode` The `position` value can be: - None, in this case, pixmap will be pasted at position (0, 0) - A QPoint() object, pixmap will be pasted at defined position """ if not isinstance(layerNode, Node): raise EInvalidType( "Given `layerNode` must be a valid Krita <Node> ") elif not isinstance(image, QImage): raise EInvalidType("Given `image` must be a valid <QImage> ") if position is None: position = QPoint(0, 0) if not isinstance(position, QPoint): raise EInvalidType("Given `position` must be a valid <QPoint> ") ptr = image.bits() ptr.setsize(image.byteCount()) layerNode.setPixelData(QByteArray(ptr.asstring()), position.x(), position.y(), image.width(), image.height())
def __init__(self, icon_name, hex_color): root = QFileInfo(__file__).absolutePath() svg_files = os.listdir(root + "/styles/assets/icons/svg/") filename = "appbar." + icon_name + ".svg" if filename in svg_files: f = QFile(root + '/styles/assets/icons/svg/' + filename) if f.open(QFile.ReadOnly | QFile.Text): textStream = QTextStream(f) svgData = textStream.readAll().replace( 'fill="#000000"', 'fill="{}"'.format(hex_color)) f.close() svg = QSvgRenderer(QByteArray().append(svgData)) qim = QImage(76, 76, QImage.Format_RGBA8888) qim.fill(0) painter = QPainter() painter.begin(qim) svg.render(painter) painter.end() self.icon = (QIcon(QPixmap.fromImage(qim)))
def __init__(self): super(Monitor, self).__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.help_menu = QtWidgets.QMenu('&Help', self) self.menuBar().addMenu(self.help_menu) self.help_menu.addAction('& About', self.about) self.s = QTcpSocket(self) self.ui.BtnShow.setEnabled(False) self.ui.BtnCon.clicked.connect(self.connectToServer) self.ui.BtnDiscon.clicked.connect(self.disconnectToServer) self.ui.RBHistory.clicked.connect(self.onClickRBHistory) self.ui.RBRealTime.clicked.connect(self.onClickRBRealTime) self.ui.BtnRef.clicked.connect(self.reflesh) self.treeModel = TreeModel(QByteArray()) self.ui.treeView.setModel(self.treeModel) self.ui.treeView.clicked.connect(self.onClickDir) self.ui.BtnShow.clicked.connect(self.showChart) self.s.error.connect(self.netError) self.s.connected.connect(self.netConnect) self.s.disconnected.connect(self.netDisconnect) self.timer0Id = 0 self.timer1Id = 0 self.isShow = False
def extension(self, extension, info=None, errorPage=None): if extension == QWebPage.ErrorPageExtension: # catch the error, populate self.errorInfo and return an error page info = sip.cast(info, QWebPage.ErrorPageExtensionOption) domain = 'Unknown' if info.domain == QWebPage.QtNetwork: domain = 'Network' elif info.domain == QWebPage.Http: domain = 'HTTP' elif info.domain == QWebPage.WebKit: domain = 'WebKit' self.error_info = RenderErrorInfo( domain, int(info.error), six.text_type(info.errorString), six.text_type(info.url.toString())) # XXX: this page currently goes nowhere content = u""" <html><head><title>Failed loading page</title></head> <body> <h1>Failed loading page ({0.text})</h1> <h2>{0.url}</h2> <p>{0.type} error #{0.code}</p> </body></html>""".format(self.error_info) errorPage = sip.cast(errorPage, QWebPage.ErrorPageExtensionReturn) errorPage.content = QByteArray(content.encode('utf-8')) return True # XXX: this method always returns True, even if we haven't # handled the extension. Is it correct? When can this method be # called with extension which is not ErrorPageExtension if we # are returning False in ``supportsExtension`` for such extensions? return True
def test__onGetRemoteMaterials_withNewMaterial(self, application_mock): reply_mock = MagicMock() device_mock = MagicMock() container_registry_mock = application_mock.getContainerRegistry.return_value material_manager_mock = application_mock.getMaterialManager.return_value container_registry_mock.getContainerFilePathById = lambda x: _FILES_MAP.get( x) device_mock.createFormPart.return_value = "_xXx_" all_results = self._LOCAL_MATERIAL_WHITE_ALL_RESULT.copy() for key, value in self._LOCAL_MATERIAL_BLACK_ALL_RESULT.items(): all_results[key] = value material_manager_mock.getAllMaterialGroups.return_value = all_results reply_mock.attribute.return_value = 200 reply_mock.readAll.return_value = QByteArray( json.dumps([self._REMOTE_MATERIAL_BLACK]).encode("ascii")) with mock.patch.object(Application, "getInstance", new=lambda: application_mock): job = SendMaterialJob(device_mock) job._onGetRemoteMaterials(reply_mock) self.assertEqual(1, device_mock.createFormPart.call_count) self.assertEqual(1, device_mock.postFormWithParts.call_count) self.assertEqual([ call.createFormPart( "name=\"file\"; filename=\"generic_pla_white.xml.fdm_material\"", "<xml></xml>"), call.postFormWithParts(target="materials/", parts=["_xXx_"], on_finished=job.sendingFinished) ], device_mock.method_calls)
def __init__(self, format, activeGen, parent=None): QIODevice.__init__(self, parent) self.data = QByteArray() # hold a reference to the active generator instance self.generator = activeGen self.convert_16_bit = float(2**15) # Check we can deal with the supplied # sample format. We're supposed to be # able to deal with any requested # sample format. But this is a # _minimal_ example if format.isValid() and \ format.sampleSize() == 16 and \ format.byteOrder() == \ QAudioFormat.LittleEndian and \ format.sampleType() == \ QAudioFormat.SignedInt and \ format.channelCount() == 1 : print("Meep: Format compatible. Good.") self.format = format
def set_spinner(self, file_name): # remove the old spinner if self.collecting_spinner != None: self.spinner_movie.stop() self.collecting_spinner.setParent(None) self.collecting_spinner = None self.spinner_movie = QMovie(file_name, QByteArray(), self) self.collecting_spinner = QLabel(self.parent) self.collecting_spinner.setMovie(self.spinner_movie) self.collecting_spinner.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.spinner_movie.setCacheMode(QMovie.CacheAll) self.spinner_movie.setSpeed(100) self.spinner_movie.start() # if I do not start it, it stays hidden self.spinner_movie.stop() self.collecting_spinner.move(0, 0) self.collecting_spinner.show() self.collecting_spinner.setHidden(True) img_size = self.spinner_movie.currentPixmap().size() self.collecting_spinner.resize(img_size.width(), img_size.height())
def __findForm(self, webPage, data, boundary=None): """ Private method to find the form used for logging in. @param webPage reference to the web page (QWebPage) @param data data to be sent (QByteArray) @keyparam boundary boundary string (QByteArray) for multipart encoded data, None for urlencoded data @return parsed form (LoginForm) """ from .LoginForm import LoginForm form = LoginForm() if boundary is not None: args = self.__extractMultipartQueryItems(data, boundary) else: if qVersion() >= "5.0.0": from PyQt5.QtCore import QUrlQuery argsUrl = QUrl.fromEncoded( QByteArray(b"foo://bar.com/?" + QUrl.fromPercentEncoding( data.replace(b"+", b"%20")).encode("utf-8"))) encodedArgs = QUrlQuery(argsUrl).queryItems() else: argsUrl = QUrl.fromEncoded( QByteArray(b"foo://bar.com/?" + data.replace(b"+", b"%20")) ) encodedArgs = argsUrl.queryItems() args = set() for arg in encodedArgs: key = arg[0] value = arg[1] args.add((key, value)) # extract the forms from Helpviewer.JavaScriptResources import parseForms_js lst = webPage.mainFrame().evaluateJavaScript(parseForms_js) for map in lst: formHasPasswords = False formName = map["name"] formIndex = map["index"] if isinstance(formIndex, float) and formIndex.is_integer(): formIndex = int(formIndex) elements = map["elements"] formElements = set() formElementTypes = {} deadElements = set() for elementMap in elements: try: name = elementMap["name"] value = elementMap["value"] type_ = elementMap["type"] except KeyError: continue if type_ == "password": formHasPasswords = True t = (name, value) try: if elementMap["autocomplete"] == "off": deadElements.add(t) except KeyError: pass if name: formElements.add(t) formElementTypes[name] = type_ if formElements.intersection(args) == args: form.hasAPassword = formHasPasswords if not formName: form.name = formIndex else: form.name = formName args.difference_update(deadElements) for elt in deadElements: if elt[0] in formElementTypes: del formElementTypes[elt[0]] form.elements = list(args) form.elementTypes = formElementTypes break return form
def restoreState(self, state, version=0): """ Public method to restore the state of the toolbar manager. @param state byte array containing the saved state (QByteArray) @param version version number stored with the data (integer) @return flag indicating success (boolean) """ if state.isEmpty(): return False data = QByteArray(state) stream = QDataStream(data, QIODevice.ReadOnly) stream.setVersion(QDataStream.Qt_4_6) marker = stream.readUInt16() vers = stream.readUInt16() if marker != E5ToolBarManager.VersionMarker or vers != version: return False tmarker = stream.readUInt16() if tmarker != E5ToolBarManager.ToolBarMarker: return False toolBarCount = stream.readUInt16() for i in range(toolBarCount): objectName = Utilities.readStringFromStream(stream) actionCount = stream.readUInt16() actions = [] for j in range(actionCount): actionName = Utilities.readStringFromStream(stream) if actionName: action = self.__findAction(actionName) if action is not None: actions.append(action) else: actions.append(None) toolBar = self.__findDefaultToolBar(objectName) if toolBar is not None: self.setToolBar(toolBar, actions) cmarker = stream.readUInt16() if cmarker != E5ToolBarManager.CustomToolBarMarker: return False oldCustomToolBars = self.__customToolBars[:] toolBarCount = stream.readUInt16() for i in range(toolBarCount): objectName = Utilities.readStringFromStream(stream) toolBarTitle = Utilities.readStringFromStream(stream) actionCount = stream.readUInt16() actions = [] for j in range(actionCount): actionName = Utilities.readStringFromStream(stream) if actionName: action = self.__findAction(actionName) if action is not None: actions.append(action) else: actions.append(None) toolBar = self.__toolBarByName(objectName) if toolBar is not None: toolBar.setWindowTitle(toolBarTitle) oldCustomToolBars.remove(toolBar) else: toolBar = self.createToolBar(toolBarTitle, objectName) if toolBar is not None: toolBar.setObjectName(objectName) self.setToolBar(toolBar, actions) for tb in oldCustomToolBars: self.deleteToolBar(tb) return True
def prepare_calendar(self): schema = [ QByteArray(str.encode("hour")), QByteArray(str.encode("firstPerson")), QByteArray(str.encode("secondPerson")), ] self.calendar_data = DefaultCalendarAbstractModel(schema) self.first_persons_column = list() self.second_person_column = list() # Prepare empty cells self.firstPersonList = list() self.secondPersonList = list() # Prepare data from Google Cal calendar = Calendar() calendar = calendar.get_calendarEntries("philipp") print('getting calendar entries') for appointment in calendar.appointments: print(appointment.toString()) self.calendar_data_first_person = calendar # Prepare second user data from Google Cal calendar = Calendar() calendar = calendar.get_calendarEntries("carla") print('getting calendar entries') for appointment in calendar.appointments: print(appointment.toString()) self.calendar_data_second_person = calendar for x in range(0, 24): # wenn zu dieser Uhrzeit kein Termin ansteht, das da verwenden: # noAppointmentString = DefaultCalendarEntryModel(datetime.datetime(self.date.year, self.date.month, self.date.day, x, 0), datetime.datetime(self.date.year, self.date.month, self.date.day, x, 59)) # firstPerson aus Google Cal durchloopen und DefaultCalendarEntryModel.set_data abfüllen cell = DefaultCalendarEntryModel( datetime.datetime(self.date.year, self.date.month, self.date.day, x, 0), datetime.datetime(self.date.year, self.date.month, self.date.day, x, 59)) for googleAppointment in self.calendar_data_first_person.appointments: appointment_index = googleAppointment.start.hour if x is appointment_index: nativeStart = googleAppointment.start.replace(tzinfo=None) nativeEnd = googleAppointment.end.replace(tzinfo=None) defaultCalEntryModel = DefaultCalendarEntryModel( datetime.datetime(self.date.year, self.date.month, self.date.day, x, 0), datetime.datetime(self.date.year, self.date.month, self.date.day, x, 59)) firstPersString = defaultCalEntryModel.set_data( googleAppointment.uid, nativeStart, nativeEnd, googleAppointment.description) # set_data(googleAppointment.uid, nativeStart, nativeEnd, googleAppointment.description) self.firstPersonList.append(firstPersString) else: self.firstPersonList.append(cell.full_text) for googleAppointment in self.calendar_data_second_person.appointments: appt_index = googleAppointment.start.hour if x is appt_index: nativeStart = googleAppointment.start.replace(tzinfo=None) nativeEnd = googleAppointment.end.replace(tzinfo=None) defaultCalEntryModel = DefaultCalendarEntryModel( datetime.datetime(self.date.year, self.date.month, self.date.day, x, 0), datetime.datetime(self.date.year, self.date.month, self.date.day, x, 59)) secondPersonString = defaultCalEntryModel.set_data( googleAppointment.uid, nativeStart, nativeEnd, googleAppointment.description) # set_data(googleAppointment.uid, nativeStart, nativeEnd, googleAppointment.description) self.secondPersonList.append(secondPersonString) else: self.secondPersonList.append(cell.full_text) # secondPerson aus Google Cal durchloopen und DefaultCalendarEntryModel.set_data abfüllen # self.secondPersonList.append(cell.full_text) # Hier dann calendar_data mit QByteArrays füllen self.calendar_data.append({ QByteArray(str.encode("hour")): str(x) + ":00", QByteArray(str.encode("firstPerson")): self.firstPersonList[x], QByteArray(str.encode("secondPerson")): self.secondPersonList[x], }) print(str(len(self.firstPersonList)))
class Repeater(SingletonObject): ConnectStatus = Enum('Status', "disconnected connected") _status = ConnectStatus.disconnected statusChanged = pyqtSignal() @pyqtProperty(ConnectStatus, notify=statusChanged) def status(self): return self._status @status.setter def status(self, status): self._status = status self.statusChanged.emit() def isConnected(self): return self._status is self.ConnectStatus.connected dataArrived = pyqtSignal(bytearray, name='dataArrived') snapshotArrived = pyqtSignal(QImage) videoFrameArrived = pyqtSignal(QImage) _delegates = [] _loop = None _context = None _handle = None _device = None _in_ep = None _out_ep = None _in_packet_size = 0 _out_packet_size = 0 _urb_free_list = [] _urb_busy_list = [] _mutex = QMutex() _datagram = QByteArray() _extendedDataBuffer = QByteArray() _extendedDataCategory = None _extendedDataCompressed = False _extendedDataSize = 0 def __init__(self, parent=None): super(Repeater, self).__init__(parent) context = usb1.USBContext() context.open() self._context = context self.dataArrived.connect(self.onDataArrived) self._loop = _RepeaterLoop(self) self._loop.deviceRemoved.connect(self.closeDevice) self._openDeviceTimer = QTimer(self) self._openDeviceTimer.timeout.connect(self.openDevice) self._openDeviceTimer.start(1000) def daemon(self): return self._loop @pyqtSlot() def closeDevice(self): print("close device") self.status = self.ConnectStatus.disconnected if self._handle is not None: self._handle.releaseInterface(0) self._device = None self._handle = None self.destroyURB() self._openDeviceTimer.start(1000) @pyqtSlot() def openDevice(self): context = self._context handle = context.openByVendorIDAndProductID( 0x2009, 0x0805, skip_on_error=True, ) if handle is not None: print("usb open device success") self._openDeviceTimer.stop() self._handle = handle device = handle.getDevice() self._device = device for endpoint in device[0][0][0]: address = endpoint.getAddress() if address & usb1.ENDPOINT_DIR_MASK == usb1.ENDPOINT_IN: self._in_ep = address self._in_packet_size = endpoint.getMaxPacketSize() else: self._out_ep = address self._out_packet_size = endpoint.getMaxPacketSize() self._interface = handle.claimInterface(0) self.startReceive() self._loop.start() self.status = self.ConnectStatus.connected def register(self, delegate): self._delegates.append(delegate) def reclaimURB(self, transfer): self._urb_busy_list.remove(transfer) self._urb_free_list.append(transfer) def destroyURB(self): self._urb_busy_list = [] self._urb_free_list = [] def getRequestBlock(self): block = QByteArray() ostream = QDataStream(block, QIODevice.WriteOnly) ostream.setVersion(QDataStream.Qt_4_8) ostream.writeQString('Bigeye') return block, ostream def submitRequestBlock(self, block): if self._status is self.ConnectStatus.disconnected: return block = self._escape(block) if len(self._urb_free_list) > 0: transfer = self._urb_free_list[0] self._urb_free_list.remove(transfer) else: transfer = self._handle.getTransfer() transfer.setBulk(self._out_ep, block, callback=_RepeaterLoop.sendDataCallback, user_data=self, timeout=100) transfer.submit() self._urb_busy_list.append(transfer) def getUSBContext(self): return self._context def getUSBHandle(self): return self._handle def onDataArrived(self, data): self._mutex.lock() start = 0 while True: if self._extendedDataSize > 0: size = self._extendedDataBuffer.size() remainder = self._extendedDataSize - size length = len(data) - start if length >= remainder: self._extendedDataBuffer.append(data[start:(start + remainder)]) start += remainder if self._extendedDataCompressed: self._extendedDataBuffer = qUncompress(self._extendedDataBuffer) self.onDisposedExtendedData() self._extendedDataSize = 0 else: self._extendedDataBuffer.append(data[start:]) break else: end = data.find(b'\x7e', start) if end == 0: self.onDisposed(self._datagram) self._datagram.clear() elif end > 0: self._datagram.append(data[start:end]) self.onDisposed(self._datagram) self._datagram.clear() else: self._datagram.append(data[start:]) break if end == len(data) - 1: break else: start = end + 1 self._mutex.unlock() def onDisposed(self, datagram): if datagram.size() == 0: return block = self._unescape(datagram) istream = QDataStream(block) istream.setVersion(QDataStream.Qt_4_8) magic = istream.readQString() response = istream.readQString() if istream.status() == QDataStream.Ok: if response == "extendedData": self._extendedDataCategory = istream.readQString() self._extendedDataCompressed = istream.readBool() self._extendedDataSize = istream.readInt() self._extendedDataBuffer.clear() else: handled = False for delegate in self._delegates: if hasattr(delegate, response): getattr(delegate, response)(istream) handled = True if istream.status() != QDataStream.Ok: print("{}: eeeeeeeeeeeeee".format(response)) break if not handled: print("Unhandled response:", response) else: print("onDisposed failed: block size", block.size()) def onDisposedExtendedData(self): for delegate in self._delegates: extendedDataHandel = "onExtendedDataArrived" handled = False if hasattr(delegate, extendedDataHandel): res = getattr(delegate, extendedDataHandel)(self._extendedDataCategory, self._extendedDataBuffer) if res is True: handled = True break if not handled: print("Unhandled extended data:", self._extendedDataCategory) def receiveData(self, data): self.dataArrived.emit(data) def startReceive(self): transfer = self._handle.getTransfer() transfer.setBulk(self._in_ep, self._in_packet_size * 32, callback=_RepeaterLoop.receiveDataCallback, user_data=self) transfer.submit() self._urb_busy_list.append(transfer) def stopReceive(self): pass @staticmethod def _escape(data): escape = QByteArray() escape.append(chr(0x7e)) """ for i in range(data.size()): ch = data.at(i) if ch == chr(0x7e): escape.append(chr(0x7d)) escape.append(chr(0x5e)) elif ch == chr(0x7d): escape.append(chr(0x7d)) escape.append(chr(0x5d)) else: escape.append(ch) """ data.replace(b"\x7d", b"\x7d\x5d") data.replace(b"\x7e", b"\x7d\x5e") escape.append(data) escape.append(chr(0x7e)) return escape @staticmethod def _unescape(data): """ unescape = QByteArray() is_escaped = False for i in range(data.size()): ch = data.at(i) if is_escaped: is_escaped = False if ch == chr(0x5e): unescape.append(chr(0x7e)) elif ch == chr(0x5d): unescape.append(chr(0x7d)) else: print("data corrupted") continue if ch == chr(0x7d): is_escaped = True continue else: unescape.append(ch) return unescape """ data.replace(b"\x7d\x5e", b"\x7e") data.replace(b"\x7d\x5d", b"\x7d") return data def _dumpUSBInfo(self): handle = self._handle print("bConfigurationValue ", handle.getConfiguration()) device = handle.getDevice() print("Device:") print("Bus Number ", device.getBusNumber()) print("Port Number ", device.getPortNumber()) print("Device Address ", device.getDeviceAddress()) print("Device Speed ", device.getDeviceSpeed()) print("Max Packet Size0 ", device.getMaxPacketSize0()) print("Vendor ID ", device.getVendorID()) print("Product ID ", device.getProductID()) print("Manufacturer ", device.getManufacturer()) print("Product ", device.getProduct()) print("Serial Number ", device.getSerialNumber()) print("Num Configurations ", device.getNumConfigurations()) print("Configurations:") for configuration in device: print(' ' * 2, " Configuration Value ", configuration.getConfigurationValue()) print(' ' * 2, " Descriptor ", configuration.getDescriptor()) print(' ' * 2, " Interfaces:") for interface in configuration: print(' ' * 4, "NumSettings ", interface.getNumSettings()) print(' ' * 4, "Interface Settings:") for interfaceSetting in interface: print(' ' * 6, "Number ", interfaceSetting.getNumber()) print(' ' * 6, "Endpoints:") for endpoint in interfaceSetting: print(' ' * 8, "Address ", endpoint.getAddress()) print(' ' * 8, "Attributes ", endpoint.getAttributes()) print(' ' * 8, "Max Packet Size ", endpoint.getMaxPacketSize())
def getRequestBlock(self): block = QByteArray() ostream = QDataStream(block, QIODevice.WriteOnly) ostream.setVersion(QDataStream.Qt_4_8) ostream.writeQString('Bigeye') return block, ostream
def prepare_krita_file(self): wBase = max( self.widthUnit.pixelsForUnit(self.spn_width.value(), self.DPI.value()), 1) bL = self.bleedLeftUnit.pixelsForUnit(self.bleedLeft.value(), self.DPI.value()) bR = self.bleedRightUnit.pixelsForUnit(self.bleedRight.value(), self.DPI.value()) mL = self.marginLeftUnit.pixelsForUnit(self.marginLeft.value(), self.DPI.value()) mR = self.marginRightUnit.pixelsForUnit(self.marginRight.value(), self.DPI.value()) hBase = max( self.heightUnit.pixelsForUnit(self.spn_height.value(), self.DPI.value()), 1) bT = self.bleedTopUnit.pixelsForUnit(self.bleedTop.value(), self.DPI.value()) bB = self.bleedBottomUnit.pixelsForUnit(self.bleedBottom.value(), self.DPI.value()) mT = self.marginTopUnit.pixelsForUnit(self.marginTop.value(), self.DPI.value()) mB = self.marginBottomUnit.pixelsForUnit(self.marginBottom.value(), self.DPI.value()) template = Application.createDocument((wBase + bL + bR), (hBase + bT + bB), self.templateName.text(), "RGBA", "U8", "sRGB built-in", self.DPI.value()) backgroundNode = template.activeNode() backgroundNode.setName(i18n("Background")) pixelByteArray = QByteArray() pixelByteArray = backgroundNode.pixelData(0, 0, (wBase + bL + bR), (hBase + bT + bB)) white = int(255) pixelByteArray.fill(white.to_bytes(1, byteorder='little')) backgroundNode.setPixelData(pixelByteArray, 0, 0, (wBase + bL + bR), (hBase + bT + bB)) backgroundNode.setLocked(True) sketchNode = template.createNode(i18n("Sketch"), "paintlayer") template.rootNode().setChildNodes([backgroundNode, sketchNode]) verticalGuides = [] verticalGuides.append(bL) verticalGuides.append(bL + mL) verticalGuides.append((bL + wBase) - mR) verticalGuides.append(bL + wBase) horizontalGuides = [] horizontalGuides.append(bT) horizontalGuides.append(bT + mT) horizontalGuides.append((bT + hBase) - mB) horizontalGuides.append(bT + hBase) template.setHorizontalGuides(horizontalGuides) template.setVerticalGuides(verticalGuides) template.setGuidesVisible(True) template.setGuidesLocked(True) self.urlSavedTemplate = os.path.join(self.templateDirectory, self.templateName.text() + ".kra") success = template.exportImage(self.urlSavedTemplate, InfoObject()) print("CPMT: Template", self.templateName.text(), "made and saved.") template.waitForDone() template.close() return success
def __init__(self, geometry, win_id, parent=None): super().__init__(parent) self._geometry = QByteArray(geometry) self.win_id = win_id
def responseComplete(self): request = self.serverInterface().requestHandler() params = request.parameterMap() # SERVICE=RENDERGEOJSON -- we are taking over if params.get('SERVICE', '').upper() == 'RENDERGEOJSON': request.clear() try: # Parse parameters geojson = params.get('GEOJSON') if not geojson: raise ParameterError('Parameter GEOJSON must be set.') style = params.get('STYLE') if not style: raise ParameterError('Parameter STYLE must be set.') try: width = int(params.get('WIDTH')) except TypeError: raise ParameterError('Parameter WIDTH must be integer.') try: height = int(params.get('HEIGHT')) except TypeError: raise ParameterError('Parameter HEIGHT must be integer.') try: dpi = int(params.get('DPI', 96)) except TypeError: raise ParameterError('Parameter DPI must be integer.') try: minx, miny, maxx, maxy = params.get('BBOX').split(',') bbox = QgsRectangle(float(minx), float(miny), float(maxx), float(maxy)) except (ValueError, AttributeError): raise ParameterError( 'Parameter BBOX must be specified in the form `min_x,min_y,max_x,max_y`.' ) url = geojson geojson_file_name = self._resolve_url(geojson) if '$type' in style: polygon_style = self._resolve_url( style.replace('$type', 'polygons')) line_style = self._resolve_url( style.replace('$type', 'lines')) point_style = self._resolve_url( style.replace('$type', 'points')) else: polygon_style = self._resolve_url(style) line_style = polygon_style point_style = polygon_style polygon_layer = QgsVectorLayer( geojson_file_name + '|geometrytype=Polygon', 'polygons', 'ogr') self._load_style(polygon_layer, polygon_style) line_layer = QgsVectorLayer( geojson_file_name + '|geometrytype=Line', 'lines', 'ogr') self._load_style(line_layer, line_style) point_layer = QgsVectorLayer( geojson_file_name + '|geometrytype=Point', 'points', 'ogr') self._load_style(point_layer, point_style) settings = QgsMapSettings() settings.setOutputSize(QSize(width, height)) settings.setOutputDpi(dpi) settings.setExtent(bbox) settings.setLayers([polygon_layer, line_layer, point_layer]) settings.setBackgroundColor(QColor(Qt.transparent)) renderer = QgsMapRendererParallelJob(settings) event_loop = QEventLoop() renderer.finished.connect(event_loop.quit) renderer.start() event_loop.exec_() img = renderer.renderedImage() img.setDotsPerMeterX(dpi * 39.37) img.setDotsPerMeterY(dpi * 39.37) image_data = QByteArray() buf = QBuffer(image_data) buf.open(QIODevice.WriteOnly) img.save(buf, 'PNG') request.setResponseHeader('Content-type', 'image/png') request.appendBody(image_data) except ParameterError as e: QgsMessageLog.logMessage( "RenderGeojson.responseComplete :: ParameterError") request.setResponseHeader('Content-type', 'text/plain') request.appendBody(str(e).encode('utf-8')) except: QgsMessageLog.logMessage( "RenderGeojson.responseComplete :: Exception") QgsMessageLog.logMessage( "RenderGeojson.responseComplete :: {}".format( traceback.format_exc())) request.setResponseHeader('Content-type', 'text/plain') request.appendBody(b'Unhandled error') request.appendBody(traceback.format_exc().encode('utf-8'))
def base64image(image): ba = QByteArray() buffer = QBuffer(ba) buffer.open(QIODevice.WriteOnly) image.save(buffer, "PNG") return "data:image/png;base64," + ba.toBase64().data().decode("ascii")
def run_api(): # pdf = Poppler.Document() # page = Poppler.Page() pdf = 0 page = 0 image = QImage() byte_data = QByteArray() color_theme = 'light' #allowed color themes: 'light','dark','sepia' while True: s = input() tokens = s.split(' ') if tokens[0] == 'open': #open a pdf file pdf = Poppler.Document.load(tokens[1]) pdf.setRenderHint(Poppler.Document.TextAntialiasing) if tokens[0] == 'page': #open a page of the current pdf page = pdf.page(tokens[1]) if tokens[0] == 'pages': #returns number of pages print(pdf.numPages()) if tokens[0] == 'color': #set color theme color_theme = tokens[1] if tokens[0] == 'textlist': #outputs textlist as a json file textlist = page.textList() textlist_json = [] for text in textlist: bb = text.boundingBox() d = {'text': text.text(), 'x': bb.x(), 'y': bb.y(), 'width': bb.width(), 'height': bb.height()} textlist_json.append(d) print(json.dumps(textlist_json)) if tokens[0] == 'render': #output pixel data to stdout image = page.renderToImage(3 * 72, 3 * 72, -1, -1, -1, -1) print(image.format()) if color_theme == 'dark': for x in range(image.width()): for y in range(image.height()): rgb = image.pixelColor(x, y) rgb.setRed(int(linear_interpolation(234, 68, rgb.red() / 255))) rgb.setGreen(int(linear_interpolation(234, 68, rgb.green() / 255))) rgb.setBlue(int(linear_interpolation(234, 68, rgb.blue() / 255))) image.setPixelColor(x, y, rgb) # print(image.data) # bits = image.bits() # byte_data.fromRawData(image.data) # print(byte_data) ba = QByteArray() buffer = QBuffer(ba) buffer.open(QIODevice.WriteOnly) image.save(buffer, "PNG") # writes image into ba in PNG format ba2 = buffer.data() for i in ba. bits = image.constBits() bits.setsize(image.width() * image.height() * 4) print(str(bits)) print(dir(bits)) print(bits.asarray()) print(str(bits.asarray())) imgPtr = c_void_p(bits.__int__()) print(dir(imgPtr)) # for i in range(len(bits)): # print(bits[i]) # print(image.constBits()[0]) # print(bits) # print(type(bits)) # for i in range(image.width()): # for j in range(image.height()): # # print(image.pixel(i, j)) # print(bits[i]) # # color = QColor(image.pixel(i,j)) # # print(image.pixel(i,j).red(), image.pixel(i,j).green(), image.pixel(i,j).blue()) if tokens[0] == 'toc': toc = pdf.toc()
'markdownDefaultFileExtension': '.mkd', 'previewState': False, 'pygmentsStyle': 'default', 'restDefaultFileExtension': '.rst', 'restorePreviewState': False, 'rightMargin': 0, 'saveWindowGeometry': False, 'spellCheck': False, 'spellCheckLocale': '', 'styleSheet': '', 'tabInsertsSpaces': True, 'tabWidth': 4, 'uiLanguage': QLocale.system().name(), 'useFakeVim': False, 'useWebKit': False, 'windowGeometry': QByteArray(), } def readFromSettings(key, keytype, settings=settings, default=None): if not settings.contains(key): return default try: value = settings.value(key, type=keytype) if isinstance(value, keytype): return value return keytype(value) except TypeError as error: # Type mismatch print('Warning: '+str(error)) # Return an instance of keytype return default if (default is not None) else keytype()
def sslErrors(self, errors, server, port=-1): """ Public method to handle SSL errors. @param errors list of SSL errors (list of QSslError) @param server name of the server (string) @keyparam port value of the port (integer) @return tuple indicating to ignore the SSL errors (one of NotIgnored, SystemIgnored or UserIgnored) and indicating a change of the default SSL configuration (boolean) """ caMerge = {} certificateDict = Globals.toDict( Preferences.Prefs.settings.value("Ssl/CaCertificatesDict")) for caServer in certificateDict: caMerge[caServer] = QSslCertificate.fromData( certificateDict[caServer]) caNew = [] errorStrings = [] if port != -1: server += ":{0:d}".format(port) if errors: for err in errors: if err.error() == QSslError.NoError: continue if server in caMerge and err.certificate() in caMerge[server]: continue errorStrings.append(err.errorString()) if not err.certificate().isNull(): cert = err.certificate() if cert not in caNew: caNew.append(cert) if not errorStrings: return E5SslErrorHandler.SystemIgnored, False errorString = '.</li><li>'.join(errorStrings) ret = E5MessageBox.yesNo( None, self.tr("SSL Errors"), self.tr("""<p>SSL Errors for <br /><b>{0}</b>""" """<ul><li>{1}</li></ul></p>""" """<p>Do you want to ignore these errors?</p>""").format( server, errorString), icon=E5MessageBox.Warning) if ret: caRet = False if len(caNew) > 0: certinfos = [] for cert in caNew: certinfos.append(self.__certToString(cert)) caRet = E5MessageBox.yesNo( None, self.tr("Certificates"), self.tr("""<p>Certificates:<br/>{0}<br/>""" """Do you want to accept all these certificates?""" """</p>""").format("".join(certinfos))) if caRet: if server not in caMerge: caMerge[server] = [] for cert in caNew: caMerge[server].append(cert) sslCfg = QSslConfiguration.defaultConfiguration() caList = sslCfg.caCertificates() for cert in caNew: caList.append(cert) sslCfg.setCaCertificates(caList) try: sslCfg.setProtocol(QSsl.TlsV1_1OrLater) except AttributeError: sslCfg.setProtocol(QSsl.SecureProtocols) try: sslCfg.setSslOption(QSsl.SslOptionDisableCompression, True) except AttributeError: pass QSslConfiguration.setDefaultConfiguration(sslCfg) certificateDict = {} for server in caMerge: pems = QByteArray() for cert in caMerge[server]: pems.append(cert.toPem() + b'\n') certificateDict[server] = pems Preferences.Prefs.settings.setValue( "Ssl/CaCertificatesDict", certificateDict) return E5SslErrorHandler.UserIgnored, caRet else: return E5SslErrorHandler.NotIgnored, False
def serialize(obj: _QtSerializableType) -> QByteArray: """Serialize an object into a QByteArray.""" data = QByteArray() stream = QDataStream(data, QIODevice.WriteOnly) serialize_stream(stream, obj) return data
def export_video(self): if not imageio: return QMessageBox( QMessageBox.Information, 'Export not available', 'imageio and ffmpeg must be installed to export videos').exec( ) location = QFileDialog.getSaveFileName(self, 'Choose export location', filter='Video (*.mp4)')[0] if not location: return if not location.endswith('.mp4'): location += '.mp4' frame_count = int(self.duration * FPS) progress_box = QProgressDialog('Recording and exporting video...', 'Cancel', 1, frame_count, self) progress_box.setWindowModality(Qt.WindowModal) with imageio.get_writer(location, format='mp4', mode='I', fps=FPS, quality=6) as writer: frame = 0 stopped = False def new_event(*args): nonlocal frame, stopped try: self.callback( AniState(self, frame=frame, time=frame / FPS, dt=1 / FPS)) frame += 1 except StopIteration: stopped = True old = self.paintEvent self.paintEvent = new_event self.start() self.frame_no = 0 for i in range(frame_count): progress_box.setValue(i) if progress_box.wasCanceled(): os.remove(location) return im_bytes = QByteArray() buf = QBuffer(im_bytes) buf.open(QIODevice.WriteOnly) self.grab().save(buf, 'PNG', 100) # Triggers paintEvent self.frame_no += 1 writer.append_data(imageio.imread(im_bytes.data(), 'png')) if stopped: break progress_box.setValue(progress_box.maximum()) self.paintEvent = old return QMessageBox( QMessageBox.Information, 'Completed', 'Export finished! Saved to {}'.format(location)).exec()
def __init__(self, parent=None): super(MainForm, self).__init__(parent) self.filename = "" self.copiedItem = QByteArray() self.pasteOffset = 5 self.prevPoint = QPoint() self.addOffset = 5 self.borders = [] self.printer = QPrinter(QPrinter.HighResolution) self.printer.setPageSize(QPrinter.Letter) self.view = GraphicsView() self.scene = QGraphicsScene(self) self.scene.setSceneRect(0, 0, PageSize[0], PageSize[1]) self.addBorders() self.view.setScene(self.scene) self.wrapped = [] # Needed to keep wrappers alive buttonLayout = QVBoxLayout() for text, slot in ( ("Add &Text", self.addText), ("Add &Box", self.addBox), ("Add Pi&xmap", self.addPixmap), ("&Align", None), ("&Copy", self.copy), ("C&ut", self.cut), ("&Paste", self.paste), ("&Delete...", self.delete), ("&Rotate", self.rotate), ("Pri&nt...", self.print_), ("&Open...", self.open), ("&Save", self.save), ("&Quit", self.accept)): button = QPushButton(text) if not MAC: button.setFocusPolicy(Qt.NoFocus) if slot is not None: button.clicked.connect(slot) if text == "&Align": menu = QMenu(self) for text, arg in ( ("Align &Left", Qt.AlignLeft), ("Align &Right", Qt.AlignRight), ("Align &Top", Qt.AlignTop), ("Align &Bottom", Qt.AlignBottom)): wrapper = functools.partial(self.setAlignment, arg) self.wrapped.append(wrapper) menu.addAction(text, wrapper) button.setMenu(menu) if text == "Pri&nt...": buttonLayout.addStretch(5) if text == "&Quit": buttonLayout.addStretch(1) buttonLayout.addWidget(button) buttonLayout.addStretch() layout = QHBoxLayout() layout.addWidget(self.view, 1) layout.addLayout(buttonLayout) self.setLayout(layout) fm = QFontMetrics(self.font()) self.resize(self.scene.width() + fm.width(" Delete... ") + 50, self.scene.height() + 50) self.setWindowTitle("Page Designer")