????
Your IP : 216.73.216.233
##################################################################
##
## Interactive Shell Window
##
import array
import code
import os
import string
import sys
import traceback
import __main__
import afxres
import pywin.framework.app
import pywin.scintilla.control
import pywin.scintilla.formatter
import pywin.scintilla.IDLEenvironment
import win32api
import win32clipboard
import win32con
import win32ui
## sequential after ID_GOTO_LINE defined in editor.py
ID_EDIT_COPY_CODE = 0xE2002
ID_EDIT_EXEC_CLIPBOARD = 0x2003
trace = pywin.scintilla.formatter.trace
import re
from . import winout
# 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:
exec(
compile(
open(rcfile, "rb").read(), rcfile, "exec", dont_inherit=True
),
__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()