From 2d0fecacda6cb305238a5107a0445fc673b912fb Mon Sep 17 00:00:00 2001
From: Thomas Leonard <talex5@gmail.com>
Date: Tue, 13 May 2003 16:06:26 +0000
Subject: [PATCH] Loading files now adds the namespaces.

git-svn-id: http://dom-editor.googlecode.com/svn/branches/Gtk2@483 ef21e15d-ca94-4315-9c45-0d95b1b2e117
---
 Dome/Display.py    | 540 -----------------------------------------------------
 Dome/Display2.py   |   9 +-
 Dome/Model.py      |  32 +++-
 Dome/Namespaces.py |  39 +++-
 Dome/View.py       |  10 +-
 5 files changed, 73 insertions(+), 557 deletions(-)
 delete mode 100644 Dome/Display.py

diff --git a/Dome/Display.py b/Dome/Display.py
deleted file mode 100644
index e6acf56..0000000
--- a/Dome/Display.py
+++ /dev/null
@@ -1,540 +0,0 @@
-from rox import g, TRUE, FALSE
-from gnome import canvas
-from xml.dom import Node
-from constants import *
-import rox
-
-watch_cursor = g.gdk.Cursor(g.gdk.WATCH)
-no_cursor = g.gdk.Cursor(g.gdk.TCROSS)
-
-def set_busy(widget, busy = TRUE):
-	w = widget.window
-	if not w:
-		return
-	if busy:
-		w.set_cursor(watch_cursor)
-	else:
-		w.set_cursor(no_cursor)
-
-def wrap(str, width):
-	ret = ''
-	while len(str) > width:
-		i = str[:width].rfind(' ')
-		if i == -1:
-			i = width
-		ret = ret + str[:i + 1] + '\n'
-		str = str[i + 1:]
-	return ret + str
-
-cramped_indent = 16
-normal_indent = 24
-
-import __main__
-default_font = __main__.default_font
-
-class Display(canvas.Canvas):
-	def __init__(self, window, view):
-		canvas.Canvas.__init__(self)
-		self.view = None
-		self.parent_window = window
-		self.root_group = None
-		self.update_timeout = 0
-		self.update_nodes = {}			# Set of nodes to update on update_timeout
-		self.current_attrib = None		# Canvas group
-		self.node_to_group = {}
-
-		self.visible = 1
-
-		s = self.get_style().copy()
-		s.bg[g.STATE_NORMAL] = g.gdk.color_parse('old lace')
-		self.set_style(s)
-
-		self.connect('size-allocate', self.size_allocate)
-		self.connect('destroy', self.destroyed)
-		self.connect('button-press-event', self.bg_event)
-
-		self.set_view(view)
-
-		rox.app_options.add_notify(self.options_changed)
-	
-	def size_allocate(self, canvas, size):
-		x, y, width, height = self.get_allocation()
-		chains = self.parent_window.list.chains
-		if self.visible:
-			if width < 40:
-				self.visible = 0
-				chains.set_active(0)
-				print "hide"
-		else:
-			if width > 40:
-				self.visible = 1
-				self.update_all()
-				chains.set_active(1)
-				print "show"
-	
-	def set_view(self, view):
-		if self.view:
-			self.view.remove_display(self)
-		self.view = view
-		self.view.add_display(self)
-		self.update_all()
-	
-	def set_bounds(self):
-		m = 8
-
-		(x, y, w, h) = self.get_allocation()
-		w -= m * 2 + 1
-		h -= m * 2 + 1
-
-		#self.update_now()	# GnomeCanvas bug?
-		min_x, min_y, max_x, max_y = self.root().get_bounds()
-		if max_x - min_x < w:
-			max_x = min_x + w
-		if max_y - min_y < h:
-			max_y = min_y + h
-		self.set_scroll_region(min_x - m, min_y - m, max_x + m, max_y + m)
-		self.root().move(0, 0) # Magic!
-
-	def update_record_state(self):
-		self.parent_window.update_title()
-
-	def update_all(self, node = None):
-		if not node:
-			node = self.view.model.doc.documentElement
-
-		if node == self.view.root:
-			self.update_nodes = {node: None}
-		elif node not in self.update_nodes:
-			# Note: we don't eliminate duplicates (parent and child) nodes
-			# here because it takes *ages*
-			self.update_nodes[node] = None
-
-		if self.update_timeout or not self.visible:
-			return		# Going to update anyway...
-
-		if self.view.running():
-			self.update_timeout = g.timeout_add(2000, self.update_callback)
-		else:
-			self.update_timeout = g.timeout_add(10, self.update_callback)
-	
-	def do_update_now(self):
-		# Update now, if we need to
-		if self.update_timeout:
-			g.timeout_remove(self.update_timeout)
-			self.update_callback()
-			#self.update_timeout = g.timeout_add(10, self.update_callback)
-	
-	def update_callback(self):
-		print "update_callback"
-		self.update_timeout = 0
-		#print "Update...", self.update_nodes
-		set_busy(self)
-		try:
-			for node in self.update_nodes:
-				root = self.view.root
-				if node is not root and self.view.has_ancestor(node, root):
-					# The root is OK - the change is inside...
-					try:
-						group = self.node_to_group[node]
-						#if group.flags() & DESTROYED:
-						#	print "(group destroyed)"
-						#	raise Exception('Group destroyed')
-					except:
-						# Modified node not created yet.
-						# Don't worry, updating the parent later
-						# will fix it...
-						print "(node missing)"
-						pass
-					else:
-						# Can't delete all children, so create a new group
-						# instead.
-						parent = group.get_property('parent')
-						x = group.get_property('x')
-						y = group.get_property('y')
-						gr = parent.add(canvas.CanvasGroup, x = x, y = y)
-						group.destroy()
-						group.attrib_to_group = None
-						self.node_to_group[node] = gr
-						gr.connect('event', self.node_event, node)
-						
-						self.create_tree(node, gr, cramped = group.cramped)
-						self.auto_highlight(node, rec = 1)
-						self.child_group_resized(node)
-				else:
-					# Need to rebuild everything...
-					if self.root_group:
-						self.root_group.destroy()
-					self.node_to_group = {}
-					self.root_group = self.root().add(canvas.CanvasGroup, x = 0, y = 0)
-					group = self.root_group
-					node = self.view.root
-					group.connect('event', self.node_event, node)
-					print "creating tree..."
-					self.create_tree(node, group)
-					print "highlighting..."
-					self.auto_highlight(node, rec = 1)
-					print "done"
-			self.move_from()
-			self.set_bounds()
-			if self.view.current_nodes:
-				self.scroll_to_show(self.view.current_nodes[0])
-		finally:
-			set_busy(self, FALSE)
-			self.update_nodes = {}
-		#print "<update_callback"
-		return 0
-	
-	def child_group_resized(self, node):
-		"The group for this node has changed size. Work up the tree making room for "
-		"it (and put it in the right place)."
-		kids = []
-		if node == self.view.root or node not in self.node_to_group:
-			return
-		node = node.parentNode
-		if node not in self.node_to_group:
-			return
-		for n in node.childNodes:
-			try:
-				kids.append(self.node_to_group[n])
-			except KeyError:
-				pass
-		self.position_kids(self.node_to_group[node], kids)
-		self.child_group_resized(node)
-	
-	def auto_highlight(self, node, rec = 0):
-		a = {}
-		for x in self.view.current_nodes:
-			a[x] = None
-		cattr = self.view.current_attrib
-		def do(node):
-			"After creating the tree, everything is highlighted..."
-			try:
-				self.highlight(self.node_to_group[node], cattr == None and node in a)
-			except KeyError:
-				return
-			if rec:
-				map(do, node.childNodes)
-		do(node)
-
-	def options_changed(self):
-		if default_font.has_changed:
-			self.update_all()
-	
-	def destroyed(self, widget):
-		self.view.remove_display(self)
-		rox.app_options.remove_notify(self.options_changed)
-	
-	def create_attribs(self, attrib, group, cramped, parent):
-		group.text = group.add(canvas.CanvasText, x = 0, y = -6, anchor = g.ANCHOR_NW,
-					fill_color = 'grey40',
-					font = default_font.value,
-					text = "%s=%s" % (str(attrib.name), str(attrib.value)))
-		group.connect('event', self.attrib_event, parent, attrib)
-
-		#self.update_now()	# GnomeCanvas bug?
-		(lx, ly, hx, hy) = group.text.get_bounds()
-		group.rect = group.add(canvas.CanvasRect,
-					x1 = lx - 1, y1 = ly - 1, x2 = hx + 1, y2 = hy + 1,
-					fill_color = None)
-		group.rect.lower_to_bottom()
-	
-	def create_tree(self, node, group, cramped = 0):
-		if node.nodeType == Node.ELEMENT_NODE:
-			hidden = node.hasAttributeNS(None, 'hidden')
-		else:
-			hidden = FALSE
-
-		group.node = node
-		group.cramped = cramped
-		if hidden:
-			c = 'red'
-		elif node.nodeType == Node.TEXT_NODE:
-			c = 'lightblue'
-		else:
-			c = 'yellow'
-		group.add(canvas.CanvasEllipse, x1 = -4, y1 = -4, x2 = 4, y2 = 4,
-					fill_color = c, outline_color = 'black')
-		text = self.get_text(node)
-
-		hbox = node.nodeName == 'tr'
-		if cramped:
-			text = wrap(text, 32)
-		else:
-			text = wrap(text, 1000)
-		group.text = group.add(canvas.CanvasText, x = 10 , y = -6, anchor = g.ANCHOR_NW,
-					font = default_font.value,
-					fill_color = 'black', text = text)
-		self.node_to_group[node] = group
-
-		#self.update_now()	# GnomeCanvas bug?
-		(lx, ly, hx, hy) = group.text.get_bounds()
-		group.rect = group.add(canvas.CanvasRect,
-					x1 = -8 , y1 = ly - 1, x2 = hx + 1, y2 = hy + 1,
-					fill_color = 'blue')
-		#group.rect.hide()
-
-		if hbox:
-			cramped = 1
-
-		if node.nodeType == Node.ELEMENT_NODE:
-			group.attrib_to_group = {}
-			if not hidden:
-				ax = hx + 8
-				ay = 0
-				if not cramped:
-					l = 0
-					for key in node.attributes:
-						a = node.attributes[key]
-						value = a.value or ''
-						l += len(a.name) + len(value)
-					acramped = l > 80
-				else:
-					acramped = cramped
-				for key in node.attributes:
-					a = node.attributes[key]
-					gr = group.add(canvas.CanvasGroup, x = ax, y = ay)
-					self.create_attribs(a, gr, cramped, node)
-					#self.update_now()	# GnomeCanvas bug?
-					(alx, aly, ahx, ahy) = gr.get_bounds()
-					if acramped:
-						ay = ahy + 8
-						hy = ahy
-					else:
-						ax = ahx + 8
-					group.attrib_to_group[a] = gr
-		
-		group.hy = hy
-		kids = []
-		if not hidden:
-			for n in node.childNodes:
-				gr = group.add(canvas.CanvasGroup, x = 0, y = 0)
-				gr.connect('event', self.node_event, n)
-				self.create_tree(n, gr, cramped)
-				kids.append(gr)
-		
-		self.position_kids(group, kids)
-		group.rect.lower_to_bottom()
-	
-	def position_kids(self, group, kids):
-		if not kids:
-			return
-
-		#assert not group.flags() & DESTROYED
-		#for k in kids:
-		#	assert not k.flags() & DESTROYED
-
-		if group.cramped:
-			indent = cramped_indent
-		else:
-			indent = normal_indent
-
-		node = group.node
-		hy = group.hy
-
-		if hasattr(group, 'lines'):
-			for l in group.lines:
-				l.destroy()
-		group.lines = []
-
-		if node.nodeName != 'tr':
-			y = hy + 4
-			top = None
-			for gr in kids:
-				gr.set(x = 0, y = 0)
-				#self.update_now()	# GnomeCanvas bug?
-				(lx, ly, hx, hy) = gr.get_bounds()
-				y -= ly
-				lowest_child = y
-				gr.set(x = indent, y = y)
-				if not top:
-					top = y
-				y = y + hy + 4
-			diag = min(top, indent)
-
-			max_segment = 16000
-			points = (4, 4, diag, diag, indent, top, indent,
-					min(lowest_child, top + max_segment))
-			group.lines.append(group.add(canvas.CanvasLine,
-					points = points, fill_color = 'black', width_pixels = 1))
-			group.lines[-1].lower_to_bottom()
-			while points[-1] < lowest_child:
-				old_y = points[-1]
-				points = (indent, old_y, indent,
-					  min(old_y + max_segment, lowest_child))
-				group.lines.append(group.add(canvas.CanvasLine,
-					points = points, fill_color = 'black', width_pixels = 1))
-				group.lines[-1].lower_to_bottom()
-		else:
-			y = hy + 8
-			x = indent
-			for gr in kids:
-				gr.set(x = 0, y = 0)
-				#self.update_now()	# GnomeCanvas bug?
-				(lx, ly, hx, hy) = gr.get_bounds()
-				x -= lx
-				gr.set(x = x, y = y - ly)
-				group.lines.append(group.add(canvas.CanvasLine,
-						points = (x, y - 4, x, y - ly - 4),
-						fill_color = 'black',
-						width_pixels = 1))
-				right_child = x
-				x += hx - lx + 8
-			group.lines.append(group.add(canvas.CanvasLine,
-					points = (0, 4, 0, y - 4, right_child, y - 4),
-					fill_color = 'black',
-					width_pixels = 1))
-			group.lines[-1].lower_to_bottom()
-
-	def get_text(self, node):
-		if node.nodeType == Node.TEXT_NODE:
-			return node.nodeValue.strip()
-		elif node.nodeType == Node.ELEMENT_NODE:
-			return node.nodeName
-		elif node.nodeType == Node.COMMENT_NODE:
-			return node.nodeValue.strip()
-		elif node.nodeName:
-			return node.nodeName
-		elif node.nodeValue:
-			return '<noname>' + node.nodeValue
-		else:
-			return '<unknown>'
-	
-	def show_menu(self, bev):
-		pass
-
-	def bg_event(self, widget, event):
-		if event.type == g.gdk.BUTTON_PRESS and event.button == 3:
-			self.show_menu(event)
-			return 1
-
-	# 'group' and 'node' may be None (for the background)
-	def node_event(self, group, event, node):
-		if (event.type == g.gdk.BUTTON_PRESS or event.type == g.gdk._2BUTTON_PRESS) and event.button == 1:
-			self.do_update_now()
-			self.node_clicked(node, event)
-			return 1
-		return 0
-
-	def attrib_event(self, group, event, element, attrib):
-		if event.type != g.gdk.BUTTON_PRESS or event.button == 3:
-			return 0
-		self.do_update_now()
-		self.attrib_clicked(element, attrib, event)
-		return 1
-	
-	def node_clicked(self, node, event):
-		return
-	
-	def attrib_clicked(self, element, attrib, event):
-		return
-	
-	def move_from(self, old = []):
-		self.set_current_attrib(self.view.current_attrib)
-
-		new = self.view.current_nodes
-		for n in old:
-			if self.view.current_attrib or n not in new:
-				try:
-					self.highlight(self.node_to_group[n], FALSE)
-				except KeyError:
-					pass
-		if self.update_timeout or not self.visible:
-			return		# We'll highlight on the callback...
-		# We can update without structural problems...
-		if self.view.current_nodes:
-			self.scroll_to_show(self.view.current_nodes[0])
-		if self.view.current_attrib:
-			pass
-		else:
-			for n in new:
-				try:
-					self.highlight(self.node_to_group[n], TRUE)
-				except KeyError:
-					print "Warning: Node %s not in node_to_group" % n
-
-	def set_current_attrib(self, attrib):
-		"Select 'attrib' attribute node of the current node. None to unselect."
-		if self.current_attrib:
-			if self.current_attrib.get_property('parent'):
-				self.current_attrib.rect.set(fill_color = None)
-				self.current_attrib.text.set(fill_color = 'grey40')
-		if attrib:
-			try:
-				group = self.node_to_group[self.view.get_current()].attrib_to_group[attrib]
-				group.rect.set(fill_color = 'light blue')
-				group.text.set(fill_color = 'grey40')
-				self.current_attrib = group
-			except KeyError:
-				pass
-		else:
-			self.current_attrib = None
-	
-	def marked_changed(self, nodes):
-		"nodes is a list of nodes to be rechecked."
-		marked = self.view.marked
-		for n in nodes:
-			try:
-				group = self.node_to_group[n]
-				group.rect.set(outline_color = (n in marked and 'orange') or None)
-			except KeyError:
-				pass 	# Will regenerate later
-
-	def highlight(self, group, state):
-		node = group.node
-		if state:
-			#group.text.set(fill_color = 'white')
-			rfill = 'light blue'
-		else:
-			rfill = None
-
-		nt = node.nodeType
-		if nt == 1: #Node.ELEMENT_NODE:
-			group.text.set(fill_color = 'black')
-		elif nt == 3: #Node.TEXT_NODE:
-			group.text.set(fill_color = 'blue')
-		elif nt == 8: #Node.COMMENT_NODE:
-			group.text.set(fill_color = 'darkgreen')
-		else:
-			group.text.set(fill_color = 'red')
-
-		if node in self.view.marked:
-			oc = 'orange'
-		else:
-			oc = None
-		group.rect.set(fill_color = rfill, outline_color = oc)
-
-	def world_to_canvas(self, (x, y)):
-		"Canvas routine seems to be broken..."
-		mx, my, maxx, maxy = self.get_scroll_region()
-		return (x - mx, y - my)
-		
-	def scroll_to_show(self, node):
-		try:
-			group = self.node_to_group[node]
-		except KeyError:
-			return
-		#self.update_now()	# GnomeCanvas bug?
-		(lx, ly, hx, hy) = group.rect.get_bounds()
-		x, y = self.world_to_canvas(group.i2w(0, 0))
-		lx += x
-		ly += y
-		hx += x
-		hy += y
-		lx -= 16
-
-		sx, sy = self.get_scroll_offsets()
-		if lx < sx:
-			sx = lx
-		if ly < sy:
-			sy = ly
-
-		(x, y, w, h) = self.get_allocation()
-		hx -= w
-		hy -= h
-		
-		if hx > sx:
-			sx = hx
-		if hy > sy:
-			sy = hy
-		
-		self.scroll_to(sx, sy)
diff --git a/Dome/Display2.py b/Dome/Display2.py
index 5de015f..891d9a4 100644
--- a/Dome/Display2.py
+++ b/Dome/Display2.py
@@ -4,6 +4,7 @@ import rox
 from rox import g
 from xml.dom import Node
 import pango
