Exemplo n.º 1
0
 def dropMimeData(self, data, action, row, column, parent):
     """
     Public method to accept the mime data of a drop action.
     
     @param data reference to the mime data (QMimeData)
     @param action drop action requested (Qt.DropAction)
     @param row row number (integer)
     @param column column number (integer)
     @param parent index of the parent node (QModelIndex)
     @return flag indicating successful acceptance of the data (boolean)
     """
     if action == Qt.IgnoreAction:
         return True
     
     if column > 0:
         return False
     
     parentNode = self.node(parent)
     
     if not data.hasFormat(self.MIMETYPE):
         if not data.hasUrls():
             return False
         
         from .BookmarkNode import BookmarkNode
         node = BookmarkNode(BookmarkNode.Bookmark, parentNode)
         node.url = bytes(data.urls()[0].toEncoded()).decode()
         
         if data.hasText():
             node.title = data.text()
         else:
             node.title = node.url
         
         self.__bookmarksManager.addBookmark(parentNode, node, row)
         return True
     
     ba = data.data(self.MIMETYPE)
     stream = QDataStream(ba, QIODevice.ReadOnly)
     if stream.atEnd():
         return False
     
     undoStack = self.__bookmarksManager.undoRedoStack()
     undoStack.beginMacro("Move Bookmarks")
     
     from .XbelReader import XbelReader
     while not stream.atEnd():
         encodedData = QByteArray()
         stream >> encodedData
         buffer = QBuffer(encodedData)
         buffer.open(QIODevice.ReadOnly)
         
         reader = XbelReader()
         rootNode = reader.read(buffer)
         for bookmarkNode in rootNode.children():
             rootNode.remove(bookmarkNode)
             row = max(0, row)
             self.__bookmarksManager.addBookmark(
                 parentNode, bookmarkNode, row)
             self.__endMacro = True
     
     return True
Exemplo n.º 2
0
    def SaveTools(self):
        try:
            if os.path.isfile(self.filepath):
                QFile.remove(self.file)

            self.file.open(QIODevice.WriteOnly)
            datastream = QDataStream(self.file)
            count = self.MyToolsBars.topLevelItemCount()
            datastream.writeUInt32(count)

            for i in range(0, count):
                item = self.MyToolsBars.topLevelItem(i)
                item.write(datastream)
                self.bar = None
                self.CreateToolBar(item)
                self.save_item(item, datastream)

            self.hasChanged = False
            self.file.close()
            # We restore the list of Qgis tools.
            state = self.saveWidgetState(self.ToolBars) 
            self.PopulateQgisTools()
            self.loadWidgetState(self.ToolBars, state)

            self.iface.messageBar().pushMessage("Info: ", "Save correctly.", level=QGis.Info, duration=3)
            self.rename_btn.setEnabled(False)
            self.delete_btn.setEnabled(False)
            self.restore = {}

        except Exception:
            self.iface.messageBar().pushMessage("Error: ", "Error save tools ", level=QGis.Critical, duration=3)
        return
Exemplo n.º 3
0
    def dropMimeData(self, data, action, row, column, parent):
        if not data.hasFormat('image/x-puzzle-piece'):
            return False

        if action == Qt.IgnoreAction:
            return True

        if column > 0:
            return False

        if not parent.isValid():
            if row < 0:
                endRow = len(self.pixmaps)
            else:
                endRow = min(row, len(self.pixmaps))
        else:
            endRow = parent.row()

        encodedData = data.data('image/x-puzzle-piece')
        stream = QDataStream(encodedData, QIODevice.ReadOnly)

        while not stream.atEnd():
            pixmap = QPixmap()
            location = QPoint()
            stream >> pixmap >> location

            self.beginInsertRows(QModelIndex(), endRow, endRow)
            self.pixmaps.insert(endRow, pixmap)
            self.locations.insert(endRow, location)
            self.endInsertRows()

            endRow += 1

        return True
Exemplo n.º 4
0
    def __load(self):
        """
        Private method to load the saved history entries from disk.
        """
        historyFile = QFile(self.getFileName())
        if not historyFile.exists():
            return
        if not historyFile.open(QIODevice.ReadOnly):
            E5MessageBox.warning(
                None,
                self.tr("Loading History"),
                self.tr("""<p>Unable to open history file <b>{0}</b>.<br/>""" """Reason: {1}</p>""").format(
                    historyFile.fileName, historyFile.errorString()
                ),
            )
            return

        history = []

        # double check, that the history file is sorted as it is read
        needToSort = False
        lastInsertedItem = HistoryEntry()
        data = QByteArray(historyFile.readAll())
        stream = QDataStream(data, QIODevice.ReadOnly)
        stream.setVersion(QDataStream.Qt_4_6)
        while not stream.atEnd():
            ver = stream.readUInt32()
            if ver != HISTORY_VERSION:
                continue
            itm = HistoryEntry()
            itm.url = Utilities.readStringFromStream(stream)
            stream >> itm.dateTime
            itm.title = Utilities.readStringFromStream(stream)

            if not itm.dateTime.isValid():
                continue

            if itm == lastInsertedItem:
                if not lastInsertedItem.title and len(history) > 0:
                    history[0].title = itm.title
                continue

            if not needToSort and history and lastInsertedItem < itm:
                needToSort = True

            history.insert(0, itm)
            lastInsertedItem = itm
        historyFile.close()

        if needToSort:
            history.sort()

        self.setHistory(history, True)

        # if the history had to be sorted, rewrite the history sorted
        if needToSort:
            self.__lastSavedUrl = ""
            self.__saveTimer.changeOccurred()
Exemplo n.º 5
0
 def send(self, argv):
     data = QByteArray()
     out = QDataStream(data, QIODevice.WriteOnly)
     out.setVersion(QDataStream.Qt_5_0)
     out.writeQVariant(argv)
     self._log_("writes: %s", str(data))
     self.socket.write(data)
     self.socket.flush()
     self.socket.disconnectFromServer()
Exemplo n.º 6
0
    def mimeData(self, indexes):
        mimeData = QMimeData()
        encodedData = QByteArray()
        stream = QDataStream(encodedData, QIODevice.WriteOnly)
        for index in indexes:
            if (index.isValid()):
                stream.writeInt(self.tileIndexAt(index))

        mimeData.setData(TILES_MIMETYPE, encodedData)
        return mimeData
Exemplo n.º 7
0
 def receiveData(self):
     logger.info("waits for data")
     ins = QDataStream(self.conn)
     ins.setVersion(QDataStream.Qt_5_0)
     if ins.atEnd():
         return
     argv = ins.readQVariant()
     logger.info("reads '%s'", str(argv))
     # Must be setted up on 'show' action. Move from beginning to appropriate.
     action.search_dst_window()
     self.dataReceived.emit(argv)
Exemplo n.º 8
0
def check_qdatastream(stream: QDataStream) -> None:
    """Check the status of a QDataStream and raise OSError if it's not ok."""
    status_to_str = {
        QDataStream.Ok: "The data stream is operating normally.",
        QDataStream.ReadPastEnd: ("The data stream has read past the end of "
                                  "the data in the underlying device."),
        QDataStream.ReadCorruptData: "The data stream has read corrupt data.",
        QDataStream.WriteFailed: ("The data stream cannot write to the "
                                  "underlying device."),
    }
    if stream.status() != QDataStream.Ok:
        raise OSError(status_to_str[stream.status()])
Exemplo n.º 9
0
def test_check_qdatastream(status, raising, message):
    """Test check_qdatastream.

    Args:
        status: The status to set on the QDataStream we test with.
        raising: Whether check_qdatastream is expected to raise OSError.
        message: The expected exception string.
    """
    stream = QDataStream()
    stream.setStatus(status)
    if raising:
        with pytest.raises(OSError, match=message):
            qtutils.check_qdatastream(stream)
    else:
        qtutils.check_qdatastream(stream)
Exemplo n.º 10
0
    def listMyToolBars(self):
        self.MyToolsBars.clear()

        self.file.open(QIODevice.ReadOnly)
        datastream = QDataStream(self.file)
        num_childs = datastream.readUInt32()
        for i in range(0, num_childs):
            self.MyToolsBars.setEnabled(True)
            self.My_expand.setEnabled(True)
            self.My_Collapse.setEnabled(True)
            item = QTreeWidgetItem()
            item.read(datastream)
            self.MyToolsBars.insertTopLevelItem(i, item)
            self.restore_item(datastream, item)
        self.file.close()
Exemplo n.º 11
0
    def MyToolBars(self):
        ''' Create user toolbars '''
        self.file.open(QIODevice.ReadOnly)
        datastream = QDataStream(self.file)
        num_childs = datastream.readUInt32()
        for _ in range(0, num_childs):
            item = QTreeWidgetItem()
            item.read(datastream)
            self.bar = None
            DelToolBarIface(item.text(0), self.iface)
            self.bar = self.iface.mainWindow().addToolBar(item.text(0))
            self.restore_item(datastream, item)

        self.file.close()
        return
Exemplo n.º 12
0
def serialize(items):
    """Serialize a list of QWebHistoryItems to a data stream.

    Args:
        items: An iterable of WebHistoryItems.

    Return:
        A (stream, data, user_data) tuple.
            stream: The reset QDataStream.
            data: The QByteArray with the raw data.
            user_data: A list with each item's user data.

    Warning:
        If 'data' goes out of scope, reading from 'stream' will result in a
        segfault!
    """
    data = QByteArray()
    stream = QDataStream(data, QIODevice.ReadWrite)
    user_data = []

    current_idx = None

    for i, item in enumerate(items):
        if item.active:
            if current_idx is not None:
                raise ValueError("Multiple active items ({} and {}) "
                                 "found!".format(current_idx, i))
            else:
                current_idx = i

    if items:
        if current_idx is None:
            raise ValueError("No active item found!")
    else:
        current_idx = 0

    if qtutils.is_qtwebkit_ng():
        _serialize_ng(items, current_idx, stream)
    else:
        _serialize_old(items, current_idx, stream)

    user_data += [item.user_data for item in items]

    stream.device().reset()
    qtutils.check_qdatastream(stream)
    return stream, data, user_data
