Sources_For_Win/ParaView/Lib/site-packages/pythonwin/pywin/scintilla/view.py

# A general purpose MFC CCtrlView view that uses Scintilla.

from . import control
from . import IDLEenvironment # IDLE emulation.
from pywin.mfc import docview
from pywin.mfc import dialog
from . import scintillacon
import win32con
import win32ui
import afxres
import string
import array
import sys
import types
import __main__ # for attribute lookup
from . import bindings
from . import keycodes
import struct
import re
import os

PRINTDLGORD = 1538
IDC_PRINT_MAG_EDIT = 1010
EM_FORMATRANGE = win32con.WM_USER+57

wordbreaks = "._" + string.ascii_uppercase + string.ascii_lowercase + string.digits

patImport=re.compile('import (?P<name>.*)')

_event_commands = [
	# File menu
	"win32ui.ID_FILE_LOCATE", "win32ui.ID_FILE_CHECK", "afxres.ID_FILE_CLOSE",
	"afxres.ID_FILE_NEW", "afxres.ID_FILE_OPEN", "afxres.ID_FILE_SAVE",
	"afxres.ID_FILE_SAVE_AS", "win32ui.ID_FILE_SAVE_ALL",
	# Edit menu
	"afxres.ID_EDIT_UNDO", "afxres.ID_EDIT_REDO", "afxres.ID_EDIT_CUT",
	"afxres.ID_EDIT_COPY", "afxres.ID_EDIT_PASTE", "afxres.ID_EDIT_SELECT_ALL",
	"afxres.ID_EDIT_FIND", "afxres.ID_EDIT_REPEAT", "afxres.ID_EDIT_REPLACE", 
	# View menu
	"win32ui.ID_VIEW_WHITESPACE", "win32ui.ID_VIEW_FIXED_FONT",
	"win32ui.ID_VIEW_BROWSE", "win32ui.ID_VIEW_INTERACTIVE",
	# Window menu
	"afxres.ID_WINDOW_ARRANGE", "afxres.ID_WINDOW_CASCADE",
	"afxres.ID_WINDOW_NEW", "afxres.ID_WINDOW_SPLIT",
	"afxres.ID_WINDOW_TILE_HORZ", "afxres.ID_WINDOW_TILE_VERT",
	# Others
	"afxres.ID_APP_EXIT", "afxres.ID_APP_ABOUT",
]

_extra_event_commands = [
	("EditDelete", afxres.ID_EDIT_CLEAR),
	("LocateModule", win32ui.ID_FILE_LOCATE),
	("GotoLine", win32ui.ID_EDIT_GOTO_LINE),
	("DbgBreakpointToggle", win32ui.IDC_DBG_ADD),
	("DbgGo", win32ui.IDC_DBG_GO),
	("DbgStepOver", win32ui.IDC_DBG_STEPOVER),
	("DbgStep", win32ui.IDC_DBG_STEP),
	("DbgStepOut", win32ui.IDC_DBG_STEPOUT),
	("DbgBreakpointClearAll", win32ui.IDC_DBG_CLEAR),
	("DbgClose", win32ui.IDC_DBG_CLOSE),
]

event_commands = []
def _CreateEvents():
	for name in _event_commands:
		val = eval(name)
		name_parts = name.split("_")[1:]
		name_parts = [p.capitalize() for p in name_parts]
		event = ''.join(name_parts)
		event_commands.append((event, val))
	for name, id in _extra_event_commands:
		event_commands.append((name, id))

_CreateEvents()
del _event_commands; del _extra_event_commands

command_reflectors = [
	(win32ui.ID_EDIT_UNDO, win32con.WM_UNDO),
	(win32ui.ID_EDIT_REDO, scintillacon.SCI_REDO),
	(win32ui.ID_EDIT_CUT, win32con.WM_CUT),
	(win32ui.ID_EDIT_COPY, win32con.WM_COPY),
	(win32ui.ID_EDIT_PASTE, win32con.WM_PASTE),
	(win32ui.ID_EDIT_CLEAR, win32con.WM_CLEAR),
	(win32ui.ID_EDIT_SELECT_ALL, scintillacon.SCI_SELECTALL),
]

