def setup_menus(self):
menubar = self.menuBar()
style = self.style()
file_menu = menubar.addMenu('File')
open_action = file_menu.addAction(
style.standardIcon(QStyle.SP_DialogOpenButton), 'Open PlXx.dat...')
open_action.setShortcut(QKeySequence('Ctrl+O'))
open_action.triggered.connect(self.open_file_dialog)
# open_action.setStatusTip('Open a dat file')
save_action = file_menu.addAction(
style.standardIcon(QStyle.SP_DialogSaveButton), 'Save')
save_action.setShortcut(QKeySequence('Ctrl+S'))
save_action.triggered.connect(self.save)
saveas_action = file_menu.addAction(
style.standardIcon(QStyle.SP_DialogSaveButton), 'Save As...')
saveas_action.setShortcut(QKeySequence('Ctrl+Shift+S'))
saveas_action.triggered.connect(self.saveas)
file_menu.addSeparator()
reload_action = file_menu.addAction(
style.standardIcon(QStyle.SP_BrowserReload), 'Reload From Disk')
reload_action.triggered.connect(self.reload)
close_action = file_menu.addAction(
style.standardIcon(QStyle.SP_DialogCloseButton), 'Close')
close_action.triggered.connect(self.close_current)
help_menu = menubar.addMenu('Help')
about_action = help_menu.addAction(
style.standardIcon(QStyle.SP_MessageBoxInformation), 'About...')
about_action.triggered.connect(self.about)
def __init__(self, parent, cover_flow):
QDialog.__init__(self, parent)
self._layout = QStackedLayout()
self.setLayout(self._layout)
self.setWindowTitle(_('Browse by covers'))
self.layout().addWidget(cover_flow)
geom = gprefs.get('cover_browser_dialog_geometry', bytearray(''))
geom = QByteArray(geom)
if not self.restoreGeometry(geom):
h, w = available_height()-60, int(available_width()/1.5)
self.resize(w, h)
self.action_fs_toggle = a = QAction(self)
self.addAction(a)
a.setShortcuts([QKeySequence('F11', QKeySequence.PortableText),
QKeySequence('Ctrl+Shift+F', QKeySequence.PortableText)])
a.triggered.connect(self.toggle_fullscreen)
self.action_esc_fs = a = QAction(self)
a.triggered.connect(self.show_normal)
self.addAction(a)
a.setShortcuts([QKeySequence('Esc', QKeySequence.PortableText)])
self.pre_fs_geom = None
cover_flow.setFocus(Qt.OtherFocusReason)
self.view_action = a = QAction(self)
iactions = parent.iactions
self.addAction(a)
a.setShortcuts(list(iactions['View'].menuless_qaction.shortcuts())+
[QKeySequence(Qt.Key_Space)])
a.triggered.connect(iactions['View'].menuless_qaction.trigger)
self.sd_action = a = QAction(self)
self.addAction(a)
a.setShortcuts(list(iactions['Send To Device'].
menuless_qaction.shortcuts()))
a.triggered.connect(iactions['Send To Device'].menuless_qaction.trigger)
def createMenu(self, menu):
'''
@param: menu QMenu
'''
self._window.removeActions(menu.actions())
menu.clear()
group = QActionGroup(menu)
act = menu.addAction(_('Bookmarks'), self._slotShowSideBar)
act.setCheckable(True)
act.setShortcut(QKeySequence('Ctrl+Shift+B'))
act.setData('Bookmarks')
act.setChecked(self._activeBar == 'Bookmarks')
group.addAction(act)
act = menu.addAction(_('History'), self._slotShowSideBar)
act.setCheckable(True)
act.setShortcut(QKeySequence('Ctrl+H'))
act.setData('History')
act.setChecked(self._activeBar == 'History')
group.addAction(act)
for key, sidebar in self._s_sidebars.items():
if not sidebar: continue
# QAction
act = sidebar.createMenuAction()
act.setData(key)
act.setChecked(self._activeBar == key)
act.triggered.connect(self._slotShowSideBar)
menu.addAction(act)
group.addAction(act)
self._window.addActions(menu.actions())
def __init__(self, img_data, parent=None):
QDialog.__init__(self, parent)
self.l = l = QGridLayout(self)
self.setLayout(l)
self.setWindowTitle(_('Trim Image'))
self.bar = b = QToolBar(self)
l.addWidget(b)
b.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
b.setIconSize(QSize(32, 32))
self.msg = la = QLabel('\xa0' + _(
'Select a region by dragging with your mouse on the image, and then click trim'
))
self.sz = QLabel('')
self.canvas = c = Canvas(self)
c.image_changed.connect(self.image_changed)
c.load_image(img_data)
self.undo_action = u = c.undo_action
u.setShortcut(QKeySequence(QKeySequence.Undo))
self.redo_action = r = c.redo_action
r.setShortcut(QKeySequence(QKeySequence.Redo))
self.trim_action = ac = self.bar.addAction(QIcon(I('trim.png')),
_('&Trim'), c.trim_image)
ac.setShortcut(QKeySequence('Ctrl+T'))
ac.setToolTip(
'%s [%s]' %
(_('Trim image by removing borders outside the selected region'),
ac.shortcut().toString(QKeySequence.NativeText)))
ac.setEnabled(False)
c.selection_state_changed.connect(self.selection_changed)
l.addWidget(c)
self.bar.addAction(self.trim_action)
self.bar.addSeparator()
self.bar.addAction(u)
self.bar.addAction(r)
self.bar.addSeparator()
self.bar.addWidget(la)
self.bar.addSeparator()
self.bar.addWidget(self.sz)
self.bb = bb = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb)
self.tok = b = bb.addButton(_('Trim and OK'),
QDialogButtonBox.ActionRole)
b.clicked.connect(self.trim_and_accept)
b.setIcon(self.trim_action.icon())
self.resize(QSize(900, 600))
geom = gprefs.get('image-trim-dialog-geometry', None)
if geom is not None:
self.restoreGeometry(geom)
self.setWindowIcon(self.trim_action.icon())
self.image_data = None
class Runner():
_window = None
_application = None
def __init__(self):
self._application = QApplication(sys.argv)
self._window = None
# Main Window Initialized..
try:
self._window = yali.gui.YaliWindow.Widget()
except yali.Error, msg:
ctx.logger.debug(msg)
sys.exit(1)
self._translator = QTranslator()
self._translator.load(
"qt_" + QLocale.system().name(),
QLibraryInfo.location(QLibraryInfo.TranslationsPath))
ctx.mainScreen = self._window
screens = self._get_screens(ctx.flags.install_type)
self._set_steps(screens)
# These shorcuts for developers :)
prevScreenShortCut = QShortcut(QKeySequence(Qt.SHIFT + Qt.Key_F1),
self._window)
nextScreenShortCut = QShortcut(QKeySequence(Qt.SHIFT + Qt.Key_F2),
self._window)
prevScreenShortCut.activated.connect(self._window.slotBack)
nextScreenShortCut.activated.connect(self._window.slotNext)
# VBox utils
ctx.logger.debug("Starting VirtualBox tools..")
#FIXME:sh /etc/X11/Xsession.d/98-vboxclient.sh
yali.util.run_batch("VBoxClient", ["--autoresize"])
yali.util.run_batch("VBoxClient", ["--clipboard"])
# Cp Reboot, ShutDown
yali.util.run_batch("cp", ["/sbin/reboot", "/tmp/reboot"])
yali.util.run_batch("cp", ["/sbin/shutdown", "/tmp/shutdown"])
# base connections
self._application.lastWindowClosed.connect(self._application.quit)
self._window.signalProcessEvents.connect(
self._application.processEvents) #hata olabilir
self._application.desktop().resized[int].connect(
self._reinit_screen) #hata olabilir
# Font Resize
fontMinusShortCut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_Minus),
self._window)
fontPlusShortCut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_Plus),
self._window)
fontMinusShortCut.activated.connect(self._window.setFontMinus)
fontPlusShortCut.activated.connect(self._window.setFontPlus)
def setupUi(self, *args): # {{{
self.resize(990, 670)
self.download_shortcut = QShortcut(self)
self.download_shortcut.setKey(QKeySequence('Ctrl+D',
QKeySequence.PortableText))
p = self.parent()
if hasattr(p, 'keyboard'):
kname = u'Interface Action: Edit Metadata (Edit Metadata) : menu action : download'
sc = p.keyboard.keys_map.get(kname, None)
if sc:
self.download_shortcut.setKey(sc[0])
self.swap_title_author_shortcut = s = QShortcut(self)
s.setKey(QKeySequence('Alt+Down', QKeySequence.PortableText))
self.button_box = bb = QDialogButtonBox(self)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
self.next_button = QPushButton(QIcon(I('forward.png')), _('Next'),
self)
self.next_button.setShortcut(QKeySequence('Alt+Right'))
self.next_button.clicked.connect(self.next_clicked)
self.prev_button = QPushButton(QIcon(I('back.png')), _('Previous'),
self)
self.prev_button.setShortcut(QKeySequence('Alt+Left'))
self.button_box.addButton(self.prev_button, bb.ActionRole)
self.button_box.addButton(self.next_button, bb.ActionRole)
self.prev_button.clicked.connect(self.prev_clicked)
bb.setStandardButtons(bb.Ok|bb.Cancel)
bb.button(bb.Ok).setDefault(True)
self.scroll_area = QScrollArea(self)
self.scroll_area.setFrameShape(QScrollArea.NoFrame)
self.scroll_area.setWidgetResizable(True)
self.central_widget = QTabWidget(self)
self.scroll_area.setWidget(self.central_widget)
self.l = QVBoxLayout(self)
self.setLayout(self.l)
self.l.addWidget(self.scroll_area)
ll = self.button_box_layout = QHBoxLayout()
self.l.addLayout(ll)
ll.addSpacing(10)
ll.addWidget(self.button_box)
self.setWindowIcon(QIcon(I('edit_input.png')))
self.setWindowTitle(BASE_TITLE)
self.create_basic_metadata_widgets()
if len(self.db.custom_column_label_map):
self.create_custom_metadata_widgets()
self.do_layout()
geom = gprefs.get('metasingle_window_geometry3', None)
if geom is not None:
self.restoreGeometry(bytes(geom))
def create_context_menu(self):
m = QMenu(self)
m.addAction(_('Set date to undefined') + '\t' + QKeySequence(Qt.Key_Minus).toString(QKeySequence.NativeText),
self.clear_date)
m.addAction(_('Set date to today') + '\t' + QKeySequence(Qt.Key_Equal).toString(QKeySequence.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m, use_self_for_copy_actions=True)
return m
def keysequence_from_event(ev): # {{{
k, mods = ev.key(), int(ev.modifiers())
if k in (0, Qt.Key.Key_unknown, Qt.Key.Key_Shift, Qt.Key.Key_Control,
Qt.Key.Key_Alt, Qt.Key.Key_Meta, Qt.Key.Key_AltGr,
Qt.Key.Key_CapsLock, Qt.Key.Key_NumLock, Qt.Key.Key_ScrollLock):
return
letter = QKeySequence(k).toString(QKeySequence.SequenceFormat.PortableText)
if mods & Qt.Modifier.SHIFT and letter.lower() == letter.upper():
# Something like Shift+* or Shift+> we have to remove the shift,
# since it is included in keycode.
mods = mods & ~Qt.Modifier.SHIFT
return QKeySequence(k | mods)
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(
_('Set date to undefined') + '\t' +
QKeySequence(Qt.Key_Minus).toString(QKeySequence.NativeText),
self.clear_date)
m.addAction(
_('Set date to today') + '\t' +
QKeySequence(Qt.Key_Equal).toString(QKeySequence.NativeText),
self.today_date)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def initUI(self):
#self._layout = QHBoxLayout(self)
self._widget = QWidget(self)
#self._layout.addWidget(self._widget)
self._menuBar = QMenuBar(self._widget)
exitAct = QAction(QIcon('exit.png'), '&Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(qApp.quit)
self.statusBar()
#menubar = self.menuBar()
menubar = self._menuBar
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(exitAct)
act = self._menuBar.addAction('test')
act.setShortcut(QKeySequence('Ctrl+M'))
def testCb():
print('hello')
act.triggered.connect(testCb)
act.setShortcutContext(Qt.WidgetShortcut)
print('_menuBar parent', self._menuBar.parent())
print('act parent', act.parent())
print('_widget parent', self._widget.parent())
#act.setParent(self)
#print(act.parent())
self.addAction(act)
# This is important for Qt.WidgetShortcut
# the Example is focused, and it's menu's act can trigger
# Qt.WidgetShortcut context action
#self.setFocus()
#act.parent().setFocus()
print('focusWidget', QApplication.focusWidget())
def cb():
tt = QApplication.focusWidget()
print(tt)
from PyQt5.Qt import QShortcut
self.short0 = QShortcut(QKeySequence('Ctrl+N'), self)
self.short0.activated.connect(cb)
self.setGeometry(300, 300, 300, 200)
self.setWindowTitle('Simple menu')
self.show()
def __init__(self, logger, opts, parent=None):
MainWindow.__init__(self, opts, parent)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
self.setWindowTitle(__appname__ + _(' - LRF viewer'))
self.logger = logger
self.opts = opts
self.create_document()
self.spin_box_action = self.spin_box = QSpinBox()
self.tool_bar.addWidget(self.spin_box)
self.tool_bar.addSeparator()
self.slider_action = self.slider = QSlider(Qt.Orientation.Horizontal)
self.tool_bar.addWidget(self.slider)
self.tool_bar.addSeparator()
self.search = SearchBox2(self)
self.search.initialize('lrf_viewer_search_history')
self.search_action = self.tool_bar.addWidget(self.search)
self.search.search.connect(self.find)
self.action_next_page.setShortcuts([
QKeySequence.StandardKey.MoveToNextPage,
QKeySequence(Qt.Key.Key_Space)
])
self.action_previous_page.setShortcuts([
QKeySequence.StandardKey.MoveToPreviousPage,
QKeySequence(Qt.Key.Key_Backspace)
])
self.action_next_match.setShortcuts(QKeySequence.StandardKey.FindNext)
self.addAction(self.action_next_match)
self.action_next_page.triggered[(bool)].connect(self.next)
self.action_previous_page.triggered[(bool)].connect(self.previous)
self.action_back.triggered[(bool)].connect(self.back)
self.action_forward.triggered[(bool)].connect(self.forward)
self.action_next_match.triggered[(bool)].connect(self.next_match)
self.action_open_ebook.triggered[(bool)].connect(self.open_ebook)
self.action_configure.triggered[(bool)].connect(self.configure)
self.spin_box.valueChanged[(int)].connect(self.go_to_page)
self.slider.valueChanged[(int)].connect(self.go_to_page)
self.graphics_view.setRenderHint(QPainter.RenderHint.Antialiasing,
True)
self.graphics_view.setRenderHint(QPainter.RenderHint.TextAntialiasing,
True)
self.graphics_view.setRenderHint(
QPainter.RenderHint.SmoothPixmapTransform, True)
self.closed = False
def _loadSettings(self):
settings = Settings()
# Url settings
settings.beginGroup('Web-URL-Settings')
self._homepage = settings.value('homepage', 'app:start', type=QUrl)
settings.endGroup()
# Browser Window settings
settings.beginGroup('Browser-View-Settings')
showStatusBar = settings.value('showStatusBar', False)
showBookmarksToolbar = settings.value('showBookmarksToolbar', False)
showNavigationToolbar = settings.value('showNavigationToolbar', True)
showMenuBar = settings.value('showMenuBar', False)
# Make sure both menubar and navigationbar are not hidden
if not showNavigationToolbar:
showMenuBar = True
settings.setValue('showMenubar', True)
settings.endGroup()
settings.beginGroup('Shortcuts')
self._useTabNumberShortcuts = settings.value('useTabNumberShortcuts',
True)
self._useSpeedDialNumberShortcuts = settings.value(
'useSpeedDialNumberShortcuts', True)
self._useSingleKeyShortcuts = settings.value('useSingleKeyShortcuts',
False)
settings.endGroup()
settings.beginGroup('Web-Browser-Settings')
quitAction = self._mainMenu.action('Standard/Quit')
if settings.value('closeAppWithCtrlQ', True):
quitAction.setShortcut(
gVar.appTools.actionShortcut(QKeySequence.Quit,
QKeySequence('Ctrl+Q')))
else:
quitAction.setShortcut(QKeySequence())
settings.endGroup()
self._statusBarVisible = showStatusBar
self.statusBar().setVisible(not self.isFullScreen() and showStatusBar)
self._bookmarksToolbar.setVisible(showBookmarksToolbar)
self._navigationToolbar.setVisible(showNavigationToolbar)
if not const.OS_MACOS:
self._menuBarVisible = showMenuBar
self.menuBar().setVisible(not self.isFullScreen() and showMenuBar)
showSuperMenu = self.isFullScreen() or not showMenuBar
# TODO: debug code
showSuperMenu = True
self._navigationToolbar.setSuperMenuVisible(showSuperMenu)
def key_press_event(self, ev, which=0):
code = ev.key()
if self.capture == 0 or code in (0, Qt.Key_unknown, Qt.Key_Shift,
Qt.Key_Control, Qt.Key_Alt,
Qt.Key_Meta, Qt.Key_AltGr,
Qt.Key_CapsLock, Qt.Key_NumLock,
Qt.Key_ScrollLock):
return QWidget.keyPressEvent(self, ev)
button = getattr(self, 'button%d' % which)
button.setStyleSheet('QPushButton { font-weight: normal}')
mods = int(ev.modifiers()) & ~Qt.KeypadModifier
txt = unicode(ev.text())
if txt and txt.lower() == txt.upper():
# We have a symbol like ! or > etc. In this case the value of code
# already includes Shift, so remove it
mods &= ~Qt.ShiftModifier
sequence = QKeySequence(code | mods)
button.setText(sequence.toString(QKeySequence.NativeText))
self.capture = 0
dup_desc = self.dup_check(sequence)
if dup_desc is not None:
error_dialog(self,
_('Already assigned'),
unicode(sequence.toString(QKeySequence.NativeText)) +
' ' + _('already assigned to') + ' ' + dup_desc,
show=True)
self.clear_clicked(which=which)
def setModelData(self, editor, model, index):
self.closeEditor.emit(editor, self.NoHint)
custom_keys = editor.custom_keys
sc = index.data(Qt.ItemDataRole.UserRole).data
if custom_keys is None:
candidates = []
for ckey in sc['default_keys']:
ckey = QKeySequence(ckey,
QKeySequence.SequenceFormat.PortableText)
matched = False
for s in editor.all_shortcuts:
if s is editor.shortcut:
continue
for k in s['keys']:
if k == ckey:
matched = True
break
if not matched:
candidates.append(ckey)
candidates = tuple(candidates)
sc['set_to_default'] = True
else:
sc['set_to_default'] = False
candidates = custom_keys
sc['keys'] = candidates
self.changed_signal.emit()
def key_press_event(self, ev, which=0):
code = ev.key()
if self.capture == 0 or code in (0, Qt.Key.Key_unknown,
Qt.Key.Key_Shift, Qt.Key.Key_Control,
Qt.Key.Key_Alt, Qt.Key.Key_Meta,
Qt.Key.Key_AltGr, Qt.Key.Key_CapsLock,
Qt.Key.Key_NumLock,
Qt.Key.Key_ScrollLock):
return QWidget.keyPressEvent(self, ev)
sequence = QKeySequence(code
| (int(ev.modifiers())
& (~Qt.KeyboardModifier.KeypadModifier)))
setattr(self, 'shortcut%d' % which, sequence)
self.clear_button(which)
self.capture = 0
dup_desc = self.dup_check(sequence, self.key)
if dup_desc is not None:
error_dialog(self,
_('Already assigned'),
unicode_type(
sequence.toString(
QKeySequence.SequenceFormat.NativeText)) +
' ' + _('already assigned to') + ' ' + dup_desc,
show=True)
self.clear_clicked(which=which)
def toggleTetris(self):
self.tetris = Dialog(_("Tetris"), None, True, QKeySequence(Qt.Key_F6))
_tetris = Tetris(self.tetris)
self.tetris.addWidget(_tetris)
self.tetris.resize(240, 500)
_tetris.start()
self.tetris.exec_()
def initialize(self, shortcut, all_shortcuts):
self.header.setText('<b>%s: %s</b>' %
(_('Customize'), shortcut['name']))
self.all_shortcuts = all_shortcuts
self.shortcut = shortcut
self.default_keys = [
QKeySequence(k, QKeySequence.SequenceFormat.PortableText)
for k in shortcut['default_keys']
]
self.current_keys = list(shortcut['keys'])
default = ', '.join([
unicode_type(k.toString(k.NativeText)) for k in self.default_keys
])
if not default:
default = _('None')
current = ', '.join([
unicode_type(k.toString(k.NativeText)) for k in self.current_keys
])
if not current:
current = _('None')
self.use_default.setText(
_('&Default: %(deflt)s [Currently not conflicting: %(curr)s]') %
dict(deflt=default, curr=current))
if shortcut['set_to_default']:
self.use_default.setChecked(True)
else:
self.use_custom.setChecked(True)
for key, which in zip(self.current_keys, [1, 2]):
button = getattr(self, 'button%d' % which)
button.setText(key.toString(key.NativeText))
def contextMenuEvent(self, ev):
menu = self.createStandardContextMenu()
for action in menu.actions():
parts = action.text().split('\t')
if len(parts) == 2 and QKeySequence(
QKeySequence.StandardKey.Paste).toString(
QKeySequence.SequenceFormat.NativeText) in parts[-1]:
menu.insertAction(action, self.action_paste_and_match_style)
break
else:
menu.addAction(self.action_paste_and_match_style)
st = self.text()
m = QMenu(_('Fonts'))
m.addAction(self.action_bold), m.addAction(
self.action_italic), m.addAction(self.action_underline)
menu.addMenu(m)
if st and st.strip():
self.create_change_case_menu(menu)
parent = self._parent()
if hasattr(parent, 'toolbars_visible'):
vis = parent.toolbars_visible
menu.addAction(
_('%s toolbars') % (_('Hide') if vis else _('Show')),
parent.toggle_toolbars)
menu.addSeparator()
menu.addAction(_('Smarten punctuation'), parent.smarten_punctuation)
menu.exec_(ev.globalPos())
def _ADD_CHECKABLE_ACTION(self, name, menu, icon, trName, slot, shortcut):
action = menu.addAction(icon, trName)
action.setShortcut(QKeySequence(shortcut))
action.setCheckable(True)
action.triggered.connect(slot)
self._actions[name] = action
return action
def index_to_key_sequence(idx):
mods = []
for i, x in enumerate(('ALT', 'CTRL', 'META', 'SHIFT')):
if idx[i] == 'y':
mods.append(x.capitalize())
mods.append(idx[4:])
return QKeySequence('+'.join(mods))
def create_action(self, spec=None, attr='qaction', shortcut_name=None):
if spec is None:
spec = self.action_spec
text, icon, tooltip, shortcut = spec
if icon is not None:
action = QAction(QIcon(I(icon)), text, self.gui)
else:
action = QAction(text, self.gui)
if attr == 'qaction':
if hasattr(self.action_menu_clone_qaction, 'rstrip'):
mt = unicode_type(self.action_menu_clone_qaction)
else:
mt = action.text()
self.menuless_qaction = ma = QAction(action.icon(), mt, self.gui)
ma.triggered.connect(action.trigger)
for a in ((action, ma) if attr == 'qaction' else (action,)):
a.setAutoRepeat(self.auto_repeat)
text = tooltip if tooltip else text
a.setToolTip(text)
a.setStatusTip(text)
a.setWhatsThis(text)
shortcut_action = action
desc = tooltip if tooltip else None
if attr == 'qaction':
shortcut_action = ma
if shortcut is not None:
keys = ((shortcut,) if isinstance(shortcut, string_or_bytes) else
tuple(shortcut))
if shortcut_name is None and spec[0]:
shortcut_name = unicode_type(spec[0])
if shortcut_name and self.action_spec[0] and not (
attr == 'qaction' and self.popup_type == QToolButton.InstantPopup):
try:
self.gui.keyboard.register_shortcut(self.unique_name + ' - ' + attr,
shortcut_name, default_keys=keys,
action=shortcut_action, description=desc,
group=self.action_spec[0])
except NameConflict as e:
try:
prints(unicode_type(e))
except:
pass
shortcut_action.setShortcuts([QKeySequence(key,
QKeySequence.PortableText) for key in keys])
else:
self.shortcut_action_for_context_menu = shortcut_action
if isosx:
# In Qt 5 keyboard shortcuts dont work unless the
# action is explicitly added to the main window
self.gui.addAction(shortcut_action)
if attr is not None:
setattr(self, attr, action)
if attr == 'qaction' and self.action_add_menu:
menu = QMenu()
action.setMenu(menu)
if self.action_menu_clone_qaction:
menu.addAction(self.menuless_qaction)
return action
def contextMenuEvent(self, ev):
m = QMenu(self)
m.addAction(_('Set to undefined') + '\t' + QKeySequence(Qt.Key_Space).toString(QKeySequence.NativeText),
self.clear_to_undefined)
m.addSeparator()
populate_standard_spinbox_context_menu(self, m)
m.popup(ev.globalPos())
def __init__(self):
QWidget.__init__(self)
self.v_box = QVBoxLayout()
self.v_dir = QVBoxLayout()
self.v_ext = QVBoxLayout()
self.v_av = QVBoxLayout()
self.H_default_save_dir = QHBoxLayout()
self.H_default_ext = QHBoxLayout()
self.H_av = QHBoxLayout()
self.H_save = QHBoxLayout()
self.settings = xml.ParseXMLSettings()
self.txt_default_dir = QLineEdit(self)
self.drpdwn_av = QComboBox(self)
self.drpdwn_ext = QComboBox(self)
self.shortcut = QShortcut(QKeySequence('Ctrl+W'), self)
self.shortcut.activated.connect(self.close)
self.initUI()
self.v_box.addSpacing(12)
self.H_av.addSpacing(12)
self.H_default_ext.addSpacing(12)
self.H_default_save_dir.addSpacing(12)
self.H_save.addSpacing(12)
self.setLayout(self.v_box)
self.setGeometry(200, 200, 250, 150)
self.setWindowTitle('Global Settings')
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.retranslateUi(self)
self.itemBlockSize = 25
self.menubar.setNativeMenuBar(False)
self.inboxSc = QShortcut(QKeySequence('Alt+1'), self)
self.mailSc = QShortcut(QKeySequence('Alt+2'), self)
self.closeSC1 = QShortcut(QKeySequence('Ctrl+W'), self)
self.closeSC2 = QShortcut(QKeySequence('Ctrl+Q'), self)
self.writeSc = QShortcut(QKeySequence('Ctrl+N'), self)
self._connectActions()
self.tabWidget.setCurrentIndex(0)
self.treeWidget.setFocus()
self.treeWidget.setStyleSheet("QTreeView::item { height: 22px }")
self.treeWidget.setColumnWidth(0, 250)
self.text = ""
centerPoint = QDesktopWidget().availableGeometry().center()
qtRectangle = self.frameGeometry()
qtRectangle.moveCenter(centerPoint)
self.move(qtRectangle.topLeft())
try:
self.inbox = inbox()
self.thread = Thread(target=self.inbox.refresh_mail)
self.getMessages()
self.getContacts()
self.decryption = decryption()
self.contactBook = contactBook()
if "--updatedTrue" in arg:
QMessageBox.about(self, "Security", "Updated Successfully!")
elif "--updatedFalse" in arg:
QMessageBox.about(
self, "Security",
"A Problem Occured While Updating\nPlease try again later!"
)
elif "--updatedEmpty" in arg:
QMessageBox.about(
self, "Security",
"You're already up-to-date.\nNo changes were made.")
except WizardError as e:
self.d = Dialog1(self)
self.d.textBrowser.setText(str(e))
self.d.show()
def choose_tab(self, key):
self.choose_tab_pending = None
if not self.tab_tree.activate_marked_tab(key):
if not key & Qt.Key_Escape:
key = QKeySequence(key).toString()
self.show_status_message(
_('No tab with mark: %s') % key, 5, 'error')
self.tab_tree.mark_tabs(unmark=True)
def _init(self):
self.setTitle('Hi&story')
icon = IconProvider.standardIcon(QStyle.SP_ArrowBack)
act = self.addAction(icon, '&Back', self._goBack)
act.setShortcut(
gVar.appTools.actionShortcut(QKeySequence.Back,
Qt.ALT + Qt.Key_Left,
QKeySequence.Forward,
Qt.ALT + Qt.Key_Right))
icon = IconProvider.standardIcon(QStyle.SP_ArrowForward)
act = self.addAction(icon, '&Forward', self._goForward)
act.setShortcut(
gVar.appTools.actionShortcut(QKeySequence.Forward,
Qt.ALT + Qt.Key_Right,
QKeySequence.Back,
Qt.ALT + Qt.Key_Left))
act = self.addAction(QIcon.fromTheme('go-home'), '&Home', self._goHome)
act.setShortcut(QKeySequence(Qt.ALT + Qt.Key_Home))
icon = QIcon.fromTheme('deep-history',
QIcon(':/icons/menu/history.svg'))
act = self.addAction(icon, 'Show &All History')
act.triggered.connect(self._showHistoryManager)
act.setShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_H))
self.addSeparator()
self.aboutToShow.connect(self._aboutToHide)
self.aboutToHide.connect(self._aboutToShow)
self._menuMostVisited = Menu('Most Visited', self)
self._menuMostVisited.aboutToShow.connect(self._aboutToShowMostVisited)
self._menuClosedTabs = Menu('Closed Tabs')
self._menuClosedTabs.aboutToShow.connect(self._aboutToShowClosedTabs)
self._menuClosedWindows = Menu('Closed Windows')
self._menuClosedWindows.aboutToShow.connect(
self._aboutToShowClosedWindows)
self.addMenu(self._menuMostVisited)
self.addMenu(self._menuClosedTabs)
self.addMenu(self._menuClosedWindows)
def _init(self):
self.setTitle('&Bookmarks')
act = self.addAction('Bookmark &This Page', self._bookmarkPage)
act.setShortcut(QKeySequence('Ctrl+D'))
self.addAction('Bookmark &All Tabs', self._bookmarkAllTabs)
act = self.addAction(QIcon.fromTheme('bookmarks-organize'),
'Organize &Bookmarks')
# NOTE: if use self.addAction(icon, label, self._showBookmarksManager)
# will cause connection random invalid, so here connect triggered
# separately.
act.triggered.connect(self._showBookmarksManager)
act.setShortcut(QKeySequence('Ctrl+Shift+O'))
self.addSeparator()
self.aboutToShow.connect(self._aboutToShow)
self.aboutToShow.connect(self._menuAboutToShow)
self.menuMiddleClicked.connect(self._menuMiddleClicked)
def actionShortcut(self, shortcut, fallBack, shortcutRtl=QKeySequence(),
fallbackRtl=QKeySequence()):
'''
@param: shortcut QKeySequence
@param: fallBack QKeySequence
@param: shortcutRtl QKeySequence
@param: fallbackRtl QKeySequence
@return: QKeySequence
'''
if QApplication.isRightToLeft() and (not shortcutRtl.isEmpty() or not fallbackRtl.isEmpty()):
if shortcutRtl.isEmpty():
return fallbackRtl
else:
return shortcutRtl
if not shortcut:
return fallBack
else:
return shortcut
def toggleConsole(self):
if not self.terminal:
terminal = QTermWidget()
terminal.setScrollBarPosition(QTermWidget.ScrollBarRight)
terminal.setColorScheme(1)
terminal.sendText("export TERM='xterm'\nclear\n")
self.terminal = Dialog(_("Terminal"), terminal, True,
QKeySequence(Qt.Key_F11))
self.terminal.resize(700, 500)
self.terminal.exec_()
def get_match(self, event_or_sequence, ignore=tuple()):
q = event_or_sequence
if isinstance(q, QKeyEvent):
q = QKeySequence(q.key()|(int(q.modifiers()) & (~Qt.KeyboardModifier.KeypadModifier)))
for key in self.order:
if key not in ignore:
for seq in self.get_sequences(key):
if seq.matches(q) == QKeySequence.SequenceMatch.ExactMatch:
return key
return None