Exemplo n.º 13
0
def serialize(items):
    """Serialize a list of QWebHistoryItems to a data stream.

    Args:
        items: An iterable of WebHistoryItems.

    Return:
        A (stream, data, user_data) tuple.
            stream: The reset QDataStream.
            data: The QByteArray with the raw data.
            cur_user_data: The user data for the current item or None.

    Warning:
        If 'data' goes out of scope, reading from 'stream' will result in a
        segfault!
    """
    data = QByteArray()
    stream = QDataStream(data, QIODevice.ReadWrite)
    cur_user_data = None

    current_idx = None

    for i, item in enumerate(items):
        if item.active:
            if current_idx is not None:
                raise ValueError("Multiple active items ({} and {}) "
                                 "found!".format(current_idx, i))
            current_idx = i
            cur_user_data = item.user_data

    if items:
        if current_idx is None:
            raise ValueError("No active item found!")
    else:
        current_idx = -1

    ### src/core/web_contents_adapter.cpp serializeNavigationHistory
    # kHistoryStreamVersion
    stream.writeInt(HISTORY_STREAM_VERSION)
    # count
    stream.writeInt(len(items))
    # currentIndex
    stream.writeInt(current_idx)

    for item in items:
        _serialize_item(item, stream)

    stream.device().reset()
    qtutils.check_qdatastream(stream)
    return stream, data, cur_user_data
Exemplo n.º 14
0
 def loadCookies(self, cookies):
     """
     Public method to restore the saved cookies.
     
     @param cookies byte array containing the saved cookies (QByteArray)
     @return list of cookies
     """
     if cookies.isEmpty():
         return []
     
     cookiesList = []
     data = QByteArray(cookies)
     stream = QDataStream(data, QIODevice.ReadOnly)
     stream.setVersion(QDataStream.Qt_4_6)
     
     version = stream.readUInt16()
     if version != self.JAR_VERSION:
         return []
     
     stream.readUInt32()  # number of cookies
     
     rawCookie = QByteArray()
     while not stream.atEnd():
         stream >> rawCookie
         newCookies = QNetworkCookie.parseCookies(rawCookie)
         for newCookie in newCookies:
             cookiesList.append(newCookie)
     
     return cookiesList
Exemplo n.º 15
0
def serialize(items):
    """Serialize a list of QWebHistoryItems to a data stream.

    Args:
        items: An iterable of WebHistoryItems.

    Return:
        A (stream, data, user_data) tuple.
            stream: The reset QDataStream.
            data: The QByteArray with the raw data.
            user_data: A list with each item's user data.

    Warning:
        If 'data' goes out of scope, reading from 'stream' will result in a
        segfault!
    """
    data = QByteArray()
    stream = QDataStream(data, QIODevice.ReadWrite)
    user_data = []

    current_idx = None

    for i, item in enumerate(items):
        if item.active:
            if current_idx is not None:
                raise ValueError("Multiple active items ({} and {}) "
                                 "found!".format(current_idx, i))
            else:
                current_idx = i

    if items:
        if current_idx is None:
            raise ValueError("No active item found!")
    else:
        current_idx = 0

    ### Source/WebKit/qt/Api/qwebhistory.cpp operator<<
    stream.writeInt(HISTORY_STREAM_VERSION)
    stream.writeInt(len(items))
    stream.writeInt(current_idx)

    for i, item in enumerate(items):
        _serialize_item(i, item, stream)
        user_data.append(item.user_data)

    stream.device().reset()
    qtutils.check_qdatastream(stream)
    return stream, data, user_data
Exemplo n.º 16
0
    def load(self, device):
        self.m_frames = []

        stream = QDataStream(device)
        self.m_name = stream.readQString()
        frameCount = stream.readInt()

        for i in range(frameCount):
            nodeCount = stream.readInt()

            frame = Frame()
            frame.setNodeCount(nodeCount)

            for j in range(nodeCount):
                pos = QPointF()
                stream >> pos

                frame.setNodePos(j, pos)

            self.m_frames.append(frame)
Exemplo n.º 17
0
 def restoreState(self, state):
     """
     Public method to restore the state of the sidebar.
     
     @param state byte array containing the saved state (QByteArray)
     @return flag indicating success (boolean)
     """
     if state.isEmpty():
         return False
     
     if self.__orientation in [E5SideBar.North, E5SideBar.South]:
         minSize = self.layout.minimumSize().height()
         maxSize = self.maximumHeight()
     else:
         minSize = self.layout.minimumSize().width()
         maxSize = self.maximumWidth()
     
     data = QByteArray(state)
     stream = QDataStream(data, QIODevice.ReadOnly)
     stream.setVersion(QDataStream.Qt_4_6)
     stream.readUInt16()  # version
     minimized = stream.readBool()
     
     if minimized and not self.__minimized:
         self.shrink()
     
     stream >> self.__bigSize
     self.__minSize = max(stream.readUInt16(), minSize)
     self.__maxSize = max(stream.readUInt16(), maxSize)
     count = stream.readUInt16()
     self.splitterSizes = []
     for i in range(count):
         self.splitterSizes.append(stream.readUInt16())
     
     self.__autoHide = stream.readBool()
     self.__autoHideButton.setChecked(not self.__autoHide)
     
     if not minimized:
         self.expand()
     
     return True
Exemplo n.º 18
0
    def save(self, device):
        stream = QDataStream(device)
        stream.writeQString(self.m_name)
        stream.writeInt(len(self.m_frames))

        for frame in self.m_frames:
            stream.writeInt(frame.nodeCount())

            for i in range(frame.nodeCount()):
                stream << frame.nodePos(i)
Exemplo n.º 19
0
    def readFortune(self):
        instr = QDataStream(self.tcpSocket)
        instr.setVersion(QDataStream.Qt_4_0)

        if self.blockSize == 0:
            if self.tcpSocket.bytesAvailable() < 2:
                return

            self.blockSize = instr.readUInt16()

        if self.tcpSocket.bytesAvailable() < self.blockSize:
            return

        nextFortune = instr.readQString()
        if nextFortune == self.currentFortune:
            QTimer.singleShot(0, self.requestNewFortune)
            return

        self.currentFortune = nextFortune
        self.statusLabel.setText(self.currentFortune)
        self.getFortuneButton.setEnabled(True)
Exemplo n.º 20
0
    def sendFrame(self):
        block = QByteArray()
        out = QDataStream(block, QIODevice.WriteOnly)
        out.setVersion(QDataStream.Qt_5_0)

        frame = huffman.encode(self.cam.capture())

        out.writeInt32(len(frame))
        out.writeRawData(frame)

        self.client.write(block)
Exemplo n.º 21
0
    def run(self):
        self.mutex.lock()
        serverName = self.hostName
        serverPort = self.port
        self.mutex.unlock()

        while not self.quit:
            Timeout = 5 * 1000

            socket = QTcpSocket()
            socket.connectToHost(serverName, serverPort)

            if not socket.waitForConnected(Timeout):
                self.error.emit(socket.error(), socket.errorString())
                return

            while socket.bytesAvailable() < 2:
                if not socket.waitForReadyRead(Timeout):
                    self.error.emit(socket.error(), socket.errorString())
                    return 

            instr = QDataStream(socket)
            instr.setVersion(QDataStream.Qt_4_0)
            blockSize = instr.readUInt16()

            while socket.bytesAvailable() < blockSize:
                if not socket.waitForReadyRead(Timeout):
                    self.error.emit(socket.error(), socket.errorString())
                    return

            self.mutex.lock()
            fortune = instr.readQString()
            self.newFortune.emit(fortune)

            self.cond.wait(self.mutex)
            serverName = self.hostName
            serverPort = self.port
            self.mutex.unlock()
Exemplo n.º 22
0
    def write(self, map, fileName):
        collisionLayer = None
        for layer in map.layers():
            if layer.name().lower() == "collision":
                tileLayer = layer.asTileLayer()
                if tileLayer:
                    if (collisionLayer) :
                        self.mError = self.tr("Multiple collision layers found!")
                        return False
                    
                    collisionLayer = tileLayer

        
        if (not collisionLayer) :
            self.mError = self.tr("No collision layer found!")
            return False
        
        file = QSaveFile(fileName)
        if (not file.open(QIODevice.WriteOnly)) :
            self.mError = self.tr("Could not open file for writing.")
            return False
        
        width = collisionLayer.width()
        height = collisionLayer.height()
        stream = QDataStream(file)
        stream.setByteOrder(QDataStream.LittleEndian)
        stream.writeInt16(width&0xffff)
        stream.writeInt16(height&0xffff)
        for y in range(0, height):
            for x in range(0, width):
                tile = collisionLayer.cellAt(x, y).tile
                stream.writeInt8(int(tile and tile.id()> 0)&0xff)

        if not file.commit():
            self.mError = file.errorString()
            return False

        return True
Exemplo n.º 23
0
 def saveCookies(self, cookiesList):
     """
     Public method to save the cookies.
     
     @param cookiesList list of cookies to be saved
     @return saved cookies as a byte array (QByteArray)
     """
     data = QByteArray()
     stream = QDataStream(data, QIODevice.WriteOnly)
     stream.setVersion(QDataStream.Qt_4_6)
     stream.writeUInt16(self.JAR_VERSION)
     stream.writeUInt32(len(cookiesList))
     for cookie in cookiesList:
         stream << cookie.toRawForm()
     
     return data
