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)
