[wxWidgets.git] / wxPython / samples / pydocview / TextEditor.py

#----------------------------------------------------------------------------
# Name:         TextEditor.py
# Purpose:      Text Editor for pydocview
#
# Author:       Peter Yared
#
# Created:      8/15/03
# CVS-ID:       $Id$
# Copyright:    (c) 2003-2005 ActiveGrid, Inc.
# License:      wxWindows License
#----------------------------------------------------------------------------
import wx
import wx.lib.docview
import wx.lib.pydocview
import string
import FindService
_ = wx.GetTranslation

class TextDocument(wx.lib.docview.Document):
    
    def __init__(self):
        wx.lib.docview.Document .__init__(self)
        self._inModify = False


    def SaveObject(self, fileObject):
        view = self.GetFirstView()
        fileObject.write(view.GetTextCtrl().GetValue())
        return True


    def LoadObject(self, fileObject):
        view = self.GetFirstView()
        data = fileObject.read()
        view.GetTextCtrl().SetValue(data)
        return True


    def IsModified(self):
        view = self.GetFirstView()
        if view and view.GetTextCtrl():
            return view.GetTextCtrl().IsModified()
        return False


    def Modify(self, modify):
        if self._inModify:
            return
        self._inModify = True
        
        view = self.GetFirstView()
        if not modify and view and view.GetTextCtrl():
            view.GetTextCtrl().DiscardEdits()

        wx.lib.docview.Document.Modify(self, modify)  # this must called be after the DiscardEdits call above.

        self._inModify = False