Exemplo n.º 24
0
 def decodeMimeData(self, the_bytearray: QByteArray):
     """see:
     https://wiki.python.org/moin/PyQt/Handling%20Qt's%20internal%20item%20MIME%20type
     http://doc.qt.io/qt-5.5/datastreamformat.html
     """
     data = {}
     ds = QDataStream(the_bytearray)
     while not ds.atEnd():
         item = []
         row = ds.readInt32()
         column = ds.readInt32()
         number_of_items = ds.readInt32()
         # print("rc:", row, column, number_of_items)
         for i in range(number_of_items):
             key = ds.readInt32()
             value = QVariant()
             ds >> value
             item.append((value.value(), Qt.ItemDataRole(key)))
         data[(row, column)] = item
     return data
Exemplo n.º 25
0
    def send(self, command, *args):
        self._logger.info("GC<<: {}:{}".format(command, args))
        ds = QDataStream(self._socket)
        ds.setByteOrder(QDataStream.LittleEndian)

        # Header
        ds.writeUInt32(len(command))
        ds.writeRawData(command.encode())

        # Chunks
        ds.writeUInt32(len(args))

        for chunk in args:
            ds.writeRawData(self._packLuaVal(chunk))
Exemplo n.º 26
0
 def revive(self, buff):
     buff.load(self.url)
     stream = QDataStream(self.history_data, QIODevice.ReadOnly)
     stream >> buff.history()
     self.all.remove(self)
Exemplo n.º 27
0
    def readRequest(self):
        stream = QDataStream(self)
        stream.setVersion(QDataStream.Qt_5_7)
        #print(self.bytesAvailable())
        if self.nextBlockSize == 0:
            if self.bytesAvailable() < SIZEOF_UINT16:
                return
            self.nextBlockSize = stream.readUInt16()
            #print(self.nextBlockSize)
        if self.bytesAvailable() < self.nextBlockSize:
            return

        action = ""
        room = ""
        date = QDate()
        action=stream.readQString()
        if action in ("BOOK", "UNBOOK", "BOOKINGSONDATE",
                      "BOOKINGSFORROOM"):
            room=stream.readQString()
            stream >> date            
            bookings = Bookings.get(date.toPyDate())
            uroom = str(room)
        if action == "BOOK":
            if bookings is None:
                bookings = Bookings[date.toPyDate()]
            if len(bookings) < MAX_BOOKINGS_PER_DAY:
                if uroom in bookings:
                    self.sendError("Cannot accept duplicate booking")
                else:
                    bisect.insort(bookings, uroom)
                    self.sendReply(action, room, date)
            else:
                self.sendError("{0} is fully booked".format(date.toString(Qt.ISODate)))
        elif action == "UNBOOK":
            if bookings is None or uroom not in bookings:
                self.sendError("Cannot unbook nonexistent booking")
            else:
                bookings.remove(uroom)
                self.sendReply(action, room, date)
        elif action == "BOOKINGSONDATE":
            bookings = Bookings.get(date.toPyDate())
            if bookings is not None:
                self.sendReply(action, ", ".join(bookings), date)
            else:
                self.sendError("there are no rooms booked on {0}".format(date.toString(Qt.ISODate)))
        elif action == "BOOKINGSFORROOM":
            dates = []
            for date, bookings in Bookings.items():
                if room in bookings:
                    dates.append(date)
            if dates:
                dates.sort()
                reply = QByteArray()
                stream = QDataStream(reply, QIODevice.WriteOnly)
                stream.setVersion(QDataStream.Qt_5_7)
                stream.writeUInt16(0)
                stream.writeQString(action)
                stream.writeQString(room)
                stream.writeInt32(len(dates))
                for date in dates:
                    stream << QDate(date)
                stream.device().seek(0)
                stream.writeUInt16(reply.size() - SIZEOF_UINT16)
                self.write(reply)
            else:
                self.sendError("room %1 is not booked".format(room))
        else:
            self.sendError("Unrecognized request")
        printBookings()
Exemplo n.º 28
0
    def save(self):
        """
        Public slot to save the history entries to disk.
        """
        historyFile = QFile(self.getFileName())
        if not historyFile.exists():
            self.__lastSavedUrl = ""

        saveAll = self.__lastSavedUrl == ""
        first = len(self.__history) - 1
        if not saveAll:
            # find the first one to save
            for index in range(len(self.__history)):
                if self.__history[index].url == self.__lastSavedUrl:
                    first = index - 1
                    break
        if first == len(self.__history) - 1:
            saveAll = True

        if saveAll:
            # use a temporary file when saving everything
            f = QTemporaryFile()
            f.setAutoRemove(False)
            opened = f.open()
        else:
            f = historyFile
            opened = f.open(QIODevice.Append)

        if not opened:
            E5MessageBox.warning(
                None,
                self.tr("Saving History"),
                self.tr("""<p>Unable to open history file <b>{0}</b>.<br/>""" """Reason: {1}</p>""").format(
                    f.fileName(), f.errorString()
                ),
            )
            return

        for index in range(first, -1, -1):
            data = QByteArray()
            stream = QDataStream(data, QIODevice.WriteOnly)
            stream.setVersion(QDataStream.Qt_4_6)
            itm = self.__history[index]
            stream.writeUInt32(HISTORY_VERSION)
            stream.writeString(itm.url.encode("utf-8"))
            stream << itm.dateTime
            stream.writeString(itm.title.encode("utf-8"))
            f.write(data)

        f.close()
        if saveAll:
            if historyFile.exists() and not historyFile.remove():
                E5MessageBox.warning(
                    None,
                    self.tr("Saving History"),
                    self.tr("""<p>Error removing old history file <b>{0}</b>.""" """<br/>Reason: {1}</p>""").format(
                        historyFile.fileName(), historyFile.errorString()
                    ),
                )
            if not f.copy(historyFile.fileName()):
                E5MessageBox.warning(
                    None,
                    self.tr("Saving History"),
                    self.tr(
                        """<p>Error moving new history file over old one """ """(<b>{0}</b>).<br/>Reason: {1}</p>"""
                    ).format(historyFile.fileName(), f.errorString()),
                )
        self.historySaved.emit()
        try:
            self.__lastSavedUrl = self.__history[0].url
        except IndexError:
            self.__lastSavedUrl = ""
Exemplo n.º 29
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()
Exemplo n.º 30
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()
Exemplo n.º 31
0
    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()
Exemplo n.º 32
0
    def dealCommunication(self):
        # Get a QTcpSocket from the QTcpServer
        clientConnection = self.tcpServer.nextPendingConnection()

        # instantiate a QByteArray
        block = QByteArray()

        # QDataStream class provides serialization of binary data to a QIODevice
        out = QDataStream(block, QIODevice.ReadWrite)

        # We are using PyQt5 so set the QDataStream version accordingly.
        out.setVersion(QDataStream.Qt_5_0)
        out.writeUInt16(0)

        # this is the message we will send it could come from a widget.
        message = "ok"

        # get a byte array of the message encoded appropriately.
        message = bytes(message, encoding='ascii')

        # now use the QDataStream and write the byte array to it.
        out.writeString(message)
        out.device().seek(0)
        out.writeUInt16(block.size() - 2)

        # wait until the connection is ready to read
        clientConnection.waitForReadyRead()

        # read incomming data
        instr = clientConnection.readAll()

        # in this case we print to the terminal could update text of a widget if we wanted.
        # data = str(instr, encoding='ascii')
        data = instr
        data = np.frombuffer(data, dtype=np.uint)
        print("Get ", data, " from client")

        # get the connection ready for clean up
        clientConnection.disconnected.connect(clientConnection.deleteLater)

        # now send the QByteArray.
        # clientConnection.write(block)

        # now disconnect connection.
        clientConnection.disconnectFromHost()
        print("Disconnection")
Exemplo n.º 33
0
 def paste(self):
     if self.copiedItem.isEmpty():
         return
     stream = QDataStream(self.copiedItem, QIODevice.ReadOnly)
     self.readItemFromStream(stream, self.pasteOffset)
     self.pasteOffset += 5
Exemplo n.º 34
0
 def save(self):
     exception = None
     fh = None
     try:
         if not self.filename:
             raise IOError("no filename specified for saving")
         fh = QFile(self.filename)
         if not fh.open(QIODevice.WriteOnly):
             raise IOError(fh.errorString())
         stream = QDataStream(fh)
         stream.writeInt32(MAGIC_NUMBER)
         stream.writeInt16(FILE_VERSION)
         stream.setVersion(QDataStream.Qt_5_6)
         for ship in self.ships:
             stream.writeQString(ship.name)
             stream.writeQString(ship.owner)
             stream.writeQString(ship.country)
             stream.writeQString(ship.description)
             stream.writeInt32(ship.teu)
         self.dirty = False
     except IOError as e:
         exception = e
     finally:
         if fh is not None:
             fh.close()
         if exception is not None:
             raise exception
Exemplo n.º 35
0
 def load(self):
     exception = None
     fh = None
     try:
         if not self.filename:
             raise IOError("no filename specified for loading")
         fh = QFile(self.filename)
         if not fh.open(QIODevice.ReadOnly):
             raise IOError(fh.errorString())
         stream = QDataStream(fh)
         magic = stream.readInt32()
         if magic != MAGIC_NUMBER:
             raise IOError("unrecognized file type")
         fileVersion = stream.readInt16()
         if fileVersion != FILE_VERSION:
             raise IOError("unrecognized file type version")
         stream.setVersion(QDataStream.Qt_5_6)
         self.ships = []
         while not stream.atEnd():
             name = stream.readQString()
             owner = stream.readQString()
             country = stream.readQString()
             description = stream.readQString()
             teu = stream.readInt32()
             self.ships.append(Ship(name, owner, country, teu, description))
             self.owners.add(owner)
             self.countries.add(country)
         self.dirty = False
     except IOError as e:
         exception = e
     finally:
         if fh is not None:
             fh.close()
         if exception is not None:
             raise exception
