Uploaded Test files

venv/Lib/site-packages/pythonwin/pywin/framework/interact.py

@@ -0,0 +1,870 @@
+
+##################################################################
+##
+## Interactive Shell Window
+##
+
+import sys, os
+import code
+import string
+
+import win32ui
+import win32api
+import win32clipboard
+import win32con
+import traceback
+import afxres
+import array
+import __main__
+
+import pywin.scintilla.formatter
+import pywin.scintilla.control
+import pywin.scintilla.IDLEenvironment
+import pywin.framework.app
+
+## sequential after ID_GOTO_LINE defined in editor.py
+ID_EDIT_COPY_CODE = 0xe2002
+ID_EDIT_EXEC_CLIPBOARD = 0x2003
+
+trace=pywin.scintilla.formatter.trace
+
+from . import winout
+
+import re
+# from IDLE.
+_is_block_opener = re.compile(r":\s*(#.*)?$").search
+_is_block_closer = re.compile(r"""
+    \s*
+    ( return
+    | break
+    | continue
+    | raise
+    | pass
+    )
+    \b
+""", re.VERBOSE).match
+
+tracebackHeader = "Traceback (".encode("ascii")
+
+sectionProfile = "Interactive Window"
+valueFormatTitle = "FormatTitle"
+valueFormatInput = "FormatInput"
+valueFormatOutput = "FormatOutput"
+valueFormatOutputError = "FormatOutputError"
+
+# These are defaults only.  Values are read from the registry.
+formatTitle = (-536870897, 0, 220, 0, 16711680, 184, 34, 'Arial')
+formatInput =  (-402653169, 0, 200, 0, 0, 0, 49, 'Courier New')
+formatOutput =  (-402653169, 0, 200, 0, 8421376, 0, 49, 'Courier New')
+formatOutputError = (-402653169, 0, 200, 0, 255, 0, 49, 'Courier New')
+
+try:
+	sys.ps1
+except AttributeError:
+	sys.ps1 = '>>> '
+	sys.ps2 = '... '
+
+def LoadPreference(preference, default = ""):
+	return win32ui.GetProfileVal(sectionProfile, preference, default)
+
+def SavePreference( prefName, prefValue ):
+	win32ui.WriteProfileVal( sectionProfile, prefName, prefValue )
+
+def GetPromptPrefix(line):
+	ps1=sys.ps1
+	if line[:len(ps1)]==ps1: return ps1
+	ps2=sys.ps2
+	if line[:len(ps2)]==ps2: return ps2
+
+#############################################################
+#
+# Colorizer related code.
+#
+#############################################################
+STYLE_INTERACTIVE_EOL = "Interactive EOL"
+STYLE_INTERACTIVE_OUTPUT = "Interactive Output"
+STYLE_INTERACTIVE_PROMPT = "Interactive Prompt"
+STYLE_INTERACTIVE_BANNER = "Interactive Banner"
+STYLE_INTERACTIVE_ERROR = "Interactive Error"
+STYLE_INTERACTIVE_ERROR_FINALLINE = "Interactive Error (final line)"
+
+INTERACTIVE_STYLES = [STYLE_INTERACTIVE_EOL, STYLE_INTERACTIVE_OUTPUT, STYLE_INTERACTIVE_PROMPT, STYLE_INTERACTIVE_BANNER, STYLE_INTERACTIVE_ERROR, STYLE_INTERACTIVE_ERROR_FINALLINE]
+
+FormatterParent = pywin.scintilla.formatter.PythonSourceFormatter
+class InteractiveFormatter(FormatterParent):
+	def __init__(self, scintilla):
+		FormatterParent.__init__(self, scintilla)
+		self.bannerDisplayed = False
+
+	def SetStyles(self):
+		FormatterParent.SetStyles(self)
+		Style = pywin.scintilla.formatter.Style
+		self.RegisterStyle( Style(STYLE_INTERACTIVE_EOL, STYLE_INTERACTIVE_PROMPT ) )
+		self.RegisterStyle( Style(STYLE_INTERACTIVE_PROMPT, formatInput ) )
+		self.RegisterStyle( Style(STYLE_INTERACTIVE_OUTPUT, formatOutput) )
+		self.RegisterStyle( Style(STYLE_INTERACTIVE_BANNER, formatTitle ) )
+		self.RegisterStyle( Style(STYLE_INTERACTIVE_ERROR, formatOutputError ) )
+		self.RegisterStyle( Style(STYLE_INTERACTIVE_ERROR_FINALLINE, STYLE_INTERACTIVE_ERROR ) )
+
+	def LoadPreference(self, name, default):
+		rc = win32ui.GetProfileVal("Format", name, default)
+		if rc==default:
+			rc = win32ui.GetProfileVal(sectionProfile, name, default)
+		return rc
+
+	def ColorizeInteractiveCode(self, cdoc, styleStart, stylePyStart):
+		lengthDoc = len(cdoc)
+		if lengthDoc == 0: return
+		state = styleStart
+		# As per comments in Colorize(), we work with the raw utf8
+		# bytes. To avoid too muych py3k pain, we treat each utf8 byte
+		# as a latin-1 unicode character - we only use it to compare
+		# against ascii chars anyway...
+		chNext = cdoc[0:1].decode('latin-1')
+		startSeg = 0
+		i = 0
+		lastState=state # debug only
+		while i < lengthDoc:
+			ch = chNext
+			chNext = cdoc[i+1:i+2].decode('latin-1')
+			
+#			trace("ch=%r, i=%d, next=%r, state=%s" % (ch, i, chNext, state))
+			if state == STYLE_INTERACTIVE_EOL:
+				if ch not in '\r\n':
+					self.ColorSeg(startSeg, i-1, state)
+					startSeg = i
+					if ch in [sys.ps1[0], sys.ps2[0]]:
+						state = STYLE_INTERACTIVE_PROMPT
+					elif cdoc[i:i+len(tracebackHeader)]==tracebackHeader:
+						state = STYLE_INTERACTIVE_ERROR
+					else:
+						state = STYLE_INTERACTIVE_OUTPUT
+			elif state == STYLE_INTERACTIVE_PROMPT:
+				if ch not in sys.ps1 + sys.ps2 + " ":
+					self.ColorSeg(startSeg, i-1, state)
+					startSeg = i
+					if ch in '\r\n':
+						state = STYLE_INTERACTIVE_EOL
+					else:
+						state = stylePyStart # Start coloring Python code.
+			elif state in [STYLE_INTERACTIVE_OUTPUT]:
+				if ch in '\r\n':
+					self.ColorSeg(startSeg, i-1, state)
+					startSeg = i
+					state = STYLE_INTERACTIVE_EOL
+			elif state == STYLE_INTERACTIVE_ERROR:
+				if ch in '\r\n' and chNext and chNext not in string.whitespace:
+					# Everything including me
+					self.ColorSeg(startSeg, i, state)
+					startSeg = i+1
+					state = STYLE_INTERACTIVE_ERROR_FINALLINE
+				elif i == 0 and ch not in string.whitespace:
+					# If we are coloring from the start of a line,
+					# we need this better check for the last line
+					# Color up to not including me
+					self.ColorSeg(startSeg, i-1, state)
+					startSeg = i
+					state = STYLE_INTERACTIVE_ERROR_FINALLINE
+			elif state == STYLE_INTERACTIVE_ERROR_FINALLINE:
+				if ch in '\r\n':
+					self.ColorSeg(startSeg, i-1, state)
+					startSeg = i
+					state = STYLE_INTERACTIVE_EOL
+			elif state == STYLE_INTERACTIVE_BANNER:
+				if ch in '\r\n' and (chNext=='' or chNext in ">["):
+					# Everything including me
+					self.ColorSeg(startSeg, i-1, state)
+					startSeg = i
+					state = STYLE_INTERACTIVE_EOL
+			else:
+				# It is a PythonColorizer state - seek past the end of the line
+				# and ask the Python colorizer to color that.
+				end = startSeg
+				while end < lengthDoc and cdoc[end] not in '\r\n'.encode('ascii'):
+					end = end + 1
+				self.ColorizePythonCode( cdoc[:end], startSeg, state)
+				stylePyStart = self.GetStringStyle(end-1)
+				if stylePyStart is None:
+					stylePyStart = pywin.scintilla.formatter.STYLE_DEFAULT
+				else:
+					stylePyStart = stylePyStart.name
+				startSeg =end
+				i = end - 1 # ready for increment.
+				chNext = cdoc[end:end+1].decode('latin-1')
+				state = STYLE_INTERACTIVE_EOL
+			if lastState != state:
+				lastState = state
+			i = i + 1
+		# and the rest
+		if startSeg<i:
+			self.ColorSeg(startSeg, i-1, state)
+
+	def Colorize(self, start=0, end=-1):
+		# scintilla's formatting is all done in terms of utf, so
+		# we work with utf8 bytes instead of unicode.  This magically
+		# works as any extended chars found in the utf8 don't change
+		# the semantics.
+		stringVal = self.scintilla.GetTextRange(start, end, decode=False)
+		styleStart = None
+		stylePyStart = None
+		if start > 1:
+			# Likely we are being asked to color from the start of the line.
+			# We find the last formatted character on the previous line.
+			# If TQString, we continue it.  Otherwise, we reset.
+			look = start -1
+			while look and self.scintilla.SCIGetCharAt(look) in '\n\r':
+				look = look - 1
+			if look and look < start-1: # Did we find a char before the \n\r sets?
+				strstyle = self.GetStringStyle(look)
+				quote_char = None
+				if strstyle is not None:
+					if strstyle.name == pywin.scintilla.formatter.STYLE_TQSSTRING:
+						quote_char = "'"
+					elif strstyle.name == pywin.scintilla.formatter.STYLE_TQDSTRING:
+						quote_char = '"'
+					if quote_char is not None:
+						# It is a TQS.  If the TQS is not terminated, we
+						# carry the style through.
+						if look > 2:
+							look_str = self.scintilla.SCIGetCharAt(look-2) + self.scintilla.SCIGetCharAt(look-1) + self.scintilla.SCIGetCharAt(look)
+							if look_str != quote_char * 3:
+								stylePyStart = strstyle.name
+		if stylePyStart is None: stylePyStart =  pywin.scintilla.formatter.STYLE_DEFAULT
+
+		if start > 0:
+			stylenum = self.scintilla.SCIGetStyleAt(start - 1)
+			styleStart = self.GetStyleByNum(stylenum).name
+		elif self.bannerDisplayed:
+			styleStart = STYLE_INTERACTIVE_EOL
+		else:
+			styleStart = STYLE_INTERACTIVE_BANNER
+			self.bannerDisplayed = True
+		self.scintilla.SCIStartStyling(start, 31)
+		self.style_buffer = array.array("b", (0,)*len(stringVal))
+		self.ColorizeInteractiveCode(stringVal, styleStart, stylePyStart)
+		self.scintilla.SCISetStylingEx(self.style_buffer)
+		self.style_buffer = None
+
+###############################################################
+#
+# This class handles the Python interactive interpreter.
+#
+# It uses a basic EditWindow, and does all the magic.
+# This is triggered by the enter key hander attached by the
+# start-up code.  It determines if a command is to be executed
+# or continued (ie, emit "... ") by snooping around the current
+# line, looking for the prompts
+#
+class PythonwinInteractiveInterpreter(code.InteractiveInterpreter):
+	def __init__(self, locals = None, globals = None):
+		if locals is None: locals = __main__.__dict__
+		if globals is None: globals = locals
+		self.globals = globals
+		code.InteractiveInterpreter.__init__(self, locals)
+	def showsyntaxerror(self, filename=None):
+		sys.stderr.write(tracebackHeader.decode('ascii')) # So the color syntaxer recognises it.
+		code.InteractiveInterpreter.showsyntaxerror(self, filename)
+	def runcode(self, code):
+		try:
+			exec(code, self.globals, self.locals)
+		except SystemExit:
+			raise
+		except:
+			self.showtraceback()
+
+class InteractiveCore:
+	def __init__(self, banner = None):
+		self.banner = banner
+#		LoadFontPreferences()
+	def Init(self):
+		self.oldStdOut = self.oldStdErr = None
+
+#		self.SetWordWrap(win32ui.CRichEditView_WrapNone)
+		self.interp = PythonwinInteractiveInterpreter()
+
+		self.OutputGrab()	# Release at cleanup.
+
+		if self.GetTextLength()==0:
+			if self.banner is None:
+				suffix = ""
+				if win32ui.debug: suffix = ", debug build"
+				sys.stderr.write("PythonWin %s on %s%s.\n" % (sys.version, sys.platform, suffix) )
+				sys.stderr.write("Portions %s - see 'Help/About PythonWin' for further copyright information.\n" % (win32ui.copyright,) )
+			else:
+				sys.stderr.write(banner)
+		rcfile = os.environ.get('PYTHONSTARTUP')
+		if rcfile:
+			import __main__
+			try:
+				execfile(rcfile, __main__.__dict__, __main__.__dict__)
+			except:
+				sys.stderr.write(">>> \nError executing PYTHONSTARTUP script %r\n" % (rcfile))
+				traceback.print_exc(file=sys.stderr)
+		self.AppendToPrompt([])
+
+	def SetContext(self, globals, locals, name = "Dbg"):
+		oldPrompt = sys.ps1
+		if globals is None:
+			# Reset
+			sys.ps1 = ">>> "
+			sys.ps2 = "... "
+			locals = globals = __main__.__dict__
+		else:
+			sys.ps1 = "[%s]>>> " % name
+			sys.ps2 = "[%s]... " % name
+		self.interp.locals = locals
+		self.interp.globals = globals
+		self.AppendToPrompt([], oldPrompt)
+
+	def GetContext(self):
+		return self.interp.globals, self.interp.locals
+
+	def DoGetLine(self, line=-1):
+		if line==-1: line = self.LineFromChar()
+		line = self.GetLine(line)
+		while line and line[-1] in ['\r', '\n']:
+			line = line[:-1]
+		return line
+	def AppendToPrompt(self,bufLines, oldPrompt = None):
+		" Take a command and stick it at the end of the buffer (with python prompts inserted if required)."
+		self.flush()
+		lastLineNo = self.GetLineCount()-1
+		line = self.DoGetLine(lastLineNo)
+		if oldPrompt and line==oldPrompt:
+			self.SetSel(self.GetTextLength()-len(oldPrompt), self.GetTextLength())
+			self.ReplaceSel(sys.ps1)
+		elif (line!=str(sys.ps1)):
+			if len(line)!=0: self.write('\n')
+			self.write(sys.ps1)
+		self.flush()
+		self.idle.text.mark_set("iomark", "end-1c")
+		if not bufLines:
+			return
+		terms = (["\n" + sys.ps2] * (len(bufLines)-1)) + ['']
+		for bufLine, term in zip(bufLines, terms):
+			if bufLine.strip():
+				self.write( bufLine + term )
+		self.flush()
+
+	def EnsureNoPrompt(self):
+		# Get ready to write some text NOT at a Python prompt.
+		self.flush()
+		lastLineNo = self.GetLineCount()-1
+		line = self.DoGetLine(lastLineNo)
+		if not line or line in [sys.ps1, sys.ps2]:
+			self.SetSel(self.GetTextLength()-len(line), self.GetTextLength())
+			self.ReplaceSel('')
+		else:
+			# Just add a new line.
+			self.write('\n')
+		
+	def _GetSubConfigNames(self):
+		return ["interactive"] # Allow [Keys:Interactive] sections to be specific
+
+	def HookHandlers(self):
+		# Hook menu command (executed when a menu item with that ID is selected from a menu/toolbar
+		self.HookCommand(self.OnSelectBlock, win32ui.ID_EDIT_SELECT_BLOCK)
+		self.HookCommand(self.OnEditCopyCode, ID_EDIT_COPY_CODE)
+		self.HookCommand(self.OnEditExecClipboard, ID_EDIT_EXEC_CLIPBOARD)
+		mod = pywin.scintilla.IDLEenvironment.GetIDLEModule("IdleHistory")
+		if mod is not None:
+			self.history = mod.History(self.idle.text, "\n" + sys.ps2)
+		else:
+			self.history = None
+		# hack for now for event handling.
+
+	# GetBlockBoundary takes a line number, and will return the
+	# start and and line numbers of the block, and a flag indicating if the
+	# block is a Python code block.
+	# If the line specified has a Python prompt, then the lines are parsed
+	# backwards and forwards, and the flag is true.
+	# If the line does not start with a prompt, the block is searched forward
+	# and backward until a prompt _is_ found, and all lines in between without
+	# prompts are returned, and the flag is false.
+	def GetBlockBoundary( self, lineNo ):
+		line = self.DoGetLine(lineNo)
+		maxLineNo = self.GetLineCount()-1
+		prefix = GetPromptPrefix(line)
+		if prefix is None:        # Non code block
+			flag = 0
+			startLineNo = lineNo
+			while startLineNo>0:
+				if GetPromptPrefix(self.DoGetLine(startLineNo-1)) is not None:
+					break                     # there _is_ a prompt
+				startLineNo = startLineNo-1
+			endLineNo = lineNo
+			while endLineNo<maxLineNo:
+				if GetPromptPrefix(self.DoGetLine(endLineNo+1)) is not None:
+					break                     # there _is_ a prompt
+				endLineNo = endLineNo+1
+		else:                                    # Code block
+			flag = 1
+			startLineNo = lineNo
+			while startLineNo>0 and prefix!=str(sys.ps1):
+				prefix = GetPromptPrefix(self.DoGetLine(startLineNo-1))
+				if prefix is None:
+					break;	# there is no prompt.
+				startLineNo = startLineNo - 1
+			endLineNo = lineNo
+			while endLineNo<maxLineNo:
+				prefix = GetPromptPrefix(self.DoGetLine(endLineNo+1))
+				if prefix is None:
+					break	# there is no prompt
+				if prefix==str(sys.ps1):
+					break	# this is another command
+				endLineNo = endLineNo+1
+				# continue until end of buffer, or no prompt
+		return (startLineNo, endLineNo, flag)
+
+	def ExtractCommand( self, lines ):
+		start, end = lines
+		retList = []
+		while end >= start:
+			thisLine = self.DoGetLine(end)
+			promptLen = len(GetPromptPrefix(thisLine))
+			retList = [thisLine[promptLen:]] + retList
+			end = end-1
+		return retList
+
+	def OutputGrab(self):
+#		import win32traceutil; return
+		self.oldStdOut = sys.stdout
+		self.oldStdErr = sys.stderr
+		sys.stdout=self
+		sys.stderr=self
+		self.flush()
+
+	def OutputRelease(self):
+		# a command may have overwritten these - only restore if not.
+		if self.oldStdOut is not None:
+			if sys.stdout == self:
+				sys.stdout=self.oldStdOut
+		if self.oldStdErr is not None:
+			if sys.stderr == self:
+				sys.stderr=self.oldStdErr
+		self.oldStdOut = None
+		self.oldStdErr = None
+		self.flush()
+
+	###################################
+	#
+	# Message/Command/Key Hooks.
+	#
+	# Enter key handler
+	#
+	def ProcessEnterEvent(self, event ):
+		#If autocompletion has been triggered, complete and do not process event
+		if self.SCIAutoCActive():
+			self.SCIAutoCComplete()
+			self.SCICancel()
+			return
+		
+		self.SCICancel()
+		# First, check for an error message
+		haveGrabbedOutput = 0
+		if self.HandleSpecialLine(): return 0
+
+		lineNo = self.LineFromChar()
+		start, end, isCode = self.GetBlockBoundary(lineNo)
+		# If we are not in a code block just go to the prompt (or create a new one)
+		if not isCode:
+			self.AppendToPrompt([])
+			win32ui.SetStatusText(win32ui.LoadString(afxres.AFX_IDS_IDLEMESSAGE))
+			return
+
+		lines = self.ExtractCommand((start,end))
+
+		# If we are in a code-block, but it isnt at the end of the buffer
+		# then copy it to the end ready for editing and subsequent execution
+		if end!=self.GetLineCount()-1:
+			win32ui.SetStatusText('Press ENTER to execute command')
+			self.AppendToPrompt(lines)
+			self.SetSel(-2)
+			return
+
+		# If SHIFT held down, we want new code here and now!
+		bNeedIndent = win32api.GetKeyState(win32con.VK_SHIFT)<0 or win32api.GetKeyState(win32con.VK_CONTROL)<0
+		if bNeedIndent:
+			self.ReplaceSel("\n")
+		else:
+			self.SetSel(-2)
+			self.ReplaceSel("\n")
+			source = '\n'.join(lines)
+			while source and source[-1] in '\t ':
+				source = source[:-1]
+			self.OutputGrab()	# grab the output for the command exec.
+			try:
+				if self.interp.runsource(source, "<interactive input>"): # Need more input!
+					bNeedIndent = 1
+				else:
+					# If the last line isnt empty, append a newline
+					if self.history is not None:
+						self.history.history_store(source)
+					self.AppendToPrompt([])
+					win32ui.SetStatusText(win32ui.LoadString(afxres.AFX_IDS_IDLEMESSAGE))
+#					win32ui.SetStatusText('Successfully executed statement')
+			finally:
+				self.OutputRelease()
+		if bNeedIndent:
+			win32ui.SetStatusText('Ready to continue the command')
+			# Now attempt correct indentation (should use IDLE?)
+			curLine = self.DoGetLine(lineNo)[len(sys.ps2):]
+			pos = 0
+			indent=''
+			while len(curLine)>pos and curLine[pos] in string.whitespace:
+				indent = indent + curLine[pos]
+				pos = pos + 1
+			if _is_block_opener(curLine):
+				indent = indent + '\t'
+			elif _is_block_closer(curLine):
+				indent = indent[:-1]
+			# use ReplaceSel to ensure it goes at the cursor rather than end of buffer.
+			self.ReplaceSel(sys.ps2+indent)
+		return 0
+
+	# ESC key handler
+	def ProcessEscEvent(self, event):
+		# Implement a cancel.
+		if self.SCIAutoCActive() or self.SCICallTipActive():
+			self.SCICancel()
+		else:
+			win32ui.SetStatusText('Cancelled.')
+			self.AppendToPrompt(('',))
+		return 0
+
+	def OnSelectBlock(self,command, code):
+		lineNo = self.LineFromChar()
+		start, end, isCode = self.GetBlockBoundary(lineNo)
+		startIndex = self.LineIndex(start)
+		endIndex = self.LineIndex(end+1)-2	# skip \r + \n
+		if endIndex<0:	# must be beyond end of buffer
+			endIndex = -2	# self.Length()
+		self.SetSel(startIndex,endIndex)
+
+	def OnEditCopyCode(self, command, code):
+		""" Sanitizes code from interactive window, removing prompts and output,
+			and inserts it in the clipboard."""
+		code=self.GetSelText()
+		lines=code.splitlines()
+		out_lines=[]
+		for line in lines:
+			if line.startswith(sys.ps1):
+				line=line[len(sys.ps1):]
+				out_lines.append(line)
+			elif line.startswith(sys.ps2):
+				line=line[len(sys.ps2):]
+				out_lines.append(line)
+		out_code=os.linesep.join(out_lines)
+		win32clipboard.OpenClipboard()
+		try:
+			win32clipboard.SetClipboardData(win32clipboard.CF_UNICODETEXT, str(out_code))
+		finally:
+			win32clipboard.CloseClipboard()
+
+	def OnEditExecClipboard(self, command, code):
+		""" Executes python code directly from the clipboard."""
+		win32clipboard.OpenClipboard()
+		try:
+			code=win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
+		finally:
+			win32clipboard.CloseClipboard()
+
+		code=code.replace('\r\n','\n')+'\n'
+		try:
+			o=compile(code, '<clipboard>', 'exec')
+			exec(o, __main__.__dict__)
+		except:
+			traceback.print_exc()
+
+	def GetRightMenuItems(self):
+		# Just override parents
+		ret = []
+		flags = 0
+		ret.append((flags, win32ui.ID_EDIT_UNDO, '&Undo'))
+		ret.append(win32con.MF_SEPARATOR)
+		ret.append((flags, win32ui.ID_EDIT_CUT, 'Cu&t'))
+		ret.append((flags, win32ui.ID_EDIT_COPY, '&Copy'))
+
+		start, end=self.GetSel()
+		if start!=end:
+			ret.append((flags, ID_EDIT_COPY_CODE, 'Copy code without prompts'))
+		if win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT):
+			ret.append((flags, ID_EDIT_EXEC_CLIPBOARD, 'Execute python code from clipboard'))
+
+		ret.append((flags, win32ui.ID_EDIT_PASTE, '&Paste'))
+		ret.append(win32con.MF_SEPARATOR)
+		ret.append((flags, win32ui.ID_EDIT_SELECT_ALL, '&Select all'))
+		ret.append((flags, win32ui.ID_EDIT_SELECT_BLOCK, 'Select &block'))
+		ret.append((flags, win32ui.ID_VIEW_WHITESPACE, "View &Whitespace"))
+		return ret
+
+	def MDINextEvent(self, event):
+		win32ui.GetMainFrame().MDINext(0)
+	def MDIPrevEvent(self, event):
+		win32ui.GetMainFrame().MDINext(0)
+
+	def WindowBackEvent(self, event):
+		parent = self.GetParentFrame()
+		if parent == win32ui.GetMainFrame():
+			# It is docked.
+			try:
+				wnd, isactive = parent.MDIGetActive()
+				wnd.SetFocus()
+			except win32ui.error:
+				# No MDI window active!
+				pass
+		else:
+			# Normal Window
+			try:
+				lastActive = self.GetParentFrame().lastActive
+				# If the window is invalid, reset it.
+				if lastActive is not None and (lastActive._obj_ is None or lastActive.GetSafeHwnd()==0):
+					lastActive = self.GetParentFrame().lastActive = None
+					win32ui.SetStatusText("The last active Window has been closed.")
+			except AttributeError:
+				print("Can't find the last active window!")
+				lastActive = None
+			if lastActive is not None:
+				lastActive.MDIActivate()
+
+class InteractiveView(InteractiveCore, winout.WindowOutputView):
+	def __init__(self,  doc):
+		InteractiveCore.__init__(self)
+		winout.WindowOutputView.__init__(self, doc)
+		self.encoding = pywin.default_scintilla_encoding
+		
+	def _MakeColorizer(self):
+		return InteractiveFormatter(self)
+	def OnInitialUpdate(self):
+		winout.WindowOutputView.OnInitialUpdate(self)
+		self.SetWordWrap()
+		self.Init()
+	def HookHandlers(self):
+		winout.WindowOutputView.HookHandlers(self)
+		InteractiveCore.HookHandlers(self)
+
+class CInteractivePython(winout.WindowOutput):
+	def __init__(self, makeDoc = None, makeFrame = None):
+		self.IsFinalDestroy = 0
+		winout.WindowOutput.__init__(self, sectionProfile, sectionProfile, \
+		                             winout.flags.WQ_LINE, 1, None, makeDoc, makeFrame, InteractiveView )
+		self.Create()
+
+	def OnViewDestroy(self, view):
+		if self.IsFinalDestroy:
+			view.OutputRelease()
+		winout.WindowOutput.OnViewDestroy(self, view)
+
+	def Close(self):
+		self.IsFinalDestroy = 1
+		winout.WindowOutput.Close(self)
+
+class InteractiveFrame(winout.WindowOutputFrame):
+	def __init__(self):
+		self.lastActive = None
+		winout.WindowOutputFrame.__init__(self)
+
+	def OnMDIActivate(self, bActive, wndActive, wndDeactive):
+		if bActive:
+			self.lastActive = wndDeactive
+
+######################################################################
+## 
+## Dockable Window Support
+## 
+######################################################################
+ID_DOCKED_INTERACTIVE_CONTROLBAR = 0xe802
+
+DockedInteractiveViewParent = InteractiveView
+class DockedInteractiveView(DockedInteractiveViewParent):
+	def HookHandlers(self):
+		DockedInteractiveViewParent.HookHandlers(self)
+		self.HookMessage(self.OnSetFocus, win32con.WM_SETFOCUS)
+		self.HookMessage(self.OnKillFocus, win32con.WM_KILLFOCUS)
+	def OnSetFocus(self, msg):
+		self.GetParentFrame().SetActiveView(self)
+		return 1
+	def OnKillFocus(self, msg):
+		# If we are losing focus to another in this app, reset the main frame's active view.
+		hwnd = wparam = msg[2]
+		try:
+			wnd = win32ui.CreateWindowFromHandle(hwnd)
+			reset  = wnd.GetTopLevelFrame()==self.GetTopLevelFrame()
+		except win32ui.error:
+			reset = 0 # Not my window
+		if reset: self.GetParentFrame().SetActiveView(None)
+		return 1
+	def OnDestroy(self, msg):
+		newSize = self.GetWindowPlacement()[4]
+		pywin.framework.app.SaveWindowSize("Interactive Window", newSize, "docked")
+		try:
+			if self.GetParentFrame().GetActiveView==self:
+				self.GetParentFrame().SetActiveView(None)
+		except win32ui.error:
+			pass
+		try:
+			if win32ui.GetMainFrame().GetActiveView()==self:
+				win32ui.GetMainFrame().SetActiveView(None)
+		except win32ui.error:
+			pass
+		return DockedInteractiveViewParent.OnDestroy(self, msg)
+
+class CDockedInteractivePython(CInteractivePython):
+	def __init__(self, dockbar):
+		self.bFirstCreated = 0
+		self.dockbar = dockbar
+		CInteractivePython.__init__(self)
+	def NeedRecreateWindow(self):
+		if self.bCreating:
+			return 0
+		try:
+				frame = win32ui.GetMainFrame()
+				if frame.closing:
+					return 0 # Dieing!
+		except (win32ui.error, AttributeError):
+			return 0 # The app is dieing!
+		try:
+			cb = frame.GetControlBar(ID_DOCKED_INTERACTIVE_CONTROLBAR)
+			return not cb.IsWindowVisible()
+		except win32ui.error:
+			return 1 # Control bar does not exist!
+	def RecreateWindow(self):
+		try:
+			dockbar = win32ui.GetMainFrame().GetControlBar(ID_DOCKED_INTERACTIVE_CONTROLBAR)
+			win32ui.GetMainFrame().ShowControlBar(dockbar, 1, 1)
+		except win32ui.error:
+			CreateDockedInteractiveWindow()
+
+	def Create(self):
+		self.bCreating = 1
+		doc = InteractiveDocument(None, self.DoCreateDoc())
+		view = DockedInteractiveView(doc)
+		defRect = pywin.framework.app.LoadWindowSize("Interactive Window", "docked")
+		if defRect[2]-defRect[0]==0:
+			defRect = 0, 0, 500, 200
+		style = win32con.WS_CHILD | win32con.WS_VISIBLE | win32con.WS_BORDER
+		id = 1050 # win32ui.AFX_IDW_PANE_FIRST
+		view.CreateWindow(self.dockbar, id, style, defRect)
+		view.OnInitialUpdate()
+		self.bFirstCreated = 1
+
+		self.currentView = doc.GetFirstView()
+		self.bCreating = 0
+		if self.title: doc.SetTitle(self.title)
+
+# The factory we pass to the dockable window support.
+def InteractiveViewCreator(parent):
+	global edit
+	edit = CDockedInteractivePython(parent)
+	return edit.currentView
+
+def CreateDockedInteractiveWindow():
+	# Later, the DockingBar should be capable of hosting multiple
+	# children.
+	from pywin.docking.DockingBar import DockingBar
+	bar = DockingBar()
+	creator = InteractiveViewCreator
+	bar.CreateWindow(win32ui.GetMainFrame(), creator, "Interactive Window", ID_DOCKED_INTERACTIVE_CONTROLBAR)
+	bar.SetBarStyle( bar.GetBarStyle()|afxres.CBRS_TOOLTIPS|afxres.CBRS_FLYBY|afxres.CBRS_SIZE_DYNAMIC)
+	bar.EnableDocking(afxres.CBRS_ALIGN_ANY)
+	win32ui.GetMainFrame().DockControlBar(bar, afxres.AFX_IDW_DOCKBAR_BOTTOM)
+
+######################################################################
+# 
+# The public interface to this module.
+# 
+######################################################################
+# No extra functionality now, but maybe later, so
+# publicize these names.
+InteractiveDocument = winout.WindowOutputDocument
+
+# We remember our one and only interactive window in the "edit" variable.
+edit = None
+
+def CreateInteractiveWindowUserPreference(makeDoc = None, makeFrame = None):
+	"""Create some sort of interactive window if the user's preference say we should.
+	"""
+	bCreate = LoadPreference("Show at startup", 1)
+	if bCreate:
+		CreateInteractiveWindow(makeDoc, makeFrame)
+
+def CreateInteractiveWindow(makeDoc = None, makeFrame = None):
+	"""Create a standard or docked interactive window unconditionally
+	"""
+	assert edit is None, "Creating second interactive window!"
+	bDocking = LoadPreference("Docking", 0)
+	if bDocking:
+		CreateDockedInteractiveWindow()
+	else:
+		CreateMDIInteractiveWindow(makeDoc, makeFrame)
+	assert edit is not None, "Created interactive window, but did not set the global!"
+	edit.currentView.SetFocus()
+
+def CreateMDIInteractiveWindow(makeDoc = None, makeFrame = None):
+	"""Create a standard (non-docked) interactive window unconditionally
+	"""
+	global edit
+	if makeDoc is None: makeDoc = InteractiveDocument
+	if makeFrame is None: makeFrame = InteractiveFrame
+	edit = CInteractivePython(makeDoc=makeDoc,makeFrame=makeFrame)
+
+def DestroyInteractiveWindow():
+	""" Destroy the interactive window.
+	This is different to Closing the window,
+	which may automatically re-appear.  Once destroyed, it can never be recreated,
+	and a complete new instance must be created (which the various other helper
+	functions will then do after making this call
+	"""
+	global edit
+	if edit is not None and edit.currentView is not None:
+		if edit.currentView.GetParentFrame() == win32ui.GetMainFrame():
+			# It is docked - do nothing now (this is only called at shutdown!)
+			pass
+		else:
+			# It is a standard window - call Close on the container.
+			edit.Close()
+			edit = None
+
+def CloseInteractiveWindow():
+	"""Close the interactive window, allowing it to be re-created on demand.
+	"""
+	global edit
+	if edit is not None and edit.currentView is not None:
+		if edit.currentView.GetParentFrame() == win32ui.GetMainFrame():
+			# It is docked, just hide the dock bar.
+			frame = win32ui.GetMainFrame()
+			cb = frame.GetControlBar(ID_DOCKED_INTERACTIVE_CONTROLBAR)
+			frame.ShowControlBar(cb, 0, 1)
+		else:
+			# It is a standard window - destroy the frame/view, allowing the object itself to remain.
+			edit.currentView.GetParentFrame().DestroyWindow()
+
+def ToggleInteractiveWindow():
+	"""If the interactive window is visible, hide it, otherwise show it.
+	"""
+	if edit is None:
+		CreateInteractiveWindow()
+	else:
+		if edit.NeedRecreateWindow():
+			edit.RecreateWindow()
+		else:
+			# Close it, allowing a reopen.
+			CloseInteractiveWindow()
+
+def ShowInteractiveWindow():
+	"""Shows (or creates if necessary) an interactive window"""
+	if edit is None:
+		CreateInteractiveWindow()
+	else:
+		if edit.NeedRecreateWindow():
+			edit.RecreateWindow()
+		else:
+			parent = edit.currentView.GetParentFrame()
+			if parent == win32ui.GetMainFrame(): # It is docked.
+				edit.currentView.SetFocus()
+			else: # It is a "normal" window
+				edit.currentView.GetParentFrame().AutoRestore()
+				win32ui.GetMainFrame().MDIActivate(edit.currentView.GetParentFrame())
+
+def IsInteractiveWindowVisible():
+	return edit is not None and not edit.NeedRecreateWindow()