def DoBraceMatch(control):
		curPos = control.SCIGetCurrentPos()
		charBefore = ' '
		if curPos: charBefore = control.SCIGetCharAt(curPos-1)
		charAt = control.SCIGetCharAt(curPos)
		braceAtPos = braceOpposite = -1
		if charBefore in "[](){}": braceAtPos = curPos-1
		if braceAtPos==-1:
			if charAt in "[](){}": braceAtPos = curPos
		if braceAtPos != -1:
			braceOpposite = control.SCIBraceMatch(braceAtPos, 0)
		if braceAtPos != -1 and braceOpposite==-1:
			control.SCIBraceBadHighlight(braceAtPos)
		else:
			# either clear them both or set them both.
			control.SCIBraceHighlight(braceAtPos, braceOpposite)

def _get_class_attributes(ob):
	# Recurse into base classes looking for attributes
	items = []
	try:
		items = items + dir(ob)
		for i in ob.__bases__:
			for item in _get_class_attributes(i):
				if item not in items:
					items.append(item)
	except AttributeError:
		pass
	return items

# Supposed to look like an MFC CEditView, but 
# also supports IDLE extensions and other source code generic features.
class CScintillaView(docview.CtrlView, control.CScintillaColorEditInterface):
	def __init__(self, doc):
		docview.CtrlView.__init__(self, doc, "Scintilla", win32con.WS_CHILD | win32con.WS_VSCROLL | win32con.WS_HSCROLL | win32con.WS_CLIPCHILDREN | win32con.WS_VISIBLE)
		self._tabWidth = 8 # Mirror of what we send to Scintilla - never change this directly
		self.bAutoCompleteAttributes = 1
		self.bShowCallTips = 1
		self.bMatchBraces = 0 # Editor option will default this to true later!
		self.bindings = bindings.BindingsManager(self)

		self.idle = IDLEenvironment.IDLEEditorWindow(self)
		self.idle.IDLEExtension("AutoExpand")
		# SendScintilla is called so frequently it is worth optimizing.
		self.SendScintilla = self._obj_.SendMessage

	def OnDestroy(self, msg):
		self.SendScintilla = None
		return docview.CtrlView.OnDestroy(self, msg)

	def _MakeColorizer(self):
		ext = os.path.splitext(self.GetDocument().GetPathName())[1]
		from . import formatter
		return formatter.BuiltinPythonSourceFormatter(self, ext)

	
#	def SendScintilla(self, msg, w=0, l=0):
#		return self._obj_.SendMessage(msg, w, l)

	def SCISetTabWidth(self, width):
		# I need to remember the tab-width for the AutoIndent extension.  This may go.
		self._tabWidth = width
		control.CScintillaEditInterface.SCISetTabWidth(self, width)

	def GetTabWidth(self):
		return self._tabWidth

	def HookHandlers(self):
		# Create events for all the menu names.
		for name, val in event_commands:
#			handler = lambda id, code, tosend=val, parent=parent: parent.OnCommand(tosend, 0) and 0
			self.bindings.bind(name, None, cid=val)

		# Hook commands that do nothing other than send Scintilla messages.
		for command, reflection in command_reflectors:
			handler = lambda id, code, ss=self.SendScintilla, tosend=reflection: ss(tosend) and 0
			self.HookCommand(handler, command)

		self.HookCommand(self.OnCmdViewWS, win32ui.ID_VIEW_WHITESPACE)
		self.HookCommandUpdate(self.OnUpdateViewWS, win32ui.ID_VIEW_WHITESPACE)
		self.HookCommand(self.OnCmdViewIndentationGuides, win32ui.ID_VIEW_INDENTATIONGUIDES)
		self.HookCommandUpdate(self.OnUpdateViewIndentationGuides, win32ui.ID_VIEW_INDENTATIONGUIDES)
		self.HookCommand(self.OnCmdViewRightEdge, win32ui.ID_VIEW_RIGHT_EDGE)
		self.HookCommandUpdate(self.OnUpdateViewRightEdge, win32ui.ID_VIEW_RIGHT_EDGE)
		self.HookCommand(self.OnCmdViewEOL, win32ui.ID_VIEW_EOL)
		self.HookCommandUpdate(self.OnUpdateViewEOL, win32ui.ID_VIEW_EOL)
		self.HookCommand(self.OnCmdViewFixedFont, win32ui.ID_VIEW_FIXED_FONT)
		self.HookCommandUpdate(self.OnUpdateViewFixedFont, win32ui.ID_VIEW_FIXED_FONT)
		self.HookCommand(self.OnCmdFileLocate, win32ui.ID_FILE_LOCATE)
		self.HookCommand(self.OnCmdEditFind, win32ui.ID_EDIT_FIND)
		self.HookCommand(self.OnCmdEditRepeat, win32ui.ID_EDIT_REPEAT)
		self.HookCommand(self.OnCmdEditReplace, win32ui.ID_EDIT_REPLACE)
		self.HookCommand(self.OnCmdGotoLine, win32ui.ID_EDIT_GOTO_LINE)
		self.HookCommand(self.OnFilePrint, afxres.ID_FILE_PRINT)
		self.HookCommand(self.OnFilePrint, afxres.ID_FILE_PRINT_DIRECT)
		self.HookCommand(self.OnFilePrintPreview,
			win32ui.ID_FILE_PRINT_PREVIEW)
		# Key bindings.
		self.HookMessage(self.OnKeyDown, win32con.WM_KEYDOWN)
		self.HookMessage(self.OnKeyDown, win32con.WM_SYSKEYDOWN)
		# Hook wheeley mouse events