Exemplo n.º 36
0
 def restoreState(self, state, version=0):
     """
     Public method to restore the state of the toolbar manager.
     
     @param state byte array containing the saved state (QByteArray)
     @param version version number stored with the data (integer)
     @return flag indicating success (boolean)
     """
     if state.isEmpty():
         return False
     
     data = QByteArray(state)
     stream = QDataStream(data, QIODevice.ReadOnly)
     stream.setVersion(QDataStream.Qt_4_6)
     marker = stream.readUInt16()
     vers = stream.readUInt16()
     if marker != E5ToolBarManager.VersionMarker or vers != version:
         return False
     
     tmarker = stream.readUInt16()
     if tmarker != E5ToolBarManager.ToolBarMarker:
         return False
     
     toolBarCount = stream.readUInt16()
     for i in range(toolBarCount):
         objectName = Utilities.readStringFromStream(stream)
         actionCount = stream.readUInt16()
         actions = []
         for j in range(actionCount):
             actionName = Utilities.readStringFromStream(stream)
             if actionName:
                 action = self.__findAction(actionName)
                 if action is not None:
                     actions.append(action)
             else:
                 actions.append(None)
         toolBar = self.__findDefaultToolBar(objectName)
         if toolBar is not None:
             self.setToolBar(toolBar, actions)
     
     cmarker = stream.readUInt16()
     if cmarker != E5ToolBarManager.CustomToolBarMarker:
         return False
     
     oldCustomToolBars = self.__customToolBars[:]
     
     toolBarCount = stream.readUInt16()
     for i in range(toolBarCount):
         objectName = Utilities.readStringFromStream(stream)
         toolBarTitle = Utilities.readStringFromStream(stream)
         actionCount = stream.readUInt16()
         actions = []
         for j in range(actionCount):
             actionName = Utilities.readStringFromStream(stream)
             if actionName:
                 action = self.__findAction(actionName)
                 if action is not None:
                     actions.append(action)
             else:
                 actions.append(None)
         toolBar = self.__toolBarByName(objectName)
         if toolBar is not None:
             toolBar.setWindowTitle(toolBarTitle)
             oldCustomToolBars.remove(toolBar)
         else:
             toolBar = self.createToolBar(toolBarTitle, objectName)
         if toolBar is not None:
             toolBar.setObjectName(objectName)
             self.setToolBar(toolBar, actions)
     
     for tb in oldCustomToolBars:
         self.deleteToolBar(tb)
     
     return True
Exemplo n.º 37
0
    def read(self, fileName):
        # Read data.
        file = QFile(fileName)
        if (not file.open(QIODevice.ReadOnly)):
            self.mError = self.tr("Cannot open Replica Island map file!")
            return 0

        _in = QDataStream(file)
        _in.setByteOrder(QDataStream.LittleEndian)
        _in.setFloatingPointPrecision(QDataStream.SinglePrecision)
        # Parse file header.
        mapSignature = _in.readUInt8()
        layerCount = _in.readUInt8()
        backgroundIndex = _in.readUInt8()
        if (_in.status() == QDataStream.ReadPastEnd or mapSignature != 96):
            self.mError = self.tr("Can't parse file header!")
            return 0

        # Create our map, setting width and height to 0 until we load a layer.
        map = Map(Map.Orientation.Orthogonal, 0, 0, 32, 32)
        map.setProperty("background_index", QString.number(backgroundIndex))
        # Load our Tilesets.
        typeTilesets = QVector()
        tileIndexTilesets = QVector()

        self.loadTilesetsFromResources(map, typeTilesets, tileIndexTilesets)
        # Load each of our layers.
        for i in range(layerCount):
            # Parse layer header.
            _type = _in.readUInt8()
            tileIndex = _in.readUInt8()
            scrollSpeed = _in.readFloat()
            levelSignature = _in.readUInt8()
            width = _in.readUInt32()
            height = _in.readUInt32()
            if (_in.status() == QDataStream.ReadPastEnd
                    or levelSignature != 42):
                self.mError = self.tr("Can't parse layer header!")
                return 0

            # Make sure our width and height are consistent.
            if (map.width() == 0):
                map.setWidth(width)
            if (map.height() == 0):
                map.setHeight(height)
            if (map.width() != width or map.height() != height):
                self.mError = self.tr("Inconsistent layer sizes!")
                return 0

            # Create a layer object.
            layer = TileLayer(self.layerTypeToName(_type), 0, 0, width, height)
            layer.setProperty("type", QString.number(_type))
            layer.setProperty("tile_index", QString.number(tileIndex))
            layer.setProperty("scroll_speed", QString.number(scrollSpeed, 'f'))
            map.addLayer(layer)
            # Look up the tileset for this layer.
            tileset = tilesetForLayer(_type, tileIndex, typeTilesets,
                                      tileIndexTilesets)
            # Read our tile data all at once.
            #tileData = QByteArray(width*height, b'\x00')
            bytesNeeded = width * height
            tileData = _in.readRawData(bytesNeeded)
            bytesRead = len(tileData)
            if (bytesRead != bytesNeeded):
                self.mError = self.tr("File ended in middle of layer!")
                return 0

            i = 0
            # Add the tiles to our layer.
            for y in range(0, height):
                for x in range(0, width):
                    tile_id = tileData[i] & 0xff
                    i += 1
                    if (tile_id != 255):
                        tile = tileset.tileAt(tile_id)
                        layer.setCell(x, y, Cell(tile))

        # Make sure we read the entire *.bin file.
        if (_in.status() != QDataStream.Ok or not _in.atEnd()):
            self.mError = self.tr("Unexpected data at end of file!")
            return 0

        return map
Exemplo n.º 38
0
def deserialize(data, obj):
    """Deserialize an object from a QByteArray."""
    stream = QDataStream(data, QIODevice.ReadOnly)
    stream >> obj  # pylint: disable=pointless-statement
    _check_qdatastream(stream)
Exemplo n.º 39
0
    def run(self):
        socket = QTcpSocket()
        if not socket.setSocketDescriptor(self.socketId):
            self.error.connect(socket.error)
            return
        while socket.state() == QAbstractSocket.ConnectedState:
            nextBlockSize = 0
            stream = QDataStream(socket)
            if socket.waitForReadyRead() and \
                    socket.bytesAvailable() >= SIZEOF_UINT16:
                nextBlockSize = stream.readUInt16()
            else:
                rec_text = ' 无法正常读取客户端的请求!'
                rec_text = my_cur_time() + rec_text
                try:
                    self.lock.lockForWrite()
                    self.recordSignal.sendSignal.emit(rec_text)
                finally:
                    self.lock.unlock()
                return

            if socket.bytesAvailable() < nextBlockSize:
                if not socket.waitForReadyRead(5000) or \
                        socket.bytesAvailable() < nextBlockSize:
                    rec_text = ' 无法正常读取客户端的数据!'
                    rec_text = my_cur_time() + rec_text
                    try:
                        self.lock.lockForWrite()
                        self.recordSignal.sendSignal.emit(rec_text)
                    finally:
                        self.lock.unlock()
                    return

            # MT4交易账号
            account_number = stream.readQString()
            if re.match(r'^[1-9]\d+$', account_number):
                # 交易指令
                trade_instruction = stream.readQString()
                rec_text = my_cur_time() + ' 已读取到来自 {0} 的交易指令:{1}'.format(account_number, trade_instruction)
                try:
                    self.lock.lockForWrite()
                    self.recordSignal.sendSignal.emit(rec_text)
                finally:
                    self.lock.unlock()

                try:
                    self.lock.lockForRead()
                    directory = account_dir.get(account_number, 'None')
                finally:
                    self.lock.unlock()

                if directory == 'None':
                    reply_text = 'None'
                    rec_text = my_cur_time() + ' 交易账号 {0} 没有获得交易服务器的授权!'.format(account_number)
                    try:
                        self.lock.lockForWrite()
                        self.recordSignal.sendSignal.emit(rec_text)
                    finally:
                        self.lock.unlock()
                else:
                    file_path = directory
                    # 将交易指令存到相应账号MT4的Files文件夹里
                    symbols = ['EURUSD', 'GBPUSD', 'XAUUSD', 'USDJPY']
                    for symbol in symbols:
                        if trade_instruction.find(symbol) >= 0:
                            trade_symbol = symbol
                    # 检查交易品种的子文件夹是否存在,不存在就新建相应的子文件夹
                    if os.path.exists(file_path + '\\' + trade_symbol) == False:
                        os.mkdir(file_path + '\\' + trade_symbol)
                    file_path = file_path + '\\' + trade_symbol + '\\'
                    # 将指令存到对应的子文件夹里
                    file_name = file_path + 'trade_signal.txt'
                    with open(file_name, 'w') as file_object:
                        file_object.write(trade_instruction)

                    reply_text = trade_instruction

                try:
                    self.lock.lockForWrite()
                    rec_text = my_cur_time() + ' 已将交易指令存到相应的MT4的Files文件夹里!'
                    self.recordSignal.sendSignal.emit(rec_text)
                finally:
                    self.lock.unlock()

                self.my_sendReply(socket, reply_text)
                socket.waitForDisconnected()
            else:
                rec_text = ' 接收到非正常的数据,可能是网络攻击!'
                rec_text = my_cur_time() + rec_text
                try:
                    self.lock.lockForWrite()
                    self.recordSignal.sendSignal.emit(rec_text)
                finally:
                    self.lock.unlock()
Exemplo n.º 40
0
 def sendReply(self, action, room, date):
     reply = QByteArray()
     stream = QDataStream(reply, QIODevice.WriteOnly)
     stream.setVersion(QDataStream.Qt_5_7)
     stream.writeUInt16(0)
     stream.writeQString(action)
     stream.writeQString(room)
     stream<<date        
     stream.device().seek(0)
     stream.writeUInt16(reply.size() - SIZEOF_UINT16)
     self.write(reply)