class TextView(wx.lib.docview.View):


    #----------------------------------------------------------------------------
    # Overridden methods
    #----------------------------------------------------------------------------

    def __init__(self):
        wx.lib.docview.View.__init__(self)
        self._textCtrl = None
        self._wordWrap = wx.ConfigBase_Get().ReadInt("TextEditorWordWrap", True)


    def OnCreate(self, doc, flags):
        frame = wx.GetApp().CreateDocumentFrame(self, doc, flags)
        sizer = wx.BoxSizer()
        font, color = self._GetFontAndColorFromConfig()
        self._textCtrl = self._BuildTextCtrl(frame, font, color = color)
        self._textCtrl.Bind(wx.EVT_TEXT, self.OnModify)
        sizer.Add(self._textCtrl, 1, wx.EXPAND, 0)
        frame.SetSizer(sizer)
        frame.Layout()
        frame.Show(True)
        self.Activate()
        return True


    def OnModify(self, event):
        self.GetDocument().Modify(True)


    def _BuildTextCtrl(self, parent, font, color = wx.BLACK, value = "", selection = [0, 0]):
        if self._wordWrap:
            wordWrapStyle = wx.TE_WORDWRAP
        else:
            wordWrapStyle = wx.TE_DONTWRAP
        textCtrl = wx.TextCtrl(parent, -1, pos = wx.DefaultPosition, size = parent.GetClientSize(), style = wx.TE_MULTILINE | wordWrapStyle)
        textCtrl.SetFont(font)
        textCtrl.SetForegroundColour(color)
        textCtrl.SetValue(value)
        return textCtrl


    def _GetFontAndColorFromConfig(self):
        font = wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL)
        config = wx.ConfigBase_Get()
        fontData = config.Read("TextEditorFont", "")
        if fontData:
            nativeFont = wx.NativeFontInfo()
            nativeFont.FromString(fontData)
            font.SetNativeFontInfo(nativeFont)
        color = wx.BLACK
        colorData = config.Read("TextEditorColor", "")
        if colorData:
            red = int("0x" + colorData[0:2], 16)
            green = int("0x" + colorData[2:4], 16)
            blue = int("0x" + colorData[4:6], 16)
            color = wx.Color(red, green, blue)
        return font, color


    def OnCreateCommandProcessor(self):
        # Don't create a command processor, it has its own
        pass


    def OnActivateView(self, activate, activeView, deactiveView):
        if activate and self._textCtrl:
            # In MDI mode just calling set focus doesn't work and in SDI mode using CallAfter causes an endless loop
            if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI:
                self._textCtrl.SetFocus()
            else:
                def SetFocusToTextCtrl():
                    if self._textCtrl:  # Need to make sure it is there in case we are in the closeall mode of the MDI window
                        self._textCtrl.SetFocus()
                wx.CallAfter(SetFocusToTextCtrl)


    def OnUpdate(self, sender = None, hint = None):
        if wx.lib.docview.View.OnUpdate(self, sender, hint):
            return

        if hint == "Word Wrap":
            self.SetWordWrap(wx.ConfigBase_Get().ReadInt("TextEditorWordWrap", True))
        elif hint == "Font":
            font, color = self._GetFontAndColorFromConfig()
            self.SetFont(font, color)


    def OnClose(self, deleteWindow = True):
        if not wx.lib.docview.View.OnClose(self, deleteWindow):
            return False
        self.Activate(False)
        if deleteWindow and self.GetFrame():
            self.GetFrame().Destroy()
        return True


    # Since ProcessEvent is not virtual, we have to trap the relevant events using this pseudo-ProcessEvent instead of EVT_MENU
    def ProcessEvent(self, event):
        id = event.GetId()
        if id == wx.ID_UNDO:
            if not self._textCtrl:
                return False
            self._textCtrl.Undo()
            return True
        elif id == wx.ID_REDO:
            if not self._textCtrl:
                return False
            self._textCtrl.Redo()
            return True
        elif id == wx.ID_CUT:
            if not self._textCtrl:
                return False
            self._textCtrl.Cut()
            return True
        elif id == wx.ID_COPY:
            if not self._textCtrl:
                return False
            self._textCtrl.Copy()
            return True
        elif id == wx.ID_PASTE:
            if not self._textCtrl:
                return False
            self._textCtrl.Paste()
            return True
        elif id == wx.ID_CLEAR:
            if not self._textCtrl:
                return False
            self._textCtrl.Replace(self._textCtrl.GetSelection()[0], self._textCtrl.GetSelection()[1], '')
            return True
        elif id == wx.ID_SELECTALL:
            if not self._textCtrl:
                return False
            self._textCtrl.SetSelection(-1, -1)
            return True
        elif id == TextService.CHOOSE_FONT_ID:
            if not self._textCtrl:
                return False
            self.OnChooseFont(event)
            return True
        elif id == TextService.WORD_WRAP_ID:
            if not self._textCtrl:
                return False
            self.OnWordWrap(event)
            return True
        elif id == FindService.FindService.FIND_ID:
            self.OnFind()
            return True
        elif id == FindService.FindService.FIND_PREVIOUS_ID:
            self.DoFind(forceFindPrevious = True)
            return True
        elif id == FindService.FindService.FIND_NEXT_ID:
            self.DoFind(forceFindNext = True)
            return True
        elif id == FindService.FindService.REPLACE_ID:
            self.OnFind(replace = True)
            return True
        elif id == FindService.FindService.FINDONE_ID:
            self.DoFind()
            return True
        elif id == FindService.FindService.REPLACEONE_ID:
            self.DoFind(replace = True)
            return True
        elif id == FindService.FindService.REPLACEALL_ID:
            self.DoFind(replaceAll = True)
            return True
        elif id == FindService.FindService.GOTO_LINE_ID:
            self.OnGotoLine(event)
            return True
        else:
            return wx.lib.docview.View.ProcessEvent(self, event)


    def ProcessUpdateUIEvent(self, event):
        if not self._textCtrl:
            return False

        hasText = len(self._textCtrl.GetValue()) > 0

        id = event.GetId()
        if id == wx.ID_UNDO:
            event.Enable(self._textCtrl.CanUndo())
            return True
        elif id == wx.ID_REDO:
            event.Enable(self._textCtrl.CanRedo())
            return True
        if id == wx.ID_CUT:
            event.Enable(self._textCtrl.CanCut())
            return True
        elif id == wx.ID_COPY:
            event.Enable(self._textCtrl.CanCopy())
            return True
        elif id == wx.ID_PASTE:
            event.Enable(self._textCtrl.CanPaste())
            return True
        elif id == wx.ID_CLEAR:
            event.Enable(self._textCtrl.CanCopy())
            return True
        elif id == wx.ID_SELECTALL:
            event.Enable(hasText)
            return True
        elif id == TextService.CHOOSE_FONT_ID:
            event.Enable(True)
            return True
        elif id == TextService.WORD_WRAP_ID:
            event.Enable(True)
            return True
        elif id == FindService.FindService.FIND_ID:
            event.Enable(hasText)
            return True
        elif id == FindService.FindService.FIND_PREVIOUS_ID:
            event.Enable(hasText and
                         self._FindServiceHasString() and
                         self._textCtrl.GetSelection()[0] > 0)
            return True
        elif id == FindService.FindService.FIND_NEXT_ID:
            event.Enable(hasText and
                         self._FindServiceHasString() and
                         self._textCtrl.GetSelection()[0] < len(self._textCtrl.GetValue()))
            return True
        elif id == FindService.FindService.REPLACE_ID:
            event.Enable(hasText)
            return True
        elif id == FindService.FindService.GOTO_LINE_ID:
            event.Enable(True)
            return True
        else:
            return wx.lib.docview.View.ProcessUpdateUIEvent(self, event)


    #----------------------------------------------------------------------------
    # Methods for TextDocument to call
    #----------------------------------------------------------------------------

    def GetTextCtrl(self):
        return self._textCtrl


    #----------------------------------------------------------------------------
    # Format methods
    #----------------------------------------------------------------------------

    def OnChooseFont(self, event):
        data = wx.FontData()
        data.EnableEffects(True)
        data.SetInitialFont(self._textCtrl.GetFont())
        data.SetColour(self._textCtrl.GetForegroundColour())
        fontDialog = wx.FontDialog(self.GetFrame(), data)
        if fontDialog.ShowModal() == wx.ID_OK:
            data = fontDialog.GetFontData()
            self.SetFont(data.GetChosenFont(), data.GetColour())
        fontDialog.Destroy()


    def SetFont(self, font, color):
        self._textCtrl.SetFont(font)
        self._textCtrl.SetForegroundColour(color)
        self._textCtrl.Refresh()
        self._textCtrl.Layout()


    def OnWordWrap(self, event):
        self.SetWordWrap(not self.GetWordWrap())


    def GetWordWrap(self):
        return self._wordWrap


    def SetWordWrap(self, wordWrap = True):
        self._wordWrap = wordWrap
        temp = self._textCtrl
        self._textCtrl = self._BuildTextCtrl(temp.GetParent(),
                                             font = temp.GetFont(),
                                             color = temp.GetForegroundColour(),
                                             value = temp.GetValue(),
                                             selection = temp.GetSelection())
        self.GetDocument().Modify(temp.IsModified())
        temp.Destroy()


    #----------------------------------------------------------------------------
    # Find methods
    #----------------------------------------------------------------------------

    def OnFind(self, replace = False):
        findService = wx.GetApp().GetService(FindService.FindService)
        if findService:
            findService.ShowFindReplaceDialog(findString = self._textCtrl.GetStringSelection(), replace = replace)


    def DoFind(self, forceFindNext = False, forceFindPrevious = False, replace = False, replaceAll = False):
        findService = wx.GetApp().GetService(FindService.FindService)
        if not findService:
            return
        findString = findService.GetFindString()
        if len(findString) == 0:
            return -1
        replaceString = findService.GetReplaceString()
        flags = findService.GetFlags()
        startLoc, endLoc = self._textCtrl.GetSelection()

        wholeWord = flags & wx.FR_WHOLEWORD > 0
        matchCase = flags & wx.FR_MATCHCASE > 0
        regExp = flags & FindService.FindService.FR_REGEXP > 0
        down = flags & wx.FR_DOWN > 0
        wrap = flags & FindService.FindService.FR_WRAP > 0

        if forceFindPrevious:   # this is from function keys, not dialog box
            down = False
            wrap = False        # user would want to know they're at the end of file
        elif forceFindNext:
            down = True
            wrap = False        # user would want to know they're at the end of file

        # On replace dialog operations, user is allowed to replace the currently highlighted text to determine if it should be replaced or not.
        # Typically, it is the text from a previous find operation, but we must check to see if it isn't, user may have moved the cursor or selected some other text accidentally.
        # If the text is a match, then replace it.
        if replace:
            result, start, end, replText = findService.DoFind(findString, replaceString, self._textCtrl.GetStringSelection(), 0, 0, True, matchCase, wholeWord, regExp, replace)
            if result > 0:
                self._textCtrl.Replace(startLoc, endLoc, replaceString)
                self.GetDocument().Modify(True)
                wx.GetApp().GetTopWindow().PushStatusText(_("1 occurrence of \"%s\" replaced") % findString)
                if down:
                    startLoc += len(replText)  # advance start location past replacement string to new text
                endLoc = startLoc

        text = self._textCtrl.GetValue()
        if wx.Platform == "__WXMSW__":
            text = string.replace(text, '\n', '\r\n')

        # Find the next matching text occurance or if it is a ReplaceAll, replace all occurances
        # Even if the user is Replacing, we should replace here, but only select the text and let the user replace it with the next Replace operation
        result, start, end, text = findService.DoFind(findString, replaceString, text, startLoc, endLoc, down, matchCase, wholeWord, regExp, False, replaceAll, wrap)
        if result > 0:
            self._textCtrl.SetValue(text)
            self.GetDocument().Modify(True)
            if result == 1:
                wx.GetApp().GetTopWindow().PushStatusText(_("1 occurrence of \"%s\" replaced") % findString)
            else:
                wx.GetApp().GetTopWindow().PushStatusText(_("%i occurrences of \"%s\" replaced") % (result, findString))
        elif result == 0:
            self._textCtrl.SetSelection(start, end)
            self._textCtrl.SetFocus()
            wx.GetApp().GetTopWindow().PushStatusText(_("Found \"%s\"") % findString)
        else:
            wx.GetApp().GetTopWindow().PushStatusText(_("Can't find \"%s\"") % findString)


    def _FindServiceHasString(self):
        findService = wx.GetApp().GetService(FindService.FindService)
        if not findService or not findService.GetFindString():
            return False
        return True


    def OnGotoLine(self, event):
        findService = wx.GetApp().GetService(FindService.FindService)
        if findService:
            line = findService.GetLineNumber(self.GetDocumentManager().FindSuitableParent())
            if line > -1:
                pos = self._textCtrl.XYToPosition(0, line - 1)
                self._textCtrl.SetSelection(pos, pos)


