def _loadSettings(self): settings = QSettings() # Recent documents size = settings.beginReadArray("RecentDocuments") for idx in range(size-1, -1, -1): settings.setArrayIndex(idx) canonicalName = QFileInfo(settings.value("Document")).canonicalFilePath() self._updateRecentDocuments(canonicalName) settings.endArray() # Application properties: Geometry geometry = settings.value("Application/Geometry", QByteArray()) if self._preferences.restoreApplicationGeometry() else QByteArray() if not geometry.isEmpty(): self.restoreGeometry(geometry) else: availableGeometry = self.screen().availableGeometry() self.resize(availableGeometry.width() * 2/3, availableGeometry.height() * 2/3) self.move((availableGeometry.width() - self.width()) / 2, (availableGeometry.height() - self.height()) / 2) # Application properties: State state = settings.value("Application/State", QByteArray()) if self._preferences.restoreApplicationState() else QByteArray() if not state.isEmpty(): self.restoreState(state) else: self._toolbarApplication.setVisible(True) self._toolbarDocument.setVisible(True) self._toolbarEdit.setVisible(True) self._toolbarTools.setVisible(True) self._toolbarView.setVisible(False) self._toolbarHelp.setVisible(False)
def exportDipsToURL(self, dipoles, directoryURL, fileName, addDateToExport=True): dateStr = ("-" + QDate.currentDate().toString(Qt.ISODate) ) if addDateToExport else "" filename = QUrl(directoryURL).toLocalFile() + ( QDir.separator() + fileName + dateStr + ".csv").replace(" ", "_") file = QSaveFile(filename) file.open(QIODevice.WriteOnly) file.write( QByteArray( bytearray("x,y,z,phi (°),theta (°),moment (mu_B)\n", 'utf-8'))) for dip in dipoles: angles = anglesQuaternionToSph(dip.quaternion) line = str(dip.position.x()) + "," + str( dip.position.y()) + "," + str(dip.position.z()) + "," + str( degrees(angles[0])) + "," + str(degrees( angles[1])) + "," + str(dip.moment) + "\n" line = QByteArray(bytearray(line, 'utf-8')) file.write(line) file.commit() if (file.errorString() == "Unknown error"): return True else: return False
def send_file(self): self._transaction.set_status(TransactionStatus.SENDING) file_to_byte_array = QByteArray() data = QByteArray() stream = QDataStream(data, QIODevice.WriteOnly) QFile.open(self._file, QIODevice.ReadOnly) stream.writeUInt32(0) stream.writeString(self._file_name) print("size of name ", getsizeof(self._file_name)) file_to_byte_array = self._file.readAll() data.append(file_to_byte_array) self._file.close() stream.device().seek(0) stream.writeUInt32(data.size() - getsizeof(self._file_name)) print("total ", data.size() - getsizeof(self._file_name)) x = 0 while (x < data.size()): y = self._socket.write(data) print("poslato ", y) x += y print("x ", x) self._transaction.set_status(TransactionStatus.FINISHED)
def testSliceAssignmentByteArray(self): b = QByteArray(py3k.b('0123456789')) # replace b[2:8] = bytearray(py3k.b('abcdef')) self.assertEqual(b[2:8], py3k.b('abcdef')) # shrink b[2:8] = bytearray(py3k.b('aaa')) self.assertEqual(b, py3k.b('01aaa89')) # expanse b[2:5] = bytearray(py3k.b('uvwxyz')) self.assertEqual(b, py3k.b('01uvwxyz89')) # Delete behavior b[2:8] = bytearray(py3k.b('')) self.assertEqual(b, py3k.b('0189')) b = QByteArray(py3k.b('0123456789')) # reverse assginment b[5:2:-1] = bytearray(py3k.b('ABC')) self.assertEqual(b, py3k.b('012CBA6789')) # step is not 1 b[2:9:3] = bytearray(py3k.b('XYZ')) self.assertEqual(b, py3k.b('01XCBY67Z9')) b = QByteArray(py3k.b('0123456789')) b[9:2:-3] = bytearray(py3k.b('XYZ')) self.assertEqual(b, py3k.b('012Z45Y78X'))
def testQByteArrayValid(self): '''QDataStream <<>> QByteArray - valid''' self.stream << QByteArray("hello") res = QByteArray() self.read_stream >> res self.assertEqual(res, QByteArray("hello"))
def roleNames(self) -> typing.Dict: """Returns dict with role numbers and role names for default and custom roles together""" # Append custom roles to the default roles and give them names for a usage in the QML roles = super().roleNames() roles[self.Roles.LOCATION.value] = QByteArray(b'location') roles[self.Roles.ID.value] = QByteArray(b'id') print(roles) return roles
def roleNames(self): roles = { UserModel.RoleName: QByteArray(b'name'), UserModel.RoleActive: QByteArray(b'active') } return roles
def testQByteArrayEmpty(self): '''QDataStream <<>> QByteArray - empty''' self.stream << QByteArray("") res = QByteArray() self.read_stream >> res self.assertEqual(res, QByteArray("")) self.assertTrue(res.isEmpty()) self.assertFalse(res.isNull())
def testQByteArrayNull(self): '''QDataStream <<>> QByteArray - null''' self.stream << QByteArray() res = QByteArray() self.read_stream >> res self.assertEqual(res, QByteArray()) self.assertTrue(res.isEmpty()) self.assertTrue(res.isNull())
def testSetNum(self): b = QByteArray() b.setNum(py3k.long(-124124)) self.assertEqual(b, "-124124") b = QByteArray() b.setNum(-124124) self.assertEqual(b, "-124124") b = QByteArray() b.setNum(-0.5) self.assertEqual(b, "-0.5")
def preparar_favicon(self, url): try: archivo_ico = backend.descargar_favico(url) except Exception: # Si lo que se ingreso era un link pero no se consiguio favicon with open("media/favicons/domain.ico") as ico: return QByteArray(ico.read()) # Si no se consiguio la imagen if archivo_ico is None: return None with open(archivo_ico, "rb") as ico: return QByteArray(ico.read())
def testPastEnd(self): '''QDataStream >> QBitArray reading past the end of the data''' data = [] data.append((QByteArray(), QDataStream.ReadPastEnd, QBitArray())) data.append( (QByteArray(py3k.b('\x00')), QDataStream.ReadPastEnd, QBitArray())) data.append((QByteArray(py3k.b('\x00\x00')), QDataStream.ReadPastEnd, QBitArray())) data.append( (QByteArray(py3k.b('\x00\x00\x00')), QDataStream.ReadPastEnd, QBitArray())) data.append( (QByteArray(py3k.b('\x00\x00\x00\x01')), QDataStream.ReadPastEnd, QBitArray())) data.append( (QByteArray(py3k.b('\x00\x00\x00\x02')), QDataStream.ReadPastEnd, QBitArray())) data.append( (QByteArray(py3k.b('\x00\x00\x00\x03')), QDataStream.ReadPastEnd, QBitArray())) data.append( (QByteArray(py3k.b('\x00\x00\x00\x04')), QDataStream.ReadPastEnd, QBitArray())) self._check_bitarray(data)
def setUp(self): self.dom = QDomDocument() self.goodXmlData = QByteArray(''' <typesystem package="PySide2.QtXml"> <value-type name="QDomDocument"/> <value-type name="QDomElement"/> </typesystem> ''') self.badXmlData = QByteArray(''' <typesystem package="PySide2.QtXml"> <value-type name="QDomDocument"> </typesystem> ''')
def __init__(self, parent=None): super(NetworkConnectionClass, self).__init__(parent=parent) #self.CommandSocket = QTcpSocket() self.CommandSocket = QUdpSocket() self.CommandSocket.bind(QHostAddress("192.168.100.2"), 2323) self.CommandSocket.connected.connect(self.EventConnectedHandle) self.CommandSocket.readyRead.connect(self.RecieveData) #self.CommandSocket.connectToHost("192.168.100.5",2323,QIODevice.ReadWrite) #self.CommandSocket.connectToHost("127.0.0.1",2323,QIODevice.ReadWrite) #self.CommandSocket.connectToHost("192.168.20.196",2323,QIODevice.ReadWrite) #print("NETWORK - ",self.CommandSocket.localAddress(),self.CommandSocket.peerAddress()) self.Display = WindowNetworkConnection() self.NetworkDataArray = QByteArray() self.NetworkDataArray.resize(2000) self.SignalDataRec.connect(self.Display.PrintData) self.BufferWrite = QBuffer(self.NetworkDataArray) self.BufferWrite.open(QBuffer.WriteOnly) self.BufferRead = QBuffer(self.NetworkDataArray) self.BufferRead.open(QBuffer.ReadOnly) self.ReadDataStream = QDataStream(self.BufferRead) self.ReadDataStream.setByteOrder(QDataStream.LittleEndian) self.WriteDataStream = QDataStream(self.BufferWrite) self.WriteDataStream.setByteOrder(QDataStream.LittleEndian) self.SocketDataStream = QDataStream(self.CommandSocket) self.SocketDataStream.setByteOrder(QDataStream.LittleEndian) self.Timer = QTime() self.Timer.start() self.BufferRead.seek(0) self.BufferWrite.seek(0) self.LimitBufferSize = 2000 self.MinTransferUnit = 7 self.MaxTransferUnit = 18 self.bytesAvailable = 0 self.Display.ui.pushButton.clicked.connect(self.SendData) #===================================================== WRITE BUFFER self.SendBuffer = QByteArray()
def to_base64(self, w=32, h=32): """Return icon as base64 to make it work with html""" pix = self.pixmap(w, h) data = QByteArray() buff = QBuffer(data) pix.save(buff, "PNG") return data.toBase64().data().decode()
def writeSettings(self): """Write settings to disk, save window geometry""" settings = QSettings(self.companyName, self.toolName) settings.beginGroup('{}'.format(self.toolVersion)) settings.setValue("size", self.widget.size()) settings.setValue("pos", self.widget.pos()) errors = [] if hasattr(self.widget, "saveState"): settings.beginGroup("widgetState") try: state = pickle.dumps(self.widget.saveState()) except: import traceback errors.append(traceback.format_exc()) else: settings.setValue("state", QByteArray(state)) # end widgetState settings.endGroup() # end toolVersion settings.endGroup() if errors: print(errors[-1]) return False return True
def readSettings(self): """Read settings from disk, restore window geometry.""" settings = QSettings(self.companyName, self.toolName) settings.beginGroup(str(self.toolVersion)) self.widget.resize(settings.value("size", QSize(400, 200))) self.widget.move(settings.value("pos", QPoint(200, 200))) errors = [] if hasattr(self.widget, "restoreState"): settings.beginGroup("widgetState") string = settings.value("state", QByteArray('(dp0\n.)')) if string: try: state = pickle.loads(string) self.widget.restoreState(state) except: import traceback errors.append(traceback.format_exc()) # end widgetState settings.endGroup() # end toolVersion settings.endGroup() if errors: print(errors[-1]) return False return True
def buildVertexAttrs(parent, array, attrspecs): # Measure the input array rows = len(array) columns = len(array[0]) basetype = basetype_numpy_codes_reverse[array.dtype.type] basetype_width = basetype_widths[basetype] row_width = columns * basetype_width #print(columns, rows, basetype, basetype_width, row_width) # Convert input to a qt buffer rawstring = array.tobytes() byte_array = QByteArray(rawstring) qbuffer = Qt3DRender.QBuffer(parent) qbuffer.setData(byte_array) attrs = list() for asp in attrspecs: attr = Qt3DRender.QAttribute(parent) attr.setName(asp.name) attr.setVertexBaseType(basetype) attr.setVertexSize(asp.numcols) attr.setAttributeType(Qt3DRender.QAttribute.VertexAttribute) attr.setBuffer(qbuffer) attr.setByteStride(row_width) attr.setByteOffset(asp.column * basetype_width) attr.setCount(rows) attrs.append(attr) return attrs
def testVoidPtr(self): # Creating a VoidPtr object requires an address of # a C++ object, a wrapped Shiboken Object type, # an object implementing the Python Buffer interface, # or another VoidPtr object. # Original content b = b"Hello world" ba = QByteArray(b) vp = VoidPtr(ba, ba.size()) self.assertIsInstance(vp, shiboken.VoidPtr) # Create QByteArray from voidptr byte interpretation nba = QByteArray.fromRawData(vp.toBytes()) # Compare original bytes to toBytes() self.assertTrue(b, vp.toBytes()) # Compare original with new QByteArray data self.assertTrue(b, nba.data()) # Convert original and new to str self.assertTrue(str(b), str(nba)) # Modify nba through a memoryview of vp mv = memoryview(vp) self.assertFalse(mv.readonly) mv[6:11] = b'void*' self.assertEqual(str(ba), str(b"Hello void*"))
def start(self): self._sender = self._socket.peerAddress() stream = QDataStream(self._socket) if (self._file_size == 0): if (self._socket.bytesAvailable() < getsizeof(int)): return self._file_size = stream.readUInt32() if (self._socket.bytesAvailable() < self._file_size): return self._file_name = stream.readString() line = QByteArray() line = self._socket.readAll() directory = Path(Setup().get_download_dir()) if not (directory.exists() and directory.is_dir()): directory.mkdir() self._receiving_file = QFile(Setup().get_download_dir() + str(self._file_name)) print(Setup().get_download_dir() + str(self._file_name)) if not (self._receiving_file.open(QIODevice.WriteOnly)): print("can't open file") return self._receiving_file.write(line) self._receiving_file.close() self._socket.disconnectFromHost() print("finished") return self._receiving_file
def testIt(self): w = QGLWidget() w.makeCurrent() b = QGLBuffer() b.setUsagePattern(QGLBuffer.DynamicDraw) self.assertTrue(b.create()) self.assertTrue(b.bufferId() != 0) self.assertTrue(b.bind()) data = QByteArray(py3k.b("12345")) b.allocate(data) self.assertEqual(b.size(), data.size()) m = b.map(QGLBuffer.ReadOnly) if m: self.assertEqual(m, py3k.buffer(py3k.b(data.data()))) b.unmap() m = b.map(QGLBuffer.ReadWrite) m[3] = py3k.b('A')[0] b.unmap() result, rdata = b.read(3, 1) self.assertTrue(result) self.assertEqual(py3k.b('A'), rdata.data()) else: print(" memory mapping is not possible in this OpenGL implementation.") b.release()
def load_gif(gif_name): _, ext = (os.path.splitext(gif_name)) full_path = os.path.join(get_icon_dir_path(ext[1:]), gif_name) if os.path.exists(full_path): gif_byte_array = QByteArray(open(full_path, 'rb').read()) gif_buffer = QBuffer(gif_byte_array) q_movie = QMovie(full_path) q_movie.setFormat(QByteArray(b'GIF')) q_movie.setDevice(gif_buffer) q_movie.setCacheMode(QMovie.CacheAll) q_movie.setSpeed(100) q_movie.jumpToFrame(0) return q_movie raise FileNotFoundError
def testInRangeReverse(self): #QByteArray[x] where x is a valid index (reverse order) string = 'abcdefgh' obj = QByteArray(string) for i in range(len(string) - 1, 0, -1): self.assertEqual(obj[i], py3k.b(string[i]))
def testConcatPythonStringAndQByteArray(self): #Test concatenation of a Python string with a QByteArray, in this order concat_python_string_add_qbytearray_worked = True qba = QByteArray('foo') result = 'bar\x00' + qba self.assertEqual(type(result), QByteArray) self.assertEqual(result, 'bar\x00foo')
def hCopy(self): """ # slot for action copy_to_clipboard """ sel = self.listWdg.selectedItems() #################### # test code l = [] for item in sel: # get url from path l.append(QUrl.fromLocalFile(item.data(Qt.UserRole)[0])) # init clipboard data q = QMimeData() # set some Windows magic values for copying files from system clipboard : Don't modify # 1 : copy; 2 : move q.setData("Preferred DropEffect", QByteArray(1, "2")) q.setUrls(l) # end of test code ##################### # copy image to clipboard item = sel[0] filename = item.data(Qt.UserRole)[0] if filename.endswith(IMAGE_FILE_EXTENSIONS): q.setImageData(QImage(sel[0].data(Qt.UserRole)[0])) QApplication.clipboard().clear() QApplication.clipboard().setMimeData(q)
def testInRange(self): #QByteArray[x] where x is a valid index string = 'abcdefgh' obj = QByteArray(string) for i in range(len(string)): self.assertEqual(obj[i], py3k.b(string[i]))
def refresh(self, defaultviewsize=False): xml = self.getSvgXML() svg_ba = QByteArray(bytes(xml, 'utf-8')) self.load(svg_ba) if defaultviewsize: # This will make sure diagram is shown full scale. self.resize(self.sizeHint())
def startDrag(self, event): item = self.itemAt(event.scenePos(), self.page_view_transform) if item is None: event.ignore() return self.item_being_dragged = item.parent self.remove_component_controller(item.parent) hotspot = event.scenePos() - item.scenePos() hot_spot_point = hotspot.toPoint() hot_spot_point = self.page_view_transform.map(hot_spot_point) item_data = QByteArray() data_stream = QDataStream(item_data, QIODevice.WriteOnly) data_stream << hot_spot_point # pixmap << location mime_data = QMimeData() mime_data.setData(config_controller.component_mime, item_data) drag = QDrag(self) drag.setMimeData(mime_data) horizontal_scaling = self.page_view_transform.m11() logger.info(f"sceneBoundingRect {item.sceneBoundingRect().width()}") logger.info( f"sceneBoundingRect {item.sceneBoundingRect().width()*horizontal_scaling}" ) drag.setPixmap( item.parent.pixmap.scaledToWidth(item.sceneBoundingRect().width() * horizontal_scaling)) drag.setHotSpot(hot_spot_point) result = drag.start(QtCore.Qt.MoveAction) if result: # == QtCore.Qt.MoveAction: pass
def findIcons(self): if hou.applicationVersion()[0] < 15: for category in os.listdir(self.path): for ico in os.listdir(os.path.join(self.path, category)): iconPath = os.path.join( os.path.join(self.path, category, ico)) iconName = '_'.join([category, os.path.splitext(ico)[0]]) self.icons[iconName] = QPixmap(iconPath) else: zf = zipfile.ZipFile(self.path, 'r') for f in zf.namelist(): if f.startswith('old'): continue if os.path.splitext(f)[-1] == '.svg': svg = QSvgRenderer(QByteArray(zf.read(f))) if not svg.isValid(): continue pixmap = QPixmap(iconSize, iconSize) painter = QPainter() painter.begin(pixmap) pixmap.fill(QColor(Qt.black)) svg.render(painter) painter.end() category, ico = f.split('/') iconName = '_'.join([category, os.path.splitext(ico)[0]]) self.icons[iconName] = pixmap zf.close()
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)