Exemplo n.º 41
0
 def issueRequest(self, action, room, date):
     self.request = QByteArray()
     stream = QDataStream(self.request, QIODevice.WriteOnly)
     stream.setVersion(QDataStream.Qt_5_7)
     stream.writeUInt16(0)
     stream.writeQString(action)
     stream.writeQString(room)
     stream << date
     stream.device().seek(0)
     stream.writeUInt16(self.request.size() - SIZEOF_UINT16)
     self.updateUi()
     if self.socket.isOpen():
         self.socket.close()
     self.responseLabel.setText("Connecting to server...")
     self.socket.connectToHost("localhost", PORT)
Exemplo n.º 42
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()
Exemplo n.º 43
0
def producer_repetitive_scope_test(
        path,
        repetitions=1,
        delay=0):  # producer with repetitive writes to shared memory
    import time
    from PyQt5.QtGui import QPainter, QPixmap, QColor, QFont, QPen
    from PyQt5.QtCore import Qt
    from prodcon_ipc.producer_ipc import ProducerIPC

    # FIXME: this is still buggy because when the images are not read sufficiently fast from the consumer (which
    #       only (?) happens in the non-async Python consumer), image data gets corrupted (may be overwritten by the
    #       producer?! but this SHOULD be prevented by the system semaphores and the producer/consumer sync...)

    producer_ipc = ProducerIPC(UNIQUE_SHARED_MEMORY_NAME,
                               SHARED_MEMORY_KEY_FILE)
    for i in range(repetitions):
        image = QImage()
        if not image.load(path):
            logzero.logger.error("Unable to load image " + path)
            sys.exit(1)
        else:
            pm = QPixmap.fromImage(
                image)  # .convertToFormat(QImage.Format_RGB32)

            p = QPainter()
            p.begin(pm)
            p.setPen(QPen(Qt.yellow))
            p.setFont(QFont("Times", 20, QFont.Bold))
            p.drawText(pm.rect(), Qt.AlignCenter,
                       str(i + 1) + " of " + str(repetitions))
            p.end()

            image = pm.toImage()

            # Load the image:
            buf = QBuffer()
            buf.open(QBuffer.ReadWrite)
            out = QDataStream(buf)
            out << image

            try:
                avail_size, mem_data = producer_ipc.begin(buf.size())
                if avail_size < buf.size():
                    logzero.logger.warn("Couldn't get enough memory!")
            except RuntimeError as err:
                logzero.logger.error(str(err))
                sys.exit(2)

            # Copy image data from buf into shared memory area:
            error_str = None
            try:
                mem_data[:avail_size] = buf.data().data()[:avail_size]
            except Exception as err:
                logzero.logger.error(str(err))

            try:
                producer_ipc.end()
            except RuntimeError as err:
                logzero.logger.error(str(err))
                sys.exit(3)
            if delay > 0:
                time.sleep(delay)
        logzero.logger.debug("Iteration " + str(i + 1) + " of " +
                             str(repetitions) + " completed.")

    logzero.logger.info("All okay")
    # IMPORTANT: The object should NOT go out of scope until the consumer has read the data, so (also) dont call:
    # del producer_ipc
    # ...or let the app exit right away. That's why we do here:
    try:
        input(
            "Press Enter to exit but let the consumer read the image first...")
    except:
        sys.stdout.write("\n")
        pass
    sys.exit(0)
Exemplo n.º 44
0
 def dealCommunication(self):
     # Get a QTcpSocket from the QTcpServer
     clientConnection = self.tcpServer.nextPendingConnection()
     # instantiate a QByteArray
     block = QByteArray()
     # QDataStream class provides serialization of binary data to a QIODevice
     out = QDataStream(block, QIODevice.ReadWrite)
     # We are using PyQt5 so set the QDataStream version accordingly.
     out.setVersion(QDataStream.Qt_5_0)
     out.writeUInt16(0)
     # this is the message we will send it could come from a widget.
     message = "ACK!"
     # get a byte array of the message encoded appropriately.
     message = bytes(message, encoding='ascii')
     # now use the QDataStream and write the byte array to it.
     out.writeString(message)
     out.device().seek(0)
     out.writeUInt16(block.size() - 2)
     # wait until the connection is ready to read
     while True:
         clientConnection.waitForReadyRead()
         # read incomming data
         instr = clientConnection.readAll()
         # in this case we print to the terminal could update text of a widget if we wanted.
         data = str(instr, encoding='ascii')
         print(data)
         if data.strip() == "END":
             break
         clientConnection.write(block)
     clientConnection.disconnected.connect(clientConnection.deleteLater)
     clientConnection.disconnectFromHost()
Exemplo n.º 45
0
class Client(QDialog):
    def __init__(self, parent: QWidget = None):
        super().__init__(parent)

        self._in = QDataStream()
        self.blockSize = 0

        self.currentFortune = ""

        self.hostLineEdit = QLineEdit("fortune")
        self.getFortuneButton = QPushButton(self.tr("Get Fortune"))
        self.statusLabel = QLabel(
            self.
            tr("This examples requires that you run the Local Fortune Server example as well."
               ))
        self.socket = QLocalSocket(self)

        self.setWindowFlags(self.windowFlags()
                            & ~Qt.WindowContextHelpButtonHint)
        hostLabel = QLabel(self.tr("&Server name:"))
        hostLabel.setBuddy(self.hostLineEdit)

        self.statusLabel.setWordWrap(True)

        self.getFortuneButton.setDefault(True)
        quitButton = QPushButton(self.tr("Quit"))

        buttonBox = QDialogButtonBox()
        buttonBox.addButton(self.getFortuneButton, QDialogButtonBox.ActionRole)
        buttonBox.addButton(quitButton, QDialogButtonBox.RejectRole)

        self._in.setDevice(self.socket)
        self._in.setVersion(QDataStream.Qt_5_10)

        self.hostLineEdit.textChanged.connect(self.enableGetFortuneButton)

        self.getFortuneButton.clicked.connect(self.requestNewFortune)
        quitButton.clicked.connect(self.close)
        self.socket.readyRead.connect(self.readFortune)
        self.socket.errorOccurred.connect(self.displayError)

        mainLayout = QGridLayout(self)
        mainLayout.addWidget(hostLabel, 0, 0)
        mainLayout.addWidget(self.hostLineEdit, 0, 1)
        mainLayout.addWidget(self.statusLabel, 2, 0, 1, 2)
        mainLayout.addWidget(buttonBox, 3, 0, 1, 2)

        self.setWindowTitle(QGuiApplication.applicationDisplayName())
        self.hostLineEdit.setFocus()

    @pyqtSlot()
    def requestNewFortune(self):
        self.getFortuneButton.setEnabled(False)
        self.blockSize = 0
        self.socket.abort()
        self.socket.connectToServer(self.hostLineEdit.text())

    @pyqtSlot()
    def readFortune(self):
        if self.blockSize == 0:
            # Relies on the fact that QDataStream serializes a quint32 into
            # sizeof(quint32) bytes
            if self.socket.bytesAvailable() < 4:  #  (int)sizeof(quint32))
                return
            self.blockSize = self._in.readUInt32()

        if self.socket.bytesAvailable() < self.blockSize or self._in.atEnd():
            return

        nextFortune = ""
        nextFortune = self._in.readQString()

        if nextFortune == self.currentFortune:
            QTimer.singleShot(0, self.requestNewFortune)
            return

        currentFortune = nextFortune
        self.statusLabel.setText(currentFortune)
        self.getFortuneButton.setEnabled(True)

    @pyqtSlot(QLocalSocket.LocalSocketError)
    def displayError(self, socketError):
        if socketError == QLocalSocket.ServerNotFoundError:

            QMessageBox.information(
                self,
                self.tr("Local Fortune Client"),
                self.tr("The host was not found. Please make sure "
                        "that the server is running and that the "
                        "server name is correct."),
            )
        elif socketError == QLocalSocket.ConnectionRefusedError:
            QMessageBox.information(
                self,
                self.tr("Local Fortune Client"),
                self.tr("The connection was refused by the peer. "
                        "Make sure the fortune server is running, "
                        "and check that the server name is correct."),
            )
        elif socketError == QLocalSocket.PeerClosedError:
            return
        else:
            QMessageBox.information(
                self,
                self.tr("Local Fortune Client"),
                self.tr("The following error occurred: %s." %
                        (self.socket.errorString())),
            )

        self.getFortuneButton.setEnabled(True)

    @pyqtSlot()
    def enableGetFortuneButton(self):
        self.getFortuneButton.setEnabled(bool(self.hostLineEdit.ext()))