class TextService(wx.lib.pydocview.DocService):


    WORD_WRAP_ID = wx.NewId()
    CHOOSE_FONT_ID = wx.NewId()


    def __init__(self):
        wx.lib.pydocview.DocService.__init__(self)


    def InstallControls(self, frame, menuBar = None, toolBar = None, statusBar = None, document = None):
        if document and document.GetDocumentTemplate().GetDocumentType() != TextDocument:
            return
        config = wx.ConfigBase_Get()

        formatMenuIndex = menuBar.FindMenu(_("&Format"))
        if formatMenuIndex > -1:
            formatMenu = menuBar.GetMenu(formatMenuIndex)
        else:
            formatMenu = wx.Menu()
        formatMenu = wx.Menu()
        if not menuBar.FindItemById(TextService.WORD_WRAP_ID):
            formatMenu.AppendCheckItem(TextService.WORD_WRAP_ID, _("Word Wrap"), _("Wraps text horizontally when checked"))
            formatMenu.Check(TextService.WORD_WRAP_ID, config.ReadInt("TextEditorWordWrap", True))
            wx.EVT_MENU(frame, TextService.WORD_WRAP_ID, frame.ProcessEvent)
            wx.EVT_UPDATE_UI(frame, TextService.WORD_WRAP_ID, frame.ProcessUpdateUIEvent)
        if not menuBar.FindItemById(TextService.CHOOSE_FONT_ID):
            formatMenu.Append(TextService.CHOOSE_FONT_ID, _("Font..."), _("Sets the font to use"))
            wx.EVT_MENU(frame, TextService.CHOOSE_FONT_ID, frame.ProcessEvent)
            wx.EVT_UPDATE_UI(frame, TextService.CHOOSE_FONT_ID, frame.ProcessUpdateUIEvent)
        if formatMenuIndex == -1:
            viewMenuIndex = menuBar.FindMenu(_("&View"))
            menuBar.Insert(viewMenuIndex + 1, formatMenu, _("&Format"))


    def ProcessUpdateUIEvent(self, event):
        id = event.GetId()
        if id == TextService.CHOOSE_FONT_ID:
            event.Enable(False)
            return True
        elif id == TextService.WORD_WRAP_ID:
            event.Enable(False)
            return True
        else:
            return False


