py2docfx 0.1.15rc2025477__py3-none-any.whl → 0.1.16.dev2051338__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/framework/editor/configui.py

@@ -1,299 +0,0 @@
-import pywin.scintilla.config
-import win32api
-import win32con
-import win32ui
-from pywin.framework.editor import DeleteEditorOption, GetEditorOption, SetEditorOption
-from pywin.mfc import dialog
-
-from . import document
-
-# The standard 16 color VGA palette should always be possible
-paletteVGA = (
-    ("Black", 0, 0, 0),
-    ("Navy", 0, 0, 128),
-    ("Green", 0, 128, 0),
-    ("Cyan", 0, 128, 128),
-    ("Maroon", 128, 0, 0),
-    ("Purple", 128, 0, 128),
-    ("Olive", 128, 128, 0),
-    ("Gray", 128, 128, 128),
-    ("Silver", 192, 192, 192),
-    ("Blue", 0, 0, 255),
-    ("Lime", 0, 255, 0),
-    ("Aqua", 0, 255, 255),
-    ("Red", 255, 0, 0),
-    ("Fuchsia", 255, 0, 255),
-    ("Yellow", 255, 255, 0),
-    ("White", 255, 255, 255),
-)
-
-
-######################################################
-#
-# Property Page for editor options
-#
-class EditorPropertyPage(dialog.PropertyPage):
-    def __init__(self):
-        dialog.PropertyPage.__init__(self, win32ui.IDD_PP_EDITOR)
-        self.autooptions = []
-        self._AddEditorOption(win32ui.IDC_AUTO_RELOAD, "i", "Auto Reload", 1)
-        self._AddEditorOption(
-            win32ui.IDC_COMBO1, "i", "Backup Type", document.BAK_DOT_BAK_BAK_DIR
-        )
-        self._AddEditorOption(
-            win32ui.IDC_AUTOCOMPLETE, "i", "Autocomplete Attributes", 1
-        )
-        self._AddEditorOption(win32ui.IDC_CALLTIPS, "i", "Show Call Tips", 1)
-        self._AddEditorOption(
-            win32ui.IDC_MARGIN_LINENUMBER, "i", "Line Number Margin Width", 0
-        )
-        self._AddEditorOption(win32ui.IDC_RADIO1, "i", "MarkersInMargin", None)
-        self._AddEditorOption(
-            win32ui.IDC_MARGIN_MARKER, "i", "Marker Margin Width", None
-        )
-        self["Marker Margin Width"] = GetEditorOption("Marker Margin Width", 16)
-
-        # Folding
-        self._AddEditorOption(win32ui.IDC_MARGIN_FOLD, "i", "Fold Margin Width", 12)
-        self._AddEditorOption(win32ui.IDC_FOLD_ENABLE, "i", "Enable Folding", 1)
-        self._AddEditorOption(win32ui.IDC_FOLD_ON_OPEN, "i", "Fold On Open", 0)
-        self._AddEditorOption(win32ui.IDC_FOLD_SHOW_LINES, "i", "Fold Lines", 1)
-
-        # Right edge.
-        self._AddEditorOption(
-            win32ui.IDC_RIGHTEDGE_ENABLE, "i", "Right Edge Enabled", 0
-        )
-        self._AddEditorOption(
-            win32ui.IDC_RIGHTEDGE_COLUMN, "i", "Right Edge Column", 75
-        )
-
-        # Source control, etc
-        self.AddDDX(win32ui.IDC_VSS_INTEGRATE, "bVSS")
-        self.AddDDX(win32ui.IDC_KEYBOARD_CONFIG, "Configs", "l")
-        self["Configs"] = pywin.scintilla.config.find_config_files()
-
-    def _AddEditorOption(self, idd, typ, optionName, defaultVal):
-        self.AddDDX(idd, optionName, typ)
-        # some options are "derived" - ie, can be implied from others
-        # (eg, "view markers in background" is implied from "markerMarginWidth==0"
-        # So we don't actually store these values, but they do still get DDX support.
-        if defaultVal is not None:
-            self[optionName] = GetEditorOption(optionName, defaultVal)
-            self.autooptions.append((optionName, defaultVal))
-
-    def OnInitDialog(self):
-        for name, val in self.autooptions:
-            self[name] = GetEditorOption(name, val)
-
-        # Note that these MUST be in the same order as the BAK constants.
-        cbo = self.GetDlgItem(win32ui.IDC_COMBO1)
-        cbo.AddString("None")
-        cbo.AddString(".BAK File")
-        cbo.AddString("TEMP dir")
-        cbo.AddString("Own dir")
-
-        # Source Safe
-        bVSS = (
-            GetEditorOption("Source Control Module", "") == "pywin.framework.editor.vss"
-        )
-        self["bVSS"] = bVSS
-
-        edit = self.GetDlgItem(win32ui.IDC_RIGHTEDGE_SAMPLE)
-        edit.SetWindowText("Sample Color")
-
-        rc = dialog.PropertyPage.OnInitDialog(self)
-
-        try:
-            self.GetDlgItem(win32ui.IDC_KEYBOARD_CONFIG).SelectString(
-                -1, GetEditorOption("Keyboard Config", "default")
-            )
-        except win32ui.error:
-            import traceback
-
-            traceback.print_exc()
-
-        self.HookCommand(self.OnButSimple, win32ui.IDC_FOLD_ENABLE)
-        self.HookCommand(self.OnButSimple, win32ui.IDC_RADIO1)
-        self.HookCommand(self.OnButSimple, win32ui.IDC_RADIO2)
-        self.HookCommand(self.OnButSimple, win32ui.IDC_RIGHTEDGE_ENABLE)
-        self.HookCommand(self.OnButEdgeColor, win32ui.IDC_RIGHTEDGE_DEFINE)
-
-        butMarginEnabled = self["Marker Margin Width"] > 0
-        self.GetDlgItem(win32ui.IDC_RADIO1).SetCheck(butMarginEnabled)
-        self.GetDlgItem(win32ui.IDC_RADIO2).SetCheck(not butMarginEnabled)
-
-        self.edgeColor = self.initialEdgeColor = GetEditorOption(
-            "Right Edge Color", win32api.RGB(0xEF, 0xEF, 0xEF)
-        )
-        for spinner_id in (win32ui.IDC_SPIN1, win32ui.IDC_SPIN2, win32ui.IDC_SPIN3):
-            spinner = self.GetDlgItem(spinner_id)
-            spinner.SetRange(0, 100)
-        self.UpdateUIForState()
-
-        return rc
-
-    def OnButSimple(self, id, code):
-        if code == win32con.BN_CLICKED:
-            self.UpdateUIForState()
-
-    def OnButEdgeColor(self, id, code):
-        if code == win32con.BN_CLICKED:
-            d = win32ui.CreateColorDialog(self.edgeColor, 0, self)
-            # Ensure the current color is a custom color (as it may not be in the swatch)
-            # plus some other nice gray scales.
-            ccs = [self.edgeColor]
-            for c in range(0xEF, 0x4F, -0x10):
-                ccs.append(win32api.RGB(c, c, c))
-            d.SetCustomColors(ccs)
-            if d.DoModal() == win32con.IDOK:
-                self.edgeColor = d.GetColor()
-                self.UpdateUIForState()
-
-    def UpdateUIForState(self):
-        folding = self.GetDlgItem(win32ui.IDC_FOLD_ENABLE).GetCheck()
-        self.GetDlgItem(win32ui.IDC_FOLD_ON_OPEN).EnableWindow(folding)
-        self.GetDlgItem(win32ui.IDC_FOLD_SHOW_LINES).EnableWindow(folding)
-
-        widthEnabled = self.GetDlgItem(win32ui.IDC_RADIO1).GetCheck()
-        self.GetDlgItem(win32ui.IDC_MARGIN_MARKER).EnableWindow(widthEnabled)
-        self.UpdateData()  # Ensure self[] is up to date with the control data.
-        if widthEnabled and self["Marker Margin Width"] == 0:
-            self["Marker Margin Width"] = 16
-            self.UpdateData(0)  # Ensure control up to date with self[]
-
-        # Right edge
-        edgeEnabled = self.GetDlgItem(win32ui.IDC_RIGHTEDGE_ENABLE).GetCheck()
-        self.GetDlgItem(win32ui.IDC_RIGHTEDGE_COLUMN).EnableWindow(edgeEnabled)
-        self.GetDlgItem(win32ui.IDC_RIGHTEDGE_SAMPLE).EnableWindow(edgeEnabled)
-        self.GetDlgItem(win32ui.IDC_RIGHTEDGE_DEFINE).EnableWindow(edgeEnabled)
-
-        edit = self.GetDlgItem(win32ui.IDC_RIGHTEDGE_SAMPLE)
-        edit.SetBackgroundColor(0, self.edgeColor)
-
-    def OnOK(self):
-        for name, defVal in self.autooptions:
-            SetEditorOption(name, self[name])
-        # Margin width gets handled differently.
-        if self["MarkersInMargin"] == 0:
-            SetEditorOption("Marker Margin Width", self["Marker Margin Width"])
-        else:
-            SetEditorOption("Marker Margin Width", 0)
-        if self.edgeColor != self.initialEdgeColor:
-            SetEditorOption("Right Edge Color", self.edgeColor)
-        if self["bVSS"]:
-            SetEditorOption("Source Control Module", "pywin.framework.editor.vss")
-        else:
-            if (
-                GetEditorOption("Source Control Module", "")
-                == "pywin.framework.editor.vss"
-            ):
-                SetEditorOption("Source Control Module", "")
-        # Keyboard config
-        configname = self.GetDlgItem(win32ui.IDC_KEYBOARD_CONFIG).GetWindowText()
-        if configname:
-            if configname == "default":
-                DeleteEditorOption("Keyboard Config")
-            else:
-                SetEditorOption("Keyboard Config", configname)
-
-            import pywin.scintilla.view
-
-            pywin.scintilla.view.LoadConfiguration()
-
-        # Now tell all views we have changed.
-        ##		for doc in editorTemplate.GetDocumentList():
-        ##			for view in doc.GetAllViews():
-        ##				try:
-        ##					fn = view.OnConfigChange
-        ##				except AttributeError:
-        ##					continue
-        ##				fn()
-        return 1
-
-
-class EditorWhitespacePropertyPage(dialog.PropertyPage):
-    def __init__(self):
-        dialog.PropertyPage.__init__(self, win32ui.IDD_PP_TABS)
-        self.autooptions = []
-        self._AddEditorOption(win32ui.IDC_TAB_SIZE, "i", "Tab Size", 4)
-        self._AddEditorOption(win32ui.IDC_INDENT_SIZE, "i", "Indent Size", 4)
-        self._AddEditorOption(win32ui.IDC_USE_SMART_TABS, "i", "Smart Tabs", 1)
-        self._AddEditorOption(win32ui.IDC_VIEW_WHITESPACE, "i", "View Whitespace", 0)
-        self._AddEditorOption(win32ui.IDC_VIEW_EOL, "i", "View EOL", 0)
-        self._AddEditorOption(
-            win32ui.IDC_VIEW_INDENTATIONGUIDES, "i", "View Indentation Guides", 0
-        )
-
-    def _AddEditorOption(self, idd, typ, optionName, defaultVal):
-        self.AddDDX(idd, optionName, typ)
-        self[optionName] = GetEditorOption(optionName, defaultVal)
-        self.autooptions.append((optionName, defaultVal))
-
-    def OnInitDialog(self):
-        for name, val in self.autooptions:
-            self[name] = GetEditorOption(name, val)
-
-        rc = dialog.PropertyPage.OnInitDialog(self)
-
-        idc = win32ui.IDC_TABTIMMY_NONE
-        if GetEditorOption("Use Tab Timmy", 1):
-            idc = win32ui.IDC_TABTIMMY_IND
-        self.GetDlgItem(idc).SetCheck(1)
-
-        idc = win32ui.IDC_RADIO1
-        if GetEditorOption("Use Tabs", 0):
-            idc = win32ui.IDC_USE_TABS
-        self.GetDlgItem(idc).SetCheck(1)
-
-        tt_color = GetEditorOption("Tab Timmy Color", win32api.RGB(0xFF, 0, 0))
-        self.cbo = self.GetDlgItem(win32ui.IDC_COMBO1)
-        for c in paletteVGA:
-            self.cbo.AddString(c[0])
-        sel = 0
-        for c in paletteVGA:
-            if tt_color == win32api.RGB(c[1], c[2], c[3]):
-                break
-            sel += 1
-        else:
-            sel = -1
-        self.cbo.SetCurSel(sel)
-        self.HookCommand(self.OnButSimple, win32ui.IDC_TABTIMMY_NONE)
-        self.HookCommand(self.OnButSimple, win32ui.IDC_TABTIMMY_IND)
-        self.HookCommand(self.OnButSimple, win32ui.IDC_TABTIMMY_BG)
-        # Set ranges for the spinners.
-        for spinner_id in [win32ui.IDC_SPIN1, win32ui.IDC_SPIN2]:
-            spinner = self.GetDlgItem(spinner_id)
-            spinner.SetRange(1, 16)
-        return rc
-
-    def OnButSimple(self, id, code):
-        if code == win32con.BN_CLICKED:
-            self.UpdateUIForState()
-
-    def UpdateUIForState(self):
-        timmy = self.GetDlgItem(win32ui.IDC_TABTIMMY_NONE).GetCheck()
-        self.GetDlgItem(win32ui.IDC_COMBO1).EnableWindow(not timmy)
-
-    def OnOK(self):
-        for name, defVal in self.autooptions:
-            SetEditorOption(name, self[name])
-
-        SetEditorOption("Use Tabs", self.GetDlgItem(win32ui.IDC_USE_TABS).GetCheck())
-
-        SetEditorOption(
-            "Use Tab Timmy", self.GetDlgItem(win32ui.IDC_TABTIMMY_IND).GetCheck()
-        )
-        c = paletteVGA[self.cbo.GetCurSel()]
-        SetEditorOption("Tab Timmy Color", win32api.RGB(c[1], c[2], c[3]))
-
-        return 1
-
-
-def testpp():
-    ps = dialog.PropertySheet("Editor Options")
-    ps.AddPage(EditorWhitespacePropertyPage())
-    ps.DoModal()
-
-
-if __name__ == "__main__":
-    testpp()

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/framework/editor/document.py

