def init_menu(self):
load_rom = self.create_action('載入Rom', self.load_rom)
save_rom = self.create_action('保存Rom', self.save_rom)
save_rom.setEnabled(False)
save_as = self.create_action('另存為', self.save_as)
save_as.setEnabled(False)
close_child = self.create_action('關閉窗口', self.close_child)
exit_editor = self.create_action('退出', self.close)
file_menu = self.create_menu(
'文件(&F)', None,
[load_rom, save_rom, save_as, close_child, exit_editor])
value_editors = [
self.create_action(editor_name, self.open_editor_frame)
for editor_name in CHILD_MAPPING
]
edit_menu = self.create_menu('編輯(&E)', None, value_editors)
edit_menu.setEnabled(False)
self.menuBar().addMenu(file_menu)
self.menuBar().addMenu(edit_menu)
tool_bar = QToolBar('顯示標籤')
tool_bar.setObjectName('工具')
tool_bar.addActions(value_editors)
tool_bar.setEnabled(False)
tool_bar.setMovable(False)
tool_bar.setVisible(False)
self.addToolBar(tool_bar)
action_group = QActionGroup(self)
[(action_group.addAction(i), i.setCheckable(True))
for i in value_editors]
action_group.setExclusive(True)
def create_submenu_(parent, name, items, trigger=None, check=None):
'''Create submenu based on parent widget, name, items'''
menu = QMenu(name, parent)
action_group = QActionGroup(menu)
action_group.setExclusive(True)
if trigger: action_group.triggered.connect(trigger)
for num, item in enumerate(items):
if isinstance(item, list):
action = create_submenu_(menu, '', item, trigger)[1]
menu.addMenu(action)
elif item is None:
menu.addSeparator()
continue
else:
action = QAction(item, menu, checkable=bool(check))
if num == check: action.setChecked(True)
action_group.addAction(action)
menu.addAction(action)
return menu, action_group
def debuggerMenu(self, menu):
global Settings
global Hosts
global Translations
global DebugLevels
DBG = Settings["Debug"]
if ("NOTSET" == DBG):
return False
debugMenu = menu.addMenu(Translations["Menu::Debugger"])
debugGroup = QActionGroup(debugMenu)
debugGroup.setExclusive(True)
debugGroup.triggered.connect(self.doDebugTriggered)
KEYs = DebugLevels.keys()
for D in KEYs:
MSG = Translations[f"Menu::Debug::{D}"]
dbgAction = QAction(MSG,
debugMenu,
checkable=True,
checked=(D == DBG))
dbgAction.setData(D)
debugMenu.addAction(dbgAction)
debugGroup.addAction(dbgAction)
#
self.Actions["Debugger"] = debugMenu
self.Actions["DebuggerGroup"] = debugGroup
return True
def buildActionListIdentifyTool(self):
actionList = self.iface.mapNavToolToolBar().actions()
# Add actions from QGIS attributes toolbar (handling QWidgetActions)
tmpActionList = self.iface.attributesToolBar().actions()
for action in tmpActionList:
if isinstance(action, QWidgetAction):
actionList.extend(action.defaultWidget().actions())
else:
actionList.append(action)
tmpActionList = self.iface.digitizeToolBar().actions()
for action in tmpActionList:
if isinstance(action, QWidgetAction):
actionList.extend(action.defaultWidget().actions())
else:
actionList.append(action)
tmpActionList = self.iface.selectionToolBar().actions()
for action in tmpActionList:
if isinstance(action, QWidgetAction):
actionList.extend(action.defaultWidget().actions())
else:
actionList.append(action)
# Build a group with actions from actionList and add your own action
group = QActionGroup(self.iface.mainWindow())
group.setExclusive(True)
for action in actionList:
group.addAction(action)
group.addAction(self.select_action)
def __init__(self, parent=None):
super(Camera, self).__init__(parent)
self.ui = Ui_Camera()
self.pre_id = 0
self.cur_id = 0
self.count = 0
self.checked = 0
self.audio_settime = 0
self.allow_flag = 1
self.check_list = []
self.camera = None
self.imageCapture = None
self.isCapturingImage = False
self.applicationExiting = False
self.ui.setupUi(self)
cameraDevice = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if cameraDevice.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.menuDevices.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.setCamera(cameraDevice)
# Create and load model
path_pretrained = "apis/models/facenet/20180402-114759.pb"
path_SVM = "apis/models/SVM/SVM.pkl"
self.recognizer = Recognizer()
self.recognizer.create_graph(path_pretrained, path_SVM)
def menuContextual(self, posicion):
indices = self.tabla.selectedIndexes()
if indices:
menu = QMenu()
itemsGrupo = QActionGroup(self)
itemsGrupo.setExclusive(True)
menu.addAction(QAction("Copiar todo", itemsGrupo))
columnas = [self.tabla.horizontalHeaderItem(columna).text()
for columna in range(self.tabla.columnCount())
if not self.tabla.isColumnHidden(columna)]
copiarIndividual = menu.addMenu("Copiar individual")
for indice, item in enumerate(columnas, start=0):
accion = QAction(item, itemsGrupo)
accion.setData(indice)
copiarIndividual.addAction(accion)
itemsGrupo.triggered.connect(self.copiarTableWidgetItem)
menu.exec_(self.tabla.viewport().mapToGlobal(posicion))
def menuContextualDatosFiltrados(self, posicion):
indices = self.tableWidgetVerDatosFiltrados.selectedIndexes()
if indices:
menu = QMenu()
# To make all the actions belong to a group
itemsGrupo = QActionGroup(self)
itemsGrupo.setExclusive(True)
"""
Acciones: imsis, ver horario (Hits), ver channel, Operadores
"""
actionImsis = QAction("Ver IMSIS asociados", itemsGrupo)
actionImsis.setData(VentanaFiltros.ACTION_IMSIS)
menu.addAction(actionImsis)
actionFechas = QAction("Ver fechas y hits asociados", itemsGrupo)
actionFechas.setData(VentanaFiltros.ACTION_FECHAS)
menu.addAction(actionFechas)
actionCanales = QAction("Ver canales asociados asociados", itemsGrupo)
actionCanales.setData(VentanaFiltros.ACTION_CANALES)
menu.addAction(actionCanales)
actionOps = QAction("Ver operadores asociados", itemsGrupo)
actionOps.setData(VentanaFiltros.ACTION_OPERADORES)
menu.addAction(actionOps)
itemsGrupo.triggered.connect(self.fnProcesaMenuContextual)
menu.exec(self.tableWidgetVerDatosFiltrados.viewport().mapToGlobal(posicion))
def languageMenu(self, menu):
global Settings
global Locales
global Translations
#
LANG = Settings["Language"]
#
langMenu = menu.addMenu(Translations["Menu::Language"])
langGroup = QActionGroup(langMenu)
langGroup.setExclusive(True)
langGroup.triggered.connect(self.doLanguageTriggered)
#
KEYs = Locales.keys()
for K in KEYs:
langAction = QAction(Locales[K],
langMenu,
checkable=True,
checked=(LANG == K))
langAction.setData(K)
langMenu.addAction(langAction)
langGroup.addAction(langAction)
#
self.Actions["Language"] = langMenu
self.Actions["LanguageGroup"] = langGroup
return True
def criar_menu_placas(self):
"""
Cria o menu das placas
:return:
None
"""
self.menus_personalizados = list()
titulos_menus_personalizados = list()
for pacote_alvo in self.pacotes.values():
for plataforma_alvo in pacote_alvo.get_lista_plataformas():
titulos_menus_personalizados += plataforma_alvo.get_menus(
).values()
for titulo_menu_personalizado in titulos_menus_personalizados:
menu = QMenu(titulo_menu_personalizado)
self.menus_personalizados.append(menu)
placas = QActionGroup(self.parent)
placas.setExclusive(True)
for pacote_alvo in self.pacotes.values():
for plataforma_alvo in pacote_alvo.get_lista_plataformas():
nome = plataforma_alvo.get_preferencias().get("name")
self.parent.menu_placas.addAction(QAction(nome, self))
for placa in plataforma_alvo.get_placas().values():
if not placa.get_preferencias().get('hide'):
self.parent.menu_placas.addAction(
placa.criar_acao(self))
def __init__(self, parent=None, standalone=False):
super(Camera, self).__init__(parent)
# This prevents doing unneeded initialization
# when QtDesginer loads the plugin.
if parent is None and not standalone:
return
if not multimedia_available:
return
self.ui = uic.loadUi(os.path.join(WIDGET_PATH, "camera.ui"), self)
self.camera = None
self.imageCapture = None
self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
self.videoSettings = QVideoEncoderSettings()
self.videoContainerFormat = ''
camera_device = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
if not QCamera.availableDevices():
self.ui.devicesCombo.addItem("No Device")
else:
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
self.ui.devicesCombo.addItem(description)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if camera_device.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.devicesCombo.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
self.ui.devicesCombo.currentIndexChanged.connect(
self.get_device_action)
self.ui.lockButton.hide()
# Start camera 2s after the UI has loaded
QTimer.singleShot(2000, lambda: self.setCamera(camera_device))
def add_interaction_tab(self):
# Reset
self.reset = QAction('Reset', self)
self.reset.setShortcut('Ctrl+R')
self.reset.setStatusTip('Reset')
self.reset.setEnabled(False)
self.reset.triggered.connect(self.reset_interaction)
# Pause/Resume
self.pause = QAction('Pause/Resume', self)
self.pause.setShortcut('Ctrl+P')
self.pause.setStatusTip('Pause/Resume')
self.pause.setEnabled(False)
# self.pause.triggered.connect(self.pause_interaction if not self._system._paused else self.resume_interaction)
self.pause.triggered.connect(self.pr_fun)
# if not self._system._paused:
# self.pause.triggered.connect(self.pause_interaction if not self._system._paused else self.resume_interaction)
# else:
# self.pause.triggered.connect(self.resume_interaction)
# Connect to Remote Client
crc = QAction('Connect to Remote Client', self)
crc.setStatusTip('Connect to Remote Client')
# interaction role
interact_menu = QMenu('Interaction role', self)
group = QActionGroup(interact_menu)
user = QAction('User', self, checkable=True)
system = QAction('System', self, checkable=True)
interact_menu.addAction(user)
interact_menu.addAction(system)
group.addAction(user)
group.addAction(system)
group.setExclusive(True)
# Import Dialogue From...
import_dialog = QMenu('Import Dialogue From...', self)
normal = QAction('Normal Transcript', self)
woz = QAction('Wizard-of-Oz Transcript', self)
import_dialog.addAction(normal)
import_dialog.addAction(woz)
# Save Dialogue As...
save = QAction('Save Dialogue As...', self)
# Interaction
interaction = self.menubar.addMenu('Interaction')
interaction.addAction(self.reset)
interaction.addAction(self.pause)
interaction.addAction(crc)
interaction.addMenu(interact_menu)
interaction.addMenu(import_dialog)
interaction.addAction(save)
def set_tick_choices(menu, default=20):
group = QActionGroup(menu)
group.setExclusive(True)
for tick_increment in [10, 20, 50, 100]:
action = QAction(str(tick_increment), menu)
action.setCheckable(True)
if tick_increment == default:
action.setChecked(True)
group.addAction(action)
menu.addAction(action)
def _addRelations(self):
"""Create mutually exclusive relations between toolbar buttons."""
# Get the nav toolbar actions
actions = self.iface.mapNavToolToolBar().actions()
# Build a group with actions and add GisFIRE actions
group = QActionGroup(self.iface.mainWindow())
group.setExclusive(True)
for action in actions:
group.addAction(action)
group.addAction(self.toolbarActions['ignition_point'])
def create_size_actions(self):
"""Creates window size actions."""
group = QActionGroup(self)
group.setExclusive(True)
for num, size in enumerate(sorted(self.sizes.keys()), 1):
width, height = size
action = self.sizes[size]
action.setActionGroup(group)
w, h = width, height + self.widgets_height
action.setText("%dX" % num)
action.setToolTip("%sx%s" % (width, height))
action.triggered.connect(lambda t, wi=w, he=h: self.resize(wi, he))
def create_size_actions(self):
"""Creates window size actions."""
group = QActionGroup(self)
group.setExclusive(True)
for num, size in enumerate(
sorted(self.sizes.keys()), 1):
width, height = size
action = self.sizes[size]
action.setActionGroup(group)
w, h = width, height+self.widgets_height
action.setText("%dX" % num)
action.setToolTip("%sx%s" % (width, height))
action.triggered.connect(lambda t, wi=w, he=h: self.resize(wi, he))
def create_state_slots(self):
"""Creates state slot actions."""
group = QActionGroup(self)
group.setExclusive(True)
for slot in range(10):
self.slots[slot] = QAction(self)
self.slots[slot].setCheckable(True)
self.slots[slot].setText("Slot %d" % slot)
self.slots[slot].setShortcut(QKeySequence(str(slot)))
self.slots[slot].setActionGroup(group)
self.menuStateSlot.addAction(self.slots[slot])
self.slots[0].setChecked(True)
for slot, action in self.slots.items():
action.triggered.connect(lambda t, s=slot: self.worker.state_set_slot(s))
def __init__(self, parent=None):
super(Camera, self).__init__(parent)
global API
API = AlgorithmAPIs(template_dir="templates",
threshold=0.5,
use_multiprocessing=False)
self.ui = Ui_Camera()
self.camera = None
self.imageCapture = None
# self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
self.ui.setupUi(self)
cameraDevice = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if cameraDevice.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.menuDevices.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.lcdNumber_2.display(0)
self.ui.dial.valueChanged.connect(self.dial_display)
global dial_value
dial_value = 3
self.ui.lcdNumber_2.display(dial_value)
self.setCamera(cameraDevice)
# Create and load model
path_pretrained = "apis/models/facenet/20180402-114759.pb"
path_SVM = "apis/models/SVM/SVM.pkl"
self.recognizer = Recognizer()
self.recognizer.create_graph(path_pretrained, path_SVM)
def create_state_slots(self):
"""Creates state slot actions."""
group = QActionGroup(self)
group.setExclusive(True)
for slot in range(10):
self.slots[slot] = QAction(self)
self.slots[slot].setCheckable(True)
self.slots[slot].setText("Slot %d" % slot)
self.slots[slot].setShortcut(QKeySequence(str(slot)))
self.slots[slot].setActionGroup(group)
self.menuStateSlot.addAction(self.slots[slot])
self.slots[0].setChecked(True)
for slot, action in self.slots.items():
action.triggered.connect(lambda t, s=slot: self.worker.state_set_slot(s))
def createActionGroup(parent, name=None, exclusive=False):
"""
Module function to create an action group.
@param parent parent object of the action group (QObject)
@param name name of the action group object (string)
@param exclusive flag indicating an exclusive action group (boolean)
@return reference to the created action group (QActionGroup)
"""
actGrp = QActionGroup(parent)
if name:
actGrp.setObjectName(name)
actGrp.setExclusive(exclusive)
return actGrp
def createActionGroup(parent, name=None, exclusive=False):
"""
Module function to create an action group.
@param parent parent object of the action group (QObject)
@param name name of the action group object (string)
@param exclusive flag indicating an exclusive action group (boolean)
@return reference to the created action group (QActionGroup)
"""
actGrp = QActionGroup(parent)
if name:
actGrp.setObjectName(name)
actGrp.setExclusive(exclusive)
return actGrp
def create_view_buttons(self):
self.tb_views.addWidget(QLabel("View mode: "))
ag_views = QActionGroup(self)
ag_views.setExclusive(True)
for v in self.views.keys():
a = QAction(v)
a.triggered.connect(self.change_view)
a.setCheckable(True)
ag_views.addAction(a)
self.tb_views.addActions(ag_views.actions())
ag_views.actions()[0].setChecked(True)
stretch = QWidget()
stretch.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum))
self.tb_views.addWidget(stretch)
def __init__(self, win):
super(PathToolManager, self).__init__()
self.window = win
self._active_tool = None
self._active_part = None
self.select_tool = SelectTool(self)
self.pencil_tool = PencilTool(self)
self.break_tool = BreakTool(self)
self.erase_tool = EraseTool(self)
self.insertion_tool = InsertionTool(self)
self.skip_tool = SkipTool(self)
self.paint_tool = PaintTool(
self) # (self, win.path_graphics_view.toolbar)
self.add_seq_tool = AddSeqTool(self)
self.mods_tool = ModsTool(self)
def installTool(tool_name, window):
l_tool_name = tool_name.lower()
tool_widget = getattr(window, 'action_path_' + l_tool_name)
tool = getattr(self, l_tool_name + '_tool')
tool.action_name = 'action_path_' + tool_name
def clickHandler(self):
tool_widget.setChecked(True)
self.setActiveTool(tool)
if hasattr(tool, 'widgetClicked'):
tool.widgetClicked()
# end def
select_tool_method_name = 'choose' + tool_name + 'Tool'
setattr(self.__class__, select_tool_method_name, clickHandler)
handler = getattr(self, select_tool_method_name)
tool_widget.triggered.connect(handler)
return tool_widget
# end def
tools = ('Select', 'Pencil', 'Break', 'Erase', 'Insertion', 'Skip',
'Paint', 'Add_Seq', 'Mods')
ag = QActionGroup(win)
# Call installTool on every tool
list(
map((lambda tool_name: ag.addAction(installTool(tool_name, win))),
tools))
ag.setExclusive(True)
# Select the preferred Startup tool
startup_tool_name = app().prefs.getStartupToolName()
getattr(self, 'choose' + startup_tool_name + 'Tool')()
def __init__(self, parent=None):
super().__init__(parent) #调用父类构造函数，创建窗体
self.ui=Ui_MainWindow() #创建UI对象
self.ui.setupUi(self) #构造UI界面
text=self._tr("QmyMainWindow","文件名: ")
self.ui.statusBar.showMessage(text)
actionGroup= QActionGroup(self)
actionGroup.addAction(self.ui.actLang_CN)
actionGroup.addAction(self.ui.actLang_EN)
actionGroup.setExclusive(True)
self.__translator=None #QTranslator对象
self.setCentralWidget(self.ui.textEdit)
def initUI(self):
# ========================= MENÚ ===========================
menu = self.menuBar()
archivoMenu = menu.addMenu("&Archivo")
self.accionIniciarCamara = archivoMenu.addAction(
self.style().standardIcon(QStyle.SP_MediaPlay),
"Iniciar la camara", self.iniciarCamara)
self.accionDetenerCamara = archivoMenu.addAction(
self.style().standardIcon(QStyle.SP_MediaStop),
"Detener la camara", self.detenerCamara)
archivoMenu.addAction(
self.style().standardIcon(QStyle.SP_MessageBoxCritical), " Salir",
self.close)
dispositivosMenu = menu.addMenu("&Dispositivos")
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
dispositivoCamara = QByteArray()
for nombreDispositivo in QCamera.availableDevices():
descripcion = QCamera.deviceDescription(nombreDispositivo)
videoDeviceAction = QAction(descripcion, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(nombreDispositivo)
if dispositivoCamara.isEmpty():
dispositivoCamara = nombreDispositivo
videoDeviceAction.setChecked(True)
dispositivosMenu.addAction(videoDeviceAction)
# Instancia del Widget central
self.widgets = Widgets(dispositivoCamara, self)
# Llamar función cuando se activa una Acción del Menú
videoDevicesGroup.triggered.connect(
self.widgets.actualizarDispositivoCamara)
# Establecer el Widget central de la ventana
self.setCentralWidget(self.widgets)
def on_main_window_start(main_window):
main_window.theme_menu = main_window.menuBar().addMenu(
main_window.tr('Themes'))
themes_directory = QFileInfo('themes')
if themes_directory.exists():
active_theme = ThemeManager.get_active_theme()
path = themes_directory.absoluteFilePath()
group_action = QActionGroup(main_window)
group_action.setExclusive(True)
for theme in os.listdir(path):
action = QAction(theme, main_window)
action.setData(theme)
action.setCheckable(True)
if theme == active_theme:
action.setChecked(True)
action.changed.connect(ThemeManager.wrapper(main_window))
group_action.addAction(action)
group_action.addAction(action)
main_window.theme_menu.addAction(action)
def create_submenu(self, parent, name, items, check=None, get_menu=False):
if name is None: menu = parent
else: menu = QMenu(name, parent)
action_group = QActionGroup(menu)
for num, item in enumerate(items):
action = QAction(item, menu, checkable=True)
if num == check: action.setChecked(True)
action_group.triggered.connect(self.parent().select_records)
action_group.addAction(action)
menu.addAction(action)
else:
if name is not None: parent.addMenu(menu)
action_group.setExclusive(True)
if get_menu: return action_group, menu
return action_group
def criar_menu_portas(self):
"""
Cria o menu das portas
:return:
None
"""
for acao in self.parent.menu_portas.actions():
self.parent.menu_portas.removeAction(acao)
portas = QActionGroup(self.parent)
portas.setExclusive(True)
n_portas = len(self.serial_ports())
if n_portas > 0:
for porta in self.serial_ports():
porta_acao = Porta.criar_acao(porta, self)
self.parent.menu_portas.addAction(porta_acao)
if n_portas == 1:
Preferencias.set('serial.port', porta)
else:
self.parent.menu_portas.addAction(QAction("Não há portas disponíveis", self))
def on_main_window_start(main_window):
main_window.theme_menu = main_window.menuBar().addMenu(
main_window.tr('Themes'))
themes_directory = QFileInfo('themes')
if themes_directory.exists():
active_theme = ThemeManager.get_active_theme()
path = themes_directory.absoluteFilePath()
group_action = QActionGroup(main_window)
group_action.setExclusive(True)
for theme in os.listdir(path):
action = QAction(theme, main_window)
action.setData(theme)
action.setCheckable(True)
if theme == active_theme:
action.setChecked(True)
action.changed.connect(ThemeManager.wrapper(main_window))
group_action.addAction(action)
group_action.addAction(action)
main_window.theme_menu.addAction(action)
def build_toolbars(self):
main_toolbar = Toolbar(orientation=Qt.Horizontal, iconsize=32, label_position=Qt.ToolButtonIconOnly)
main_toolbar.setObjectName("main_toolbar")
self.addToolBar(main_toolbar)
main_toolbar.addAction(QIcon("./GUI/icons/connections.png"), "Configure MQTT broker", self.setup_broker)
agBroker = QActionGroup(self)
agBroker.setExclusive(True)
self.actConnect = CheckableAction(QIcon("./GUI/icons/connect.png"), "Connect to the broker", agBroker)
self.actDisconnect = CheckableAction(QIcon("./GUI/icons/disconnect.png"), "Disconnect from broker", agBroker)
self.actDisconnect.setChecked(True)
self.actConnect.triggered.connect(self.mqtt_connect)
self.actDisconnect.triggered.connect(self.mqtt_disconnect)
main_toolbar.addActions(agBroker.actions())
main_toolbar.addSeparator()
def __init__(self, arg):
super(Camera, self).__init__(parent)
# self.arg = arg
# Attributes variables
self.ui = Ui_Camera()
self.camera = None
self.imageCapture = None
self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
self.videoSettings = QVideoEncoderSettings()
self.videoContainerFormat = ''
self.ui.setupUi(self)
#get device camera
cameraDevice = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
# Get informations about available cameras
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if cameraDevice.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.menuDevices.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
self.ui.lockButton.hide()
self.setCamera(cameraDevice)
def __init__(self, parent=None):
super(Camera, self).__init__(parent)
self.ui = Ui_Camera()
self.camera = None
self.imageCapture = None
self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
self.videoSettings = QVideoEncoderSettings()
self.videoContainerFormat = ''
self.ui.setupUi(self)
cameraDevice = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
#for multiple cameras ata
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if cameraDevice.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.menuDevices.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
self.ui.lockButton.hide()
self.setCamera(cameraDevice)
def __init__(self, win):
super(PathToolManager, self).__init__()
self.window = win
self._active_tool = None
self._active_part = None
self.select_tool = SelectTool(self)
self.pencil_tool = PencilTool(self)
self.break_tool = BreakTool(self)
self.erase_tool = EraseTool(self)
self.insertion_tool = InsertionTool(self)
self.skip_tool = SkipTool(self)
self.paint_tool = PaintTool(self) # (self, win.path_graphics_view.toolbar)
self.add_seq_tool = AddSeqTool(self)
self.mods_tool = ModsTool(self)
def installTool(tool_name, window):
l_tool_name = tool_name.lower()
tool_widget = getattr(window, 'action_path_' + l_tool_name)
tool = getattr(self, l_tool_name + '_tool')
tool.action_name = 'action_path_' + tool_name
def clickHandler(self):
tool_widget.setChecked(True)
self.setActiveTool(tool)
if hasattr(tool, 'widgetClicked'):
tool.widgetClicked()
# end def
select_tool_method_name = 'choose' + tool_name + 'Tool'
setattr(self.__class__, select_tool_method_name, clickHandler)
handler = getattr(self, select_tool_method_name)
tool_widget.triggered.connect(handler)
return tool_widget
# end def
tools = ('Select', 'Pencil', 'Break', 'Erase', 'Insertion', 'Skip', 'Paint', 'Add_Seq', 'Mods')
ag = QActionGroup(win)
# Call installTool on every tool
list(map((lambda tool_name: ag.addAction(installTool(tool_name, win))), tools))
ag.setExclusive(True)
# Select the preferred Startup tool
startup_tool_name = app().prefs.getStartupToolName()
getattr(self, 'choose' + startup_tool_name + 'Tool')()
def menu_view(menu_bar):
view_menu = menu_bar.addMenu('View')
view_radio_group = QActionGroup(menu_bar)
view_radio_group.setExclusive(True)
view_now_playing = view_radio_group.addAction('Now Playing')
view_now_playing.setCheckable(True)
view_now_playing.setChecked(True)
view_menu.addAction(view_now_playing)
view_animelist = view_radio_group.addAction('Anime List')
view_animelist.setCheckable(True)
view_menu.addAction(view_animelist)
view_history = view_radio_group.addAction('History')
view_history.setCheckable(True)
view_menu.addAction(view_history)
view_statistics = view_radio_group.addAction('Statistics')
view_statistics.setCheckable(True)
view_menu.addAction(view_statistics)
view_search = view_radio_group.addAction('Search')
view_search.setCheckable(True)
view_menu.addAction(view_search)
view_seasons = view_radio_group.addAction('Seasons')
view_seasons.setCheckable(True)
view_menu.addAction(view_seasons)
view_torrents = view_radio_group.addAction('Torrents')
view_torrents.setCheckable(True)
view_menu.addAction(view_torrents)
view_menu.addSeparator()
view_sidebar = QAction('Show sidebar', menu_bar)
view_sidebar.setCheckable(True)
view_sidebar.setChecked(True)
view_menu.addAction(view_sidebar)
def __buildUI(self): ##窗体上动态添加组件
# 创建状态栏上的组件
self.__LabFile = QLabel(self) # QLabel组件显示信息
self.__LabFile.setMinimumWidth(150)
self.__LabFile.setText("文件名： ")
self.ui.statusBar.addWidget(self.__LabFile)
self.__progressBar1 = QProgressBar(self) # progressBar1
self.__progressBar1.setMaximumWidth(200)
self.__progressBar1.setMinimum(5)
self.__progressBar1.setMaximum(50)
sz = self.ui.textEdit.font().pointSize() #字体大小
self.__progressBar1.setValue(sz)
self.ui.statusBar.addWidget(self.__progressBar1)
self.__LabInfo = QLabel(self) # QLabel组件显示字体名称
self.__LabInfo.setText("选择字体名称： ")
self.ui.statusBar.addPermanentWidget(self.__LabInfo)
#为actLang_CN和actLang_EN创建QActionGroup，互斥型选择
actionGroup = QActionGroup(self)
actionGroup.addAction(self.ui.actLang_CN)
actionGroup.addAction(self.ui.actLang_EN)
actionGroup.setExclusive(True) #互斥型分组
self.ui.actLang_CN.setChecked(True)
#创建工具栏上的组件
self.__spinFontSize = QSpinBox(self) #字体大小spinbox
self.__spinFontSize.setMinimum(5)
self.__spinFontSize.setMaximum(50)
sz = self.ui.textEdit.font().pointSize()
self.__spinFontSize.setValue(sz)
self.__spinFontSize.setMinimumWidth(50)
self.ui.mainToolBar.addWidget(self.__spinFontSize) #SpinBox添加到工具栏
self.__comboFontName = QFontComboBox(self) #字体 combobox
self.__comboFontName.setMinimumWidth(100)
self.ui.mainToolBar.addWidget(self.__comboFontName)
self.ui.mainToolBar.addSeparator() #添加一个分隔条
self.ui.mainToolBar.addAction(self.ui.actClose) #添加 actClose作为“关闭”按钮
def create_submenu(parent, name, items, trigger, check=None, get_menu=False):
'''Create submenu based on parent widget, name, items'''
if name is None: menu = parent
else: menu = QMenu(name, parent)
action_group = QActionGroup(menu)
for num, item in enumerate(items):
action = QAction(item, menu, checkable=True)
if num == check: action.setChecked(True)
action_group.triggered.connect(trigger)
action_group.addAction(action)
menu.addAction(action)
else:
if name is not None: parent.addMenu(menu)
action_group.setExclusive(True)
if get_menu: return action_group, menu
return action_group
def __init__(self):
super().__init__()
self.setupUi()
cameraDevice = ''
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if not cameraDevice:
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
print(7)
self.setCamera(cameraDevice)
print(8)
self.show()
class MainWindow(QMainWindow, Ui_MainWindow):
"""docstring for MainWindow."""
def __init__(self, parent=None):
super(MainWindow, self).__init__()
self._csvFilePath = ""
self.serialport = serial.Serial()
self.receiver_thread = readerThread(self)
self.receiver_thread.setPort(self.serialport)
self._localEcho = None
self._viewMode = None
self._quickSendOptRow = 1
self.setupUi(self)
self.setCorner(Qt.TopLeftCorner, Qt.LeftDockWidgetArea)
self.setCorner(Qt.BottomLeftCorner, Qt.LeftDockWidgetArea)
font = QtGui.QFont()
font.setFamily(EDITOR_FONT)
font.setPointSize(9)
self.txtEdtOutput.setFont(font)
self.txtEdtInput.setFont(font)
#self.quickSendTable.setFont(font)
if UI_FONT is not None:
font = QtGui.QFont()
font.setFamily(UI_FONT)
font.setPointSize(9)
self.dockWidget_PortConfig.setFont(font)
self.dockWidget_SendHex.setFont(font)
self.dockWidget_QuickSend.setFont(font)
self.setupMenu()
self.setupFlatUi()
self.onEnumPorts()
icon = QtGui.QIcon(":/MyTerm.ico")
self.setWindowIcon(icon)
self.actionAbout.setIcon(icon)
self.defaultStyleWidget = QWidget()
self.defaultStyleWidget.setWindowIcon(icon)
icon = QtGui.QIcon(":/qt_logo_16.ico")
self.actionAbout_Qt.setIcon(icon)
self._viewGroup = QActionGroup(self)
self._viewGroup.addAction(self.actionAscii)
self._viewGroup.addAction(self.actionHex_lowercase)
self._viewGroup.addAction(self.actionHEX_UPPERCASE)
self._viewGroup.setExclusive(True)
# bind events
self.actionOpen_Cmd_File.triggered.connect(self.openQuickSend)
self.actionSave_Log.triggered.connect(self.onSaveLog)
self.actionExit.triggered.connect(self.onExit)
self.actionOpen.triggered.connect(self.openPort)
self.actionClose.triggered.connect(self.closePort)
self.actionPort_Config_Panel.triggered.connect(self.onTogglePrtCfgPnl)
self.actionQuick_Send_Panel.triggered.connect(self.onToggleQckSndPnl)
self.actionSend_Hex_Panel.triggered.connect(self.onToggleHexPnl)
self.dockWidget_PortConfig.visibilityChanged.connect(self.onVisiblePrtCfgPnl)
self.dockWidget_QuickSend.visibilityChanged.connect(self.onVisibleQckSndPnl)
self.dockWidget_SendHex.visibilityChanged.connect(self.onVisibleHexPnl)
self.actionLocal_Echo.triggered.connect(self.onLocalEcho)
self.actionAlways_On_Top.triggered.connect(self.onAlwaysOnTop)
self.actionAscii.triggered.connect(self.onViewChanged)
self.actionHex_lowercase.triggered.connect(self.onViewChanged)
self.actionHEX_UPPERCASE.triggered.connect(self.onViewChanged)
self.actionAbout.triggered.connect(self.onAbout)
self.actionAbout_Qt.triggered.connect(self.onAboutQt)
self.btnOpen.clicked.connect(self.onOpen)
self.btnClear.clicked.connect(self.onClear)
self.btnSaveLog.clicked.connect(self.onSaveLog)
self.btnEnumPorts.clicked.connect(self.onEnumPorts)
self.btnSendHex.clicked.connect(self.onSend)
self.receiver_thread.read.connect(self.onReceive)
self.receiver_thread.exception.connect(self.onReaderExcept)
self._signalMapQuickSendOpt = QSignalMapper(self)
self._signalMapQuickSendOpt.mapped[int].connect(self.onQuickSendOptions)
self._signalMapQuickSend = QSignalMapper(self)
self._signalMapQuickSend.mapped[int].connect(self.onQuickSend)
# initial action
self.actionHEX_UPPERCASE.setChecked(True)
self.receiver_thread.setViewMode(VIEWMODE_HEX_UPPERCASE)
self.initQuickSend()
self.restoreLayout()
self.moveScreenCenter()
self.syncMenu()
if self.isMaximized():
self.setMaximizeButton("restore")
else:
self.setMaximizeButton("maximize")
self.loadSettings()
def setupMenu(self):
self.menuMenu = QtWidgets.QMenu()
self.menuMenu.setTitle("&File")
self.menuMenu.setObjectName("menuMenu")
self.menuView = QtWidgets.QMenu(self.menuMenu)
self.menuView.setTitle("&View")
self.menuView.setObjectName("menuView")
self.menuView.addAction(self.actionAscii)
self.menuView.addAction(self.actionHex_lowercase)
self.menuView.addAction(self.actionHEX_UPPERCASE)
self.menuMenu.addAction(self.actionOpen_Cmd_File)
self.menuMenu.addAction(self.actionSave_Log)
self.menuMenu.addSeparator()
self.menuMenu.addAction(self.actionPort_Config_Panel)
self.menuMenu.addAction(self.actionQuick_Send_Panel)
self.menuMenu.addAction(self.actionSend_Hex_Panel)
self.menuMenu.addAction(self.menuView.menuAction())
self.menuMenu.addAction(self.actionLocal_Echo)
self.menuMenu.addAction(self.actionAlways_On_Top)
self.menuMenu.addSeparator()
self.menuMenu.addAction(self.actionAbout)
self.menuMenu.addAction(self.actionAbout_Qt)
self.menuMenu.addSeparator()
self.menuMenu.addAction(self.actionExit)
self.sendOptMenu = QtWidgets.QMenu()
self.actionSend_Hex = QtWidgets.QAction(self)
self.actionSend_Hex.setText("Send &Hex")
self.actionSend_Hex.setStatusTip("Send Hex (e.g. 31 32 FF)")
self.actionSend_Asc = QtWidgets.QAction(self)
self.actionSend_Asc.setText("Send &Asc")
self.actionSend_Asc.setStatusTip("Send Asc (e.g. abc123)")
self.actionSend_TFH = QtWidgets.QAction(self)
self.actionSend_TFH.setText("Send &Text file as hex")
self.actionSend_TFH.setStatusTip('Send text file as hex (e.g. strings "31 32 FF" in the file)')
self.actionSend_TFA = QtWidgets.QAction(self)
self.actionSend_TFA.setText("Send t&Ext file as asc")
self.actionSend_TFA.setStatusTip('Send text file as asc (e.g. strings "abc123" in the file)')
self.actionSend_FB = QtWidgets.QAction(self)
self.actionSend_FB.setText("Send &Bin/Hex file")
self.actionSend_FB.setStatusTip("Send a bin file or a hex file")
self.sendOptMenu.addAction(self.actionSend_Hex)
self.sendOptMenu.addAction(self.actionSend_Asc)
self.sendOptMenu.addAction(self.actionSend_TFH)
self.sendOptMenu.addAction(self.actionSend_TFA)
self.sendOptMenu.addAction(self.actionSend_FB)
self.actionSend_Hex.triggered.connect(self.onSetSendHex)
self.actionSend_Asc.triggered.connect(self.onSetSendAsc)
self.actionSend_TFH.triggered.connect(self.onSetSendTFH)
self.actionSend_TFA.triggered.connect(self.onSetSendTFA)
self.actionSend_FB.triggered.connect(self.onSetSendFB)
def setupFlatUi(self):
self._dragPos = self.pos()
self._isDragging = False
self.setMouseTracking(True)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setStyleSheet("""
QWidget {
background-color: %(BackgroundColor)s;
/*background-image: url(:/background.png);*/
outline: none;
}
QLabel {
color:%(TextColor)s;
font-size:12px;
/*font-family:Century;*/
}
QComboBox {
color:%(TextColor)s;
font-size:12px;
/*font-family:Century;*/
}
QComboBox {
border: none;
padding: 1px 1px 1px 3px;
}
QComboBox:editable {
background: white;
}
QComboBox:!editable, QComboBox::drop-down:editable {
background: #62c7e0;
}
QComboBox:!editable:hover, QComboBox::drop-down:editable:hover {
background: #c7eaf3;
}
QComboBox:!editable:pressed, QComboBox::drop-down:editable:pressed {
background: #35b6d7;
}
QComboBox:on {
padding-top: 3px;
padding-left: 4px;
}
QComboBox::drop-down {
subcontrol-origin: padding;
subcontrol-position: top right;
width: 16px;
border: none;
}
QComboBox::down-arrow {
image: url(:/downarrow.png);
}
QComboBox::down-arrow:on {
image: url(:/uparrow.png);
}
QGroupBox {
color:%(TextColor)s;
font-size:12px;
/*font-family:Century;*/
border: 1px solid gray;
margin-top: 15px;
}
QGroupBox::title {
subcontrol-origin: margin;
subcontrol-position: top left;
left:5px;
top:3px;
}
QCheckBox {
color:%(TextColor)s;
spacing: 5px;
font-size:12px;
/*font-family:Century;*/
}
QCheckBox::indicator:unchecked {
image: url(:/checkbox_unchecked.png);
}
QCheckBox::indicator:unchecked:hover {
image: url(:/checkbox_unchecked_hover.png);
}
QCheckBox::indicator:unchecked:pressed {
image: url(:/checkbox_unchecked_pressed.png);
}
QCheckBox::indicator:checked {
image: url(:/checkbox_checked.png);
}
QCheckBox::indicator:checked:hover {
image: url(:/checkbox_checked_hover.png);
}
QCheckBox::indicator:checked:pressed {
image: url(:/checkbox_checked_pressed.png);
}
QScrollBar:horizontal {
background-color:%(BackgroundColor)s;
border: none;
height: 15px;
margin: 0px 20px 0 20px;
}
QScrollBar::handle:horizontal {
background: %(ScrollBar_Handle)s;
min-width: 20px;
}
QScrollBar::add-line:horizontal {
image: url(:/rightarrow.png);
border: none;
background: %(ScrollBar_Line)s;
width: 20px;
subcontrol-position: right;
subcontrol-origin: margin;
}
QScrollBar::sub-line:horizontal {
image: url(:/leftarrow.png);
border: none;
background: %(ScrollBar_Line)s;
width: 20px;
subcontrol-position: left;
subcontrol-origin: margin;
}
QScrollBar:vertical {
background-color:%(BackgroundColor)s;
border: none;
width: 15px;
margin: 20px 0px 20px 0px;
}
QScrollBar::handle::vertical {
background: %(ScrollBar_Handle)s;
min-height: 20px;
}
QScrollBar::add-line::vertical {
image: url(:/downarrow.png);
border: none;
background: %(ScrollBar_Line)s;
height: 20px;
subcontrol-position: bottom;
subcontrol-origin: margin;
}
QScrollBar::sub-line::vertical {
image: url(:/uparrow.png);
border: none;
background: %(ScrollBar_Line)s;
height: 20px;
subcontrol-position: top;
subcontrol-origin: margin;
}
QTableView {
background-color: white;
/*selection-background-color: #FF92BB;*/
border: 1px solid %(TableView_Border)s;
color: %(TextColor)s;
}
QTableView::focus {
/*border: 1px solid #2a7fff;*/
}
QTableView QTableCornerButton::section {
border: none;
border-right: 1px solid %(TableView_Border)s;
border-bottom: 1px solid %(TableView_Border)s;
background-color: %(TableView_Corner)s;
}
QTableView QWidget {
background-color: white;
}
QTableView::item:focus {
border: 1px red;
background-color: transparent;
color: %(TextColor)s;
}
QHeaderView::section {
border: none;
border-right: 1px solid %(TableView_Border)s;
border-bottom: 1px solid %(TableView_Border)s;
padding-left: 2px;
padding-right: 2px;
color: #444444;
background-color: %(TableView_Header)s;
}
QTextEdit {
background-color:white;
color:%(TextColor)s;
border-top: none;
border-bottom: none;
border-left: 2px solid %(BackgroundColor)s;
border-right: 2px solid %(BackgroundColor)s;
}
QTextEdit::focus {
}
QToolButton, QPushButton {
background-color:#30a7b8;
border:none;
color:#ffffff;
font-size:12px;
/*font-family:Century;*/
}
QToolButton:hover, QPushButton:hover {
background-color:#51c0d1;
}
QToolButton:pressed, QPushButton:pressed {
background-color:#3a9ecc;
}
QMenuBar {
color: %(TextColor)s;
height: 24px;
}
QMenuBar::item {
background-color: transparent;
margin: 8px 0px 0px 0px;
padding: 1px 8px 1px 8px;
height: 15px;
}
QMenuBar::item:selected {
background: #51c0d1;
}
QMenuBar::item:pressed {
}
/*
QMenu {
color: %(TextColor)s;
background: #ffffff;
}
QMenu {
margin: 2px;
}
QMenu::item {
padding: 2px 25px 2px 21px;
border: 1px solid transparent;
}
QMenu::item:selected {
background: #51c0d1;
}
QMenu::icon {
background: transparent;
border: 2px inset transparent;
}*/
QDockWidget {
font-size:12px;
/*font-family:Century;*/
color: %(TextColor)s;
titlebar-close-icon: none;
titlebar-normal-icon: none;
}
QDockWidget::title {
margin: 0;
padding: 2px;
subcontrol-origin: content;
subcontrol-position: right top;
text-align: left;
background: #67baed;
}
QDockWidget::float-button {
max-width: 12px;
max-height: 12px;
background-color:transparent;
border:none;
image: url(:/restore_inactive.png);
}
QDockWidget::float-button:hover {
background-color:#227582;
image: url(:/restore_active.png);
}
QDockWidget::float-button:pressed {
padding: 0;
background-color:#14464e;
image: url(:/restore_active.png);
}
QDockWidget::close-button {
max-width: 12px;
max-height: 12px;
background-color:transparent;
border:none;
image: url(:/close_inactive.png);
}
QDockWidget::close-button:hover {
background-color:#ea5e00;
image: url(:/close_active.png);
}
QDockWidget::close-button:pressed {
background-color:#994005;
image: url(:/close_active.png);
padding: 0;
}
""" % dict(
BackgroundColor = '#99d9ea',
TextColor = '#202020',
ScrollBar_Handle = '#61b9e1',
ScrollBar_Line = '#7ecfe4',
TableView_Corner = '#8ae6d2',
TableView_Header = '#8ae6d2',
TableView_Border = '#eeeeee'
))
self.dockWidgetContents.setStyleSheet("""
QPushButton {
min-height:23px;
}
""")
self.dockWidget_QuickSend.setStyleSheet("""
QToolButton, QPushButton {
background-color:#27b798;
/*font-family:Consolas;*/
/*font-size:12px;*/
/*min-width:46px;*/
}
QToolButton:hover, QPushButton:hover {
background-color:#3bd5b4;
}
QToolButton:pressed, QPushButton:pressed {
background-color:#1d8770;
}
""")
self.dockWidgetContents_2.setStyleSheet("""
QPushButton {
min-height:23px;
min-width:50px;
}
""")
w = self.frameGeometry().width()
self._minBtn = QPushButton(self)
self._minBtn.setGeometry(w-103,0,28,24)
self._minBtn.clicked.connect(self.onMinimize)
self._minBtn.setStyleSheet("""
QPushButton {
background-color:transparent;
border:none;
outline: none;
image: url(:/minimize_inactive.png);
}
QPushButton:hover {
background-color:#227582;
image: url(:/minimize_active.png);
}
QPushButton:pressed {
background-color:#14464e;
image: url(:/minimize_active.png);
}
""")
self._maxBtn = QPushButton(self)
self._maxBtn.setGeometry(w-74,0,28,24)
self._maxBtn.clicked.connect(self.onMaximize)
self.setMaximizeButton("maximize")
self._closeBtn = QPushButton(self)
self._closeBtn.setGeometry(w-45,0,36,24)
self._closeBtn.clicked.connect(self.onExit)
self._closeBtn.setStyleSheet("""
QPushButton {
background-color:transparent;
border:none;
outline: none;
image: url(:/close_inactive.png);
}
QPushButton:hover {
background-color:#ea5e00;
image: url(:/close_active.png);
}
QPushButton:pressed {
background-color:#994005;
image: url(:/close_active.png);
}
""")
self.btnMenu = QtWidgets.QToolButton(self)
self.btnMenu.setEnabled(True)
self.btnMenu.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
self.btnMenu.setIcon(QtGui.QIcon(':/MyTerm.ico'))
self.btnMenu.setText('Myterm ')
self.btnMenu.setGeometry(3,3,80,18)
self.btnMenu.setMenu(self.menuMenu)
self.btnMenu.setPopupMode(QtWidgets.QToolButton.InstantPopup)
self.btnRefresh = QtWidgets.QToolButton(self)
self.btnRefresh.setEnabled(True)
self.btnRefresh.setIcon(QtGui.QIcon(':/refresh.ico'))
self.btnRefresh.setGeometry(110,3,18,18)
self.btnRefresh.clicked.connect(self.onEnumPorts)
self.verticalLayout_1.removeWidget(self.cmbPort)
self.cmbPort.setParent(self)
self.cmbPort.setGeometry(128,3,60,18)
self.verticalLayout_1.removeWidget(self.btnOpen)
self.btnOpen.setParent(self)
self.btnOpen.setGeometry(210,3,60,18)
def resizeEvent(self, event):
w = event.size().width()
self._minBtn.move(w-103,0)
self._maxBtn.move(w-74,0)
self._closeBtn.move(w-45,0)
def onMinimize(self):
self.showMinimized()
def isMaximized(self):
return ((self.windowState() == Qt.WindowMaximized))
def onMaximize(self):
if self.isMaximized():
self.showNormal()
self.setMaximizeButton("maximize")
else:
self.showMaximized()
self.setMaximizeButton("restore")
def setMaximizeButton(self, style):
if "maximize" == style:
self._maxBtn.setStyleSheet("""
QPushButton {
background-color:transparent;
border:none;
outline: none;
image: url(:/maximize_inactive.png);
}
QPushButton:hover {
background-color:#227582;
image: url(:/maximize_active.png);
}
QPushButton:pressed {
background-color:#14464e;
image: url(:/maximize_active.png);
}
""")
elif "restore" == style:
self._maxBtn.setStyleSheet("""
QPushButton {
background-color:transparent;
border:none;
outline: none;
image: url(:/restore_inactive.png);
}
QPushButton:hover {
background-color:#227582;
image: url(:/restore_active.png);
}
QPushButton:pressed {
background-color:#14464e;
image: url(:/restore_active.png);
}
""")
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self._isDragging = True
self._dragPos = event.globalPos() - self.pos()
event.accept()
def mouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton and self._isDragging and not self.isMaximized():
self.move(event.globalPos() - self._dragPos)
event.accept()
def mouseReleaseEvent(self, event):
self._isDragging = False
event.accept()
def saveSettings(self):
root = ET.Element("MyTerm")
GUISettings = ET.SubElement(root, "GUISettings")
PortCfg = ET.SubElement(GUISettings, "PortConfig")
ET.SubElement(PortCfg, "port").text = self.cmbPort.currentText()
ET.SubElement(PortCfg, "baudrate").text = self.cmbBaudRate.currentText()
ET.SubElement(PortCfg, "databits").text = self.cmbDataBits.currentText()
ET.SubElement(PortCfg, "parity").text = self.cmbParity.currentText()
ET.SubElement(PortCfg, "stopbits").text = self.cmbStopBits.currentText()
ET.SubElement(PortCfg, "rtscts").text = self.chkRTSCTS.isChecked() and "on" or "off"
ET.SubElement(PortCfg, "xonxoff").text = self.chkXonXoff.isChecked() and "on" or "off"
View = ET.SubElement(GUISettings, "View")
ET.SubElement(View, "LocalEcho").text = self.actionLocal_Echo.isChecked() and "on" or "off"
ET.SubElement(View, "ReceiveView").text = self._viewGroup.checkedAction().text()
with open(get_config_path('MyTerm.xml'), 'w') as f:
f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
f.write(ET.tostring(root, encoding='utf-8', pretty_print=True).decode("utf-8"))
def loadSettings(self):
if os.path.isfile(get_config_path("MyTerm.xml")):
with open(get_config_path("MyTerm.xml"), 'r') as f:
tree = safeET.parse(f)
port = tree.findtext('GUISettings/PortConfig/port', default='')
if port != '':
self.cmbPort.setCurrentText(port)
baudrate = tree.findtext('GUISettings/PortConfig/baudrate', default='38400')
if baudrate != '':
self.cmbBaudRate.setCurrentText(baudrate)
databits = tree.findtext('GUISettings/PortConfig/databits', default='8')
id = self.cmbDataBits.findText(databits)
if id >= 0:
self.cmbDataBits.setCurrentIndex(id)
parity = tree.findtext('GUISettings/PortConfig/parity', default='None')
id = self.cmbParity.findText(parity)
if id >= 0:
self.cmbParity.setCurrentIndex(id)
stopbits = tree.findtext('GUISettings/PortConfig/stopbits', default='1')
id = self.cmbStopBits.findText(stopbits)
if id >= 0:
self.cmbStopBits.setCurrentIndex(id)
rtscts = tree.findtext('GUISettings/PortConfig/rtscts', default='off')
if 'on' == rtscts:
self.chkRTSCTS.setChecked(True)
else:
self.chkRTSCTS.setChecked(False)
xonxoff = tree.findtext('GUISettings/PortConfig/xonxoff', default='off')
if 'on' == xonxoff:
self.chkXonXoff.setChecked(True)
else:
self.chkXonXoff.setChecked(False)
LocalEcho = tree.findtext('GUISettings/View/LocalEcho', default='off')
if 'on' == LocalEcho:
self.actionLocal_Echo.setChecked(True)
self._localEcho = True
else:
self.actionLocal_Echo.setChecked(False)
self._localEcho = False
ReceiveView = tree.findtext('GUISettings/View/ReceiveView', default='HEX(UPPERCASE)')
if 'Ascii' in ReceiveView:
self.actionAscii.setChecked(True)
self._viewMode = VIEWMODE_ASCII
elif 'lowercase' in ReceiveView:
self.actionHex_lowercase.setChecked(True)
self._viewMode = VIEWMODE_HEX_LOWERCASE
elif 'UPPERCASE' in ReceiveView:
self.actionHEX_UPPERCASE.setChecked(True)
self._viewMode = VIEWMODE_HEX_UPPERCASE
self.receiver_thread.setViewMode(self._viewMode)
def closeEvent(self, event):
self.saveLayout()
self.saveQuickSend()
self.saveSettings()
event.accept()
def initQuickSend(self):
#self.quickSendTable.horizontalHeader().setDefaultSectionSize(40)
#self.quickSendTable.horizontalHeader().setMinimumSectionSize(25)
self.quickSendTable.setRowCount(50)
self.quickSendTable.setColumnCount(3)
self.quickSendTable.verticalHeader().setSectionsClickable(True)
for row in range(50):
self.initQuickSendButton(row)
if os.path.isfile(get_config_path('QuickSend.csv')):
self.loadQuickSend(get_config_path('QuickSend.csv'))
self.quickSendTable.resizeColumnsToContents()
def initQuickSendButton(self, row, cmd = 'cmd', opt = 'H', dat = ''):
if self.quickSendTable.cellWidget(row, 0) is None:
item = QToolButton(self)
item.setText(cmd)
item.clicked.connect(self._signalMapQuickSend.map)
self._signalMapQuickSend.setMapping(item, row)
self.quickSendTable.setCellWidget(row, 0, item)
else:
self.quickSendTable.cellWidget(row, 0).setText(cmd)
if self.quickSendTable.cellWidget(row, 1) is None:
item = QToolButton(self)
item.setText(opt)
#item.setMaximumSize(QtCore.QSize(16, 16))
item.clicked.connect(self._signalMapQuickSendOpt.map)
self._signalMapQuickSendOpt.setMapping(item, row)
self.quickSendTable.setCellWidget(row, 1, item)
else:
self.quickSendTable.cellWidget(row, 1).setText(opt)
if self.quickSendTable.item(row, 2) is None:
self.quickSendTable.setItem(row, 2, QTableWidgetItem(dat))
else:
self.quickSendTable.item(row, 2).setText(dat)
self.quickSendTable.setRowHeight(row, 16)
def onSetSendHex(self):
item = self.quickSendTable.cellWidget(self._quickSendOptRow, 1)
item.setText('H')
def onSetSendAsc(self):
item = self.quickSendTable.cellWidget(self._quickSendOptRow, 1)
item.setText('A')
def onSetSendTFH(self):
item = self.quickSendTable.cellWidget(self._quickSendOptRow, 1)
item.setText('FH')
def onSetSendTFA(self):
item = self.quickSendTable.cellWidget(self._quickSendOptRow, 1)
item.setText('FA')
def onSetSendFB(self):
item = self.quickSendTable.cellWidget(self._quickSendOptRow, 1)
item.setText('FB')
def onQuickSendOptions(self, row):
self._quickSendOptRow = row
item = self.quickSendTable.cellWidget(row, 1)
self.sendOptMenu.popup(item.mapToGlobal(QPoint(item.size().width(), item.size().height())))
def openQuickSend(self):
fileName = QFileDialog.getOpenFileName(self, "Select a file",
os.getcwd(), "CSV Files (*.csv)")[0]
if fileName:
self.loadQuickSend(fileName, notifyExcept = True)
def saveQuickSend(self):
# scan table
rows = self.quickSendTable.rowCount()
#cols = self.quickSendTable.columnCount()
save_data = [[self.quickSendTable.cellWidget(row, 0).text(),
self.quickSendTable.cellWidget(row, 1).text(),
self.quickSendTable.item(row, 2) is not None
and self.quickSendTable.item(row, 2).text() or ''] for row in range(rows)]
#import pprint
#pprint.pprint(save_data, width=120, compact=True)
# write to file
with open(get_config_path('QuickSend.csv'), 'w') as csvfile:
csvwriter = csv.writer(csvfile, delimiter=',', lineterminator='\n')
csvwriter.writerows(save_data)
def loadQuickSend(self, path, notifyExcept = False):
data = []
set_rows = 0
set_cols = 0
try:
with open(path) as csvfile:
csvData = csv.reader(csvfile)
for row in csvData:
data.append(row)
set_rows = set_rows + 1
if len(row) > set_cols:
set_cols = len(row)
except IOError as e:
print("({})".format(e))
if notifyExcept:
QMessageBox.critical(self.defaultStyleWidget, "Open failed",
str(e), QMessageBox.Close)
return
rows = self.quickSendTable.rowCount()
cols = self.quickSendTable.columnCount()
if rows < set_rows:
rows = set_rows + 10
self.quickSendTable.setRowCount(rows)
for row, rowdat in enumerate(data):
if len(rowdat) >= 3:
cmd, opt, dat = rowdat[0:3]
self.initQuickSendButton(row, cmd, opt, dat)
# self.quickSendTable.cellWidget(row, 0).setText(cmd)
# self.quickSendTable.cellWidget(row, 1).setText(opt)
# self.quickSendTable.setItem(row, 2, QTableWidgetItem(dat))
self.quickSendTable.resizeColumnsToContents()
#self.quickSendTable.resizeRowsToContents()
def onQuickSend(self, row):
if self.quickSendTable.item(row, 2) is not None:
tablestring = self.quickSendTable.item(row, 2).text()
format = self.quickSendTable.cellWidget(row, 1).text()
if 'H' == format:
self.transmitHex(tablestring)
elif 'A' == format:
self.transmitAsc(tablestring)
elif 'FB' == format:
try:
with open(tablestring, 'rb') as f:
bytes = f.read()
self.transmitBytearray(bytes)
except IOError as e:
print("({})".format(e))
QMessageBox.critical(self.defaultStyleWidget, "Open failed",
str(e), QMessageBox.Close)
else:
try:
with open(tablestring, 'rt') as f:
filestring = f.read()
if 'FH' == format:
self.transmitHex(filestring)
elif 'FA' == format:
self.transmitAsc(filestring)
except IOError as e:
print("({})".format(e))
QMessageBox.critical(self.defaultStyleWidget, "Open failed",
str(e), QMessageBox.Close)
def onSend(self):
sendstring = self.txtEdtInput.toPlainText()
self.transmitHex(sendstring)
def transmitHex(self, hexstring):
if len(hexstring) > 0:
hexarray = []
_hexstring = hexstring.replace(' ', '')
_hexstring = _hexstring.replace('\r', '')
_hexstring = _hexstring.replace('\n', '')
for i in range(0, len(_hexstring), 2):
word = _hexstring[i:i+2]
if is_hex(word):
hexarray.append(int(word, 16))
else:
QMessageBox.critical(self.defaultStyleWidget, "Error",
"'%s' is not hexadecimal." % (word), QMessageBox.Close)
return
self.transmitBytearray(bytearray(hexarray))
def transmitAsc(self, text):
if len(text) > 0:
byteArray = [ord(char) for char in text]
self.transmitBytearray(bytearray(byteArray))
def transmitBytearray(self, byteArray):
if self.serialport.isOpen():
try:
self.serialport.write(byteArray)
except Exception as e:
QMessageBox.critical(self.defaultStyleWidget,
"Exception in transmit", str(e), QMessageBox.Close)
print("Exception in transmitBytearray(%s)" % text)
else:
if self._viewMode == VIEWMODE_ASCII:
text = byteArray.decode('unicode_escape')
elif self._viewMode == VIEWMODE_HEX_LOWERCASE:
text = ''.join('%02x ' % t for t in byteArray)
elif self._viewMode == VIEWMODE_HEX_UPPERCASE:
text = ''.join('%02X ' % t for t in byteArray)
self.appendOutputText("\n%s T->:%s" % (self.timestamp(), text), Qt.blue)
def onReaderExcept(self, e):
self.closePort()
QMessageBox.critical(self.defaultStyleWidget, "Read failed", str(e), QMessageBox.Close)
def timestamp(self):
return datetime.datetime.now().time().isoformat()[:-3]
def onReceive(self, data):
self.appendOutputText("\n%s R<-:%s" % (self.timestamp(), data))
def appendOutputText(self, data, color=Qt.black):
# the qEditText's "append" methon will add a unnecessary newline.
# self.txtEdtOutput.append(data.decode('utf-8'))
tc=self.txtEdtOutput.textColor()
self.txtEdtOutput.moveCursor(QtGui.QTextCursor.End)
self.txtEdtOutput.setTextColor(QtGui.QColor(color))
self.txtEdtOutput.insertPlainText(data)
self.txtEdtOutput.moveCursor(QtGui.QTextCursor.End)
self.txtEdtOutput.setTextColor(tc)
def getPort(self):
return self.cmbPort.currentText()
def getDataBits(self):
return {'5':serial.FIVEBITS,
'6':serial.SIXBITS,
'7':serial.SEVENBITS,
'8':serial.EIGHTBITS}[self.cmbDataBits.currentText()]
def getParity(self):
return {'None' :serial.PARITY_NONE,
'Even' :serial.PARITY_EVEN,
'Odd' :serial.PARITY_ODD,
'Mark' :serial.PARITY_MARK,
'Space':serial.PARITY_SPACE}[self.cmbParity.currentText()]
def getStopBits(self):
return {'1' :serial.STOPBITS_ONE,
'1.5':serial.STOPBITS_ONE_POINT_FIVE,
'2' :serial.STOPBITS_TWO}[self.cmbStopBits.currentText()]
def openPort(self):
if self.serialport.isOpen():
return
_port = self.getPort()
if '' == _port:
QMessageBox.information(self.defaultStyleWidget, "Invalid parameters", "Port is empty.")
return
_baudrate = self.cmbBaudRate.currentText()
if '' == _baudrate:
QMessageBox.information(self.defaultStyleWidget, "Invalid parameters", "Baudrate is empty.")
return
self.serialport.port = _port
self.serialport.baudrate = _baudrate
self.serialport.bytesize = self.getDataBits()
self.serialport.stopbits = self.getStopBits()
self.serialport.parity = self.getParity()
self.serialport.rtscts = self.chkRTSCTS.isChecked()
self.serialport.xonxoff = self.chkXonXoff.isChecked()
# self.serialport.timeout = THREAD_TIMEOUT
# self.serialport.writeTimeout = SERIAL_WRITE_TIMEOUT
try:
self.serialport.open()
except Exception as e:
QMessageBox.critical(self.defaultStyleWidget,
"Could not open serial port", str(e), QMessageBox.Close)
else:
self._start_reader()
self.setWindowTitle("%s on %s [%s, %s%s%s%s%s]" % (
appInfo.title,
self.serialport.portstr,
self.serialport.baudrate,
self.serialport.bytesize,
self.serialport.parity,
self.serialport.stopbits,
self.serialport.rtscts and ' RTS/CTS' or '',
self.serialport.xonxoff and ' Xon/Xoff' or '',
)
)
pal = self.btnOpen.palette()
pal.setColor(QtGui.QPalette.Button, QtGui.QColor(0,0xff,0x7f))
self.btnOpen.setAutoFillBackground(True)
self.btnOpen.setPalette(pal)
self.btnOpen.setText('Close')
self.btnOpen.update()
def closePort(self):
if self.serialport.isOpen():
self._stop_reader()
self.serialport.close()
self.setWindowTitle(appInfo.title)
pal = self.btnOpen.style().standardPalette()
self.btnOpen.setAutoFillBackground(True)
self.btnOpen.setPalette(pal)
self.btnOpen.setText('Open')
self.btnOpen.update()
def _start_reader(self):
"""Start reader thread"""
self.receiver_thread.start()
def _stop_reader(self):
"""Stop reader thread only, wait for clean exit of thread"""
self.receiver_thread.join()
def onTogglePrtCfgPnl(self):
if self.actionPort_Config_Panel.isChecked():
self.dockWidget_PortConfig.show()
else:
self.dockWidget_PortConfig.hide()
def onToggleQckSndPnl(self):
if self.actionQuick_Send_Panel.isChecked():
self.dockWidget_QuickSend.show()
else:
self.dockWidget_QuickSend.hide()
def onToggleHexPnl(self):
if self.actionSend_Hex_Panel.isChecked():
self.dockWidget_SendHex.show()
else:
self.dockWidget_SendHex.hide()
def onVisiblePrtCfgPnl(self, visible):
self.actionPort_Config_Panel.setChecked(visible)
def onVisibleQckSndPnl(self, visible):
self.actionQuick_Send_Panel.setChecked(visible)
def onVisibleHexPnl(self, visible):
self.actionSend_Hex_Panel.setChecked(visible)
def onLocalEcho(self):
self._localEcho = self.actionLocal_Echo.isChecked()
def onAlwaysOnTop(self):
if self.actionAlways_On_Top.isChecked():
style = self.windowFlags()
self.setWindowFlags(style|Qt.WindowStaysOnTopHint)
self.show()
else:
style = self.windowFlags()
self.setWindowFlags(style & ~Qt.WindowStaysOnTopHint)
self.show()
def onOpen(self):
if self.serialport.isOpen():
self.closePort()
else:
self.openPort()
def onClear(self):
self.txtEdtOutput.clear()
def onSaveLog(self):
fileName = QFileDialog.getSaveFileName(self, "Save as", os.getcwd(),
"Log files (*.log);;Text files (*.txt);;All files (*.*)")[0]
if fileName:
import codecs
with codecs.open(fileName, 'w', 'utf-8') as f:
f.write(self.txtEdtOutput.toPlainText())
def moveScreenCenter(self):
w = self.frameGeometry().width()
h = self.frameGeometry().height()
desktop = QDesktopWidget()
screenW = desktop.screen().width()
screenH = desktop.screen().height()
self.setGeometry((screenW-w)/2, (screenH-h)/2, w, h)
def onEnumPorts(self):
self.cmbPort.clear()
for p in enum_ports():
self.cmbPort.addItem(p)
def onAbout(self):
QMessageBox.about(self.defaultStyleWidget, "About MyTerm", appInfo.aboutme)
def onAboutQt(self):
QMessageBox.aboutQt(self.defaultStyleWidget)
def onExit(self):
if self.serialport.isOpen():
self.closePort()
self.close()
def restoreLayout(self):
if os.path.isfile(get_config_path("UILayout.dat")):
try:
f=open(get_config_path("UILayout.dat"), 'rb')
geometry, state=pickle.load(f)
self.restoreGeometry(geometry)
self.restoreState(state)
except Exception as e:
print("Exception on restoreLayout, {}".format(e))
else:
try:
f=QFile(':/default_layout_qt5.dat')
f.open(QIODevice.ReadOnly)
geometry, state=pickle.loads(f.readAll())
self.restoreGeometry(geometry)
self.restoreState(state)
except Exception as e:
print("Exception on restoreLayout, {}".format(e))
def saveLayout(self):
with open(get_config_path("UILayout.dat"), 'wb') as f:
pickle.dump((self.saveGeometry(), self.saveState()), f)
def syncMenu(self):
self.actionPort_Config_Panel.setChecked(not self.dockWidget_PortConfig.isHidden())
self.actionQuick_Send_Panel.setChecked(not self.dockWidget_QuickSend.isHidden())
self.actionSend_Hex_Panel.setChecked(not self.dockWidget_SendHex.isHidden())
def onViewChanged(self):
checked = self._viewGroup.checkedAction()
if checked is None:
self._viewMode = VIEWMODE_HEX_UPPERCASE
self.actionHEX_UPPERCASE.setChecked(True)
else:
if 'Ascii' in checked.text():
self._viewMode = VIEWMODE_ASCII
elif 'lowercase' in checked.text():
self._viewMode = VIEWMODE_HEX_LOWERCASE
elif 'UPPERCASE' in checked.text():
self._viewMode = VIEWMODE_HEX_UPPERCASE
self.receiver_thread.setViewMode(self._viewMode)
def __init__(self, supported_exts, parent=None):
super().__init__(parent)
self._diasshowRunning = False
# a dummy widget to center actions
spacer1 = QWidget()
spacer1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.addWidget(spacer1)
self.supportedExts = supported_exts
self._fromFile = self.addAction(QIcon("icons/image-outline.svg"), "", self.chooseFile) # load images from file
self._fromFile.setToolTip("Load image")
self._fromFolder = self.addAction(QIcon("icons/folder-open.svg"), "", self.chooseFolder) # load images from folder
self._fromFolder.setToolTip("Load from directory")
# View in native size, fit width, fit height or fit image
self._imageMode = QToolButton(self)
self._imageMode.setIcon(QIcon("icons/eye-outline.svg"))
self._imageMode.setToolTip("Image view mode")
self._imageMode.setPopupMode(QToolButton.InstantPopup)
self.addWidget(self._imageMode)
# imageMode menu
imageModeMenu = QMenu(self)
imageModeActions = QActionGroup(imageModeMenu)
imModeAct1 = imageModeActions.addAction("Native size")
imModeAct1.setCheckable(True)
imModeAct1.triggered.connect(lambda: self.imageModeChanged.emit(0))
imModeAct2 = imageModeActions.addAction("Fit in view")
imModeAct2.setCheckable(True)
imModeAct2.triggered.connect(lambda: self.imageModeChanged.emit(1))
imModeAct3 = imageModeActions.addAction("Fit width")
imModeAct3.setCheckable(True)
imModeAct3.triggered.connect(lambda: self.imageModeChanged.emit(2))
imModeAct4 = imageModeActions.addAction("Fit height")
imModeAct4.setCheckable(True)
imModeAct4.triggered.connect(lambda: self.imageModeChanged.emit(3))
imageModeActions.setExclusive(True)
imageModeMenu.addActions(imageModeActions.actions())
self._imageMode.setMenu(imageModeMenu)
self._imgDirection = self.addAction(QIcon("icons/arrow-move-outline.svg"), "", self.imageDirectionChanged.emit) # Horizontal or Vertical
self._imgDirection.setToolTip("Toggle image direction")
# start or stop diasshow
self._playDias = self.addAction(QIcon("icons/media-play-outline.svg"), "", self.diasshowState)
self._playDias.setToolTip("Start/stop diasshow")
#diasshow menu
self._diasMenu = QMenu(self)
self._diasMenu.addAction("5 seconds", lambda: self.diasshowState(5))
self._diasMenu.addAction("10 seconds", lambda: self.diasshowState(10))
self._diasMenu.addAction("30 seconds", lambda: self.diasshowState(30))
self._diasMenu.addAction("5 minutes", lambda: self.diasshowState(60*5))
self._diasMenu.addAction("10 minutes", lambda: self.diasshowState(600))
self._playDias.setMenu(self._diasMenu)
self._zoomIn = self.addAction(QIcon("icons/zoom-in-outline.svg"), "", lambda: self.zoomChanged.emit(True))
self._zoomOut = self.addAction(QIcon("icons/zoom-out-outline.svg"), "", lambda: self.zoomChanged.emit(False))
self._rotateCW = self.addAction(QIcon("icons/rotate-cw-outline.svg"), "", self.rotateChanged.emit) # Clockwise
self._rotateCW.setToolTip("Rotate Clockwise")
#self._rotateCCW = self.addAction("Rotate Left") # Counter clockwise
# a dummy widget to center actions
spacer2 = QWidget()
spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.addWidget(spacer2)
