コード例 #1
0
 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
コード例 #2
0
    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()
コード例 #3
0
ファイル: AdBlockSubscription.py プロジェクト: Darriall/eric
 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()
コード例 #4
0
ファイル: server.py プロジェクト: iu7-2014/networks
    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:]
コード例 #5
0
ファイル: Connection.py プロジェクト: testmana2/test
 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
コード例 #6
0
ファイル: audiooutput.py プロジェクト: Axel-Erfurt/pyqt5
    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()
コード例 #7
0
ファイル: Connection.py プロジェクト: Darriall/eric
 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)
コード例 #8
0
ファイル: Connection.py プロジェクト: Darriall/eric
 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()
コード例 #9
0
    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()
コード例 #10
0
ファイル: Connection.py プロジェクト: Darriall/eric
 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)
コード例 #11
0
 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()
コード例 #12
0
ファイル: audiooutput.py プロジェクト: Axel-Erfurt/pyqt5
    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)
コード例 #13
0
ファイル: fortuneserver.py プロジェクト: Axel-Erfurt/pyqt5
    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()
コード例 #14
0
ファイル: mapreader.py プロジェクト: theall/Python-Tiled
    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()
コード例 #15
0
 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()
コード例 #16
0
    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())
コード例 #17
0
ファイル: Connection.py プロジェクト: testmana2/test
 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()
コード例 #18
0
ファイル: Connection.py プロジェクト: testmana2/test
 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)
コード例 #19
0
ファイル: CookiesDialog.py プロジェクト: testmana2/test
 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()
コード例 #20
0
ファイル: Tabview.py プロジェクト: paulmadore/Eric-IDE
 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)
コード例 #21
0
 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'))
コード例 #22
0
    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()
コード例 #23
0
ファイル: openedfilemodel.py プロジェクト: rapgro/enki
    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
コード例 #24
0
ファイル: builder.py プロジェクト: doudz/pyqtdeploy
    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())
コード例 #25
0
ファイル: server.py プロジェクト: ericlin1001/RemoteControl
 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;
コード例 #26
0
 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()
コード例 #27
0
ファイル: PyPreviewer.py プロジェクト: louisraccoon/PyStudy
    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()
コード例 #28
0
    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)
コード例 #29
0
    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
コード例 #30
0
ファイル: EricAccessHandler.py プロジェクト: pycom/EricShort
 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
コード例 #31
0
ファイル: qwebpage.py プロジェクト: Patterns-AI/splash-1
    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
コード例 #32
0
    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
コード例 #33
0
    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)
コード例 #34
0
    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
コード例 #35
0
ファイル: main.py プロジェクト: hf6391964/crispy
    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()
コード例 #36
0
	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
コード例 #37
0
    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
コード例 #38
0
	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()
コード例 #39
0
ファイル: qtutils.py プロジェクト: melody40/monorepo
    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
コード例 #40
0
    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()
コード例 #41
0
ファイル: i.py プロジェクト: ssssssssss10/dsadsadsadavcad
    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)
コード例 #42
0
    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)
コード例 #43
0
    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
コード例 #44
0
ファイル: SendTest.py プロジェクト: spyderhexapod/Python
 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)
コード例 #45
0
    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)
コード例 #46
0
 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)
コード例 #47
0
    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)
コード例 #48
0
    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)
コード例 #49
0
    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
コード例 #50
0
    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)
コード例 #51
0
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
コード例 #52
0
    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
コード例 #53
0
ファイル: extended_pyGISS.py プロジェクト: qdhqf/pyGISS
    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)
コード例 #54
0
ファイル: main.py プロジェクト: AzisK/giffer
    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()
コード例 #55
0
ファイル: code_Web.py プロジェクト: trinkner/lapwing
    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)
コード例 #56
0
    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)
コード例 #57
0
    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)))
コード例 #58
0
    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()
コード例 #59
0
    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)
コード例 #60
0
    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)