class TextOptionsPanel(wx.Panel):


    def __init__(self, parent, id):
        wx.Panel.__init__(self, parent, id)
        SPACE = 10
        HALF_SPACE   = 5
        config = wx.ConfigBase_Get()
        self._textFont = wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL)
        fontData = config.Read("TextEditorFont", "")
        if fontData:
            nativeFont = wx.NativeFontInfo()
            nativeFont.FromString(fontData)
            self._textFont.SetNativeFontInfo(nativeFont)
        self._originalTextFont = self._textFont
        self._textColor = wx.BLACK
        colorData = config.Read("TextEditorColor", "")
        if colorData:
            red = int("0x" + colorData[0:2], 16)
            green = int("0x" + colorData[2:4], 16)
            blue = int("0x" + colorData[4:6], 16)
            self._textColor = wx.Color(red, green, blue)
        self._originalTextColor = self._textColor
        parent.AddPage(self, _("Text"))
        fontLabel = wx.StaticText(self, -1, _("Font:"))
        self._sampleTextCtrl = wx.TextCtrl(self, -1, "", size = (125, -1))
        self._sampleTextCtrl.SetEditable(False)
        chooseFontButton = wx.Button(self, -1, _("Choose Font..."))
        wx.EVT_BUTTON(self, chooseFontButton.GetId(), self.OnChooseFont)
        self._wordWrapCheckBox = wx.CheckBox(self, -1, _("Wrap words inside text area"))
        self._wordWrapCheckBox.SetValue(wx.ConfigBase_Get().ReadInt("TextEditorWordWrap", True))
        textPanelBorderSizer = wx.BoxSizer(wx.VERTICAL)
        textPanelSizer = wx.BoxSizer(wx.VERTICAL)
        textFontSizer = wx.BoxSizer(wx.HORIZONTAL)
        textFontSizer.Add(fontLabel, 0, wx.ALIGN_LEFT | wx.RIGHT | wx.TOP, HALF_SPACE)
        textFontSizer.Add(self._sampleTextCtrl, 0, wx.ALIGN_LEFT | wx.EXPAND | wx.RIGHT, HALF_SPACE)
        textFontSizer.Add(chooseFontButton, 0, wx.ALIGN_RIGHT | wx.LEFT, HALF_SPACE)
        textPanelSizer.Add(textFontSizer, 0, wx.ALL, HALF_SPACE)
        textPanelSizer.Add(self._wordWrapCheckBox, 0, wx.ALL, HALF_SPACE)
        textPanelBorderSizer.Add(textPanelSizer, 0, wx.ALL, SPACE)
        self.SetSizer(textPanelBorderSizer)
        self.UpdateSampleFont()


    def UpdateSampleFont(self):
        nativeFont = wx.NativeFontInfo()
        nativeFont.FromString(self._textFont.GetNativeFontInfoDesc())
        font = wx.NullFont
        font.SetNativeFontInfo(nativeFont)
        font.SetPointSize(self._sampleTextCtrl.GetFont().GetPointSize())  # Use the standard point size
        self._sampleTextCtrl.SetFont(font)
        self._sampleTextCtrl.SetForegroundColour(self._textColor)
        self._sampleTextCtrl.SetValue(_("%d pt. %s") % (self._textFont.GetPointSize(), self._textFont.GetFaceName()))
        self._sampleTextCtrl.Refresh()
        self.Layout()


    def OnChooseFont(self, event):
        data = wx.FontData()
        data.EnableEffects(True)
        data.SetInitialFont(self._textFont)
        data.SetColour(self._textColor)
        fontDialog = wx.FontDialog(self, data)
        if fontDialog.ShowModal() == wx.ID_OK:
            data = fontDialog.GetFontData()
            self._textFont = data.GetChosenFont()
            self._textColor = data.GetColour()
            self.UpdateSampleFont()
        fontDialog.Destroy()


    def OnOK(self, optionsDialog):
        config = wx.ConfigBase_Get()
        doWordWrapUpdate = config.ReadInt("TextEditorWordWrap", True) != self._wordWrapCheckBox.GetValue()
        config.WriteInt("TextEditorWordWrap", self._wordWrapCheckBox.GetValue())
        doFontUpdate = self._originalTextFont != self._textFont or self._originalTextColor != self._textColor
        config.Write("TextEditorFont", self._textFont.GetNativeFontInfoDesc())
        config.Write("TextEditorColor", "%02x%02x%02x" % (self._textColor.Red(), self._textColor.Green(), self._textColor.Blue()))
        if doWordWrapUpdate or doFontUpdate:
            for document in optionsDialog.GetDocManager().GetDocuments():
                if document.GetDocumentTemplate().GetDocumentType() == TextDocument:
                    if doWordWrapUpdate:
                        document.UpdateAllViews(hint = "Word Wrap")
                    if doFontUpdate:
                        document.UpdateAllViews(hint = "Font")
Commit	Line	Data
d1dc2b32 RD	1	#----------------------------------------------------------------------------
	2	# Name: TextEditor.py
	3	# Purpose: Text Editor for pydocview
	4	#
	5	# Author: Peter Yared
	6	#
	7	# Created: 8/15/03
	8	# CVS-ID: $Id$
3fa8f722	9	# Copyright: (c) 2003-2005 ActiveGrid, Inc.
b792147d	10	# License: wxWindows License
d1dc2b32 RD	11	#----------------------------------------------------------------------------
	12	import wx
	13	import wx.lib.docview
	14	import wx.lib.pydocview
	15	import string
	16	import FindService
	17	_ = wx.GetTranslation
	18
	19	class TextDocument(wx.lib.docview.Document):
aca310e5 RD	20
	21	def __init__(self):
	22	wx.lib.docview.Document .__init__(self)
	23	self._inModify = False
d1dc2b32 RD	24
d1dc2b32 RD	25
aca310e5	26	def SaveObject(self, fileObject):
d1dc2b32	27	view = self.GetFirstView()
aca310e5	28	fileObject.write(view.GetTextCtrl().GetValue())
d1dc2b32 RD	29	return True
	30
	31
aca310e5	32	def LoadObject(self, fileObject):
d1dc2b32	33	view = self.GetFirstView()
aca310e5 RD	34	data = fileObject.read()
aca310e5 RD	35	view.GetTextCtrl().SetValue(data)
d1dc2b32 RD	36	return True
	37
	38
	39	def IsModified(self):
	40	view = self.GetFirstView()
	41	if view and view.GetTextCtrl():
