def bzr_qcommands(c, p, menu):
"""see module docs."""
menu = menu.addMenu("bzr")
# special case, no q* command for stat
def bzr_stat(c=c, p=p):
path = g.scanAllAtPathDirectives(c, p) or c.getNodePath(p)
cmd = subprocess.Popen(['bzr', 'stat', path],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = cmd.communicate()
g.es("\n\n".join([stdout, stderr]))
action = menu.addAction('stat')
action.connect(action, QtCore.SIGNAL("triggered()"), bzr_stat)
qcoms = "qadd qannotate qbind qbranch qbrowse qcat qcommit qconfig " \
"qconflicts qdiff qexport qgetnew qgetupdates qinfo qinit " \
"qlog qmerge qplugins qpull qpush qrevert qrun qsend " \
"qswitch qtag qunbind quncommit qupdate qversion qviewer".split()
for qcom in qcoms:
def cmd(c=c, p=p, qcom=qcom):
path = g.scanAllAtPathDirectives(c, p) or c.getNodePath(p)
cmd = subprocess.Popen(['bzr', qcom, path])
cmd.communicate()
action = menu.addAction(qcom)
action.connect(action, QtCore.SIGNAL("triggered()"), cmd)
def start (self,event):
c = self.c
# Create the callback to insert the selected completion.
def completion_callback(completion,self=self):
self.end(completion)
# Create the completer.
cpl = c.frame.top.completer = self.completer = QCompleter()
cpl.setWidget(self.body)
cpl.connect(cpl,QtCore.SIGNAL("activated(QString)"),completion_callback)
# Connect key strokes to the popup.
# self.popup = cpl.popup()
# self.popup_filter = PopupEventFilter(c,self.popup) # Required
# self.popup.installEventFilter(self.popup_filter)
# self.popup.setFocus()
# Set the flag for the event filter: all keystrokes will go to cc.onKey.
self.active = True
self.ev_filter.ctagscompleter_active = True
self.ev_filter.ctagscompleter_onKey = self.onKey
# Show the completions.
self.complete(event)
def connected(self):
'''Event handler for newConnection.'''
lprint("hnd con")
lsock = self.srv.nextPendingConnection()
lprint("conn", lsock)
buf = LProtoBuf()
self.ses[lsock] = ses_ent = {'_sock': lsock, '_buf': buf}
def msg_recv_cb(msg):
self.msg_received(msg, ses_ent)
buf.set_recv_cb( msg_recv_cb )
def readyread_cb():
lprint("read ready")
allbytes = lsock.readAll()
buf = ses_ent['_buf']
buf.push_bytes(allbytes)
lsock.connect(lsock,
QtCore.SIGNAL('readyRead()'),
readyread_cb)
def __init__(self):
self.srv = QtNetwork.QLocalServer()
self.receiver = None
self.ses = {}
self.is_connected = self.srv.connect(self.srv,
QtCore.SIGNAL("newConnection()"),
self.connected)
def __init__(self, c, mode="nav", parent=None):
QtWidgets.QWidget.__init__(self, parent)
self.ui = qt_quicksearch.Ui_LeoQuickSearchWidget()
self.ui.setupUi(self)
# set to True after return is pressed in nav mode, to disable live updates until field is cleaned again
self.frozen = False
w = self.ui.listWidget
u = self.ui
cc = QuickSearchController(c, w, u)
self.scon = cc
if mode == "popout":
self.setWindowTitle("Go anywhere")
if 1:
self.ui.lineEdit.returnPressed.connect(self.selectAndDismiss)
else:
self.connect(self.ui.lineEdit,
QtCore.SIGNAL("returnPressed()"),
self.selectAndDismiss)
threadutil.later(self.ui.lineEdit.setFocus)
else:
if 1:
self.ui.lineEdit.returnPressed.connect(self.returnPressed)
else:
self.connect(self.ui.lineEdit,
QtCore.SIGNAL("returnPressed()"),
self.returnPressed)
if 1:
self.ui.lineEdit.textChanged.connect(self.liveUpdate)
else:
self.connect(self.ui.lineEdit,
QtCore.SIGNAL("textChanged(QString)"),
self.liveUpdate)
self.ev_filter = QuickSearchEventFilter(c, w, self.ui.lineEdit)
self.ui.lineEdit.installEventFilter(self.ev_filter)
self.c = c
def __init__(self, owner):
'''Ctor for backlinkQtUI class.'''
self.owner = owner
QtWidgets.QWidget.__init__(self)
uiPath = g.os_path_join(g.app.leoDir, 'plugins', 'Backlink.ui')
form_class, base_class = uic.loadUiType(uiPath)
self.owner.c.frame.log.createTab('Links', widget = self)
self.UI = form_class()
self.UI.setupUi(self)
u = self.UI
o = self.owner
if 1: # Compatible with PyQt5
u.markBtn.clicked.connect(o.mark)
u.swapBtn.clicked.connect(o.swap)
u.linkBtn.clicked.connect(self.linkClicked)
u.rescanBtn.clicked.connect(o.loadLinksInt)
u.dirLeftBtn.clicked.connect(self.dirClicked)
u.dirRightBtn.clicked.connect( self.dirClicked)
u.linkList.itemClicked.connect(self.listClicked)
u.deleteBtn.stateChanged.connect(o.deleteSet)
else: # old code
self.connect(u.markBtn,
QtCore.SIGNAL("clicked()"), o.mark)
self.connect(u.swapBtn,
QtCore.SIGNAL("clicked()"), o.swap)
self.connect(u.linkBtn,
QtCore.SIGNAL("clicked()"), self.linkClicked)
self.connect(u.rescanBtn,
QtCore.SIGNAL("clicked()"), o.loadLinksInt)
self.connect(u.dirLeftBtn,
QtCore.SIGNAL("clicked()"), self.dirClicked)
self.connect(u.dirRightBtn,
QtCore.SIGNAL("clicked()"), self.dirClicked)
self.connect(u.linkList,
QtCore.SIGNAL("itemClicked(QListWidgetItem*)"), self.listClicked)
self.connect(u.deleteBtn,
QtCore.SIGNAL("stateChanged(int)"), o.deleteSet)
def rclick_path_importfile(c, p, menu):
if not p.h.startswith('@path'):
return
def importfiles_rclick_cb():
aList = g.get_directives_dict_list(p)
path = c.scanAtPathDirectives(aList)
table = [
("All files", "*"),
("Python files", "*.py"),
]
# This is incomplete: files is not used.
# files = g.app.gui.runOpenFileDialog(c,
g.app.gui.runOpenFileDialog(c,
title="Import files",
filetypes=table,
defaultextension='.notused',
multiple=True)
print("import files from", path)
action = menu.addAction("Import files")
action.connect(action, QtCore.SIGNAL("triggered()"), importfiles_rclick_cb)
def start (self,event):
c = self.c
# Create the callback to insert the selected completion.
def completion_callback(completion,self=self):
# pylint: disable=maybe-no-member
self.end(completion)
# Create the completer.
cpl = c.frame.top.completer = self.completer = QCompleter()
cpl.setWidget(self.body)
cpl.connect(cpl,QtCore.SIGNAL("activated(QString)"),completion_callback)
# Set the flag for the event filter: all keystrokes will go to cc.onKey.
self.active = True
self.ev_filter.ctagscompleter_active = True
self.ev_filter.ctagscompleter_onKey = self.complete
# EKR: was self.onKey, which does not exist.
# Show the completions.
self.complete(event)
def popup(self, c, p, menu):
"""make popup menu entry for tree context menu"""
# pylint: disable=function-redefined
# several callbacks have the same name.
if c != self.c:
return # wrong commander
for cb, name in reversed(self.recent_moves):
a = QtGui.QAction(name, menu)
a.connect(a, QtCore.SIGNAL("triggered()"),
lambda cb=cb, name=name: self.do_wrap(cb, name))
menu.insertAction(menu.actions()[0], a)
pathmenu = menu.addMenu("Move")
# copy / cut to other outline
for txt, cut in ("Copy to...", False), ("Move to...", True):
sub = pathmenu.addMenu(txt)
# global targets
for target in g.app.db['_quickmove']['global_targets']:
a = sub.addAction(target['name'])
def cb(c2=target['unl'], cut=cut):
self.to_other(c2, cut=cut)
def wrap(cb=cb, name=txt.strip('.')+' '+target['name']):
self.do_wrap(cb, name)
a.connect(a, QtCore.SIGNAL("triggered()"), wrap)
# top of open outlines
for c2 in g.app.commanders():
a = sub.addAction("Top of " +
g.os_path_basename(c2.fileName()))
def cb(c2=c2, cut=cut):
self.to_other(c2, cut=cut)
def wrap(cb=cb, name=txt.strip('.')+' top of '+g.os_path_basename(c2.fileName())):
self.do_wrap(cb, name)
a.connect(a, QtCore.SIGNAL("triggered()"), wrap)
# bookmark to other outline
sub = pathmenu.addMenu("Bookmark to...")
# global targets
for target in g.app.db['_quickmove']['global_targets']:
a = sub.addAction(target['name'])
def cb(c2=target['unl'], cut=cut):
self.bookmark_other(c2)
def wrap(cb=cb, name="Bookmark to "+target['name']):
self.do_wrap(cb, name)
a.connect(a, QtCore.SIGNAL("triggered()"), wrap)
# top of open outlines
for c2 in g.app.commanders():
a = sub.addAction(g.os_path_basename(c2.fileName()))
def cb(c2=c2):
self.bookmark_other(c2)
def wrap(cb=cb, name="Bookmark to top of "+g.os_path_basename(c2.fileName())):
self.do_wrap(cb, name)
a.connect(a, QtCore.SIGNAL("triggered()"), wrap)
# actions within this outline
need_submenu = 'Move', 'Copy', 'Clone', 'Bookmark', 'Link'
current_kind = None
current_submenu = None
for name,dummy,command in self.local_imps:
kind = name.split()[0]
if kind in need_submenu:
if current_kind != kind:
current_submenu = pathmenu.addMenu(kind)
current_kind = kind
else:
current_submenu = pathmenu
a = current_submenu.addAction(name)
a.connect(a, QtCore.SIGNAL("triggered()"), command)
# add new global target, etc.
a = pathmenu.addAction("Add node as target")
a.connect(a, QtCore.SIGNAL("triggered()"),
lambda p=p: self.add_target(p))
a = pathmenu.addAction("Show targets")
a.connect(a, QtCore.SIGNAL("triggered()"),
lambda p=p: self.show_targets())
a = pathmenu.addAction("Read targets")
a.connect(a, QtCore.SIGNAL("triggered()"),
lambda p=p: self.read_targets())
def addButton (self, which, type_="move", v=None, parent=None):
'''Add a button that creates a target for future moves.'''
c = self.c
p = c.p
if v is None:
v = p.v
sc = scriptingController(c)
mb = quickMoveButton(self,v,which,type_=type_)
txt=self.txts[type_]
if parent: # find parent button
for i in self.buttons:
if i[0].target.gnx == parent:
parent = i[1]
break
else:
g.es('Move to button parent not found, placing at top level')
parent = None
header = v.anyAtFileNodeName() or v.h # drop @auto etc.
text = txt + ":" + header if txt else header
# createButton truncates text.
if parent and g.app.gui.guiName() == "qt":
pb = parent.button
rc = QtGui.QAction(text, pb)
rc.connect(rc, QtCore.SIGNAL("triggered()"), mb.moveCurrentNodeToTarget)
pb.insertAction(pb.actions()[0], rc) # insert at top
b = None
mb.has_parent = True
t = QtCore.QString(c.config.getString('mod_scripting_subtext') or '')
if not unicode(pb.text()).endswith(unicode(t)):
pb.setText(pb.text()+t)
else:
b = sc.createIconButton(
args=None,
text=text,
command = mb.moveCurrentNodeToTarget,
statusLine = '%s current node to %s child of %s' % (
type_.title(), which, v.h),
kind = "quick-move"
)
if g.app.gui.guiName() == "qt":
def cb_goto_target(event=None, c=c, v=v):
p = c.vnode2position(v)
c.selectPosition(p)
c.redraw()
def cb_set_parent(event=None, c=c, v=v, first=which, type_=type_):
c.quickMove.set_parent(v, first, type_)
def cb_permanent(event=None, c=c, v=v, type_=type_, first=which):
c.quickMove.permanentButton(v=v, type_=type_, first=first)
# def cb_clear(event=None, c=c, v=v):
# c.quickMove.clearButton(v)
for cb, txt in [
(cb_goto_target, 'Goto target'),
(cb_permanent, 'Make permanent'),
# (cb_clear, 'Clear permanent'),
(cb_set_parent, 'Set parent'),
]:
but = b.button
rc = QtGui.QAction(txt, but)
rc.connect(rc, QtCore.SIGNAL("triggered()"), cb)
but.insertAction(but.actions()[-1], rc)
# insert rc before Remove Button
self.buttons.append((mb,b))
def install_qt_quicksearch_tab(c):
#tabw = c.frame.top.tabWidget
wdg = LeoQuickSearchWidget(c, mode="nav")
qsWidgent = wdg
c.frame.log.createTab("Nav", widget=wdg)
#tabw.addTab(wdg, "QuickSearch")
def focus_quicksearch_entry(event):
c.frame.log.selectTab('Nav')
wdg.ui.lineEdit.selectAll()
wdg.ui.lineEdit.setFocus()
def focus_to_nav(event):
c.frame.log.selectTab('Nav')
wdg.ui.listWidget.setFocus()
def find_selected(event):
text = c.frame.body.wrapper.getSelectedText()
if text.strip():
wdg.ui.lineEdit.setText(text)
wdg.returnPressed()
focus_to_nav(event)
else:
focus_quicksearch_entry(event)
def nodehistory(event):
c.frame.log.selectTab('Nav')
wdg.scon.doNodeHistory()
def show_dirty(event):
c.frame.log.selectTab('Nav')
wdg.scon.doChanged()
def timeline(event):
c.frame.log.selectTab('Nav')
wdg.scon.doTimeline()
c.k.registerCommand('find-quick', None, focus_quicksearch_entry)
c.k.registerCommand('find-quick-selected', 'Ctrl-Shift-f', find_selected)
c.k.registerCommand('focus-to-nav', None, focus_to_nav)
c.k.registerCommand('find-quick-test-failures', None,
show_unittest_failures)
c.k.registerCommand('find-quick-timeline', None, timeline)
c.k.registerCommand('find-quick-changed', None, show_dirty)
c.k.registerCommand('history', None, nodehistory)
@g.command('marked-list')
def showmarks(event):
""" List marked nodes in nav tab """
#c.frame.log.selectTab('Nav')
wdg.scon.doShowMarked()
@g.command('go-anywhere')
def find_popout_f(event):
c = event['c']
w = LeoQuickSearchWidget(c, mode="popout", parent=c.frame.top)
topgeo = c.frame.top.geometry()
wid = topgeo.width()
w.setGeometry(wid / 2, 0, wid / 2, 500)
#w.setParent(c.frame.top)
#w.setWindowFlags(QtConst.FramelessWindowHint)
w.show()
w.setFocus(QtConst.OtherFocusReason)
#w.setGeometry(100,0,800,500)
c._popout = w
c.frame.nav = wdg
# make activating this tab activate the input box
def activate_input(idx, c=c):
wdg = c.frame.nav
tab_widget = wdg.parent().parent()
if tab_widget.currentWidget() == wdg:
wdg.ui.lineEdit.selectAll()
wdg.ui.lineEdit.setFocus()
# Careful: we may be unit testing.
if wdg and wdg.parent():
tab_widget = wdg.parent().parent()
if 1:
tab_widget.currentChanged.connect(activate_input)
else:
tab_widget.connect(tab_widget,
QtCore.SIGNAL("currentChanged(int)"),
activate_input)
def __init__(self, c, listWidget):
self.c = c
self.lw = w = listWidget # A QListWidget.
self.its = {} # Keys are id(w),values are tuples (p,pos)
self.worker = threadutil.UnitWorker()
self.frozen = False
def searcher(inp):
#print("searcher", inp)
if self.frozen:
return
exp = inp.replace(" ", "*")
res = self.bgSearch(exp)
return res
def dumper():
# always run on ui thread
if self.frozen:
return
out = self.worker.output
#print("dumper")
self.throttler.add(out)
def throttledDump(lst):
""" dumps the last output """
#print "Throttled dump"
# we do get called with empty list on occasion
if not lst:
return
if self.frozen:
return
hm, bm = lst[-1]
self.clear()
self.addHeadlineMatches(hm)
self.addBodyMatches(bm)
self.throttler = threadutil.NowOrLater(throttledDump)
self.worker.set_worker(searcher)
#self.worker.set_output_f(dumper)
self.worker.resultReady.connect(dumper)
self.worker.start()
if 1: # Compatible with PyQt5
# we want both single-clicks and activations (press enter)
w.itemActivated.connect(self.onActivated)
w.itemPressed.connect(self.onSelectItem)
w.currentItemChanged.connect(self.onSelectItem)
else:
# we want both single-clicks and activations (press enter)
w.connect(w, QtCore.SIGNAL("itemActivated(QListWidgetItem*)"),
self.onActivated)
w.connect(w, QtCore.SIGNAL("itemPressed(QListWidgetItem*)"),
self.onSelectItem)
w.connect(
w,
QtCore.SIGNAL(
"currentItemChanged(QListWidgetItem*,QListWidgetItem *)"),
self.onSelectItem)
