def __init__(self, data, min, max, settings, type):
super(SelectPlottedPoints, self).__init__()
self.ui = Ui_SelectPlottedPoints()
self.ui.setupUi(self)
self.type = type
self.min = min
self.y_axis = data[min:max]
self.x_axis = np.arange(min, min + len(self.y_axis))
self.ui.x_coordinate.setRange(self.x_axis[0], self.x_axis[-1])
self.plot = QtCommons.nestWidget(self.ui.plot_widget,
QMathPlotWidget())
self.finished.connect(lambda: self.deleteLater())
self.ui.smoothing_factor.valueChanged.connect(self.factor_valueChanged)
self.ui.smoothing_degree.valueChanged.connect(lambda v: self.draw())
self.ui.smoothing_factor_auto.toggled.connect(lambda v: self.draw())
self.ui.smoothing_factor_auto.toggled.connect(
lambda v: self.ui.smoothing_factor.setEnabled(not v))
self.restoreGeometry(
settings.value('select_plotted_points_geometry', QByteArray()))
self.finished.connect(lambda: settings.setValue(
'select_plotted_points_geometry', self.saveGeometry()))
self.ui.x_coordinate.valueChanged.connect(self.set_point)
QTimer.singleShot(100, self.draw)
def set_window_settings(self, hexstate, window_size, prefs_dialog_size,
pos, is_maximized, is_fullscreen):
"""Set window settings
Symetric to the 'get_window_settings' accessor"""
self.setUpdatesEnabled(False)
self.window_size = QSize(window_size[0], window_size[1]) # w, h
self.prefs_dialog_size = QSize(prefs_dialog_size[0],
prefs_dialog_size[1]) # w, h
self.window_position = QPoint(pos[0], pos[1]) # x,y
self.setWindowState(Qt.WindowNoState)
self.resize(self.window_size)
self.move(self.window_position)
# Window layout
if hexstate:
self.restoreState(QByteArray().fromHex(
str(hexstate).encode('utf-8')))
# [Workaround for Issue 880]
# QDockWidget objects are not painted if restored as floating
# windows, so we must dock them before showing the mainwindow.
for widget in self.children():
if isinstance(widget, QDockWidget) and widget.isFloating():
self.floating_dockwidgets.append(widget)
widget.setFloating(False)
# Is fullscreen?
if is_fullscreen:
self.setWindowState(Qt.WindowFullScreen)
# self.__update_fullscreen_action()
# Is maximized?
if is_fullscreen:
self.maximized_flag = is_maximized
elif is_maximized:
self.setWindowState(Qt.WindowMaximized)
self.setUpdatesEnabled(True)
def start_drag(self, mouse_event):
"""
starts a drag event and sends necessary data via mime types
called from mouseMoveEvent() when mouse leaves current track,
deletes the current timeable if drop was succesfull
"""
# hide timeable while dragging
self.setVisible(False)
# write timeable data
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
QDataStream.writeString(data_stream, str.encode(self.view_id))
mimeData = QMimeData()
mimeData.setData('ubicut/timeable', item_data)
if self.model.is_video or (self.model.is_video is None):
mimeData.setText("is_video")
else:
mimeData.setText("is_audio")
# set first frame as pixmap
frame = self.model.get_first_frame()
pixmap = get_pixmap_from_file(self.model.file_name, frame)
# start drag
drag = QDrag(self.scene())
drag.setMimeData(mimeData)
drag.setPixmap(pixmap.scaled(QSize(100, 100), Qt.KeepAspectRatio))
# delete the timeable if the the item was succesfully dropped
if (drag.exec_(Qt.MoveAction) == Qt.MoveAction):
self.delete(hist=False)
else:
self.setVisible(True)
def image_to_data(img, compression_quality=95, fmt='JPEG', png_compression_level=9, jpeg_optimized=True, jpeg_progressive=False):
'''
Serialize image to bytestring in the specified format.
:param compression_quality: is for JPEG and goes from 0 to 100. 100 being lowest compression, highest image quality
:param png_compression_level: is for PNG and goes from 0-9. 9 being highest compression.
:param jpeg_optimized: Turns on the 'optimize' option for libjpeg which losslessly reduce file size
:param jpeg_progressive: Turns on the 'progressive scan' option for libjpeg which allows JPEG images to be downloaded in streaming fashion
'''
fmt = fmt.upper()
ba = QByteArray()
buf = QBuffer(ba)
buf.open(QBuffer.WriteOnly)
if fmt == 'GIF':
w = QImageWriter(buf, b'PNG')
w.setQuality(90)
if not w.write(img):
raise ValueError('Failed to export image as ' + fmt + ' with error: ' + w.errorString())
return png_data_to_gif_data(ba.data())
is_jpeg = fmt in ('JPG', 'JPEG')
w = QImageWriter(buf, fmt.encode('ascii'))
if is_jpeg:
if img.hasAlphaChannel():
img = blend_image(img)
# QImageWriter only gained the following options in Qt 5.5
if jpeg_optimized:
w.setOptimizedWrite(True)
if jpeg_progressive:
w.setProgressiveScanWrite(True)
w.setQuality(compression_quality)
elif fmt == 'PNG':
cl = min(9, max(0, png_compression_level))
w.setQuality(10 * (9-cl))
if not w.write(img):
raise ValueError('Failed to export image as ' + fmt + ' with error: ' + w.errorString())
return ba.data()
def on_caDeleteButton_clicked(self):
"""
Private slot to delete the selected CA certificate.
"""
itm = self.caCertificatesTree.currentItem()
res = E5MessageBox.yesNo(
self, self.tr("Delete CA Certificate"),
self.tr(
"""<p>Shall the CA certificate really be deleted?</p>"""
"""<p>{0}</p>"""
"""<p>If the CA certificate is deleted, the browser"""
""" will not trust any certificate issued by this CA.</p>""").
format(itm.text(0)))
if res:
cert = self.caCertificatesTree.currentItem().data(0, self.CertRole)
# delete the selected entry and its parent entry,
# if it was the only one
parent = itm.parent()
parent.takeChild(parent.indexOfChild(itm))
if parent.childCount() == 0:
self.caCertificatesTree.takeTopLevelItem(
self.caCertificatesTree.indexOfTopLevelItem(parent))
# delete the certificate from the CA certificate store
caCerts = self.__getSystemCaCertificates()
if cert in caCerts:
caCerts.remove(cert)
pems = QByteArray()
for cert in caCerts:
pems.append(cert.toPem() + '\n')
Preferences.Prefs.settings.setValue("Help/SystemCertificates",
pems)
# delete the certificate from the default certificates
self.__updateDefaultConfiguration()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(200, 200, 400, 400)
self.setWindowTitle("QMovie to show animated gif")
# set up the movie screen on a label
self.movie_screen = QLabel()
# expand and center the label
self.movie_screen.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.movie_screen.setAlignment(Qt.AlignCenter)
main_layout = QVBoxLayout()
main_layout.addWidget(self.movie_screen)
self.setLayout(main_layout)
# use an animated gif file you have in the working folder
# or give the full file path
self.movie = QMovie("giphy.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_screen.setMovie(self.movie)
self.movie.start()
def setupCRS_customPage(self):
self.recordingActive = False
self.elapsed_time = 0
self.isICMReceived = False
self.currentHeartRate = 0
self.maxHeartRate = 100
#graph setup
self.max30001_graph.setBackground('w')
self.RXvaluesArray = [0.0] #Recieved values for plotting
self.timevaluesArray = [0.0] #Time values for plotting
self.start_time = time.perf_counter() #Start collecting time value
pen = mkPen(color=(255, 0, 0))
self.data_line = self.max30001_graph.plot(self.timevaluesArray,
self.RXvaluesArray,
pen=pen)
# Subscribe to notification for CRS RX value changes via descriptor writing
self.RXMeasurChar = self.ble_controller.openedService.characteristic(
QBluetoothUuid("{0000fe62-8e22-4541-9d4c-21edae82ed19}")
) #uuid RX karakteristike
if (self.RXMeasurChar.isValid() == False):
print("ERR: Cannot read RX characteristic\n")
self.RXCharCfg = QBluetoothUuid(
QBluetoothUuid.ClientCharacteristicConfiguration)
self.RXdescript = self.RXMeasurChar.descriptor(self.RXCharCfg)
if (self.RXdescript.isValid() == False):
print("ERR: Cannot create notification for CRS RX value\n")
self.array = QByteArray(
b'\x01\x00') #turn on NOTIFY for characteristic
self.ble_controller.openedService.characteristicChanged.connect(
self.handleRXValueChanged)
self.ble_controller.openedService.writeDescriptor(
self.RXdescript, self.array) #turn on NOTIFY
def mouseMoveEvent(self, event):
""" Starts the drag to the timeline """
# do nothing if there is no item at the event position
item = self.itemAt(event.pos())
if item is None:
return
# write the path to the dragevent
item_data = QByteArray()
data_stream = QDataStream(item_data, QIODevice.WriteOnly)
path = item.statusTip()
QDataStream.writeString(data_stream, str.encode(path))
# get width of timeable that would be created
width = get_width_from_file(path)
# do nothing if width is 0 because something went wrong
if width == 0:
return
QDataStream.writeInt(data_stream, width)
mime_data = QMimeData()
mime_data.setData('ubicut/file', item_data)
# set first frame as pixmap
pixmap = get_pixmap_from_file(path, 1)
# create and execute drag
drag = QDrag(self)
drag.setMimeData(mime_data)
if pixmap is not None:
drag.setPixmap(pixmap.scaled(QSize(100, 100), Qt.KeepAspectRatio))
drag.exec_(Qt.MoveAction)
def fromQImage(layerNode, image, position=None):
"""Paste given `image` to `position` in '`layerNode`
The `position` value can be:
- None, in this case, pixmap will be pasted at position (0, 0)
- A QPoint() object, pixmap will be pasted at defined position
"""
if not isinstance(layerNode, Node):
raise EInvalidType(
"Given `layerNode` must be a valid Krita <Node> ")
elif not isinstance(image, QImage):
raise EInvalidType("Given `image` must be a valid <QImage> ")
if position is None:
position = QPoint(0, 0)
if not isinstance(position, QPoint):
raise EInvalidType("Given `position` must be a valid <QPoint> ")
ptr = image.bits()
ptr.setsize(image.byteCount())
layerNode.setPixelData(QByteArray(ptr.asstring()), position.x(),
position.y(), image.width(), image.height())
def __init__(self, icon_name, hex_color):
root = QFileInfo(__file__).absolutePath()
svg_files = os.listdir(root + "/styles/assets/icons/svg/")
filename = "appbar." + icon_name + ".svg"
if filename in svg_files:
f = QFile(root + '/styles/assets/icons/svg/' + filename)
if f.open(QFile.ReadOnly | QFile.Text):
textStream = QTextStream(f)
svgData = textStream.readAll().replace(
'fill="#000000"', 'fill="{}"'.format(hex_color))
f.close()
svg = QSvgRenderer(QByteArray().append(svgData))
qim = QImage(76, 76, QImage.Format_RGBA8888)
qim.fill(0)
painter = QPainter()
painter.begin(qim)
svg.render(painter)
painter.end()
self.icon = (QIcon(QPixmap.fromImage(qim)))
def __init__(self):
super(Monitor, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.help_menu = QtWidgets.QMenu('&Help', self)
self.menuBar().addMenu(self.help_menu)
self.help_menu.addAction('& About', self.about)
self.s = QTcpSocket(self)
self.ui.BtnShow.setEnabled(False)
self.ui.BtnCon.clicked.connect(self.connectToServer)
self.ui.BtnDiscon.clicked.connect(self.disconnectToServer)
self.ui.RBHistory.clicked.connect(self.onClickRBHistory)
self.ui.RBRealTime.clicked.connect(self.onClickRBRealTime)
self.ui.BtnRef.clicked.connect(self.reflesh)
self.treeModel = TreeModel(QByteArray())
self.ui.treeView.setModel(self.treeModel)
self.ui.treeView.clicked.connect(self.onClickDir)
self.ui.BtnShow.clicked.connect(self.showChart)
self.s.error.connect(self.netError)
self.s.connected.connect(self.netConnect)
self.s.disconnected.connect(self.netDisconnect)
self.timer0Id = 0
self.timer1Id = 0
self.isShow = False
def extension(self, extension, info=None, errorPage=None):
if extension == QWebPage.ErrorPageExtension:
# catch the error, populate self.errorInfo and return an error page
info = sip.cast(info, QWebPage.ErrorPageExtensionOption)
domain = 'Unknown'
if info.domain == QWebPage.QtNetwork:
domain = 'Network'
elif info.domain == QWebPage.Http:
domain = 'HTTP'
elif info.domain == QWebPage.WebKit:
domain = 'WebKit'
self.error_info = RenderErrorInfo(
domain, int(info.error), six.text_type(info.errorString),
six.text_type(info.url.toString()))
# XXX: this page currently goes nowhere
content = u"""
<html><head><title>Failed loading page</title></head>
<body>
<h1>Failed loading page ({0.text})</h1>
<h2>{0.url}</h2>
<p>{0.type} error #{0.code}</p>
</body></html>""".format(self.error_info)
errorPage = sip.cast(errorPage, QWebPage.ErrorPageExtensionReturn)
errorPage.content = QByteArray(content.encode('utf-8'))
return True
# XXX: this method always returns True, even if we haven't
# handled the extension. Is it correct? When can this method be
# called with extension which is not ErrorPageExtension if we
# are returning False in ``supportsExtension`` for such extensions?
return True
def test__onGetRemoteMaterials_withNewMaterial(self, application_mock):
reply_mock = MagicMock()
device_mock = MagicMock()
container_registry_mock = application_mock.getContainerRegistry.return_value
material_manager_mock = application_mock.getMaterialManager.return_value
container_registry_mock.getContainerFilePathById = lambda x: _FILES_MAP.get(
x)
device_mock.createFormPart.return_value = "_xXx_"
all_results = self._LOCAL_MATERIAL_WHITE_ALL_RESULT.copy()
for key, value in self._LOCAL_MATERIAL_BLACK_ALL_RESULT.items():
all_results[key] = value
material_manager_mock.getAllMaterialGroups.return_value = all_results
reply_mock.attribute.return_value = 200
reply_mock.readAll.return_value = QByteArray(
json.dumps([self._REMOTE_MATERIAL_BLACK]).encode("ascii"))
with mock.patch.object(Application,
"getInstance",
new=lambda: application_mock):
job = SendMaterialJob(device_mock)
job._onGetRemoteMaterials(reply_mock)
self.assertEqual(1, device_mock.createFormPart.call_count)
self.assertEqual(1, device_mock.postFormWithParts.call_count)
self.assertEqual([
call.createFormPart(
"name=\"file\"; filename=\"generic_pla_white.xml.fdm_material\"",
"<xml></xml>"),
call.postFormWithParts(target="materials/",
parts=["_xXx_"],
on_finished=job.sendingFinished)
], device_mock.method_calls)
def __init__(self, format, activeGen, parent=None):
QIODevice.__init__(self, parent)
self.data = QByteArray()
# hold a reference to the active generator instance
self.generator = activeGen
self.convert_16_bit = float(2**15)
# Check we can deal with the supplied
# sample format. We're supposed to be
# able to deal with any requested
# sample format. But this is a
# _minimal_ example
if format.isValid() and \
format.sampleSize() == 16 and \
format.byteOrder() == \
QAudioFormat.LittleEndian and \
format.sampleType() == \
QAudioFormat.SignedInt and \
format.channelCount() == 1 :
print("Meep: Format compatible. Good.")
self.format = format
def set_spinner(self, file_name):
# remove the old spinner
if self.collecting_spinner != None:
self.spinner_movie.stop()
self.collecting_spinner.setParent(None)
self.collecting_spinner = None
self.spinner_movie = QMovie(file_name, QByteArray(), self)
self.collecting_spinner = QLabel(self.parent)
self.collecting_spinner.setMovie(self.spinner_movie)
self.collecting_spinner.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.spinner_movie.setCacheMode(QMovie.CacheAll)
self.spinner_movie.setSpeed(100)
self.spinner_movie.start() # if I do not start it, it stays hidden
self.spinner_movie.stop()
self.collecting_spinner.move(0, 0)
self.collecting_spinner.show()
self.collecting_spinner.setHidden(True)
img_size = self.spinner_movie.currentPixmap().size()
self.collecting_spinner.resize(img_size.width(), img_size.height())
def __findForm(self, webPage, data, boundary=None):
"""
Private method to find the form used for logging in.
@param webPage reference to the web page (QWebPage)
@param data data to be sent (QByteArray)
@keyparam boundary boundary string (QByteArray) for multipart
encoded data, None for urlencoded data
@return parsed form (LoginForm)
"""
from .LoginForm import LoginForm
form = LoginForm()
if boundary is not None:
args = self.__extractMultipartQueryItems(data, boundary)
else:
if qVersion() >= "5.0.0":
from PyQt5.QtCore import QUrlQuery
argsUrl = QUrl.fromEncoded(
QByteArray(b"foo://bar.com/?" + QUrl.fromPercentEncoding(
data.replace(b"+", b"%20")).encode("utf-8")))
encodedArgs = QUrlQuery(argsUrl).queryItems()
else:
argsUrl = QUrl.fromEncoded(
QByteArray(b"foo://bar.com/?" + data.replace(b"+", b"%20"))
)
encodedArgs = argsUrl.queryItems()
args = set()
for arg in encodedArgs:
key = arg[0]
value = arg[1]
args.add((key, value))
# extract the forms
from Helpviewer.JavaScriptResources import parseForms_js
lst = webPage.mainFrame().evaluateJavaScript(parseForms_js)
for map in lst:
formHasPasswords = False
formName = map["name"]
formIndex = map["index"]
if isinstance(formIndex, float) and formIndex.is_integer():
formIndex = int(formIndex)
elements = map["elements"]
formElements = set()
formElementTypes = {}
deadElements = set()
for elementMap in elements:
try:
name = elementMap["name"]
value = elementMap["value"]
type_ = elementMap["type"]
except KeyError:
continue
if type_ == "password":
formHasPasswords = True
t = (name, value)
try:
if elementMap["autocomplete"] == "off":
deadElements.add(t)
except KeyError:
pass
if name:
formElements.add(t)
formElementTypes[name] = type_
if formElements.intersection(args) == args:
form.hasAPassword = formHasPasswords
if not formName:
form.name = formIndex
else:
form.name = formName
args.difference_update(deadElements)
for elt in deadElements:
if elt[0] in formElementTypes:
del formElementTypes[elt[0]]
form.elements = list(args)
form.elementTypes = formElementTypes
break
return form
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
def prepare_calendar(self):
schema = [
QByteArray(str.encode("hour")),
QByteArray(str.encode("firstPerson")),
QByteArray(str.encode("secondPerson")),
]
self.calendar_data = DefaultCalendarAbstractModel(schema)
self.first_persons_column = list()
self.second_person_column = list()
# Prepare empty cells
self.firstPersonList = list()
self.secondPersonList = list()
# Prepare data from Google Cal
calendar = Calendar()
calendar = calendar.get_calendarEntries("philipp")
print('getting calendar entries')
for appointment in calendar.appointments:
print(appointment.toString())
self.calendar_data_first_person = calendar
# Prepare second user data from Google Cal
calendar = Calendar()
calendar = calendar.get_calendarEntries("carla")
print('getting calendar entries')
for appointment in calendar.appointments:
print(appointment.toString())
self.calendar_data_second_person = calendar
for x in range(0, 24):
# wenn zu dieser Uhrzeit kein Termin ansteht, das da verwenden:
# noAppointmentString = DefaultCalendarEntryModel(datetime.datetime(self.date.year, self.date.month, self.date.day, x, 0), datetime.datetime(self.date.year, self.date.month, self.date.day, x, 59))
# firstPerson aus Google Cal durchloopen und DefaultCalendarEntryModel.set_data abfüllen
cell = DefaultCalendarEntryModel(
datetime.datetime(self.date.year, self.date.month,
self.date.day, x, 0),
datetime.datetime(self.date.year, self.date.month,
self.date.day, x, 59))
for googleAppointment in self.calendar_data_first_person.appointments:
appointment_index = googleAppointment.start.hour
if x is appointment_index:
nativeStart = googleAppointment.start.replace(tzinfo=None)
nativeEnd = googleAppointment.end.replace(tzinfo=None)
defaultCalEntryModel = DefaultCalendarEntryModel(
datetime.datetime(self.date.year, self.date.month,
self.date.day, x, 0),
datetime.datetime(self.date.year, self.date.month,
self.date.day, x, 59))
firstPersString = defaultCalEntryModel.set_data(
googleAppointment.uid, nativeStart, nativeEnd,
googleAppointment.description)
# set_data(googleAppointment.uid, nativeStart, nativeEnd, googleAppointment.description)
self.firstPersonList.append(firstPersString)
else:
self.firstPersonList.append(cell.full_text)
for googleAppointment in self.calendar_data_second_person.appointments:
appt_index = googleAppointment.start.hour
if x is appt_index:
nativeStart = googleAppointment.start.replace(tzinfo=None)
nativeEnd = googleAppointment.end.replace(tzinfo=None)
defaultCalEntryModel = DefaultCalendarEntryModel(
datetime.datetime(self.date.year, self.date.month,
self.date.day, x, 0),
datetime.datetime(self.date.year, self.date.month,
self.date.day, x, 59))
secondPersonString = defaultCalEntryModel.set_data(
googleAppointment.uid, nativeStart, nativeEnd,
googleAppointment.description)
# set_data(googleAppointment.uid, nativeStart, nativeEnd, googleAppointment.description)
self.secondPersonList.append(secondPersonString)
else:
self.secondPersonList.append(cell.full_text)
# secondPerson aus Google Cal durchloopen und DefaultCalendarEntryModel.set_data abfüllen
# self.secondPersonList.append(cell.full_text)
# Hier dann calendar_data mit QByteArrays füllen
self.calendar_data.append({
QByteArray(str.encode("hour")):
str(x) + ":00",
QByteArray(str.encode("firstPerson")):
self.firstPersonList[x],
QByteArray(str.encode("secondPerson")):
self.secondPersonList[x],
})
print(str(len(self.firstPersonList)))
class Repeater(SingletonObject):
ConnectStatus = Enum('Status', "disconnected connected")
_status = ConnectStatus.disconnected
statusChanged = pyqtSignal()
@pyqtProperty(ConnectStatus, notify=statusChanged)
def status(self):
return self._status
@status.setter
def status(self, status):
self._status = status
self.statusChanged.emit()
def isConnected(self):
return self._status is self.ConnectStatus.connected
dataArrived = pyqtSignal(bytearray, name='dataArrived')
snapshotArrived = pyqtSignal(QImage)
videoFrameArrived = pyqtSignal(QImage)
_delegates = []
_loop = None
_context = None
_handle = None
_device = None
_in_ep = None
_out_ep = None
_in_packet_size = 0
_out_packet_size = 0
_urb_free_list = []
_urb_busy_list = []
_mutex = QMutex()
_datagram = QByteArray()
_extendedDataBuffer = QByteArray()
_extendedDataCategory = None
_extendedDataCompressed = False
_extendedDataSize = 0
def __init__(self, parent=None):
super(Repeater, self).__init__(parent)
context = usb1.USBContext()
context.open()
self._context = context
self.dataArrived.connect(self.onDataArrived)
self._loop = _RepeaterLoop(self)
self._loop.deviceRemoved.connect(self.closeDevice)
self._openDeviceTimer = QTimer(self)
self._openDeviceTimer.timeout.connect(self.openDevice)
self._openDeviceTimer.start(1000)
def daemon(self):
return self._loop
@pyqtSlot()
def closeDevice(self):
print("close device")
self.status = self.ConnectStatus.disconnected
if self._handle is not None:
self._handle.releaseInterface(0)
self._device = None
self._handle = None
self.destroyURB()
self._openDeviceTimer.start(1000)
@pyqtSlot()
def openDevice(self):
context = self._context
handle = context.openByVendorIDAndProductID(
0x2009,
0x0805,
skip_on_error=True,
)
if handle is not None:
print("usb open device success")
self._openDeviceTimer.stop()
self._handle = handle
device = handle.getDevice()
self._device = device
for endpoint in device[0][0][0]:
address = endpoint.getAddress()
if address & usb1.ENDPOINT_DIR_MASK == usb1.ENDPOINT_IN:
self._in_ep = address
self._in_packet_size = endpoint.getMaxPacketSize()
else:
self._out_ep = address
self._out_packet_size = endpoint.getMaxPacketSize()
self._interface = handle.claimInterface(0)
self.startReceive()
self._loop.start()
self.status = self.ConnectStatus.connected
def register(self, delegate):
self._delegates.append(delegate)
def reclaimURB(self, transfer):
self._urb_busy_list.remove(transfer)
self._urb_free_list.append(transfer)
def destroyURB(self):
self._urb_busy_list = []
self._urb_free_list = []
def getRequestBlock(self):
block = QByteArray()
ostream = QDataStream(block, QIODevice.WriteOnly)
ostream.setVersion(QDataStream.Qt_4_8)
ostream.writeQString('Bigeye')
return block, ostream
def submitRequestBlock(self, block):
if self._status is self.ConnectStatus.disconnected:
return
block = self._escape(block)
if len(self._urb_free_list) > 0:
transfer = self._urb_free_list[0]
self._urb_free_list.remove(transfer)
else:
transfer = self._handle.getTransfer()
transfer.setBulk(self._out_ep, block, callback=_RepeaterLoop.sendDataCallback, user_data=self, timeout=100)
transfer.submit()
self._urb_busy_list.append(transfer)
def getUSBContext(self):
return self._context
def getUSBHandle(self):
return self._handle
def onDataArrived(self, data):
self._mutex.lock()
start = 0
while True:
if self._extendedDataSize > 0:
size = self._extendedDataBuffer.size()
remainder = self._extendedDataSize - size
length = len(data) - start
if length >= remainder:
self._extendedDataBuffer.append(data[start:(start + remainder)])
start += remainder
if self._extendedDataCompressed:
self._extendedDataBuffer = qUncompress(self._extendedDataBuffer)
self.onDisposedExtendedData()
self._extendedDataSize = 0
else:
self._extendedDataBuffer.append(data[start:])
break
else:
end = data.find(b'\x7e', start)
if end == 0:
self.onDisposed(self._datagram)
self._datagram.clear()
elif end > 0:
self._datagram.append(data[start:end])
self.onDisposed(self._datagram)
self._datagram.clear()
else:
self._datagram.append(data[start:])
break
if end == len(data) - 1:
break
else:
start = end + 1
self._mutex.unlock()
def onDisposed(self, datagram):
if datagram.size() == 0:
return
block = self._unescape(datagram)
istream = QDataStream(block)
istream.setVersion(QDataStream.Qt_4_8)
magic = istream.readQString()
response = istream.readQString()
if istream.status() == QDataStream.Ok:
if response == "extendedData":
self._extendedDataCategory = istream.readQString()
self._extendedDataCompressed = istream.readBool()
self._extendedDataSize = istream.readInt()
self._extendedDataBuffer.clear()
else:
handled = False
for delegate in self._delegates:
if hasattr(delegate, response):
getattr(delegate, response)(istream)
handled = True
if istream.status() != QDataStream.Ok:
print("{}: eeeeeeeeeeeeee".format(response))
break
if not handled:
print("Unhandled response:", response)
else:
print("onDisposed failed: block size", block.size())
def onDisposedExtendedData(self):
for delegate in self._delegates:
extendedDataHandel = "onExtendedDataArrived"
handled = False
if hasattr(delegate, extendedDataHandel):
res = getattr(delegate, extendedDataHandel)(self._extendedDataCategory, self._extendedDataBuffer)
if res is True:
handled = True
break
if not handled:
print("Unhandled extended data:", self._extendedDataCategory)
def receiveData(self, data):
self.dataArrived.emit(data)
def startReceive(self):
transfer = self._handle.getTransfer()
transfer.setBulk(self._in_ep, self._in_packet_size * 32, callback=_RepeaterLoop.receiveDataCallback, user_data=self)
transfer.submit()
self._urb_busy_list.append(transfer)
def stopReceive(self):
pass
@staticmethod
def _escape(data):
escape = QByteArray()
escape.append(chr(0x7e))
"""
for i in range(data.size()):
ch = data.at(i)
if ch == chr(0x7e):
escape.append(chr(0x7d))
escape.append(chr(0x5e))
elif ch == chr(0x7d):
escape.append(chr(0x7d))
escape.append(chr(0x5d))
else:
escape.append(ch)
"""
data.replace(b"\x7d", b"\x7d\x5d")
data.replace(b"\x7e", b"\x7d\x5e")
escape.append(data)
escape.append(chr(0x7e))
return escape
@staticmethod
def _unescape(data):
"""
unescape = QByteArray()
is_escaped = False
for i in range(data.size()):
ch = data.at(i)
if is_escaped:
is_escaped = False
if ch == chr(0x5e):
unescape.append(chr(0x7e))
elif ch == chr(0x5d):
unescape.append(chr(0x7d))
else:
print("data corrupted")
continue
if ch == chr(0x7d):
is_escaped = True
continue
else:
unescape.append(ch)
return unescape
"""
data.replace(b"\x7d\x5e", b"\x7e")
data.replace(b"\x7d\x5d", b"\x7d")
return data
def _dumpUSBInfo(self):
handle = self._handle
print("bConfigurationValue ", handle.getConfiguration())
device = handle.getDevice()
print("Device:")
print("Bus Number ", device.getBusNumber())
print("Port Number ", device.getPortNumber())
print("Device Address ", device.getDeviceAddress())
print("Device Speed ", device.getDeviceSpeed())
print("Max Packet Size0 ", device.getMaxPacketSize0())
print("Vendor ID ", device.getVendorID())
print("Product ID ", device.getProductID())
print("Manufacturer ", device.getManufacturer())
print("Product ", device.getProduct())
print("Serial Number ", device.getSerialNumber())
print("Num Configurations ", device.getNumConfigurations())
print("Configurations:")
for configuration in device:
print(' ' * 2, " Configuration Value ", configuration.getConfigurationValue())
print(' ' * 2, " Descriptor ", configuration.getDescriptor())
print(' ' * 2, " Interfaces:")
for interface in configuration:
print(' ' * 4, "NumSettings ", interface.getNumSettings())
print(' ' * 4, "Interface Settings:")
for interfaceSetting in interface:
print(' ' * 6, "Number ", interfaceSetting.getNumber())
print(' ' * 6, "Endpoints:")
for endpoint in interfaceSetting:
print(' ' * 8, "Address ", endpoint.getAddress())
print(' ' * 8, "Attributes ", endpoint.getAttributes())
print(' ' * 8, "Max Packet Size ", endpoint.getMaxPacketSize())
def getRequestBlock(self):
block = QByteArray()
ostream = QDataStream(block, QIODevice.WriteOnly)
ostream.setVersion(QDataStream.Qt_4_8)
ostream.writeQString('Bigeye')
return block, ostream
def prepare_krita_file(self):
wBase = max(
self.widthUnit.pixelsForUnit(self.spn_width.value(),
self.DPI.value()), 1)
bL = self.bleedLeftUnit.pixelsForUnit(self.bleedLeft.value(),
self.DPI.value())
bR = self.bleedRightUnit.pixelsForUnit(self.bleedRight.value(),
self.DPI.value())
mL = self.marginLeftUnit.pixelsForUnit(self.marginLeft.value(),
self.DPI.value())
mR = self.marginRightUnit.pixelsForUnit(self.marginRight.value(),
self.DPI.value())
hBase = max(
self.heightUnit.pixelsForUnit(self.spn_height.value(),
self.DPI.value()), 1)
bT = self.bleedTopUnit.pixelsForUnit(self.bleedTop.value(),
self.DPI.value())
bB = self.bleedBottomUnit.pixelsForUnit(self.bleedBottom.value(),
self.DPI.value())
mT = self.marginTopUnit.pixelsForUnit(self.marginTop.value(),
self.DPI.value())
mB = self.marginBottomUnit.pixelsForUnit(self.marginBottom.value(),
self.DPI.value())
template = Application.createDocument((wBase + bL + bR),
(hBase + bT + bB),
self.templateName.text(), "RGBA",
"U8", "sRGB built-in",
self.DPI.value())
backgroundNode = template.activeNode()
backgroundNode.setName(i18n("Background"))
pixelByteArray = QByteArray()
pixelByteArray = backgroundNode.pixelData(0, 0, (wBase + bL + bR),
(hBase + bT + bB))
white = int(255)
pixelByteArray.fill(white.to_bytes(1, byteorder='little'))
backgroundNode.setPixelData(pixelByteArray, 0, 0, (wBase + bL + bR),
(hBase + bT + bB))
backgroundNode.setLocked(True)
sketchNode = template.createNode(i18n("Sketch"), "paintlayer")
template.rootNode().setChildNodes([backgroundNode, sketchNode])
verticalGuides = []
verticalGuides.append(bL)
verticalGuides.append(bL + mL)
verticalGuides.append((bL + wBase) - mR)
verticalGuides.append(bL + wBase)
horizontalGuides = []
horizontalGuides.append(bT)
horizontalGuides.append(bT + mT)
horizontalGuides.append((bT + hBase) - mB)
horizontalGuides.append(bT + hBase)
template.setHorizontalGuides(horizontalGuides)
template.setVerticalGuides(verticalGuides)
template.setGuidesVisible(True)
template.setGuidesLocked(True)
self.urlSavedTemplate = os.path.join(self.templateDirectory,
self.templateName.text() + ".kra")
success = template.exportImage(self.urlSavedTemplate, InfoObject())
print("CPMT: Template", self.templateName.text(), "made and saved.")
template.waitForDone()
template.close()
return success
def __init__(self, geometry, win_id, parent=None):
super().__init__(parent)
self._geometry = QByteArray(geometry)
self.win_id = win_id
def responseComplete(self):
request = self.serverInterface().requestHandler()
params = request.parameterMap()
# SERVICE=RENDERGEOJSON -- we are taking over
if params.get('SERVICE', '').upper() == 'RENDERGEOJSON':
request.clear()
try:
# Parse parameters
geojson = params.get('GEOJSON')
if not geojson:
raise ParameterError('Parameter GEOJSON must be set.')
style = params.get('STYLE')
if not style:
raise ParameterError('Parameter STYLE must be set.')
try:
width = int(params.get('WIDTH'))
except TypeError:
raise ParameterError('Parameter WIDTH must be integer.')
try:
height = int(params.get('HEIGHT'))
except TypeError:
raise ParameterError('Parameter HEIGHT must be integer.')
try:
dpi = int(params.get('DPI', 96))
except TypeError:
raise ParameterError('Parameter DPI must be integer.')
try:
minx, miny, maxx, maxy = params.get('BBOX').split(',')
bbox = QgsRectangle(float(minx), float(miny), float(maxx),
float(maxy))
except (ValueError, AttributeError):
raise ParameterError(
'Parameter BBOX must be specified in the form `min_x,min_y,max_x,max_y`.'
)
url = geojson
geojson_file_name = self._resolve_url(geojson)
if '$type' in style:
polygon_style = self._resolve_url(
style.replace('$type', 'polygons'))
line_style = self._resolve_url(
style.replace('$type', 'lines'))
point_style = self._resolve_url(
style.replace('$type', 'points'))
else:
polygon_style = self._resolve_url(style)
line_style = polygon_style
point_style = polygon_style
polygon_layer = QgsVectorLayer(
geojson_file_name + '|geometrytype=Polygon', 'polygons',
'ogr')
self._load_style(polygon_layer, polygon_style)
line_layer = QgsVectorLayer(
geojson_file_name + '|geometrytype=Line', 'lines', 'ogr')
self._load_style(line_layer, line_style)
point_layer = QgsVectorLayer(
geojson_file_name + '|geometrytype=Point', 'points', 'ogr')
self._load_style(point_layer, point_style)
settings = QgsMapSettings()
settings.setOutputSize(QSize(width, height))
settings.setOutputDpi(dpi)
settings.setExtent(bbox)
settings.setLayers([polygon_layer, line_layer, point_layer])
settings.setBackgroundColor(QColor(Qt.transparent))
renderer = QgsMapRendererParallelJob(settings)
event_loop = QEventLoop()
renderer.finished.connect(event_loop.quit)
renderer.start()
event_loop.exec_()
img = renderer.renderedImage()
img.setDotsPerMeterX(dpi * 39.37)
img.setDotsPerMeterY(dpi * 39.37)
image_data = QByteArray()
buf = QBuffer(image_data)
buf.open(QIODevice.WriteOnly)
img.save(buf, 'PNG')
request.setResponseHeader('Content-type', 'image/png')
request.appendBody(image_data)
except ParameterError as e:
QgsMessageLog.logMessage(
"RenderGeojson.responseComplete :: ParameterError")
request.setResponseHeader('Content-type', 'text/plain')
request.appendBody(str(e).encode('utf-8'))
except:
QgsMessageLog.logMessage(
"RenderGeojson.responseComplete :: Exception")
QgsMessageLog.logMessage(
"RenderGeojson.responseComplete :: {}".format(
traceback.format_exc()))
request.setResponseHeader('Content-type', 'text/plain')
request.appendBody(b'Unhandled error')
request.appendBody(traceback.format_exc().encode('utf-8'))
def base64image(image):
ba = QByteArray()
buffer = QBuffer(ba)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, "PNG")
return "data:image/png;base64," + ba.toBase64().data().decode("ascii")
def run_api():
# pdf = Poppler.Document()
# page = Poppler.Page()
pdf = 0
page = 0
image = QImage()
byte_data = QByteArray()
color_theme = 'light' #allowed color themes: 'light','dark','sepia'
while True:
s = input()
tokens = s.split(' ')
if tokens[0] == 'open': #open a pdf file
pdf = Poppler.Document.load(tokens[1])
pdf.setRenderHint(Poppler.Document.TextAntialiasing)
if tokens[0] == 'page': #open a page of the current pdf
page = pdf.page(tokens[1])
if tokens[0] == 'pages': #returns number of pages
print(pdf.numPages())
if tokens[0] == 'color': #set color theme
color_theme = tokens[1]
if tokens[0] == 'textlist': #outputs textlist as a json file
textlist = page.textList()
textlist_json = []
for text in textlist:
bb = text.boundingBox()
d = {'text': text.text(), 'x': bb.x(), 'y': bb.y(), 'width': bb.width(), 'height': bb.height()}
textlist_json.append(d)
print(json.dumps(textlist_json))
if tokens[0] == 'render': #output pixel data to stdout
image = page.renderToImage(3 * 72, 3 * 72, -1, -1, -1, -1)
print(image.format())
if color_theme == 'dark':
for x in range(image.width()):
for y in range(image.height()):
rgb = image.pixelColor(x, y)
rgb.setRed(int(linear_interpolation(234, 68, rgb.red() / 255)))
rgb.setGreen(int(linear_interpolation(234, 68, rgb.green() / 255)))
rgb.setBlue(int(linear_interpolation(234, 68, rgb.blue() / 255)))
image.setPixelColor(x, y, rgb)
# print(image.data)
# bits = image.bits()
# byte_data.fromRawData(image.data)
# print(byte_data)
ba = QByteArray()
buffer = QBuffer(ba)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, "PNG") # writes image into ba in PNG format
ba2 = buffer.data()
for i in ba.
bits = image.constBits()
bits.setsize(image.width() * image.height() * 4)
print(str(bits))
print(dir(bits))
print(bits.asarray())
print(str(bits.asarray()))
imgPtr = c_void_p(bits.__int__())
print(dir(imgPtr))
# for i in range(len(bits)):
# print(bits[i])
# print(image.constBits()[0])
# print(bits)
# print(type(bits))
# for i in range(image.width()):
# for j in range(image.height()):
# # print(image.pixel(i, j))
# print(bits[i])
# # color = QColor(image.pixel(i,j))
# # print(image.pixel(i,j).red(), image.pixel(i,j).green(), image.pixel(i,j).blue())
if tokens[0] == 'toc':
toc = pdf.toc()
'markdownDefaultFileExtension': '.mkd',
'previewState': False,
'pygmentsStyle': 'default',
'restDefaultFileExtension': '.rst',
'restorePreviewState': False,
'rightMargin': 0,
'saveWindowGeometry': False,
'spellCheck': False,
'spellCheckLocale': '',
'styleSheet': '',
'tabInsertsSpaces': True,
'tabWidth': 4,
'uiLanguage': QLocale.system().name(),
'useFakeVim': False,
'useWebKit': False,
'windowGeometry': QByteArray(),
}
def readFromSettings(key, keytype, settings=settings, default=None):
if not settings.contains(key):
return default
try:
value = settings.value(key, type=keytype)
if isinstance(value, keytype):
return value
return keytype(value)
except TypeError as error:
# Type mismatch
print('Warning: '+str(error))
# Return an instance of keytype
return default if (default is not None) else keytype()
def sslErrors(self, errors, server, port=-1):
"""
Public method to handle SSL errors.
@param errors list of SSL errors (list of QSslError)
@param server name of the server (string)
@keyparam port value of the port (integer)
@return tuple indicating to ignore the SSL errors (one of NotIgnored,
SystemIgnored or UserIgnored) and indicating a change of the
default SSL configuration (boolean)
"""
caMerge = {}
certificateDict = Globals.toDict(
Preferences.Prefs.settings.value("Ssl/CaCertificatesDict"))
for caServer in certificateDict:
caMerge[caServer] = QSslCertificate.fromData(
certificateDict[caServer])
caNew = []
errorStrings = []
if port != -1:
server += ":{0:d}".format(port)
if errors:
for err in errors:
if err.error() == QSslError.NoError:
continue
if server in caMerge and err.certificate() in caMerge[server]:
continue
errorStrings.append(err.errorString())
if not err.certificate().isNull():
cert = err.certificate()
if cert not in caNew:
caNew.append(cert)
if not errorStrings:
return E5SslErrorHandler.SystemIgnored, False
errorString = '.</li><li>'.join(errorStrings)
ret = E5MessageBox.yesNo(
None,
self.tr("SSL Errors"),
self.tr("""<p>SSL Errors for <br /><b>{0}</b>"""
"""<ul><li>{1}</li></ul></p>"""
"""<p>Do you want to ignore these errors?</p>""").format(
server, errorString),
icon=E5MessageBox.Warning)
if ret:
caRet = False
if len(caNew) > 0:
certinfos = []
for cert in caNew:
certinfos.append(self.__certToString(cert))
caRet = E5MessageBox.yesNo(
None, self.tr("Certificates"),
self.tr("""<p>Certificates:<br/>{0}<br/>"""
"""Do you want to accept all these certificates?"""
"""</p>""").format("".join(certinfos)))
if caRet:
if server not in caMerge:
caMerge[server] = []
for cert in caNew:
caMerge[server].append(cert)
sslCfg = QSslConfiguration.defaultConfiguration()
caList = sslCfg.caCertificates()
for cert in caNew:
caList.append(cert)
sslCfg.setCaCertificates(caList)
try:
sslCfg.setProtocol(QSsl.TlsV1_1OrLater)
except AttributeError:
sslCfg.setProtocol(QSsl.SecureProtocols)
try:
sslCfg.setSslOption(QSsl.SslOptionDisableCompression,
True)
except AttributeError:
pass
QSslConfiguration.setDefaultConfiguration(sslCfg)
certificateDict = {}
for server in caMerge:
pems = QByteArray()
for cert in caMerge[server]:
pems.append(cert.toPem() + b'\n')
certificateDict[server] = pems
Preferences.Prefs.settings.setValue(
"Ssl/CaCertificatesDict", certificateDict)
return E5SslErrorHandler.UserIgnored, caRet
else:
return E5SslErrorHandler.NotIgnored, False
def serialize(obj: _QtSerializableType) -> QByteArray:
"""Serialize an object into a QByteArray."""
data = QByteArray()
stream = QDataStream(data, QIODevice.WriteOnly)
serialize_stream(stream, obj)
return data
def export_video(self):
if not imageio:
return QMessageBox(
QMessageBox.Information, 'Export not available',
'imageio and ffmpeg must be installed to export videos').exec(
)
location = QFileDialog.getSaveFileName(self,
'Choose export location',
filter='Video (*.mp4)')[0]
if not location:
return
if not location.endswith('.mp4'):
location += '.mp4'
frame_count = int(self.duration * FPS)
progress_box = QProgressDialog('Recording and exporting video...',
'Cancel', 1, frame_count, self)
progress_box.setWindowModality(Qt.WindowModal)
with imageio.get_writer(location,
format='mp4',
mode='I',
fps=FPS,
quality=6) as writer:
frame = 0
stopped = False
def new_event(*args):
nonlocal frame, stopped
try:
self.callback(
AniState(self,
frame=frame,
time=frame / FPS,
dt=1 / FPS))
frame += 1
except StopIteration:
stopped = True
old = self.paintEvent
self.paintEvent = new_event
self.start()
self.frame_no = 0
for i in range(frame_count):
progress_box.setValue(i)
if progress_box.wasCanceled():
os.remove(location)
return
im_bytes = QByteArray()
buf = QBuffer(im_bytes)
buf.open(QIODevice.WriteOnly)
self.grab().save(buf, 'PNG', 100) # Triggers paintEvent
self.frame_no += 1
writer.append_data(imageio.imread(im_bytes.data(), 'png'))
if stopped:
break
progress_box.setValue(progress_box.maximum())
self.paintEvent = old
return QMessageBox(
QMessageBox.Information, 'Completed',
'Export finished! Saved to {}'.format(location)).exec()
def __init__(self, parent=None):
super(MainForm, self).__init__(parent)
self.filename = ""
self.copiedItem = QByteArray()
self.pasteOffset = 5
self.prevPoint = QPoint()
self.addOffset = 5
self.borders = []
self.printer = QPrinter(QPrinter.HighResolution)
self.printer.setPageSize(QPrinter.Letter)
self.view = GraphicsView()
self.scene = QGraphicsScene(self)
self.scene.setSceneRect(0, 0, PageSize[0], PageSize[1])
self.addBorders()
self.view.setScene(self.scene)
self.wrapped = [] # Needed to keep wrappers alive
buttonLayout = QVBoxLayout()
for text, slot in (
("Add &Text", self.addText),
("Add &Box", self.addBox),
("Add Pi&xmap", self.addPixmap),
("&Align", None),
("&Copy", self.copy),
("C&ut", self.cut),
("&Paste", self.paste),
("&Delete...", self.delete),
("&Rotate", self.rotate),
("Pri&nt...", self.print_),
("&Open...", self.open),
("&Save", self.save),
("&Quit", self.accept)):
button = QPushButton(text)
if not MAC:
button.setFocusPolicy(Qt.NoFocus)
if slot is not None:
button.clicked.connect(slot)
if text == "&Align":
menu = QMenu(self)
for text, arg in (
("Align &Left", Qt.AlignLeft),
("Align &Right", Qt.AlignRight),
("Align &Top", Qt.AlignTop),
("Align &Bottom", Qt.AlignBottom)):
wrapper = functools.partial(self.setAlignment, arg)
self.wrapped.append(wrapper)
menu.addAction(text, wrapper)
button.setMenu(menu)
if text == "Pri&nt...":
buttonLayout.addStretch(5)
if text == "&Quit":
buttonLayout.addStretch(1)
buttonLayout.addWidget(button)
buttonLayout.addStretch()
layout = QHBoxLayout()
layout.addWidget(self.view, 1)
layout.addLayout(buttonLayout)
self.setLayout(layout)
fm = QFontMetrics(self.font())
self.resize(self.scene.width() + fm.width(" Delete... ") + 50,
self.scene.height() + 50)
self.setWindowTitle("Page Designer")