Exemplo n.º 46
0
    def readMessage(self):
        """
        读取文件数据
        """
        receiver = QDataStream(self.tcpClient)
        receiver.setVersion(QDataStream.Qt_5_4)

        if self.bytesReceive <= 2:
            if self.tcpClient.bytesAvailable() >= 2 and self.fileNameSize == 0:
                self.TotalBytes = receiver.readInt64()
                self.fileNameSize = receiver.readInt64()
                self.bytesReceive += 2
        # 当接收的字节数小于等2,同时套接字返回等待读取的传入字节数大于2而文件名大小不确定时,传输的总大小receiver.readInt64(),文件名大小是receiver.readInt64()。

            if self.tcpClient.bytesAvailable() >= self.fileNameSize and self.fileNameSize != 0:
                self.fileName = receiver.readQString()
                self.bytesReceive += self.fileNameSize
                # 当我们接收的字节数一定后,我们读取文件名receiver.readQString(),自然收到的字节数要加上文件名大小。
                if not(self.localFile.open(QFile.WriteOnly)):
                    QMessageBox.warning(self, "应用程序", "无法读取文件 {}:\n {}".format(self.fileName, self.localFile.errorString()))
                    return
                    # 要是写文件存在问题就报错。
            else:
                return

        if self.bytesReceive < self.TotalBytes:
            self.bytesReceive += self.tcpClient.bytesAvailable()
            inBlock = self.tcpClient.readAll()
            self.localFile.write(inBlock)
            inBlock.resize(0)

        useTime = self.time.elapsed() / 1000
        
        bytesReceived = self.bytesReceive / (1024*1024)
        speed = bytesReceived / useTime
        total = self.TotalBytes / (1024*1024)
        left = (total - bytesReceived) / speed

        if bytesReceived < 0.01:
            # 要是我们收到的文件太小了,我们设定成KB为单位
            bytesReceived = self.bytesReceive / 1024
            speed = bytesReceived / useTime / 1024
            total = self.TotalBytes / 1024
            if left > 0:
                msg = "已接收 {0:.2f} KB ({1:.2f}KB/s)\n共{2:.2f}KB.已用时:{3:.1f}秒\n估计剩余时间:{4:.1f}秒".format(bytesReceived, speed, total, useTime, left)
            else:
                msg = "已接收 {0:.2f} KB ({1:.2f}KB/s)\n共{2:.2f}KB.已用时:{3:.1f}秒\n".format(bytesReceived, speed, total, useTime)

        else:
            # 要是文件比较大,我们设定成MB为单位
            if left > 0:
                msg = "已接收 {0:.2f} MB ({1:.2f}MB/s)\n共{2:.2f}MB.已用时:{3:.1f}秒\n估计剩余时间:{4:.1f}秒".format(bytesReceived, speed, total, useTime, left)
            else:
                msg = "已接收 {0:.2f} MB ({1:.2f}MB/s)\n共{2:.2f}MB.已用时:{3:.1f}秒\n".format(bytesReceived, speed, total, useTime)

        self.progressBar.setMaximum(total)
        self.progressBar.setValue(bytesReceived)

        self.tcpClientStatuslabel.setText(msg)
        
        if self.bytesReceive == self.TotalBytes:
            self.localFile.close()
            self.tcpClient.close()
            self.tcpClientStatuslabel.setText("接收文件{}完毕".format(self.fileName))
            self.tcpClientBtn.setEnabled(False)
Exemplo n.º 47
0
 def saveState(self):
     """
     Public method to save the state of the sidebar.
     
     @return saved state as a byte array (QByteArray)
     """
     if len(self.splitterSizes) == 0:
         if self.splitter:
             self.splitterSizes = self.splitter.sizes()
         self.__bigSize = self.size()
         if self.__orientation in [E5SideBar.North, E5SideBar.South]:
             self.__minSize = self.minimumSizeHint().height()
             self.__maxSize = self.maximumHeight()
         else:
             self.__minSize = self.minimumSizeHint().width()
             self.__maxSize = self.maximumWidth()
     
     data = QByteArray()
     stream = QDataStream(data, QIODevice.WriteOnly)
     stream.setVersion(QDataStream.Qt_4_6)
     
     stream.writeUInt16(self.Version)
     stream.writeBool(self.__minimized)
     stream << self.__bigSize
     stream.writeUInt16(self.__minSize)
     stream.writeUInt16(self.__maxSize)
     stream.writeUInt16(len(self.splitterSizes))
     for size in self.splitterSizes:
         stream.writeUInt16(size)
     stream.writeBool(self.__autoHide)
     
     return data
Exemplo n.º 48
0
    def from_buffer(cls, buff):
        data = QByteArray()
        stream = QDataStream(data, QIODevice.WriteOnly)
        stream << buff.history()

        return cls(buff.url(), buff.title(), buff.icon(), data)
Exemplo n.º 49
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()
Exemplo n.º 50
0
 def restoreState(self, state):
     """
     Public method to restore the state of the sidebar.
     
     @param state byte array containing the saved state (QByteArray)
     @return flag indicating success (boolean)
     """
     if state.isEmpty():
         return False
     
     if self.__orientation in [E5SideBar.North, E5SideBar.South]:
         minSize = self.layout.minimumSize().height()
         maxSize = self.maximumHeight()
     else:
         minSize = self.layout.minimumSize().width()
         maxSize = self.maximumWidth()
     
     data = QByteArray(state)
     stream = QDataStream(data, QIODevice.ReadOnly)
     stream.setVersion(QDataStream.Qt_4_6)
     stream.readUInt16()  # version
     minimized = stream.readBool()
     
     if minimized and not self.__minimized:
         self.shrink()
     
     stream >> self.__bigSize
     self.__minSize = max(stream.readUInt16(), minSize)
     self.__maxSize = max(stream.readUInt16(), maxSize)
     count = stream.readUInt16()
     self.splitterSizes = []
     for i in range(count):
         self.splitterSizes.append(stream.readUInt16())
     
     self.__autoHide = stream.readBool()
     self.__autoHideButton.setChecked(not self.__autoHide)
     
     if not minimized:
         self.expand()
     
     return True
Exemplo n.º 51
0
 def sendError(self, msg):
     reply = QByteArray()
     stream = QDataStream(reply, QIODevice.WriteOnly)
     stream.setVersion(QDataStream.Qt_5_7)
     stream.writeUInt16(0)      
     stream.writeQString("ERROR")
     stream.writeQString(msg)        
     stream.device().seek(0)
     stream.writeUInt16(reply.size() - SIZEOF_UINT16)
     self.write(reply)
Exemplo n.º 52
0
 def save(self):
     """
     Public slot to save the history entries to disk.
     """
     historyFile = QFile(self.getFileName())
     if not historyFile.exists():
         self.__lastSavedUrl = ""
     
     saveAll = self.__lastSavedUrl == ""
     first = len(self.__history) - 1
     if not saveAll:
         # find the first one to save
         for index in range(len(self.__history)):
             if self.__history[index].url == self.__lastSavedUrl:
                 first = index - 1
                 break
     if first == len(self.__history) - 1:
         saveAll = True
     
     if saveAll:
         # use a temporary file when saving everything
         f = QTemporaryFile()
         f.setAutoRemove(False)
         opened = f.open()
     else:
         f = historyFile
         opened = f.open(QIODevice.Append)
     
     if not opened:
         E5MessageBox.warning(
             None,
             self.tr("Saving History"),
             self.tr(
                 """<p>Unable to open history file <b>{0}</b>.<br/>"""
                 """Reason: {1}</p>""")
             .format(f.fileName(), f.errorString()))
         return
     
     for index in range(first, -1, -1):
         data = QByteArray()
         stream = QDataStream(data, QIODevice.WriteOnly)
         stream.setVersion(QDataStream.Qt_4_6)
         itm = self.__history[index]
         stream.writeUInt32(HISTORY_VERSION)
         stream.writeString(itm.url.encode())
         stream << itm.dateTime
         stream.writeString(itm.title.encode('utf-8'))
         f.write(data)
     
     f.close()
     if saveAll:
         if historyFile.exists() and not historyFile.remove():
             E5MessageBox.warning(
                 None,
                 self.tr("Saving History"),
                 self.tr(
                     """<p>Error removing old history file <b>{0}</b>."""
                     """<br/>Reason: {1}</p>""")
                 .format(historyFile.fileName(),
                         historyFile.errorString()))
         if not f.copy(historyFile.fileName()):
             E5MessageBox.warning(
                 None,
                 self.tr("Saving History"),
                 self.tr(
                     """<p>Error moving new history file over old one """
                     """(<b>{0}</b>).<br/>Reason: {1}</p>""")
                 .format(historyFile.fileName(), f.errorString()))
     self.historySaved.emit()
     try:
         self.__lastSavedUrl = self.__history[0].url
     except IndexError:
         self.__lastSavedUrl = ""
Exemplo n.º 53
0
 def messageFromBoard(self):
     instr = QDataStream(self.board_connection)
     instr.setVersion(QDataStream.Qt_5_0)
     if self.board_connection.bytesAvailable() > 0:
         self._log(str(self.board_connection.readAll()))
Exemplo n.º 54
0
    def sendMessage(self):
        """
        发送文件
        """
        self.serverSendBtn.setEnabled(False)
        self.clientConnection = self.tcpServer.nextPendingConnection()
        self.clientConnection.bytesWritten.connect(self.updateClientProgress)
        self.serverStatuslabel.setText("开始传送文件 {} !".format(self.theFileName))

        self.localFile = QFile(self.fileName)
        if not (self.localFile.open(QFile.ReadOnly)):
            errorMsg = "无法读取文件 {}:\n {}".format(self.fileName,
                                                self.localFile.errorString())
            QMessageBox.warning(self, "应用程序", errorMsg)
            return

        self.serverCloseBtn.setText("取消")

        self.totalBytes = self.localFile.size()  #单位:字节
        sendOut = QDataStream(self.outBlock, QIODevice.WriteOnly)
        sendOut.setVersion(QDataStream.Qt_5_4)
        self.time.start()
        currentFile = self.fileName.split("/")[-1]
        sendOut.writeInt64(0)
        sendOut.writeInt64(0)
        sendOut.writeQString(currentFile)
        self.totalBytes += self.outBlock.size()
        sendOut.device().seek(0)
        sendOut.writeInt64(self.totalBytes)
        sendOut.writeInt64(self.outBlock.size() - 2)
        self.bytesToWrite = self.totalBytes - self.clientConnection.write(
            self.outBlock)
        self.outBlock.resize(0)
Exemplo n.º 55
0
    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()
Exemplo n.º 56
0
def deserialize(data: QByteArray, obj: QObject) -> None:
    """Deserialize an object from a QByteArray."""
    stream = QDataStream(data, QIODevice.ReadOnly)
    deserialize_stream(stream, obj)
