def send_ctrl_to_process(self, letter):
char = chr("abcdefghijklmnopqrstuvwxyz".index(letter) + 1)
byte_array = QByteArray()
byte_array.append(char)
self.process.write(byte_array)
self.process.waitForBytesWritten(-1)
self.shell.write(locale_codec.toUnicode(byte_array), flush=True)
def qstring2path (qs):
# BUG: this is ugly; might be properly handled w/PyQt4.6/Python2.6
qba= QByteArray ()
qba.append (qs)
s= str (qba)
return s
def read(self, size):
content = self.content
self.content = ""
# content = string while the input parameter size in QByteArray
data = QByteArray(content)
data.chop(data.size() - size)
return str(data)
def read(self, size):
content = self.content
self.content = ""
# content = string while the input parameter size in QByteArray
data = QByteArray(content)
data.chop(data.size() - size)
return str(data)
def createRequest(self, operation, request, data):
if operation == self.GetOperation:
if not self.is_request_allowed(request):
request.setUrl(QUrl('forbidden://localhost/'))
else:
logger.debug(u'Quering URL: %s' % request.url().toString())
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.PreferCache)
reply = QNetworkAccessManager.createRequest(self, operation, request,
data)
reply.error.connect(self.catch_error)
reply = KitNetworkReply(self, reply)
# add Base-Url header, then we can get it from QWebView
# WTF?
if isinstance(request.originatingObject(), QWebFrame):
try:
reply.setRawHeader(
QByteArray('Base-Url'),
QByteArray('').append(request.originatingObject().page().
mainFrame().baseUrl().toString()))
except Exception as e:
logger.debug(e)
return reply
def test_dropping_the_data_emits_the_signal(self):
mw = self._get_one()
self.assertEqual(mw.supportedDropActions(), Qt.CopyAction)
self.assertIn('application/vnd.re-eat.recipe', mw.mimeTypes())
assert mw.viewport().acceptDrops()
mw.recipeAdded = DummySignal()
mimeData = QMimeData()
encodedData = QByteArray()
stream = QDataStream(encodedData, QIODevice.WriteOnly)
stream.writeInt(1)
stream.writeInt(2)
mimeData.setData('application/vnd.re-eat.recipe', encodedData)
mw.dropMimeData(0, mimeData, Qt.CopyAction)
self.assertListEqual(mw.recipeAdded.received, [(1, mw.date, mw.index),
(2, mw.date, mw.index)])
mw.recipeMoved = DummySignal()
mimeData = QMimeData()
encodedData = QByteArray()
stream = QDataStream(encodedData, QIODevice.WriteOnly)
stream.writeInt(42)
stream.writeQVariant(datetime.date.today())
stream.writeInt(2)
mimeData.setData('application/vnd.re-eat.meal_recipe', encodedData)
mw.dropMimeData(0, mimeData, Qt.CopyAction)
self.assertListEqual(
mw.recipeMoved.received,
[(42, datetime.date.today(), 2, mw.date, mw.index)])
def openUrl(self, address, op, settings):
operation = op
body = QByteArray()
self.applySettings(settings)
self.m_webPage.triggerAction(QWebPage.Stop)
if type(op) is dict:
operation = op.get('operation')
body = QByteArray(op.get('data', ''))
if operation == '':
operation = 'get'
networkOp = QNetworkAccessManager.CustomOperation
operation = operation.lower()
if operation == 'get':
networkOp = QNetworkAccessManager.GetOperation
elif operation == 'head':
networkOp = QNetworkAccessManager.HeadOperation
elif operation == 'put':
networkOp = QNetworkAccessManager.PutOperation
elif operation == 'post':
networkOp = QNetworkAccessManager.PostOperation
elif operation == 'delete':
networkOp = QNetworkAccessManager.DeleteOperation
if networkOp == QNetworkAccessManager.CustomOperation:
self.m_mainFrame.evaluateJavaScript(
'console.error("Unknown network operation: %s");' % operation)
return
self.m_mainFrame.load(QNetworkRequest(QUrl(address)), networkOp, body)
def send_ctrl_to_process(self, letter):
char = chr("abcdefghijklmnopqrstuvwxyz".index(letter) + 1)
byte_array = QByteArray()
byte_array.append(char)
self.process.write(byte_array)
self.process.waitForBytesWritten(-1)
self.shell.write(locale_codec.toUnicode(byte_array), flush=True)
def send_ctrl_to_process(self, letter):
char = chr("abcdefghijklmnopqrstuvwxyz".index(letter) + 1)
byte_array = QByteArray()
byte_array.append(char)
self.process.write(byte_array)
self.process.waitForBytesWritten(-1)
self.shell.write(QString(byte_array))
def startDrag(self, dropAction):
"""
Start drag
@param dropAction:
@type dropAction:
"""
if self.datasetView:
return
# check indexes
indexes = self.selectedIndexes()
if not indexes:
return
for index in indexes:
if not index.isValid():
return
rowVal = self.model.getValueRow(indexes[0])
if len(rowVal) > 1:
meta = QByteArray()
meta.append("description('%s')" % rowVal['key'])
# create mime data object
mime = QMimeData()
m = 'application/x-%s-description-item' % Settings.instance(
).readValue(key='Common/acronym').lower()
mime.setData(m, meta)
# start drag
drag = QDrag(self)
drag.setMimeData(mime)
drag.exec_(Qt.CopyAction)
def dataReceive(self):
while self.udpSocket.hasPendingDatagrams():
try:
if self.broadFlag == False:
continue
datagram = QByteArray()
datagram.resize(self.udpSocket.pendingDatagramSize())
msglist = self.udpSocket.readDatagram(datagram.size())
msg = msglist[0]
if len(msg) <= 21:
print "msg data smaller"
continue
timetemp = msg[0:17]
datanumth = msg[17:19]
datatotalnum = msg[19:21]
datacontent = msg[21:]
self.addToLocal(timetemp,datanumth,datatotalnum,datacontent)
del msg
del datacontent
except Exception, e:
del datacontent
self.logger.error(e.message)
def dataReceive(self):
while self.udpSocket.hasPendingDatagrams():
try:
datagram = QByteArray()
datagram.resize(self.udpSocket.pendingDatagramSize())
msglist = self.udpSocket.readDatagram(datagram.size())
if self.broadFlag == False:
continue
if len(msglist[0]) <= 21:
self.logger.info("msg data smaller")
continue
msg = msglist[0]
timetemp = msg[0:17]
datanumth = msg[17:19]
datatotalnum = msg[19:21]
datacontent = msg[21:]
self.addToLocal(timetemp,datanumth,datatotalnum,datacontent)
#del msg
#del datacontent
except Exception, e:
#del datacontent
f = open("/opt/morningcloud/massclouds/record.txt", 'a')
traceback.print_exc(file=f)
f.flush()
f.close()
self.logger.error(e.message)
class FriendFeedRequest(QObject):
def __init__(self, reply, feed = False, parent = None):
QObject.__init__(self, parent)
self.reply = reply
self.feed = feed
self.connect(self.reply, SIGNAL("readyRead()"), self.readData)
self.connect(self.reply, SIGNAL("finished()"), self.dataDone)
self.data = QByteArray()
def readData(self):
self.data.append(self.reply.readAll())
def dataDone(self):
if self.reply.error() != QNetworkReply.NoError:
self.emit(SIGNAL("error"), self.reply.error())
else:
self.data.append(self.reply.readAll())
result = simplejson.loads(str(self.data).decode("utf-8"))
if self.feed:
date_properties = frozenset(("updated", "published"))
for entry in result.get("entries", []):
entry["updated"] = self._parse_date(entry["updated"])
entry["published"] = self._parse_date(entry["published"])
for comment in entry.get("comments", []):
comment["date"] = self._parse_date(comment["date"])
for like in entry.get("likes", []):
like["date"] = self._parse_date(like["date"])
result["entries"].sort(key = lambda x:x["updated"], reverse = True)
self.emit(SIGNAL("ready"), result)
self.emit(SIGNAL("cleanup"), self)
def _parse_date(self, date_str):
rfc3339_date = "%Y-%m-%dT%H:%M:%SZ"
return datetime.datetime(*time.strptime(date_str, rfc3339_date)[:6])
def createRequest(self, operation, request, data):
if operation == self.GetOperation:
if self.is_forbidden(request):
# deny GET request for banned media type by setting dummy URL
# XXX abort properly
request.setUrl(QUrl(QString('forbidden://localhost/')))
else:
common.logger.debug(
common.to_unicode(
request.url().toString().toUtf8().data()).encode(
'utf-8'))
#print request.url().toString(), operation
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.PreferCache)
reply = QNetworkAccessManager.createRequest(self, operation, request,
data)
reply.error.connect(self.catch_error)
#add Base-Url header, then we can get it from QWebView
if isinstance(request.originatingObject(), QWebFrame):
try:
reply.setRawHeader(
QByteArray('Base-Url'),
QByteArray('').append(request.originatingObject().page().
mainFrame().baseUrl().toString()))
except Exception, e:
common.logger.debug(e)
def dataReceiveTwo(self):
while self.udpSocketTwo.hasPendingDatagrams():
datagram = QByteArray()
datagram.resize(self.udpSocketTwo.pendingDatagramSize())
msglist = self.udpSocketTwo.readDatagram(datagram.size())
msg = str(msglist[0])
self.parseMsg(msg)
def from_QImage(self, img):
buf = QByteArray()
bf = QBuffer(buf)
bf.open(QIODevice.WriteOnly)
img.save(bf, format='PNG')
self.buf = buf.data()
self.format = PackedQImage.FORMAT_PNG
self._encode()
class AudioBuffer(QIODevice):
def __init__(self, size):
QIODevice.__init__(self)
self.offset = 0
self.size_ = size
self.buffer_ = QByteArray(size, "\0")
self.real_len = 0
def receive_data(self, data):
self.writeData(data)
def set_size(self, size):
self.size_ = size
if len(self.buffer_) == 0:
self.buffer_ = QByteArray(size, "\0")
# Implementation of methods derived from QIODevice
def size(self):
return self.size_
def bytesAvailable(self):
avail = self.real_len
avail -= self.offset
#avail += super(AudioBuffer, self).bytesAvailable()
return max(avail, 0)
def readAll(self):
return QByteArray(self.buffer_)
def readData(self, maxlen):
while self.bytesAvailable() == 0:
qApp.processEvents()
time.sleep(0.01)
number = min(maxlen, len(self.buffer_) - self.offset)
data = self.buffer_[self.offset:self.offset + number]
self.offset += number
return str(data)
def writeData(self, data):
self.buffer_.replace(self.real_len, len(data), QByteArray(data))
self.real_len += len(data)
self.readyRead.emit()
def seek(self, pos):
if pos <= len(self.buffer_):
self.offset = pos
QIODevice.seek(self, pos)
return True
else:
return False
def isSequential(self):
return False
def pos(self):
return self.offset
def pasted(self, checked):
clipboard = QApplication.clipboard()
mime = clipboard.mimeData()
if mime.hasImage():
pixmap = clipboard.pixmap()
byteArray = QByteArray()
buffer = QBuffer(byteArray)
pixmap.save(buffer, "PNG")
self.call("setClipboard", str(byteArray.toBase64(), sys.stdout.encoding))
def pasted(self, checked):
clipboard = QApplication.clipboard()
mime = clipboard.mimeData()
if mime.hasImage():
pixmap = clipboard.pixmap()
byteArray = QByteArray()
buffer = QBuffer(byteArray)
pixmap.save(buffer, "PNG")
self.call("setClipboard", str(byteArray.toBase64(), sys.stdout.encoding))
def restoreSettingsConsole(self):
storedTabScripts = self.settings.value("pythonConsole/tabScripts", [])
self.tabListScript = storedTabScripts
self.splitter.restoreState(
self.settings.value("pythonConsole/splitterConsole", QByteArray()))
self.splitterEditor.restoreState(
self.settings.value("pythonConsole/splitterEditor", QByteArray()))
self.splitterObj.restoreState(
self.settings.value("pythonConsole/splitterObj", QByteArray()))
def path2qurl (path):
# path= '/home/mdione/media/music/Patricio Rey Y Sus Redonditos De Ricota/\xc3\x9altimo bondi a Finisterre/07- La peque\xf1a novia del carioca.wav'
qba= QByteArray (path)
qu= QUrl.fromEncoded (qba.toPercentEncoding ("/ "))
# older versions need this, at least for the gstreamer backend
if qu.scheme ()=='':
qu.setScheme ('file')
return qu
def __init__(self, files_to_load):
QMainWindow.__init__(self)
self._inited = False
self._currentMatcher = None
self._lastMatch = None
global globalMainWindow
globalMainWindow = self
self.setWindowTitle(QApplication.applicationName())
self.setWindowIcon(QIcon(':/main/images/hex.png'))
self.subWidgets = []
self._activeSubWidget = None
self.tabsWidget = QTabWidget(self)
self.tabsWidget.setDocumentMode(True)
self.tabsWidget.setTabsClosable(True)
self.tabsWidget.setFocusPolicy(Qt.StrongFocus)
self.tabsWidget.currentChanged.connect(self._onTabChanged)
self.tabsWidget.tabCloseRequested.connect(self.closeTab)
self.setCentralWidget(self.tabsWidget)
self.setFocusProxy(self.tabsWidget)
self.setFocus()
QApplication.instance().focusChanged.connect(self._onGlobalFocusChanged)
self.createActions()
self.buildMenus()
self.buildStatusbar()
self.buildToolbar()
self.dockSearch = SearchDockWidget(self)
self.dockSearch.hide()
self.addDockWidget(Qt.BottomDockWidgetArea, self.dockSearch)
geom = globalQuickSettings['mainWindow.geometry']
if geom and isinstance(geom, str):
self.restoreGeometry(QByteArray.fromHex(geom))
else:
self.resize(800, 600)
state = globalQuickSettings['mainWindow.state']
if state and isinstance(state, str):
self.restoreState(QByteArray.fromHex(state))
app = QApplication.instance()
for file_to_load in files_to_load:
load_options = documents.FileLoadOptions()
load_options.readOnly = app.args.readOnly
load_options.freezeSize = app.args.freezeSize
if app.args.noLoadDialog:
self.openFile(file_to_load, load_options)
else:
self.openFileWithOptionsDialog(file_to_load, load_options)
def get_html_img(scene):
"""
Create HTML img element with base64-encoded image from the scene
"""
byte_array = QByteArray()
filename = QBuffer(byte_array)
filename.open(QIODevice.WriteOnly)
PngFormat.write(filename, scene)
img_encoded = byte_array.toBase64().data().decode("utf-8")
return "<img src='data:image/png;base64,%s'/>" % img_encoded
def get_html_img(scene):
"""
Create HTML img element with base64-encoded image from the scene
"""
byte_array = QByteArray()
filename = QBuffer(byte_array)
filename.open(QIODevice.WriteOnly)
PngFormat.write(filename, scene)
img_encoded = byte_array.toBase64().data().decode("utf-8")
return "<img src='data:image/png;base64,%s'/>" % img_encoded
def mimeData(self, items):
""" Returns QMimeData for drag and drop.
"""
logging.debug(self.__class__.__name__ + ": mimeData()")
mime = QMimeData()
encodedData = QByteArray()
for item in items:
encodedData.append(item.text(0))
mime.setData(self.mimeType(), encodedData)
return mime
def mimeData(self, items):
""" Returns QMimeData for drag and drop.
"""
logging.debug(self.__class__.__name__ + ": mimeData()")
mime = QMimeData()
encodedData = QByteArray()
for item in items:
encodedData.append(item.text(0))
mime.setData(self.mimeType(), encodedData)
return mime
def issueRequest(self, inpdata):
self.request = QByteArray()
stream = QDataStream(self.request, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_2)
stream.writeUInt16(0)
stream << inpdata
stream.device().seek(0)
stream.writeUInt16(self.request.size() - SIZEOF_UINT16)
if self.socket.isOpen():
self.socket.close()
self.socket.connectToHost("127.0.0.1", PORT)
def handle_request(self):
sock = self.sender()
logger.info("handle_request: %s %d", sock.peerAddress(), sock.peerPort())
sock_id = id(sock)
if sock.state() in (QTcpSocket.UnconnectedState, QTcpSocket.ClosingState):
logger.info("connection closed")
self.sockets.remove(sock)
sock.deleteLater()
return
client_data = str(sock.readAll())
logger.info("request %r", client_data)
line = client_data.split("\r\n")[0]
logger.info("first line: %r", line)
try:
resource, ext, http_version = self.get_regex.match(line).groups()
logger.info("resource=%r, ext=%r, http_version=%r", resource, ext, http_version)
except AttributeError:
try:
host, port = self.host_regex.match(line).groups()
print "found host header", host, port
return
#sock.write("HTTP/1.1 501 Not Implemented\r\n")
except AttributeError:
logger.info("no matching request - sending 404 not found")
sock.write("HTTP/1.1 404 Not Found\r\n")
return
else:
if ext == "ico":
directory = os.path.dirname(os.path.abspath(__file__))
data = open(os.path.join(directory, "favicon.ico"), "rb").read()
sock.write(QByteArray('HTTP/1.1 200 Ok\r\nContent-Type: image/x-ico\r\n\r\n%s' % data))
elif ext == "html":
directory = os.path.dirname(os.path.abspath(__file__))
data = open(os.path.join(directory, "index.html"), "rb").read() % sock_id
self.html_map[sock_id] = None
sock.write(QByteArray('HTTP/1.1 200 Ok\r\nContent-Type: text/html;encoding: utf-8\r\n\r\n%s' % data))
elif ext == "mjpeg":
try:
_, html_sock_id = resource.split("_", 1)
html_sock_id = int(html_sock_id)
except ValueError:
html_sock_id = None
if sock not in self.stream_clients:
logger.info("starting streaming...")
if html_sock_id is not None:
self.html_map[html_sock_id] = sock
self.stream_clients.append(sock)
sock.write(QByteArray('HTTP/1.1 200 Ok\r\nContent-Type: multipart/x-mixed-replace; boundary=--2342\r\n\r\n'))
else:
logger.error("request not found/handled - sending 404 not found")
sock.write("HTTP/1.1 404 Not Found\r\n")
def do_ftp_put(self):
num = len(self.files)
for i in range(num):
file = self.files[i]
fhandle = QFile(file)
fhandle.open(QIODevice.ReadOnly)
byte_array = QByteArray()
byte_array.append(fhandle.readData(fhandle.size()))
fileinfo = QFileInfo(file)
filename = fileinfo.fileName()
self.ftp.put(byte_array, filename)
self.ftp.close()
def restoreGuiSettings(self):
settings = QSettings('sim.informatik.tu-darmstadt.de', 'Servo Tool')
settings.beginGroup('MainWindow')
self.restoreState(
settings.value('state', QVariant(QByteArray())).toByteArray())
self.resize(settings.value('size', QVariant(QSize(800, 600))).toSize())
self.move(settings.value('pos', QVariant(QPoint(200, 200))).toPoint())
self.splitter.restoreState(
settings.value('splitter', QVariant(QByteArray())).toByteArray())
self.splitter_2.restoreState(
settings.value('splitter_2', QVariant(QByteArray())).toByteArray())
self.spinLogLevel.setValue(
settings.value('logLevel', QVariant(3)).toInt()[0])
settings.endGroup()
def loadSettings(self):
'''
If a settings file exists, then the settings are loaded from it. These override the default values.
'''
try:
with open(settingsFileName) as settingsFile:
settings = settingsFile.readlines()
except IOError:
print("Couldn't read last state from file. Ignoring...")
return
for i in range(len(settings)):
try:
line = makeAllWhitespaceSpaces(settings[i]).split(' ')
if line[0] == 'SIZE':
self.lastWindowWidth = int(line[1])
self.lastWindowHeight = int(line[2])
elif line[0] == 'POSITION':
self.lastWindowLeft = int(line[1])
self.lastWindowTop = int(line[2])
elif line[0] == 'TIME_DECMALStretchyCenteredDisplay_PLACES':
self.decimalPlaces = int(line[1])
elif line[0] == 'INPUT_METHOD' and line[1] in acceptedInputMethods:
self.inputMethod = line[1]
elif line[0] == 'INSPECTION_ENABLED' and line[1] in ['0', '1']:
self.inspectionEnabled = int(line[1])
elif line[0] == 'INSPECTION_TIME':
self.inspectionTimeLimit = int(line[1])
elif line[0] == 'SCRAMBLE_FONT':
fontStartPos = settings[i].find(line[1])
self.newScrambleFont = QtGui.QFont()
self.newScrambleFont.fromString(settings[i][fontStartPos:].strip())
elif line[0] == 'TIMER_DISPLAY_SETTINGS':
self.timerDisplaySplitterSizes = QByteArray.fromHex(line[1].split("'")[1])
elif line[0] == 'BOTTOM_PANEL_SETTINGS':
self.bottomPanelSplitterSizes = QByteArray.fromHex(line[1].split("'")[1])
except:
print("Error reading line", i, "in settings file")
print(" " + settings[i].strip())
def restoreWindowState(self):
# GUI settings
history = util.readConfigString(GeneralConfig, "Url History", '')\
.split(',')
self.characterCombo.insertItems(history)
self.historyLength = util.readConfigInt(GeneralConfig, "History Length",
20)
self.autoLookup = util.readConfigString(GeneralConfig,
"Auto-Lookup clipboard", str(False)) != "False"
self.autoLookupAction.setChecked(self.autoLookup)
self.onlyAutoLookupCJKCharacters = util.readConfigString(GeneralConfig,
"Auto-Lookup only Chinese characters", str(False)) != "False"
self.splitterFrame.restoreState(QByteArray.fromBase64(
str(util.readConfigString(GeneralConfig, "Splitter", ""))))
self.splitterSizes = [int(i) for i \
in util.readConfigString(GeneralConfig, "Splitter sizes",
"220,426").split(',')]
self.toolbarOriginalState = QByteArray.fromBase64(
str(util.readConfigString(GeneralConfig, "Toolbar original state",
"")))
self.restoreState(self.toolbarOriginalState)
self.menuBar().setVisible(True)
self.characterChooser.setCurrentIndex(util.readConfigInt(GeneralConfig,
"Toolbox current", 0))
visible = GeneralConfig.readEntry("Toolbox visibile", str(True))
if visible == "False":
self.characterChooserOriginalVisibility = False
else:
self.splitterFrame.setSizes(self.splitterSizes)
self.characterChooserOriginalVisibility = True
self.characterChooser.setVisible(
self.characterChooserOriginalVisibility)
self.toggleToolboxAction.setChecked(
self.characterChooserOriginalVisibility)
w = util.readConfigInt(GeneralConfig, "Width", 640)
h = util.readConfigInt(GeneralConfig, "Height", 420)
self.defaultWindowSize = QSize(w, h)
x = util.readConfigInt(GeneralConfig, "LastX", 0)
y = util.readConfigInt(GeneralConfig, "LastY", 0)
mini_w = util.readConfigInt(GeneralConfig, "Mini-mode Width", 400)
mini_h = util.readConfigInt(GeneralConfig, "Mini-mode Height", 200)
self.miniModeWindowSize = QSize(mini_w, mini_h)
self.setGeometry(x, y, w, h)
def do_ftp_put(self):
num = len(self.files)
for i in range(num):
file = self.files[i]
fhandle = QFile(file)
fhandle.open(QIODevice.ReadOnly)
byte_array = QByteArray()
byte_array.append(fhandle.readData(fhandle.size()))
fileinfo = QFileInfo(file)
filename = fileinfo.fileName()
self.ftp.put(byte_array, filename)
self.ftp.close()
def rasterize_svg(self, elem, width=0, height=0, format='PNG'):
view_box = elem.get('viewBox', elem.get('viewbox', None))
sizes = None
logger = self.oeb.logger
if view_box is not None:
try:
box = [
float(x) for x in filter(None, re.split('[, ]', view_box))
]
sizes = [box[2] - box[0], box[3] - box[1]]
except (TypeError, ValueError, IndexError):
logger.warn(
'SVG image has invalid viewBox="%s", ignoring the viewBox'
% view_box)
else:
for image in elem.xpath(
'descendant::*[local-name()="image" and '
'@height and contains(@height, "%")]'):
logger.info(
'Found SVG image height in %, trying to convert...')
try:
h = float(image.get('height').replace('%', '')) / 100.
image.set('height', str(h * sizes[1]))
except:
logger.exception(
'Failed to convert percentage height:',
image.get('height'))
data = QByteArray(xml2str(elem, with_tail=False))
svg = QSvgRenderer(data)
size = svg.defaultSize()
if size.width() == 100 and size.height() == 100 and sizes:
size.setWidth(sizes[0])
size.setHeight(sizes[1])
if width or height:
size.scale(width, height, Qt.KeepAspectRatio)
logger.info('Rasterizing %r to %dx%d' %
(elem, size.width(), size.height()))
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
image.fill(QColor("white").rgb())
painter = QPainter(image)
svg.render(painter)
painter.end()
array = QByteArray()
buffer = QBuffer(array)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, format)
return str(array)
def testQByteArrayCell(self):
_, filename = tempfile.mkstemp('.xls')
writer = Writer(filename)
row0 = ['ID', 'NUMBER']
row1 = [QByteArray('0'), QByteArray('42')]
writer.writeAttributeRow(0, row0)
writer.writeAttributeRow(1, row1)
writer.saveFile()
reader = Reader(filename)
rows = reader.openFile()
assert rows[1][0] == 0
assert rows[1][1] == 42
os.remove(filename)
def dataReceiveTest(self):
while self.udpSocket.hasPendingDatagrams():
try:
datagram = QByteArray()
datagram.resize(self.udpSocket.pendingDatagramSize())
self.udpSocket.readDatagram(datagram.size())
except Exception, e:
#del datacontent
f = open("/opt/morningcloud/massclouds/record.txt", 'a')
traceback.print_exc(file=f)
f.flush()
f.close()
self.logger.error(e.message)
def readSessionSettings(self, settings):
"""Restore ourselves from session manager settings.
These methods store much more information than the readSettings and
writeSettings methods. This method tries to restore window size and
position. Also the objectName() is set, so that the window manager can
preserve stacking order, etc.
"""
name = settings.value('name', '', type(""))
if name:
self.setObjectName(name)
self.restoreGeometry(
settings.value('geometry', QByteArray(), QByteArray))
self.restoreState(settings.value('state', QByteArray(), QByteArray))
def __init__(self, my_cookie_dict):
super(QWebView, self).__init__()
# 将字典转化成QNetworkCookieJar的格式
self.cookie_jar = QNetworkCookieJar()
cookies = []
for key, values in my_cookie_dict.items():
my_cookie = QNetworkCookie(QByteArray(key), QByteArray(values))
#my_cookie.setDomain('.baidu.com')
cookies.append(my_cookie)
self.cookie_jar.setAllCookies(cookies)
# 如果没有在前面设置domain,那么可以在这里指定一个url作为domain
# self.cookie_jar.setCookiesFromUrl(cookies, QUrl('https://www.baidu.com/'))
# 最后cookiejar替换完成
self.page().networkAccessManager().setCookieJar(self.cookie_jar)
def mouseMoveEvent(self, event):
"""Override Qt method"""
if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \
(event.pos() - self.__drag_start_pos).manhattanLength() > \
QApplication.startDragDistance():
drag = QDrag(self)
mimeData = QMimeData()
mimeData.setData("parent-id", QByteArray.number(id(self.ancestor)))
mimeData.setData("tabwidget-id",
QByteArray.number(id(self.parentWidget())))
mimeData.setData("tabbar-id", QByteArray.number(id(self)))
mimeData.setData("source-index",
QByteArray.number(self.tabAt(self.__drag_start_pos)))
drag.setMimeData(mimeData)
drag.exec_()
QTabBar.mouseMoveEvent(self, event)
def __init__(self, iface):
QDialog.__init__(self, iface.mainWindow())
self.iface = iface
self.setupUi(self)
# self.setModal(False) # we want to be able to interact with the featuresmc.extent().width()
# self.setWindowFlags( Qt.SubWindow )
# adjust user interface
self.setWindowTitle(self.tr("Check geometry validity"))
self.cmbField.setVisible(False)
self.label.setVisible(False)
self.useSelected.setVisible(True)
self.label_2.setText(self.tr("Geometry errors"))
self.label_4.setText(self.tr("Total encountered errors"))
self.partProgressBar.setVisible(False)
self.tblUnique.setSelectionMode(QAbstractItemView.SingleSelection)
self.tblUnique.setSelectionBehavior(QAbstractItemView.SelectRows)
# populate list of available layers
myList = ftools_utils.getLayerNames([QGis.Point, QGis.Line, QGis.Polygon])
self.connect(self.tblUnique, SIGNAL("currentItemChanged(QTableWidgetItem*, QTableWidgetItem*)"), self.zoomToError)
self.inShape.addItems(myList)
self.buttonBox_2.setOrientation(Qt.Horizontal)
self.cancel_close = self.buttonBox_2.button(QDialogButtonBox.Close)
self.buttonOk = self.buttonBox_2.button(QDialogButtonBox.Ok)
self.progressBar.setValue(0)
self.storedScale = self.iface.mapCanvas().scale()
# create marker for error
self.marker = MarkerErrorGeometry(self.iface.mapCanvas())
settings = QSettings()
self.restoreGeometry(settings.value("/fTools/ValidateDialog/geometry", QByteArray(), type=QByteArray))
QObject.connect(self.browseShpError, SIGNAL("clicked()"), self.outFile)
QObject.connect(self.ckBoxShpError, SIGNAL("stateChanged( int )"), self.updateGui)
self.updateGui()
def get_png_image( input_svg_file, newWidth = None, verify = True ):
assert( os.path.basename( input_svg_file ).endswith( '.svg' ) or
os.path.basename( input_svg_file ).endswith( '.svgz') )
assert( os.path.isfile( input_svg_file ) )
if os.path.basename( input_svg_file ).endswith( '.svgz' ):
r = QSvgRenderer( QByteArray( gzip.open( input_svg_file, 'rb' ).read( ) ) )
files = { 'file' : gzip.open( input_svg_file, 'rb' ) }
else:
r = QSvgRenderer( input_svg_file )
files = { 'file' : open( input_svg_file, 'rb' ) }
width = r.defaultSize().width()
height = r.defaultSize().height()
apiKey = get_cloudconvert_api_key( )
params = { 'apikey' : apiKey,
'input' : 'upload',
'inputformat' : 'svg',
'outputformat' : 'png',
}
if newWidth is not None:
assert( isinstance( newWidth, int ) )
assert( newWidth > 10 )
newHeight = int( height * 1.0 * newWidth / width )
params['converteroptions[resize]'] = '%dx%d' % ( newWidth, newHeight )
#
##
response = requests.post( "https://api.cloudconvert.com/convert", params = params,
files = files, verify = verify )
if response.status_code != 200:
raise ValueError("Error, could not upload and convert SVG file %s." % input_svg_file )
img = Image.open( StringIO( response.content ) )
return img
def getBytes(self):
""" Get the text as bytes (utf-8 encoded). This is how
the data is stored internally. """
len = self.SendScintilla(self.SCI_GETLENGTH) + 1
bb = QByteArray(len, '0')
self.SendScintilla(self.SCI_GETTEXT, len, bb)
return bytes(bb)[:-1]
def restoreWidgetPosition(self):
restored = False
if self.save_position:
geometry = self.savedWidgetGeometry
if geometry is not None:
restored = self.restoreGeometry(QByteArray(geometry))
if restored:
space = qApp.desktop().availableGeometry(self)
frame, geometry = self.frameGeometry(), self.geometry()
#Fix the widget size to fit inside the available space
width = space.width() - (frame.width() - geometry.width())
width = min(width, geometry.width())
height = space.height() - (frame.height() - geometry.height())
height = min(height, geometry.height())
self.resize(width, height)
# Move the widget to the center of available space if it is
# currently outside it
if not space.contains(self.frameGeometry()):
x = max(0, space.width() / 2 - width / 2)
y = max(0, space.height() / 2 - height / 2)
self.move(x, y)
return restored
def read_output(self, error=False):
if error:
self.process.setReadChannel(QProcess.StandardError)
else:
self.process.setReadChannel(QProcess.StandardOutput)
bytes = QByteArray()
while self.process.bytesAvailable():
if error:
bytes += self.process.readAllStandardError()
else:
bytes += self.process.readAllStandardOutput()
text = unicode( QString.fromLocal8Bit(bytes.data()) )
if error:
self.error_output += text
else:
self.output += text
def __init__(self, reply, feed = False, parent = None):
QObject.__init__(self, parent)
self.reply = reply
self.feed = feed
self.connect(self.reply, SIGNAL("readyRead()"), self.readData)
self.connect(self.reply, SIGNAL("finished()"), self.dataDone)
self.data = QByteArray()
def paintEvent(self, event):
option=QStyleOption()
option.initFrom(self)
h=option.rect.height()
w=option.rect.width()
if self.m_shape in (QLed.Triangle, QLed.Round):
aspect=(4/3.0) if self.m_shape==QLed.Triangle else 2.0
ah=w/aspect
aw=w
if ah>h:
ah=h
aw=h*aspect
x=abs(aw-w)/2.0
y=abs(ah-h)/2.0
bounds=QRectF(x,y,aw,ah)
else:
size=min(w,h)
x=abs(size-w)/2.0
y=abs(size-h)/2.0
bounds=QRectF(x,y,size,size)
painter=QPainter(self);
painter.setRenderHint(QPainter.Antialiasing, True);
(dark_r,dark_g,dark_b)=self.colours[self.m_onColour if self.m_value else self.m_offColour]
dark_str="rgb(%d,%d,%d)" % (dark_r,dark_g,dark_b)
light_str="rgb(%d,%d,%d)" % self.adjust(dark_r,dark_g,dark_b)
self.renderer.load(QByteArray(self.shapes[self.m_shape] % (dark_str,light_str)))
self.renderer.render(painter, bounds)
def loadGeometry(self):
import hex.settings as settings
if self.name:
saved_geom = settings.globalQuickSettings()[self.name + '.geometry']
if saved_geom and isinstance(saved_geom, str):
self.restoreGeometry(QByteArray.fromHex(saved_geom))
def mimeData(self, indexes):
nodes = dedupe(index.internalPointer() for index in indexes)
paths = [str(self.name + node.ref.path) for node in nodes]
data = '\n'.join(paths).encode('utf-8')
mimeData = QMimeData()
mimeData.setData(MIME_PATHS, QByteArray(data))
return mimeData
def read_output(self, error=False):
if error:
self.process.setReadChannel(QProcess.StandardError)
else:
self.process.setReadChannel(QProcess.StandardOutput)
bytes = QByteArray()
while self.process.bytesAvailable():
if error:
bytes += self.process.readAllStandardError()
else:
bytes += self.process.readAllStandardOutput()
text = unicode(QString.fromLocal8Bit(bytes.data()))
if error:
self.error_output += text
else:
self.output += text
def __init__(self):
QWidget.__init__(self)
self.tray = Tray(self)
self.setMinimumSize(QSize(320, 200))
self.setWindowFlags(Qt.Popup|Qt.FramelessWindowHint)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(1)
self.text = QTextBrowser(self)
self.text.setReadOnly(True)
self.text.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.text.setOpenExternalLinks(True)
self.verticalLayout.addWidget(self.text)
self.text.textChanged.connect(self.on_text_changed)
self.notify = Notify(self)
self.movie = QMovie()
dev = QBuffer()
dev.setData(QByteArray.fromBase64(CHECK_IMAGE))
dev.open(QBuffer.ReadOnly)
dev.setParent(self.movie)
self.movie.setDevice(dev)
self.movie.frameChanged.connect(self.on_frame_changed)
self.realized = False
self.show()
def open(self, address, method='get', headers={}, auth=None):
"""Opens a web page.
:param address: The resource URL.
:param method: The Http method.
:param headers: An optional dict of extra request hearders.
:param auth: An optional tupple of HTTP auth (username, password).
:return: Page resource, All loaded resources.
"""
body = QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise Exception("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
if not "User-Agent" in headers:
headers["User-Agent"] = self.user_agent
for header in headers:
request.setRawHeader(header, headers[header])
self._auth = auth
self._auth_attempt = 0 # Avoids reccursion
self.main_frame.load(request, method, body)
self.loaded = False
return self.wait_for_page_loaded()
def __init__(self):
QWidget.__init__(self)
self.tray = Tray(self)
self.setMinimumSize(QSize(320, 200))
self.setWindowFlags(Qt.Popup | Qt.FramelessWindowHint)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(1)
self.text = QTextBrowser(self)
self.text.setReadOnly(True)
self.text.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.text.setOpenExternalLinks(True)
self.verticalLayout.addWidget(self.text)
self.text.textChanged.connect(self.on_text_changed)
self.notify = Notify(self)
self.movie = QMovie()
dev = QBuffer()
dev.setData(QByteArray.fromBase64(CHECK_IMAGE))
dev.open(QBuffer.ReadOnly)
dev.setParent(self.movie)
self.movie.setDevice(dev)
self.movie.frameChanged.connect(self.on_frame_changed)
self.realized = False
self.show()
def exportThumbnail(self, report_path, thumbpath, name, node, size=None):
self.thumbnailer = Thumbnailer()
if self.thumbnailer.isThumbnailable(node):
pixmap = self.thumbnailer.generate(node,
iconSize=256,
frames=10,
blocking=True)
self.thumbnailer.unregister()
if pixmap:
try:
exportPath = os.path.join(report_path,
os.path.join(thumbpath, name))
array = QByteArray()
qfile = QBuffer(array)
qfile.open(QIODevice.ReadWrite)
pixmap.save(qfile, 'JPG')
qfile.seek(0)
with open(exportPath, 'wb') as f:
f.write(qfile.read(qfile.size()))
qfile.close()
return True
except Exception as e:
qfile.close()
return False
else:
return False
def queryExit(self):
"""
save config data before exiting
"""
self.emit(SIGNAL("writeSettings()"))
if self.miniMode:
self.miniModeWindowSize = self.size()
else:
self.defaultWindowSize = self.size()
GeneralConfig.writeEntry("Width", str(self.defaultWindowSize.width()))
GeneralConfig.writeEntry("Height", str(self.defaultWindowSize.height()))
GeneralConfig.writeEntry("LastX", str(self.x()))
GeneralConfig.writeEntry("LastY", str(self.y()))
GeneralConfig.writeEntry("Mini-mode Width",
str(self.miniModeWindowSize.width()))
GeneralConfig.writeEntry("Mini-mode Height",
str(self.miniModeWindowSize.height()))
GeneralConfig.writeEntry("Show installer on startup", 'False')
GeneralConfig.writeEntry("Url History",
self.characterCombo.historyItems()[:self.historyLength])
GeneralConfig.writeEntry("Splitter",
QByteArray.toBase64(self.splitterFrame.saveState()))
GeneralConfig.writeEntry("Auto-Lookup clipboard", str(self.autoLookup))
GeneralConfig.writeEntry("Auto-Lookup only Chinese characters",
str(self.onlyAutoLookupCJKCharacters))
# toolbox
if self.characterChooser.isVisible():
self.splitterSizes = self.splitterFrame.sizes()
GeneralConfig.writeEntry("Splitter sizes", ",".join(
[str(i) for i in self.splitterSizes]))
if not self.miniMode:
self.toolbarOriginalState = self.saveState(0)
GeneralConfig.writeEntry("Toolbar original state",
QByteArray.toBase64(self.toolbarOriginalState))
GeneralConfig.writeEntry("Toolbox current",
str(self.characterChooser.currentIndex()))
GeneralConfig.writeEntry("Toolbox visibile",
str(self.characterChooserOriginalVisibility))
return True
def __init__(self, parent):
QFrame.__init__(self,parent)
self.filename = QString()
self.copiedItem = QByteArray()
self.pasteOffset = 5
self.prevPoint = QPoint()
self.addOffset = 5
self.screenSize = (320, 240)
self.bgColor = QColor(244,244,244)
'''0.Portrait 1.Landscape'''
self.orientation = 0
self.currentItem = None
self.printer = QPrinter(QPrinter.HighResolution)
self.printer.setPageSize(QPrinter.Letter)
'''Header'''
self.headingBar = HeadingBar(self)
'''WidgetsBar'''
self.widgetsBar = WidgetsBar(self)
'''Property'''
self.propertyBar = PropertyBar(self)
'''view'''
viewLayoutWidget = QFrame()
viewLayoutWidget.setFrameShape(QFrame.StyledPanel)
viewLayout = QHBoxLayout(viewLayoutWidget)
#viewLayout.setMargin(10)
self.view = ScreenView(viewLayoutWidget)
'''scene'''
self.scene = QGraphicsScene(self)
#self.scene.selectionChanged.connect(self.setConnect)
#self.view.setStyleSheet("border: 1px solid red;")
self.setBackgroundColor(self.bgColor)
self.setScreenSize(self.screenSize)
self.view.setScene(self.scene)
self.view.setAlignment(Qt.AlignCenter)
self.connect(self.view, SIGNAL("dropped"),self.addPixmapFile)
self.scroll_off = 1
self.setScrollBar()
viewLayout.setMargin(0)
viewLayout.addWidget(self.view)
self.wrapped = [] # Needed to keep wrappers alive
layout = QVBoxLayout(self)
layout.addWidget(self.headingBar)
layout.addWidget(viewLayoutWidget)
layout.addWidget(self.widgetsBar)
layout.addWidget(self.propertyBar)
layout.setMargin(0)
self.setLayout(layout)
def writeSettings(self):
if self.pluginConfig:
self.pluginConfig.writeEntry("Component splitter",
QByteArray.toBase64(self.componentSplitter.saveState()))
self.pluginConfig.writeEntry("Component include similar",
str(self.includeSimilar))
self.pluginConfig.writeEntry("Component include variants",
str(self.includeVariants))
def get_icon(data):
image = QImage()
bytearr = QByteArray.fromBase64(data)
image.loadFromData(bytearr, "PNG")
pixmap = QPixmap.fromImage(image)
icon = QIcon()
icon.addPixmap(pixmap)
return icon
def mimeData(self, indexes ):
"""See QAbstractItemModel documentation"""
if len(indexes) != 1:
return 0
data = QMimeData()
data.setData( self.mimeTypes()[0], QByteArray.number( indexes[0].row() ) )
return data
def dataReceive(self):
self.datareceivenum+=1
while self.udpSocket.hasPendingDatagrams():
datagram = QByteArray()
datagram.resize(self.udpSocket.pendingDatagramSize())
msglist = self.udpSocket.readDatagram(datagram.size())
if self.broadFlag == False:
continue
msg = msglist[0]
timetemp = msg[0:17]
datanumth = msg[17:19]
datatotalnum = msg[19:21]
datacontent = msg[21:]
self.addToLocal(timetemp,datanumth,datatotalnum,datacontent)
self.datanum+=1
