Esempio n. 1
0
class VirtView():
	'''class VirtView()
	THIS SHOULD PROBABLY MOVE INSIDE SBSTRING OBJECT
	AND BE RENAMED.
 
	This object holds a list that contains abstracted
	pointers that allow for a logical view of the foreign
	text in an SBString object.  
	If edits are made to the foreign text, new text
	entries will be appened to the end of the foreign list but the pointers 
	here will be ordered so that the intended logical view
	of the foreign text is preserved.  

	Example: the foreign list contains the text "abcdefghij", then I 
	insert "zz" after "d", which is offset 4.  The new text ("zz")
	is appended to the end of the foreign list object
	but the entry in this object becomes:
	   [[0, 4, 0], [0, 2, 1], [4, 9, 0]]
	The entry for [0, 2, 1] means to grab bytes 0-1 (which
	is python slice s[0:2]) from the string that is stored
	at index 1 in the foreign list.
	
	*range* format: [start, end, list_offset_for_text]	
	where start and end* are python *slice()* numbers that
	point into the text that is referenced by the list offset.
	'''
	class StateEntry(object):
		start_pt = None
		end_pt = None
		list_idx = None
		length = None
		def __init__(self, start_pt, end_pt, list_idx):
			object.__init__(self)
			self.start_pt = start_pt
			self.end_pt = end_pt
			self.list_idx = list_idx 
			self.length = self.end_pt - self.start_pt
		def __repr__(self):
			return('[' + str(self.start_pt) + ', ' + str(self.end_pt) \
				+ ', '+ str(self.list_idx) + ', ' + str(self.length) + ']')

	class StateDeRef(object):
		'''class StateDeRef()
		This class will hold some values that will help to
		translate an entry in the state list to an entry
		in the main list.  

		The state list holds range entries with [start, end]
		indexes (in python slice() format) that refer to
		entries in the main list object.

		state_offset = the zero-based offset into the state
		               object.
		state_adj    = a virtual offset that would point to
		               a logical value in the range [start, end].
		               For example, if the state entry is [10, 20]
		               and state_adj = 3, then the reference is to
		               an entry in the main list at offset 13, which
		               is 10 + 3.
		list_idx     = an index into self.l that corresponds to
		               self.state[state_offset][0] + state_adj.
		'''

		state_offset = None
		state_adj = None
		str_ptr = None
		list_idx = None
		def __init__(self, s_offset, s_adj, str_ptr, l_idx):
			'''StateDeRef.__init()
			'''
			object.__init__(self)
			self.state_offset = s_offset
			self.state_adj = s_adj
			self.str_ptr = str_ptr
			self.list_idx = l_idx
		def __iter__ (self): 
			# Maybe add a flag that will lock the objects from
			# being altered when iter is active?
			self.iterindex = 4
			return(self)
		def __next__(self):
			self.iterindex -= 1
			if self.iterindex == 4:
				return(self.state_offset)
			elif self.iterindex == 3:
				return(self.state_adj)
			elif self.iterindex == 2:
				return(self.str_ptr)
			elif self.iterindex == 1:
				return(self.list_idx)
			else:
				raise StopIteration

		def __repr__(self):
			return([repr(self.state_offset) + ', ' + repr(self.state_adj) \
					+ repr(self.str_ptr) + repr(self.list_idx)])

	def __init__(self, state_entry):
		'''VirtView.__init__()
		'''
		self.state = SBList([state_entry])
		# use self.get_state_id()
		#self.state_id = 1 # NOT USED??

	def __iter__ (self): 
		# Maybe add a flag that will lock the objects from
		# being altered when iter is active?
		self.iterindex = len(self.state)
		return(self)

	def __getitem__(self, i):
		return(self.state[i])

	def __len__(self):
		'''VirtView.__len__()
		Returns the number of saved states.
		'''
		return(len(self.state))

	def __next__ (self): 
		'''VirtView.__next__
		Returns a range object, which contains
		a start offset, end offset, and an id for 
		a string stored elsewhere.  The start/end
		pair follows python slice() notation where
		end is one greater than the value that will
		be returned when used as list[start : end]
		'''
		# return an object of type xxx with each iteration.
		if self.iterindex == 0:
			raise StopIteration
		self.iterindex -= 1
		##(s_offset, s_adj, l_idx) = self._get_vl_idx(self.iterindex)
		##return(self.state[l_idx])
		return(self.state[len(self.state) - self.iterindex])

	def __repr__(self):
		return(repr(self.state))


	def _get_vl_idx(self, str_offset, state_id=-1):
		'''VirtView._get_vl_idx()
		Return pointers into state and a dereferenced
		pointer into the the foreign list for the given
		character offset.

		If the character offset is beyond the 
		virtual length of the underlying object, this
		returns [None, None, None, None], which might mean 
		to append a proposed insert at the end of the list.
		'''
		if state_id == -1: state_id = self.get_state_id()
		#assert(state_id < (len(self.state) ))
		str_len = self.get_llen(state_id=state_id)
		if str_offset >= str_len: #l_list_len:
			return([None, None, None, None])
		# temp_str_offset will be the starting offset into the string
		# in the range of pointers at this state offset.  If temp_str_offset
		# is less than the desired offset, read the next range of
		# pointers from this state and see if the span of that range
		# adds enough to temp_str_offset to contain the desired offset.
		temp_str_offset = 0	
		l_adjust = None
		#print('SBSTring. char offset=' + str(str_offset) +' state: ' + repr(self.state))
		for s_offset in range(len(self.state)):
			# For each s_offset in the current state (s_offset
			# is an index into character offset
			# ranges entered into the current state).
			#
			# 'highest_str_offset' is the highest character offset that would
			# be captured by the tuple in self.state[state_id][s_offset].
			highest_str_offset = temp_str_offset + self.state[s_offset].end_pt \
				- self.state[s_offset].start_pt - 1
			if highest_str_offset < str_offset:
				# We have not scanned forward far enough to reach the
				# desired virtual row, advance the search row index:
				temp_str_offset = highest_str_offset + 1
			else:
				# The desired string offset is in this range
				#
				# Within the specified range, I want to find the entry
				# in l that is 'offset' from the first entry in
				# the current range, so the real data will be in
				# l[state[state_id][0] + l_adjust]
				l_adjust = str_offset - temp_str_offset 

				temp_str_offset += l_adjust
				break
		# Return 
		# 1) s_offset = (state offset) an offset into the current state that contains
		#    a range that spans the specified virtual row.
		# 2) l_adjust = an offset that should be added to the contents of
		#    state[s_offset][0] to point into l to
		#    find the specifed virtual row; e.g.:
		#    l[self.state[s_offset][0] + l_adjust]
		# 3) l_offset = the desired string? offset into the text object?
		#  
		# I think str_pt is now used to point to the character offset within
		# a chunk of text, and string_id is the index of the list entry in
		# the foreign list.
		str_pt = self.state[s_offset].start_pt + l_adjust
		string_id = self.state[s_offset].list_idx 
		# IS STRING_ID THE SAME AS str_pt?
		# THIS ASSERTION FAILED: assert(string_id == str_pt)
		sd = self.StateDeRef(s_offset, l_adjust,  str_pt, string_id)
		return(sd)

	def delete_state(self, s_offset, batch=False, state_id=-1):
		'''VirtView.delete_state()
		Delete a *range* item from the state.
		'''
		if state_id == -1: state_id = self.get_state_id()
		#del self.state[s_offset]
		self.state.delete(s_offset, state_id=state_id, batch=batch)
		return(0)

	def get_item(self, idx, state_id=-1):
		if state_id == -1:
			state_id = self.get_state_id()
		return(self.state.get_item(idx, state_id))

	def get_list(self):
		return(self.state.return_list())
	
	def get_llen(self, state_id=-1):
		'''VirtView.get_llen()
		Return the length of the virtual string in the
		specified state.
		'''
		if state_id == -1: state_id = self.get_state_id()
		llen = 0
		#for s in self.state: ################################ THIS DIDN'T WORK
		startt =  datetime.datetime.now()
		#for j in range(len(self.state)):
		#	s = self.state[j]
		# The 'for s in self.state' version was 25% faster than for j in range(len(self.state
		# but is still slow. I then stored the list len in SBList and reduce run time by
		# half.
		for s in self.state:
			# Remember that the last index is in python format is
			# is one greater than the real index of what will
			# be includuded in this state element.
			#print('adding virtual len of state ' + repr(s) + ' totlen = ' + str(len(self.state)))
			#llen += s[1] - s[0]
			# The change from calculating length to storing made no difference
			llen += s.length
		endt = datetime.datetime.now()
		#dprint('llen took ' + str((endt - startt).microseconds) )#+ ' for loop count: ' + str(j))
		return(llen)

	def get_range(self, s_offset=-1, v_row=-1, state_id=-1):
		'''VirtView.get_range()
		Given either a state_offset or a virtual row index,
		return the *range* entry, which contains  
		start, end, string_id (where start and end are in
		python slice() format).

		You must pass a keyword argument for either s_offset
		or v_row.
		'''
		if state_id == -1: state_id = self.get_state_id()
		if s_offset == -1:
			if v_row == -1:
				raise Exception('You must pass either a state offset or a v_row " \
					+ "as a keyword parameter to get_range')
			else:
				#(s_offset, s_adj, l_idx, str_idx) = self._get_vl_idx(v_row)
				sd = self._get_vl_idx(v_row)
				return(self.state[sd.state_offset])
		else:
			return(self.state[s_offset])

	def get_state_id(self):
		'''VirtView.et_state_id()
		This gets the state ID from the underlying SBLIst object
		that holds the state information.

		see also self.state.incr_state_id()
		'''
		return(self.state.get_state_id())

	def insert(self, v_row, state_entry, state_id=-1, batch=False,):
		'''VirtView.insert()
		l_range is now a state_entry object

		*range* points to a slice of a foreign list, but
		the contents of that slice will be displayed 
		starting at the specified virtual row.

		I think *range* contains [start, end] but I'm not sure.
		
		Insert the range into the state list, and ideally
		I should merge state entries if the starting or ending
		values inside *range* are contiguous to those entries
		near it in the *state* list.
		'''
		times = []
		#dprint('-----------------insert start')
		if state_id == -1:
			state_id = self.get_state_id()
		v_idx = 0
		s_offset = 0
		# * a *range* is a 3-item list like [5, 8, 2], the fist two
		#            numbers of which are 
		#            a 'slice()' referece to a range of entries in 
		#            a foreign list object that can be identifed with the third nbr.
		# * s_offset points to an existing *range* entry in self.state
		# * sd.state_adj is an offset between l_range[0] and l_range[1]
		# * list_idx is an offset into the foreign table where the associated
		#            virtual item (v_row) is stored. Its value is between
		#            l_range[0] and l_range[1]
		#
		# Length of the string before insertion.
		times.append(['a', datetime.datetime.now()])	
		virtual_len = self.get_llen(state_id=state_id)
		times.append(['b', datetime.datetime.now()])	
		if virtual_len == 0:
			# The state list can be empty if the user deleted everything,
			# but point to row zero to facilitate insert()
			v_row = 0
		#print('vv, vrow = ' + str(v_row) + ' len ' + str(virtual_len) + ' state: ' + repr(self.state))
		if v_row >= virtual_len:
			# Append the new row at the end of self.state, regardless of how far 
			# v_row exceeds the length of self.state 
			self.state.append(state_entry, state_id=state_id, batch=batch)
			return(0)
		# For the given virtual row, find the index into self.state. I think
		# l_row is a character offset
		#(s_offset, s_adj, l_row, string_id) = self._get_vl_idx(v_row)
		sd = self._get_vl_idx(v_row)
		assert(sd.list_idx is not None)
		if sd.state_adj == 0:
			# The new *range* item belongs at the start of an existing range
			# so insert the new item here:
			times.append(['c', datetime.datetime.now()])
			self.state.insert(sd.state_offset, state_entry, state_id=state_id, batch=batch)
			times.append(['c2', datetime.datetime.now()])
		else:
			if self.state[sd.state_offset].end_pt == v_row:
				# The new item goes after this state entry
				times.append(['d', datetime.datetime.now()])
				self.state.insert(sd.state_offset + 1, state_entry, state_id=state_id, batch=batch)
				times.append(['d2', datetime.datetime.now()])
			else:
				# split the old range entry
				low = self.state[sd.state_offset].start_pt
				high = self.state[sd.state_offset].end_pt
				# I think str_id is an offset into the sblist for an immutable string.
				str_id = self.state[sd.state_offset].list_idx
				self.state.delete(sd.state_offset, state_id=state_id, batch=batch)
				# The deletion above should have creatd a new state for the self.state object.
				# I should now use that for the remainin transactions in this batch:
				state_id = self.state.get_state_id()
				# Insert the lower part of the state entry:
				times.append(['e', datetime.datetime.now()])
				self.state.insert(sd.state_offset, self.StateEntry(low, low + sd.state_adj, sd.list_idx), 
					batch=True, state_id=state_id)# batch is always true here
				# Insert the entry for the newly inserted text:
				self.state.insert(sd.state_offset + 1, state_entry, batch=True, state_id=state_id)
				# Insert the top half of the old range that was split
				self.state.insert(sd.state_offset+ 2, self.StateEntry(low + sd.state_adj, high, sd.list_idx), 
					batch=True, state_id=state_id)
				times.append(['e2', datetime.datetime.now()])
		#for j in range(1, len(times)):
		#	#dprint(times[j][0] + ', ' + times[j - 1][0] + ' ' 
		#	#	+ repr((times[j][1] - times[j - 1][1]).microseconds))
		return(0)


	def insert_state(self, s_offset, state_entry, state_id=-1, batch=False):
		'''VirtView.insert_state()
		Insert a range object into self.state.
		This is intended to facilitate rewriting
		the state for deletions in the virual
		representation of the underlyling list.
		see also: delete_state()
		'''
		if state_id == -1: state_id = self.get_state_id()
		self.state.insert(s_offset, state_entry, state_id=state_id, batch=batch)
		return(0)

	def set_state_id(self, id):
		self.state.set_state_id(id)
		return(0)
	
	def show_state(self, state_id):
		'''VirtView.show_state()
		return some debugging info
		'''
		#return(self.state.show_state(state_id=state_id))
		return(repr(self.state))