aca310e5 RD	42	return view.GetTextCtrl().IsModified()
aca310e5 RD	43	return False
d1dc2b32 RD	44
d1dc2b32 RD	45
aca310e5 RD	46	def Modify(self, modify):
	47	if self._inModify:
	48	return
	49	self._inModify = True
	50
d1dc2b32	51	view = self.GetFirstView()
aca310e5	52	if not modify and view and view.GetTextCtrl():
d1dc2b32 RD	53	view.GetTextCtrl().DiscardEdits()
d1dc2b32 RD	54
aca310e5 RD	55	wx.lib.docview.Document.Modify(self, modify) # this must called be after the DiscardEdits call above.
	56
	57	self._inModify = False
	58
d1dc2b32 RD	59
	60	class TextView(wx.lib.docview.View):
	61
	62
	63	#----------------------------------------------------------------------------
	64	# Overridden methods
	65	#----------------------------------------------------------------------------
	66
	67	def __init__(self):
	68	wx.lib.docview.View.__init__(self)
	69	self._textCtrl = None
	70	self._wordWrap = wx.ConfigBase_Get().ReadInt("TextEditorWordWrap", True)
	71
	72
	73	def OnCreate(self, doc, flags):
	74	frame = wx.GetApp().CreateDocumentFrame(self, doc, flags)
	75	sizer = wx.BoxSizer()
	76	font, color = self._GetFontAndColorFromConfig()
	77	self._textCtrl = self._BuildTextCtrl(frame, font, color = color)
aca310e5	78	self._textCtrl.Bind(wx.EVT_TEXT, self.OnModify)
d1dc2b32 RD	79	sizer.Add(self._textCtrl, 1, wx.EXPAND, 0)
	80	frame.SetSizer(sizer)
	81	frame.Layout()
	82	frame.Show(True)
	83	self.Activate()
	84	return True
	85
	86
aca310e5 RD	87	def OnModify(self, event):
	88	self.GetDocument().Modify(True)
	89
	90
d1dc2b32 RD	91	def _BuildTextCtrl(self, parent, font, color = wx.BLACK, value = "", selection = [0, 0]):
	92	if self._wordWrap:
	93	wordWrapStyle = wx.TE_WORDWRAP
	94	else:
	95	wordWrapStyle = wx.TE_DONTWRAP
	96	textCtrl = wx.TextCtrl(parent, -1, pos = wx.DefaultPosition, size = parent.GetClientSize(), style = wx.TE_MULTILINE \| wordWrapStyle)
	97	textCtrl.SetFont(font)
	98	textCtrl.SetForegroundColour(color)
	99	textCtrl.SetValue(value)
	100	return textCtrl
	101
	102
	103	def _GetFontAndColorFromConfig(self):
	104	font = wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL)
	105	config = wx.ConfigBase_Get()
	106	fontData = config.Read("TextEditorFont", "")
	107	if fontData:
	108	nativeFont = wx.NativeFontInfo()
	109	nativeFont.FromString(fontData)
	110	font.SetNativeFontInfo(nativeFont)
	111	color = wx.BLACK
	112	colorData = config.Read("TextEditorColor", "")
	113	if colorData:
	114	red = int("0x" + colorData[0:2], 16)
	115	green = int("0x" + colorData[2:4], 16)
	116	blue = int("0x" + colorData[4:6], 16)
	117	color = wx.Color(red, green, blue)
	118	return font, color
	119
	120
	121	def OnCreateCommandProcessor(self):
	122	# Don't create a command processor, it has its own
	123	pass
	124
	125
	126	def OnActivateView(self, activate, activeView, deactiveView):
	127	if activate and self._textCtrl:
	128	# In MDI mode just calling set focus doesn't work and in SDI mode using CallAfter causes an endless loop
	129	if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI:
	130	self._textCtrl.SetFocus()
	131	else:
	132	def SetFocusToTextCtrl():
	133	if self._textCtrl: # Need to make sure it is there in case we are in the closeall mode of the MDI window
	134	self._textCtrl.SetFocus()
	135	wx.CallAfter(SetFocusToTextCtrl)
	136
	137
	138	def OnUpdate(self, sender = None, hint = None):
aca310e5 RD	139	if wx.lib.docview.View.OnUpdate(self, sender, hint):
	140	return
	141
d1dc2b32 RD	142	if hint == "Word Wrap":
	143	self.SetWordWrap(wx.ConfigBase_Get().ReadInt("TextEditorWordWrap", True))
	144	elif hint == "Font":
	145	font, color = self._GetFontAndColorFromConfig()
	146	self.SetFont(font, color)
	147
	148
	149	def OnClose(self, deleteWindow = True):
	150	if not wx.lib.docview.View.OnClose(self, deleteWindow):
	151	return False
	152	self.Activate(False)
