def __init__(self, parent):
QMenu.__init__(self, "&Archivo", parent)
self.sig = Communicate()
#self.parent = parent
self.new = QAction(QIcon(
'Iconos/document-new.png'), 'Nuevo', self)
self.new.setShortcut('Ctrl+N')
self.new.triggered.connect(self.sig.new_file.emit)
self.addAction(self.new)
self.open = QAction(QIcon(
'Iconos/document-open.png'), 'Abrir...', self)
self.open.setShortcut('Ctrl+O')
self.open.triggered.connect(self.sig.open_file.emit)
self.addAction(self.open)
self.addSeparator()
self.save = QAction(QIcon(
'Iconos/document-save.png'), 'Guardar', self)
self.save.setShortcut('Ctrl+S')
self.save.triggered.connect(self.sig.save_file.emit)
self.save.setEnabled(False)
self.addAction(self.save)
self.saveas = QAction(QIcon(
'Iconos/document-save-as.png'), 'Guardar Como...', self)
self.saveas.triggered.connect(self.sig.save_file_as.emit)
self.saveas.setEnabled(False)
self.addAction(self.saveas)
'''
def __init__(self, *args, label=None, parent=None, **kwargs):
"""Create a SubMenu instance."""
if label is None:
QMenu.__init__(self, parent)
else:
QMenu.__init__(self, label, parent)
self._images = []
def __init__(self, titre='', liste=None, fonction=None, aide=''):
QMenu.__init__(self, titre)
# self.parent = parent
self.fonction = None
# self.titre = titre
# self.setTitle(titre)
self.update(liste, fonction, aide)
def __init__(self, quit_fn, parent=None):
QMenu.__init__(self, parent=None)
quit = QAction("Exit", self)
quit.triggered.connect(quit_fn)
# self.addSeparator()
self.addAction(quit)
def __init__(self, parent):
QMenu.__init__(self, parent)
self.setStyleSheet(
"""
QMenu {
background-color: #404040;
}
QMenu::item {
color: #D0D0D0;
padding: 5px;
}
QMenu::item:selected {
background-color: #707070;
}
QMenu::item:disabled {
color: #999999;
}
"""
)
self.setMinimumWidth(CONTEXT_MENU_WIDTH)
def __init__(self, widget):
QMenu.__init__(self)
self.widget = widget
center_plot = self.addAction(_('Center Plot'))
center_plot.triggered.connect(lambda: widget.view.setRange(yRange=(
widget.left_axis[-1], widget.left_axis[-1])))
vertical_autorange = self.addAction(_('Vertical Autorange'))
vertical_autorange.triggered.connect(lambda: widget.view.autoRange())
if self.widget.filtering:
filters_menu = self.addMenu(_('Filters'))
filters_lst = []
r = QRadioButton('No Filter')
radio_action = QWidgetAction(filters_menu)
radio_action.setDefaultWidget(r)
filters_menu.addAction(radio_action)
filters_lst.append(r)
for f in self.widget.iir_filter.filters.keys():
r = QRadioButton(f)
radio_action = QWidgetAction(filters_menu)
radio_action.setDefaultWidget(r)
filters_menu.addAction(radio_action)
filters_lst.append(r)
for i, f in enumerate(filters_lst):
if i == self.current_filter:
f.setChecked(True)
self.filters = [(r,
r.clicked.connect(lambda: self.filter_chosen()))
for r in filters_lst]
if self.widget.time_synchronised:
sync_x_chbx = QCheckBox(_('\t\t\t\t\tSynchronize time'))
sync_x_chbx.setChecked(Menu.sync_chbx_state)
sync_x_chbx.stateChanged.connect(lambda i: self.state_changed(i))
sync_x = QWidgetAction(self)
sync_x.setDefaultWidget(sync_x_chbx)
self.addAction(sync_x)
def __init__(self, parent=None):
QMenu.__init__(self, parent)
_translate = QCoreApplication.translate
# Model keys must match the ones used in search widget class
self.filters = {
Model.Outline:
searchFilter(_translate("MainWindow", "Outline"), True,
list(OutlineSearchLabels.keys())),
Model.Character:
searchFilter(_translate("MainWindow", "Characters"), True,
list(CharacterSearchLabels.keys())),
Model.FlatData:
searchFilter(_translate("MainWindow", "FlatData"), True,
list(FlatDataSearchLabels.keys())),
Model.World:
searchFilter(_translate("MainWindow", "World"), True,
list(WorldSearchLabels.keys())),
Model.Plot:
searchFilter(_translate("MainWindow", "Plot"), True,
list(PlotSearchLabels.keys()))
}
self.options = {
"CS": [self.tr("Case sensitive"), True],
"MatchWords": [self.tr("Match words"), False],
"Regex": [self.tr("Regex"), False]
}
self._generateOptions()
def __init__(self, parent=None):
QMenu.__init__(self)
self.parent = parent
try:
self.parent.children()
except AttributeError:
pass
else:
try:
self.setParent(self.parent)
except TypeError:
pass
finally:
self.key = '{0}_{1}'.format(self.parent.key, self.key)
self.signals = SignalManager(self)
self.settings = Settings(SETTING_FILEPTH['app'], ST_FORMAT['ini'],
self)
self.values = dict(w=self.width(),
h=self.height(),
x=self.x(),
y=self.y())
def __init__(self, index, isPlaylistEmpty, hasUndo, hasRedo, parent=None):
QMenu.__init__(self, parent)
self.trackIndex = index
self.w = PlaylistMenuWidget()
if index.row() != -1:
self.addAction(self.w.play)
self.w.play.triggered.connect(self._onPlay)
self.addAction(self.w.remove)
self.w.remove.triggered.connect(self._onRemove)
if not isPlaylistEmpty:
self.addAction(self.w.clear)
self.w.clear.triggered.connect(self._onClear)
self.addAction(self.w.save)
self.w.save.triggered.connect(self._onSave)
if hasUndo:
self.addAction(self.w.undo)
self.w.undo.triggered.connect(self._onUndo)
if hasRedo:
self.addAction(self.w.redo)
self.w.redo.triggered.connect(self._onRedo)
self.addAction(self.w.reconnect)
self.w.reconnect.triggered.connect(self._onReconnect)
def __init__(self, widget):
QMenu.__init__(self)
center_plot = self.addAction(_('Center Plot'))
center_plot.triggered.connect(lambda: widget.viewbox.setRange(yRange=(
widget.right_axis[-1], widget.right_axis[-1])))
vertical_autorange = self.addAction(_('Vertical Autorange'))
vertical_autorange.triggered.connect(
lambda: widget.viewbox.autoRange())
def __init__(self, menuModel, button=None, parent=None):
QMenu.__init__(self, parent)
self.setSeparatorsCollapsible(False)
self.filterTerm = ""
self.menuModel = menuModel
self.buildMenu(self.menuModel.menu_items)
self.initFilterVisibility = True
self.filterConditions = [False, True, False]
self.button = button
def __init__(self, name: str, port_data, parent):
QMenu.__init__(self, name, parent)
self._port_data = port_data
self._group_id = port_data._group_id
self._port_id = port_data._port_id
self._port_type = port_data._port_type
self._port_mode = port_data._port_mode
self._portgrp_id = port_data._portgrp_id
self._is_alternate = port_data._is_alternate
self._port_id_list = port_data._port_id_list
def __init__(self, canvas_scene, position, clicked, offset=None):
QMenu.__init__(self)
self.clicked = clicked
self.offset = offset
self.canvas_scene = canvas_scene
self.selectedItems = [shape for shape in canvas_scene.shapes if shape.isSelected()]
if len(self.selectedItems) == 0:
return
invertAction = self.addAction(self.tr("Invert Selection"))
disableAction = self.addAction(self.tr("Disable Selection"))
enableAction = self.addAction(self.tr("Enable Selection"))
self.addSeparator()
swdirectionAction = self.addAction(self.tr("Switch Direction"))
SetNxtStPAction = self.addAction(self.tr("Set Nearest StartPoint"))
if g.config.machine_type == "drag_knife":
pass
else:
self.addSeparator()
submenu1 = QMenu(self.tr("Cutter Compensation"), self)
self.noCompAction = submenu1.addAction(self.tr("G40 No Compensation"))
self.noCompAction.setCheckable(True)
self.leCompAction = submenu1.addAction(self.tr("G41 Left Compensation"))
self.leCompAction.setCheckable(True)
self.reCompAction = submenu1.addAction(self.tr("G42 Right Compensation"))
self.reCompAction.setCheckable(True)
logger.debug(self.tr("The selected shapes have the following direction: %i") % (self.calcMenuDir()))
self.checkMenuDir(self.calcMenuDir())
self.addMenu(submenu1)
invertAction.triggered.connect(self.invertSelection)
disableAction.triggered.connect(self.disableSelection)
enableAction.triggered.connect(self.enableSelection)
swdirectionAction.triggered.connect(self.switchDirection)
SetNxtStPAction.triggered.connect(self.setNearestStPoint)
if g.config.machine_type == "drag_knife":
pass
else:
self.noCompAction.triggered.connect(self.setNoComp)
self.leCompAction.triggered.connect(self.setLeftComp)
self.reCompAction.triggered.connect(self.setRightComp)
self.exec_(position)
def __init__(self, roi: Roi):
QMenu.__init__(self)
self.roi = roi
self.key = roi.key
self.roi_dict = App().roi_dict
self._init_menu()
if App().debug_tracker:
App().debug_tracker.add_object(self)
self.exec_(QCursor.pos())
def __init__(self, canvas_scene, position, clicked, offset=None):
QMenu.__init__(self)
self.clicked = clicked
self.offset = offset
self.canvas_scene = canvas_scene
self.selectedItems = [shape for shape in canvas_scene.shapes if shape.isSelected()]
if len(self.selectedItems) == 0:
return
invertAction = self.addAction(self.tr("Invert Selection"))
disableAction = self.addAction(self.tr("Disable Selection"))
enableAction = self.addAction(self.tr("Enable Selection"))
self.addSeparator()
swdirectionAction = self.addAction(self.tr("Switch Direction"))
SetNxtStPAction = self.addAction(self.tr("Set Nearest StartPoint"))
if g.config.machine_type == 'drag_knife':
pass
else:
self.addSeparator()
submenu1 = QMenu(self.tr('Cutter Compensation'), self)
self.noCompAction = submenu1.addAction(self.tr("G40 No Compensation"))
self.noCompAction.setCheckable(True)
self.leCompAction = submenu1.addAction(self.tr("G41 Left Compensation"))
self.leCompAction.setCheckable(True)
self.reCompAction = submenu1.addAction(self.tr("G42 Right Compensation"))
self.reCompAction.setCheckable(True)
logger.debug(self.tr("The selected shapes have the following direction: %i") % (self.calcMenuDir()))
self.checkMenuDir(self.calcMenuDir())
self.addMenu(submenu1)
invertAction.triggered.connect(self.invertSelection)
disableAction.triggered.connect(self.disableSelection)
enableAction.triggered.connect(self.enableSelection)
swdirectionAction.triggered.connect(self.switchDirection)
SetNxtStPAction.triggered.connect(self.setNearestStPoint)
if g.config.machine_type == 'drag_knife':
pass
else:
self.noCompAction.triggered.connect(self.setNoComp)
self.leCompAction.triggered.connect(self.setLeftComp)
self.reCompAction.triggered.connect(self.setRightComp)
self.exec_(position)
def __init__(self, text, parent=None):
QMenu.__init__(self, text, parent)
self.historyMenu = QMenu("History", self)
self.initHistoryMenu()
self.maxHistoryLength = 10
# When creating menu first time (for the main root menu), a special
# menu entry should be created, which will allow user to alwayas return
# to that very first/main menu. It should always be the top choice in the
# View menu, except when main menu is already loaded.
self.rootMenuElement = None
def __init__(self, parent=None):
QMenu.__init__(self, "File", parent)
icon = QIcon.fromTheme("document-new")
self.addAction(QAction(icon, "&New", self))
icon = QIcon.fromTheme("document-open")
self.addAction(QAction(icon, "&Open", self))
icon = QIcon.fromTheme("document-save")
self.addAction(QAction(icon, "&Save", self))
def __init__(self, parent=None):
QMenu.__init__(self, "Edit", parent)
icon = QtGui.QIcon.fromTheme("edit-cut")
self.addAction(QAction(icon, "Cut (&X)", self))
icon = QIcon.fromTheme("edit-copy")
self.addAction(QAction(icon, "&Copy", self))
icon = QIcon.fromTheme("edit-paste")
self.addAction(QAction(icon, "&Paste", self))
def __init__(self, index, parent=None):
QMenu.__init__(self, parent)
self.trackIndex = index
if index.row() != -1:
play = self.addAction("Play")
play.triggered.connect(self._onPlay)
remove = self.addAction("Remove")
remove.triggered.connect(self._onRemove)
clear = self.addAction("Clear")
clear.triggered.connect(self._onClear)
def __init__(self, parent, gid, title=''):
QMenu.__init__(self, title, parent)
self.gid = gid
self._parent = parent
self._aRect = {}
self._bg_image = None
self._fg_image = None
self._side_image = None
self.installEventFilter(self)
self.setMouseTracking(True)
self.setStyleSheet("QMenu { menu-scrollable: 1; }")
self.setSeparatorsCollapsible(False)
def __init__(self, theTree):
QMenu.__init__(self, theTree)
self.theTree = theTree
self.theItem = None
self.editItem = QAction("Edit Project Item", self)
self.editItem.triggered.connect(self._doEditItem)
self.addAction(self.editItem)
self.openItem = QAction("Open Document", self)
self.openItem.triggered.connect(self._doOpenItem)
self.addAction(self.openItem)
self.viewItem = QAction("View Document", self)
self.viewItem.triggered.connect(self._doViewItem)
self.addAction(self.viewItem)
self.toggleExp = QAction("Toggle Included Flag", self)
self.toggleExp.triggered.connect(self._doToggleExported)
self.addAction(self.toggleExp)
self.newFile = QAction("New File", self)
self.newFile.triggered.connect(self._doMakeFile)
self.addAction(self.newFile)
self.newFolder = QAction("New Folder", self)
self.newFolder.triggered.connect(self._doMakeFolder)
self.addAction(self.newFolder)
self.deleteItem = QAction("Delete Item", self)
self.deleteItem.triggered.connect(self._doDeleteItem)
self.addAction(self.deleteItem)
self.emptyTrash = QAction("Empty Trash", self)
self.emptyTrash.triggered.connect(self._doEmptyTrash)
self.addAction(self.emptyTrash)
self.moveUp = QAction("Move Item Up", self)
self.moveUp.triggered.connect(self._doMoveUp)
self.addAction(self.moveUp)
self.moveDown = QAction("Move Item Down", self)
self.moveDown.triggered.connect(self._doMoveDown)
self.addAction(self.moveDown)
return
def __init__(self, title, parent, icon=None):
QMenu.__init__(self, title, parent)
if icon is None:
title = '\u2022 ' + title
self._title = self.addAction(title)
else:
if isinstance(icon, str):
##icon = QIcon(png(icon))
icon = QIcon(png_pth(icon))
self._title = self.addAction(icon, title)
self._title.setEnabled(False)
self._title.setIconVisibleInMenu(True)
font = QFont()
font.setBold(True)
font.setStyle(QFont.StyleItalic)
self._title.setFont(font)
self.addSeparator()
def __init__(self, parent):
QMenu.__init__(self, "&Código", parent)
item = QAction('Aumentar Texto', self)
item.setShortcut('Ctrl++')
self.addAction(item)
item = QAction('Disminuir Texto', self)
item.setShortcut('Ctrl+-')
self.addAction(item)
item = QAction('Formato Texto...', self)
item.setShortcut('Ctrl+T')
item.triggered.connect(self.showDialog)
self.addAction(item)
self.addSeparator()
item = QAction('Aumentar Tabulación', self)
#item.setShortcut('Ctrl+X')
self.addAction(item)
item = QAction('Disminuir Tabulación', self)
#item.setShortcut('Ctrl+V')
self.addAction(item)
self.addSeparator()
item = QAction('Buscar Texto...', self)
item.setShortcut('Ctrl+B')
self.addAction(item)
item = QAction('Remplazar Texto...', self)
#item.setShortcut('Ctrl+B')
self.addAction(item)
self.addSeparator()
item = QAction('Chequear Sintaxis...', self)
#item.setShortcut('Ctrl+B')
self.addAction(item)
def __init__(self, parent):
QMenu.__init__(self, parent)
self.setStyleSheet("""
QMenu {
background-color: #404040;
}
QMenu::item {
color: #D0D0D0;
padding: 5px;
}
QMenu::item:selected {
background-color: #707070;
}
QMenu::item:disabled {
color: #999999;
}
""")
def __init__(self, theParent):
QMenu.__init__(self, theParent)
self.theParent = theParent
self.acceptToggle = True
mnuHead = QAction("Select Columns", self)
self.addAction(mnuHead)
self.addSeparator()
self.actionMap = {}
for hItem in nwOutline:
if hItem == nwOutline.TITLE:
continue
self.actionMap[hItem] = QAction(nwLabels.OUTLINE_COLS[hItem], self)
self.actionMap[hItem].setCheckable(True)
self.actionMap[hItem].toggled.connect(
lambda isChecked, tItem=hItem: self._columnToggled(
isChecked, tItem))
self.addAction(self.actionMap[hItem])
return
def __init__(self, menubar, titre, liste):
QMenu.__init__(self, titre, menubar)
IDEM = True
# self.parent = menubar.parent
self.aboutToShow.connect(self.actualiser)
for contenu in liste:
if not contenu:
self.addSeparator()
elif isinstance(contenu, RSSMenu):
self.addMenu(contenu)
else:
if len(contenu) == 1: # menus predefinis
contenu = menubar.menus[contenu[0]]
if isinstance(contenu[1], (list, tuple)): # le menu contient un sous-menu
menu = Menu(menubar, contenu[0], contenu[1:])
self.addMenu(menu)
else:
if not contenu[1]:
contenu[1] = ''
# 0->titre, 1->description, 2->raccourci, 3->fonction associee[, 4->cocher ou non]
titre = contenu[0]
shortcut = (QKeySequence(contenu[2]) if contenu[2] else 0)
action = self.addAction(titre)
if contenu[3]:
action.triggered.connect(contenu[3])
action.setShortcut(shortcut)
action.setStatusTip(contenu[1])
if len(contenu) == 5: # le menu contient une case a cocher
if contenu[4] == IDEM:
contenu[4] = contenu[3]
action.setCheckable(True)
action.setChecked(contenu[4]())
action._test = contenu[4]
def __init__(self, parent):
QMenu.__init__(self, "A&yuda", parent)
self.parent = parent
curso = QMenu("Curso Inicial", self)
item = QAction('Directorios y Archivos', self)
item.triggered.connect(self.__open_help)
curso.addAction(item)
item = QAction('Permisos de Archivos y Directorios', self)
item.triggered.connect(self.__open_help)
curso.addAction(item)
self.addMenu(curso)
curso = QMenu("Programar en python", self)
item = QAction('Escribir un programa', self)
item.triggered.connect(self.__open_help)
curso.addAction(item)
item = QAction('Tipos de Datos', self)
item.triggered.connect(self.__open_help)
curso.addAction(item)
self.addMenu(curso)
self._help = None
def __init__(self, title, parent):
QMenu.__init__(self, title, parent)
def __init__(self, *args, label=None, parent=None, **kwargs):
if label is None:
QMenu.__init__(self, parent)
else:
QMenu.__init__(self, label, parent)
def __init__(self, group_id: int, port_id: int, portgrp_id=0):
QMenu.__init__(self)
#self.setStyleSheet(
#"""QMenu{background-color:#202020; border: 1px solid;
#border-color: red; border-radius: 4px};
#QMenu::item{background-color:#999900};
#QMenu::item:selected{background-color: red}""")
if portgrp_id:
# menu is for a portgroup
for portgrp in canvas.portgrp_list:
if (portgrp.group_id == group_id
and portgrp.portgrp_id == portgrp_id):
port_type = portgrp.port_type
port_mode = portgrp.port_mode
is_alternate = False
break
else:
return
else:
# menu is for a port
for port in canvas.port_list:
if port.group_id == group_id and port.port_id == port_id:
port_type = port.port_type
port_mode = port.port_mode
is_alternate = port.is_alternate
break
else:
return
border_color = canvas.theme.port_audio_jack_pen.color().name()
sel_bg = canvas.theme.port_audio_jack_bg.name()
sel_text_color = canvas.theme.port_audio_jack_text.color().name()
if port_type == PORT_TYPE_MIDI_JACK:
border_color = canvas.theme.port_midi_jack_pen.color().name()
sel_bg = canvas.theme.port_midi_jack_bg.name()
sel_text_color = canvas.theme.port_midi_jack_text.color().name()
style_str = """QMenu{background-color:#202020; border: 1px solid;
border-color: %s; border-radius: 4px}
QMenu::item{background-color: #202020;color: white}
QMenu::item:disabled{color: #777777}
QMenu::item:selected{background-color: %s; color:%s}""" % (
border_color, sel_bg, sel_text_color)
#self.setStyleSheet(style_str)
PortData.__init__(self, group_id, port_id, port_type, port_mode,
portgrp_id, is_alternate)
self.connection_list = []
canvas.qobject.connection_added.connect(
self.connection_added_to_canvas)
canvas.qobject.connection_removed.connect(
self.connection_removed_from_canvas)
port_data = PortData(group_id, port_id, port_type, port_mode,
portgrp_id, is_alternate)
dark = ''
if is_dark_theme(self):
dark = '-dark'
self.connect_menu = ConnectMenu(port_data, self)
self.connect_menu.setIcon(
QIcon(QPixmap(':scalable/breeze%s/lines-connector' % dark)))
self.addMenu(self.connect_menu)
self.disconnect_menu = DisconnectMenu(port_data, self)
self.disconnect_menu.setIcon(
QIcon(QPixmap(':scalable/breeze%s/lines-disconnector' % dark)))
self.addMenu(self.disconnect_menu)
disconnect_all_action = self.addAction(
_translate('patchbay', "Disconnect All"))
disconnect_all_action.setIcon(
QIcon(QPixmap(':scalable/breeze%s/lines-disconnector' % dark)))
disconnect_all_action.triggered.connect(self.disconnect_all)
self.clipboard_menu = ClipboardMenu(port_data, self)
self.clipboard_menu.setIcon(QIcon.fromTheme('edit-paste'))
self.addMenu(self.clipboard_menu)
self.addSeparator()
for connection in canvas.connection_list:
if CanvasConnectionConcerns(connection, self._group_id,
self._port_id_list):
self.add_connection(connection)
def __init__(self, roi: 'AbstractROI'):
QMenu.__init__(self)
self.value = roi.value
self._roi = weakref.ref(roi)
self.__init_menu__()
self.exec_(QCursor.pos())
def __init__(self, parent=None):
QMenu.__init__(self, parent)
self._add_actions()
self.open_dunya.triggered.connect(self._send_player_request)
def __init__(self, parent=None):
QMenu.__init__(self, parent=None)
action = QAction("Exit", self)
action.triggered.connect(lambda : QApplication.exit(0))
self.addAction(action)
def __init__(self, patchbay_manager):
QMenu.__init__(self, _translate('patchbay', 'Patchbay'))
self.patchbay_manager = patchbay_manager
# fix wrong menu position with Wayland,
# see https://community.kde.org/Guidelines_and_HOWTOs/Wayland_Porting_Notes
self.winId()
main_win = self.patchbay_manager.session.main_win
main_win.winId()
parent_window_handle = main_win.windowHandle()
if not parent_window_handle:
native_parent_widget = main_win.nativeParentWidget()
if native_parent_widget:
parent_window_handle = native_parent_widget.windowHandle()
self.windowHandle().setTransientParent(parent_window_handle)
self.patchbay_manager.session.signaler.port_types_view_changed.connect(
self._port_types_view_changed)
self.action_fullscreen = self.addAction(
_translate('patchbay', "Toggle Full Screen"))
self.action_fullscreen.setIcon(QIcon.fromTheme('view-fullscreen'))
self.action_fullscreen.triggered.connect(
patchbay_manager.toggle_full_screen)
port_types_view = patchbay_manager.port_types_view & (
GROUP_CONTEXT_AUDIO | GROUP_CONTEXT_MIDI)
self.action_find_box = self.addAction(
_translate('patchbay', "Find a box...\tCtrl+F"))
self.action_find_box.setIcon(QIcon.fromTheme('edit-find'))
self.action_find_box.triggered.connect(
main_win.toggle_patchbay_filters_bar)
self.port_types_menu = QMenu(_translate('patchbay', 'Type filter'), self)
self.port_types_menu.setIcon(QIcon.fromTheme('view-filter'))
self.action_audio_midi = self.port_types_menu.addAction(
_translate('patchbay', 'Audio + Midi'))
self.action_audio_midi.setCheckable(True)
self.action_audio_midi.setChecked(
bool(port_types_view == (GROUP_CONTEXT_AUDIO
| GROUP_CONTEXT_MIDI)))
self.action_audio_midi.triggered.connect(
self.port_types_view_audio_midi_choice)
self.action_audio = self.port_types_menu.addAction(
_translate('patchbay', 'Audio only'))
self.action_audio.setCheckable(True)
self.action_audio.setChecked(port_types_view == GROUP_CONTEXT_AUDIO)
self.action_audio.triggered.connect(
self.port_types_view_audio_choice)
self.action_midi = self.port_types_menu.addAction(
_translate('patchbay', 'MIDI only'))
self.action_midi.setCheckable(True)
self.action_midi.setChecked(port_types_view == GROUP_CONTEXT_MIDI)
self.action_midi.triggered.connect(
self.port_types_view_midi_choice)
self.addMenu(self.port_types_menu)
self.zoom_menu = QMenu(_translate('patchbay', 'Zoom'), self)
self.zoom_menu.setIcon(QIcon.fromTheme('zoom'))
self.autofit = self.zoom_menu.addAction(
_translate('patchbay', 'auto-fit'))
self.autofit.setIcon(QIcon.fromTheme('zoom-select-fit'))
self.autofit.setShortcut('Home')
self.autofit.triggered.connect(patchcanvas.canvas.scene.zoom_fit)
self.zoom_in = self.zoom_menu.addAction(
_translate('patchbay', 'Zoom +'))
self.zoom_in.setIcon(QIcon.fromTheme('zoom-in'))
self.zoom_in.setShortcut('Ctrl++')
self.zoom_in.triggered.connect(patchcanvas.canvas.scene.zoom_in)
self.zoom_out = self.zoom_menu.addAction(
_translate('patchbay', 'Zoom -'))
self.zoom_out.setIcon(QIcon.fromTheme('zoom-out'))
self.zoom_out.setShortcut('Ctrl+-')
self.zoom_out.triggered.connect(patchcanvas.canvas.scene.zoom_out)
self.zoom_orig = self.zoom_menu.addAction(
_translate('patchbay', 'Zoom 100%'))
self.zoom_orig.setIcon(QIcon.fromTheme('zoom'))
self.zoom_orig.setShortcut('Ctrl+1')
self.zoom_orig.triggered.connect(patchcanvas.canvas.scene.zoom_reset)
self.addMenu(self.zoom_menu)
self.action_refresh = self.addAction(
_translate('patchbay', "Refresh the canvas"))
self.action_refresh.setIcon(QIcon.fromTheme('view-refresh'))
self.action_refresh.triggered.connect(patchbay_manager.refresh)
self.action_manual = self.addAction(
_translate('patchbay', "Patchbay manual"))
self.action_manual.setIcon(QIcon.fromTheme('system-help'))
self.action_manual.triggered.connect(self.internal_manual)
self.action_options = self.addAction(
_translate('patchbay', "Canvas options"))
self.action_options.setIcon(QIcon.fromTheme("configure"))
self.action_options.triggered.connect(
patchbay_manager.show_options_dialog)
