def image_to_byte_test(self):
"""
Test the image_to_byte() function
"""
with patch('openlp.core.lib.QtCore') as MockedQtCore:
# GIVEN: A set of mocked-out Qt classes
mocked_byte_array = MagicMock()
MockedQtCore.QByteArray.return_value = mocked_byte_array
mocked_byte_array.toBase64.return_value = QtCore.QByteArray('base64mock')
mocked_buffer = MagicMock()
MockedQtCore.QBuffer.return_value = mocked_buffer
MockedQtCore.QIODevice.WriteOnly = 'writeonly'
mocked_image = MagicMock()
# WHEN: We convert an image to a byte array
result = image_to_byte(mocked_image)
# THEN: We should receive a value of 'base64mock'
MockedQtCore.QByteArray.assert_called_with()
MockedQtCore.QBuffer.assert_called_with(mocked_byte_array)
mocked_buffer.open.assert_called_with('writeonly')
mocked_image.save.assert_called_with(mocked_buffer, "PNG")
mocked_byte_array.toBase64.assert_called_with()
self.assertEqual('base64mock', result, 'The result should be the return value of the mocked out '
'base64 method')
def on_btnPrint_clicked(self):
widgetIndex = self.tabWidget.currentIndex()
if widgetIndex == 1:
model = self.modelTemperatureSheet
doc = QtGui.QTextDocument()
cursor = QtGui.QTextCursor(doc)
cursor.setCharFormat(CReportBase.ReportTitle)
cursor.insertText(u'Таблица температурного листа\n')
cursor.insertBlock()
cursor.setCharFormat(CReportBase.ReportBody)
cursor.insertText(u'Пациент: %s' %
(getClientString(self.clientId)))
cursor.insertText(u'\nОтчёт составлен: ' +
forceString(QtCore.QDateTime.currentDateTime()))
cursor.insertBlock()
colWidths = [
self.tblTemperatureSheet.columnWidth(i)
for i in xrange(model.columnCount() - 1)
]
colWidths.insert(0, 10)
totalWidth = sum(colWidths)
tableColumns = []
iColNumber = False
for iCol, colWidth in enumerate(colWidths):
widthInPercents = str(max(1, colWidth * 90 / totalWidth)) + '%'
if iColNumber == False:
tableColumns.append(
(widthInPercents, [u'№'], CReportBase.AlignRight))
iColNumber = True
headers = model.headers
tableColumns.append(
(widthInPercents, [forceString(headers[iCol][1])],
CReportBase.AlignLeft))
table = createTable(cursor, tableColumns)
for iModelRow in xrange(model.rowCount()):
iTableRow = table.addRow()
table.setText(iTableRow, 0, iModelRow + 1)
for iModelCol in xrange(model.columnCount()):
index = model.createIndex(iModelRow, iModelCol)
text = forceString(model.data(index))
table.setText(iTableRow, iModelCol + 1, text)
html = doc.toHtml(QtCore.QByteArray('utf-8'))
view = CReportViewDialog(self)
view.setText(html)
view.exec_()
else:
printer = QtGui.QPrinter(QtGui.QPrinter.HighResolution)
printer.setOrientation(QtGui.QPrinter.Landscape)
dialog = QtGui.QPrintDialog(printer, self)
if dialog.exec_():
painter = QtGui.QPainter(printer)
scale = min(
printer.pageRect().width() /
self.scrollArea.widget().width(),
printer.pageRect().height() /
self.scrollArea.widget().height())
painter.scale(scale, scale)
self.scrollArea.widget().render(painter)
painter.end()
def main():
# gen Pixmaps.py
with open(os.path.join(DirRes, 'Pixmaps.py'), 'w') as fp:
fp.write('# auto generated resource file. WARNING: do not edit\n')
fp.write('from PyQt4 import QtCore, QtGui\n')
fp.write('_cache = {}\n')
for name in os.listdir(DirPixmaps):
fileName = os.path.join(DirPixmaps, name)
if not os.path.isfile(fileName): continue
if not os.path.splitext(name)[1].lower() == '.png': continue
arr = QtCore.QByteArray()
p = QtCore.QBuffer(arr)
p.open(p.WriteOnly)
px = QtGui.QPixmap(fileName, 'PNG')
px.save(p, 'png')
funtionName = os.path.splitext(name)[0]
fp.write('def %s():\n' % funtionName)
fp.write('\tpx = _cache.get("%s", None)\n' % funtionName)
fp.write('\tif px is None:\n')
fp.write('\t\tarr = QtCore.QByteArray.fromBase64("%s")\n' % arr.toBase64() )
fp.write('\t\tpx = QtGui.QPixmap()\n')
fp.write('\t\tpx.loadFromData(arr, "PNG")\n' )
fp.write('\t\t_cache["%s"] = px\n' % funtionName)
fp.write('\treturn px\n')
# gen HtmlPages.py
with open(os.path.join(DirRes, 'HtmlPages.py'), 'w') as fp:
fp.write('# auto generated resource file. WARNING: do not edit\n')
fp.write('from PyQt4 import QtCore\n')
fp.write('_cache = {}\n')
for name in os.listdir(DirHtmlPages):
fileName = os.path.join(DirHtmlPages, name)
if not os.path.isfile(fileName): continue
if not os.path.splitext(name)[1].lower() == '.html': continue
with open(fileName, 'r') as fp2:
arr = QtCore.QByteArray(fp2.read() )
funtionName = os.path.splitext(name)[0]
fp.write('def %s():\n' % funtionName)
fp.write('\tarr = _cache.get("%s", None)\n' % funtionName)
fp.write('\tif arr is None:\n')
fp.write('\t\tarr = QtCore.QByteArray.fromBase64("%s")\n' % arr.toBase64() )
fp.write('\t\t_cache["%s"] = arr\n' % funtionName)
fp.write('\treturn QtCore.QString(arr)\n')
def docRead(self, readWrite, r):
data = r.readAll('FILE')
image = QtGui.QImage()
image.loadFromData(QtCore.QByteArray(data))
if image.isNull():
return
self.imageLabel.setPixmap(QtGui.QPixmap.fromImage(image))
self.__adjustSize()
def __imageHandler(self):
self._ui.tContent.setVisible(False)
self._ui.wImage.setVisible(True)
data = QtCore.QByteArray(self._content)
pixmap = QtGui.QPixmap()
pixmap.loadFromData(data)
self._ui.lImage.setPixmap(pixmap)
def byte_array_from(qimage):
image_data = QtCore.QByteArray()
buffer = QtCore.QBuffer(image_data)
buffer.open(QtCore.QIODevice.WriteOnly)
qimage.save(buffer, 'PNG')
buffer.close()
return image_data
def receiveMessage(self):
ins = QtCore.QDataStream(self.socket)
ins.setVersion(QtCore.QDataStream.Qt_4_4)
self.socket.bytesAvailable()
result = QtCore.QByteArray()
ins >> result
self.hasRight = json.loads(forceString(result))
def getScene(self):
instr = QtCore.QDataStream(self.tcpSocket)
instr.setVersion(QtCore.QDataStream.Qt_4_0)
while True:
if self.blockSize == 0:
if self.tcpSocket.bytesAvailable() < 4:
return
self.blockSize = instr.readUInt32()
if self.tcpSocket.bytesAvailable() < self.blockSize:
return
self.blockSize = 0
pix = QtGui.QImage()
ba = QtCore.QByteArray()
instr >> ba
# skip this frame if there is another one in buffer
if self.tcpSocket.bytesAvailable() > 0:
rospy.logdebug("Frame dropped")
continue
# start = time.time()
# 16ms
if not pix.loadFromData(ba, "JPG"):
rospy.logerr("Failed to load image from received data")
return
if self.calibrating or not self.projectors_calibrated or not self.maps_ready:
return
# 3ms
img = pix.convertToFormat(QtGui.QImage.Format_ARGB32)
v = qimage2ndarray.rgb_view(img)
# TODO some further optimalization? this is about 30ms (with INTER_LINEAR)s...
image_np = cv2.remap(v, self.map_x, self.map_y, cv2.INTER_LINEAR)
# this is about 3ms
height, width, channel = image_np.shape
bytesPerLine = 3 * width
image = QtGui.QPixmap.fromImage(
QtGui.QImage(image_np.data, width, height, bytesPerLine,
QtGui.QImage.Format_RGB888))
self.pix_label.setPixmap(image)
self.update()
# end = time.time()
# rospy.logdebug("Frame loaded in: " + str(end-start))
return
def sendMessage(self):
buf = QtCore.QBuffer()
buf.open(QtCore.QBuffer.ReadWrite)
out = QtCore.QDataStream(buf)
out.setVersion(QtCore.QDataStream.Qt_4_4)
out << QtCore.QByteArray(json.dumps(self.hasRight))
self.serverSocket.write(buf.data().data())
self.serverSocket.flush()
def createRequest(self, op, req, outgoingData):
if self.token is not None:
req.setRawHeader("X-Authentication-Token", QtCore.QByteArray(self.token))
# Block TTF under Mac
if sys.platform == "darwin" and unicode(req.url().path()).endswith(".ttf"):
# Block .ttf file for now as there are badly displayed
return super(TokenNetworkAccessManager, self).createRequest(op,
QtNetwork.QNetworkRequest(QtCore.QUrl()), outgoingData)
return super(TokenNetworkAccessManager, self).createRequest(op, req, outgoingData)
def run(self):
self.cam = self.cam.copy()
self.cam.connect()
self.setPriority(QtCore.QThread.IdlePriority)
self.time = time()
self.compression = self.cam['compression']
self.count = 0.
# frame_number = self.cam.get('frame_number')
frame_number = 0
force = True
# Create new cam object with connection unique to this thread.
tcam = self.cam
while self.stream:
if not self.parent().isVisible():
sleep(self.waiting)
continue
fr = tcam.new_frame(frame_number, force)
if not fr:
self.stream = False
continue
crop, frs, frame_number = fr
if force:
force = False
if frs is False:
sleep(self.waiting)
continue
# Emit cropping region signal
self.emit(QtCore.SIGNAL('crop(int,int,int,int)'), *crop)
t0 = time()
n = -1
r = 0
for ent in frs:
n += 1
if not ent:
continue
x, y, w, h, fr = ent
# Create a QImage for signalling
img = QtGui.QImage()
img.loadFromData(QtCore.QByteArray(fr.data), self.compression)
# print 'FrameProcessor.readyImage',n,x,y,w,h,len(fr.data)
self.emit(
QtCore.SIGNAL('readyImage(int,int,int,int,int,QImage)'), n,
x, y, w, h, img)
r += 1
# Update counter only for good frames
if r > 0:
self.count += 1.
if self.count % 10 == 0:
fps = self.count / (time() - self.time)
self.emit(QtCore.SIGNAL('fps(float)'), fps)
self.time = time()
self.count = 0.
sleep(0.001)
# r=raw_input('Press enter for next frame')
self.exit(0)
def default_pixmap_as_bytes(self):
xres = self.imgsize
pixmap = icons.cola().pixmap(xres)
byte_array = QtCore.QByteArray()
buf = QtCore.QBuffer(byte_array)
buf.open(QtCore.QIODevice.WriteOnly)
pixmap.save(buf, 'PNG')
buf.close()
return byte_array
def __init__(self,
map_name,
download_root=VAULT_DOWNLOAD_ROOT,
parent=None):
QtCore.QObject.__init__(self, parent)
self.map_name = map_name
self.url = QtCore.QUrl(download_root + name2link(map_name))
self.data = QtCore.QByteArray()
self.reply = None
def fromQPixmap(klass, image):
'''
@param image: (QImage, QPixmap)
'''
arr = QtCore.QByteArray()
p = QtCore.QBuffer(arr)
p.open(p.WriteOnly)
image.save(p, format='PGM')
return klass(arr.data())
def __init__(self):
super(FB2Info, self).__init__()
self.Year = None
self.Genres = QtCore.QStringList()
self.Authors = []
self.Translators = []
self.documentAuthors = []
self.Sequences = []
self.publisherSequences = []
self.Coverpage = QtCore.QByteArray()
def svg2pm(svg, tam):
pm = QtGui.QPixmap(tam, tam)
pm.fill(QtCore.Qt.transparent)
qb = QtCore.QByteArray(svg)
render = QtSvg.QSvgRenderer(qb)
painter = QtGui.QPainter()
painter.begin(pm)
render.render(painter)
painter.end()
return pm
def __sendToClient(self, clientConnection, data):
dataString = ""
try:
dataString = json.dumps(data)
except Exception:
logging.error("Cann't parse data: " + unicode(data))
return
message = QtCore.QByteArray(dataString)
clientConnection.write(message + '\n')
def updateClientProgress(self, numBytes):
self.bytesWritten += numBytes
if self.bytesToWrite > 0:
self.bytesToWrite -= self.tcpClient.write(
QtCore.QByteArray('String\n'))
self.clientProgressBar.setMaximum(DialogClient.TotalBytes)
self.clientProgressBar.setValue(self.bytesWritten)
self.clientStatusLabel.setText("Sent %dMB" % (self.bytesWritten /
(1024 * 1024)))
def receive(self):
while (self.s.hasPendingDatagrams()):
datagram = QtCore.QByteArray()
size = self.s.pendingDatagramSize()
data, addr, port = self.s.readDatagram(size)
sz = "data : %s" % str(data)
print sz, ", len : %s, size : %s " % (str(len(data)), str(size))
#szRcvTxt = "data : " + sz4to1(data)
#self.lbRcvTxt.setText(szRcvTxt)
self.lbRcvTxt.setText(data)
def sendMessage():
global sock, timer
bl = QtCore.QByteArray()
out = QtCore.QDataStream(bl, QtCore.QIODevice.WriteOnly)
out.writeDouble(10)
sock.write(bl)
timer.start(30)
def load_qibla(self, angle=None):
if angle == None:
direction = settingsDialog.qibla_direction()
else:
direction = angle
simple_qibla_xml = self.qibla_svg(
self.svg_rotation_to_cardinal(direction))
qibla = QtCore.QByteArray(simple_qibla_xml)
self.svgwidget.load(qibla)
def repaint(self, graph, parent):
stream = BytesIO()
if graph:
graph.draw_graphviz(stream, 'svg')
stream.seek(0)
stream = QtCore.QByteArray(stream.read())
self.setContent(stream, 'image/svg+xml')
webframe = self.page().mainFrame()
webframe.addToJavaScriptWindowObject('pybridge', parent)
webframe.evaluateJavaScript(JS_GRAPH)
def default_pixmap_as_bytes(self):
xres = self.imgsize
pixmap = QtGui.QPixmap(resources.icon('git.svg'))
pixmap = pixmap.scaledToHeight(xres, Qt.SmoothTransformation)
byte_array = QtCore.QByteArray()
buf = QtCore.QBuffer(byte_array)
buf.open(QtCore.QIODevice.WriteOnly)
pixmap.save(buf, 'PNG')
buf.close()
return byte_array
def __init__(self, view, data):
QtSvg.QGraphicsSvgItem.__init__(self)
# The renderer must be preserved for the lifetime of the image
self.renderer = QtSvg.QSvgRenderer(QtCore.QByteArray(data))
#print "IH", self.renderer.defaultSize().height()
self.setSharedRenderer(self.renderer)
view.gScene.addItem(self)
self.uscale = 1.0
def accept(self):
settings = QtCore.QSettings()
for name in self.fontsDict.keys():
font = self.fontsDict.get(name).font()
arr = QtCore.QByteArray()
buf = QtCore.QBuffer(arr)
buf.open(QtCore.QIODevice.WriteOnly)
QtCore.QDataStream(buf) << font
settings.setValue(name, arr)
settings.sync()
super(FontSettingsDialog, self).accept()
def leePiezas(self, nombre=None): # nombre usado por compatibilidad
dic = {}
for pieza in "rnbqkpRNBQKP":
fich = os.path.join(
self.carpetaBF,
"%s%s.svg" % ("w" if pieza.isupper() else "b", pieza.lower()))
f = codecs.open(fich, "r", 'utf-8', 'ignore')
qb = QtCore.QByteArray(f.read())
f.close()
dic[pieza] = qb
return dic
def mimeData(self, indexlist):
descriptors = []
vars = []
for index in indexlist:
var = self[index.row()]
descriptors.append((var.name, vartype(var)))
vars.append(var)
mime = QtCore.QMimeData()
mime.setData(self.MIME_TYPE, QtCore.QByteArray(str(descriptors)))
mime._vars = vars
return mime
def signal_received(self, message):
logger.debug(QtCore.qVersion())
try:
if message == "reset":
self.webView.setHtml(self.blankpage)
else:
self.request = QtNetwork.QNetworkRequest()
self.request.setRawHeader(
"Content-Type",
QtCore.QByteArray('application/octet-stream'))
self.request.setRawHeader("Accept-Language",
QtCore.QByteArray("de, *"))
self.request.setUrl(QtCore.QUrl(message))
self.webView.load(self.request)
# old version without user-agent
# self.webView.load(QtCore.QUrl(message))
except:
self.webView.setHtml(self.startpage)
logger.error('receive: {}'.format(message))
def onLabelFeedbackDoubleClicked(self):
lastError = self._feedbackMessages[None]
if lastError:
dlg = Tc2DialogException.DialogException(lastError, parent=self)
dlg.restoreGeometry(
Tc2Config.settingsValue(
self.SettingsKeyDialogExceptionGeometry,
QtCore.QByteArray()).toByteArray())
dlg.exec_()
Tc2Config.settingsSetValue(self.SettingsKeyDialogExceptionGeometry,
dlg.saveGeometry())
def mouseMoveEvent(self, event):
if event.buttons() == QtCore.Qt.LeftButton:
data = QtCore.QByteArray()
mime_data = QtCore.QMimeData()
mime_data.setData("application/x-operator", data)
mime_data.setText(self.name)
drag = QtGui.QDrag(self)
drag.setMimeData(mime_data)
drag.setHotSpot(self.rect().topLeft())
drag.setPixmap(self.icon().pixmap(24, 24))
drop_action = drag.start(QtCore.Qt.MoveAction)