3fa8f722	153	if deleteWindow and self.GetFrame():
d1dc2b32 RD	154	self.GetFrame().Destroy()
	155	return True
	156
	157
	158	# Since ProcessEvent is not virtual, we have to trap the relevant events using this pseudo-ProcessEvent instead of EVT_MENU
	159	def ProcessEvent(self, event):
	160	id = event.GetId()
	161	if id == wx.ID_UNDO:
	162	if not self._textCtrl:
	163	return False
	164	self._textCtrl.Undo()
	165	return True
	166	elif id == wx.ID_REDO:
	167	if not self._textCtrl:
	168	return False
	169	self._textCtrl.Redo()
	170	return True
	171	elif id == wx.ID_CUT:
	172	if not self._textCtrl:
	173	return False
	174	self._textCtrl.Cut()
	175	return True
	176	elif id == wx.ID_COPY:
	177	if not self._textCtrl:
	178	return False
	179	self._textCtrl.Copy()
	180	return True
	181	elif id == wx.ID_PASTE:
	182	if not self._textCtrl:
	183	return False
	184	self._textCtrl.Paste()
	185	return True
	186	elif id == wx.ID_CLEAR:
	187	if not self._textCtrl:
	188	return False
	189	self._textCtrl.Replace(self._textCtrl.GetSelection()[0], self._textCtrl.GetSelection()[1], '')
	190	return True
	191	elif id == wx.ID_SELECTALL:
	192	if not self._textCtrl:
	193	return False
	194	self._textCtrl.SetSelection(-1, -1)
	195	return True
	196	elif id == TextService.CHOOSE_FONT_ID:
	197	if not self._textCtrl:
	198	return False
	199	self.OnChooseFont(event)
	200	return True
	201	elif id == TextService.WORD_WRAP_ID:
	202	if not self._textCtrl:
	203	return False
	204	self.OnWordWrap(event)
	205	return True
	206	elif id == FindService.FindService.FIND_ID:
	207	self.OnFind()
	208	return True
	209	elif id == FindService.FindService.FIND_PREVIOUS_ID:
	210	self.DoFind(forceFindPrevious = True)
	211	return True
	212	elif id == FindService.FindService.FIND_NEXT_ID:
	213	self.DoFind(forceFindNext = True)
	214	return True
	215	elif id == FindService.FindService.REPLACE_ID:
	216	self.OnFind(replace = True)
	217	return True
218	elif id == FindService.FindService.FINDONE_ID:
219	self.DoFind()
220	return True
221	elif id == FindService.FindService.REPLACEONE_ID:
222	self.DoFind(replace = True)
223	return True
224	elif id == FindService.FindService.REPLACEALL_ID:
225	self.DoFind(replaceAll = True)
226	return True
227	elif id == FindService.FindService.GOTO_LINE_ID:
228	self.OnGotoLine(event)
229	return True
230	else:
231	return wx.lib.docview.View.ProcessEvent(self, event)
232
233
234	def ProcessUpdateUIEvent(self, event):
235	if not self._textCtrl:
236	return False
237
238	hasText = len(self._textCtrl.GetValue()) > 0
239
240	id = event.GetId()
241	if id == wx.ID_UNDO:
242	event.Enable(self._textCtrl.CanUndo())
243	return True
244	elif id == wx.ID_REDO:
245	event.Enable(self._textCtrl.CanRedo())
246	return True
247	if id == wx.ID_CUT:
248	event.Enable(self._textCtrl.CanCut())
249	return True
250	elif id == wx.ID_COPY:
251	event.Enable(self._textCtrl.CanCopy())
252	return True
253	elif id == wx.ID_PASTE:
254	event.Enable(self._textCtrl.CanPaste())
255	return True
256	elif id == wx.ID_CLEAR:
3fa8f722	257	event.Enable(self._textCtrl.CanCopy())
d1dc2b32 RD	258	return True
	259	elif id == wx.ID_SELECTALL:
	260	event.Enable(hasText)
	261	return True
	262	elif id == TextService.CHOOSE_FONT_ID:
	263	event.Enable(True)
	264	return True
	265	elif id == TextService.WORD_WRAP_ID:
	266	event.Enable(True)
	267	return True
	268	elif id == FindService.FindService.FIND_ID:
	269	event.Enable(hasText)
	270	return True
	271	elif id == FindService.FindService.FIND_PREVIOUS_ID:
	272	event.Enable(hasText and
	273	self._FindServiceHasString() and
	274	self._textCtrl.GetSelection()[0] > 0)
	275	return True
	276	elif id == FindService.FindService.FIND_NEXT_ID:
	277	event.Enable(hasText and
	278	self._FindServiceHasString() and
	279	self._textCtrl.GetSelection()[0] < len(self._textCtrl.GetValue()))
	280	return True
	281	elif id == FindService.FindService.REPLACE_ID:
	282	event.Enable(hasText)
	283	return True
	284	elif id == FindService.FindService.GOTO_LINE_ID:
	285	event.Enable(True)
	286	return True
	287	else:
	288	return wx.lib.docview.View.ProcessUpdateUIEvent(self, event)
	289
	290
	291	#----------------------------------------------------------------------------
	292	# Methods for TextDocument to call
	293	#----------------------------------------------------------------------------
	294
	295	def GetTextCtrl(self):
	296	return self._textCtrl
	297
	298
	299	#----------------------------------------------------------------------------
	300	# Format methods
	301	#----------------------------------------------------------------------------
	302
	303	def OnChooseFont(self, event):
	304	data = wx.FontData()
	305	data.EnableEffects(True)
	306	data.SetInitialFont(self._textCtrl.GetFont())
	307	data.SetColour(self._textCtrl.GetForegroundColour())
	308	fontDialog = wx.FontDialog(self.GetFrame(), data)
	309	if fontDialog.ShowModal() == wx.ID_OK:
	310	data = fontDialog.GetFontData()
	311	self.SetFont(data.GetChosenFont(), data.GetColour())
	312	fontDialog.Destroy()
	313
	314
	315	def SetFont(self, font, color):
	316	self._textCtrl.SetFont(font)
	317	self._textCtrl.SetForegroundColour(color)
	318	self._textCtrl.Refresh()
	319	self._textCtrl.Layout()
	320
	321
