def tray_quit(self):
""" Triggered by clicking on `quit` in the systray popup: asks to close an unlocked container """
if not self.is_unlocked:
QApplication.instance().quit()
elif not self.is_waiting_for_worker:
self.show()
self.confirm_close()
def _formatHeader(self, text):
"""Format current directory for show it in the list of completions
"""
return '<font style="background-color: %s; color: %s">%s</font>' % \
(QApplication.instance().palette().color(QPalette.Window).name(),
QApplication.instance().palette().color(QPalette.WindowText).name(),
htmlEscape(text))
def test_1(self):
self.qpart.lines = \
[ 'func(param,',
' "text ( param"))']
self.qpart.detectSyntax(language = 'Python')
while self.qpart.isHighlightingInProgress():
QApplication.instance().processEvents()
firstBlock = self.qpart.document().firstBlock()
secondBlock = firstBlock.next()
bh = BracketHighlighter()
self._verify(bh.extraSelections(self.qpart, firstBlock, 1),
[])
self._verify(bh.extraSelections(self.qpart, firstBlock, 4),
[(4, 5, True), (31, 32, True)])
self._verify(bh.extraSelections(self.qpart, firstBlock, 5),
[(4, 5, True), (31, 32, True)])
self._verify(bh.extraSelections(self.qpart, secondBlock, 11),
[])
self._verify(bh.extraSelections(self.qpart, secondBlock, 19),
[(31, 32, True), (4, 5, True)])
self._verify(bh.extraSelections(self.qpart, secondBlock, 20),
[(32, 33, False)])
self._verify(bh.extraSelections(self.qpart, secondBlock, 21),
[(32, 33, False)])
def test_spectrum(self):
port = self.__get_free_port()
spectrum_dialog = self.__get_spectrum_dialog()
spectrum_dialog.device.set_server_port(port)
spectrum_dialog.ui.btnStart.click()
self.assertEqual(len(spectrum_dialog.scene_manager.peak), 0)
data = np.array([complex(1, 1), complex(2, 2), complex(3, 3)], dtype=np.complex64)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect(("127.0.0.1", port))
sock.sendall(data.tostring())
sock.shutdown(socket.SHUT_RDWR)
sock.close()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertGreater(len(spectrum_dialog.scene_manager.peak), 0)
spectrum_dialog.ui.btnStop.click()
self.__close_dialog(spectrum_dialog)
def openFile(self):
path, _ = QFileDialog.getOpenFileName(
self, self.tr("Open File"), '',
platformSpecific.fileFormat
)
if path:
QApplication.instance().openFile(path)
def test_send(self):
port = self.__get_free_port()
receive_dialog = self.__get_recv_dialog()
receive_dialog.device.set_server_port(port)
receive_dialog.ui.btnStart.click()
send_dialog = self.__get_send_dialog()
send_dialog.device.set_client_port(port)
send_dialog.ui.spinBoxNRepeat.setValue(2)
send_dialog.ui.btnStart.click()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertEqual(receive_dialog.device.current_index, 2 * self.signal.num_samples)
self.assertTrue(np.array_equal(receive_dialog.device.data[:receive_dialog.device.current_index // 2],
self.signal.data))
self.assertEqual(send_dialog.send_indicator.rect().width(), self.signal.num_samples)
self.assertFalse(send_dialog.ui.btnClear.isEnabled())
send_dialog.on_clear_clicked()
self.assertEqual(send_dialog.send_indicator.rect().width(), 0)
send_dialog.ui.btnStop.click()
self.assertFalse(send_dialog.ui.btnStop.isEnabled())
receive_dialog.ui.btnStop.click()
self.assertFalse(receive_dialog.ui.btnStop.isEnabled())
self.__close_dialog(receive_dialog)
self.__close_dialog(send_dialog)
def test_receive(self):
port = self.__get_free_port()
receive_dialog = self.__get_recv_dialog()
receive_dialog.device.set_server_port(port)
receive_dialog.ui.btnStart.click()
data = np.array([complex(1, 2), complex(3, 4), complex(5, 6)], dtype=np.complex64)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect(("127.0.0.1", port))
sock.sendall(data.tostring())
sock.shutdown(socket.SHUT_RDWR)
sock.close()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertEqual(receive_dialog.device.current_index, 3)
self.assertTrue(np.array_equal(receive_dialog.device.data[:3], data))
receive_dialog.ui.btnStop.click()
receive_dialog.ui.btnClear.click()
self.assertEqual(receive_dialog.device.current_index, 0)
self.__close_dialog(receive_dialog)
def save_as(self, filename: str):
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
self.filename = filename
FileOperator.save_signal(self)
self.name = os.path.splitext(os.path.basename(filename))[0]
self.changed = False
QApplication.instance().restoreOverrideCursor()
def show_protocol_selection_in_interpretation(self, start_message, start, end_message, end):
try:
cfc = self.compare_frame_controller
msg_total = 0
last_sig_frame = None
for protocol in cfc.protocol_list:
if not protocol.show:
continue
n = protocol.num_messages
view_type = cfc.ui.cbProtoView.currentIndex()
messages = [i - msg_total for i in range(msg_total, msg_total + n) if start_message <= i <= end_message]
if len(messages) > 0:
try:
signal_frame = next((sf for sf, pf in self.signal_protocol_dict.items() if pf == protocol))
except StopIteration:
QMessageBox.critical(self, self.tr("Error"),
self.tr("Could not find corresponding signal frame."))
return
signal_frame.set_roi_from_protocol_analysis(min(messages), start, max(messages), end + 1, view_type)
last_sig_frame = signal_frame
msg_total += n
focus_frame = last_sig_frame
if last_sig_frame is not None:
self.signal_tab_controller.ui.scrollArea.ensureWidgetVisible(last_sig_frame, 0, 0)
QApplication.instance().processEvents()
self.ui.tabWidget.setCurrentIndex(0)
if focus_frame is not None:
focus_frame.ui.txtEdProto.setFocus()
except Exception as e:
logger.exception(e)
def __init__(self):
super(ChatMainWindow, self).__init__()
self.m_nickname = "nickname"
self.m_messages = []
self.setupUi(self)
self.sendButton.setEnabled(False)
self.messageLineEdit.textChanged.connect(self.textChangedSlot)
self.sendButton.clicked.connect(self.sendClickedSlot)
self.actionChangeNickname.triggered.connect(self.changeNickname)
self.actionAboutQt.triggered.connect(self.aboutQt)
QApplication.instance().lastWindowClosed.connect(self.exiting)
# Add our D-Bus interface and connect to D-Bus.
ChatAdaptor(self)
QDBusConnection.sessionBus().registerObject('/', self)
iface = ChatInterface('', '', QDBusConnection.sessionBus(), self)
QDBusConnection.sessionBus().connect('', '', 'org.example.chat',
'message', self.messageSlot)
iface.action.connect(self.actionSlot)
dialog = NicknameDialog()
dialog.cancelButton.setVisible(False)
dialog.exec_()
self.m_nickname = dialog.nickname.text().strip()
self.action.emit(self.m_nickname, "joins the chat")
def download_catalogs(self):
dialog = QDialog()
dialog.setWindowTitle('Download Catalogs')
dialog.setLayout(QVBoxLayout())
dialog.layout().addWidget(QLabel('Select catalogues to be downloaded'))
checkboxes = dict([(c, QCheckBox(c)) for c in self.reference_catalogues.catalogues])
for name, checkbox in checkboxes.items():
checkbox.setChecked(True)
dialog.layout().addWidget(checkbox)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonbox.accepted.connect(dialog.accept)
buttonbox.rejected.connect(dialog.reject)
dialog.layout().addWidget(buttonbox)
if dialog.exec() == QDialog.Rejected:
return
for cat, checkbox in checkboxes.items():
if not checkbox.isChecked():
continue
spectra = self.reference_catalogues.spectra(cat)
progress = QProgressDialog('Downloading spectra from catalog {}'.format(cat), 'Cancel', 0, len(spectra))
progress.setWindowTitle('Downloading catalogs')
progress.setWindowModality(Qt.WindowModal)
progress.show()
for index, spectrum in enumerate(spectra):
progress.setValue(index)
if progress.wasCanceled():
return;
QApplication.instance().processEvents()
self.reference_catalogues.fits(spectrum)
def set_signal(self):
indx = self.ui.combobox_signals.currentIndex()
if indx != 0:
self.ui.inpt.setReadOnly(True)
else:
self.ui.inpt.setReadOnly(False)
self.ui.inpt.setText("10010110")
self.decoder_update()
return
signal = self.signals[indx - 1]
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
self.ui.inpt.setText("".join(pa.decoded_proto_bits_str))
tmp_scene = QGraphicsScene()
tmp_scene.addText(self.tr("Loading Signal..."))
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
self.ui.graphicsView_signal.setScene(tmp_scene)
if signal is not None:
last_message = pa.messages[-1]
lookup = {i: msg.bit_sample_pos for i, msg in enumerate(pa.messages)}
plot_data = signal.qad[lookup[0][0]:lookup[pa.num_messages - 1][len(last_message) - 1]]
self.ui.graphicsView_signal.plot_data(plot_data)
self.ui.graphicsView_signal.centerOn(0, 0)
QApplication.instance().restoreOverrideCursor()
def terminate(self):
"""Explicitly called destructor
"""
if self._searchThread is not None:
self._searchThread.stop()
if self._replaceThread is not None:
self._replaceThread.stop()
for action in self._createdActions:
core.actionManager().removeAction(action)
self._menuSeparator.parent().removeAction(self._menuSeparator)
if self._widget is not None:
core.workspace().currentDocumentChanged.disconnect(self._updateFileActionsState)
self._widget.visibilityChanged.disconnect(self._updateSearchWidgetFoundItemsHighlighting)
core.workspace().textChanged.disconnect(self._updateSearchWidgetFoundItemsHighlighting)
self._widget = None
if self._dock is not None:
self._dock.terminate()
self._dock = None
core.workspace().currentDocumentChanged.disconnect(self._onCurrentDocumentChanged)
core.workspace().currentDocumentChanged.disconnect(self._resetSearchInFileStartPoint)
QApplication.instance().focusChanged.disconnect(self._resetSearchInFileStartPoint)
def go():
global graphic_view, status_label
data_parent, data_child = Pipe(duplex=False)
receiver = Process(target=generate_data, args=(data_child,))
receiver.daemon = True
receiver.start()
scene = QGraphicsScene()
graphic_view.setScene(scene)
scene.setSceneRect(0, 0, 1024, 1024)
x_pos = 0
y_pos = 0
t = time.time()
while True:
speed = time.time()
data = data_parent.recv()
spectrogram = Spectrogram(data)
pixmap = QPixmap.fromImage(spectrogram.create_spectrogram_image(transpose=True))
scene.setSceneRect(scene.sceneRect().adjusted(0, 0, 0, pixmap.height()))
item = scene.addPixmap(pixmap)
item.setPos(x_pos, y_pos)
y_pos += pixmap.height()
graphic_view.fitInView(scene.sceneRect())
status_label.setText("Height: {0:.0f} // Speed: {1:.2f} // Total Time: {2:.2f}".format(scene.sceneRect().height(),
1/(time.time()-speed),
time.time()-t))
QApplication.instance().processEvents()
def modulate_data(self, buffer: np.ndarray) -> np.ndarray:
"""
:param buffer: Buffer in which the modulated data shall be written, initialized with zeros
:return:
"""
self.ui.prBarGeneration.show()
self.ui.prBarGeneration.setValue(0)
self.ui.prBarGeneration.setMaximum(self.table_model.row_count)
self.modulation_msg_indices.clear()
pos = 0
for i in range(0, self.table_model.row_count):
message = self.table_model.protocol.messages[i]
modulator = self.__get_modulator_of_message(message)
# We do not need to modulate the pause extra, as result is already initialized with zeros
modulated = modulator.modulate(start=0, data=message.encoded_bits, pause=0)
buffer[pos:pos + len(modulated)] = modulated
pos += len(modulated) + message.pause
self.modulation_msg_indices.append(pos)
self.ui.prBarGeneration.setValue(i + 1)
QApplication.instance().processEvents()
self.ui.prBarGeneration.hide()
return buffer
def hide():
"""Hide the currently displayed widget (if any)."""
global _widget
if _widget:
_widget.hide()
_widget = None
QApplication.instance().removeEventFilter(_handler)
def createActions(self):
self.newAct = QAction("&New", self, shortcut=QKeySequence.New,
statusTip="Create a new file", triggered=self.newFile)
self.openAct = QAction("&Open...", self, shortcut=QKeySequence.Open,
statusTip="Open an existing file", triggered=self.open)
self.saveAct = QAction("&Save", self, shortcut=QKeySequence.Save,
statusTip="Save the document to disk", triggered=self.save)
self.saveAsAct = QAction("Save &As...", self,
shortcut=QKeySequence.SaveAs,
statusTip="Save the document under a new name",
triggered=self.saveAs)
for i in range(MainWindow.MaxRecentFiles):
self.recentFileActs.append(
QAction(self, visible=False,
triggered=self.openRecentFile))
self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
statusTip="Exit the application",
triggered=QApplication.instance().closeAllWindows)
self.aboutAct = QAction("&About", self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction("About &Qt", self,
statusTip="Show the Qt library's About box",
triggered=QApplication.instance().aboutQt)
def show(widget, pos=None, timeout=10000):
"""Show the widget at position."""
if pos is None:
pos = QCursor.pos()
global _widget
if _widget:
if _widget is not widget:
_widget.hide()
else:
global _handler
if _handler is None:
_handler = EventHandler()
QApplication.instance().installEventFilter(_handler)
# where to display the tooltip
screen = QApplication.desktop().availableGeometry(pos)
x = pos.x() + 2
y = pos.y() + 20
if x + widget.width() > screen.x() + screen.width():
x -= 4 + widget.width()
if y + widget.height() > screen.y() + screen.height():
y -= 24 + widget.height()
if y < screen.y():
y = screen.y()
if x < screen.x():
x = screen.x()
widget.move(x, y)
if widget.windowFlags() & Qt.ToolTip != Qt.ToolTip:
widget.setWindowFlags(Qt.ToolTip)
widget.ensurePolished()
widget.show()
_widget = widget
_timer.start(timeout)
def __init__(self, parent=None, command="/bin/bash",
font_name="Monospace", font_size=18):
super(TerminalWidget, self).__init__(parent)
self.parent().setTabOrder(self, self)
self.setFocusPolicy(Qt.WheelFocus)
self.setAutoFillBackground(False)
self.setAttribute(Qt.WA_OpaquePaintEvent, True)
self.setCursor(Qt.IBeamCursor)
font = QFont(font_name)
font.setPixelSize(font_size)
self.setFont(font)
self._session = None
self._last_update = None
self._screen = []
self._text = []
self._cursor_rect = None
self._cursor_col = 0
self._cursor_row = 0
self._dirty = False
self._blink = False
self._press_pos = None
self._selection = None
self._clipboard = QApplication.clipboard()
QApplication.instance().lastWindowClosed.connect(Session.close_all)
if command:
self.execute()
def __init__(self, fig):
r"""Initializes the custom toolbar."""
# check to see if a QApplication exists, and if not, make one
if QApplication.instance() is None:
self.qapp = QApplication(sys.argv) # pragma: no cover
else:
self.qapp = QApplication.instance()
# Store the figure number for use later (Note this works better than relying on plt.gcf()
# to determine which figure actually triggered the button events.)
self.fig_number = fig.number
# create buttons - Prev Plot
icon = QIcon(os.path.join(get_images_dir(), 'prev_plot.png'))
self.btn_prev_plot = _HoverButton(icon, '')
self.btn_prev_plot.setToolTip('Show the previous plot')
fig.canvas.toolbar.addWidget(self.btn_prev_plot)
self.btn_prev_plot.clicked.connect(self.prev_plot)
# create buttons - Next Plot
icon = QIcon(os.path.join(get_images_dir(), 'next_plot.png'))
self.btn_next_plot = _HoverButton(icon, '')
self.btn_next_plot.setToolTip('Show the next plot')
fig.canvas.toolbar.addWidget(self.btn_next_plot)
self.btn_next_plot.clicked.connect(self.next_plot)
# create buttons - Close all
icon = QIcon(os.path.join(get_images_dir(), 'close_all.png'))
self.btn_close_all = _HoverButton(icon, '')
self.btn_close_all.setToolTip('Close all the open plots')
fig.canvas.toolbar.addWidget(self.btn_close_all)
self.btn_close_all.clicked.connect(self._close_all)
def main():
"""Main Loop."""
APPNAME = str(__package__ or __doc__)[:99].lower().strip().replace(" ", "")
if not sys.platform.startswith("win") and sys.stderr.isatty():
def add_color_emit_ansi(fn):
"""Add methods we need to the class."""
def new(*args):
"""Method overload."""
if len(args) == 2:
new_args = (args[0], copy(args[1]))
else:
new_args = (args[0], copy(args[1]), args[2:])
if hasattr(args[0], 'baseFilename'):
return fn(*args)
levelno = new_args[1].levelno
if levelno >= 50:
color = '\x1b[31;5;7m\n ' # blinking red with black
elif levelno >= 40:
color = '\x1b[31m' # red
elif levelno >= 30:
color = '\x1b[33m' # yellow
elif levelno >= 20:
color = '\x1b[32m' # green
elif levelno >= 10:
color = '\x1b[35m' # pink
else:
color = '\x1b[0m' # normal
try:
new_args[1].msg = color + str(new_args[1].msg) + ' \x1b[0m'
except Exception as reason:
print(reason) # Do not use log here.
return fn(*new_args)
return new
# all non-Windows platforms support ANSI Colors so we use them
log.StreamHandler.emit = add_color_emit_ansi(log.StreamHandler.emit)
log.basicConfig(level=-1, format="%(levelname)s:%(asctime)s %(message)s")
log.getLogger().addHandler(log.StreamHandler(sys.stderr))
log.info(__doc__)
try:
os.nice(19) # smooth cpu priority
libc = cdll.LoadLibrary('libc.so.6') # set process name
buff = create_string_buffer(len(APPNAME) + 1)
buff.value = bytes(APPNAME.encode("utf-8"))
libc.prctl(15, byref(buff), 0, 0, 0)
except Exception as reason:
log.warning(reason)
signal.signal(signal.SIGINT, signal.SIG_DFL) # CTRL+C work to quit app
app = QApplication(sys.argv)
app.setApplicationName(APPNAME)
app.setOrganizationName(APPNAME)
app.setOrganizationDomain(APPNAME)
app.instance().setQuitOnLastWindowClosed(False) # no quit on dialog close
icon = QIcon(app.style().standardPixmap(QStyle.SP_FileIcon))
app.setWindowIcon(icon)
win = MainWindow(icon)
win.show()
log.info('Total Maximum RAM Memory used: ~{} MegaBytes.'.format(int(
resource.getrusage(resource.RUSAGE_SELF).ru_maxrss *
resource.getpagesize() / 1024 / 1024 if resource else 0)))
sys.exit(app.exec_())
def resize_me(self):
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
w = self.font().pointSize() + 2
for i in range(10):
self.setColumnWidth(i, 2 * w)
for i in range(10, self.model().col_count):
self.setColumnWidth(i, w * len(str(i + 1)))
QApplication.instance().restoreOverrideCursor()
def makeConnections(self):
self.actionClose.triggered.connect(self.close)
self.actionChangeLayout.triggered.connect(self.toggleLayoutEditor)
self.actionChangeBackground.triggered.connect(self.changeBackground)
self.actionResetBackground.triggered.connect(self.useDefaultBackground)
self.actionSelectWidgets.triggered.connect(self.selectWidgets)
self.actionResetDefaultLayout.triggered.connect(self.resetDefaultLayout)
QApplication.instance().focusChanged.connect(self.onWindowFocusChanged)
def load_style_sheet(self, sheetName, iconsDir):
"""load qss file"""
print('Using qss file: %s'%sheetName)
qss = QFile(sheetName)
qss.open(QFile.ReadOnly)
styleSheet = str(qss.readAll(), encoding='utf8').replace(':PathPrefix', iconsDir)
QApplication.instance().setStyleSheet(styleSheet)
qss.close()
def __build_protocol(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
result = ProtocolAnalyzer(signal=None)
for _ in range(self.NUM_MESSAGES):
b = Message([True] * self.BITS_PER_MESSAGE, pause=1000, message_type=result.default_message_type)
result.messages.append(b)
return result
def __add_first_signal_to_generator(self):
generator_frame = self.form.generator_tab_controller
generator_frame.ui.cbViewType.setCurrentIndex(0)
item = generator_frame.tree_model.rootItem.children[0].children[0]
index = generator_frame.tree_model.createIndex(0, 0, item)
mimedata = generator_frame.tree_model.mimeData([index])
generator_frame.table_model.dropMimeData(mimedata, 1, -1, -1, generator_frame.table_model.createIndex(0, 0))
QApplication.instance().processEvents()
def terminate(self):
# Only run this once.
if self.isAlive:
self.isAlive = False
if self.parent():
self.parent().destroyed.disconnect(self.onParentDestroyed)
QApplication.instance().destroyed.disconnect(self.onParentDestroyed)
self._terminate()
def mouseReleaseEvent(self, event):
if self.crop_extents_model._editable:
self.mouseMoveStartH = -1
self.mouseMoveStartV = -1
# Restore the cursor to its previous state.
QApplication.instance().restoreOverrideCursor()
def test_demodulated_view(self):
self.add_signal_to_form("esaver.complex")
frame = self.form.signal_tab_controller.signal_frames[0]
frame.ui.cbSignalView.setCurrentIndex(1)
QApplication.instance().processEvents()
self.assertEqual(frame.ui.gvSignal.scene_type, 1)
if self.SHOW:
self.assertTrue(frame.ui.gvLegend.isVisible())
def __get_send_dialog(self):
send_dialog = SendDialogController(self.form.project_manager, modulated_data=self.signal.data,
testing_mode=True, parent=self.form)
if self.SHOW:
send_dialog.show()
QApplication.instance().processEvents()
send_dialog.graphics_view.show_full_scene(reinitialize=True)
return send_dialog
def clipboardDataChanged(self): mimeData = QApplication.instance().clipboard().mimeData() if mimeData is not None: self.actionPaste.setEnabled(mimeData.hasText()) self.actionPasteImage.setEnabled(mimeData.hasImage())
def postEventWithCallback(self, callback, *args):
self.queue.put((callback, args))
app = QApplication.instance()
app.postEvent(self, QEvent(QEvent.User))
def make_app():
global app
app = QApplication.instance()
if app is None:
app = QApplication([])
return app
def quit_act(self):
# sender 是发送信号的对象
sender = self.sender()
print(sender.text() + '键被按下')
qApp = QApplication.instance()
qApp.quit()
def __init__(self):
super(MainWindow, self).__init__()
self.currentPath = ''
self.view = SvgView()
fileMenu = QMenu("&File", self)
openAction = fileMenu.addAction("&Open...")
openAction.setShortcut("Ctrl+O")
quitAction = fileMenu.addAction("E&xit")
quitAction.setShortcut("Ctrl+Q")
self.menuBar().addMenu(fileMenu)
viewMenu = QMenu("&View", self)
self.backgroundAction = viewMenu.addAction("&Background")
self.backgroundAction.setEnabled(False)
self.backgroundAction.setCheckable(True)
self.backgroundAction.setChecked(False)
self.backgroundAction.toggled.connect(self.view.setViewBackground)
self.outlineAction = viewMenu.addAction("&Outline")
self.outlineAction.setEnabled(False)
self.outlineAction.setCheckable(True)
self.outlineAction.setChecked(True)
self.outlineAction.toggled.connect(self.view.setViewOutline)
self.menuBar().addMenu(viewMenu)
rendererMenu = QMenu("&Renderer", self)
self.nativeAction = rendererMenu.addAction("&Native")
self.nativeAction.setCheckable(True)
self.nativeAction.setChecked(True)
if QGLFormat.hasOpenGL():
self.glAction = rendererMenu.addAction("&OpenGL")
self.glAction.setCheckable(True)
self.imageAction = rendererMenu.addAction("&Image")
self.imageAction.setCheckable(True)
if QGLFormat.hasOpenGL():
rendererMenu.addSeparator()
self.highQualityAntialiasingAction = rendererMenu.addAction(
"&High Quality Antialiasing")
self.highQualityAntialiasingAction.setEnabled(False)
self.highQualityAntialiasingAction.setCheckable(True)
self.highQualityAntialiasingAction.setChecked(False)
self.highQualityAntialiasingAction.toggled.connect(
self.view.setHighQualityAntialiasing)
rendererGroup = QActionGroup(self)
rendererGroup.addAction(self.nativeAction)
if QGLFormat.hasOpenGL():
rendererGroup.addAction(self.glAction)
rendererGroup.addAction(self.imageAction)
self.menuBar().addMenu(rendererMenu)
openAction.triggered.connect(self.openFile)
quitAction.triggered.connect(QApplication.instance().quit)
rendererGroup.triggered.connect(self.setRenderer)
self.setCentralWidget(self.view)
self.setWindowTitle("SVG Viewer")
def on_signals_recorded(self, file_names: list, sample_rate: float):
QApplication.instance().setOverrideCursor(Qt.WaitCursor)
for filename in file_names:
self.add_signalfile(filename, enforce_sample_rate=sample_rate)
QApplication.instance().restoreOverrideCursor()
def mainUI(self):
### remove title bar
self.setWindowFlags(QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnBottomHint)
### background image and Fixed Size
back_label = QLabel(self)
back = QPixmap('.\\img\\background.png')
back_label.setPixmap(back)
self.setFixedSize(back.width(), back.height())
### close Button
close_btn = QPushButton('', self)
close_btn.setIcon(QIcon('.\\img\\close_btn.png'))
close_btn.setFixedSize(20, 20)
close_btn.setIconSize(QtCore.QSize(30, 30))
close_btn.move(back.width() - 40, 20)
close_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
close_btn.clicked.connect(QApplication.instance().quit)
### set Font
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
### ID Label, txt
ID_Label = QLabel('', self)
ID_Label.setText('I D : ')
ID_Label.setFont(font)
ID_Label.setStyleSheet("color: white")
ID_Label.setFixedSize(50, 50)
ID_Label.move(50, 430)
self.ID_txt = QTextEdit('', self)
self.ID_txt.setFixedSize(150, 30)
self.ID_txt.move(120, 440)
self.ID_txt.setCursor(QtGui.QCursor(QtCore.Qt.IBeamCursor))
### PW Label, txt
PW_Label = QLabel('', self)
PW_Label.setText('PW : ')
PW_Label.setFont(font)
PW_Label.setStyleSheet("color: white")
PW_Label.setFixedSize(50, 50)
PW_Label.move(50, 490)
self.PW_txt = QLineEdit('', self)
self.PW_txt.setFixedSize(150, 30)
self.PW_txt.setEchoMode(QLineEdit.Password)
self.PW_txt.move(120, 500)
self.PW_txt.setCursor(QtGui.QCursor(QtCore.Qt.IBeamCursor))
### Sign In Button
sin_btn = QPushButton('', self)
sin_btn.setText('Sign in')
sin_btn.setFixedSize(120, 40)
sin_btn.move(300, 435)
sin_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
### Sign Up Button
sup_btn = QPushButton('', self)
sup_btn.setText('Sign up')
sup_btn.setFixedSize(120, 40)
sup_btn.move(300, 495)
sup_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
###Btn_Clicked
sin_btn.clicked.connect(self.sin_btn_clicked)
### sup_btn.clicked.connect(self.sup_btn_clicked)
sup_btn.clicked.connect(self.sup_btn_clicked)
self.show()
def __init__(self, *args, **kwargs):
super(MoveDialog, self).__init__(*args, **kwargs)
self._pos = None
self._rect = QApplication.instance().desktop().availableGeometry(self)
def moveToCenter(window):
r = window.geometry()
r.moveCenter(QApplication.instance().desktop().screenGeometry().center())
window.setGeometry(r)
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import sys
import unittest
from unittest.mock import patch
from ReText.editor import ReTextEdit
from ReText.editor import documentIndentMore, documentIndentLess
from PyQt5.QtGui import QImage, QTextCursor, QTextDocument
from PyQt5.QtCore import Qt, QMimeData
from PyQt5.QtWidgets import QApplication
from markups import MarkdownMarkup, ReStructuredTextMarkup
QApplication.setAttribute(Qt.AA_ShareOpenGLContexts)
# Keep a reference so it is not garbage collected
app = QApplication.instance() or QApplication(sys.argv)
class SettingsMock:
tabWidth = 4
tabInsertsSpaces = True
class TestIndentation(unittest.TestCase):
def setUp(self):
self.document = QTextDocument()
self.document.setPlainText('foo\nbar\nbaz')
self.settings = SettingsMock()
def test_indentMore(self):
cursor = QTextCursor(self.document)
def test_qt(self):
from PyQt5.QtCore import QTimer
from PyQt5.QtWidgets import QApplication
from PyQt5.QtWebEngineWidgets import QWebEnginePage
from PyQt5.QtGui import QImageReader, QFontDatabase
from PyQt5.QtNetwork import QNetworkAccessManager
from calibre.utils.img import image_from_data, image_to_data, test
# Ensure that images can be read before QApplication is constructed.
# Note that this requires QCoreApplication.libraryPaths() to return the
# path to the Qt plugins which it always does in the frozen build,
# because Qt is patched to know the layout of the calibre application
# package. On non-frozen builds, it should just work because the
# hard-coded paths of the Qt installation should work. If they do not,
# then it is a distro problem.
fmts = set(
map(lambda x: x.data().decode('utf-8'),
QImageReader.supportedImageFormats())) # no2to3
testf = {'jpg', 'png', 'svg', 'ico', 'gif'}
self.assertEqual(
testf.intersection(fmts), testf,
"Qt doesn't seem to be able to load some of its image plugins. Available plugins: %s"
% fmts)
data = P('images/blank.png', allow_user_override=False, data=True)
img = image_from_data(data)
image_from_data(
P('catalog/mastheadImage.gif',
allow_user_override=False,
data=True))
for fmt in 'png bmp jpeg'.split():
d = image_to_data(img, fmt=fmt)
image_from_data(d)
# Run the imaging tests
test()
from calibre.gui2 import ensure_app, destroy_app
os.environ.pop('DISPLAY', None)
ensure_app()
self.assertGreaterEqual(
len(QFontDatabase().families()), 5,
'The QPA headless plugin is not able to locate enough system fonts via fontconfig'
)
from calibre.ebooks.covers import create_cover
create_cover('xxx', ['yyy'])
na = QNetworkAccessManager()
self.assertTrue(hasattr(na, 'sslErrors'),
'Qt not compiled with openssl')
if iswindows:
from PyQt5.Qt import QtWin
QtWin
p = QWebEnginePage()
def callback(result):
callback.result = result
if hasattr(print_callback, 'result'):
QApplication.instance().quit()
def print_callback(result):
print_callback.result = result
if hasattr(callback, 'result'):
QApplication.instance().quit()
p.runJavaScript('1 + 1', callback)
p.printToPdf(print_callback)
QTimer.singleShot(5000, lambda: QApplication.instance().quit())
QApplication.instance().exec_()
test_flaky = isosx and not is_ci
if not test_flaky:
self.assertEqual(callback.result, 2,
'Simple JS computation failed')
self.assertIn(b'Skia/PDF', bytes(print_callback.result),
'Print to PDF failed')
del p
del na
destroy_app()
del QWebEnginePage
def run(self):
self.clicked.connect(QApplication.instance().quit)
# It call function which is in argument when button is clicked
self.resize(self.sizeHint())
self.move(50, 50)
def _loop_forever():
'''Run the main loop forever
'''
QApplication.instance().exec_()
def test_sniff(self):
assert isinstance(self.form, MainController)
# add a signal so we can use it
self.add_signal_to_form("esaver.coco")
logger.debug("Added signalfile")
QApplication.instance().processEvents()
self.__add_first_signal_to_generator()
generator_frame = self.form.generator_tab_controller
self.assertEqual(generator_frame.table_model.rowCount(), 3)
QApplication.instance().processEvents()
sniff_dialog = self.__get_sniff_dialog()
sniff_dialog.sniff_settings_widget.ui.checkBoxAdaptiveNoise.click()
self.assertTrue(sniff_dialog.sniffer.adaptive_noise)
sniff_dialog.sniff_settings_widget.ui.btn_sniff_use_signal.click()
self.assertEqual(
sniff_dialog.sniff_settings_widget.ui.spinbox_sniff_BitLen.value(),
self.form.signal_tab_controller.signal_frames[0].signal.bit_len)
sniff_dialog.sniff_settings_widget.ui.checkBox_sniff_Timestamp.setChecked(
False)
self.assertEqual(sniff_dialog.device.name,
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
sniff_dialog.sniff_settings_widget.ui.comboBox_sniff_viewtype.setCurrentIndex(
0)
port = self.get_free_port()
sniff_dialog.device.set_server_port(port)
generator_frame.network_sdr_plugin.client_port = port
sniff_dialog.ui.btnStart.click()
for msg in generator_frame.table_model.protocol.messages:
msg.pause = 500e3
generator_frame.ui.btnNetworkSDRSend.click()
time.sleep(2)
QTest.qWait(100)
received_msgs = sniff_dialog.ui.txtEd_sniff_Preview.toPlainText(
).split("\n")
orig_msgs = generator_frame.table_model.protocol.plain_bits_str
self.assertEqual(len(received_msgs), len(orig_msgs))
for received, orig in zip(received_msgs, orig_msgs):
pad = 0 if len(orig) % 8 == 0 else 8 - len(orig) % 8
self.assertEqual(received, orig + "0" * pad)
sniff_dialog.ui.btnStop.click()
sniff_dialog.sniff_settings_widget.ui.checkBox_sniff_Timestamp.click()
self.assertTrue(
sniff_dialog.ui.txtEd_sniff_Preview.toPlainText().startswith("["))
sniff_dialog.sniff_settings_widget.ui.checkBox_sniff_Timestamp.click()
self.assertFalse(
sniff_dialog.ui.txtEd_sniff_Preview.toPlainText().startswith("["))
n = self.form.compare_frame_controller.protocol_model.rowCount()
sniff_dialog.protocol_accepted.emit(sniff_dialog.sniffer.messages)
QTest.qWait(10)
self.assertEqual(
self.form.compare_frame_controller.protocol_model.rowCount(),
n + 3)
target_file = os.path.join(QDir.tempPath(), "sniff_file.txt")
if os.path.isfile(target_file):
os.remove(target_file)
sniff_dialog.ui.btnClear.click()
QApplication.instance().processEvents()
sniff_dialog.sniff_settings_widget.ui.lineEdit_sniff_OutputFile.setText(
target_file)
sniff_dialog.sniff_settings_widget.ui.lineEdit_sniff_OutputFile.editingFinished.emit(
)
sniff_dialog.ui.btnStart.click()
QApplication.instance().processEvents()
self.assertFalse(sniff_dialog.ui.btnAccept.isEnabled())
generator_frame.ui.btnNetworkSDRSend.click()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
with open(target_file, "r") as f:
for i, line in enumerate(f):
pad = 0 if len(
orig_msgs[i]) % 8 == 0 else 8 - len(orig_msgs[i]) % 8
self.assertEqual(line.strip(), orig_msgs[i] + "0" * pad)
sniff_dialog.ui.btnStop.click()
self.assertFalse(sniff_dialog.ui.btnStop.isEnabled())
sniff_dialog.close()
def get_app():
""" Returns the current QApplication instance of OpenShot """
return QApplication.instance()
def __init__(self):
super(UIMainWindow, self).__init__()
uic.loadUi(main_window_ui, self)
# Update title if app running with admin privileges
if is_admin():
self.setWindowTitle(self.windowTitle() + ' (Administrator)')
# region External windows
self.about_w = UIAbout() # "About" dialogue window
self.db_settings_w = UIDBSettings() # "DB Settings" dialogue window
self.general_settings_w = UIGeneralSettings(
) # "General Settings" dialogue window
self.ca_settings_w = UICASettings() # "Channel Access" dialogue window
self.service_dir_path_w = UIServicePathDialog(
) # "Service Directory" dialogue window
self.config_entry_w = UIConfigEntryDialog(
) # Add/Edit Configuration Entry dialogue window
# endregion
# region External windows setup
self.db_settings_w.update_db_connection_status.connect(
self.update_fields)
self.service_dir_path_w.service_updated.connect(self.update_service)
self.service_dir_path_w.service_updated.connect(self.update_fields)
self.config_entry_w.config_updated.connect(self.refresh_config)
# endregion
# region Attributes
self.table_expanded = False # For toggling table expansion ("Expand Table"/"Service Info")
self.pv_config_data = [
] # Store the PV configuration data to be displayed in the config. table
self.expand_table_btn_text = EXPAND_CONFIG_TABLE_BTN
# endregion
# region Menu actions & signals
self.about_action.triggered.connect(
lambda _: self.trigger_window(self.about_w))
self.manager_log_action.triggered.connect(
lambda _: os.startfile(MANAGER_LOGS_FILE))
self.manager_settings_action.triggered.connect(
lambda _: os.startfile(MANAGER_SETTINGS_FILE))
self.manager_settings_dir_action.triggered.connect(
lambda _: os.startfile(MANAGER_SETTINGS_DIR))
self.show_service_log.triggered.connect(self.open_service_log)
self.show_service_dir.triggered.connect(self.trigger_open_service_dir)
self.show_service_settings.triggered.connect(
lambda _: os.startfile(Settings.Service.settings_path))
self.db_settings_action.triggered.connect(
lambda _: self.trigger_window(self.db_settings_w))
self.general_settings_action.triggered.connect(
lambda _: self.trigger_window(self.general_settings_w))
self.ca_settings_action.triggered.connect(
lambda _: self.trigger_window(self.ca_settings_w))
self.service_directory_action.triggered.connect(
self.trigger_service_directory)
self.open_pv_config_action.triggered.connect(
self.trigger_open_pv_config)
# endregion
# region Setup widgets
btn_conf = [(self.btn_service_start, 'start.svg'),
(self.btn_service_stop, 'stop.svg'),
(self.btn_service_restart, 'restart.svg'),
(self.db_connection_refresh_btn, 'refresh.svg'),
(self.expand_table_btn, None),
(self.refresh_btn, 'refresh_config.svg'),
(self.show_filter_btn, 'filter.svg'),
(self.new_config_btn, 'add.svg'),
(self.edit_config_btn, 'edit.svg'),
(self.delete_config_btn, 'delete.svg')]
for btn in btn_conf:
setup_button(btn[0], btn[1])
if not is_admin():
for btn in [
self.btn_service_start, self.btn_service_stop,
self.btn_service_restart
]:
btn.setEnabled(False)
btn.setToolTip(
btn.toolTip() +
'\nRun the manager as administrator to start/stop/restart the service.'
)
# Filter/Search Frame Setup
self.filter_frame.setVisible(False)
# Save the table header names, to be used for the Filters columns combo box
column_names = [
self.config_table.horizontalHeaderItem(index).text()
for index in range(self.config_table.columnCount())
]
self.filter_columns_cb.insertItems(0, ['All columns', *column_names])
# endregion
# region Signals to Slots
self.btn_service_start.clicked.connect(
lambda _: self.call_on_service(win32serviceutil.StartService))
self.btn_service_stop.clicked.connect(
lambda _: self.call_on_service(win32serviceutil.StopService))
self.btn_service_restart.clicked.connect(
lambda _: self.call_on_service(win32serviceutil.RestartService))
self.db_connection_refresh_btn.clicked.connect(
self.refresh_db_connection)
self.config_table.itemSelectionChanged.connect(
self.enable_or_disable_edit_and_delete_buttons)
self.expand_table_btn.clicked.connect(self.expand_table_btn_clicked)
self.refresh_btn.clicked.connect(self.refresh_config)
self.show_filter_btn.clicked.connect(self.show_filter_btn_clicked)
self.new_config_btn.clicked.connect(self.new_config_btn_clicked)
self.edit_config_btn.clicked.connect(self.edit_config_btn_clicked)
self.delete_config_btn.clicked.connect(self.delete_config_btn_clicked)
# Table Filters
self.apply_filter_btn.clicked.connect(self.apply_filters)
self.filter_bar.returnPressed.connect(self.apply_filters)
self.clear_filter_btn.clicked.connect(self.clear_filters)
# endregion
# region Threads
# region Service Status Thread
# noinspection PyTypeChecker
self.thread_service_status = ServiceStatusCheckThread()
self.thread_service_status.update_status_title.connect(
self.service_status_title.setText)
self.thread_service_status.update_status_style.connect(
self.service_status_title.setStyleSheet)
self.thread_service_status.update_service_details.connect(
self.update_service_details)
self.thread_service_status.update_service_control_btns.connect(
self.update_service_control_btns)
self.thread_service_status.start()
# endregion
# region Service Log Thread
# noinspection PyTypeChecker
self.thread_service_log = ServiceLogUpdaterThread(
self.service_log_show_lines_spinbox.value())
self.thread_service_log.log_fetched.connect(self.update_service_log)
self.thread_service_log.file_not_found.connect(self.clear_service_log)
self.thread_service_log.enable_or_disable_buttons.connect(
self.update_service_log_btns)
self.thread_service_log.start()
# endregion
# QThreads graceful exit on app close
QApplication.instance().aboutToQuit.connect(
self.thread_service_status.stop)
QApplication.instance().aboutToQuit.connect(
self.thread_service_log.stop)
# endregion
# region Service Log Widgets
self.service_log_file_open_btn.clicked.connect(self.open_service_log)
self.service_log_scroll_down_btn.clicked.connect(
self.log_scroll_to_bottom)
# Emit spinner valueChanged only on return key pressed, focus lost, and widget arrow keys clicked
self.service_log_show_lines_spinbox.setKeyboardTracking(False)
self.service_log_font_size.currentTextChanged.connect(
self.update_log_font_size)
self.service_log_show_lines_spinbox.valueChanged.connect(
self.thread_service_log.set_displayed_lines_no)
def initUI(self):
self.setStyleSheet("background-color: white")
#Layout Manager and Items
self.chooseFile = QCheckBox("Audio File")
self.chooseFile.setChecked(True)
self.chooseFile.clicked.connect(self.audioSelected)
#chooseFile.setAlignment(Qt.AlignCenter)
filecheckbox = QHBoxLayout()
filecheckbox.addWidget(self.chooseFile)
filecheckbox.setAlignment(Qt.AlignCenter)
self.fileLabel = QLineEdit("")
openBtn = QPushButton("Open", self)
openBtn.clicked.connect(self.openFileDialog)
openBtn.resize(openBtn.sizeHint())
filebox = QHBoxLayout()
filebox.addWidget(self.fileLabel)
filebox.addWidget(openBtn)
filebox.setAlignment(Qt.AlignCenter)
filebox.setContentsMargins(90, 0, 90, 0)
self.chooseMic = QCheckBox("Microphone")
self.chooseMic.clicked.connect(self.micSelected)
miccheckbox = QHBoxLayout()
miccheckbox.addWidget(self.chooseMic)
miccheckbox.setAlignment(Qt.AlignCenter)
startBtn = QPushButton("Start", self)
startBtn.clicked.connect(self.hal)
startBtn.resize(startBtn.sizeHint())
hbox = QHBoxLayout()
hbox.addWidget(startBtn)
hbox.setAlignment(Qt.AlignCenter)
self.commandBtn = QPushButton("Execute Command", self)
self.commandBtn.clicked.connect(self.runCmd)
self.commandBtn.setEnabled(False)
self.commandBtn.resize(self.commandBtn.sizeHint())
hbox4 = QHBoxLayout()
hbox4.addWidget(self.commandBtn)
hbox4.setAlignment(Qt.AlignCenter)
closeBtn = QPushButton("Close", self)
closeBtn.clicked.connect(QApplication.instance().quit)
closeBtn.resize(closeBtn.sizeHint())
hbox5 = QHBoxLayout()
hbox5.addWidget(closeBtn)
hbox5.setAlignment(Qt.AlignCenter)
self.gif = QLabel("Loading GIF here.")
self.gif.setPixmap(QPixmap("../../gui/stop.png"))
hbox2 = QHBoxLayout()
hbox2.addWidget(self.gif)
hbox2.setAlignment(Qt.AlignCenter)
self.resultLabel = QLabel("Click Start to begin detection...")
hbox3 = QHBoxLayout()
hbox3.setAlignment(Qt.AlignCenter)
hbox3.addWidget(self.resultLabel)
vbox = QVBoxLayout()
vbox.addLayout(filecheckbox)
vbox.addLayout(filebox)
vbox.addLayout(miccheckbox)
vbox.addLayout(hbox2)
vbox.addLayout(hbox3)
vbox.addLayout(hbox)
vbox.addLayout(hbox4)
vbox.addLayout(hbox5)
self.setLayout(vbox)
self.resize(600, 500)
self.center()
self.setWindowTitle('Word Recognizer')
self.show()
def print_msg(self):
print(QApplication.instance())
print(QApplication.instance().datacenter)
def create_connects(self):
self.ui.actionFullscreen_mode.setShortcut(QKeySequence.FullScreen)
self.ui.actionOpen.setShortcut(QKeySequence(QKeySequence.Open))
self.ui.actionOpen_directory.setShortcut(QKeySequence("Ctrl+Shift+O"))
self.ui.menuEdit.aboutToShow.connect(self.on_edit_menu_about_to_show)
self.ui.actionNew_Project.triggered.connect(
self.on_new_project_action_triggered)
self.ui.actionNew_Project.setShortcut(QKeySequence.New)
self.ui.actionProject_settings.triggered.connect(
self.on_project_settings_action_triggered)
self.ui.actionSave_project.triggered.connect(self.save_project)
self.ui.actionClose_project.triggered.connect(self.close_project)
self.ui.actionAbout_AutomaticHacker.triggered.connect(
self.on_show_about_clicked)
self.ui.actionRecord.triggered.connect(
self.on_show_record_dialog_action_triggered)
self.ui.actionFullscreen_mode.triggered.connect(
self.on_fullscreen_action_triggered)
self.ui.actionSaveAllSignals.triggered.connect(
self.signal_tab_controller.save_all)
self.ui.actionCloseAllFiles.triggered.connect(
self.on_close_all_files_action_triggered)
self.ui.actionOpen.triggered.connect(
self.on_open_file_action_triggered)
self.ui.actionOpen_directory.triggered.connect(
self.on_open_directory_action_triggered)
self.ui.actionDecoding.triggered.connect(
self.on_show_decoding_dialog_triggered)
self.ui.actionSpectrum_Analyzer.triggered.connect(
self.on_show_spectrum_dialog_action_triggered)
self.ui.actionOptions.triggered.connect(
self.show_options_dialog_action_triggered)
self.ui.actionSniff_protocol.triggered.connect(
self.show_proto_sniff_dialog)
self.ui.actionAbout_Qt.triggered.connect(
QApplication.instance().aboutQt)
self.ui.actionSamples_from_csv.triggered.connect(
self.on_import_samples_from_csv_action_triggered)
self.ui.actionAuto_detect_new_signals.triggered.connect(
self.on_auto_detect_new_signals_action_triggered)
self.ui.btnFileTreeGoUp.clicked.connect(
self.on_btn_file_tree_go_up_clicked)
self.ui.fileTree.directory_open_wanted.connect(
self.project_manager.set_project_folder)
self.signal_tab_controller.frame_closed.connect(
self.close_signal_frame)
self.signal_tab_controller.signal_created.connect(
self.on_signal_created)
self.signal_tab_controller.ui.scrollArea.files_dropped.connect(
self.on_files_dropped)
self.signal_tab_controller.files_dropped.connect(self.on_files_dropped)
self.signal_tab_controller.frame_was_dropped.connect(
self.set_frame_numbers)
self.simulator_tab_controller.open_in_analysis_requested.connect(
self.on_simulator_open_in_analysis_requested)
self.simulator_tab_controller.rx_file_saved.connect(
self.adjust_for_current_file)
self.compare_frame_controller.show_interpretation_clicked.connect(
self.show_protocol_selection_in_interpretation)
self.compare_frame_controller.files_dropped.connect(
self.on_files_dropped)
self.compare_frame_controller.show_decoding_clicked.connect(
self.on_show_decoding_dialog_triggered)
self.compare_frame_controller.ui.treeViewProtocols.files_dropped_on_group.connect(
self.on_files_dropped_on_group)
self.compare_frame_controller.participant_changed.connect(
self.signal_tab_controller.on_participant_changed)
self.compare_frame_controller.ui.treeViewProtocols.close_wanted.connect(
self.on_cfc_close_wanted)
self.compare_frame_controller.show_config_field_types_triggered.connect(
self.on_show_field_types_config_action_triggered)
self.compare_frame_controller.load_protocol_clicked.connect(
self.on_compare_frame_controller_load_protocol_clicked)
self.compare_frame_controller.ui.listViewParticipants.doubleClicked.connect(
self.on_project_settings_action_triggered)
self.ui.lnEdtTreeFilter.textChanged.connect(
self.on_file_tree_filter_text_changed)
self.ui.tabWidget.currentChanged.connect(self.on_selected_tab_changed)
self.project_save_timer.timeout.connect(self.save_project)
self.ui.actionConvert_Folder_to_Project.triggered.connect(
self.project_manager.convert_folder_to_project)
self.project_manager.project_loaded_status_changed.connect(
self.on_project_loaded_status_changed)
self.project_manager.project_updated.connect(self.on_project_updated)
self.ui.textEditProjectDescription.textChanged.connect(
self.on_text_edit_project_description_text_changed)
self.ui.tabWidget_Project.tabBarDoubleClicked.connect(
self.on_project_tab_bar_double_clicked)
self.ui.listViewParticipants.doubleClicked.connect(
self.on_project_settings_action_triggered)
self.ui.actionShowFileTree.triggered.connect(
self.on_action_show_filetree_triggered)
self.ui.actionShowFileTree.setShortcut(QKeySequence("F10"))
self.ui.labelNonProjectMode.linkActivated.connect(
self.on_label_non_project_mode_link_activated)
self.ui.menuFile.addSeparator()
for i in range(settings.MAX_RECENT_FILE_NR):
recent_file_action = QAction(self)
recent_file_action.setVisible(False)
recent_file_action.triggered.connect(
self.on_open_recent_action_triggered)
self.recentFileActionList.append(recent_file_action)
self.ui.menuFile.addAction(self.recentFileActionList[i])
import lxml.etree as ET
import pytest
from GEMEditor.model.classes.cobra import Model, Reaction, Gene, Metabolite
from GEMEditor.model.classes.reference import Reference
from GEMEditor.model.classes.evidence import Evidence
from GEMEditor.rw import *
from GEMEditor.rw.evidences import add_evidences_to_xml, parse_evidences_from_xml, get_item_from_model
from GEMEditor.rw.test.ex_evidences import minimal_evidence, full_evidence
from PyQt5.QtWidgets import QApplication
from lxml.etree import Element
# Make sure to only start an application
# if there is no active one. Opening multiple
# applications will lead to a crash.
app = QApplication.instance()
if app is None:
app = QApplication([])
class TestEvidence:
@pytest.fixture(autouse=True)
def setup_evidence(self):
self.reaction = Reaction("r_id")
self.gene = Gene("g_id")
self.target = Gene("g_id2")
self.model = Model("test id")
self.reference = Reference()
self.model.add_gene(self.gene)
self.model.add_gene(self.target)
self.model.add_reactions([self.reaction])
def __init__(self):
QObject.__init__(self)
self.moveToThread(QApplication.instance().thread())
self.showMessageSignal.connect(self.showMessageSlot)
self.showMessageSignal.emit()
def version():
"""Return a string with various version information."""
lines = ["qutebrowser v{}".format(qutebrowser.__version__)]
gitver = _git_str()
if gitver is not None:
lines.append("Git commit: {}".format(gitver))
lines.append("Backend: {}".format(_backend()))
lines += [
'',
'{}: {}'.format(platform.python_implementation(),
platform.python_version()),
'Qt: {}'.format(earlyinit.qt_version()),
'PyQt: {}'.format(PYQT_VERSION_STR),
'',
]
lines += _module_versions()
lines += [
'pdf.js: {}'.format(_pdfjs_version()),
'sqlite: {}'.format(sql.version()),
'QtNetwork SSL: {}\n'.format(QSslSocket.sslLibraryVersionString(
) if QSslSocket.supportsSsl() else 'no'),
]
qapp = QApplication.instance()
if qapp:
style = qapp.style()
lines.append('Style: {}'.format(style.metaObject().className()))
importpath = os.path.dirname(os.path.abspath(qutebrowser.__file__))
lines += [
'Platform: {}, {}'.format(platform.platform(),
platform.architecture()[0]),
]
dist = distribution()
if dist is not None:
lines += [
'Linux distribution: {} ({})'.format(dist.pretty, dist.parsed.name)
]
lines += [
'Frozen: {}'.format(hasattr(sys, 'frozen')),
"Imported from {}".format(importpath),
"Using Python from {}".format(sys.executable),
"Qt library executable path: {}, data path: {}".format(
QLibraryInfo.location(QLibraryInfo.LibraryExecutablesPath),
QLibraryInfo.location(QLibraryInfo.DataPath))
]
if not dist or dist.parsed == Distribution.unknown:
lines += _os_info()
lines += [
'',
'Paths:',
]
for name, path in sorted(_path_info().items()):
lines += ['{}: {}'.format(name, path)]
lines += [
'',
'Uptime: {}'.format(_uptime()),
]
return '\n'.join(lines)
def __init__(self):
super(UIConfigEntryDialog, self).__init__()
uic.loadUi(uifile=config_entry_ui,
baseinstance=self) # Load the UI file and its widgets
self.setModal(True)
# region Attributes
self.last_details_update_obj = None # Name of object whose details were last updated and displayed
self.loading_msg = LoadingPopupWindow(
) # Loading splash screen when testing PV connection
self.pv_check_obj_id = None # For PV auto-check. Save object ID and whether it already exists
self.pv_check_obj_already_exists = None # before starting the connection test thread.
self.existing_config_pvs = {
} # Store existing object config measurement PVs when 'Load' clicked
self.type_and_comment_updated = False # If the object type and comment were updated by an existing object
# Default text of the Check PVs button ("Loading ...")
self.check_pvs_btn_default_text = self.check_pvs_btn.text()
# endregion
# region Widget Setup - things that can't be done in QtDesigner
self.obj_name_cb.lineEdit().setPlaceholderText(
'Enter new object name or select existing')
self.mea_widgets = [
(self.mea_pv_name_1, self.mea_type_lbl_1, self.mea_status_lbl_1),
(self.mea_pv_name_2, self.mea_type_lbl_2, self.mea_status_lbl_2),
(self.mea_pv_name_3, self.mea_type_lbl_3, self.mea_status_lbl_3),
(self.mea_pv_name_4, self.mea_type_lbl_4, self.mea_status_lbl_4),
(self.mea_pv_name_5, self.mea_type_lbl_5, self.mea_status_lbl_5),
]
self.existing_config_frame.hide()
self.existing_config_load_btn.setEnabled(False)
self.check_pvs_progress_bar.hide()
# endregion
# region Signals & Slots
self.obj_details_frame.showEvent = lambda x: self.obj_details_btn.setText(
'Hide details')
self.obj_details_frame.hideEvent = lambda x: self.obj_details_btn.setText(
'Show details')
self.obj_name_cb.currentIndexChanged.connect(self.load_object_data)
self.obj_name_cb.lineEdit().returnPressed.connect(
self.load_object_data)
self.obj_name_cb.lineEdit().textChanged.connect(
lambda: set_red_border(self.obj_name_frame, False))
self.obj_name_cb.lineEdit().textChanged.connect(
self.check_for_existing_config_pvs)
self.obj_name_cb.lineEdit().textChanged.connect(self.load_object_data)
self.object_name_filter = ObjectNameCBFilter(
) # instantiate event filter with custom signals
self.object_name_filter.focusOut.connect(
self.load_object_data) # connect filter custom signal to slot
self.obj_name_cb.installEventFilter(
self.object_name_filter) # install filter to widget
self.obj_display_group_cb.currentTextChanged.connect(
self.message_lbl.clear)
self.obj_type_cb.currentTextChanged.connect(self.message_lbl.clear)
self.obj_type_cb.currentTextChanged.connect(
lambda: set_red_border(self.obj_type_frame, False))
self.obj_type_cb.currentTextChanged.connect(
self.update_measurement_types)
self.obj_details_btn.clicked.connect(self.toggle_details_frame)
# Connect signals for each measurement PV name line edit
for mea in self.mea_widgets:
# Need to bind mea for each function created (x=mea), otherwise only last mea will be affected
mea[0].textChanged.connect(
lambda _, x=mea: self.on_mea_pv_text_change(x))
# If any PV name has been changed, if the load existing config frame is visible, enable the load button
# and update its text. (Disabled, 'Loaded' --> Enabled, 'Load')
mea[0].textEdited.connect(self.update_load_existing_config_btn)
self.existing_config_load_btn.clicked.connect(
self.load_existing_config_pvs)
self.check_pvs_progress_bar.showEvent = self.on_progress_bar_show_event
self.check_pvs_progress_bar.hideEvent = self.on_progress_bar_hide_event
self.check_pvs_btn.clicked.connect(self.start_measurement_pvs_check)
self.ok_btn.clicked.connect(self.on_accepted)
self.cancel_btn.clicked.connect(self.close)
self.delete_btn.clicked.connect(self.on_delete)
# endregion
# region Thread - PV Connection Check
self.pvs_connection_thread = CheckPVsThread()
self.pvs_connection_thread.mea_status_update.connect(
self.update_measurements_pvs_status)
self.pvs_connection_thread.display_progress_bar.connect(
lambda x: self.check_pvs_progress_bar.setVisible(x))
self.pvs_connection_thread.progress_bar_update.connect(
lambda val: self.check_pvs_progress_bar.setValue(val))
self.pvs_connection_thread.started.connect(
self.pvs_connection_check_started)
self.pvs_connection_thread.finished_check.connect(
lambda x: self.pvs_connection_check_finished(x))
QApplication.instance().aboutToQuit.connect(
self.pvs_connection_thread.stop) # graceful exit on app close
def styleSheet(cls):
"""获取Application的样式
"""
return QApplication.instance().styleSheet()
def initUI(
self, key
): # Method which creates some default settings (creates the window)
QToolTip.setFont(
QFont("Arial",
10)) # Font used to render (= berechnen, erzeugen) tooltips
self.setToolTip(
"This is a <b>QWidget</b> widget"
) # Shows up when hovering over the Window object, i.e., the window
btn = QPushButton(
"Quit", self
) # Creates a Button object whith text = "Button" which "belongs" to the Window object created
btn.setToolTip(
"This is a <b>QPushButton</b> widget"
) # Shows up when hovering over the Button (<b></b> means "bold")
btn.clicked.connect(
QApplication.instance().quit
) # "clicked" is a signal (signal and slot system) connected to the quit() method
btn.resize(
btn.sizeHint()
) # Resizes the Button according to the window's dimensions (sizeHint())
btn.move(250, 175) # Moves the Button to (x = 50, y = 50)
# Buttons
okButton = QPushButton(
"OK"
) # "self" attribute missing because you don't simply want to place the
# button inside the window
cancelButton = QPushButton("Cancel")
# Layouts - Can only be placed inside of a QWidget, it is not compatible with QMainWindow!
if key == "hOrVBox":
hBox = QHBoxLayout(
) # Creates a horizontal Layout, i.e a layout where items placed are
# alligned horizontally
hBox.addStretch(
1
) # Adds a stretchfactor of 1, i.e a strechable space on the left
# part of the HBox, which pushes the buttons to the right of the layout
hBox.addWidget(okButton) # Adds the button to the layout
hBox.addWidget(cancelButton)
vBox = QVBoxLayout() # Creates a vertical layout
vBox.addStretch(1) # Same as for the HBox
vBox.addLayout(hBox) # Adds the HBox to the VBox
self.setLayout(vBox) # Sets the window's layout
elif key == "grid":
grid = QGridLayout(
) # Creates a grid layout, i.e a layout which works with columns and rows
grid.setSpacing(10)
buttonLabels = [ # List of button labels
'Clear', 'Back', '', 'Close', '7', '8', '9', '/', '4', '5',
'6', '*', '1', '2', '3', '-', '0', '.', '=', '+'
]
positions = [
(i, j) for i in range(5) for j in range(4)
] # List of positions, stored as (y,x) coordinates, i.e a list
# of tuples
for buttonLabel, position in zip(
buttonLabels, positions
): # zip() creates an iterable of the form (first, second),
# (first, second)
if buttonLabel == "": # No button needed here
continue
button = QPushButton(buttonLabel)
grid.addWidget(
button, *position
) # * = variadic arguments, which means that the position tuple
# gets unpacked and the row and the column index is passed to
# the function
self.setLayout(grid)
else:
title = QLabel('Title') # Creates a basic label which says "Title"
author = QLabel('Author')
review = QLabel('Review')
titleEdit = QLineEdit(
) # Creates an line where the user can type in stuff
authorEdit = QLineEdit()
reviewEdit = QTextEdit(
) # Creates an area where the user can type in stuff, which can be expanded
# to the bottom by the user himself by adding a newline or manually by
# increasing its rowspan
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(title, 1, 0)
grid.addWidget(titleEdit, 1, 1)
grid.addWidget(author, 2, 0)
grid.addWidget(authorEdit, 2, 1)
grid.addWidget(review, 3, 0)
grid.addWidget(
reviewEdit, 3, 1, 5, 1
) # The last two arguments define respectively the features "rowspan" and
# "columnspan", which influences the amount of rows or columns the widget
# will occupy
self.setLayout(grid)
self.resize(350, 250) # Resizes the window
self.move(0, 50)
#self.center() # Custom method to center the window which does not work because the class
# is obsolete
#self.setWindowTitle("PyQt5") # Sets the window's title
#self.setWindowIcon(QIcon("exit.jpeg")) # Sets an icon to the left of the WindowTitle (does not work on mac)
self.show() # Makes the window appear on the screen
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.resize(950, 700)
screenRect = QDesktopWidget().screenGeometry()
if globalSettings.windowGeometry:
self.restoreGeometry(globalSettings.windowGeometry)
else:
self.move((screenRect.width()-self.width())/2, (screenRect.height()-self.height())/2)
if not screenRect.contains(self.geometry()):
self.showMaximized()
if sys.platform.startswith('darwin'):
# https://github.com/retext-project/retext/issues/198
searchPaths = QIcon.themeSearchPaths()
searchPaths.append('/opt/local/share/icons')
searchPaths.append('/usr/local/share/icons')
QIcon.setThemeSearchPaths(searchPaths)
if globalSettings.iconTheme:
QIcon.setThemeName(globalSettings.iconTheme)
if QIcon.themeName() in ('hicolor', ''):
if not QFile.exists(getBundledIcon('document-new')):
QIcon.setThemeName(get_icon_theme())
if QFile.exists(getBundledIcon('retext')):
self.setWindowIcon(QIcon(getBundledIcon('retext')))
elif QFile.exists('/usr/share/pixmaps/retext.png'):
self.setWindowIcon(QIcon('/usr/share/pixmaps/retext.png'))
else:
self.setWindowIcon(QIcon.fromTheme('retext',
QIcon.fromTheme('accessories-text-editor')))
self.tabWidget = QTabWidget(self)
self.initTabWidget()
self.setCentralWidget(self.tabWidget)
self.tabWidget.currentChanged.connect(self.changeIndex)
self.tabWidget.tabCloseRequested.connect(self.closeTab)
self.toolBar = QToolBar(self.tr('File toolbar'), self)
self.addToolBar(Qt.TopToolBarArea, self.toolBar)
self.editBar = QToolBar(self.tr('Edit toolbar'), self)
self.addToolBar(Qt.TopToolBarArea, self.editBar)
self.searchBar = QToolBar(self.tr('Search toolbar'), self)
self.addToolBar(Qt.BottomToolBarArea, self.searchBar)
self.toolBar.setVisible(not globalSettings.hideToolBar)
self.editBar.setVisible(not globalSettings.hideToolBar)
self.actionNew = self.act(self.tr('New'), 'document-new',
self.createNew, shct=QKeySequence.New)
self.actionNew.setPriority(QAction.LowPriority)
self.actionOpen = self.act(self.tr('Open'), 'document-open',
self.openFile, shct=QKeySequence.Open)
self.actionOpen.setPriority(QAction.LowPriority)
self.actionSetEncoding = self.act(self.tr('Set encoding'),
trig=self.showEncodingDialog)
self.actionSetEncoding.setEnabled(False)
self.actionReload = self.act(self.tr('Reload'), 'view-refresh',
lambda: self.currentTab.readTextFromFile())
self.actionReload.setEnabled(False)
self.actionSave = self.act(self.tr('Save'), 'document-save',
self.saveFile, shct=QKeySequence.Save)
self.actionSave.setEnabled(False)
self.actionSave.setPriority(QAction.LowPriority)
self.actionSaveAs = self.act(self.tr('Save as'), 'document-save-as',
self.saveFileAs, shct=QKeySequence.SaveAs)
self.actionNextTab = self.act(self.tr('Next tab'), 'go-next',
lambda: self.switchTab(1), shct=Qt.CTRL+Qt.Key_PageDown)
self.actionPrevTab = self.act(self.tr('Previous tab'), 'go-previous',
lambda: self.switchTab(-1), shct=Qt.CTRL+Qt.Key_PageUp)
self.actionCloseCurrentTab = self.act(self.tr('Close tab'), 'window-close',
lambda: self.closeTab(self.ind), shct=QKeySequence.Close)
self.actionPrint = self.act(self.tr('Print'), 'document-print',
self.printFile, shct=QKeySequence.Print)
self.actionPrint.setPriority(QAction.LowPriority)
self.actionPrintPreview = self.act(self.tr('Print preview'), 'document-print-preview',
self.printPreview)
self.actionViewHtml = self.act(self.tr('View HTML code'), 'text-html', self.viewHtml)
self.actionChangeEditorFont = self.act(self.tr('Change editor font'),
trig=self.changeEditorFont)
self.actionChangePreviewFont = self.act(self.tr('Change preview font'),
trig=self.changePreviewFont)
self.actionSearch = self.act(self.tr('Find text'), 'edit-find',
self.search, shct=QKeySequence.Find)
self.actionGoToLine = self.act(self.tr('Go to line'),
trig=self.goToLine, shct=Qt.CTRL+Qt.Key_G)
self.searchBar.visibilityChanged.connect(self.searchBarVisibilityChanged)
self.actionPreview = self.act(self.tr('Preview'), shct=Qt.CTRL+Qt.Key_E,
trigbool=self.preview)
if QIcon.hasThemeIcon('document-preview'):
self.actionPreview.setIcon(QIcon.fromTheme('document-preview'))
elif QIcon.hasThemeIcon('preview-file'):
self.actionPreview.setIcon(QIcon.fromTheme('preview-file'))
elif QIcon.hasThemeIcon('x-office-document'):
self.actionPreview.setIcon(QIcon.fromTheme('x-office-document'))
else:
self.actionPreview.setIcon(QIcon(getBundledIcon('document-preview')))
self.actionLivePreview = self.act(self.tr('Live preview'), shct=Qt.CTRL+Qt.Key_L,
trigbool=self.enableLivePreview)
menuPreview = QMenu()
menuPreview.addAction(self.actionLivePreview)
self.actionPreview.setMenu(menuPreview)
self.actionInsertTable = self.act(self.tr('Insert table'),
trig=lambda: self.insertFormatting('table'))
self.actionTableMode = self.act(self.tr('Table editing mode'),
shct=Qt.CTRL+Qt.Key_T,
trigbool=lambda x: self.currentTab.editBox.enableTableMode(x))
if ReTextFakeVimHandler:
self.actionFakeVimMode = self.act(self.tr('FakeVim mode'),
shct=Qt.CTRL+Qt.ALT+Qt.Key_V, trigbool=self.enableFakeVimMode)
if globalSettings.useFakeVim:
self.actionFakeVimMode.setChecked(True)
self.enableFakeVimMode(True)
self.actionFullScreen = self.act(self.tr('Fullscreen mode'), 'view-fullscreen',
shct=Qt.Key_F11, trigbool=self.enableFullScreen)
self.actionFullScreen.setChecked(self.isFullScreen())
self.actionFullScreen.setPriority(QAction.LowPriority)
self.actionConfig = self.act(self.tr('Preferences'), icon='preferences-system',
trig=self.openConfigDialog)
self.actionConfig.setMenuRole(QAction.PreferencesRole)
self.actionSaveHtml = self.act('HTML', 'text-html', self.saveFileHtml)
self.actionPdf = self.act('PDF', 'application-pdf', self.savePdf)
self.actionOdf = self.act('ODT', 'x-office-document', self.saveOdf)
self.getExportExtensionsList()
self.actionQuit = self.act(self.tr('Quit'), 'application-exit', shct=QKeySequence.Quit)
self.actionQuit.setMenuRole(QAction.QuitRole)
self.actionQuit.triggered.connect(self.close)
self.actionUndo = self.act(self.tr('Undo'), 'edit-undo',
lambda: self.currentTab.editBox.undo(), shct=QKeySequence.Undo)
self.actionRedo = self.act(self.tr('Redo'), 'edit-redo',
lambda: self.currentTab.editBox.redo(), shct=QKeySequence.Redo)
self.actionCopy = self.act(self.tr('Copy'), 'edit-copy',
lambda: self.currentTab.editBox.copy(), shct=QKeySequence.Copy)
self.actionCut = self.act(self.tr('Cut'), 'edit-cut',
lambda: self.currentTab.editBox.cut(), shct=QKeySequence.Cut)
self.actionPaste = self.act(self.tr('Paste'), 'edit-paste',
lambda: self.currentTab.editBox.paste(), shct=QKeySequence.Paste)
self.actionPasteImage = self.act(self.tr('Paste image'), 'edit-paste',
lambda: self.currentTab.editBox.pasteImage(), shct=Qt.CTRL+Qt.SHIFT+Qt.Key_V)
self.actionMoveUp = self.act(self.tr('Move line up'), 'go-up',
lambda: self.currentTab.editBox.moveLineUp(), shct=Qt.ALT+Qt.Key_Up)
self.actionMoveDown = self.act(self.tr('Move line down'), 'go-down',
lambda: self.currentTab.editBox.moveLineDown(), shct=Qt.ALT+Qt.Key_Down)
self.actionUndo.setEnabled(False)
self.actionRedo.setEnabled(False)
self.actionCopy.setEnabled(False)
self.actionCut.setEnabled(False)
qApp = QApplication.instance()
qApp.clipboard().dataChanged.connect(self.clipboardDataChanged)
self.clipboardDataChanged()
if enchant is not None:
self.actionEnableSC = self.act(self.tr('Enable'), trigbool=self.enableSpellCheck)
self.actionSetLocale = self.act(self.tr('Set locale'), trig=self.changeLocale)
self.actionWebKit = self.act(self.tr('Use WebKit renderer'), trigbool=self.enableWebKit)
if ReTextWebKitPreview is None:
globalSettings.useWebKit = False
self.actionWebKit.setEnabled(False)
self.actionWebKit.setChecked(globalSettings.useWebKit)
self.actionWebEngine = self.act(self.tr('Use WebEngine (Chromium) renderer'),
trigbool=self.enableWebEngine)
if ReTextWebEnginePreview is None:
globalSettings.useWebEngine = False
self.actionWebEngine.setChecked(globalSettings.useWebEngine)
self.actionShow = self.act(self.tr('Show directory'), 'system-file-manager', self.showInDir)
self.actionFind = self.act(self.tr('Next'), 'go-next', self.find,
shct=QKeySequence.FindNext)
self.actionFindPrev = self.act(self.tr('Previous'), 'go-previous',
lambda: self.find(back=True), shct=QKeySequence.FindPrevious)
self.actionReplace = self.act(self.tr('Replace'), 'edit-find-replace',
lambda: self.find(replace=True))
self.actionReplaceAll = self.act(self.tr('Replace all'), trig=self.replaceAll)
menuReplace = QMenu()
menuReplace.addAction(self.actionReplaceAll)
self.actionReplace.setMenu(menuReplace)
self.actionCloseSearch = self.act(self.tr('Close'), 'window-close',
lambda: self.searchBar.setVisible(False),
shct=QKeySequence.Cancel)
self.actionCloseSearch.setPriority(QAction.LowPriority)
self.actionHelp = self.act(self.tr('Get help online'), 'help-contents', self.openHelp)
self.aboutWindowTitle = self.tr('About ReText')
self.actionAbout = self.act(self.aboutWindowTitle, 'help-about', self.aboutDialog)
self.actionAbout.setMenuRole(QAction.AboutRole)
self.actionAboutQt = self.act(self.tr('About Qt'))
self.actionAboutQt.setMenuRole(QAction.AboutQtRole)
self.actionAboutQt.triggered.connect(qApp.aboutQt)
availableMarkups = markups.get_available_markups()
if not availableMarkups:
print('Warning: no markups are available!')
if len(availableMarkups) > 1:
self.chooseGroup = QActionGroup(self)
markupActions = []
for markup in availableMarkups:
markupAction = self.act(markup.name, trigbool=self.markupFunction(markup))
if markup.name == globalSettings.defaultMarkup:
markupAction.setChecked(True)
self.chooseGroup.addAction(markupAction)
markupActions.append(markupAction)
self.actionBold = self.act(self.tr('Bold'), shct=QKeySequence.Bold,
trig=lambda: self.insertFormatting('bold'))
self.actionItalic = self.act(self.tr('Italic'), shct=QKeySequence.Italic,
trig=lambda: self.insertFormatting('italic'))
self.actionUnderline = self.act(self.tr('Underline'), shct=QKeySequence.Underline,
trig=lambda: self.insertFormatting('underline'))
self.usefulTags = ('header', 'italic', 'bold', 'underline', 'numbering',
'bullets', 'image', 'link', 'inline code', 'code block', 'blockquote',
'table')
self.usefulChars = ('deg', 'divide', 'euro', 'hellip', 'laquo', 'larr',
'lsquo', 'mdash', 'middot', 'minus', 'nbsp', 'ndash', 'raquo',
'rarr', 'rsquo', 'times')
self.formattingBox = QComboBox(self.editBar)
self.formattingBox.addItem(self.tr('Formatting'))
self.formattingBox.addItems(self.usefulTags)
self.formattingBox.activated[str].connect(self.insertFormatting)
self.symbolBox = QComboBox(self.editBar)
self.symbolBox.addItem(self.tr('Symbols'))
self.symbolBox.addItems(self.usefulChars)
self.symbolBox.activated.connect(self.insertSymbol)
self.updateStyleSheet()
menubar = self.menuBar()
menuFile = menubar.addMenu(self.tr('File'))
menuEdit = menubar.addMenu(self.tr('Edit'))
menuHelp = menubar.addMenu(self.tr('Help'))
menuFile.addAction(self.actionNew)
menuFile.addAction(self.actionOpen)
self.menuRecentFiles = menuFile.addMenu(self.tr('Open recent'))
self.menuRecentFiles.aboutToShow.connect(self.updateRecentFiles)
menuFile.addAction(self.actionShow)
menuFile.addAction(self.actionSetEncoding)
menuFile.addAction(self.actionReload)
menuFile.addSeparator()
menuFile.addAction(self.actionSave)
menuFile.addAction(self.actionSaveAs)
menuFile.addSeparator()
menuFile.addAction(self.actionNextTab)
menuFile.addAction(self.actionPrevTab)
menuFile.addAction(self.actionCloseCurrentTab)
menuFile.addSeparator()
menuExport = menuFile.addMenu(self.tr('Export'))
menuExport.addAction(self.actionSaveHtml)
menuExport.addAction(self.actionOdf)
menuExport.addAction(self.actionPdf)
if self.extensionActions:
menuExport.addSeparator()
for action, mimetype in self.extensionActions:
menuExport.addAction(action)
menuExport.aboutToShow.connect(self.updateExtensionsVisibility)
menuFile.addAction(self.actionPrint)
menuFile.addAction(self.actionPrintPreview)
menuFile.addSeparator()
menuFile.addAction(self.actionQuit)
menuEdit.addAction(self.actionUndo)
menuEdit.addAction(self.actionRedo)
menuEdit.addSeparator()
menuEdit.addAction(self.actionCut)
menuEdit.addAction(self.actionCopy)
menuEdit.addAction(self.actionPaste)
menuEdit.addAction(self.actionPasteImage)
menuEdit.addSeparator()
menuEdit.addAction(self.actionMoveUp)
menuEdit.addAction(self.actionMoveDown)
menuEdit.addSeparator()
if enchant is not None:
menuSC = menuEdit.addMenu(self.tr('Spell check'))
menuSC.addAction(self.actionEnableSC)
menuSC.addAction(self.actionSetLocale)
menuEdit.addAction(self.actionSearch)
menuEdit.addAction(self.actionGoToLine)
menuEdit.addAction(self.actionChangeEditorFont)
menuEdit.addAction(self.actionChangePreviewFont)
menuEdit.addSeparator()
if len(availableMarkups) > 1:
self.menuMode = menuEdit.addMenu(self.tr('Default markup'))
for markupAction in markupActions:
self.menuMode.addAction(markupAction)
menuFormat = menuEdit.addMenu(self.tr('Formatting'))
menuFormat.addAction(self.actionBold)
menuFormat.addAction(self.actionItalic)
menuFormat.addAction(self.actionUnderline)
if ReTextWebKitPreview is not None or ReTextWebEnginePreview is None:
menuEdit.addAction(self.actionWebKit)
else:
menuEdit.addAction(self.actionWebEngine)
menuEdit.addSeparator()
menuEdit.addAction(self.actionViewHtml)
menuEdit.addAction(self.actionPreview)
menuEdit.addAction(self.actionInsertTable)
menuEdit.addAction(self.actionTableMode)
if ReTextFakeVimHandler:
menuEdit.addAction(self.actionFakeVimMode)
menuEdit.addSeparator()
menuEdit.addAction(self.actionFullScreen)
menuEdit.addAction(self.actionConfig)
menuHelp.addAction(self.actionHelp)
menuHelp.addSeparator()
menuHelp.addAction(self.actionAbout)
menuHelp.addAction(self.actionAboutQt)
self.toolBar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.toolBar.addAction(self.actionNew)
self.toolBar.addSeparator()
self.toolBar.addAction(self.actionOpen)
self.toolBar.addAction(self.actionSave)
self.toolBar.addAction(self.actionPrint)
self.toolBar.addSeparator()
self.toolBar.addAction(self.actionPreview)
self.toolBar.addAction(self.actionFullScreen)
self.editBar.addAction(self.actionUndo)
self.editBar.addAction(self.actionRedo)
self.editBar.addSeparator()
self.editBar.addAction(self.actionCut)
self.editBar.addAction(self.actionCopy)
self.editBar.addAction(self.actionPaste)
self.editBar.addSeparator()
self.editBar.addWidget(self.formattingBox)
self.editBar.addWidget(self.symbolBox)
self.searchEdit = QLineEdit(self.searchBar)
self.searchEdit.setPlaceholderText(self.tr('Search'))
self.searchEdit.returnPressed.connect(self.find)
self.replaceEdit = QLineEdit(self.searchBar)
self.replaceEdit.setPlaceholderText(self.tr('Replace with'))
self.replaceEdit.returnPressed.connect(self.find)
self.csBox = QCheckBox(self.tr('Case sensitively'), self.searchBar)
self.searchBar.addWidget(self.searchEdit)
self.searchBar.addWidget(self.replaceEdit)
self.searchBar.addSeparator()
self.searchBar.addWidget(self.csBox)
self.searchBar.addAction(self.actionFindPrev)
self.searchBar.addAction(self.actionFind)
self.searchBar.addAction(self.actionReplace)
self.searchBar.addAction(self.actionCloseSearch)
self.searchBar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.searchBar.setVisible(False)
self.autoSaveEnabled = globalSettings.autoSave
if self.autoSaveEnabled:
timer = QTimer(self)
timer.start(60000)
timer.timeout.connect(self.saveAll)
self.ind = None
if enchant is not None:
self.sl = globalSettings.spellCheckLocale
try:
enchant.Dict(self.sl or None)
except enchant.errors.Error as e:
warnings.warn(str(e), RuntimeWarning)
globalSettings.spellCheck = False
if globalSettings.spellCheck:
self.actionEnableSC.setChecked(True)
self.fileSystemWatcher = QFileSystemWatcher()
self.fileSystemWatcher.fileChanged.connect(self.fileChanged)
def __init__(self):
super().__init__()
#general variables
self.gender = -1
self.branch = -1
self.year = -1
self.roll = -1
self.name = ""
self.address = ""
self.mobile = -1
self.academic_year = -1
self.btnCancel = QPushButton("Cancel", self)
self.btnReset = QPushButton("Reset", self)
self.btnAdd = QPushButton("Add", self)
self.btnCancel.setFixedHeight(30)
self.btnReset.setFixedHeight(30)
self.btnAdd.setFixedHeight(30)
self.yearCombo = QComboBox(self)
self.yearCombo.addItem("1st")
self.yearCombo.addItem("2nd")
self.yearCombo.addItem("3rd")
self.yearCombo.addItem("4th")
self.genderCombo = QComboBox(self)
self.genderCombo.addItem("Male")
self.genderCombo.addItem("Female")
self.branchCombo = QComboBox(self)
self.branchCombo.addItem("Mechanical")
self.branchCombo.addItem("Civil")
self.branchCombo.addItem("Electrical")
self.branchCombo.addItem("Electronics and Communication")
self.branchCombo.addItem("Computer Science")
self.branchCombo.addItem("Information Technology")
self.rollLabel = QLabel("Roll No")
self.nameLabel = QLabel("Name")
self.addressLabel = QLabel("Address")
self.mobLabel = QLabel("Mobile")
self.yearLabel = QLabel("Current Year")
self.academicYearLabel = QLabel("Academic Year")
self.branchLabel = QLabel("Branch")
self.genderLabel = QLabel("Gender")
self.rollText = QLineEdit(self)
self.nameText = QLineEdit(self)
self.addressText = QLineEdit(self)
self.mobText = QLineEdit(self)
self.academicYearText = QLineEdit(self)
self.grid = QGridLayout(self)
self.grid.addWidget(self.rollLabel, 1, 1)
self.grid.addWidget(self.nameLabel, 2, 1)
self.grid.addWidget(self.genderLabel, 3, 1)
self.grid.addWidget(self.addressLabel, 4, 1)
self.grid.addWidget(self.mobLabel, 5, 1)
self.grid.addWidget(self.branchLabel, 6, 1)
self.grid.addWidget(self.yearLabel, 7, 1)
self.grid.addWidget(self.academicYearLabel, 8, 1)
self.grid.addWidget(self.rollText, 1, 2)
self.grid.addWidget(self.nameText, 2, 2)
self.grid.addWidget(self.genderCombo, 3, 2)
self.grid.addWidget(self.addressText, 4, 2)
self.grid.addWidget(self.mobText, 5, 2)
self.grid.addWidget(self.branchCombo, 6, 2)
self.grid.addWidget(self.yearCombo, 7, 2)
self.grid.addWidget(self.academicYearText, 8, 2)
#adding three buttons
self.grid.addWidget(self.btnReset, 9, 1)
self.grid.addWidget(self.btnCancel, 9, 3)
self.grid.addWidget(self.btnAdd, 9, 2)
#button connectors
self.btnAdd.clicked.connect(self.addStudent)
self.btnCancel.clicked.connect(QApplication.instance().quit)
self.btnReset.clicked.connect(self.reset)
self.setLayout(self.grid)
self.setWindowTitle("Add Student Details")
self.resize(500, 300)
self.show()
sys.exit(self.exec())
def _get_widgets():
"""Get a string list of all widgets."""
widgets = QApplication.instance().allWidgets()
widgets.sort(key=repr)
return [repr(w) for w in widgets]
def exception_hook(self, exctype, excvalue, tb):
"""Handle uncaught python exceptions.
It'll try very hard to write all open tabs to a file, and then exit
gracefully.
"""
exc = (exctype, excvalue, tb)
qapp = QApplication.instance()
if not self._quitter.quit_status['crash']:
log.misc.error(
"ARGH, there was an exception while the crash "
"dialog is already shown:",
exc_info=exc)
return
log.misc.error("Uncaught exception", exc_info=exc)
is_ignored_exception = (exctype is bdb.BdbQuit
or not issubclass(exctype, Exception))
if 'pdb-postmortem' in self._args.debug_flags:
pdb.post_mortem(tb)
if is_ignored_exception or 'pdb-postmortem' in self._args.debug_flags:
# pdb exit, KeyboardInterrupt, ...
status = 0 if is_ignored_exception else 2
try:
self._quitter.shutdown(status)
return
except Exception:
log.init.exception("Error while shutting down")
qapp.quit()
return
self._quitter.quit_status['crash'] = False
info = self._get_exception_info()
try:
objreg.get('ipc-server').ignored = True
except Exception:
log.destroy.exception("Error while ignoring ipc")
try:
self._app.lastWindowClosed.disconnect(
self._quitter.on_last_window_closed)
except TypeError:
log.destroy.exception("Error while preventing shutdown")
global is_crashing
is_crashing = True
self._app.closeAllWindows()
if self._args.no_err_windows:
crashdialog.dump_exception_info(exc, info.pages, info.cmd_history,
info.objects)
else:
self._crash_dialog = crashdialog.ExceptionCrashDialog(
self._args.debug, info.pages, info.cmd_history, exc,
info.objects)
ret = self._crash_dialog.exec_()
if ret == QDialog.Accepted: # restore
self._quitter.restart(info.pages)
# We might risk a segfault here, but that's better than continuing to
# run in some undefined state, so we only do the most needed shutdown
# here.
qInstallMessageHandler(None)
self.destroy_crashlogfile()
sys.exit(usertypes.Exit.exception)
def _uptime() -> datetime.timedelta:
launch_time = QApplication.instance().launch_time
time_delta = datetime.datetime.now() - launch_time
# Round off microseconds
time_delta -= datetime.timedelta(microseconds=time_delta.microseconds)
return time_delta