#		self.HookMessage(self.OnMouseWheel, win32con.WM_MOUSEWHEEL)
		self.HookFormatter()

	def OnInitialUpdate(self):
		doc = self.GetDocument()

		# Enable Unicode
		self.SendScintilla(scintillacon.SCI_SETCODEPAGE, scintillacon.SC_CP_UTF8, 0)
		self.SendScintilla(scintillacon.SCI_SETKEYSUNICODE, 1, 0)

		# Create margins
		self.SendScintilla(scintillacon.SCI_SETMARGINTYPEN, 1, scintillacon.SC_MARGIN_SYMBOL);
		self.SendScintilla(scintillacon.SCI_SETMARGINMASKN, 1, 0xF);
		self.SendScintilla(scintillacon.SCI_SETMARGINTYPEN, 2, scintillacon.SC_MARGIN_SYMBOL);
		self.SendScintilla(scintillacon.SCI_SETMARGINMASKN, 2, scintillacon.SC_MASK_FOLDERS);
		self.SendScintilla(scintillacon.SCI_SETMARGINSENSITIVEN, 2, 1);

		self.GetDocument().HookViewNotifications(self) # is there an MFC way to grab this?
		self.HookHandlers()

		# Load the configuration information.
		self.OnWinIniChange(None)

		self.SetSel()

		self.GetDocument().FinalizeViewCreation(self) # is there an MFC way to grab this?
		

	def _GetSubConfigNames(self):
		return None # By default we use only sections without sub-sections.

	def OnWinIniChange(self, section = None):
		self.bindings.prepare_configure()
		try:
			self.DoConfigChange()
		finally:
			self.bindings.complete_configure()

	def DoConfigChange(self):
		# Bit of a hack I dont kow what to do about - these should be "editor options"
		from pywin.framework.editor import GetEditorOption
		self.bAutoCompleteAttributes = GetEditorOption("Autocomplete Attributes", 1)
		self.bShowCallTips = GetEditorOption("Show Call Tips", 1)
		# Update the key map and extension data.
		configManager.configure(self, self._GetSubConfigNames())
		if configManager.last_error:
			win32ui.MessageBox(configManager.last_error, "Configuration Error")
		self.bMatchBraces = GetEditorOption("Match Braces", 1)
		self.ApplyFormattingStyles(1)

	def OnDestroy(self, msg):
		self.bindings.close()
		self.bindings = None
		self.idle.close()
		self.idle = None
		control.CScintillaColorEditInterface.close(self)
		return docview.CtrlView.OnDestroy(self, msg)

	def OnMouseWheel(self, msg):
		zDelta = msg[2] >> 16
		vpos = self.GetScrollPos(win32con.SB_VERT)
		vpos = vpos - zDelta/40 # 3 lines per notch
		self.SetScrollPos(win32con.SB_VERT, vpos)
		self.SendScintilla(win32con.WM_VSCROLL,
						   (vpos<<16) | win32con.SB_THUMBPOSITION,
						   0)

	def OnBraceMatch(self, std, extra):
		if not self.bMatchBraces: return
		DoBraceMatch(self)

	def OnNeedShown(self, std, extra):
		notify = self.SCIUnpackNotifyMessage(extra)
		# OnNeedShown is called before an edit operation when
		# text is folded (as it is possible the text insertion will happen
		# in a folded region.)  As this happens _before_ the insert,
		# we ignore the length (if we are at EOF, pos + length may
		# actually be beyond the end of buffer)
		self.EnsureCharsVisible(notify.position)

	def EnsureCharsVisible(self, start, end = None):
		if end is None: end = start
		lineStart = self.LineFromChar(min(start, end))
		lineEnd = self.LineFromChar(max(start, end))
		while lineStart <= lineEnd:
			self.SCIEnsureVisible(lineStart)
			lineStart = lineStart + 1

	# Helper to add an event to a menu.
	def AppendMenu(self, menu, text="", event=None, flags = None, checked=0):
		if event is None:
			assert flags is not None, "No event or custom flags!"
			cmdid = 0
		else:
			cmdid = self.bindings.get_command_id(event)
			if cmdid is None:
				# No event of that name - no point displaying it.
				print('View.AppendMenu(): Unknown event "%s" specified for menu text "%s" - ignored' % (event, text))
				return 
			keyname = configManager.get_key_binding( event, self._GetSubConfigNames() )
			if keyname is not None:
				text = text + "\t" + keyname
		if flags is None: flags = win32con.MF_STRING|win32con.MF_ENABLED
		if checked: flags = flags | win32con.MF_CHECKED
		menu.AppendMenu(flags, cmdid, text)

	def OnKeyDown(self, msg):
		return self.bindings.fire_key_event( msg )

	def GotoEndOfFileEvent(self, event):
		self.SetSel(-1)

	def KeyDotEvent(self, event):
		## Don't trigger autocomplete if any text is selected
		s,e = self.GetSel()
		if s!=e:
			return 1
		self.SCIAddText(".")
		if self.bAutoCompleteAttributes:
			self._AutoComplete()

	# View Whitespace/EOL/Indentation UI.

	def OnCmdViewWS(self, cmd, code): # Handle the menu command
		viewWS = self.SCIGetViewWS()
		self.SCISetViewWS(not viewWS)
	def OnUpdateViewWS(self, cmdui): # Update the tick on the UI.
		cmdui.SetCheck(self.SCIGetViewWS())
		cmdui.Enable()
	def OnCmdViewIndentationGuides(self, cmd, code): # Handle the menu command
		viewIG = self.SCIGetIndentationGuides()
		self.SCISetIndentationGuides(not viewIG)
	def OnUpdateViewIndentationGuides(self, cmdui): # Update the tick on the UI.
		cmdui.SetCheck(self.SCIGetIndentationGuides())
		cmdui.Enable()
	def OnCmdViewRightEdge(self, cmd, code): # Handle the menu command
		if self.SCIGetEdgeMode() == scintillacon.EDGE_NONE:
			mode = scintillacon.EDGE_BACKGROUND
		else:
			mode = scintillacon.EDGE_NONE
		self.SCISetEdgeMode(mode)
	def OnUpdateViewRightEdge(self, cmdui): # Update the tick on the UI.
		cmdui.SetCheck(self.SCIGetEdgeMode() != scintillacon.EDGE_NONE)
		cmdui.Enable()
	def OnCmdViewEOL(self, cmd, code): # Handle the menu command
		viewEOL = self.SCIGetViewEOL()
		self.SCISetViewEOL(not viewEOL)
	def OnUpdateViewEOL(self, cmdui): # Update the tick on the UI.
		cmdui.SetCheck(self.SCIGetViewEOL())
		cmdui.Enable()

	def OnCmdViewFixedFont(self, cmd, code): # Handle the menu command
		self._GetColorizer().bUseFixed = not self._GetColorizer().bUseFixed
		self.ApplyFormattingStyles(0)
		# Ensure the selection is visible!
		self.ScrollCaret()

	def OnUpdateViewFixedFont(self, cmdui): # Update the tick on the UI.
		c = self._GetColorizer()
		if c is not None: cmdui.SetCheck(c.bUseFixed)
		cmdui.Enable(c is not None)

	def OnCmdEditFind(self, cmd, code):
		from . import find
		find.ShowFindDialog()
	def OnCmdEditRepeat(self, cmd, code):
		from . import find
		find.FindNext()
	def OnCmdEditReplace(self, cmd, code):
		from . import find
		find.ShowReplaceDialog()

	def OnCmdFileLocate(self, cmd, id):
		line = self.GetLine().strip()
		import pywin.framework.scriptutils
		m = patImport.match(line)
		if m:
			# Module name on this line - locate that!
			modName = m.group('name')
			fileName = pywin.framework.scriptutils.LocatePythonFile(modName)
			if fileName is None:
				win32ui.SetStatusText("Can't locate module %s" % modName)
				return 1 # Let the default get it.
			else:
				win32ui.GetApp().OpenDocumentFile(fileName)
		else:
			# Just to a "normal" locate - let the default handler get it.
			return 1
		return 0

	def OnCmdGotoLine(self, cmd, id):
		try:
			lineNo = int(input("Enter Line Number"))-1
		except (ValueError, KeyboardInterrupt):
			return 0
		self.SCIEnsureVisible(lineNo)
		self.SCIGotoLine(lineNo)
		return 0

	def SaveTextFile(self, filename, encoding=None):
		doc = self.GetDocument()
		doc._SaveTextToFile(self, filename, encoding=encoding)
		doc.SetModifiedFlag(0)
		return 1

	def _AutoComplete(self):
		def list2dict(l):
			ret={}
			for i in l:
				ret[i] = None
			return ret

		self.SCIAutoCCancel() # Cancel old auto-complete lists.
		# First try and get an object without evaluating calls
		ob = self._GetObjectAtPos(bAllowCalls = 0)
		# If that failed, try and process call or indexing to get the object.
		if ob is None:
			ob = self._GetObjectAtPos(bAllowCalls = 1)
		items_dict = {}
		if ob is not None:
			try: # Catch unexpected errors when fetching attribute names from the object
				# extra attributes of win32ui objects
				if hasattr(ob, "_obj_"):
					try:
						items_dict.update(list2dict(dir(ob._obj_)))
					except AttributeError:
						pass # object has no __dict__
				
				# normal attributes
				try:
					items_dict.update(list2dict(dir(ob)))
				except AttributeError:
					pass # object has no __dict__
				if hasattr(ob, "__class__"):
					items_dict.update(list2dict(_get_class_attributes(ob.__class__)))
				# The object may be a COM object with typelib support - lets see if we can get its props.
				# (contributed by Stefan Migowsky)
				try:
					# Get the automation attributes
					items_dict.update(ob.__class__._prop_map_get_)
					# See if there is an write only property 
					# could be optimized
					items_dict.update(ob.__class__._prop_map_put_)
					# append to the already evaluated list
				except AttributeError:
					pass
				# The object might be a pure COM dynamic dispatch with typelib support - lets see if we can get its props.
				if hasattr(ob, "_oleobj_"):
					try:
						for iTI in range(0,ob._oleobj_.GetTypeInfoCount()):
							typeInfo = ob._oleobj_.GetTypeInfo(iTI)
							self._UpdateWithITypeInfo (items_dict, typeInfo)
					except:
						pass
			except:
				win32ui.SetStatusText("Error attempting to get object attributes - %s" % (repr(sys.exc_info()[0]),))

		# ensure all keys are strings.
		items = [str(k) for k in items_dict.keys()]
		# All names that start with "_" go!
		items = [k for k in items if not k.startswith('_')]

		if not items:
			# Heuristics a-la AutoExpand
			# The idea is to find other usages of the current binding
			# and assume, that it refers to the same object (or at least,
			# to an object of the same type)
			# Contributed by Vadim Chugunov [vadimch@yahoo.com]
			left, right = self._GetWordSplit()
			if left=="": # Ignore standalone dots
				return None
			# We limit our search to the current class, if that
			# information is available
			minline, maxline, curclass = self._GetClassInfoFromBrowser()
			endpos = self.LineIndex(maxline)
			text = self.GetTextRange(self.LineIndex(minline),endpos)
			try:
				l = re.findall(r"\b"+left+"\.\w+",text)
			except re.error:
				# parens etc may make an invalid RE, but this code wouldnt
				# benefit even if the RE did work :-)
				l = []
			prefix = len(left)+1
			unique = {}
			for li in l:
				unique[li[prefix:]] = 1
			# Assuming traditional usage of self...
			if curclass and left=="self":
				self._UpdateWithClassMethods(unique,curclass)

			items = [word for word in unique.keys() if word[:2]!='__' or word[-2:]!='__']
			# Ignore the word currently to the right of the dot - probably a red-herring.
			try:
				items.remove(right[1:])
			except ValueError:
				pass
		if items:
			items.sort()
			self.SCIAutoCSetAutoHide(0)
			self.SCIAutoCShow(items)

	def _UpdateWithITypeInfo (self, items_dict, typeInfo):
		import pythoncom
		typeInfos = [typeInfo]
		# suppress IDispatch and IUnknown methods
		inspectedIIDs = {pythoncom.IID_IDispatch:None}

		while len(typeInfos)>0:
			typeInfo = typeInfos.pop()
			typeAttr = typeInfo.GetTypeAttr()

			if typeAttr.iid not in inspectedIIDs:
				inspectedIIDs[typeAttr.iid] = None
				for iFun in range(0,typeAttr.cFuncs):
					funDesc = typeInfo.GetFuncDesc(iFun)
					funName = typeInfo.GetNames(funDesc.memid)[0]
					if funName not in items_dict:
						items_dict[funName] = None

				# Inspect the type info of all implemented types
				# E.g. IShellDispatch5 implements IShellDispatch4 which implements IShellDispatch3 ...
				for iImplType in range(0,typeAttr.cImplTypes):
					iRefType = typeInfo.GetRefTypeOfImplType(iImplType)
					refTypeInfo = typeInfo.GetRefTypeInfo(iRefType)
					typeInfos.append(refTypeInfo)

	# TODO: This is kinda slow. Probably need some kind of cache 
	# here that is flushed upon file save
	# Or maybe we don't need the superclass methods at all ?
	def _UpdateWithClassMethods(self,dict,classinfo):
		if not hasattr(classinfo,"methods"):
			# No 'methods' - probably not what we think it is.
			return
		dict.update(classinfo.methods)
		for super in classinfo.super:
			if hasattr(super,"methods"):
				self._UpdateWithClassMethods(dict,super)

	# Find which class definition caret is currently in and return
	# indexes of the the first and the last lines of that class definition
	# Data is obtained from module browser (if enabled)
	def _GetClassInfoFromBrowser(self,pos=-1):
		minline = 0
		maxline = self.GetLineCount()-1
		doc = self.GetParentFrame().GetActiveDocument()
		browser = None
		try:
			if doc is not None:
				browser = doc.GetAllViews()[1]
		except IndexError:
			pass
		if browser is None:
			return (minline,maxline,None) # Current window has no browser
		if not browser.list: return (minline,maxline,None) # Not initialized
		path = self.GetDocument().GetPathName()
		if not path: return (minline,maxline,None) # No current path
		
		import pywin.framework.scriptutils
		curmodule, path = pywin.framework.scriptutils.GetPackageModuleName(path)
		try:
			clbrdata = browser.list.root.clbrdata
		except AttributeError:
			return (minline,maxline,None) # No class data for this module.
		curline = self.LineFromChar(pos)
		curclass = None
		# Find out which class we are in
		for item in clbrdata.values():
			if item.module==curmodule:
				item_lineno = item.lineno - 1 # Scintilla counts lines from 0, whereas pyclbr - from 1
				if minline < item_lineno <= curline:
					minline = item_lineno
					curclass = item
				if curline < item_lineno < maxline:
					maxline = item_lineno
		return (minline,maxline,curclass)


	def _GetObjectAtPos(self, pos = -1, bAllowCalls = 0):
		left, right = self._GetWordSplit(pos, bAllowCalls)
		if left: # It is an attribute lookup
			# How is this for a hack!
			namespace = sys.modules.copy()
			namespace.update(__main__.__dict__)
			# Get the debugger's context.
			try:
				from pywin.framework import interact
				if interact.edit is not None and interact.edit.currentView is not None:
					globs, locs = interact.edit.currentView.GetContext()[:2]
					if globs: namespace.update(globs)
					if locs: namespace.update(locs)
			except ImportError:
				pass
			try:
				return eval(left, namespace)
			except:
				pass
		return None

	def _GetWordSplit(self, pos = -1, bAllowCalls = 0):
		if pos==-1: pos = self.GetSel()[0]-1 # Character before current one
		limit = self.GetTextLength()
		before = []
		after = []
		index = pos-1
		wordbreaks_use = wordbreaks
		if bAllowCalls: wordbreaks_use = wordbreaks_use + "()[]"
		while index>=0:
			char = self.SCIGetCharAt(index)
			if char not in wordbreaks_use: break
			before.insert(0, char)
			index = index-1
		index = pos
		while index<=limit:
			char = self.SCIGetCharAt(index)
			if char not in wordbreaks_use: break
			after.append(char)
			index=index+1
		return ''.join(before), ''.join(after)

	def OnPrepareDC (self, dc, pInfo):
