def read(self, fileName): uncompressed = QByteArray() # Read data f = QFile(fileName) if (f.open(QIODevice.ReadOnly)) : compressed = f.readAll() f.close() uncompressed, length = decompress(compressed, 48 * 48) # Check the data if (uncompressed.count() != 48 * 48) : self.mError = self.tr("This is not a valid Droidcraft map file!") return None uncompressed = uncompressed.data() # Build 48 x 48 map # Create a Map -> Create a Tileset -> Add Tileset to map # -> Create a TileLayer -> Fill layer -> Add TileLayer to Map map = Map(Map.Orientation.Orthogonal, 48, 48, 32, 32) mapTileset = Tileset.create("tileset", 32, 32) mapTileset.loadFromImage(QImage(":/tileset.png"), "tileset.png") map.addTileset(mapTileset) # Fill layer mapLayer = TileLayer("map", 0, 0, 48, 48) # Load for i in range(0, 48 * 48): tileFile = int(uncompressed[i])&0xff y = int(i / 48) x = i - (48 * y) tile = mapTileset.tileAt(tileFile) mapLayer.setCell(x, y, Cell(tile)) map.addLayer(mapLayer) return map
def on_caImportButton_clicked(self): """ Private slot to import server certificates. """ certs = self.__importCertificate() if certs: caCerts = self.__getSystemCaCertificates() for cert in certs: if cert in caCerts: if qVersion() >= "5.0.0": commonStr = ", ".join(cert.subjectInfo(QSslCertificate.CommonName)) else: commonStr = cert.subjectInfo(QSslCertificate.CommonName) E5MessageBox.warning( self, self.tr("Import Certificate"), self.tr("""<p>The certificate <b>{0}</b> already exists.""" """ Skipping.</p>""").format( Utilities.decodeString(commonStr) ), ) else: caCerts.append(cert) pems = QByteArray() for cert in caCerts: pems.append(cert.toPem() + "\n") Preferences.Prefs.settings.setValue("Help/SystemCertificates", pems) self.caCertificatesTree.clear() self.__populateCaCertificatesTree() self.__updateDefaultConfiguration()
def __parseUrl(self, url): """ Private method to parse the AdBlock URL for the subscription. @param url AdBlock URL for the subscription (QUrl) """ if url.scheme() != "abp": return if url.path() != "subscribe": return if qVersion() >= "5.0.0": from PyQt5.QtCore import QUrlQuery urlQuery = QUrlQuery(url) self.__title = urlQuery.queryItemValue("title") self.__enabled = urlQuery.queryItemValue("enabled") != "false" self.__location = QByteArray(urlQuery.queryItemValue("location")) # Check for required subscription self.__requiresLocation = urlQuery.queryItemValue( "requiresLocation") self.__requiresTitle = urlQuery.queryItemValue("requiresTitle") if self.__requiresLocation and self.__requiresTitle: import Helpviewer.HelpWindow Helpviewer.HelpWindow.HelpWindow.adBlockManager()\ .loadRequiredSubscription(self.__requiresLocation, self.__requiresTitle) lastUpdateString = urlQuery.queryItemValue("lastUpdate") self.__lastUpdate = QDateTime.fromString(lastUpdateString, Qt.ISODate) else: self.__title = \ QUrl.fromPercentEncoding(url.encodedQueryItemValue("title")) self.__enabled = QUrl.fromPercentEncoding( url.encodedQueryItemValue("enabled")) != "false" self.__location = QByteArray(QUrl.fromPercentEncoding( url.encodedQueryItemValue("location"))) # Check for required subscription self.__requiresLocation = QUrl.fromPercentEncoding( url.encodedQueryItemValue("requiresLocation")) self.__requiresTitle = QUrl.fromPercentEncoding( url.encodedQueryItemValue("requiresTitle")) if self.__requiresLocation and self.__requiresTitle: import Helpviewer.HelpWindow Helpviewer.HelpWindow.HelpWindow.adBlockManager()\ .loadRequiredSubscription(self.__requiresLocation, self.__requiresTitle) lastUpdateByteArray = url.encodedQueryItemValue("lastUpdate") lastUpdateString = QUrl.fromPercentEncoding(lastUpdateByteArray) self.__lastUpdate = QDateTime.fromString(lastUpdateString, Qt.ISODate) self.__loadRules()
def take_screenshot(self): byte_array = QByteArray() buffer = QBuffer(byte_array) buffer.open(QIODevice.WriteOnly) image = self.__screen.grabWindow(QApplication.desktop().winId()) image.save(buffer, "PNG") return str(byte_array.toBase64())[1:]
def __sendGreetingMessage(self): """ Private slot to send a greeting message. """ greeting = QByteArray(self.__greetingMessage.encode("utf-8")) data = QByteArray("{0}{1}{2}{1}".format( Connection.ProtocolGreeting, SeparatorToken, greeting.size()) .encode("utf-8")) + greeting if self.write(data) == data.size(): self.__isGreetingMessageSent = True
def readData(self, maxlen): data = QByteArray() total = 0 while maxlen > total: chunk = min(self.m_buffer.size() - self.m_pos, maxlen - total) data.append(self.m_buffer.mid(self.m_pos, chunk)) self.m_pos = (self.m_pos + chunk) % self.m_buffer.size() total += chunk return data.data()
def sendEditorCommand(self, projectHash, filename, message): """ Public method to send an editor command. @param projectHash hash of the project (string) @param filename project relative universal file name of the sending editor (string) @param message editor command to be sent (string) """ msg = QByteArray("{0}{1}{2}{1}{3}".format( projectHash, SeparatorToken, filename, message).encode("utf-8")) data = QByteArray("{0}{1}{2}{1}".format( Connection.ProtocolEditor, SeparatorToken, msg.size())) + msg self.write(data)
def sendMessage(self, message): """ Public method to send a message. @param message message to be sent (string) @return flag indicating a successful send (boolean) """ if message == "": return False msg = QByteArray(message.encode("utf-8")) data = QByteArray("{0}{1}{2}{1}".format( Connection.ProtocolMessage, SeparatorToken, msg.size())) + msg return self.write(data) == data.size()
def sendFortune(self): block = QByteArray() out = QDataStream(block, QIODevice.WriteOnly) out.setVersion(QDataStream.Qt_4_0) out.writeUInt16(0) out.writeQString(random.choice(self.fortunes)) out.device().seek(0) out.writeUInt16(block.size() - 2) clientConnection = self.server.nextPendingConnection() clientConnection.disconnected.connect(clientConnection.deleteLater) clientConnection.write(block) clientConnection.flush() clientConnection.disconnectFromServer()
def sendParticipants(self, participants): """ Public method to send the list of participants. @param participants list of participants (list of strings of "host:port") """ if participants: message = SeparatorToken.join(participants) else: message = "<empty>" msg = QByteArray(message.encode("utf-8")) data = QByteArray("{0}{1}{2}{1}".format( Connection.ProtocolParticipants, SeparatorToken, msg.size())) + msg self.write(data)
def on_serversDeleteButton_clicked(self): """ Private slot to delete the selected server certificate. """ itm = self.serversCertificatesTree.currentItem() res = E5MessageBox.yesNo( self, self.tr("Delete Server Certificate"), self.tr("""<p>Shall the server certificate really be""" """ deleted?</p><p>{0}</p>""" """<p>If the server certificate is deleted, the""" """ normal security checks will be reinstantiated""" """ and the server has to present a valid""" """ certificate.</p>""") .format(itm.text(0))) if res: server = itm.text(1) cert = self.serversCertificatesTree.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.serversCertificatesTree.takeTopLevelItem( self.serversCertificatesTree.indexOfTopLevelItem(parent)) # delete the certificate from the user certificate store certificateDict = Preferences.toDict( Preferences.Prefs.settings.value("Ssl/CaCertificatesDict")) if server in certificateDict: certs = QSslCertificate.fromData(certificateDict[server]) if cert in certs: certs.remove(cert) if certs: pems = QByteArray() for cert in certs: pems.append(cert.toPem() + '\n') certificateDict[server] = pems else: del certificateDict[server] Preferences.Prefs.settings.setValue( "Ssl/CaCertificatesDict", certificateDict) # delete the certificate from the default certificates self.__updateDefaultConfiguration()
def __init__(self, format, durationUs, sampleRate, parent): super(Generator, self).__init__(parent) self.m_pos = 0 self.m_buffer = QByteArray() self.generateData(format, durationUs, sampleRate)
def sendFortune(self): fortune = self.FORTUNES[random.randint(0, len(self.FORTUNES) - 1)] block = QByteArray() out = QDataStream(block, QIODevice.WriteOnly) out.setVersion(QDataStream.Qt_4_0) out.writeUInt16(0) out.writeQString(fortune) out.device().seek(0) out.writeUInt16(block.size() - 2) clientConnection = self.tcpServer.nextPendingConnection() clientConnection.disconnected.connect(clientConnection.deleteLater) clientConnection.write(block) clientConnection.disconnectFromHost()
def __readImage(self): atts = self.xml.attributes() source = atts.value("source") format = atts.value("format") if len(source)==0: while (self.xml.readNextStartElement()): if (self.xml.name() == "data"): atts = self.xml.attributes() encoding = atts.value("encoding") data = self.xml.readElementText().toLatin1() if (encoding == "base64"): data = QByteArray.fromBase64(data) self.xml.skipCurrentElement() return QImage.fromData(data, format.toLatin1()) else: self.__readUnknownElement() else: self.xml.skipCurrentElement() source = self.p.resolveReference(source, self.mPath) image = self.p.readExternalImage(source) if (image.isNull()): self.xml.raiseError(self.tr("Error loading image:\n'%s'"%source)) return image return QImage()
def capture(self, fullScreen = False, filename = ''): if fullScreen: image = QApplication.primaryScreen().grabWindow(0) else: image = QImage(self.webView.mainFrame.contentsSize(), QImage.Format_ARGB32) painter = QPainter(image) self.webView.mainFrame.render(painter) painter.end() if filename: return image.save(filename) else: data = QByteArray() buffer = QBuffer(data) buffer.open(QBuffer.WriteOnly) image.save(buffer, 'PNG') return bytes(data.toBase64()).decode()
def __init__(self, request, fileData, mimeType, parent=None): """Constructor. Args: request: reference to the request object (QNetworkRequest) fileData: reference to the data buffer (QByteArray) mimeType: for the reply (string) parent: reference to the parent object (QObject) """ super().__init__(parent) self._data = fileData self.setRequest(request) self.setUrl(request.url()) self.setOpenMode(QIODevice.ReadOnly) self.setHeader(QNetworkRequest.ContentTypeHeader, mimeType) self.setHeader(QNetworkRequest.ContentLengthHeader, QByteArray.number(len(fileData))) self.setAttribute(QNetworkRequest.HttpStatusCodeAttribute, 200) self.setAttribute(QNetworkRequest.HttpReasonPhraseAttribute, 'OK') # For some reason, a segfault will be triggered if these lambdas aren't # there. QTimer.singleShot(0, lambda: self.metaDataChanged.emit()) QTimer.singleShot(0, lambda: self.readyRead.emit()) QTimer.singleShot(0, lambda: self.finished.emit())
def __processData(self): """ Private method to process the received data. """ self.__buffer = QByteArray( self.read(self.__numBytesForCurrentDataType)) if self.__buffer.size() != self.__numBytesForCurrentDataType: self.abort() return if self.__currentDataType == Connection.PlainText: self.newMessage.emit( self.__username, str(self.__buffer, encoding="utf-8")) elif self.__currentDataType == Connection.Ping: self.write("{0}{1}1{1}p".format( Connection.ProtocolPong, SeparatorToken)) elif self.__currentDataType == Connection.Pong: self.__pongTime.restart() elif self.__currentDataType == Connection.GetParticipants: self.getParticipants.emit() elif self.__currentDataType == Connection.Participants: msg = str(self.__buffer, encoding="utf-8") if msg == "<empty>": participantsList = [] else: participantsList = msg.split(SeparatorToken) self.participants.emit(participantsList[:]) elif self.__currentDataType == Connection.Editor: hash, fn, msg = \ str(self.__buffer, encoding="utf-8").split(SeparatorToken) self.editorCommand.emit(hash, fn, msg) self.__currentDataType = Connection.Undefined self.__numBytesForCurrentDataType = 0 self.__buffer.clear()
def __init__(self, parent=None): """ Constructor @param parent referenec to the parent object (QObject) """ super(Connection, self).__init__(parent) self.__greetingMessage = self.tr("undefined") self.__username = self.tr("unknown") self.__serverPort = 0 self.__state = Connection.WaitingForGreeting self.__currentDataType = Connection.Undefined self.__numBytesForCurrentDataType = -1 self.__transferTimerId = 0 self.__isGreetingMessageSent = False self.__pingTimer = QTimer(self) self.__pingTimer.setInterval(PingInterval) self.__pongTime = QTime() self.__buffer = QByteArray() self.__client = None self.readyRead.connect(self.__processReadyRead) self.disconnected.connect(self.__disconnected) self.__pingTimer.timeout.connect(self.__sendPing) self.connected.connect(self.__sendGreetingMessage)
def __showCookieDetails(self, index): """ Private slot to show a dialog with the cookie details. @param index index of the entry to show (QModelIndex) """ if not index.isValid(): return cookiesTable = self.sender() if cookiesTable is None: return model = cookiesTable.model() row = index.row() domain = model.data(model.index(row, 0)) name = model.data(model.index(row, 1)) path = model.data(model.index(row, 2)) secure = model.data(model.index(row, 3)) expires = model.data(model.index(row, 4)).toString("yyyy-MM-dd hh:mm") value = bytes( QByteArray.fromPercentEncoding( model.data(model.index(row, 5)))).decode() if self.__detailsDialog is None: from .CookieDetailsDialog import CookieDetailsDialog self.__detailsDialog = CookieDetailsDialog(self) self.__detailsDialog.setData(domain, name, path, secure, expires, value) self.__detailsDialog.show()
def mouseMoveEvent(self, event): """ Protected method to handle mouse move events. @param event reference to the mouse move event (QMouseEvent) """ if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \ (event.pos() - self.__dragStartPos).manhattanLength() > \ QApplication.startDragDistance(): drag = QDrag(self) mimeData = QMimeData() index = self.tabAt(event.pos()) mimeData.setText(self.tabText(index)) mimeData.setData("action", b"tab-reordering") mimeData.setData("tabbar-id", str(id(self)).encode("utf-8")) mimeData.setData( "source-index", QByteArray.number(self.tabAt(self.__dragStartPos))) mimeData.setData( "tabwidget-id", str(id(self.parentWidget())).encode("utf-8")) drag.setMimeData(mimeData) if event.modifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier): drag.exec_(Qt.DropActions(Qt.CopyAction)) elif event.modifiers() == Qt.KeyboardModifiers(Qt.NoModifier): drag.exec_(Qt.DropActions(Qt.MoveAction)) super(TabBar, self).mouseMoveEvent(event)
def save(self, fileName, selectedFilter): if selectedFilter == self.filters[1]: img = self.page().mainFrame().evaluateJavaScript("chart.getImageURI()") if img: ba = QByteArray() ba.append(img[22:]) by = QByteArray.fromBase64(ba) image = QImage.fromData(by, "PNG") image.save(fileName) else: QMessageBox.warning(self.parent(), self.tr("Saving"), self.tr("Image not ready. Please try again later")) else: if selectedFilter == self.filters[0]: with open(fileName, 'wb') as f: f.write(bytes(self.html_data, 'utf-8'))
def run(self): tcpSocket = QTcpSocket() if not tcpSocket.setSocketDescriptor(self.socketDescriptor): self.error.emit(tcpSocket.error()) return block = QByteArray() outstr = QDataStream(block, QIODevice.WriteOnly) outstr.setVersion(QDataStream.Qt_4_0) outstr.writeUInt16(0) outstr.writeQString(self.text) outstr.device().seek(0) outstr.writeUInt16(block.size() - 2) tcpSocket.write(block) tcpSocket.disconnectFromHost() tcpSocket.waitForDisconnected()
def mimeData(self, indexes): """See QAbstractItemModel documentation""" if len(indexes) != 1: return 0 data = QMimeData() data.setData(self.mimeTypes()[0], QByteArray.number(indexes[0].row())) return data
def run(self, argv, error_message, in_build_dir=False): """ Execute a command and capture the output. """ if in_build_dir: project = self._project saved_cwd = os.getcwd() build_dir = project.path_from_user(project.build_dir) build_dir = QDir.toNativeSeparators(build_dir) os.chdir(build_dir) self._message_handler.verbose_message( "{0} is now the current directory".format(build_dir)) else: saved_cwd = None self._message_handler.verbose_message( "Running '{0}'".format(' '.join(argv))) QCoreApplication.processEvents() process = QProcess() process.readyReadStandardOutput.connect( lambda: self._message_handler.progress_message( QTextCodec.codecForLocale().toUnicode( process.readAllStandardOutput()).strip())) stderr_output = QByteArray() process.readyReadStandardError.connect( lambda: stderr_output.append(process.readAllStandardError())) process.start(argv[0], argv[1:]) finished = process.waitForFinished() if saved_cwd is not None: os.chdir(saved_cwd) self._message_handler.verbose_message( "{0} is now the current directory".format(saved_cwd)) if not finished: raise UserException(error_message, process.errorString()) if process.exitStatus() != QProcess.NormalExit or process.exitCode() != 0: raise UserException(error_message, QTextCodec.codecForLocale().toUnicode(stderr_output).strip())
def getScreenAsData(self, quality = 20): ss = self.screen.grabWindow(self.sid); #b = ss.toImage().mirrored(True, True); #ss.convertFromImage(b); painter = QPainter(); painter.begin(ss); painter.setBrush(QColor( 255,0, 0)) size = 8; half_size = size / 2; cx, cy = self.getMouseXY(); painter.drawEllipse(cx - half_size, cy - half_size, size,size); painter.end(); # bytesArray = QByteArray(); buff = QBuffer(bytesArray); ss.save(buff, 'JPEG', quality = quality) data = bytesArray.data(); return data;
def on_serversImportButton_clicked(self): """ Private slot to import server certificates. """ certs = self.__importCertificate() if certs: server = "*" certificateDict = Preferences.toDict( Preferences.Prefs.settings.value("Ssl/CaCertificatesDict")) if server in certificateDict: sCerts = QSslCertificate.fromData(certificateDict[server]) else: sCerts = [] pems = QByteArray() for cert in certs: if cert in sCerts: if qVersion() >= "5.0.0": commonStr = ", ".join( cert.subjectInfo(QSslCertificate.CommonName)) else: commonStr = cert.subjectInfo( QSslCertificate.CommonName) E5MessageBox.warning( self, self.tr("Import Certificate"), self.tr( """<p>The certificate <b>{0}</b> already exists.""" """ Skipping.</p>""") .format(Utilities.decodeString(commonStr))) else: pems.append(cert.toPem() + '\n') if server not in certificateDict: certificateDict[server] = QByteArray() certificateDict[server].append(pems) Preferences.Prefs.settings.setValue( "Ssl/CaCertificatesDict", certificateDict) self.serversCertificatesTree.clear() self.__populateServerCertificatesTree() self.__updateDefaultConfiguration()
def clickAction_MessagePushButton(self): temp = self.messagelineEdit.text() self.append_plainTextEdit_3(temp) self.append_plainTextEdit_3("\n") bArray = QByteArray() if self.sysencoding == "cp949": bArray.append(temp.encode(encoding='cp949',errors='ignore'))#독립실행시 elif self.sysencoding == "UTF-8": bArray.append(temp.encode(encoding='utf-8',errors='ignore'))#pycharm else: bArray.append(temp.encode(encoding='cp949',errors='ignore'))#독립실행시 bArray.append("\n") if( self.process.write(bArray) == -1): print("chlidprocess write error") self.messagelineEdit.clear()
def __init__(self, parent=None): super(Camera, self).__init__(parent) self.ui = Ui_Camera() self.camera = None self.imageCapture = None self.mediaRecorder = None self.isCapturingImage = False self.applicationExiting = False self.imageSettings = QImageEncoderSettings() self.audioSettings = QAudioEncoderSettings() self.videoSettings = QVideoEncoderSettings() self.videoContainerFormat = '' self.ui.setupUi(self) cameraDevice = QByteArray() videoDevicesGroup = QActionGroup(self) videoDevicesGroup.setExclusive(True) #for multiple cameras ata for deviceName in QCamera.availableDevices(): description = QCamera.deviceDescription(deviceName) videoDeviceAction = QAction(description, videoDevicesGroup) videoDeviceAction.setCheckable(True) videoDeviceAction.setData(deviceName) if cameraDevice.isEmpty(): cameraDevice = deviceName videoDeviceAction.setChecked(True) self.ui.menuDevices.addAction(videoDeviceAction) videoDevicesGroup.triggered.connect(self.updateCameraDevice) self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode) self.ui.lockButton.hide() self.setCamera(cameraDevice)
def sql_2_bytearray(self, val): """ sql string representation to QByteArray :param val: {str} sql string representation :return: {QByteArray} """ from PyQt5.QtCore import QByteArray try: elemsList = map(chr, map(int, val.split(','))) except: print 'CONFIGURATIN: COULD NOT CONVERT SETTING TO QBYTEARRAY' elemsList = [] ba = QByteArray() for i in xrange(len(elemsList)): ba.append(elemsList[i]) return ba
def __createSpeedDialPage(self): """ Private method to create the Speeddial page. @return prepared speeddial page (QByteArray) """ if self._speedDialPage is None: htmlFile = QFile(":/html/speeddialPage.html") htmlFile.open(QFile.ReadOnly) html = bytes(htmlFile.readAll()).decode() html = ( html.replace("@FAVICON@", "qrc:icons/ericWeb16.png") .replace("@IMG_PLUS@", "qrc:icons/plus.png") .replace("@IMG_CLOSE@", "qrc:icons/close.png") .replace("@IMG_EDIT@", "qrc:icons/edit.png") .replace("@IMG_RELOAD@", "qrc:icons/reload.png") .replace("@IMG_SETTINGS@", "qrc:icons/setting.png") .replace("@LOADING-IMG@", "qrc:icons/loading.gif") .replace("@BOX-BORDER@", "qrc:icons/box-border-small.png") .replace("@JQUERY@", "qrc:javascript/jquery.js") .replace("@JQUERY-UI@", "qrc:javascript/jquery-ui.js") .replace("@SITE-TITLE@", self.tr("Speed Dial")) .replace("@URL@", self.tr("URL")) .replace("@TITLE@", self.tr("Title")) .replace("@APPLY@", self.tr("Apply")) .replace("@CLOSE@", self.tr("Close")) .replace("@NEW-PAGE@", self.tr("New Page")) .replace("@TITLE-EDIT@", self.tr("Edit")) .replace("@TITLE-REMOVE@", self.tr("Remove")) .replace("@TITLE-RELOAD@", self.tr("Reload")) .replace("@TITLE-WARN@", self.tr("Are you sure to remove this speed dial?")) .replace("@TITLE-FETCHTITLE@", self.tr("Load title from page")) .replace("@SETTINGS-TITLE@", self.tr("Speed Dial Settings")) .replace("@ADD-TITLE@", self.tr("Add New Page")) .replace("@TXT_NRROWS@", self.tr("Maximum pages in a row:")) .replace("@TXT_SDSIZE@", self.tr("Change size of pages:")) ) self._speedDialPage = Utilities.html_uencode(html) import Helpviewer.HelpWindow html = QByteArray(self._speedDialPage.encode("utf-8")) dial = Helpviewer.HelpWindow.HelpWindow.speedDial() html.replace("@INITIAL-SCRIPT@", dial.initialScript().encode("utf-8")) html.replace("@ROW-PAGES@", str(dial.pagesInRow()).encode("utf-8")) html.replace("@SD-SIZE@", str(dial.sdSize()).encode("utf-8")) return html
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), str(info.errorString), str(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 __init__(self, format, parent=None): QIODevice.__init__(self, parent) self.data = QByteArray() # Preserve phase across calls self.phase = 0 # 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, right? 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 checkServiceKeyValidity(self, key, protocol=""): """ Public method to check the validity of the given service key. @param key service key (string) @param protocol protocol used to access VirusTotal (string) """ if protocol == "": urlStr = self.GetFileReportUrl else: urlStr = self.GetFileReportPattern.format(protocol) request = QNetworkRequest(QUrl(urlStr)) request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded") params = QByteArray("key={0}&resource={1}".format( key, self.TestServiceKeyScanID)) import Helpviewer.HelpWindow nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager() reply = nam.post(request, params) reply.finished.connect(self.__checkServiceKeyValidityFinished) self.__replies.append(reply)
def mousePressEvent(self, event): square = self.targetSquare(event.pos()) found = self.findPiece(square) if found == -1: return location = self.pieceLocations[found] pixmap = self.piecePixmaps[found] del self.pieceLocations[found] del self.piecePixmaps[found] del self.pieceRects[found] if location == QPoint(square.x() / 80, square.y() / 80): self.inPlace -= 1 self.update(square) itemData = QByteArray() dataStream = QDataStream(itemData, QIODevice.WriteOnly) dataStream << pixmap << location mimeData = QMimeData() mimeData.setData("image/x-puzzle-piece", itemData) drag = QDrag(self) drag.setMimeData(mimeData) drag.setHotSpot(event.pos() - square.topLeft()) drag.setPixmap(pixmap) if drag.exec_(Qt.MoveAction) != Qt.MoveAction: self.pieceLocations.insert(found, location) self.piecePixmaps.insert(found, pixmap) self.pieceRects.insert(found, square) self.update(self.targetSquare(event.pos())) if location == QPoint(square.x() / 80, square.y() / 80): self.inPlace += 1
def loadSettings(self): settings.beginGroup("MainWindow") state = settings.value("State") if state is not None: self.restoreState(QByteArray(state)) size = settings.value("Size") if size is not None: self.resize(QSize(size)) pos = settings.value("Position") if pos is not None: self.move(QPoint(pos)) splitter = settings.value("Splitter") if splitter is not None: sizes = [int(size) for size in splitter] else: sizes = [6, 1] self.splitter.setSizes(sizes) settings.endGroup()
def restoreSplitterState ( self, data, stateFormat ): if len ( data[ "items" ] ) < 2: print ( "Invalid splitter encountered" ) if len ( data[ "items" ] ) == 0: return None splitter = self.createSplitter () for itemData in data[ "items" ]: itemValue = itemData itemType = itemValue[ "type" ] if itemType == "splitter": w = self.restoreSplitterState ( itemValue, stateFormat ) if w: splitter.addWidget ( w ) elif itemType == "area": area = self.createArea () area.restoreState ( itemValue, stateFormat ) splitter.addWidget ( area.getWidget () ) elif itemType == "rollup": area = self.createArea () area.restoreState ( itemValue, stateFormat ) splitter.addWidget ( area.getWidget () ) else: print ( "Unknown item type" ) if stateFormat == 1: if data[ "state" ]: if not splitter.restoreState ( data[ "state" ] ): print ( "Failed to restore splitter state" ) elif stateFormat == 2: if data[ "state" ]: if not splitter.restoreState ( QByteArray.fromBase64 ( data[ "state" ] ) ): print ( "Failed to restore splitter state" ) else: print ( "Unknown state format" ) return splitter
def createRequest(self, op, request, outgoingData=None): """ Public method to create a request. @param op the operation to be performed (QNetworkAccessManager.Operation) @param request reference to the request object (QNetworkRequest) @param outgoingData reference to an IODevice containing data to be sent (QIODevice) @return reference to the created reply object (QNetworkReply) """ if op == QNetworkAccessManager.GetOperation and \ request.rawHeader(b"X-Eric6-UserLoadAction") == QByteArray(b"1"): urlString = request.url().toString(QUrl.RemoveFragment | QUrl.RemoveQuery) if urlString.endswith(".user.js"): self.downloadScript(request) from Helpviewer.Network.EmptyNetworkReply import \ EmptyNetworkReply return EmptyNetworkReply(self) return None
def show_loading_model(self, path): # Show text self.text_loading = QLabel("<strong>Loading model: </strong>" + path, self.window) self.text_loading.setGeometry(QRect(30, 10, WIDTH - 60, HEIGHT / 4)) self.text_loading.setWordWrap(True) self.text_loading.show() # Display gif SIZE_X = 150 SIZE_Y = 150 self.movie_screen = QLabel(self.window) self.movie_screen.resize(150, 150) self.movie = QMovie("loading.gif", QByteArray(), self.window) self.movie.setCacheMode(QMovie.CacheAll) self.movie.setSpeed(100) self.movie.setScaledSize(QSize(SIZE_X, SIZE_Y)) self.movie_screen.setMovie(self.movie) self.movie_screen.setGeometry(QRect((WIDTH / 2) - (SIZE_X / 2), (HEIGHT / 4) , WIDTH / 2, HEIGHT / 2)) self.movie_screen.show() self.movie.start() # Show cancel button self.cancel_read.move((WIDTH / 2) - 50, HEIGHT - 60) self.cancel_read.show()
def readline(self, size=-1): self._check_open() self._check_readable() if size < 0: qt_size = 0 # no maximum size elif size == 0: return QByteArray() else: qt_size = size + 1 # Qt also counts the NUL byte if self.dev.canReadLine(): buf = self.dev.readLine(qt_size) else: if size < 0: buf = self.dev.readAll() else: buf = self.dev.read(size) if buf is None: raise QtOSError(self.dev) return buf
def setupUi(self): title = QLabel(self.title, self) title.setStyleSheet(''.join( ["QWidget {font: 14pt; color: ", self.textcolor, "}"])) lbl_movie = QLabel("", self) self.movie = QMovie(self.mypath, QByteArray(), self) lbl_movie.setMovie(self.movie) lbl_movie.setAlignment(Qt.AlignCenter) grid_0 = QVBoxLayout() grid_0.addWidget(title) grid_0.addWidget(lbl_movie) self.setLayout(grid_0) self.setWindowFlags(self.windowFlags() | Qt.FramelessWindowHint) self.setAttribute(Qt.WA_TranslucentBackground) self.movie.start() self.setModal(True) self.show()
def generate(self): # Отображение в соответствие с размерами size_pic = min(self.height, self.width) self.label_for_pic.resize(size_pic, size_pic) if not self.message: pxmap = QPixmap() if self.profile.hasPic: pxmap.loadFromData(QByteArray(self.profile.profile_pic)) else: pxmap.loadFromData(no_photo) pxmap = pxmap.scaled(size_pic, size_pic) self.label_for_pic.setPixmap(pxmap) self.label_for_pic.move(self.x, self.y) else: self.label_for_pic.setPixmap(QPixmap()) font = self.label_for_text.font() limit = int(self.height * 0.9) min_size_font = 0 max_size_font = 200 while max_size_font - min_size_font > 1: d = int((min_size_font + max_size_font) / 2) font.setPointSize(d) if QFontMetrics(font).height() > limit: max_size_font = d else: min_size_font = d font.setPointSize(min_size_font) self.label_for_text.setFont(font) self.label_for_text.resize(self.width - size_pic, self.height) if not self.message: self.label_for_text.move(self.x + size_pic + 10, self.y) text = self.profile.inst_profile.username if self.profile.inst_profile.is_private: text += " (private) " self.label_for_text.setText(text) else: self.label_for_text.move(self.x + 4, self.y) self.label_for_text.setText(self.text)
def doRequest(self): print(self.slider.value()) data = QByteArray() data.append("'brightness':") data.append(str(self.slider.value())) #url = "https://httpbin.org/post" url = "https://postman-echo.com/post" req = QNetworkRequest(QUrl(url)) req.setHeader(QNetworkRequest.ContentTypeHeader, '"Content-Type": "application/json; charset=UTF-8"',) self.nam = QNetworkAccessManager() self.nam.finished.connect(self.handleResponse) self.nam.post(req, data)
def sendOneImage(self): if not self.isImageLoaded: self.makeErrMessage("Зарузите избражение") #get pixamp bytes in tiff extension original_img_bytes = QByteArray() original_img_buff = QBuffer(original_img_bytes) original_img_buff.open(QIODevice.WriteOnly) extention = os.path.splitext(self.metafileobj.origFilename)[1][1:] self.cellPixmapUnscaled.save(original_img_buff, extention) original_img_buff.close() #marked image mmarked_img_bytes = QByteArray() marked_img_buff = QBuffer(mmarked_img_bytes) marked_img_buff.open(QIODevice.WriteOnly) marked_img = self.getMarkedImage() marked_img.save(marked_img_buff, extention) marked_img_buff.close() self.metafileobj.setPoints(self.pointsArray) payload = { 'id': str(client_config['id']), 'code': ReqCodes.NEW_IMAGES._value_, 'count': 1, 'data': [{ 'metafile': str(self.metafileobj.getDict()), 'originalImage': str(base64.b64encode(original_img_bytes.data()), 'utf-8'), 'markedImage': str(base64.b64encode(mmarked_img_bytes.data()), 'utf-8') }], 'random_seed': random.randint(0, 999999999) } json_data = json.dumps(payload) try: response = requests.post(client_config['url'], data=json_data, headers=client_config['headers']).json() print(response) except: self.makeErrMessage("Произшала ошибка при взаимодействии с сервером, попробуйте позже") finally: del original_img_bytes del original_img_buff del marked_img del mmarked_img_bytes del marked_img_buff del json_data
def selfSend(self): dane = self.selfSendLineEdit.text() self.senderMonitor.append("Własne: " + dane) self.selfSendLineEdit.clear() array = QByteArray() array.append('(') try: array.append(dane) except UnicodeEncodeError as ex: msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText( "Wystąpił bład podczas próby wysłania\nPodaj inną wartość\nTreść błędu: " + str(ex)) msg.setStandardButtons(QMessageBox.Ok) pom = msg.exec_() monitor.serialWrite(array)
def generate_baselineexcel(self): self.getdata = [] registerdata = QByteArray(GlobalVariable.receivebuffer).data().decode( encodingType) #.data().decode(encodingType) # print("测试后buffer数据",GlobalVariable.receivebuffer) GlobalVariable.receivebuffer = b"" #接收buffer清空 print("串口终端返回的寄存器信息:", registerdata) print("所有寄存器地址:", self.all_register_address) for i in range(len(self.all_register_address)): registeraddress = str(self.all_register_address[i]) reg_search = registeraddress[5:] + ": 0x(\w{16})" pattern = re.compile(reg_search, re.I) # reg_search="reg_rd64 "+registeraddress #临时测试 # print("getdata:",self.getdata) # print("finddata",re.findall(reg_search,registerdata)) searchdata = pattern.findall(registerdata) if searchdata == []: self.getdata.append("Error") else: self.getdata.append(searchdata[0]) print("找到的寄存器值:", self.getdata) # print(self.registerbaseline) self.registerbaseline.loc[:, '实际读出值'] = self.getdata #比较寄存器基线值,并设定颜色 # bin(int(self.getdata[0], scale))[2:].zfill(num_of_bits) #写入excel date = datetime.now().date() #- timedelta(days=1) time = datetime.now().time() choosefilename = self.choosefilename.replace('.xlsx', '') print("临时变量choosefilename", choosefilename) print("self变量choosefilename", self.choosefilename) self.gen_filename = choosefilename + "_%d%02d%02d_%d_%02d_%02d" % ( date.year, date.month, date.day, time.hour, time.minute, time.second) + ".xlsx" self.registerbaseline.to_excel(self.gen_filename, sheet_name='寄存器基线', index=False)
def readSettings(self): settings = QSettings(QSettings.IniFormat, QSettings.UserScope, QCoreApplication.organizationName(), QCoreApplication.applicationName()) geometry = settings.value("geometry", QByteArray()) if geometry.isEmpty(): availableGeometry = QApplication.desktop().availableGeometry(self) self.resize(availableGeometry.width() / 3, availableGeometry.height() / 2) self.move(int(((availableGeometry.width() - self.width()) / 2)), int((availableGeometry.height() - self.height()) / 2)) else: self.restoreGeometry(geometry) self.restoreState(settings.value("state")) self.database = settings.value("database") if not self.database: self.database = "." fs = settings.value("fontSize") if not fs: fs = 10 self.fontSize = int(fs) font = QFont("Sans Serif", self.fontSize) self.app.setFont(font)
def test__onGetRemoteMaterials_withInvalidVersionInLocalMaterial( self, application_mock, container_registry_mock, reply_mock, device_mock): reply_mock.attribute.return_value = 200 reply_mock.readAll.return_value = QByteArray( json.dumps([self._REMOTE_MATERIAL_WHITE]).encode("ascii")) localMaterialWhiteWithInvalidVersion = self._LOCAL_MATERIAL_WHITE.copy( ) localMaterialWhiteWithInvalidVersion["version"] = "one" container_registry_mock.findContainersMetadata.return_value = [ localMaterialWhiteWithInvalidVersion ] application_mock.getContainerRegistry.return_value = container_registry_mock with mock.patch.object(Application, "getInstance", new=lambda: application_mock): job = SendMaterialJob(device_mock) job._onGetRemoteMaterials(reply_mock) self.assertEqual(0, device_mock.createFormPart.call_count)
def test__onGetRemoteMaterials_withNoUpdate(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 device_mock.createFormPart.return_value = "_xXx_" material_manager_mock.getAllMaterialGroups.return_value = self._LOCAL_MATERIAL_WHITE_ALL_RESULT.copy( ) reply_mock.attribute.return_value = 200 reply_mock.readAll.return_value = QByteArray( json.dumps([self._REMOTE_MATERIAL_WHITE]).encode("ascii")) with mock.patch.object(Application, "getInstance", new=lambda: application_mock): job = SendMaterialJob(device_mock) job._onGetRemoteMaterials(reply_mock) self.assertEqual(0, device_mock.createFormPart.call_count) self.assertEqual(0, device_mock.postFormWithParts.call_count)
def suggestionsUrl(self, searchTerm): """ Public method to get a URL ready for suggestions. @param searchTerm term to search for (string) @return URL (QUrl) """ if not self._suggestionsUrlTemplate: return QUrl() ret = QUrl.fromEncoded( QByteArray( self.parseTemplate( searchTerm, self._suggestionsUrlTemplate).encode("utf-8"))) if self.__searchMethod != "post": urlQuery = QUrlQuery(ret) for parameter in self._suggestionsParameters: urlQuery.addQueryItem( parameter[0], self.parseTemplate(searchTerm, parameter[1])) ret.setQuery(urlQuery) return ret
def test__onGetRemoteMaterials_withNoUpdate(self, application_mock, container_registry_mock, reply_mock, device_mock): application_mock.getContainerRegistry.return_value = container_registry_mock device_mock.createFormPart.return_value = "_xXx_" container_registry_mock.findContainersMetadata.return_value = [ self._LOCAL_MATERIAL_WHITE ] reply_mock.attribute.return_value = 200 reply_mock.readAll.return_value = QByteArray( json.dumps([self._REMOTE_MATERIAL_WHITE]).encode("ascii")) with mock.patch.object(Application, "getInstance", new=lambda: application_mock): job = SendMaterialJob(device_mock) job._onGetRemoteMaterials(reply_mock) self.assertEqual(0, device_mock.createFormPart.call_count) self.assertEqual(0, device_mock.postFormWithParts.call_count)
def create_qt_mime_data(data): """ Creates a Qt's MIME data object for data in valid QmxGraph's drag&drop format. :param dict data: Contents of MIME data. :rtype: QMimeData :return: MIME data in QmxGraph format. """ from PyQt5.QtCore import QByteArray, QDataStream, QIODevice, QMimeData item_data = QByteArray() data_stream = QDataStream(item_data, QIODevice.WriteOnly) qgraph_mime = { 'version': qmxgraph.constants.QGRAPH_DD_MIME_VERSION, } qgraph_mime.update(data) data_stream.writeString(json.dumps(qgraph_mime).encode('utf8')) mime_data = QMimeData() mime_data.setData(qmxgraph.constants.QGRAPH_DD_MIME_TYPE, item_data) return mime_data
def mimeData(self, indices): row = -1 for index in indices: # Only generate mime data on command rows if (index.row() < 0 or index.row() >= self.mCommands.size()): return None # Currently only one row at a time is supported for drags # Note: we can get multiple indexes in the same row (different columns) if (row != -1 and index.row() != row): return None row = index.row() command = self.mCommands[row] mimeData = QMimeData() # Text data is used if command is dragged to a text editor or terminal mimeData.setText(command.finalCommand()) # Ptr is used if command is dragged onto another command # We could store the index instead, the only difference would be that if # the item is moved or deleted shomehow during the drag, the ptr approach # will result in a no-op instead of moving the wrong thing. addr = command mimeData.setData(commandMimeType, QByteArray(addr, 4)) return mimeData
def mousePressEvent(self, event): child = self.childAt(event.pos()) if not child: return pixmap = QPixmap(child.pixmap().scaled(QSize(100, 100), Qt.KeepAspectRatio, Qt.SmoothTransformation)) mime_data = QMimeData() mime_data.setData('application/x-dnditemdata', QByteArray()) drag = QDrag(self) drag.setMimeData(mime_data) drag.setPixmap(pixmap) drag.setHotSpot(child.pos() + QPoint(10, 0)) if drag.exec_(Qt.CopyAction | Qt.MoveAction, Qt.CopyAction) == Qt.MoveAction: child.close() else: child.show() child.setPixmap(pixmap)
def generate_gif(self): img: Image imgs: List[Image] # https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#gif select_frames_labels = self.layout_children(self.select_frames_layout) if not select_frames_labels: self.adjust_corgo() return pixmaps = [ i.original_pixmap for i in select_frames_labels if i.highlighted ] height = int(self.height.text()) img, *imgs = [ qpixmap_to_pil(i.scaledToHeight(height)) for i in pixmaps ] delay = int(self.delay.text()) bytesio = io.BytesIO() img.save(fp=bytesio, format='GIF', append_images=imgs, save_all=True, duration=delay, loop=0) self.gif_qbytearray = QByteArray(bytesio.getvalue()) bytesio.close() self.gif_qbuffer = QBuffer(self.gif_qbytearray) gif = QMovie() gif.setDevice(self.gif_qbuffer) gif.setCacheMode(QMovie.CacheAll) print(f'Movie isValid() {gif.isValid()}') self.gif_view.setMovie(gif) gif.start()
def html(self): # QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) html = """ <!DOCTYPE html> <html> <head> </head> <body> """ myPixmap = self.webView.grab() myPixmap = myPixmap.scaledToWidth(600, Qt.SmoothTransformation) myByteArray = QByteArray() myBuffer = QBuffer(myByteArray) myBuffer.open(QIODevice.WriteOnly) myPixmap.save(myBuffer, "PNG") encodedImage = base64.b64encode(myByteArray) html = html + (""" <img src="data:image/png;base64, """) html = html + str(encodedImage)[1:] html = html + (""" <font size> </body> </html> """) # QApplication.restoreOverrideCursor() return (html)
def __getTranslationModels(self): """ Private method to get the translation models supported by IBM Watson Language Translator. """ apiKey = self.plugin.getPreferences("IbmKey") if not apiKey: E5MessageBox.critical( self.__ui, self.tr("Error Getting Available Translations"), self.tr("A valid IBM Watson Language Translator key is" " required.")) return translatorUrl = self.plugin.getPreferences("IbmUrl") if not translatorUrl: E5MessageBox.critical( self.__ui, self.tr("Error Getting Available Translations"), self.tr("A valid IBM Watson Language Translator URL is" " required.")) return params = "?version=2018-05-01" url = QUrl(translatorUrl + "/v3/models" + params) extraHeaders = [ (b"Authorization", b"Basic " + QByteArray(b"apikey:" + apiKey.encode("utf-8")).toBase64()) ] request = QNetworkRequest(url) request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True) if extraHeaders: for name, value in extraHeaders: request.setRawHeader(name, value) reply = self.__networkManager.get(request) reply.finished.connect( lambda: self.__getTranslationModelsReplyFinished(reply)) self.__replies.append(reply)
def fetch(self, url, user_data=None, blocking=False): """ If called with blocking=True, this will block until the image is fetched. If called with blocking=False, this will run the fetch in the background, and emit a signal when done """ self.user_data = user_data self.fetched_url = url # first look in the DB image_data = self.get_image_from_cache(url) if blocking: if image_data is None: try: image_data = urllib.request.urlopen( url, context=self.ssl).read() except Exception as e: print(e) raise ImageFetcherException("Network Error!") # save the image to the cache self.add_image_to_cache(self.fetched_url, image_data) return image_data else: # if we found it, just emit the signal asap if image_data is not None: self.fetchComplete.emit(QByteArray(image_data), self.user_data) return # didn't find it. look online self.nam = QNetworkAccessManager() self.nam.finished.connect(self.finishRequest) self.nam.get(QNetworkRequest(QUrl(url)))
def __init__(self): super().__init__() uic.loadUi("UI/MainWindow.ui", self) self.searchButton.clicked.connect(self.crawler_search) self.movie = QMovie("loading.gif", QByteArray(), self.lblLogo) self.movie.setCacheMode(QMovie.CacheAll) self.movie.setSpeed(100) self.lblLogo.setMovie(self.movie) self.dw = None alerts = open("alerts.txt", "r").readlines() for line in alerts: print(line[:-1]) self.add_item(self.newListWidget, line) with open('history\history.txt', 'r') as fl: dict = json.load(fl) for key in dict.keys(): s = "" for c in dict[key]: s += c + "\n" self.add_item(self.webListWidget, key) self.show()
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 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)