+from constants import XMLNS_NAMESPACE
 
 import __main__
 default_font = __main__.default_font
@@ -13,7 +14,11 @@ def calc_node(display, node, pos):
 	if node.nodeType == Node.TEXT_NODE:
 		text = node.nodeValue.strip()
 	elif node.nodeType == Node.ELEMENT_NODE:
-		text = node.nodeName
+		if node.namespaceURI:
+			text = display.view.model.namespaces.prefix.get(node.namespaceURI, 'ERROR') + \
+				':' + node.localName
+		else:
+			text = node.localName
 	elif node.nodeType == Node.ATTRIBUTE_NODE:
 		text = ' %s=%s' % (unicode(node.name), unicode(node.value))
 	elif node.nodeType == Node.COMMENT_NODE:
@@ -265,6 +270,8 @@ class Display(g.HBox):
 					apos = [bbox[2] + 4, bbox[1]]
 					for key in node.attributes:
 						a = node.attributes[key]
+						if a.namespaceURI == XMLNS_NAMESPACE:
+							continue
 						abbox, draw_fn = calc_node(self, a, apos)
 						apos[0] = abbox[2] + 4
 						yield (a, abbox, draw_fn)
diff --git a/Dome/Model.py b/Dome/Model.py
index fdfddff..a194a15 100644
--- a/Dome/Model.py
+++ b/Dome/Model.py
@@ -89,13 +89,36 @@ class Model:
 		if data_to_load:
 			self.doc = implementation.createDocument(None, 'root', None)
 			if not root_program:
-				node = support.import_with_ns(self.doc, data_to_load)
+				node = self.import_with_ns(data_to_load)
 				self.doc.replaceChild(node, self.doc.documentElement)
 				self.strip_space()
 		
 		self.views = []		# Notified when something changes
 		self.locks = {}		# Node -> number of locks
 	
+	def import_with_ns(self, node):
+		"""Return a copy of node for this model. All namespaces used in the subtree
+		will have been added to the global namespaces list. Prefixes will have been changed
+		as required to avoid conflicts."""
+		doc = self.doc
+		def ns_clone(node, clone):
+			if node.nodeType != Node.ELEMENT_NODE:
+				return doc.importNode(node, 1)
+			if node.namespaceURI:
+				prefix = self.namespaces.ensure_ns(node.prefix, node.namespaceURI)
+				new = doc.createElementNS(node.namespaceURI,
+							  prefix + ':' + node.localName)
+			else:
+				new = doc.createElementNS(None, node.localName)
+			for a in node.attributes.values():
+				if a.namespaceURI == XMLNS_NAMESPACE: continue
+				new.setAttributeNS(a.namespaceURI, a.name, a.value)
+			for k in node.childNodes:
+				new.appendChild(clone(k, clone))
+			return new
+		new = ns_clone(node, ns_clone)
+		return new
+	
 	def clear_undo(self):
 		# Pop an (op_number, function) off one of these and call the function to
 		# move forwards or backwards in the undo history.