#		print "OnPrepareDC for page", pInfo.GetCurPage(), "of", pInfo.GetFromPage(), "to", pInfo.GetToPage(), ", starts=", self.starts
		if dc.IsPrinting():
			# Check if we are beyond the end.
			# (only do this when actually printing, else messes up print preview!)
			if not pInfo.GetPreview() and self.starts is not None:
				prevPage = pInfo.GetCurPage() - 1
				if prevPage > 0 and self.starts[prevPage] >= self.GetTextLength():
					# All finished.
					pInfo.SetContinuePrinting(0)
					return
			dc.SetMapMode(win32con.MM_TEXT);

	def OnPreparePrinting(self, pInfo):
		flags = win32ui.PD_USEDEVMODECOPIES | \
		        win32ui.PD_ALLPAGES | \
		        win32ui.PD_NOSELECTION # Dont support printing just a selection.
# NOTE: Custom print dialogs are stopping the user's values from coming back :-(
#		self.prtDlg = PrintDialog(pInfo, PRINTDLGORD, flags)
#		pInfo.SetPrintDialog(self.prtDlg)
		pInfo.SetMinPage(1)
		# max page remains undefined for now.
		pInfo.SetFromPage(1)
		pInfo.SetToPage(1)
		ret = self.DoPreparePrinting(pInfo)
		return ret

	def OnBeginPrinting(self, dc, pInfo):
		self.starts = None
		return self._obj_.OnBeginPrinting(dc, pInfo)

	def CalculatePageRanges(self, dc, pInfo):
		# Calculate page ranges and max page
		self.starts = {0:0}
		metrics = dc.GetTextMetrics()
		left, top, right, bottom = pInfo.GetDraw()
		# Leave space at the top for the header.
		rc = (left, top + int((9*metrics['tmHeight'])/2), right, bottom)
		pageStart = 0
		maxPage = 0
		textLen = self.GetTextLength()
		while pageStart < textLen:
			pageStart = self.FormatRange(dc, pageStart, textLen, rc, 0)
			maxPage = maxPage + 1
			self.starts[maxPage] = pageStart
		# And a sentinal for one page past the end
		self.starts[maxPage+1] = textLen
		# When actually printing, maxPage doesnt have any effect at this late state.
		# but is needed to make the Print Preview work correctly.
		pInfo.SetMaxPage(maxPage)

	def OnFilePrintPreview(self, *arg):
		self._obj_.OnFilePrintPreview()

	def OnFilePrint(self, *arg):
		self._obj_.OnFilePrint()

	def FormatRange(self, dc, pageStart, lengthDoc, rc, draw):
		"""
		typedef struct _formatrange {
			HDC hdc;
			HDC hdcTarget;
			RECT rc;
			RECT rcPage;
			CHARRANGE chrg;} FORMATRANGE;
		"""
		fmt='PPIIIIIIIIll'
		hdcRender = dc.GetHandleOutput()
		hdcFormat = dc.GetHandleAttrib()
		fr = struct.pack(fmt, hdcRender, hdcFormat, rc[0], rc[1], rc[2], rc[3], rc[0], rc[1], rc[2], rc[3], pageStart, lengthDoc)
		nextPageStart = self.SendScintilla(EM_FORMATRANGE, draw, fr)
		return nextPageStart

	def OnPrint(self, dc, pInfo):
		metrics = dc.GetTextMetrics()
