mirror of
https://github.com/textmate/textmate.git
synced 2026-01-22 13:17:55 -05:00
397 lines
16 KiB
C++
397 lines
16 KiB
C++
#ifndef DOCUMENT_H_MIJOONQT
|
|
#define DOCUMENT_H_MIJOONQT
|
|
|
|
#include <buffer/buffer.h>
|
|
#include <undo/undo.h>
|
|
#include <plist/uuid.h>
|
|
#include <plist/date.h>
|
|
#include <settings/settings.h>
|
|
#include <text/types.h>
|
|
#include <authorization/authorization.h>
|
|
#include <file/bytes.h>
|
|
#include <file/open.h>
|
|
#include <file/save.h>
|
|
#include <file/encoding.h>
|
|
#include <scope/scope.h>
|
|
#include <regexp/glob.h>
|
|
#include <oak/debug.h>
|
|
|
|
namespace document
|
|
{
|
|
struct watch_t;
|
|
struct document_t;
|
|
typedef std::shared_ptr<watch_t> watch_ptr;
|
|
typedef std::shared_ptr<document_t> document_ptr;
|
|
typedef std::shared_ptr<document_t const> document_const_ptr;
|
|
typedef std::weak_ptr<document_t> document_weak_ptr;
|
|
|
|
struct PUBLIC open_callback_t : file::open_callback_t
|
|
{
|
|
virtual ~open_callback_t () { }
|
|
virtual void show_content (std::string const& path, io::bytes_ptr content, std::map<std::string, std::string> const& attributes, std::string const& fileType, encoding::type const& encoding, std::vector<oak::uuid_t> const& binaryImportFilters, std::vector<oak::uuid_t> const& textImportFilters) { }
|
|
virtual void show_document (std::string const& path, document_ptr document) = 0;
|
|
virtual void show_error (std::string const& path, document_ptr document, std::string const& message, oak::uuid_t const& filter) = 0;
|
|
virtual void show_error (std::string const& path, std::string const& message, oak::uuid_t const& filter) { }
|
|
};
|
|
|
|
typedef std::shared_ptr<open_callback_t> open_callback_ptr;
|
|
|
|
struct PUBLIC save_callback_t : file::save_callback_t
|
|
{
|
|
virtual ~save_callback_t () { }
|
|
virtual void did_save_document (document_ptr document, std::string const& path, bool success, std::string const& message, oak::uuid_t const& filter) = 0;
|
|
virtual void did_save (std::string const& path, io::bytes_ptr content, encoding::type const& encoding, bool success, std::string const& message, oak::uuid_t const& filter) { }
|
|
};
|
|
|
|
typedef std::shared_ptr<save_callback_t> save_callback_ptr;
|
|
|
|
struct inode_t
|
|
{
|
|
inode_t () { }
|
|
inode_t (dev_t device, ino_t inode, std::string const& path);
|
|
inode_t (std::string const& path);
|
|
|
|
operator bool () const { return valid; }
|
|
bool operator== (inode_t const& rhs) const { return valid == rhs.valid && inode == rhs.inode && device == rhs.device; }
|
|
bool operator!= (inode_t const& rhs) const { return valid != rhs.valid || inode != rhs.inode || device != rhs.device; }
|
|
bool operator< (inode_t const& rhs) const;
|
|
|
|
dev_t device = 0;
|
|
ino_t inode = 0;
|
|
bool valid = false;
|
|
};
|
|
|
|
struct PUBLIC document_t : std::enable_shared_from_this<document_t>
|
|
{
|
|
WATCH_LEAKS(document_t);
|
|
|
|
document_t () : _did_load_marks(false), _selection(NULL_STR), _folded(NULL_STR), _disable_callbacks(false), _revision(0), _disk_revision(0), _modified(false), _path(NULL_STR), _open_count(0), _has_lru(false), _is_on_disk(false), _recent_tracking(true), _backup_path(NULL_STR), _backup_revision(0), _virtual_path(NULL_STR), _custom_name(NULL_STR), _untitled_count(0), _file_type(NULL_STR), /*_folder(NULL_STR),*/ _disk_encoding(NULL_STR), _disk_newlines(NULL_STR), _disk_bom(false) { }
|
|
~document_t ();
|
|
|
|
bool operator== (document_t const& rhs) const { return _identifier == rhs._identifier; }
|
|
bool operator!= (document_t const& rhs) const { return _identifier != rhs._identifier; }
|
|
|
|
// ============================================================
|
|
// = Doing one-pass reading of file (find in arbitrary files) =
|
|
// ============================================================
|
|
|
|
struct reader_t { virtual io::bytes_ptr next () = 0; virtual ~reader_t () { } };
|
|
typedef std::shared_ptr<reader_t> reader_ptr;
|
|
reader_ptr create_reader () const;
|
|
|
|
// ======================================================
|
|
// = Performing replacements (from outside a text view) =
|
|
// ======================================================
|
|
|
|
void replace (std::multimap<std::pair<size_t, size_t>, std::string> const& replacements);
|
|
|
|
// ===================================================================
|
|
// = Controlling marks (bookmarks, warnings, errors, search matches) =
|
|
// ===================================================================
|
|
|
|
struct mark_t
|
|
{
|
|
WATCH_LEAKS(document_t::mark_t);
|
|
|
|
mark_t (char const* type = "bookmark") : type(type), info("") { }
|
|
mark_t (std::string const& type, std::string const& info = "") : type(type), info(info) { }
|
|
bool operator== (mark_t const& rhs) const { return type == rhs.type && info == rhs.info; }
|
|
bool operator!= (mark_t const& rhs) const { return type != rhs.type || info != rhs.info; }
|
|
std::string type, info;
|
|
};
|
|
|
|
void add_mark (text::range_t const& range, mark_t const& mark = mark_t());
|
|
void remove_all_marks (std::string const& typeToClear = NULL_STR);
|
|
std::multimap<text::range_t, mark_t> marks () const;
|
|
|
|
private:
|
|
void load_marks (std::string const& src) const;
|
|
void setup_marks (std::string const& src, ng::buffer_t& buf) const;
|
|
std::string marks_as_string () const;
|
|
mutable std::multimap<text::range_t, mark_t> _marks;
|
|
mutable bool _did_load_marks;
|
|
|
|
std::string _selection;
|
|
std::string _folded;
|
|
ng::index_t _visible_index;
|
|
io::bytes_ptr _content;
|
|
|
|
// ===============
|
|
// = Symbol list =
|
|
// ===============
|
|
public:
|
|
std::map<text::pos_t, std::string> symbols ();
|
|
|
|
// ===================
|
|
// = Callback system =
|
|
// ===================
|
|
|
|
struct callback_t
|
|
{
|
|
WATCH_LEAKS(document_t::callback_t);
|
|
|
|
enum event_t
|
|
{
|
|
did_save,
|
|
|
|
did_change_open_status,
|
|
did_change_modified_status,
|
|
did_change_on_disk_status,
|
|
did_change_path,
|
|
did_change_file_type,
|
|
did_change_indent_settings,
|
|
// did_change_display_name,
|
|
did_change_marks,
|
|
// did_change_symbols,
|
|
};
|
|
|
|
virtual ~callback_t () { }
|
|
virtual void handle_document_event (document_ptr document, event_t event) = 0;
|
|
};
|
|
|
|
void add_callback (callback_t* callback) { _callbacks.add(callback); }
|
|
void remove_callback (callback_t* callback) { _callbacks.remove(callback); }
|
|
|
|
private:
|
|
void check_modified (ssize_t diskRev, ssize_t rev);
|
|
|
|
void broadcast (callback_t::event_t event, bool cascade = true)
|
|
{
|
|
if(_disable_callbacks)
|
|
return;
|
|
|
|
_disable_callbacks = !cascade;
|
|
_callbacks(&callback_t::handle_document_event, shared_from_this(), event);
|
|
_disable_callbacks = false;
|
|
}
|
|
|
|
oak::callbacks_t<callback_t> _callbacks;
|
|
bool _disable_callbacks;
|
|
|
|
// ===================
|
|
// = For OakTextView =
|
|
// ===================
|
|
|
|
void post_load (std::string const& path, io::bytes_ptr content, std::map<std::string, std::string> const& attributes, std::string const& fileType, encoding::type const& encoding);
|
|
|
|
struct open_callback_wrapper_t : file::open_callback_t
|
|
{
|
|
open_callback_wrapper_t (document::document_ptr doc, document::open_callback_ptr callback) : _document(doc), _callbacks(1, callback) { }
|
|
|
|
void select_charset (std::string const& path, io::bytes_ptr content, file::open_context_ptr context) { _callbacks[0]->select_charset(path, content, context); }
|
|
void select_line_feeds (std::string const& path, io::bytes_ptr content, file::open_context_ptr context) { _callbacks[0]->select_line_feeds(path, content, context); }
|
|
void select_file_type (std::string const& path, io::bytes_ptr content, file::open_context_ptr context) { if(_document->file_type() == NULL_STR) _callbacks[0]->select_file_type(path, content, context); else context->set_file_type(_document->file_type()); }
|
|
void add_callback (document::open_callback_ptr callback) { _callbacks.push_back(callback); }
|
|
|
|
void show_content (std::string const& path, io::bytes_ptr content, std::map<std::string, std::string> const& attributes, std::string const& fileType, encoding::type const& encoding, std::vector<oak::uuid_t> const& binaryImportFilters, std::vector<oak::uuid_t> const& textImportFilters)
|
|
{
|
|
// we are deleted in post_load() so make a copy of relevant data
|
|
std::vector<document::open_callback_ptr> callbacks(_callbacks);
|
|
document::document_ptr doc = _document;
|
|
|
|
_document->post_load(path, content, attributes, fileType, encoding);
|
|
iterate(cb, callbacks)
|
|
(*cb)->show_document(path, doc);
|
|
}
|
|
|
|
void show_error (std::string const& path, std::string const& message, oak::uuid_t const& filter)
|
|
{
|
|
// we are deleted in post_load() so make a copy of relevant data
|
|
std::vector<document::open_callback_ptr> callbacks(_callbacks);
|
|
document::document_ptr doc = _document;
|
|
|
|
_document->post_load(path, io::bytes_ptr(), std::map<std::string, std::string>(), NULL_STR, encoding::type());
|
|
iterate(cb, callbacks)
|
|
(*cb)->show_error(path, doc, message, filter);
|
|
}
|
|
|
|
private:
|
|
document::document_ptr _document;
|
|
std::vector<document::open_callback_ptr> _callbacks;
|
|
};
|
|
|
|
typedef std::shared_ptr<open_callback_wrapper_t> open_callback_wrapper_ptr;
|
|
open_callback_wrapper_ptr _open_callback;
|
|
|
|
void post_save (std::string const& path, io::bytes_ptr content, encoding::type const& encoding, bool succes);
|
|
|
|
public:
|
|
bool try_open (document::open_callback_ptr callback);
|
|
void open ();
|
|
void close ();
|
|
|
|
void show ();
|
|
void hide ();
|
|
oak::date_t const& lru () const;
|
|
|
|
void try_save (document::save_callback_ptr callback);
|
|
bool save ();
|
|
bool backup ();
|
|
void detach_backup () { _backup_path = NULL_STR; }
|
|
|
|
void set_path (std::string const& newPath);
|
|
void set_virtual_path (std::string const& virtualPath) { _virtual_path = virtualPath; }
|
|
void set_custom_name (std::string const& newCustomName) { _custom_name = newCustomName; }
|
|
void set_file_type (std::string const& newFileType);
|
|
|
|
std::string path () const { return _path; }
|
|
std::string virtual_path () const { return _virtual_path == NULL_STR ? _path : _virtual_path; }
|
|
std::string custom_name () const { return _custom_name; }
|
|
std::string backup_path () const;
|
|
std::string display_name () const;
|
|
|
|
void set_disk_encoding (encoding::type const& encoding) { _disk_newlines = encoding.newlines(); _disk_encoding = encoding.charset(); _disk_bom = encoding.byte_order_mark(); }
|
|
encoding::type disk_encoding () const { return encoding::type(_disk_newlines, _disk_encoding, _disk_bom); }
|
|
|
|
void set_indent (text::indent_t const& indent);
|
|
text::indent_t const& indent () const;
|
|
|
|
encoding::type encoding_for_save_as_path (std::string const& path);
|
|
|
|
bool recent_tracking () const { return _recent_tracking && _path != NULL_STR; }
|
|
void set_recent_tracking (bool flag) { _recent_tracking = flag; }
|
|
|
|
bool sticky () const { return _sticky; }
|
|
void set_sticky (bool flag) { _sticky = flag; }
|
|
|
|
ng::buffer_t& buffer () { ASSERT(_buffer); return *_buffer; }
|
|
ng::buffer_t const& buffer () const { ASSERT(_buffer); return *_buffer; }
|
|
|
|
ng::undo_manager_t& undo_manager () { ASSERT(_undo_manager); return *_undo_manager; }
|
|
ng::undo_manager_t const& undo_manager () const { ASSERT(_undo_manager); return *_undo_manager; }
|
|
|
|
std::string content () const;
|
|
void set_content (std::string const& str);
|
|
|
|
// =============
|
|
// = Accessors =
|
|
// =============
|
|
|
|
oak::uuid_t identifier () const { return _identifier; }
|
|
ssize_t revision () const { return _revision; }
|
|
void set_revision (ssize_t rev) { check_modified(_disk_revision, rev); }
|
|
bool is_open () const { return _open_count != 0 && !_open_callback; }
|
|
|
|
std::string file_type () const;
|
|
|
|
std::map<std::string, std::string> document_variables () const;
|
|
|
|
bool is_modified () const;
|
|
bool is_on_disk () const { return is_open() ? _is_on_disk : path::exists(path()); }
|
|
void set_disk_revision (ssize_t rev) { check_modified(rev, _revision); }
|
|
std::string const& selection () const { return _selection; }
|
|
std::string const& folded () const { return _folded; }
|
|
ng::index_t visible_index () const { return _visible_index; }
|
|
|
|
void set_selection (std::string const& sel) { _selection = sel; _visible_index = ng::index_t(); }
|
|
void set_folded (std::string const& folded) { _folded = folded; }
|
|
void set_visible_index (ng::index_t index) { _visible_index = index; }
|
|
|
|
void set_authorization (osx::authorization_t const& auth) { _authorization = auth; }
|
|
|
|
private:
|
|
void setup_buffer ();
|
|
void set_modified (bool flag);
|
|
|
|
// ==============
|
|
// = Properties =
|
|
// ==============
|
|
|
|
friend document_ptr create (std::string const& path);
|
|
friend document_ptr from_content (std::string const& content, std::string fileType);
|
|
friend document_ptr find (oak::uuid_t const& uuid, bool searchBackups);
|
|
|
|
oak::uuid_t _identifier; // to identify this document when there is no path
|
|
inode_t _inode;
|
|
ssize_t _revision;
|
|
ssize_t _disk_revision;
|
|
bool _modified;
|
|
|
|
std::string _path; // does not imply there actually is a file
|
|
size_t _open_count; // document open in some window/tab
|
|
mutable oak::date_t _lru; // last time document was shown
|
|
mutable bool _has_lru;
|
|
bool _is_on_disk;
|
|
bool _recent_tracking;
|
|
bool _sticky = false;
|
|
|
|
mutable std::string _backup_path; // if there is a backup, this is set — we can have a backup even when there is no path
|
|
mutable ssize_t _backup_revision;
|
|
|
|
std::string _virtual_path;
|
|
std::string _custom_name;
|
|
mutable size_t _untitled_count; // this is ≠ 0 if the document is untitled
|
|
|
|
mutable std::string _file_type; // this may also be in the settings
|
|
// oak::uuid_t _grammar_uuid;
|
|
|
|
std::shared_ptr<ng::buffer_t> _buffer;
|
|
std::string _pristine_buffer = NULL_STR;
|
|
std::shared_ptr<ng::undo_manager_t> _undo_manager;
|
|
void mark_pristine ();
|
|
|
|
// std::string _folder; // when there is no path, this value is where the document will likely end up, i.e, used for retrieving settings and default save location
|
|
osx::authorization_t _authorization; // when opened via sudo
|
|
|
|
friend struct document_tracker_t;
|
|
size_t untitled_count () const { return _untitled_count; }
|
|
|
|
std::string _disk_encoding;
|
|
std::string _disk_newlines;
|
|
bool _disk_bom;
|
|
|
|
text::indent_t _indent;
|
|
|
|
protected: // so that we can trigger the callback in unit tests
|
|
watch_ptr _file_watcher;
|
|
friend struct watch_t;
|
|
void watch_callback (int flags, std::string const& newPath, bool async = true);
|
|
};
|
|
|
|
PUBLIC document_ptr create (std::string const& path = NULL_STR);
|
|
PUBLIC document_ptr find (oak::uuid_t const& uuid, bool searchBackups = false);
|
|
PUBLIC document_ptr from_content (std::string const& content, std::string fileType = NULL_STR);
|
|
|
|
// ====================
|
|
// = Document scanner =
|
|
// ====================
|
|
|
|
struct PUBLIC scanner_t
|
|
{
|
|
WATCH_LEAKS(scanner_t);
|
|
|
|
scanner_t (std::string const& path, path::glob_list_t const& glob, bool follow_links = false, bool depth_first = false, bool includeUntitled = true);
|
|
~scanner_t ();
|
|
|
|
bool is_running () const { return is_running_flag; }
|
|
void stop () { should_stop_flag = true; }
|
|
void wait () const { pthread_join(thread, NULL); }
|
|
|
|
static std::vector<document_ptr> open_documents ();
|
|
|
|
std::vector<document_ptr> accept_documents ();
|
|
std::string get_current_path () const;
|
|
|
|
private:
|
|
std::string path;
|
|
path::glob_list_t glob;
|
|
bool follow_links, depth_first;
|
|
|
|
pthread_t thread;
|
|
mutable pthread_mutex_t mutex;
|
|
volatile bool is_running_flag, should_stop_flag;
|
|
|
|
void thread_main ();
|
|
void scan_dir (std::string const& dir);
|
|
|
|
std::string current_path;
|
|
std::vector<document_ptr> documents;
|
|
std::set< std::pair<dev_t, ino_t> > seen_paths;
|
|
};
|
|
|
|
typedef std::shared_ptr<scanner_t> scanner_ptr;
|
|
|
|
} /* document */
|
|
|
|
#endif /* end of include guard: DOCUMENT_H_MIJOONQT */
|