@@ -437,6 +460,13 @@ class Model:
 			return node.attributes[(namespaceURI, localName)]
 	
 	def prefix_to_namespace(self, node, prefix):
+		"Using attributes for namespaces was too confusing. Keep a global list instead."
+		try:
+			return self.namespaces.uri[prefix]
+		except KeyError:
+			raise Exception("Namespace '%s' is not defined. Choose "
+				"View->Show namespaces from the popup menu to set it." % prefix)
+		
 		"Use the xmlns attributes to workout the namespace."
 		nss = GetAllNs(node)
 		if nss.has_key(prefix):
diff --git a/Dome/Namespaces.py b/Dome/Namespaces.py
index 36921af..9b6d4da 100644
--- a/Dome/Namespaces.py
+++ b/Dome/Namespaces.py
@@ -8,12 +8,15 @@ fixed_ns = {'xml': XML_NAMESPACE, 'xmlns': XMLNS_NAMESPACE}
 class Namespaces(g.GenericTreeModel):
 	def __init__(self):
 		g.GenericTreeModel.__init__(self)
-		self.dict = dict(fixed_ns)
+		self.uri = dict(fixed_ns)
 		self.update_list()
 	
 	def update_list(self):
-		self.list = self.dict.keys()
+		self.list = self.uri.keys()
 		self.list.sort()