Esempio n. 2
0
class SBStrList(object):
	'''class SBStrList()
	This is a list of strings that is built
	on state-based objects that facilitate
	undo().
	'''
	class StorageRef(object):
		storage_start = None
		storage_end = None
		logical_start = None
		logical_end = None
		def __init__(self):#, storage_range, logical_range):
			object.__init__(self)
			
	class LogEntry():
			'''class SBStrList.LogEntry
			This holds information about one edit action.
			The properties are populated according to what makes
			sense for the given action.

			t_pt is a pointer into the text of the current line,
			not a global text pointer.
			sbstr will be an SBString object for line-deletion transaction 
			or line cut/paste.

			Action codes:
				'i' for insert text, 
				'd' for delete text,
				'il' = insertline, 
				'dl' = delete line. 
			Possible future codes would be 'm' for move-a-line, or 'u' for
			updated. Update is currently processed by a deletion and 
			an insert.
			'''
			action = None
			time = None
			old_lstate = None
			new_lstate = None
			old_str_state = None
			new_str_state = None
			row_idx = None
			t_pt = None
			txt = None
			sbstr = None
			def __init__(self, action, time, old_lstate, new_lstate, old_str_state, \
				new_str_state, row_idx, del_count=None, t_pt=None, txt=None, sbstr=None):
				'''UndoChanges.__init__
				'''
				self.action = action
				self.time = time
				self.old_lstate = old_lstate
				self.new_lstate = new_lstate
				self.old_str_state = old_str_state
				self.new_str_state = new_str_state
				self.row_idx = row_idx
				# for text edits only (not line insertion or deletion:
				self.t_pt = t_pt
				self.txt = txt
				# for line deletion, cut and paste
				self.sbstr # a SBString object
			def __repr__(self):
				'''log.__repr__
				'''
				return('[' + self.action + ', ' + self.time.strftime("%Y %h %d %H:%M:%S.") \
					+ str(self.time.time().microsecond) + ', ' \
					+ str(self.old_lstate) + ', ' + str(self.new_lstate) + ', ' \
					+ str(self.old_str_state) + ', ' + str(self.new_str_state) + ', ' \
					+ str(self.row_idx) + ', ' + repr(self.t_pt) + ', ' 
					+ repr(self.txt) + ']\n')
					

	def __init__(self, ListOfStrings):
		'''SBStrList.__init__()
		'''
		# MAYBE I SHOULD CODE ATTRIBUTES WITH THE VALUE OF THE
		# CURRENT INSTANCE SO EVERYTHING CAN GRAB THE CURRENT
		# STATE_ID WITHOUT REQUIRING INPUT FROM THE USER -- is that needed?
		object.__init__(self)
	
	
		# Cast the strings as SBSTring objects and load into a new list.
		# I tried embedding this into SBList, but it caused a loop in the 
		# definitions of SBList and SBString.
		self.buff_len = SBList([0])
		temp_l = []
		for j in range(len(ListOfStrings)):
			#if ListOfStrings[j][-1] not in ['\n', '\r'] \
			#and j != (len(ListOfStrings) - 1):
			#	temp_l.append(SBString(ListOfStrings[j]) + '\n')
			#else:
			if ListOfStrings[j][0:-1].count('\n') > 0:
				raise Exception('Your test string contains an embedded EOL in mid-line.')
			temp_l.append(SBString(ListOfStrings[j]))
			self.buff_len[0] += len(ListOfStrings[j])
		self.l = SBList(temp_l)
		#
		self.state_id = 0
		self.point = SBList([0])
		# The main state_id for SBStrList will be the state_id for
		# self.log?  To show the undo list of self.log, display
		# only values in the range self.log[0:self.log.get_state_id].
		# I might have to review how transactions
		# are chunked (such as 'replace' or 'update' transactions).
		self.log = SBList([]) 
		# Maybe use a list or function that lists all the 
		# objects that contain range-based lists so that users
		# can create one and have it automatically updated.
		self.range_lists = []
		self.range_funcs = []
		self.bookmarks = SBList([])
		# The *statements* field might be used to store the start and
		# end points of comment blocks or full statements in a
		# programming language. It might help the logic for applying
		# the syntax highligher by telling it to start on a prior line.
		self.statements = SBList([])
		self.range_lists.append(self.bookmarks)
		self.range_lists.append(self.statements)
		
		self.line_pts = None
		self.rebuild_line_pts()
		tmp_lp = None
		self.range_lists.append(self.line_pts)

	def __getitem__(self, x):
		# This returns an item from the main list based
		# on the virtual row index, *x*.	That index
		# can be a slice(), which is a range() specifed
		# in python format (i.e., the last index is one
		# greater than what you want returned).
		if x > len(self):
			raise IndexError
		if type(x) == type(slice(1,2)):
			temp = []
			if x.step is None:
				step = 1
			else:
				step = x.step
			for j in range(x.start, x.stop, step):
				temp.append(self.l[self.get_lrow_idx(j)])
			return(temp)
		else:
			# The requested item is not a slice:
			return(self.l[x])
			#return(self.l[self.get_lrow_idx(x)])

	def __iter__ (self): 
		# Maybe add a flag that will lock the objects from
		# being altered when iter is active?
		self.iterindex = len(self.l)
		return(self)

	def __len__(self):
		'''SBStrList.__len__()
		Returns the length of the virtual list object.
		'''
		return(len(self.l))

	
	def __next__ (self): 
		'''SBStrList.__next__()
		Return a list entry with each call.
		'''
		self.iterindex -= 1
		if self.iterindex < 0:
			raise StopIteration
		#
		# the countdown starts at the maximum value, but I want
		# to reverse the index to start at zero:
		new_idx = len(self.l) - self.iterindex - 1
		return(self.l[new_idx])

	def __repr__(self):
		#s = ''
		tmp_l = []
		for j in range(self.line_count()):
			#s += self.l[j].get_string()
			tmp_l.append(self.l[j].get_string())
		return(''.join(tmp_l))

	def __len__(self):
		return(len(self.l))

	def _dump(self, msg):
		'''SBStrList._dump()
		Dump many important objects to sys.stderr

		Run this program from the command line like this:
		env python sbed02.py -f infile.txt 2> debug.log
		where 2> is the redirection for stderr.
		'''
		dprint('---------------------------------------DUMP START')
		dprint(msg)
		dprint('')
		dprint('state_id= ' + str(self.state_id))
		dprint('point state id=' + str(self.point.get_state_id()) +' contents = ' + repr(self.point))
		dprint('log state id =' + str(self.log.get_state_id()) + ' contents=\n' + repr(self.log))
		dprint('line_pts state id= ' + str(self.line_pts.get_state_id()) + ', contents:\n' + repr(self.line_pts))
		dprint('self.l:\n' + repr(self.l))
		return(0)

	def add_bookmark(self, range):
		pass

	def add_statement(self, range):
		pass

	def add_range_list(self, lst):
		'''SBStrList.add_range_list(
		Add a list object that contains [start, end]
		pointers into the text using python slice()
		format.

		Lists entered here need corresponding entries
		loaded via add_range_updater() that are run
		via update_range_lists()
		'''
		self.rangelist.append(lst)
		return(0)
	
	def delete(self, pt, count, batch=False):
		# 1) Find the affected line
		# 2) determine if the full line is being deleted
		# 3) delete as needed
		# 4) update line_pts
		# 5) update bookmarks
		# 6) update statements
		idx = self.pt_to_line(pt)
		# Get the pointer within the appropriate text chunk:
		t_pt = self.pt_to_t_pt(pt)
		#
		save_lstate = self.l.get_state_id()
		save_str_state = self.l[idx].get_state_id()
		save_t_pt = t_pt	
		dprint('del a ' + str(self.l[idx].get_point()))
		self.l[idx].delete(t_pt,  count, batch=batch)
		dprint('del b ' + str(self.l[idx].get_point()))
		self.update_line_pts(pt, -1 * count, batch=batch)
		self.log.append(self.LogEntry('d', datetime.datetime.now(), save_lstate, \
			self.l.get_state_id(), save_str_state, \
			self.l[idx].get_state_id(), idx, t_pt=t_pt, del_count=count))
		return(0)

	def get_char(self, pt):
		idx = self.pt_to_line(pt)
		t_pt = self.pt_to_t_pt(pt)
		return(self.l[idx].get_char(t_pt))

	def get_lines(self, idx, count=1):
		pass

	def get_line_pts(self, idx):
		'''SBStrList.get_line_pts()
		return a range that contains the starting and ending
		points for the specified line in [star, end] slice()
		format.
		'''
		if idx > len(self.line_pts) or idx < 0:
			raise IndexError
		return(self.line_pts[idx])

	def get_point(self, state_id=-1):
		pass
	
	def get_str_list(self):
		'''StrList.get_str_list()
		Return a list object that contains the regular text
		stored in this object.
		'''
		tmp_l = []
		for j in range(len(self.l)):
			l.append(self.l[j].get_string())
		return(''.join(tmp_l))

	def goto_bookmark(self, bmark):
		# maybe use a dictionary to handle bookmarks,
		# so this arg would be the string name of the 
		# bookmark.
		pass	

	def insert(self, pt, txt, batch=False):
		# make all these methods so that they operate on
		# the current state (no state_id override)
		# Note: pt is the global point. t_point is the point
		# into the current text object.
		#
		# Function:
		# 1) Find the affected line
		# 2) determine if new lines are being created (embedded EOL)
		# 3) insert as needed
		# 4) update the log
		# 5) update line_pts
		# 6) update bookmarks
		# 7) update statements

		# TODO: consider keeping the EOL marker as the indicator of 
		# where existing SBString object will be copied.  In other
		# words, If I insert a block of text with embedded EOL,
		# the first part of the insertion would generate a new SBString
		# as if the existing EOL is fixed in concrete thereby forcing
		# the inserted lines to be inserted above.  This will help to
		# keep undo history predictable.  If an EOL marker is deleted,
		# then that SBString object will be deleted from the virtual view.
		idx = self.pt_to_line(pt)
		# Get the pointer within the appropriate text chunk:
		t_pt = self.pt_to_t_pt(pt)
		#
		save_lstate = self.l.get_state_id()
		save_str_state = self.l[idx].get_state_id()
		dprint('in SBStrList.insert a: str sid = ' + str(self.l[idx].get_state_id()) \
			+ ' lstateid = ' + str(self.l.get_state_id()) + ' batch is ' + repr(batch))
		save_t_pt = t_pt	
		# DO I NEED EXTRA LOGIC FOR NON-STANDARD EOL?
		lines = txt.split(os.linesep)
		end_txt = ''
		for j in range(len(lines)):
			if j == 0:
				# Insert the first part of the new text:
				self.l[idx].insert(t_pt, lines[j], batch=batch)
				dprint('in SBStrList.insert B: str sid = ' + str(self.l[idx].get_state_id()) \
					+ ' lstateid = ' + str(self.l.get_state_id()))
				self.update_line_pts(pt, len(lines[j]))
				pt += len(lines[j])
				if len(lines) > 1:
					# The insertion contains embedded EOL, so
					# delete the end of the line that was displaced by 
					# inserting the EOL (but leave the existing EOL)
					t_pt = self.pt_to_t_pt(pt)#pointer within this text chunck
					end_txt = self.l[idx].get_string()[t_pt:] 
					#print("multi-line insert, pt=" + str(pt) + ' deleting from tpt=' \
					#	+ str(t_pt) + ' endtxt= ' + end_txt)
					self.l[idx].delete(t_pt, len(end_txt), batch=True)
					self.update_line_pts(pt, -1 * len(end_txt))

					# Insert an EOL after the first insertion
					# (note that the last line in the file might not have had one)
					self.l[idx].insert(t_pt, '\n', batch=True)
					self.update_line_pts(pt, 1)
					pt += 1

					# Push the end of the insertion line to a new line.
					self.l.insert(idx + 1, SBString(end_txt ), batch=True)
					self.rebuild_line_pts()
					#self.update_line_pts(pt, len(end_txt) + 1)
					#pt += 1 #eol
			else:
				# Insert the second (or higher) line of new text.
				if len(lines[j]) != 0:
					if j == (len(lines) - 1):
						# The last portion of the split text in 'lines'
						# If it is empty, don't do anything, others insert 
						# the text into an existing SBText object
						t_pt = self.pt_to_t_pt(pt)#pointer within this text chunck
						self.l[idx + j].insert(t_pt, lines[j], batch=True)
						dprint('in SBStrList.insert B: str sid = ' + str(self.l[idx].get_state_id()) \
							+ ' lstateid = ' + str(self.l.get_state_id()))
						self.update_line_pts(pt, len(lines[j]))
						pt += len(lines[j])
					else:
						# This is a new, full line with EOL.
						# Insert a new line into the file.
						self.l.insert(idx + j, SBString(lines[j]), batch=True)
						# RUN REBUILD_LINE_PTS HERE !!!!!!!!!!!!!!!!!!!!!!!!
						self.update_line_pts(pt, len(lines[j]))
						pt += len(lines[j])
		# Now insert that end text at the end
		#if end_txt != '':
		#	t_pt = self.pt_to_t_pt(pt)#pointer within this text chunck
		#	print('Appending end, pt=' + str(pt) + ', tpt= ' + str(t_pt))
		#	print('chcking line nb ' + str(self.pt_to_line(pt)))
		#	self.l[idx].insert(t_pt, end_txt, batch=False)
		#	self.update_line_pts(pt, len(end_txt))
		#	print('line pts= ' + repr(self.line_pts))
		
			# Construct the log entry:	
		self.log.append(self.LogEntry('i', datetime.datetime.now(), save_lstate, \
			self.l.get_state_id(), save_str_state, \
			self.l[idx].get_state_id(), idx, t_pt=t_pt, txt=txt))
		self.buff_len[0] += len(txt)
		return(0)

	def insert_line(self, before_line, txt):
		pass

	def line_count(self):
		return(len(self.l))

	def list_bookmarks(self):
		pass

	def list_statements(self):
		pass

	def pt_to_line(self, pt):
		'''SBStrList.pt_to_line()
		Return the index number of the line that contains the
		specified point in the current state.
		'''
		#print(repr(self.line_pts))	
		found = False
		j = 0
		while not found and j < len(self.line_pts):
			if self.line_pts[j][0] <= pt and (self.line_pts[j][1] - 1) >= pt:
				found = True	
			j += 1
		return(j - 1)

	def pt_to_t_pt(self, pt):
		'''SBStrList.pt_to_t_pt()
		Convert a global point into the buffer to a t_pt,
		which is a zero-based index into the text at the current line
		'''
		line = self.pt_to_line(pt)
		assert( line >= 0)
		return(pt - self.line_pts[line][0])	

	def rebuild_line_pts(self):
		tmp_lp = []
		tmp_pt = 0
		for j in range(len(self.l)):
			# Record the starting and ending point on each line.
			# This is NOT in slice() format.
			tmp_lp.append([tmp_pt, tmp_pt + len(self.l[j])])
			tmp_pt += len(self.l[j])
		self.line_pts = SBList(tmp_lp)
		return(0)

	def redo(self):
		pass

	def set_bookmark(self, pt_start, len):
		pass

	def show_line_pts(self):
		'''SBStrList.show_line_pts()
		This is for debugging purposes to show the saved
		list of starting and ending points (slice() format)
		for each buffer line.
		'''
		return(repr(self.line_pts))

	def show_undo_list(self):
		return(repr(self.log))

	def set_point(self, pt):
		pass

	def str_len(self):
		'''SbStrList.str_len()
		Return the full length of the buffer in characters.
		'''
		#ln = 0
		#for sbs in self.l:
		#	ln += len(sbs)
		#return(ln)
		reuturn(self.buff_len[0])

	def list_len(self):
		return(len(self.l))

	def undo(self):
		if len(self.log) == 0:
			return(0)

		top_state_id = self.log.get_state_id()
		#top_log_entry = self.log[-1]
		#self.log[0:self.log.get_state_id]
		top_log_entry = self.log[top_state_id]
		top_action_code = top_log_entry.action
		top_idx = top_log_entry.row_idx
		# The undo() below undoes the record of the transaction
		# and thereby leaves the top entry with the l_state and
		# v_state IDs that are desired.
		# ONE UNDO ON THE LOG ENTRY WILL NOT UNDO MANY BATCH ENTRIES !!!!!!!!!!!!!!!!!!!!i!!!!!!!
		self.log.undo() #this undoes only the transaction
		if top_action_code in ['i', 'd']:
			#print('UNDO TEXT EDIT for line idx ' + str(top_idx))
			self.l[top_idx].undo(count=1)
			self.buff_len.undo()
		else:
			raise Exception ("not ready to undo line-oriented actions")
		
		pass

	def update_line_pts(self, pt, incr, batch=False):
		'''SBStrList.update_line_pts()
		Update self.line_pts to reflect inserted or deleted
		text. Do NOT call this if there are new or delete lines.
	  self.line_pts is a list of the starting points
		and ending points for each line.

		see also: rebuild_line_pts
		'''
		idx = self.pt_to_line(pt)
		# I will delete all the existing range entries and then append
		# new ones
		old_lp_state = self.line_pts.get_state_id()
		b_code = batch
		len_pts = len(self.line_pts) 
		save_line_pts = []
		for j in range(len_pts):
			# Save the current state of line_pts because if actions
			# are taken in batch mode, I'll need this to get the 
			# prior state.
			save_line_pts.append(self.line_pts[j])

		for j in range(len_pts -1, idx - 1 , -1):
			self.line_pts.delete(j, batch=b_code)
			b_code = True

		# Now insert the updated entries (there might be new or delete rows)
		for j in range(idx, len(save_line_pts)):
			# The current state of self.line_pts should contain one entry 
			# for each record in self.l. Get that entry to find the starting and
			# ending point for each line:
			low = save_line_pts[j][0]
			high = save_line_pts[j][1]
			if low <= pt:
				self.line_pts.append([low , high+ incr], batch=True)
			else:
				self.line_pts.append([low + incr, high+ incr], batch=True)

		return(0)

	def update_range_lists(self, pt, incr):
		'''SBStrList.update_ranges()
		Update all the list objects that contain ranges of 
		start/end points.  This processes anything that was
		registered with add_range_list()

		see also: rebuild_line_pts
		'''
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		# MODIFY THIS TO MAKE IT GENERIC FOR THE REGISTERED LISTSV
		idx = self.pt_to_line(pt)
		# I will delete all the existing range entries and then append
		# new ones
		old_lp_state = self.line_pts.get_state_id()
		b_code = False
		for j in range(idx, len(self.line_pts)):
			self.line_pts.delete(idx, batch=b_code)
			b_code = True

		# Now insert the updated entries (there might be new or delete rows)
		for j in range(idx, len(self.l)):
			low = self.line_pts.get_item(j, state_id=old_lp_state)[0]
			high = self.line_pts.get_item(j, state_id=old_lp_state)[1]
			if low < pt:
				self.line_pts.append([low , high+ incr], batch=True)
			else:
				self.line_pts.append([low + incr, high+ incr], batch=True)

		return(0)