@@ -1,379 +0,0 @@
-# We no longer support the old, non-colour editor!
-
-import os
-import shutil
-import traceback
-
-import win32api
-import win32con
-import win32ui
-from pywin.framework.editor import GetEditorOption
-
-BAK_NONE = 0
-BAK_DOT_BAK = 1
-BAK_DOT_BAK_TEMP_DIR = 2
-BAK_DOT_BAK_BAK_DIR = 3
-
-MSG_CHECK_EXTERNAL_FILE = (
-    win32con.WM_USER + 1999
-)  ## WARNING: Duplicated in editor.py and coloreditor.py
-
-import pywin.scintilla.document
-
-ParentEditorDocument = pywin.scintilla.document.CScintillaDocument
-
-
-class EditorDocumentBase(ParentEditorDocument):
-    def __init__(self, template):
-        self.bAutoReload = GetEditorOption("Auto Reload", 1)
-        self.bDeclinedReload = 0  # Has the user declined to reload.
-        self.fileStat = None
-        self.bReportedFileNotFound = 0
-
-        # what sort of bak file should I create.
-        # default to write to %temp%/bak/filename.ext
-        self.bakFileType = GetEditorOption("Backup Type", BAK_DOT_BAK_BAK_DIR)
-
-        self.watcherThread = FileWatchingThread(self)
-        self.watcherThread.CreateThread()
-        # Should I try and use VSS integration?
-        self.scModuleName = GetEditorOption("Source Control Module", "")
-        self.scModule = None  # Loaded when first used.
-        ParentEditorDocument.__init__(self, template, template.CreateWin32uiDocument())
-
-    def OnCloseDocument(self):
-        self.watcherThread.SignalStop()
-        return self._obj_.OnCloseDocument()
-
-    # 	def OnOpenDocument(self, name):
-    # 		rc = ParentEditorDocument.OnOpenDocument(self, name)
-    # 		self.GetFirstView()._SetLoadedText(self.text)
-    # 		self._DocumentStateChanged()
-    # 		return rc
-
-    def OnSaveDocument(self, fileName):
-        win32ui.SetStatusText("Saving file...", 1)
-        # rename to bak if required.
-        dir, basename = os.path.split(fileName)
-        if self.bakFileType == BAK_DOT_BAK:
-            bakFileName = dir + "\\" + os.path.splitext(basename)[0] + ".bak"
-        elif self.bakFileType == BAK_DOT_BAK_TEMP_DIR:
-            bakFileName = (
-                win32api.GetTempPath() + "\\" + os.path.splitext(basename)[0] + ".bak"
-            )
-        elif self.bakFileType == BAK_DOT_BAK_BAK_DIR:
-            tempPath = os.path.join(win32api.GetTempPath(), "bak")
-            try:
-                os.mkdir(tempPath, 0)
-            except OSError:
-                pass
-            bakFileName = os.path.join(tempPath, basename)
-        try:
-            os.unlink(bakFileName)  # raise NameError if no bakups wanted.
-        except (OSError, NameError):
-            pass
-        try:
-            # Do a copy as it might be on different volumes,
-            # and the file may be a hard-link, causing the link
-            # to follow the backup.
-            shutil.copy2(fileName, bakFileName)
-        except (OSError, NameError):
-            pass
-        try:
-            self.SaveFile(fileName)
-        except OSError as details:
-            win32ui.MessageBox("Error - could not save file\r\n\r\n%s" % details)
-            return 0
-        except (UnicodeEncodeError, LookupError) as details:
-            rc = win32ui.MessageBox(
-                "Encoding failed: \r\n%s" % details
-                + "\r\nPlease add desired source encoding as first line of file, eg \r\n"
-                + "# -*- coding: mbcs -*-\r\n\r\n"
-                + "If you continue, the file will be saved as binary and will\r\n"
-                + "not be valid in the declared encoding.\r\n\r\n"
-                + "Save the file as binary with an invalid encoding?",
-                "File save failed",
-                win32con.MB_YESNO | win32con.MB_DEFBUTTON2,
-            )
-            if rc == win32con.IDYES:
-                try:
-                    self.SaveFile(fileName, encoding="latin-1")
-                except OSError as details:
-                    win32ui.MessageBox(
-                        "Error - could not save file\r\n\r\n%s" % details
-                    )
-                    return 0
-            else:
-                return 0
-        self.SetModifiedFlag(0)  # No longer dirty
-        self.bDeclinedReload = 0  # They probably want to know if it changes again!
-        win32ui.AddToRecentFileList(fileName)
-        self.SetPathName(fileName)
-        win32ui.SetStatusText("Ready")
-        self._DocumentStateChanged()
-        return 1
-
-    def FinalizeViewCreation(self, view):
-        ParentEditorDocument.FinalizeViewCreation(self, view)
-        if view == self.GetFirstView():
-            self._DocumentStateChanged()
-            if view.bFolding and GetEditorOption("Fold On Open", 0):
-                view.FoldTopLevelEvent()
-
-    def HookViewNotifications(self, view):
-        ParentEditorDocument.HookViewNotifications(self, view)
-
-    # Support for reloading the document from disk - presumably after some
-    # external application has modified it (or possibly source control has
-    # checked it out.
-    def ReloadDocument(self):
-        """Reloads the document from disk.  Assumes the file has
-        been saved and user has been asked if necessary - it just does it!
-        """
-        win32ui.SetStatusText("Reloading document.  Please wait...", 1)
-        self.SetModifiedFlag(0)
-        # Loop over all views, saving their state, then reload the document
-        views = self.GetAllViews()
-        states = []
-        for view in views:
-            try:
-                info = view._PrepareUserStateChange()
-            except AttributeError:  # Not our editor view?
-                info = None
-            states.append(info)
-        self.OnOpenDocument(self.GetPathName())
-        for view, info in zip(views, states):
-            if info is not None:
-                view._EndUserStateChange(info)
-        self._DocumentStateChanged()
-        win32ui.SetStatusText("Document reloaded.")
-
-    # Reloading the file
-    def CheckExternalDocumentUpdated(self):
-        if self.bDeclinedReload or not self.GetPathName():
-            return
-        try:
-            newstat = os.stat(self.GetPathName())
-        except OSError as exc:
-            if not self.bReportedFileNotFound:
-                print(
-                    "The file '{}' is open for editing, but\nchecking it for changes caused the error: {}".format(
-                        self.GetPathName(), exc.strerror
-                    )
-                )
-                self.bReportedFileNotFound = 1
-            return
-        if self.bReportedFileNotFound:
-            print(
-                "The file '{}' has re-appeared - continuing to watch for changes...".format(
-                    self.GetPathName()
-                )
-            )
-            self.bReportedFileNotFound = (
-                0  # Once found again we want to start complaining.
-            )
-        changed = (
-            (self.fileStat is None)
-            or self.fileStat[0] != newstat[0]
-            or self.fileStat[6] != newstat[6]
-            or self.fileStat[8] != newstat[8]
-            or self.fileStat[9] != newstat[9]
-        )
-        if changed:
-            question = None
-            if self.IsModified():
-                question = (
-                    "%s\r\n\r\nThis file has been modified outside of the source editor.\r\nDo you want to reload it and LOSE THE CHANGES in the source editor?"
-                    % self.GetPathName()
-                )
-                mbStyle = win32con.MB_YESNO | win32con.MB_DEFBUTTON2  # Default to "No"
-            else:
-                if not self.bAutoReload:
-                    question = (
-                        "%s\r\n\r\nThis file has been modified outside of the source editor.\r\nDo you want to reload it?"
-                        % self.GetPathName()
-                    )
-                    mbStyle = win32con.MB_YESNO  # Default to "Yes"
-            if question:
-                rc = win32ui.MessageBox(question, None, mbStyle)
-                if rc != win32con.IDYES:
-                    self.bDeclinedReload = 1
-                    return
-            self.ReloadDocument()
-
-    def _DocumentStateChanged(self):
-        """Called whenever the documents state (on disk etc) has been changed
-        by the editor (eg, as the result of a save operation)
-        """
-        if self.GetPathName():
-            try:
-                self.fileStat = os.stat(self.GetPathName())
-            except OSError:
-                self.fileStat = None
-        else:
-            self.fileStat = None
-        self.watcherThread._DocumentStateChanged()
-        self._UpdateUIForState()
-        self._ApplyOptionalToViews("_UpdateUIForState")
-        self._ApplyOptionalToViews("SetReadOnly", self._IsReadOnly())
-        self._ApplyOptionalToViews("SCISetSavePoint")
-        # Allow the debugger to reset us too.
-        import pywin.debugger
-
-        if pywin.debugger.currentDebugger is not None:
-            pywin.debugger.currentDebugger.UpdateDocumentLineStates(self)
-
-    # Read-only document support - make it obvious to the user
-    # that the file is read-only.
-    def _IsReadOnly(self):
-        return self.fileStat is not None and (self.fileStat[0] & 128) == 0
-
-    def _UpdateUIForState(self):
-        """Change the title to reflect the state of the document -
-        eg ReadOnly, Dirty, etc
-        """
-        filename = self.GetPathName()
-        if not filename:
-            return  # New file - nothing to do
-        try:
-            # This seems necessary so the internal state of the window becomes
-            # "visible".  without it, it is still shown, but certain functions
-            # (such as updating the title) don't immediately work?
-            self.GetFirstView().ShowWindow(win32con.SW_SHOW)
-            title = win32ui.GetFileTitle(filename)
-        except win32ui.error:
-            title = filename
-        if self._IsReadOnly():
-            title += " (read-only)"
-        self.SetTitle(title)
-
-    def MakeDocumentWritable(self):
-        pretend_ss = 0  # Set to 1 to test this without source safe :-)
-        if not self.scModuleName and not pretend_ss:  # No Source Control support.
-            win32ui.SetStatusText(
-                "Document is read-only, and no source-control system is configured"
-            )
-            win32api.MessageBeep()
-            return 0
-
-        # We have source control support - check if the user wants to use it.
-        msg = "Would you like to check this file out?"
-        defButton = win32con.MB_YESNO
-        if self.IsModified():
-            msg += "\r\n\r\nALL CHANGES IN THE EDITOR WILL BE LOST"
-            defButton = win32con.MB_YESNO
-        if win32ui.MessageBox(msg, None, defButton) != win32con.IDYES:
-            return 0
-
-        if pretend_ss:
-            print("We are only pretending to check it out!")
-            win32api.SetFileAttributes(
-                self.GetPathName(), win32con.FILE_ATTRIBUTE_NORMAL
-            )
-            self.ReloadDocument()
-            return 1
-
-        # Now call on the module to do it.
-        if self.scModule is None:
-            try:
-                self.scModule = __import__(self.scModuleName)
-                for part in self.scModuleName.split(".")[1:]:
-                    self.scModule = getattr(self.scModule, part)
-            except:
-                traceback.print_exc()
-                print("Error loading source control module.")
-                return 0
-
-        if self.scModule.CheckoutFile(self.GetPathName()):
-            self.ReloadDocument()
-            return 1
-        return 0
-
-    def CheckMakeDocumentWritable(self):
-        if self._IsReadOnly():
-            return self.MakeDocumentWritable()
-        return 1
-
-    def SaveModified(self):
-        # Called as the document is closed.  If we are about
-        # to prompt for a save, bring the document to the foreground.
-        if self.IsModified():
-            frame = self.GetFirstView().GetParentFrame()
-            try:
-                frame.MDIActivate()
-                frame.AutoRestore()
-            except:
-                print("Could not bring document to foreground")
-        return self._obj_.SaveModified()
-
-
-# NOTE - I DONT use the standard threading module,
-# as this waits for all threads to terminate at shutdown.
-# When using the debugger, it is possible shutdown will
-# occur without Pythonwin getting a complete shutdown,
-# so we deadlock at the end - threading is waiting for
-import pywin.mfc.thread
-import win32event
-
-
-class FileWatchingThread(pywin.mfc.thread.WinThread):
-    def __init__(self, doc):
-        self.doc = doc
-        self.adminEvent = win32event.CreateEvent(None, 0, 0, None)
-        self.stopEvent = win32event.CreateEvent(None, 0, 0, None)
-        self.watchEvent = None
-        pywin.mfc.thread.WinThread.__init__(self)
-
-    def _DocumentStateChanged(self):
-        win32event.SetEvent(self.adminEvent)
-
-    def RefreshEvent(self):
-        self.hwnd = self.doc.GetFirstView().GetSafeHwnd()
-        if self.watchEvent is not None:
-            win32api.FindCloseChangeNotification(self.watchEvent)
-            self.watchEvent = None
-        path = self.doc.GetPathName()
-        if path:
-            path = os.path.dirname(path)
-        if path:
-            filter = (
-                win32con.FILE_NOTIFY_CHANGE_FILE_NAME
-                | win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES
-                | win32con.FILE_NOTIFY_CHANGE_LAST_WRITE
-            )
-            try:
-                self.watchEvent = win32api.FindFirstChangeNotification(path, 0, filter)
-            except win32api.error as exc:
-                print("Can not watch file", path, "for changes -", exc.strerror)
-
-    def SignalStop(self):
-        win32event.SetEvent(self.stopEvent)
-
-    def Run(self):
-        while 1:
-            handles = [self.stopEvent, self.adminEvent]
-            if self.watchEvent is not None:
-                handles.append(self.watchEvent)
-            rc = win32event.WaitForMultipleObjects(handles, 0, win32event.INFINITE)
-            if rc == win32event.WAIT_OBJECT_0:
-                break
-            elif rc == win32event.WAIT_OBJECT_0 + 1:
-                self.RefreshEvent()
-            else:
-                win32api.PostMessage(self.hwnd, MSG_CHECK_EXTERNAL_FILE, 0, 0)
-                try:
-                    # If the directory has been removed underneath us, we get this error.
-                    win32api.FindNextChangeNotification(self.watchEvent)
-                except win32api.error as exc:
-                    print(
-                        "Can not watch file",
-                        self.doc.GetPathName(),
-                        "for changes -",
-                        exc.strerror,
-                    )
-                    break
-
-        # close a circular reference
-        self.doc = None
-        if self.watchEvent:
-            win32api.FindCloseChangeNotification(self.watchEvent)