+		pre = self.prefix = {}
+		for p, u in self.uri.iteritems():
+			pre[u] = p
 	
 	def on_get_n_columns(self):
 		return 2
@@ -25,7 +28,7 @@ class Namespaces(g.GenericTreeModel):
 	def on_get_value(self, iter, column):
 		if column == 0:
 			return self.list[iter]
-		return self.dict[self.list[iter]]
+		return self.uri[self.list[iter]]
 	
 	def on_iter_nth_child(self, iter, n):
 		if iter == None:
@@ -43,16 +46,16 @@ class Namespaces(g.GenericTreeModel):
 			return iter + 1
 	
 	def __setitem__(self, prefix, uri):
-		if prefix in self.dict and self.dict[prefix] == uri:
+		if prefix in self.uri and self.uri[prefix] == uri:
 			return
 
 		assert prefix
 		if prefix in fixed_ns:
 			raise Exception('That namespace prefix cannot be changed')
 
-		modifed = prefix in self.dict
+		modifed = prefix in self.uri
 
-		self.dict[prefix] = uri
+		self.uri[prefix] = uri
 		self.update_list()
 		path = (self.list.index(prefix),)
 
@@ -66,9 +69,25 @@ class Namespaces(g.GenericTreeModel):
 		if prefix in fixed_ns:
 			raise Exception('This is a built-in namespace and cannot be deleted')
 		path = (self.list.index(prefix),)
