We are currently indexing your data, so search results may be incomplete until we finish.
|
|
# thgpbranch.py - embeddable widget for the PatchBranch extension
#
# Copyright 2009 Peer Sommerlund <peer.sommerlund@gmail.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2, incorporated herein by reference.
import os
import tempfile
import gtk
import gobject
from mercurial import cmdutil, extensions, util
from mercurial import commands as hg
import mercurial.ui
from tortoisehg.util.i18n import _
from tortoisehg.hgtk import hgcmd
from tortoisehg.hgtk import update
from tortoisehg.hgtk import gtklib, dialog
from tortoisehg.hgtk.logview import graphcell
# Patch Branch model enumeration
M_NODE = 0
M_IN_LINES = 1
M_OUT_LINES = 2
M_NAME = 3
M_STATUS = 4
M_TITLE = 5
M_MSG = 6
M_MSGESC = 7
# Patch Branch column enumeration
C_GRAPH = 0
C_STATUS = 1
C_NAME = 2
C_TITLE = 3
C_MSG = 4
class PBranchWidget(gtk.VBox):
__gproperties__ = {
'graph-column-visible': (gobject.TYPE_BOOLEAN,
'Graph',
'Show graph column',
False,
gobject.PARAM_READWRITE),
'status-column-visible': (gobject.TYPE_BOOLEAN,
'Status',
'Show status column',
False,
gobject.PARAM_READWRITE),
'name-column-visible': (gobject.TYPE_BOOLEAN,
'Name',
'Show name column',
False,
gobject.PARAM_READWRITE),
'title-column-visible': (gobject.TYPE_BOOLEAN,
'Title',
'Show title column',
False,
gobject.PARAM_READWRITE),
'message-column-visible': (gobject.TYPE_BOOLEAN,
'Title',
'Show title column',
False,
gobject.PARAM_READWRITE),
'show-internal-branches': (gobject.TYPE_BOOLEAN,
'ShowInternalBranches',
"Show internal branches",
False,
gobject.PARAM_READWRITE)
}
__gsignals__ = {
'repo-invalidated': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
()),
'patch-selected': (gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE,
(int, # revision number for patch head
str)) # patch name
}
def __init__(self, parentwin, repo, statusbar, accelgroup=None, tooltips=None):
gtk.VBox.__init__(self)
self.parent_window = parentwin
self.repo = repo
self.pbranch = extensions.find('pbranch')
self.statusbar = statusbar
# top toolbar
tbar = gtklib.SlimToolbar(tooltips)
## buttons
self.btn = {}
pmergebtn = tbar.append_button(gtk.STOCK_CONVERT,
_('Merge all pending dependencies'))
pmergebtn.connect('clicked', self.pmerge_clicked)
self.btn['pmerge'] = pmergebtn
pbackoutbtn = tbar.append_button(gtk.STOCK_GO_BACK,
_('Backout current patch branch'))
pbackoutbtn.connect('clicked', self.pbackout_clicked)
self.btn['pbackout'] = pbackoutbtn
reapplybtn = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
reapplybtn = tbar.append_button(gtk.STOCK_GO_FORWARD,
_('Backport part of a changeset to a dependency'))
reapplybtn.connect('clicked', self.reapply_clicked)
self.btn['reapply'] = reapplybtn
pnewbtn = tbar.append_button(gtk.STOCK_NEW,
_('Start a new patch branch'))
pnewbtn.connect('clicked', self.pnew_clicked)
self.btn['pnew'] = pnewbtn
pgraphbtn = tbar.append_button(gtk.STOCK_EDIT,
_('Edit patch dependency graph'))
pgraphbtn.connect('clicked', self.edit_pgraph_clicked)
self.btn['pnew'] = pnewbtn
## separator
tbar.append_space()
## drop-down menu
menubtn = gtk.MenuToolButton('')
menubtn.set_menu(self.create_view_menu())
tbar.append_widget(menubtn, padding=0)
self.btn['menu'] = menubtn
def after_init():
menubtn.child.get_children()[0].hide()
gtklib.idle_add_single_call(after_init)
self.pack_start(tbar, False, False)
# center pane
mainbox = gtk.VBox()
self.pack_start(mainbox, True, True)
## scrolled pane
pane = gtk.ScrolledWindow()
pane.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
pane.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(pane)
### patch list
#### patch list model
self.model = gtk.ListStore(
gobject.TYPE_PYOBJECT, # node info
gobject.TYPE_PYOBJECT, # in-lines
gobject.TYPE_PYOBJECT, # out-lines
str, # patch name
str, # patch status
str, # patch title
str, # patch message
str) # patch message escaped
#### patch list view
self.list = gtk.TreeView(self.model)
# To support old PyGTK (<2.12)
if hasattr(self.list, 'set_tooltip_column'):
self.list.set_tooltip_column(M_MSGESC)
self.list.connect('cursor-changed', self.list_sel_changed)
self.list.connect('button-press-event', self.list_pressed)
self.list.connect('row-activated', self.list_row_activated)
self.list.connect('size-allocate', self.list_size_allocated)
#### patch list columns
self.cols = {}
self.cells = {}
def addcol(header, col_idx, model_idx=None, right=False, resizable=False,
editable=False, editfunc=None, cell_renderer=None,
properties=[]):
header = (right and '%s ' or ' %s') % header
cell = cell_renderer or gtk.CellRendererText()
if editfunc:
cell.set_property('editable', editable)
cell.connect('edited', editfunc)
col = gtk.TreeViewColumn(header, cell)
if cell_renderer is None:
col.add_attribute(cell, 'text', model_idx)
col.set_resizable(resizable)
col.set_visible(self.get_property(self.col_to_prop(col_idx)))
if right:
col.set_alignment(1)
cell.set_property('xalign', 1)
for (property_name, model_index) in properties:
col.add_attribute(cell, property_name, model_index)
self.list.append_column(col)
self.cols[col_idx] = col
self.cells[col_idx] = cell
def cell_edited(cell, path, newname):
row = self.model[path]
patchname = row[M_NAME]
if newname != patchname:
self.qrename(newname, patch=patchname)
#### patch list columns and cell renderers
addcol(_('Graph'), C_GRAPH, resizable=True,
cell_renderer=graphcell.CellRendererGraph(),
properties=[("node", M_NODE),
("in-lines",M_IN_LINES),
("out-lines", M_OUT_LINES)]
)
addcol(_('St'), C_STATUS, M_STATUS)
addcol(_('Name'), C_NAME, M_NAME, editfunc=cell_edited)
addcol(_('Title'), C_TITLE, M_TITLE)
addcol(_('Message'), C_MSG, M_MSG)
pane.add(self.list)
## command widget
self.cmd = hgcmd.CmdWidget(style=hgcmd.STYLE_COMPACT,
tooltips=tooltips)
mainbox.pack_start(self.cmd, False, False)
# accelerator
if accelgroup:
# TODO
pass
### public functions ###
def refresh(self):
"""
Refresh the list of patches.
This operation will try to keep selection state.
"""
if not self.pbranch:
return
# store selected patch name
selname = None
model, paths = self.list.get_selection().get_selected_rows()
if len(paths) > 0:
selname = model[paths[0]][M_NAME]
# compute model data
self.model.clear()
opts = {'tips': True}
mgr = self.pbranch.patchmanager(self.repo.ui, self.repo, opts)
graph = mgr.graphforopts(opts)
if not self.get_property('show-internal-branches'):
graph = mgr.patchonlygraph(graph)
names = None
patch_list = graph.topolist(names)
in_lines = []
if patch_list:
dep_list = [patch_list[0]]
cur_branch = self.repo['.'].branch()
patch_status = {}
for name in patch_list:
patch_status[name] = self.pstatus(name)
for name in patch_list:
parents = graph.deps(name)
# Node properties
if name in dep_list:
node_column = dep_list.index(name)
else:
node_column = len(dep_list)
node_colour = patch_status[name] and '#ff0000' or 0
node_status = (name == cur_branch) and 4 or 0
node = (node_column, node_colour, node_status)
# Find next dependency list
my_deps = []
for p in parents:
if p not in dep_list:
my_deps.append(p)
next_dep_list = dep_list[:]
next_dep_list[node_column:node_column+1] = my_deps
# Dependency lines
shift = len(parents) - 1
out_lines = []
for p in parents:
dep_column = next_dep_list.index(p)
colour = 0 # black
if patch_status[p]:
colour = '#ff0000' # red
style = 0 # solid lines
out_lines.append((node_column, dep_column, colour, style))
for lines in in_lines:
(start_column, end_column, colour, style) = lines
if end_column == node_column:
# Deps to current patch end here
pass
else:
# Find line continuations
dep = dep_list[end_column]
dep_column = next_dep_list.index(dep)
out_lines.append((end_column, dep_column, colour, style))
stat = patch_status[name] and 'M' or 'C' # patch status
patchname = name
msg = self.pmessage(name) # summary
if msg:
msg_esc = gtklib.markup_escape_text(msg) # escaped summary (utf-8)
title = msg.split('\n')[0]
else:
msg_esc = None
title = None
self.model.append((node, in_lines, out_lines, patchname, stat,
title, msg, msg_esc))
# Loop
in_lines = out_lines
dep_list = next_dep_list
# restore patch selection
if selname:
iter = self.get_iter_by_patchname(selname)
if iter:
self.list.get_selection().select_iter(iter)
# update UI sensitives
self.update_sensitives()
# report status
status_text = ''
idle_text = None
if self.has_patch():
status_text = self.pending_merges() \
and _('pending pmerges') \
or _('no pending pmerges')
self.statusbar.set_text(status_text, 'pbranch')
self.statusbar.set_idle_text(idle_text)
def pgraph(self):
"""
[pbranch] Execute 'pgraph' command.
:returns: A list of patches and dependencies
"""
if self.pbranch is None:
return None
opts = {}
mgr = self.pbranch.patchmanager(self.repo.ui, self.repo, opts)
return mgr.graphforopts(opts)
def patch_list(self, opts={}):
"""List all patches in pbranch dependency DAG"""
mgr = self.pbranch.patchmanager(self.repo.ui, self.repo, opts)
graph = mgr.graphforopts(opts)
names = None
return graph.topolist(names)
def pending_merges(self):
"""Return True if there are pending pmerge operations"""
for patch in self.patch_list():
if self.pstatus(patch):
return True
return False
def pstatus(self, patch_name):
"""
[pbranch] Execute 'pstatus' command.
:param patch_name: Name of patch-branch
:retv: list of status messages. If empty there is no pending merges
"""
if self.pbranch is None:
return None
status = []
opts = {}
mgr = self.pbranch.patchmanager(self.repo.ui, self.repo, opts)
graph = mgr.graphforopts(opts)
heads = self.repo.branchheads(patch_name)
if len(heads) > 1:
status.append(_('needs merge of %i heads\n') % len(heads))
for dep, through in graph.pendingmerges(patch_name):
if through:
status.append(_('needs merge with %s (through %s)\n') %
(dep, ", ".join(through)))
else:
status.append(_('needs merge with %s\n') % dep)
for dep in graph.pendingrebases(patch_name):
status.append(_('needs update of diff base to tip of %s\n') % dep)
return status
def pmessage(self, patch_name):
"""
Get patch message
:param patch_name: Name of patch-branch
:retv: Full patch message. If you extract the first line
you will get the patch title. If the repo does not contain
message or patch, the function returns None
"""
opts = {}
mgr = self.pbranch.patchmanager(self.repo.ui, self.repo, opts)
try:
return mgr.patchdesc(patch_name)
except:
return None
def peditmessage(self, patch_name):
"""
Edit patch message
:param patch_name: Name of patch-branch
"""
if not patch_name in self.patch_list():
return
cmdline = ['hg', 'peditmessage', patch_name]
self.cmd.execute(cmdline, self.cmd_done)
def pdiff(self, patch_name):
"""
[pbranch] Execute 'pdiff --tips' command.
:param patch_name: Name of patch-branch
:retv: list of lines of generated patch
"""
opts = {}
mgr = self.pbranch.patchmanager(self.repo.ui, self.repo, opts)
graph = mgr.graphattips()
return graph.diff(patch_name, None, opts)
def pnew_ui(self):
"""
Create new patch.
Propmt user for new patch name. Patch is created
on current branch.
"""
parent = None
title = _('New Patch Name')
new_name = dialog.entry_dialog(parent, title)
if not new_name:
return False
self.pnew(new_name)
return True
def pnew(self, patch_name):
"""
[pbranch] Execute 'pnew' command.
:param patch_name: Name of new patch-branch
"""
if self.pbranch is None:
return False
self.pbranch.cmdnew(self.repo.ui, self.repo, patch_name)
self.emit('repo-invalidated')
return True
def pmerge(self, patch_name=None):
"""
[pbranch] Execute 'pmerge' command.
:param patch_name: Merge to this patch-branch
"""
if not self.has_patch():
return
cmdline = ['hg', 'pmerge']
if patch_name:
cmdline += [patch_name]
else:
cmdline += ['--all']
self.cmd.execute(cmdline, self.cmd_done)
def pbackout(self):
"""
[pbranch] Execute 'pbackout' command.
"""
assert False
def pfinish(self, patch_name):
"""
[pbranch] Execute 'pfinish' command.
The workdir must be clean.
The patch branch dependencies must be merged.
:param patch_name: A patch branch (not an internal branch)
"""
# Check preconditions for pfinish
assert self.is_patch(patch_name)
pmerge_status = self.pstatus(patch_name)
if pmerge_status != []:
dialog.error_dialog(self.parent_window,
_('Pending Pmerge'),
_('You cannot finish this patch branch unless you pmerge it first.\n'
'pmerge will solve the following issues with %(patch)s:\n'
'* %(issuelist)s') %
{'patch': patch_name,
'issuelist': '* '.join(pmerge_status)}
)
return
if not self.workdir_is_clean():
dialog.error_dialog(self.parent_window,
_('Uncommitted Local Changes'),
_('pfinish uses your working directory for temporary work.\n'
'Please commit your local changes before issuing pfinish.')
)
return
if hasattr(self.repo, 'mq') and len(self.repo.mq.applied) > 0:
dialog.error_dialog(self.parent_window,
_('Applied MQ patch'),
_('pfinish must be able to commit, but this is not allowed\n'
'as long as you have MQ patches applied.')
)
return
# Set up environment for mercurial commands
class CmdWidgetUi(mercurial.ui.ui):
def __init__(self, cmdLogWidget):
src = None
super(CmdWidgetUi, self).__init__(src)
self.cmdLogWidget = cmdLogWidget
def write(self, *args, **opts):
for a in args:
self.cmdLogWidget.append(str(a))
def write_err(self, *args, **opts):
for a in args:
self.cmdLogWidget.append(str(a), error=True)
def flush(self):
pass
def prompt(self, msg, choices=None, default="y"):
raise util.Abort("Internal Error: prompt not available")
def promptchoice(self, msg, choices, default=0):
raise util.Abort("Internal Error: promptchoice not available")
def getpass(self, prompt=None, default=None):
raise util.Abort("Internal Error: getpass not available")
repo = self.repo
ui = CmdWidgetUi(self.cmd.log)
old_ui = repo.ui
repo.ui = ui
# Commit patch to dependency
fd, patch_file_name = tempfile.mkstemp(prefix='thg-patch-')
patch_file = os.fdopen(fd, 'w')
patch_file.writelines(self.pdiff(patch_name))
patch_file.close()
upstream_branch = self.pgraph().deps(patch_name)[0]
hg.update(ui, repo, rev=upstream_branch)
hg.import_(ui, repo, patch_file_name, base='', strip=1)
os.unlink(patch_file_name)
# Close patch branch
hg.update(ui, repo, rev=patch_name)
hg.merge(ui, repo, upstream_branch)
msg = _('Patch branch finished')
hg.commit(ui, repo, close_branch=True, message=msg)
# Update GUI
repo.ui = old_ui
self.emit('repo-invalidated')
def has_pbranch(self):
""" return True if pbranch extension can be used """
return self.pbranch is not None
def has_patch(self):
""" return True if pbranch extension is in use on repo """
if not self.has_pbranch():
return False
g = self.pgraph()
return len(self.pbranch.patchonlygraph(g.mgr, g)._nodes) > 0
def is_patch(self, branch_name):
""" return True if branch is a patch. This excludes root branches
and internal diff base branches (for patches with multiple
dependencies. """
return self.has_pbranch() and self.pgraph().ispatch(branch_name)
def cur_branch(self):
""" Return branch that workdir belongs to. """
return self.repo.dirstate.branch()
def workdir_is_clean(self):
""" return True if the working directory is clean """
c = self.repo[None]
return not (c.modified() or c.added() or c.removed())
### internal functions ###
def get_iter_by_patchname(self, name):
""" return iter has specified patch name """
if name:
for row in self.model:
if row[M_NAME] == name:
return row.iter
return None
def get_path_by_patchname(self, name):
""" return path has specified patch name """
iter = self.get_iter_by_patchname(name)
if iter:
return self.model.get_path(iter)
return None
def update_sensitives(self):
""" Update the sensitives of entire UI """
def disable_pbranchcmd():
for name in ('pbackout', 'pmerge', 'pnew', 'reapply'):
self.btn[name].set_sensitive(False)
if self.pbranch:
self.list.set_sensitive(True)
self.btn['menu'].set_sensitive(True)
in_pbranch = True #TODO
is_merge = len(self.repo.parents()) > 1
self.btn['pmerge'].set_sensitive(in_pbranch)
self.btn['pbackout'].set_sensitive(in_pbranch)
self.btn['pnew'].set_sensitive(not is_merge)
self.btn['reapply'].set_sensitive(True)
else:
self.list.set_sensitive(False)
self.btn['menu'].set_sensitive(False)
disable_pbranchcmd()
def scroll_to_current(self):
"""
Scroll to current patch in the patch list.
If the patch is selected, it will do nothing.
"""
if self.list.get_selection().count_selected_rows() > 0:
return
curpatch = self.cur_branch()
if not curpatch:
return
path = self.get_path_by_patchname(curpatch)
if path:
self.list.scroll_to_cell(path)
def show_patch_cmenu(self, list, path):
"""Context menu for selected patch"""
row = self.model[path]
menu = gtk.Menu()
def append(label, handler=None):
item = gtk.MenuItem(label, True)
item.set_border_width(1)
if handler:
item.connect('activate', handler, row)
menu.append(item)
has_pbranch = self.has_pbranch()
is_current = self.has_patch() and self.cur_branch() == row[M_NAME]
is_patch = self.is_patch(row[M_NAME])
is_internal = self.pbranch.isinternal(row[M_NAME])
is_merge = len(self.repo.branchheads(row[M_NAME])) > 1
if has_pbranch and not is_merge and not is_internal:
append(_('_new'), self.pnew_activated)
if not is_current:
append(_('_goto (update workdir)'), self.goto_activated)
if is_patch:
append(_('_edit message'), self.edit_message_activated)
append(_('_rename'), self.rename_activated)
append(_('_delete'), self.delete_activated)
append(_('_finish'), self.finish_activated)
if len(menu.get_children()) > 0:
menu.show_all()
menu.popup(None, None, None, 0, 0)
def create_view_menu(self):
"""Top right menu for selection of columns and
view configuration."""
menu = gtk.Menu()
def append(item=None, handler=None, check=False,
active=False, sep=False):
if sep:
item = gtk.SeparatorMenuItem()
else:
if isinstance(item, str):
if check:
item = gtk.CheckMenuItem(item)
item.set_active(active)
else:
item = gtk.MenuItem(item)
item.set_border_width(1)
if handler:
item.connect('activate', handler)
menu.append(item)
return item
def colappend(label, col_idx, active=True):
def handler(menuitem):
col = self.cols[col_idx]
col.set_visible(menuitem.get_active())
propname = self.col_to_prop(col_idx)
item = append(label, handler, check=True, active=active)
self.vmenu[propname] = item
self.vmenu = {}
colappend(_('Show graph'), C_GRAPH)
colappend(_('Show status'), C_STATUS, active=False)
colappend(_('Show name'), C_NAME)
colappend(_('Show title'), C_TITLE, active=False)
colappend(_('Show message'), C_MSG, active=False)
append(sep=True)
def enable_editable(item):
self.cells[C_NAME].set_property('editable', item.get_active())
item = append(_('Enable editable cells'), enable_editable,
check=True, active=False)
self.vmenu['editable-cell'] = item
item = append(_("Show internal branches"), lambda item: self.refresh(),
check=True, active=False)
self.vmenu['show-internal-branches'] = item
menu.show_all()
return menu
def show_dialog(self, dlg):
"""Show modal dialog and block application
See also show_dialog in history.py
"""
dlg.set_transient_for(self.parent_window)
dlg.show_all()
dlg.run()
if gtk.pygtk_version < (2, 12, 0):
# Workaround for old PyGTK (< 2.12.0) issue.
# See background of this: f668034aeda3
dlg.set_transient_for(None)
def update_by_row(self, row):
branch = row[M_NAME]
rev = cmdutil.revrange(self.repo, [branch])
parents = [x.node() for x in self.repo.parents()]
dialog = update.UpdateDialog(rev[0])
self.show_dialog(dialog)
self.update_completed(parents)
def update_completed(self, oldparents):
self.repo.invalidate()
self.repo.dirstate.invalidate()
newparents = [x.node() for x in self.repo.parents()]
if not oldparents == newparents:
self.emit('repo-invalidated')
def cmd_done(self, returncode, useraborted, noemit=False):
if returncode == 0:
if self.cmd.get_pbar():
self.cmd.set_result(_('Succeed'), style='ok')
elif useraborted:
self.cmd.set_result(_('Canceled'), style='error')
else:
self.cmd.set_result(_('Failed'), style='error')
self.refresh()
if not noemit:
self.emit('repo-invalidated')
def do_get_property(self, property):
try:
return self.vmenu[property.name].get_active()
except:
raise AttributeError, 'unknown property %s' % property.name
def do_set_property(self, property, value):
try:
self.vmenu[property.name].set_active(value)
except:
raise AttributeError, 'unknown property %s' % property.name
def col_to_prop(self, col_idx):
if col_idx == C_GRAPH:
return 'graph-column-visible'
if col_idx == C_STATUS:
return 'status-column-visible'
if col_idx == C_NAME:
return 'name-column-visible'
if col_idx == C_TITLE:
return 'title-column-visible'
if col_idx == C_MSG:
return 'message-column-visible'
return ''
### signal handlers ###
def list_pressed(self, list, event):
x, y = int(event.x), int(event.y)
pathinfo = list.get_path_at_pos(x, y)
if event.button == 1:
if not pathinfo:
# HACK: clear selection after this function calling,
# against selection by getting focus
def unselect():
selection = list.get_selection()
selection.unselect_all()
gtklib.idle_add_single_call(unselect)
elif event.button == 3:
if pathinfo:
self.show_patch_cmenu(self.list, pathinfo[0])
def list_sel_changed(self, list):
path, focus = list.get_cursor()
row = self.model[path]
patchname = row[M_NAME]
try:
ctx = self.repo[patchname]
revid = ctx.rev()
except hglib.RepoError:
revid = -1
self.emit('patch-selected', revid, patchname)
def list_row_activated(self, list, path, column):
self.update_by_row(self.model[path])
def list_size_allocated(self, list, req):
if self.has_patch():
self.scroll_to_current()
def pbackout_clicked(self, toolbutton):
pass
def pmerge_clicked(self, toolbutton):
self.pmerge()
def pnew_clicked(self, toolbutton):
self.pnew_ui()
def reapply_clicked(self, toolbutton):
pass
def edit_pgraph_clicked(self, toolbutton):
opts = {} # TODO: How to find user ID
mgr = self.pbranch.patchmanager(self.repo.ui, self.repo, opts)
oldtext = mgr.graphdesc()
# run editor in the repository root
olddir = os.getcwd()
os.chdir(self.repo.root)
newtext = self.repo.ui.edit(oldtext, opts.get('user'))
os.chdir(olddir)
mgr.updategraphdesc(newtext)
### context menu signal handlers ###
def pnew_activated(self, menuitem, row):
"""Insert new patch after this row"""
if self.cur_branch() == row[M_NAME]:
self.pnew_ui()
return
# pnew from patch different than current
assert False
if self.wdir_modified():
# Ask user if current changes should be discarded
# Abort if user does not agree
pass
# remember prev branch
# Update to row[M_NAME]
# pnew_ui
# if aborted, update back to prev branch
pass
def edit_message_activated(self, menuitem, row):
self.peditmessage(row[M_NAME])
def goto_activated(self, menuitem, row):
self.update_by_row(row)
def delete_activated(self, menuitem, row):
assert False
def rename_activated(self, menuitem, row):
assert False
def finish_activated(self, menuitem, row):
self.pfinish(row[M_NAME])
|
Loading...