def __init__(self, app, path=None):
self.app = app
self._updates_path_on_file_move = app.config["updates_path_on_file_move"]
self.file_path = path or const.UNTITLED_DOCUMENT_NAME
self.persistent_path = path
self.id = next(DocumentController.id_gen)
self.icon_cache = (None, None)
self.document_attrs = {
ak.NSDocumentTypeDocumentAttribute: ak.NSPlainTextDocumentType,
ak.NSCharacterEncodingDocumentAttribute: fn.NSUTF8StringEncoding,
}
self.undo_manager = UndoManager()
self.syntaxer = Highlighter(app.theme)
self.props = KVOProxy(self)
self._kvo = KVOLink([
(self.undo_manager, "has_unsaved_actions", self.props, "is_dirty"),
])
self.indent_mode = app.config["indent.mode"]
self.indent_size = app.config["indent.size"] # should come from syntax definition
self.newline_mode = app.config["newline_mode"]
self.highlight_selected_text = app.config["theme.highlight_selected_text.enabled"]
self.syntax_needs_color = False
self._edit_range = None
app.on_reload_config(self.reset_text_attributes, self)
class TextDocument(object):
app = WeakProperty()
def __init__(self, app, path=None):
self.app = app
self._updates_path_on_file_move = app.config["updates_path_on_file_move"]
self.file_path = path or const.UNTITLED_DOCUMENT_NAME
self.persistent_path = path
self.id = next(DocumentController.id_gen)
self.icon_cache = (None, None)
self.document_attrs = {
ak.NSDocumentTypeDocumentAttribute: ak.NSPlainTextDocumentType,
ak.NSCharacterEncodingDocumentAttribute: fn.NSUTF8StringEncoding,
}
self.undo_manager = UndoManager()
self.syntaxer = Highlighter(app.theme)
self.props = KVOProxy(self)
self._kvo = KVOLink([(self.undo_manager, "has_unsaved_actions", self.props, "is_dirty")])
self.indent_mode = app.config["indent.mode"]
self.indent_size = app.config["indent.size"] # should come from syntax definition
self.newline_mode = app.config["newline_mode"]
self.highlight_selected_text = app.config["theme.highlight_selected_text.enabled"]
self.syntax_needs_color = False
self._edit_range = None
app.on_reload_config(self.reset_text_attributes, self)
# self.save_hooks = []
@property
def name(self):
return os.path.basename(self.file_path)
@property
def file_path(self):
if self.updates_path_on_file_move:
return self._fileref.path
return self._fileref
@file_path.setter
def file_path(self, value):
if self.updates_path_on_file_move:
ref = getattr(self, "_fileref", None)
if ref is None:
old_path = None
self._fileref = FileRef(value)
else:
old_path = ref.original_path
ref.path = value
else:
old_path = getattr(self, "_fileref", None)
self._fileref = value
self._refresh_file_mtime() # TODO should this (always) happen here?
if self.has_real_path():
self.app.documents.change_document_path(old_path, self)
@property
def updates_path_on_file_move(self):
return self._updates_path_on_file_move
@updates_path_on_file_move.setter
def updates_path_on_file_move(self, value):
path = self.file_path = self.file_path
if value:
self._fileref = FileRef(path)
else:
self._fileref = path
self._updates_path_on_file_move = value
@property
def file_mtime(self):
return self._filestat.st_mtime if self._filestat else None
@property
def text_storage(self):
try:
return self._text_storage
except AttributeError:
self.text_storage = Text()
self._load()
return self._text_storage
@text_storage.setter
def text_storage(self, value):
if hasattr(self, "_disable_text_edit_callback"):
self._disable_text_edit_callback()
del self._disable_text_edit_callback
if value is not None:
self._disable_text_edit_callback = value.on_edit(self.on_text_edit)
self._text_storage = value
@property
def text(self):
return self.text_storage.mutableString()
@text.setter
def text(self, value):
self.text_storage.mutableString().setString_(value)
self.reset_text_attributes()
@property
def newline_mode(self):
return self._newline_mode
@newline_mode.setter
def newline_mode(self, value):
self._newline_mode = value
self.eol = const.EOLS[value]
@property
def character_encoding(self):
return self.document_attrs.get(ak.NSCharacterEncodingDocumentAttribute)
@character_encoding.setter
def character_encoding(self, value):
# TODO when value is None encoding should be removed from document_attrs
if value is not None:
self.document_attrs[ak.NSCharacterEncodingDocumentAttribute] = value
else:
self.document_attrs.pop(ak.NSCharacterEncodingDocumentAttribute, None)
@property
def font(self):
try:
return self._font
except AttributeError:
return self.app.default_font
@font.setter
def font(self, value):
self._font = value
self.reset_text_attributes()
def reset_text_attributes(self, indent_size=0, event=None):
attrs = self.default_text_attributes(indent_size)
if self.text_storage is not None:
no_color = {k: v for k, v in attrs.items() if k != ak.NSForegroundColorAttributeName}
range = fn.NSMakeRange(0, self.text_storage.length())
self.text_storage.addAttributes_range_(no_color, range)
self.text_storage.setFont_(self.font.font)
self.syntax_needs_color = event and event.theme_changed
for editor in self.app.iter_editors_of_document(self):
editor.set_text_attributes(attrs)
def default_text_attributes(self, indent_size=None):
if indent_size is None:
try:
return self._text_attributes
except AttributeError:
indent_size = self.indent_size
if indent_size == 0:
indent_size = self.indent_size
font = self.font.font
tabw = (
ak.NSString.stringWithString_("8" * indent_size).sizeWithAttributes_({ak.NSFontAttributeName: font}).width
)
ps = ak.NSParagraphStyle.defaultParagraphStyle().mutableCopy()
ps.setTabStops_([])
ps.setDefaultTabInterval_(tabw)
self._text_attributes = attrs = {
ak.NSFontAttributeName: font,
ak.NSParagraphStyleAttributeName: ps,
ak.NSForegroundColorAttributeName: self.app.theme.text_color,
}
return attrs
def _load(self):
"""Load the document's file contents from disk
:returns: True if the file was loaded from disk, otherwise False.
"""
self.persistent_path = self.file_path
self._refresh_file_mtime()
if self._filestat is not None:
data = ak.NSData.dataWithContentsOfFile_(self.file_path)
success, err = self.read_from_data(data)
if success:
self.analyze_content()
self.reset_text_attributes()
else:
log.error(err) # TODO display error in progress bar
return success
self.reset_text_attributes()
return False
def read_from_data(self, data):
options = {ak.NSDefaultAttributesDocumentOption: self.default_text_attributes()}
options.update(self.document_attrs)
while True:
success, attrs, err = self._text_storage.readFromData_options_documentAttributes_error_(
data, options, None, None
)
if success or ak.NSCharacterEncodingDocumentAttribute not in options:
if success:
self.document_attrs = attrs
break
if err:
log.error(err)
options.pop(ak.NSCharacterEncodingDocumentAttribute, None)
return success, err
def save(self):
"""Save the document to disk
:raises: Error if the document does not have a real path.
"""
if not self.has_real_path():
if isabs(self.file_path):
raise Error("parent directory is missing: {}".format(self.file_path))
else:
raise Error("file path is not set")
path = self.file_path
self.write_to_file(path)
self.file_path = path # update FileRef
self.persistent_path = path
for action in [self._refresh_file_mtime, self.clear_dirty, self.app.save_window_states, self.update_syntaxer]:
try:
action()
except Exception:
log.error("unexpected error", exc_info=True)
def write_to_file(self, path):
"""Write the document's content to the given file path
The given file path must be an absolute path.
"""
if not isabs(path):
raise Error("cannot write to relative path: {}".format(path))
data, err = self.data()
if err is None:
ok, err = data.writeToFile_options_error_(path, 1, None)
if not ok:
raise Error("cannot write to {}: {}".format(path, err))
def data(self):
range = fn.NSMakeRange(0, self.text_storage.length())
attrs = self.document_attrs
data, err = self.text_storage.dataFromRange_documentAttributes_error_(range, attrs, None)
return (data, err)
def analyze_content(self):
text = self.text_storage.string()
start, end, cend = text.getLineStart_end_contentsEnd_forRange_(None, None, None, (0, 0))
if end != cend:
eol = EOLREF.get(text[cend:end], const.NEWLINE_MODE_UNIX)
self.props.newline_mode = eol
mode, size = calculate_indent_mode_and_size(text)
if size is not None:
self.props.indent_size = size
if mode is not None:
self.props.indent_mode = mode
def has_real_path(self):
"""Return true if this docuemnt has an absolute path where it could
possibly be saved; otherwise false
Note that this is not a garantee that the file can be saved at its
currently assigned file_path. For example, this will not detect if
file system permissions would prevent writing.
"""
return isabs(self.file_path) and isdir(dirname(self.file_path))
def file_exists(self):
"""Return True if this file has no absolute path on disk"""
return self.has_real_path() and exists(self.file_path)
def _refresh_file_mtime(self):
if self.file_exists():
self._filestat = filestat(self.file_path)
return
self._filestat = None
def is_externally_modified(self):
"""check if this document has been modified by another program
:returns: True if the file has been modified by another program,
otherwise False, and None if the file cannot be accessed.
"""
if self.file_exists():
stat = filestat(self.file_path)
if stat is not None:
return self._filestat != stat
return None
def file_changed_since_save(self):
"""Check if the file on disk has changed since the last save
:returns: True if the file on disk has been edited or moved by an
external program, False if the file exists but has not changed, and
None if the file does not exist.
"""
return self.persistent_path != self.file_path or self.is_externally_modified()
def check_for_external_changes(self, window):
if not self.is_externally_modified():
return
if self.is_dirty():
if window is None:
return # ignore change (no gui for alert)
stat = filestat(self.file_path)
if self._filestat == stat: # TODO is this check necessary?
return
self._filestat = stat
def callback(code, end_alert):
if code == ak.NSAlertFirstButtonReturn:
self.reload_document()
# should self.file_changed_since_save() -> True on cancel here?
alert = Alert.alloc().init()
alert.setMessageText_("“%s” source document changed" % self.name)
alert.setInformativeText_("Discard changes and reload?")
alert.addButtonWithTitle_("Reload")
alert.addButtonWithTitle_("Cancel")
alert.beginSheetModalForWindow_withCallback_(window, callback)
else:
self.reload_document()
@refactor("improve undo after reload - use difflib to replace changed text only")
def reload_document(self):
"""Reload document with the given URL
This implementation allows the user to undo beyond the reload. The
down-side is that it may use a lot of memory if the document is very
large.
"""
if not self.file_exists():
return
textstore = self._text_storage
self._text_storage = Text()
try:
ok = self._load()
finally:
tempstore = self._text_storage
self._text_storage = textstore
if not ok:
return
textview = None
for editor in self.app.iter_editors_of_document(self):
textview = editor.text_view
if textview is not None:
break
text = tempstore.string()
range = fn.NSRange(0, textstore.length())
if textview is None:
textstore.replaceCharactersInRange_withString_(range, text)
self.undo_manager.removeAllActions()
elif textview.shouldChangeTextInRange_replacementString_(range, text):
# state = self.documentState
textstore.replaceCharactersInRange_withString_(range, text)
# self.documentState = state
textview.didChangeText()
textview.breakUndoCoalescing()
# HACK use timed invocation to allow didChangeText notification
# to update change count before _clearUndo is invoked
call_later(0, self.clear_dirty)
textview.setSelectedRange_(fn.NSRange(0, 0))
self.reset_text_attributes()
self.update_syntaxer()
@untested
def prepareSavePanel_(self, panel):
try:
panel.setCanSelectHiddenExtension_(True)
panel.setExtensionHidden_(False)
panel.setAllowsOtherFileTypes_(True)
name = panel.nameFieldStringValue() # 10.6 API
url = self.fileURL()
if url is not None:
filename = url.lastPathComponent()
directory = url.URLByDeletingLastPathComponent()
panel.setDirectoryURL_(directory) # 10.6 API
else:
filename = name
name += ".txt"
if name != filename or (name.endswith(".txt") and "." in name[:-4]):
panel.setNameFieldStringValue_(filename)
exts = ["txt"]
if "." in filename:
ext = filename.rsplit(".", 1)[1]
if ext not in exts:
exts.insert(0, ext)
panel.setAllowedFileTypes_(exts)
except Exception:
log.error("cannot prepare save panel...", exc_info=True)
return True
def is_dirty(self):
return self.undo_manager.has_unsaved_actions()
def clear_dirty(self):
self.undo_manager.savepoint()
def icon(self):
path = self.file_path
key = "" if path is None else path
old_key, data = self.icon_cache
if old_key is None or old_key != key:
data = fetch_icon(key)
self.icon_cache = (key, data)
return data
@property
def comment_token(self):
return self.syntaxer.syntaxdef.comment_token
@comment_token.setter
def comment_token(self, value):
self.syntaxer.syntaxdef.comment_token = value
@property
def syntaxdef(self):
return self.syntaxer.syntaxdef
@syntaxdef.setter
def syntaxdef(self, value):
self.syntaxer.syntaxdef = value
self.color_text()
def update_syntaxer(self):
filename = os.path.basename(self.file_path)
if filename != self.syntaxer.filename:
self.syntaxer.filename = filename
syntaxdef = self.app.syntax_factory.get_definition(filename)
if self.syntaxdef is not syntaxdef:
self.syntax_needs_color = False
self.props.syntaxdef = syntaxdef
self.color_text()
return
if self.syntax_needs_color:
# force re-highlight entire document
self.syntax_needs_color = False
self.color_text()
def on_text_edit(self, rng):
if self.text_storage.editedMask() == ak.NSTextStorageEditedAttributes:
# break color text -> attribute change -> color text -> ...
return
self.color_text(rng)
def _coalesce_edit_ranges(self, rng=None):
rng_ = self._edit_range
if rng is None or rng_ is ALL:
rng = None
elif rng_ is not None:
rng = union_range(rng, rng_)
self._edit_range = rng or ALL
return (self, rng), {}
@debounce(0.05, _coalesce_edit_ranges)
def color_text(self, rng):
if self.text_storage is not None:
self.syntaxer.color_text(self.text_storage, rng, timeout=0.05)
self._edit_range = None
def __repr__(self):
return "<%s 0x%x %s>" % (type(self).__name__, id(self), self.name)
@objc.typedSelector(b"v@:@ii")
def document_shouldClose_contextInfo_(self, doc, should_close, info):
self.app.context.pop(info)(should_close)
def close(self):
self.text_storage = None
self.props = None
self.app.document_closed(self)
# -- TODO refactor NSDocument compat --------------------------------------
def displayName(self):
return self.name
def canCloseDocumentWithDelegate_shouldCloseSelector_contextInfo_(self, delegate, should_close, info):
raise NotImplementedError