#		print "dev", w, h, l, metrics['tmAscent'], metrics['tmDescent']
		if self.starts is None:
			self.CalculatePageRanges(dc, pInfo)
		pageNum = pInfo.GetCurPage() - 1
		# Setup the header of the page - docname on left, pagenum on right.
		doc = self.GetDocument()
		cxChar = metrics['tmAveCharWidth']
		cyChar = metrics['tmHeight']
		left, top, right, bottom = pInfo.GetDraw()
		dc.TextOut(0, 2*cyChar, doc.GetTitle())
		pagenum_str = win32ui.LoadString(afxres.AFX_IDS_PRINTPAGENUM) % (pageNum+1,)
		dc.SetTextAlign(win32con.TA_RIGHT)
		dc.TextOut(right, 2*cyChar, pagenum_str)
		dc.SetTextAlign(win32con.TA_LEFT)
		top = top + int((7*cyChar)/2)
		dc.MoveTo(left, top)
		dc.LineTo(right, top)
		top = top + cyChar
		rc = (left, top, right, bottom)
		nextPageStart = self.FormatRange(dc, self.starts[pageNum], self.starts[pageNum+1], rc, 1)

def LoadConfiguration():
	global configManager
	# Bit of a hack I dont kow what to do about?
	from .config import ConfigManager
	configName = rc = win32ui.GetProfileVal("Editor", "Keyboard Config", "default")
	configManager = ConfigManager(configName)
	if configManager.last_error:
		bTryDefault = 0
		msg = "Error loading configuration '%s'\n\n%s" % (configName, configManager.last_error)
		if configName != "default":
			msg = msg + "\n\nThe default configuration will be loaded."
			bTryDefault = 1
		win32ui.MessageBox(msg)
		if bTryDefault:
			configManager = ConfigManager("default")
			if configManager.last_error:
				win32ui.MessageBox("Error loading configuration 'default'\n\n%s" % (configManager.last_error))

configManager = None
LoadConfiguration()