-		del self.dict[prefix]
+		del self.uri[prefix]
 		self.update_list()
 		self.emit('row-deleted', path)
+	
+	def ensure_ns(self, suggested_prefix, uri):
+		"""Return the prefix for this URI. If none is set choose one (using suggested_prefix
+		if possible)."""
+		try:
+			return self.prefix[uri]
+		except KeyError:
+			if not suggested_prefix:
+				suggested_prefix = 'ns'
+			if suggested_prefix in self.uri:
+				x = 1
+				while suggested_prefix + `x` in self.uri: x += 1
+				suggested_prefix += `x`
+			self[suggested_prefix] = uri
+			print "Added", suggested_prefix, uri
+			return suggested_prefix
 
 class GUI(rox.Dialog):
 	def __init__(self, model):
@@ -83,11 +102,11 @@ class GUI(rox.Dialog):
 
 		def response(dialog, resp):
 			if resp == 1:
-				self.add_new(model.namespaces)
+				dialog.add_new(model.namespaces)
 			elif resp == 2:
-				self.delete_selected(tree.get_selection())
+				dialog.delete_selected(tree.get_selection())
 			else:
-				self.destroy()
+				dialog.destroy()
 		self.connect('response', response)
 		self.set_position(g.WIN_POS_MOUSE)
 		self.set_title('Namespaces for ' + `model.uri`)