Exemplo n.º 57
0
 def saveState(self, version=0):
     """
     Public method to save the state of the toolbar manager.
     
     @param version version number stored with the data (integer)
     @return saved state as a byte array (QByteArray)
     """
     data = QByteArray()
     stream = QDataStream(data, QIODevice.WriteOnly)
     stream.setVersion(QDataStream.Qt_4_6)
     stream.writeUInt16(E5ToolBarManager.VersionMarker)
     stream.writeUInt16(version)
     
     # save default toolbars
     stream.writeUInt16(E5ToolBarManager.ToolBarMarker)
     stream.writeUInt16(len(self.__defaultToolBars))
     for tbID in self.__defaultToolBars:
         tb = self.__allToolBars[tbID]
         if tb.objectName():
             stream.writeString(tb.objectName().encode("utf-8"))
         else:
             stream.writeString(tb.windowTitle().encode("utf-8"))
         stream.writeUInt16(len(self.__toolBars[tbID]))
         for action in self.__toolBars[tbID]:
             if action is not None:
                 if action.objectName():
                     stream.writeString(action.objectName().encode("utf-8"))
                 else:
                     stream.writeString(action.text().encode("utf-8"))
             else:
                 stream.writeString("".encode("utf-8"))
     
     # save the custom toolbars
     stream.writeUInt16(E5ToolBarManager.CustomToolBarMarker)
     stream.writeUInt16(len(self.__toolBars) - len(self.__defaultToolBars))
     for tbID in self.__toolBars:
         if tbID not in self.__defaultToolBars:
             tb = self.__allToolBars[tbID]
             stream.writeString(tb.objectName().encode("utf-8"))
             stream.writeString(tb.windowTitle().encode("utf-8"))
             stream.writeUInt16(len(self.__toolBars[tbID]))
             for action in self.__toolBars[tbID]:
                 if action is not None:
                     if action.objectName():
                         stream.writeString(action.objectName()
                                            .encode("utf-8"))
                     else:
                         stream.writeString(action.text().encode("utf-8"))
                 else:
                     stream.writeString("".encode("utf-8"))
     
     return data
Exemplo n.º 58
0
def serialize(obj: _QtSerializableType) -> QByteArray:
    """Serialize an object into a QByteArray."""
    data = QByteArray()
    stream = QDataStream(data, QIODevice.WriteOnly)
    serialize_stream(stream, obj)
    return data
Exemplo n.º 59
0
class QmyMainWindow(QMainWindow): 
   def __init__(self, parent=None):
      super().__init__(parent)    #调用父类构造函数,创建窗体
      self.ui=Ui_MainWindow()     #创建UI对象
      self.ui.setupUi(self)       #构造UI界面

      self.ui.groupBox.setEnabled(False)
      self.ui.actSaveALL.setEnabled(False)
      self.ui.actReadALL.setEnabled(False)

      self.setWindowTitle("二进制文件流化读写")
      
      self.__testFileName=""   #测试用文件的文件名
      
##  ==============自定义功能函数============
   def __iniWrite(self):     ##初始化写文件操作
      self.fileDevice=QFile(self.__testFileName)    #创建文件对象
      if  not self.fileDevice.open(QIODevice.WriteOnly):
         del self.fileDevice    #删除对象
         return False

      self.fileStream=QDataStream(self.fileDevice)   #流对象

      self.fileStream.setVersion(QDataStream.Qt_5_12)   #设置版本号,写入和读取的版本号要兼容
      if self.ui.radio_BigEndian.isChecked():
         self.fileStream.setByteOrder(QDataStream.BigEndian)
      else:
         self.fileStream.setByteOrder(QDataStream.LittleEndian)

      ##必须要设置精度,float和double都按照这个精度
      precision=QDataStream.DoublePrecision
      if self.ui.radio_Single.isChecked(): 
         precision=QDataStream.SinglePrecision
      self.fileStream.setFloatingPointPrecision(precision)
      return True

   def __delFileStream(self): ##结束写文件操作
      self.fileDevice.close()
      del self.fileStream
      del self.fileDevice


   def __iniRead(self):  ##开始读文件操作
      if not QFile.exists(self.__testFileName):
         QMessageBox.critical(self,"错误","文件不存在")
         return False
      
      self.fileDevice=QFile(self.__testFileName)    #创建文件对象
      if  not self.fileDevice.open(QIODevice.ReadOnly):
         del self.fileDevice    #删除对象
         return False

      self.fileStream=QDataStream(self.fileDevice)
      self.fileStream.setVersion(QDataStream.Qt_5_12)   #设置流版本号,写入和读取的版本号要兼容

      if self.ui.radio_BigEndian.isChecked():
         self.fileStream.setByteOrder(QDataStream.BigEndian)
      else:
         self.fileStream.setByteOrder(QDataStream.LittleEndian)

      ##必须要设置精度,float和double都按照这个精度
      precision=QDataStream.DoublePrecision
      if self.ui.radio_Single.isChecked(): 
         precision=QDataStream.SinglePrecision
      self.fileStream.setFloatingPointPrecision(precision)

      return True
          