322	def OnWordWrap(self, event):
323	self.SetWordWrap(not self.GetWordWrap())
324
325
326	def GetWordWrap(self):
327	return self._wordWrap
328
329
330	def SetWordWrap(self, wordWrap = True):
331	self._wordWrap = wordWrap
332	temp = self._textCtrl
333	self._textCtrl = self._BuildTextCtrl(temp.GetParent(),
334	font = temp.GetFont(),
335	color = temp.GetForegroundColour(),
336	value = temp.GetValue(),
337	selection = temp.GetSelection())
338	self.GetDocument().Modify(temp.IsModified())
339	temp.Destroy()
340
341
342	#----------------------------------------------------------------------------
343	# Find methods
344	#----------------------------------------------------------------------------
345
346	def OnFind(self, replace = False):
347	findService = wx.GetApp().GetService(FindService.FindService)
348	if findService:
349	findService.ShowFindReplaceDialog(findString = self._textCtrl.GetStringSelection(), replace = replace)
350
351
352	def DoFind(self, forceFindNext = False, forceFindPrevious = False, replace = False, replaceAll = False):
353	findService = wx.GetApp().GetService(FindService.FindService)
354	if not findService:
355	return
356	findString = findService.GetFindString()
357	if len(findString) == 0:
358	return -1
359	replaceString = findService.GetReplaceString()
360	flags = findService.GetFlags()
361	startLoc, endLoc = self._textCtrl.GetSelection()
362
363	wholeWord = flags & wx.FR_WHOLEWORD > 0
364	matchCase = flags & wx.FR_MATCHCASE > 0
365	regExp = flags & FindService.FindService.FR_REGEXP > 0
366	down = flags & wx.FR_DOWN > 0
367	wrap = flags & FindService.FindService.FR_WRAP > 0
368
369	if forceFindPrevious: # this is from function keys, not dialog box
370	down = False
371	wrap = False # user would want to know they're at the end of file
372	elif forceFindNext:
373	down = True
374	wrap = False # user would want to know they're at the end of file
375
376	# On replace dialog operations, user is allowed to replace the currently highlighted text to determine if it should be replaced or not.
377	# Typically, it is the text from a previous find operation, but we must check to see if it isn't, user may have moved the cursor or selected some other text accidentally.
378	# If the text is a match, then replace it.
379	if replace:
380	result, start, end, replText = findService.DoFind(findString, replaceString, self._textCtrl.GetStringSelection(), 0, 0, True, matchCase, wholeWord, regExp, replace)
381	if result > 0:
382	self._textCtrl.Replace(startLoc, endLoc, replaceString)
383	self.GetDocument().Modify(True)
384	wx.GetApp().GetTopWindow().PushStatusText(_("1 occurrence of \"%s\" replaced") % findString)
385	if down:
386	startLoc += len(replText) # advance start location past replacement string to new text
387	endLoc = startLoc
388
389	text = self._textCtrl.GetValue()
390	if wx.Platform == "__WXMSW__":
391	text = string.replace(text, '\n', '\r\n')
392
393	# Find the next matching text occurance or if it is a ReplaceAll, replace all occurances
394	# Even if the user is Replacing, we should replace here, but only select the text and let the user replace it with the next Replace operation
395	result, start, end, text = findService.DoFind(findString, replaceString, text, startLoc, endLoc, down, matchCase, wholeWord, regExp, False, replaceAll, wrap)
396	if result > 0:
397	self._textCtrl.SetValue(text)
398	self.GetDocument().Modify(True)
399	if result == 1:
400	wx.GetApp().GetTopWindow().PushStatusText(_("1 occurrence of \"%s\" replaced") % findString)
401	else:
402	wx.GetApp().GetTopWindow().PushStatusText(_("%i occurrences of \"%s\" replaced") % (result, findString))
403	elif result == 0:
404	self._textCtrl.SetSelection(start, end)
405	self._textCtrl.SetFocus()
406	wx.GetApp().GetTopWindow().PushStatusText(_("Found \"%s\"") % findString)
407	else:
408	wx.GetApp().GetTopWindow().PushStatusText(_("Can't find \"%s\"") % findString)
409
410
411	def _FindServiceHasString(self):
412	findService = wx.GetApp().GetService(FindService.FindService)
413	if not findService or not findService.GetFindString():
414	return False
415	return True
416
417
418	def OnGotoLine(self, event):
419	findService = wx.GetApp().GetService(FindService.FindService)
420	if findService:
421	line = findService.GetLineNumber(self.GetDocumentManager().FindSuitableParent())
422	if line > -1:
423	pos = self._textCtrl.XYToPosition(0, line - 1)
424	self._textCtrl.SetSelection(pos, pos)
425
426
427	class TextService(wx.lib.pydocview.DocService):
428
429
430	WORD_WRAP_ID = wx.NewId()
431	CHOOSE_FONT_ID = wx.NewId()
432
433
434	def __init__(self):
435	wx.lib.pydocview.DocService.__init__(self)
436
437
438	def InstallControls(self, frame, menuBar = None, toolBar = None, statusBar = None, document = None):
439	if document and document.GetDocumentTemplate().GetDocumentType() != TextDocument:
440	return
441	config = wx.ConfigBase_Get()
442
443	formatMenuIndex = menuBar.FindMenu(_("&Format"))
444	if formatMenuIndex > -1:
445	formatMenu = menuBar.GetMenu(formatMenuIndex)
446	else:
447	formatMenu = wx.Menu()
448	formatMenu = wx.Menu()
449	if not menuBar.FindItemById(TextService.WORD_WRAP_ID):
450	formatMenu.AppendCheckItem(TextService.WORD_WRAP_ID, _("Word Wrap"), _("Wraps text horizontally when checked"))
451	formatMenu.Check(TextService.WORD_WRAP_ID, config.ReadInt("TextEditorWordWrap", True))
452	wx.EVT_MENU(frame, TextService.WORD_WRAP_ID, frame.ProcessEvent)
453	wx.EVT_UPDATE_UI(frame, TextService.WORD_WRAP_ID, frame.ProcessUpdateUIEvent)
454	if not menuBar.FindItemById(TextService.CHOOSE_FONT_ID):
455	formatMenu.Append(TextService.CHOOSE_FONT_ID, _("Font..."), _("Sets the font to use"))
456	wx.EVT_MENU(frame, TextService.CHOOSE_FONT_ID, frame.ProcessEvent)
457	wx.EVT_UPDATE_UI(frame, TextService.CHOOSE_FONT_ID, frame.ProcessUpdateUIEvent)
458	if formatMenuIndex == -1:
459	viewMenuIndex = menuBar.FindMenu(_("&View"))
460	menuBar.Insert(viewMenuIndex + 1, formatMenu, _("&Format"))
461
462
463	def ProcessUpdateUIEvent(self, event):
464	id = event.GetId()
465	if id == TextService.CHOOSE_FONT_ID:
466	event.Enable(False)
467	return True
468	elif id == TextService.WORD_WRAP_ID:
469	event.Enable(False)
470	return True
471	else:
472	return False
473
474
475	class TextOptionsPanel(wx.Panel):
476
477
478	def __init__(self, parent, id):
479	wx.Panel.__init__(self, parent, id)
480	SPACE = 10
481	HALF_SPACE = 5
482	config = wx.ConfigBase_Get()
483	self._textFont = wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL)
484	fontData = config.Read("TextEditorFont", "")
485	if fontData:
486	nativeFont = wx.NativeFontInfo()
487	nativeFont.FromString(fontData)
488	self._textFont.SetNativeFontInfo(nativeFont)
489	self._originalTextFont = self._textFont
490	self._textColor = wx.BLACK
491	colorData = config.Read("TextEditorColor", "")
492	if colorData:
493	red = int("0x" + colorData[0:2], 16)
494	green = int("0x" + colorData[2:4], 16)
495	blue = int("0x" + colorData[4:6], 16)
496	self._textColor = wx.Color(red, green, blue)
497	self._originalTextColor = self._textColor
498	parent.AddPage(self, _("Text"))
499	fontLabel = wx.StaticText(self, -1, _("Font:"))
500	self._sampleTextCtrl = wx.TextCtrl(self, -1, "", size = (125, -1))
501	self._sampleTextCtrl.SetEditable(False)
502	chooseFontButton = wx.Button(self, -1, _("Choose Font..."))
503	wx.EVT_BUTTON(self, chooseFontButton.GetId(), self.OnChooseFont)
504	self._wordWrapCheckBox = wx.CheckBox(self, -1, _("Wrap words inside text area"))
505	self._wordWrapCheckBox.SetValue(wx.ConfigBase_Get().ReadInt("TextEditorWordWrap", True))
506	textPanelBorderSizer = wx.BoxSizer(wx.VERTICAL)
507	textPanelSizer = wx.BoxSizer(wx.VERTICAL)
508	textFontSizer = wx.BoxSizer(wx.HORIZONTAL)
509	textFontSizer.Add(fontLabel, 0, wx.ALIGN_LEFT \| wx.RIGHT \| wx.TOP, HALF_SPACE)
510	textFontSizer.Add(self._sampleTextCtrl, 0, wx.ALIGN_LEFT \| wx.EXPAND \| wx.RIGHT, HALF_SPACE)
511	textFontSizer.Add(chooseFontButton, 0, wx.ALIGN_RIGHT \| wx.LEFT, HALF_SPACE)
512	textPanelSizer.Add(textFontSizer, 0, wx.ALL, HALF_SPACE)
513	textPanelSizer.Add(self._wordWrapCheckBox, 0, wx.ALL, HALF_SPACE)
514	textPanelBorderSizer.Add(textPanelSizer, 0, wx.ALL, SPACE)
515	self.SetSizer(textPanelBorderSizer)
516	self.UpdateSampleFont()
517
518
519	def UpdateSampleFont(self):
520	nativeFont = wx.NativeFontInfo()
521	nativeFont.FromString(self._textFont.GetNativeFontInfoDesc())
522	font = wx.NullFont
523	font.SetNativeFontInfo(nativeFont)
524	font.SetPointSize(self._sampleTextCtrl.GetFont().GetPointSize()) # Use the standard point size
525	self._sampleTextCtrl.SetFont(font)
526	self._sampleTextCtrl.SetForegroundColour(self._textColor)
527	self._sampleTextCtrl.SetValue(_("%d pt. %s") % (self._textFont.GetPointSize(), self._textFont.GetFaceName()))
528	self._sampleTextCtrl.Refresh()
529	self.Layout()
530
531
532	def OnChooseFont(self, event):
533	data = wx.FontData()
534	data.EnableEffects(True)
535	data.SetInitialFont(self._textFont)
536	data.SetColour(self._textColor)
537	fontDialog = wx.FontDialog(self, data)
538	if fontDialog.ShowModal() == wx.ID_OK:
539	data = fontDialog.GetFontData()
540	self._textFont = data.GetChosenFont()
541	self._textColor = data.GetColour()
542	self.UpdateSampleFont()
543	fontDialog.Destroy()
544
545
546	def OnOK(self, optionsDialog):
547	config = wx.ConfigBase_Get()
548	doWordWrapUpdate = config.ReadInt("TextEditorWordWrap", True) != self._wordWrapCheckBox.GetValue()
549	config.WriteInt("TextEditorWordWrap", self._wordWrapCheckBox.GetValue())
550	doFontUpdate = self._originalTextFont != self._textFont or self._originalTextColor != self._textColor
551	config.Write("TextEditorFont", self._textFont.GetNativeFontInfoDesc())
552	config.Write("TextEditorColor", "%02x%02x%02x" % (self._textColor.Red(), self._textColor.Green(), self._textColor.Blue()))
553	if doWordWrapUpdate or doFontUpdate:
554	for document in optionsDialog.GetDocManager().GetDocuments():
555	if document.GetDocumentTemplate().GetDocumentType() == TextDocument:
556	if doWordWrapUpdate:
557	document.UpdateAllViews(hint = "Word Wrap")
558	if doFontUpdate:
559	document.UpdateAllViews(hint = "Font")