diff --git a/Dome/View.py b/Dome/View.py
index d55e31b..bd6c9dc 100644
--- a/Dome/View.py
+++ b/Dome/View.py
@@ -610,7 +610,7 @@ class View:
 
 		ns = {}
 		if not ns:
-			ns = GetAllNs(self.current_nodes[0])
+			ns = GetAllNs(self.current_nodes[0])	 # XXX
 		ns['ext'] = FT_EXT_NAMESPACE
 		#print "ns is", ns
 		c = Context.Context(self.get_current(), processorNss = ns)
@@ -637,7 +637,7 @@ class View:
 			raise Beep
 		src = self.current_nodes[-1]
 		if not ns:
-			ns = GetAllNs(src)
+			ns = GetAllNs(src)	# XXX
 		ns['ext'] = FT_EXT_NAMESPACE
 		c = Context.Context(src, [src], processorNss = ns)
 		rt = XPath.Evaluate(path, context = c)
@@ -698,7 +698,7 @@ class View:
 				self.op_in_progress.cached_code = code
 
 		if not ns:
-			ns = GetAllNs(src)
+			ns = GetAllNs(src)	 # XXX
 		ns['ext'] = FT_EXT_NAMESPACE
 		c = Context.Context(src, [src], processorNss = ns)
 		
@@ -783,7 +783,7 @@ class View:
 			if self.op_in_progress and expr.find('@CURRENT@') == -1:
 				self.op_in_progress.cached_code = code
 
-		ns = GetAllNs(src)
+		ns = GetAllNs(src)	# XXX
 		ns['ext'] = FT_EXT_NAMESPACE
 		c = Context.Context(src, [src], processorNss = ns)
 		
@@ -1532,7 +1532,7 @@ class View:
 	def fail_if(self, xpath):
 		"""Evaluate xpath as a boolean, and fail if true."""
 		src = self.get_current()
-		ns = GetAllNs(src)
+		ns = GetAllNs(src)	# XXX
 		ns['ext'] = FT_EXT_NAMESPACE
 		c = Context.Context(src.parentNode, [src.parentNode], processorNss = ns)
 		
-- 
2.11.4.GIT