##  ==========由connectSlotsByName() 自动连接的槽函数==================
   
   @pyqtSlot()    ##选择测试用文件
   def on_btnFile_clicked(self):  
      curPath=QDir.currentPath()       #当前目录
      title="选择文件"                 #对话框标题
      filt="流数据文件(*.stream)"     #文件过滤器
      fileName,flt=QFileDialog.getSaveFileName(self,title,curPath,filt)
      if (fileName == ""):
         return

      self.__testFileName=fileName     #测试用文件
      self.ui.editFilename.setText(fileName)
      self.ui.groupBox.setEnabled(True)
      self.ui.actSaveALL.setEnabled(True)
      self.ui.actReadALL.setEnabled(True)


   @pyqtSlot()   ##写  int8
   def on_btnInt8_Write_clicked(self):  
      Value=self.ui.spin_Int8.value() #Python int
      if self.__iniWrite():
         try:
            self.fileStream.writeInt8(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeInt8()出现错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  int8
   def on_btnInt8_Read_clicked(self):  
      if self.__iniRead():
         Value=self.fileStream.readInt8()
         self.ui.edit_Int8.setText("%d"%Value)
         self.__delFileStream()

   @pyqtSlot()   ##写  uint8
   def on_btnUInt8_Write_clicked(self):  
      Value=self.ui.spin_UInt8.value()
      if self.__iniWrite(): 
         try:
            self.fileStream.writeUInt8(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeUInt8()出现错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  uint8
   def on_btnUInt8_Read_clicked(self):  
      if self.__iniRead():
         Value=self.fileStream.readUInt8()
         self.ui.edit_UInt8.setText("%d"%Value)
         self.__delFileStream()


   @pyqtSlot()    ##写int16
   def on_btnInt16_Write_clicked(self):  
      Value=self.ui.spin_Int16.value()       #Python的int
      if self.__iniWrite():
         try:
            self.fileStream.writeInt16(Value)   #以int16类型写入文件
         except Exception as e:
            QMessageBox.critical(self, "writeInt16()发生错误", str(e))
         finally:
            self.__delFileStream()
##            print("finally被执行")
          
   @pyqtSlot()    ##读 int16
   def on_btnInt16_Read_clicked(self):  
      if self.__iniRead():
         try:
            Value=self.fileStream.readInt16() 
            self.ui.edit_Int16.setText("%d"%Value)
         except Exception as e:
            QMessageBox.critical(self, "readInt16()发生错误", str(e))
         finally:
            self.__delFileStream()
##            print("finally被执行")
            
            
   @pyqtSlot()   ##写  uint16
   def on_btnUInt16_Write_clicked(self):  
      Value=self.ui.spin_UInt16.value()
      if self.__iniWrite():
         try:
            self.fileStream.writeUInt16(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeUInt16()发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  uint16
   def on_btnUIn16_Read_clicked(self):  
      if self.__iniRead():
         Value=self.fileStream.readUInt16()
         self.ui.edit_UInt16.setText("%d"%Value)
         self.__delFileStream()

         
   @pyqtSlot()   ##写  int32
   def on_btnInt32_Write_clicked(self):  
      Value=self.ui.spin_Int32.value()
      if self.__iniWrite():
         try:
            self.fileStream.writeInt32(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeInt32()发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  int32
   def on_btnInt32_Read_clicked(self):  
      if self.__iniRead():
         Value=self.fileStream.readInt32()
         self.ui.edit_Int32.setText("%d"%Value)
         self.__delFileStream()


   @pyqtSlot()   ##写  int64
   def on_btnInt64_Write_clicked(self):  
      Value=self.ui.spin_Int64.value()
      if self.__iniWrite():
         try:
            self.fileStream.writeInt64(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeInt64()发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  int64
   def on_btnInt64_Read_clicked(self):  
      if self.__iniRead():
         Value=self.fileStream.readInt64()
         self.ui.edit_Int64.setText("%d"%Value)
         self.__delFileStream()


   @pyqtSlot()   ##写  int
   def on_btnInt_Write_clicked(self):  
      Value=self.ui.spin_Int.value()
      if self.__iniWrite():
         try:
            self.fileStream.writeInt(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeInt()发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  int
   def on_btnInt_Read_clicked(self):  
      if self.__iniRead():
         Value=self.fileStream.readInt()
         self.ui.edit_Int.setText("%d"%Value)
         self.__delFileStream()


   @pyqtSlot()   ##写  bool
   def on_btnBool_Write_clicked(self):  
      Value=self.ui.chkBox_In.isChecked() #bool型
      if self.__iniWrite(): 
         self.fileStream.writeBool(Value)
         self.__delFileStream()
          
   @pyqtSlot()    ##读  bool
   def on_btnBool_Read_clicked(self):  
      if self.__iniRead():
         Value=self.fileStream.readBool() #bool型
         self.ui.chkBox_Out.setChecked(Value)
         self.__delFileStream()


   @pyqtSlot()   ##写  float
   def on_btnFloat_Write_clicked(self):  
      Value=self.ui.spin_Float.value()
      if self.__iniWrite():
         try:
            self.fileStream.writeFloat(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeFloat()发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  float
   def on_btnFloat_Read_clicked(self):  
      if self.__iniRead():
         try:
            Value=self.fileStream.readFloat()
            self.ui.edit_Float.setText("%.4f"%Value)
         except Exception as e:
            QMessageBox.critical(self, "writeFloat()发生错误", str(e))
         finally:
            self.__delFileStream()


   @pyqtSlot()   ##写  double
   def on_btnDouble_Write_clicked(self):  
      Value=self.ui.spin_Double.value()
      if self.__iniWrite():
         try:
            self.fileStream.writeDouble(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeDouble()发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读  double
   def on_btnDouble_Read_clicked(self):  
      if self.__iniRead():
         try:
            Value=self.fileStream.readDouble()
            self.ui.edit_Double.setText("%.4f"%Value)
         except Exception as e:
            QMessageBox.critical(self, "readDouble()发生错误", str(e))
         finally:
            self.__delFileStream()


   @pyqtSlot()    ##写 QString,与Python的str兼容
   def on_btnQStr_Write_clicked(self):  
      Value=self.ui.editQStr_In.text()
      if self.__iniWrite():
         try:
            self.fileStream.writeQString(Value)
         except Exception as e:
            QMessageBox.critical(self, "writeQString()发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读 QString,与Python的str兼容
   def on_btnQStr_Read_clicked(self):  
      if self.__iniRead():
         try:
            Value=self.fileStream.readQString()
            self.ui.editQStr_Out.setText(Value)
         except Exception as e:
            QMessageBox.critical(self, "readQString()发生错误", str(e))
         finally:
            self.__delFileStream()

   @pyqtSlot()    ##写 String
   def on_btnStr_Write_clicked(self):  
      strV=self.ui.editStr_In.text()   #str类型
      if self.__iniWrite():
         try:
            bts=bytes(strV,encoding="utf-8")  #转换为bytes类型
            self.fileStream.writeString(bts)
         except Exception as e:
            QMessageBox.critical(self, "写入时发生错误", str(e))
         finally:
            self.__delFileStream()
          
   @pyqtSlot()    ##读 String
   def on_btnStr_Read_clicked(self):  
      if self.__iniRead():
         try:
            Value=self.fileStream.readString()  #bytes类型
            strV=Value.decode("utf-8")          #从bytes类型解码为字符串,编码utf-8
            self.ui.editStr_Out.setText(strV)
         except Exception as e:
            QMessageBox.critical(self, "读取时发生错误", str(e))
         finally:
            self.__delFileStream()

##===字体的写入与读取
   @pyqtSlot()   ##选择字体
   def on_btnFont_In_clicked(self):  
      font=self.ui.btnFont_In.font()
      font,OK=QFontDialog.getFont(font,self) #选择字体
      if OK:
         self.ui.btnFont_In.setFont(font)

   @pyqtSlot()   ##写  QVariant, QFont
   def on_btnFont_Write_clicked(self):  
      font=self.ui.btnFont_In.font()    #QFont类型
      if self.__iniWrite(): 
         self.fileStream.writeQVariant(font)  #QFont类型
         self.__delFileStream()
          
   @pyqtSlot()    ##读  QVariant, QFont
   def on_btnFont_Read_clicked(self):  
      if self.__iniRead():
         try:
            font=self.fileStream.readQVariant()   #QFont类型
            self.ui.editFont_Out.setFont(font)
         except Exception as e:
            QMessageBox.critical(self, "读取时发生错误", str(e))
         finally:
            self.__delFileStream()


##===颜色的写入与读取
   @pyqtSlot()   ##选择颜色
   def on_btnColor_In_clicked(self):  
      plet=self.ui.btnColor_In.palette()  #QPalette
      color=plet.buttonText().color()     #QColor
      color= QColorDialog.getColor(color,self)
      if color.isValid():
         plet.setColor(QPalette.ButtonText,color)
         self.ui.btnColor_In.setPalette(plet)


   @pyqtSlot()   ##写  QVariant, QColor
   def on_btnColor_Write_clicked(self):  
      plet=self.ui.btnColor_In.palette()  
      color=plet.buttonText().color()     #QColor
      if self.__iniWrite(): 
         self.fileStream.writeQVariant(color)  #QColor
         self.__delFileStream()
          
   @pyqtSlot()    ##读  QVariant, QColor
   def on_btnColor_Read_clicked(self):  
      if self.__iniRead():
         try:
            color=self.fileStream.readQVariant()   #读取为QColor类型
            plet=self.ui.editColor_Out.palette() 
            plet.setColor(QPalette.Text,color)
            self.ui.editColor_Out.setPalette(plet)
         except Exception as e:
            QMessageBox.critical(self, "读取时发生错误", str(e))
         finally:
            self.__delFileStream()

   @pyqtSlot()    ##读出编辑框全清空
   def on_actClearOutput_triggered(self):  
      self.ui.edit_Int8.clear()
      self.ui.edit_UInt8.clear()
      self.ui.edit_Int16.clear()
      self.ui.edit_UInt16.clear()
      self.ui.edit_Int32.clear()
      self.ui.edit_Int64.clear()
      self.ui.edit_Int.clear()

      self.ui.edit_Float.clear()
      self.ui.edit_Double.clear()

      font=self.font()
      self.ui.editFont_Out.setFont(font)

      plet=self.palette()
      self.ui.editColor_Out.setPalette(plet)

   @pyqtSlot()    ##连续写入文件
   def on_actSaveALL_triggered(self):  
      if not self.__iniWrite():
         QMessageBox.critical(self,"错误","为写入打开文件时出错")
         return
   #数据写入部分
      Value=self.ui.spin_Int8.value()
      self.fileStream.writeInt8(Value)    #int8

      Value=self.ui.spin_UInt8.value()
      self.fileStream.writeUInt8(Value)   #uint8

      Value=self.ui.spin_Int16.value()
      self.fileStream.writeInt16(Value)   #int16

      Value=self.ui.spin_UInt16.value()
      self.fileStream.writeUInt16(Value)  #uint16

      Value=self.ui.spin_Int32.value()
      self.fileStream.writeInt32(Value)   #int32

      Value=self.ui.spin_Int64.value()
      self.fileStream.writeInt64(Value)   #int64

      Value=self.ui.spin_Int.value()
      self.fileStream.writeInt(Value)     #int

      Value=self.ui.chkBox_In.isChecked()
      self.fileStream.writeBool(Value)    #bool

      Value=self.ui.spin_Float.value()
      self.fileStream.writeFloat(Value)   #float

      Value=self.ui.spin_Double.value() 
      self.fileStream.writeDouble(Value)  #double

      str_Value=self.ui.editQStr_In.text()
      self.fileStream.writeQString(str_Value)   #QString
      
      str_Value=self.ui.editStr_In.text()       #str类型
      bts=bytes(str_Value,encoding="utf-8")     #转换为bytes类型
      self.fileStream.writeString(bts)    

      font=self.ui.btnFont_In.font()
      self.fileStream.writeQVariant(font)    #QFont

      plet=self.ui.btnColor_In.palette()
      color=plet.buttonText().color() 
      self.fileStream.writeQVariant(color)   #QColor

   #数据写入完成
      self.__delFileStream()
      QMessageBox.information(self,"消息","数据连续写入完成.")


   @pyqtSlot()    ##连续读取文件
   def on_actReadALL_triggered(self):  
      if not self.__iniRead():
         QMessageBox.critical(self,"错误","为读取打开文件时出错")
         return
      
   #数据读取部分
      Value=self.fileStream.readInt8()    #int8
      self.ui.edit_Int8.setText("%d"%Value)

      Value=self.fileStream.readUInt8()   #uint8
      self.ui.edit_UInt8.setText("%d"%Value)

      Value=self.fileStream.readInt16()   #int16
      self.ui.edit_Int16.setText("%d"%Value)

      Value=self.fileStream.readUInt16()  #uint16
      self.ui.edit_UInt16.setText("%d"%Value)

      Value=self.fileStream.readInt32()   #int32
      self.ui.edit_Int32.setText("%d"%Value)

      Value=self.fileStream.readInt64()   #int64
      self.ui.edit_Int64.setText("%d"%Value)

      Value=self.fileStream.readInt()     #int
      self.ui.edit_Int.setText("%d"%Value)

      Value=self.fileStream.readBool()    #bool
      self.ui.chkBox_Out.setChecked(Value)

      Value=self.fileStream.readFloat()   #float
      self.ui.edit_Float.setText("%.4f"%Value)

      Value=self.fileStream.readDouble()  #double
      self.ui.edit_Double.setText("%.4f"%Value)

      str_Value=self.fileStream.readQString()  #str
      self.ui.editQStr_Out.setText(str_Value)

      byteStr=self.fileStream.readString()   #bytes
      str_Value=byteStr.decode("utf-8")      #从bytes类型解码为字符串
      self.ui.editStr_Out.setText(str_Value)

      font=self.fileStream.readQVariant()    #QFont
      self.ui.editFont_Out.setFont(font)

      color=self.fileStream.readQVariant()   #QColor
      plet=self.ui.editColor_Out.palette() 
      plet.setColor(QPalette.Text,color)
      self.ui.editColor_Out.setPalette(plet)
      
   #数据写入完成
      self.__delFileStream()
      QMessageBox.information(self,"消息","数据连续读取完成.")
Exemplo n.º 60
0
    def write(self, map, fileName):
        # Open up a temporary file for saving the level.
        file = QSaveFile(fileName)
        if (not file.open(QIODevice.WriteOnly)):
            self.mError = self.tr("Could not open temporary file for writing.")
            return False

        # Create an output stream for serializing data.
        out = QDataStream(file)
        out.setByteOrder(QDataStream.LittleEndian)
        out.setFloatingPointPrecision(QDataStream.SinglePrecision)
        # Write out the signature and file header.
        out.writeInt8(96)  # Signature.
        out.writeInt8(map.layerCount())
        ok = False
        x, ok = Int2(map.property("background_index"))
        if (not ok):
            self.mError = self.tr(
                "You must define a background_index property on the map!")
            return False
        out.writeInt8(x)
        # Write out each layer.
        for i in range(0, map.layerCount()):
            layer = map.layerAt(i).asTileLayer()
            if (not layer):
                self.mError = self.tr("Can't save non-tile layer!")
                return False

            if (not self.writeLayer(out, layer)):
                return False

            if not file.commit():
                self.mError = file.errorString()
                return False

        return True