nyje/medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
medit/moo/mooscript/mooscript-classes-impl.cpp
Yevgen Muntyan 9dd2b8329e Build pygtk bindings from generated defs file
2010-12-11 00:28:34 -08:00

1558 lines
44 KiB
C++
Raw Blame History

#include "mooscript-classes.h"
#include "mooscript-classes-util.h"
#include "mooapp/mooapp.h"
#include "mooedit/moofileenc.h"
#include "mooutils/mooutils-misc.h"
#include "mooutils/moodialogs.h"
#include <string.h>
#include <sstream>
namespace mom {
// static void check_no_args(const VariantArray &args)
// {
// if (args.size() != 0)
// Error::raise("no arguments expected");
// }
//
// static void check_1_arg(const VariantArray &args)
// {
// if (args.size() != 1)
// Error::raise("exactly one argument expected");
// }
//
// template<typename T>
// static moo::SharedPtr<T> get_object(const Variant &val, bool null_ok = false)
// {
// if (null_ok && val.vt() == VtVoid)
// return moo::SharedPtr<T>();
//
// if (val.vt() != VtObject)
// Error::raise("object expected");
//
// HObject h = val.value<VtObject>();
// if (null_ok && h.id() == 0)
// return moo::SharedPtr<T>();
//
// moo::SharedPtr<Object> obj = Object::lookup_object(h);
//
// if (!obj)
// Error::raise("bad object");
// if (&obj->meta() != &T::class_meta())
// Error::raise("bad object");
//
// return moo::SharedPtr<T>(static_cast<T*>(obj.get()));
// }
//
// static bool get_bool(const Variant &val)
// {
// if (val.vt() != VtBool)
// Error::raise("boolean expected");
// return val.value<VtBool>();
// }
static String get_string(const Variant &val, bool null_ok = false)
{
if (null_ok && val.vt() == VtVoid)
return String();
if (val.vt() != VtString)
Error::raise("string expected");
return val.value<VtString>();
}
static moo::Vector<String> get_string_list(const Variant &val)
{
VariantArray ar;
if (val.vt() == VtArray)
ar = val.value<VtArray>();
else if (val.vt() == VtArgList)
ar = val.value<VtArgList>();
else
Error::raise("list expected");
moo::Vector<String> ret;
for (int i = 0, c = ar.size(); i < c; ++i)
ret.append(get_string(ar[i]));
return ret;
}
template<typename GClass, typename Class>
static VariantArray wrap_gslist(GSList *list)
{
VariantArray array;
while (list)
{
GClass *gobj = (GClass*) list->data;
array.append(HObject(gobj ? Class::wrap(gobj)->id() : 0));
list = list->next;
}
return array;
}
template<typename GArrayClass, typename GClass, typename Class>
static VariantArray wrap_array(GArrayClass *ar)
{
VariantArray array;
for (guint i = 0; i < ar->n_elms; ++i)
{
GClass *gobj = ar->elms[i];
array.append(HObject(gobj ? Class::wrap(gobj)->id() : 0));
}
return array;
}
static Index get_index(const Variant &val)
{
switch (val.vt())
{
case VtIndex:
return val.value<VtIndex>();
case VtInt:
return Index(val.value<VtInt>());
case VtBase1:
return val.value<VtBase1>().get_index();
default:
Error::raise("index expected");
}
}
static void get_iter(gint64 pos, GtkTextBuffer *buf, GtkTextIter *iter)
{
if (pos > gtk_text_buffer_get_char_count(buf) || pos < 0)
Error::raise("invalid offset");
gtk_text_buffer_get_iter_at_offset(buf, iter, pos);
}
static void get_iter(const Variant &val, GtkTextBuffer *buf, GtkTextIter *iter)
{
get_iter(get_index(val).get(), buf, iter);
}
static void get_pair(const Variant &val, Variant &elm1, Variant &elm2)
{
VariantArray ar;
if (val.vt() == VtArray)
ar = val.value<VtArray>();
else if (val.vt() == VtArgList)
ar = val.value<VtArgList>();
else
Error::raise("pair of values expected");
if (ar.size() != 2)
Error::raise("pair of values expected");
elm1 = ar[0];
elm2 = ar[1];
}
static VariantArray make_pair(const Variant &elm1, const Variant &elm2)
{
VariantArray ar;
ar.append(elm1);
ar.append(elm2);
return ar;
}
static void get_iter_pair(const Variant &val, GtkTextBuffer *buf, GtkTextIter *iter1, GtkTextIter *iter2)
{
Variant elm1, elm2;
get_pair(val, elm1, elm2);
get_iter(elm1, buf, iter1);
get_iter(elm2, buf, iter2);
}
///////////////////////////////////////////////////////////////////////////////
//
// Application
//
///
/// @node Application object
/// @section Application object
/// @helpsection{SCRIPT_APPLICATION}
/// @table @method
///
/// @item Application.editor()
/// returns Editor object.
Editor *Application::editor()
{
return &Editor::get_instance();
}
/// @item Application.quit()
/// quit @medit{}.
void Application::quit()
{
moo_app_quit(moo_app_get_instance());
}
struct DialogButtons
{
GtkButtonsType bt;
moo::Vector<String> custom;
String default_button;
};
static DialogButtons parse_buttons(const Variant &var)
{
DialogButtons buttons = { GTK_BUTTONS_NONE };
if (var.vt() == VtVoid)
return buttons;
if (var.vt() == VtArray)
{
buttons.custom = get_string_list(var);
return buttons;
}
if (var.vt() == VtString)
{
const String &str = var.value<VtString>();
if (str == "none")
buttons.bt = GTK_BUTTONS_NONE;
else if (str == "ok")
buttons.bt = GTK_BUTTONS_OK;
else if (str == "close")
buttons.bt = GTK_BUTTONS_CLOSE;
else if (str == "cancel")
buttons.bt = GTK_BUTTONS_CANCEL;
else if (str == "yesno")
buttons.bt = GTK_BUTTONS_YES_NO;
else if (str == "okcancel")
buttons.bt = GTK_BUTTONS_OK_CANCEL;
else
Error::raisef("in function %s, invalid dialog buttons value '%s'",
(const char*) current_func().name, (const char*) str);
return buttons;
}
Error::raisef("in function %s, invalid dialog buttons value",
(const char*) current_func().name);
}
static void
add_buttons (GtkWidget *dialog, const DialogButtons &buttons)
{
int default_response = G_MININT;
for (int i = 0, c = buttons.custom.size(); i < c; ++i)
{
gtk_dialog_add_button(GTK_DIALOG(dialog), buttons.custom[i], i);
if (buttons.custom[i] == buttons.default_button)
default_response = i;
}
if (default_response < 0 && !buttons.default_button.empty())
{
if (buttons.default_button == "ok")
default_response = GTK_RESPONSE_OK;
else if (buttons.default_button == "close")
default_response = GTK_RESPONSE_CLOSE;
else if (buttons.default_button == "cancel")
default_response = GTK_RESPONSE_CANCEL;
else if (buttons.default_button == "yes")
default_response = GTK_RESPONSE_YES;
else if (buttons.default_button == "no")
default_response = GTK_RESPONSE_NO;
else
Error::raisef("in function %s, invalid default button '%s'",
(const char*) current_func().name,
(const char*) buttons.default_button);
}
if (default_response != G_MININT)
gtk_dialog_set_default_response(GTK_DIALOG(dialog), default_response);
}
struct DialogOptions
{
String title;
String dialog_id;
String icon;
DialogButtons buttons;
gint64 width;
gint64 height;
DocumentWindow *parent;
};
struct FileDialogOptions
{
String filename;
bool multiple;
bool directory;
bool save;
};
struct ListDialogOptions
{
moo::Vector<String> columns;
moo::Vector<String> data;
bool checklist;
bool radiolist;
bool editable;
bool show_header;
String return_column;
};
struct MessageDialogOptions
{
String kind;
String text;
String secondary_text;
};
struct EntryDialogOptions
{
String text;
String entry_text;
bool hide;
};
struct TextDialogOptions
{
String text;
String info_text;
String filename;
bool editable;
};
static void setup_dialog(GtkWidget *dialog, const DialogOptions &opts)
{
add_buttons(dialog, opts.buttons);
if (!opts.title.empty())
gtk_window_set_title(GTK_WINDOW(dialog), opts.title);
if (opts.parent)
moo_window_set_parent(dialog, GTK_WIDGET(opts.parent->gobj()));
if (!opts.dialog_id.empty())
{
String prefs_key("Dialogs/");
prefs_key += opts.dialog_id;
_moo_window_set_remember_size(GTK_WINDOW(dialog), prefs_key, opts.width, opts.height, FALSE);
}
else if (opts.width > 0 && opts.height > 0)
{
gtk_window_set_default_size(GTK_WINDOW(dialog), opts.width, opts.height);
}
if (!opts.icon.empty())
gtk_window_set_icon_name(GTK_WINDOW(dialog), opts.icon);
}
static String response_to_string(int response, const DialogOptions &opts)
{
if (response >= 0)
{
if (response >= opts.buttons.custom.size())
Error::raisef("in function %s, got unexpected response %d from dialog",
(const char*) current_func().name, response);
return opts.buttons.custom[response];
}
switch (response)
{
case GTK_RESPONSE_NONE:
case GTK_RESPONSE_DELETE_EVENT:
return "";
case GTK_RESPONSE_REJECT:
return "reject";
case GTK_RESPONSE_ACCEPT:
return "accept";
case GTK_RESPONSE_OK:
return "ok";
case GTK_RESPONSE_CANCEL:
return "cancel";
case GTK_RESPONSE_CLOSE:
return "close";
case GTK_RESPONSE_YES:
return "yes";
case GTK_RESPONSE_NO:
return "no";
case GTK_RESPONSE_APPLY:
return "apply";
case GTK_RESPONSE_HELP:
return "help";
default:
Error::raisef("in function %s, got unexpected response %d from dialog",
(const char*) current_func().name, response);
}
}
static Variant show_file_dialog(G_GNUC_UNUSED const FileDialogOptions &dopts, G_GNUC_UNUSED const DialogOptions &opts)
{
Error::raise("not implemented");
}
static Variant show_list_dialog(G_GNUC_UNUSED const ListDialogOptions &dopts, G_GNUC_UNUSED const DialogOptions &opts)
{
Error::raise("not implemented");
}
static Variant show_message_dialog(const MessageDialogOptions &dopts, const DialogOptions &opts)
{
GtkMessageType type = GTK_MESSAGE_OTHER;
if (dopts.kind == "error")
type = GTK_MESSAGE_ERROR;
else if (dopts.kind == "warning")
type = GTK_MESSAGE_WARNING;
else if (dopts.kind == "question")
type = GTK_MESSAGE_QUESTION;
else if (dopts.kind == "information" || dopts.kind == "info")
type = GTK_MESSAGE_INFO;
else
Error::raisef("in function %s, invalid message dialog kind '%s'",
(const char*) current_func().name, (const char*) dopts.kind);
GtkWidget *dialog = gtk_message_dialog_new (0, GTK_DIALOG_MODAL, type, opts.buttons.bt,
"%s", (const char*) dopts.text);
if (!dopts.secondary_text.empty())
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG(dialog), "%s",
(const char*) dopts.secondary_text);
setup_dialog(dialog, opts);
int response = gtk_dialog_run(GTK_DIALOG(dialog));
return response_to_string(response, opts);
}
static Variant show_entry_dialog(G_GNUC_UNUSED const EntryDialogOptions &dopts, G_GNUC_UNUSED const DialogOptions &opts)
{
Error::raise("not implemented");
}
static Variant show_text_dialog(G_GNUC_UNUSED const TextDialogOptions &dopts, G_GNUC_UNUSED const DialogOptions &opts)
{
Error::raise("not implemented");
}
/// @item Application.dialog()
/// show a dialog.
Variant Application::dialog(const ArgSet &args)
{
if (!args.pos.empty())
Error::raisef("in function %s, no positional arguments expected",
(const char*) current_func().name);
DialogOptions opts;
opts.title = get_kwarg_string_opt(args, "title");
opts.dialog_id = get_kwarg_string_opt(args, "id");
opts.icon = get_kwarg_string_opt(args, "icon");
opts.width = get_kwarg_int_opt(args, "width", -1);
opts.height = get_kwarg_int_opt(args, "height", -1);
opts.buttons = parse_buttons(get_kwarg_variant_opt(args, "buttons"));
opts.buttons.default_button = get_kwarg_string_opt(args, "default_button");
opts.parent = get_object_arg_opt<DocumentWindow>(args.kw.value("parent"), "parent");
String kind = get_kwarg_string(args, "kind");
if (kind == "file" || kind == "file-selection")
{
FileDialogOptions dopts;
dopts.filename = get_kwarg_string_opt(args, "filename");
dopts.multiple = get_kwarg_bool_opt(args, "multiple");
dopts.directory = get_kwarg_bool_opt(args, "directory");
dopts.save = get_kwarg_bool_opt(args, "save");
return show_file_dialog(dopts, opts);
}
if (kind == "list")
{
ListDialogOptions dopts;
dopts.columns = get_string_list(args.kw.value("column"));
dopts.data = get_string_list(args.kw.value("data"));
dopts.checklist = get_kwarg_bool_opt(args, "checklist");
dopts.radiolist = get_kwarg_bool_opt(args, "radiolist");
dopts.editable = get_kwarg_bool_opt(args, "editable");
dopts.show_header = get_kwarg_bool_opt(args, "show_header");
dopts.return_column = get_kwarg_string_opt(args, "return_column");
return show_list_dialog(dopts, opts);
}
if (kind == "error" || kind == "warning" || kind == "question" || kind == "information")
{
MessageDialogOptions dopts;
dopts.kind = kind;
dopts.text = get_kwarg_string(args, "text");
dopts.secondary_text = get_kwarg_string_opt(args, "secondary_text");
return show_message_dialog(dopts, opts);
}
if (kind == "entry" || kind == "text-entry")
{
EntryDialogOptions dopts;
dopts.text = get_kwarg_string_opt(args, "text");
dopts.entry_text = get_kwarg_string_opt(args, "entry_text");
dopts.hide = get_kwarg_bool_opt(args, "hide");
return show_entry_dialog(dopts, opts);
}
if (kind == "text" || kind == "text-info")
{
TextDialogOptions dopts;
dopts.text = get_kwarg_string_opt(args, "text");
dopts.info_text = get_kwarg_string_opt(args, "info_text");
dopts.filename = get_kwarg_string_opt(args, "filename");
dopts.editable = get_kwarg_bool_opt(args, "editable");
return show_text_dialog(dopts, opts);
}
Error::raisef("in function %s, invalid dialog kind '%s'",
(const char*) current_func().name, (const char*) kind);
}
///
/// @end table
///
///////////////////////////////////////////////////////////////////////////////
//
// Editor
//
///
/// @node Editor object
/// @section Editor object
/// @helpsection{SCRIPT_EDITOR}
/// @table @method
///
/// @item Editor.active_document()
/// returns current active document or @null{} if there are no open documents
Document *Editor::active_document()
{
return Document::wrap(moo_editor_get_active_doc(moo_editor_instance()));
}
/// @item Editor.set_active_document(doc)
/// makes @param{doc} active
void Editor::set_active_document(Document &doc)
{
moo_editor_set_active_doc(moo_editor_instance(), doc.gobj());
}
/// @item Editor.active_window()
/// returns current active window
DocumentWindow *Editor::active_window()
{
return DocumentWindow::wrap(moo_editor_get_active_window(moo_editor_instance()));
}
/// @item Editor.set_active_window(window)
/// makes @param{window} active
void Editor::set_active_window(DocumentWindow &window)
{
moo_editor_set_active_window(moo_editor_instance(), window.gobj());
}
/// @item Editor.documents()
/// returns list of all open documents
VariantArray Editor::documents()
{
MooEditArray *docs = moo_editor_get_docs(moo_editor_instance());
VariantArray ret = wrap_array<MooEditArray, MooEdit, Document>(docs);
moo_edit_array_free(docs);
return ret;
}
/// @item Editor.windows()
/// returns list of all document windows
VariantArray Editor::windows()
{
MooEditWindowArray *windows = moo_editor_get_windows(moo_editor_instance());
VariantArray ret = wrap_array<MooEditWindowArray, MooEditWindow, DocumentWindow>(windows);
moo_edit_window_array_free(windows);
return ret;
}
/// @item Editor.new_document(window=null)
/// creates new document in specified window. If window is @null{} then
/// the document is created in an existing window
Document *Editor::new_document(DocumentWindow *window)
{
return Document::wrap(moo_editor_new_doc(moo_editor_instance(), window ? window->gobj() : NULL));
}
/// @item Editor.new_window()
/// creates new document window
DocumentWindow *Editor::new_window()
{
return DocumentWindow::wrap(moo_editor_new_window(moo_editor_instance()));
}
/// @item Editor.get_document_by_path(path)
/// returns document with path @param{path} or @null{}.
Document *Editor::get_document_by_path(const String &path)
{
return Document::wrap(moo_editor_get_doc_for_path(moo_editor_instance(), path));
}
/// @item Editor.get_document_by_uri(path)
/// returns document with uri @param{uri} or @null{}.
Document *Editor::get_document_by_uri(const String &uri)
{
return Document::wrap(moo_editor_get_doc_for_uri(moo_editor_instance(), uri));
}
static MooFileEncArray *get_file_info_list(const Variant &val, bool uri)
{
moo::Vector<String> filenames = get_string_list(val);
if (filenames.empty())
return NULL;
MooFileEncArray *files = moo_file_enc_array_new();
for (int i = 0, c = filenames.size(); i < c; ++i)
{
MooFileEnc *fenc = uri ?
moo_file_enc_new_for_uri(filenames[i], NULL) :
moo_file_enc_new_for_path(filenames[i], NULL);
if (!fenc)
goto error;
moo_file_enc_array_take(files, fenc);
}
return files;
error:
moo_file_enc_array_free(files);
Error::raise("error");
}
static void open_files_or_uris(const VariantArray &file_array, DocumentWindow *window, bool uri)
{
MooFileEncArray *files = get_file_info_list(file_array, uri);
moo_editor_open(moo_editor_instance(), window ? window->gobj() : NULL, NULL, files);
moo_file_enc_array_free(files);
}
/// @item Editor.open_files(files, window=null)
/// open files. If @param{window} is given then open files in that window,
/// otherwise in an existing window.
void Editor::open_files(const VariantArray &files, DocumentWindow *window)
{
open_files_or_uris(files, window, false);
}
/// @item Editor.open_uris(uris, window=null)
/// open files. If @param{window} is given then open files in that window,
/// otherwise in an existing window.
void Editor::open_uris(const VariantArray &uris, DocumentWindow *window)
{
open_files_or_uris(uris, window, true);
}
static Document *open_file_or_uri(const String &file, const String &encoding, DocumentWindow *window, bool uri, bool new_file)
{
MooEdit *doc = NULL;
if (new_file)
{
if (uri)
{
moo_assert_not_reached();
Error::raise("error");
}
else
{
doc = moo_editor_new_file(moo_editor_instance(), window ? window->gobj() : NULL, NULL, file, encoding);
}
}
else
{
if (uri)
doc = moo_editor_open_uri(moo_editor_instance(), window ? window->gobj() : NULL, NULL, file, encoding);
else
doc = moo_editor_open_file(moo_editor_instance(), window ? window->gobj() : NULL, NULL, file, encoding);
}
return Document::wrap(doc);
}
/// @item Editor.open_file(file, encoding=null, window=null)
/// open file. If @param{encoding} is @null{} or "auto" then pick character
/// encoding automatically, otherwise use @param{encoding}. If @param{window}
/// is given then open files in that window, otherwise in an existing window.
Document *Editor::open_file(const String &file, const String &encoding, DocumentWindow *window)
{
return open_file_or_uri(file, encoding, window, false, false);
}
/// @item Editor.open_uri(uri, encoding=null, window=null)
/// open file. If @param{encoding} is @null{} or "auto" then pick character
/// encoding automatically, otherwise use @param{encoding}. If @param{window}
/// is given then open files in that window, otherwise in an existing window.
Document *Editor::open_uri(const String &uri, const String &encoding, DocumentWindow *window)
{
return open_file_or_uri(uri, encoding, window, true, false);
}
/// @item Editor.new_file(file, encoding=null, window=null)
/// open file if it exists on disk or create a new one. If @param{encoding} is
/// @null{} or "auto" then pick character encoding automatically, otherwise use
/// @param{encoding}. If @param{window} is given then open file in that window,
/// otherwise in an existing window.
Document *Editor::new_file(const String &file, const String &encoding, DocumentWindow *window)
{
return open_file_or_uri(file, encoding, window, false, true);
}
/// @item Editor.reload(doc)
/// reload document.
void Editor::reload(Document &doc)
{
moo_edit_reload(doc.gobj(), NULL, NULL);
}
/// @item Editor.save(doc)
/// save document.
bool Editor::save(Document &doc)
{
return moo_edit_save(doc.gobj(), NULL);
}
/// @item Editor.save_as(doc, filename=null)
/// save document as @param{filename}. If @param{filename} is not given then
/// first ask user for new filename.
bool Editor::save_as(Document &doc, const String &filename)
{
return moo_edit_save_as(doc.gobj(),
filename.empty() ? NULL : (const char*) filename,
NULL,
NULL);
}
/// @item Editor.close(doc)
/// close document.
bool Editor::close(Document &doc)
{
return moo_edit_close(doc.gobj(), TRUE);
}
/// @item Editor.close_documents(docs)
/// close all documents in the list @param{docs}.
bool Editor::close_documents(const VariantArray &arr)
{
moo::Vector<MooEdit*> pvec;
for (int i = 0, c = arr.size(); i < c; ++i)
pvec.append(get_object_arg<Document>(arr[i], "doc").gobj());
MooEditArray *docs = moo_edit_array_new ();
for (int i = 0, c = pvec.size(); i < c; ++i)
moo_edit_array_append (docs, pvec[i]);
bool retval = moo_editor_close_docs (moo_editor_instance(), docs, TRUE);
moo_edit_array_free (docs);
return retval;
}
/// @item Editor.close_window(window)
/// close window.
bool Editor::close_window(DocumentWindow &window)
{
return moo_editor_close_window(moo_editor_instance(), window.gobj(), TRUE);
}
///
/// @end table
///
///////////////////////////////////////////////////////////////////////////////
//
// DocumentWindow
//
///
/// @node DocumentWindow object
/// @section DocumentWindow object
/// @helpsection{SCRIPT_DOCUMENT_WINDOW}
/// @table @method
///
/// @item DocumentWindow.editor()
/// returns Editor object.
Editor *DocumentWindow::editor()
{
return &Editor::get_instance();
}
/// @item DocumentWindow.active_document()
/// returns current active document in this window.
Document *DocumentWindow::active_document()
{
return Document::wrap(moo_edit_window_get_active_doc(gobj()));
}
/// @item DocumentWindow.set_active_document(doc)
/// makes active document @param{doc}.
void DocumentWindow::set_active_document(Document &doc)
{
moo_edit_window_set_active_doc(gobj(), doc.gobj());
}
/// @item DocumentWindow.documents()
/// returns list of all documents in this window.
VariantArray DocumentWindow::documents()
{
MooEditArray *docs = moo_edit_window_get_docs(gobj());
VariantArray ret = wrap_array<MooEditArray, MooEdit, Document>(docs);
moo_edit_array_free(docs);
return ret;
}
/// @item DocumentWindow.is_active()
/// returns whether this window is the active one.
bool DocumentWindow::is_active()
{
return gobj() == moo_editor_get_active_window(moo_editor_instance());
}
/// @item DocumentWindow.set_active()
/// makes this window active.
void DocumentWindow::set_active()
{
moo_editor_set_active_window(moo_editor_instance(), gobj());
}
///
/// @end table
///
///////////////////////////////////////////////////////////////////////////////
//
// Document
//
///
/// @node Document object
/// @section Document object
/// @helpsection{DOCUMENT}
///
/// @table @method
static GtkTextBuffer *buffer(Document *doc)
{
return gtk_text_view_get_buffer(GTK_TEXT_VIEW(doc->gobj()));
}
/// @item Document.filename()
/// returns full file path of the document or @null{} if the document
/// has not been saved yet or if it can't be represented with a local
/// path (e.g. if it is in a remote location like a web site).
/// @itemize @minus
/// @item Untitled => @null{}
/// @item @file{/home/user/example.txt} => @code{"/home/user/example.txt"}
/// @item @file{http://example.com/index.html} => @null{}
/// @end itemize
String Document::filename()
{
char *filename = moo_edit_get_utf8_filename(gobj());
return filename ? String::take_utf8(filename) : String::Null();
}
/// @item Document.uri()
/// returns URI of the document or @null{} if the document has not been
/// saved yet.
String Document::uri()
{
char *uri = moo_edit_get_uri(gobj());
return uri ? String::take_utf8(uri) : String::Null();
}
/// @item Document.basename()
/// returns basename of the document, that is the full path minus directory
/// part. If the document has not been saved yet, then it returns the name
/// shown in the titlebar, e.g. "Untitled".
String Document::basename()
{
return String(moo_edit_get_display_basename(gobj()));
}
/// @item Document.is_modified()
/// returns whether the document is modified.
bool Document::is_modified()
{
return MOO_EDIT_IS_MODIFIED(gobj());
}
/// @item Document.set_modified(modified)
/// sets modification state of the document.
void Document::set_modified(bool modified)
{
moo_edit_set_modified(gobj(), modified);
}
/// @item Document.encoding()
/// returns character encoding of the document.
String Document::encoding()
{
return moo_edit_get_encoding(gobj());
}
/// @item Document.set_encoding(encoding)
/// set character encoding of the document, it will be used when the document
/// is saved.
void Document::set_encoding(const String &enc)
{
moo_edit_set_encoding(gobj(), enc);
}
String Document::line_endings()
{
switch (moo_edit_get_line_end_type(gobj()))
{
case MOO_LE_UNIX:
return "unix";
case MOO_LE_WIN32:
return "win32";
case MOO_LE_MAC:
return "mac";
case MOO_LE_MIX:
return "mix";
case MOO_LE_NONE:
return "none";
}
moo_assert_not_reached();
Error::raise("error");
}
void Document::set_line_endings(const String &str_le)
{
MooLineEndType le = MOO_LE_NONE;
if (str_le == "unix")
le = MOO_LE_UNIX;
else if (str_le == "win32")
le = MOO_LE_WIN32;
else if (str_le == "mac")
le = MOO_LE_MAC;
else if (str_le == "mix")
le = MOO_LE_MIX;
else if (str_le == "none")
le = MOO_LE_NONE;
else
Error::raise("invalid line ending type");
moo_edit_set_line_end_type(gobj(), le);
}
/// @item Document.reload()
/// reload the document.
void Document::reload()
{
Editor::get_instance().reload(*this);
}
/// @item Document.save()
/// save the document.
bool Document::save()
{
return Editor::get_instance().save(*this);
}
/// @item Document.save_as(filename=null)
/// save the document as @param{filename}. If @param{filename} is @null{} then
/// @uilabel{Save As} will be shown to choose new filename.
bool Document::save_as(const String &filename)
{
return Editor::get_instance().save_as(*this, filename);
}
/// @item Document.can_undo()
/// returns whether undo action is available.
bool Document::can_undo()
{
return moo_text_view_can_undo(MOO_TEXT_VIEW(gobj()));
}
/// @item Document.can_redo()
/// returns whether redo action is available.
bool Document::can_redo()
{
return moo_text_view_can_redo(MOO_TEXT_VIEW(gobj()));
}
/// @item Document.undo()
/// undo.
void Document::undo()
{
moo_text_view_undo(MOO_TEXT_VIEW(gobj()));
}
/// @item Document.redo()
/// redo.
void Document::redo()
{
moo_text_view_redo(MOO_TEXT_VIEW(gobj()));
}
/// @item Document.begin_not_undoable_action()
/// mark the beginning of a non-undoable operation. Undo stack will be erased
/// and undo will not be recorded until @method{end_not_undoable_action()} call.
void Document::begin_not_undoable_action()
{
moo_text_view_begin_not_undoable_action(MOO_TEXT_VIEW(gobj()));
}
/// @item Document.end_not_undoable_action()
/// end the non-undoable operation started with @method{begin_not_undoable_action()}.
void Document::end_not_undoable_action()
{
moo_text_view_end_not_undoable_action(MOO_TEXT_VIEW(gobj()));
}
/// @end table
/// @table @method
/// @item Document.start_pos()
/// position at the beginning of the document (0 in Python, 1 in Lua, etc.)
gint64 Document::start_pos()
{
return 0;
}
/// @item Document.end_pos()
/// position at the end of the document. This is the position past the last
/// character: it points to no character, but it is a valid position for
/// text insertion, cursor may be put there, etc.
gint64 Document::end_pos()
{
return gtk_text_buffer_get_char_count(buffer(this));
}
/// @item Document.cursor_pos()
/// position at the cursor.
gint64 Document::cursor_pos()
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark(buf, &iter, gtk_text_buffer_get_insert(buf));
return gtk_text_iter_get_offset(&iter);
}
/// @item Document.set_cursor_pos(pos)
/// move cursor to position @param{pos}.
void Document::set_cursor_pos(gint64 pos)
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter iter;
get_iter(pos, buf, &iter);
gtk_text_buffer_place_cursor(buf, &iter);
}
/// @item Document.selection()
/// returns selection bounds as a list of two items, start and end. Returned
/// list is always sorted, use @method{cursor()} and @method{selection_bound()}
/// if you need to distinguish beginning and end of selection. If no text is
/// is selected, then it returns pair @code{[cursor, cursor]}.
VariantArray Document::selection()
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(buf, &start, &end);
return make_pair(Index(gtk_text_iter_get_offset(&start)),
Index(gtk_text_iter_get_offset(&end)));
}
/// @item Document.set_selection(bounds_as_list)
/// @item Document.set_selection(start, end)
/// select text.
void Document::set_selection(const ArgList &args)
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
if (args.size() == 1)
{
get_iter_pair(args[0], buf, &start, &end);
}
else if (args.size() == 2)
{
get_iter(args[0], buf, &start);
get_iter(args[1], buf, &end);
}
else
{
Error::raise("exactly one or two arguments expected");
}
gtk_text_buffer_select_range(buf, &start, &end);
}
/// @item Document.selection_bound()
/// returns the selection bound other than cursor position. Selection is
/// either [cursor, selection_bound) or [selection_bound, cursor), depending
/// on direction user dragged the mouse (or on @method{set_selection}
/// arguments).
gint64 Document::selection_bound()
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark(buf, &iter, gtk_text_buffer_get_selection_bound(buf));
return gtk_text_iter_get_offset(&iter);
}
/// @item Document.has_selection()
/// whether any text is selected.
bool Document::has_selection()
{
return gtk_text_buffer_get_selection_bounds(buffer(this), NULL, NULL);
}
/// @item Document.char_count()
/// character count.
gint64 Document::char_count()
{
return gtk_text_buffer_get_char_count(buffer(this));
}
/// @item Document.line_count()
/// line count.
gint64 Document::line_count()
{
return gtk_text_buffer_get_line_count(buffer(this));
}
/// @item Document.line_at_pos(pos)
/// returns index of the line which contains position @param{pos}.
gint64 Document::line_at_pos(gint64 pos)
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter iter;
get_iter(pos, buf, &iter);
return gtk_text_iter_get_line(&iter);
}
/// @item Document.pos_at_line(line)
/// returns position at the beginning of line @param{line}.
gint64 Document::pos_at_line(gint64 line)
{
GtkTextBuffer *buf = buffer(this);
if (line < 0 || line >= gtk_text_buffer_get_line_count(buf))
Error::raise("invalid line");
GtkTextIter iter;
gtk_text_buffer_get_iter_at_line(buf, &iter, line);
return gtk_text_iter_get_offset(&iter);
}
/// @item Document.pos_at_line_end(line)
/// returns position at the end of line @param{line}.
gint64 Document::pos_at_line_end(gint64 line)
{
GtkTextBuffer *buf = buffer(this);
if (line < 0 || line >= gtk_text_buffer_get_line_count(buf))
Error::raise("invalid line");
GtkTextIter iter;
gtk_text_buffer_get_iter_at_line(buf, &iter, line);
gtk_text_iter_forward_to_line_end(&iter);
return gtk_text_iter_get_offset(&iter);
}
/// @item Document.char_at_pos(pos)
/// returns character at position @param{pos} as string.
String Document::char_at_pos(gint64 pos)
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter iter;
get_iter(pos, buf, &iter);
if (gtk_text_iter_is_end(&iter))
Error::raise("can't get text at end of buffer");
gunichar c = gtk_text_iter_get_char(&iter);
char b[7];
b[g_unichar_to_utf8(c, b)] = 0;
return String(b);
}
/// @item Document.text()
/// returns whole document contents.
/// @item Document.text(start, end)
/// returns text in the range [@param{start}, @param{end}), @param{end} not
/// included. Example: @code{doc.text(doc.start_pos(), doc.end_pos())} is
/// equivalent @code{to doc.text()}.
String Document::text(const ArgList &args)
{
if (args.size() == 0)
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
gtk_text_buffer_get_bounds(buf, &start, &end);
return String::take_utf8(gtk_text_buffer_get_slice(buf, &start, &end, TRUE));
}
if (args.size() != 2)
Error::raise("either 0 or 2 arguments expected");
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
get_iter(args[0], buf, &start);
get_iter(args[1], buf, &end);
return String::take_utf8(gtk_text_buffer_get_slice(buf, &start, &end, TRUE));
}
/// @item Document.insert_text(text)
/// @item Document.insert_text(pos, text)
/// insert text into the document. If @param{pos} is not given, insert at
/// cursor position.
void Document::insert_text(const ArgList &args)
{
String text;
GtkTextIter iter;
GtkTextBuffer *buf = buffer(this);
if (args.size() == 1)
{
text = get_string(args[0]);
gtk_text_buffer_get_iter_at_mark(buf, &iter, gtk_text_buffer_get_insert(buf));
}
else if (args.size() == 2)
{
get_iter(args[0], buf, &iter);
text = get_string(args[1]);
}
else
{
Error::raise("one or two arguments expected");
}
gtk_text_buffer_insert(buf, &iter, text.utf8(), -1);
}
/// @item Document.replace_text(start, end, text)
/// replace text in the region [@param{start}, @param{end}). Equivalent to
/// @code{delete_text(start, end), insert_text(start, text)}.
void Document::replace_text(gint64 start_pos, gint64 end_pos, const String &text)
{
GtkTextIter start, end;
GtkTextBuffer *buf = buffer(this);
get_iter(start_pos, buf, &start);
get_iter(end_pos, buf, &end);
gtk_text_buffer_delete(buf, &start, &end);
gtk_text_buffer_insert(buf, &start, text.utf8(), -1);
}
/// @item Document.delete_text(start, end)
/// delete text in the region [@param{start}, @param{end}). Example:
/// @code{doc.delete_text(doc.start(), doc.end())} will delete all text in
/// @code{doc}.
void Document::delete_text(gint64 start_pos, gint64 end_pos)
{
GtkTextIter start, end;
GtkTextBuffer *buf = buffer(this);
get_iter(start_pos, buf, &start);
get_iter(end_pos, buf, &end);
gtk_text_buffer_delete(buf, &start, &end);
}
/// @item Document.append_text(text)
/// append text. Equivalent to @code{doc.insert_text(doc.end(), text)}.
void Document::append_text(const String &text)
{
GtkTextIter iter;
GtkTextBuffer *buf = buffer(this);
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, text.utf8(), -1);
}
/// @item Document.clear()
/// delete all text in the document.
void Document::clear()
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
gtk_text_buffer_get_bounds(buf, &start, &end);
gtk_text_buffer_delete(buf, &start, &end);
}
/// @item Document.copy()
/// copy selected text to clipboard. If no text is selected then nothing
/// will happen, same as Ctrl-C key combination.
void Document::copy()
{
g_signal_emit_by_name(gobj(), "copy-clipboard");
}
/// @item Document.cut()
/// cut selected text to clipboard. If no text is selected then nothing
/// will happen, same as Ctrl-X key combination.
void Document::cut()
{
g_signal_emit_by_name(gobj(), "cut-clipboard");
}
/// @item Document.paste()
/// paste text from clipboard. It has the same effect as Ctrl-V key combination:
/// nothing happens if clipboard is empty, and selected text is replaced with
/// clipboard contents otherwise.
void Document::paste()
{
g_signal_emit_by_name(gobj(), "paste-clipboard");
}
/// @item Document.select_text(bounds_as_list)
/// @item Document.select_text(start, end)
/// select text, same as @method{set_selection()}.
void Document::select_text(const ArgList &args)
{
GtkTextIter start, end;
GtkTextBuffer *buf = buffer(this);
if (args.size() == 2)
{
get_iter(args[0], buf, &start);
get_iter(args[1], buf, &end);
}
else if (args.size() == 1)
{
get_iter_pair(args[0], buf, &start, &end);
}
else
{
Error::raise("exactly one or two arguments expected");
}
gtk_text_buffer_select_range(buf, &start, &end);
}
/// @item Document.select_lines(line)
/// select a line.
/// @item Document.select_lines(first, last)
/// select lines from @param{first} to @param{last}, @emph{including}
/// @param{last}.
void Document::select_lines(const ArgList &args)
{
Index first_line, last_line;
if (args.size() == 1)
{
first_line = last_line = get_index(args[0]);
}
else if (args.size() == 2)
{
first_line = get_index(args[0]);
last_line = get_index(args[1]);
}
else
{
Error::raise("exactly one or two arguments expected");
}
if (first_line.get() > last_line.get())
std::swap(first_line, last_line);
GtkTextBuffer *buf = buffer(this);
if (first_line.get() < 0 || first_line.get() >= gtk_text_buffer_get_line_count(buf))
Error::raise("invalid line");
if (last_line.get() < 0 || last_line.get() >= gtk_text_buffer_get_line_count(buf))
Error::raise("invalid line");
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_line(buf, &start, first_line.get());
gtk_text_buffer_get_iter_at_line(buf, &end, last_line.get());
gtk_text_iter_forward_line(&end);
gtk_text_buffer_select_range(buf, &start, &end);
}
static void get_select_lines_range(const VariantArray &args, GtkTextBuffer *buf, GtkTextIter *start, GtkTextIter *end)
{
if (args.size() == 1)
{
get_iter(args[0], buf, start);
*end = *start;
}
else if (args.size() == 2)
{
get_iter(args[0], buf, start);
get_iter(args[1], buf, end);
}
else
{
Error::raise("exactly one or two arguments expected");
}
gtk_text_iter_order(start, end);
gtk_text_iter_forward_line(end);
}
/// @item Document.select_lines_at_pos(bounds_as_list)
/// @item Document.select_lines_at_pos(start, end)
/// select lines: similar to @method{select_text}, but select whole lines.
void Document::select_lines_at_pos(const ArgList &args)
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
get_select_lines_range(args, buf, &start, &end);
gtk_text_buffer_select_range(buf, &start, &end);
}
/// @item Document.select_all()
/// select all.
void Document::select_all()
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
gtk_text_buffer_get_bounds(buf, &start, &end);
gtk_text_buffer_select_range(buf, &start, &end);
}
/// @item Document.selected_text()
/// returns selected text.
String Document::selected_text()
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(buf, &start, &end);
return String::take_utf8(gtk_text_buffer_get_slice(buf, &start, &end, TRUE));
}
static void get_selected_lines_bounds(GtkTextBuffer *buf, GtkTextIter *start, GtkTextIter *end, bool *cursor_at_next_line = 0)
{
if (cursor_at_next_line)
*cursor_at_next_line = false;
gtk_text_buffer_get_selection_bounds(buf, start, end);
gtk_text_iter_set_line_offset(start, 0);
if (gtk_text_iter_starts_line(end) && !gtk_text_iter_equal(start, end))
{
gtk_text_iter_backward_line(end);
if (cursor_at_next_line)
*cursor_at_next_line = true;
}
if (!gtk_text_iter_ends_line(end))
gtk_text_iter_forward_to_line_end(end);
}
/// @item Document.selected_lines()
/// returns selected lines as a list of strings, one string for each line,
/// line terminator characters not included. If nothing is selected, then
/// line at cursor is returned.
VariantArray Document::selected_lines()
{
GtkTextIter start, end;
GtkTextBuffer *buf = buffer(this);
get_selected_lines_bounds(buf, &start, &end);
char *text = gtk_text_buffer_get_slice(buf, &start, &end, TRUE);
char **lines = moo_splitlines(text);
VariantArray ar;
for (char **p = lines; p && *p; ++p)
ar.append(String::take_utf8(*p));
g_free(lines);
g_free(text);
return ar;
}
/// @item Document.delete_selected_text()
/// delete selected text, equivalent to @code{doc.delete_text(doc.cursor(),
/// doc.selection_bound())}.
void Document::delete_selected_text()
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(buf, &start, &end);
gtk_text_buffer_delete(buf, &start, &end);
}
/// @item Document.delete_selected_lines()
/// delete selected lines. Similar to @method{delete_selected_text()} but
/// selection is extended to include whole lines. If nothing is selected,
/// then line at cursor is deleted.
void Document::delete_selected_lines()
{
GtkTextIter start, end;
GtkTextBuffer *buf = buffer(this);
get_selected_lines_bounds(buf, &start, &end);
gtk_text_iter_forward_line(&end);
gtk_text_buffer_delete(buf, &start, &end);
}
/// @item Document.replace_selected_text(text)
/// replace selected text with @param{text}. If nothing is selected,
/// @param{text} is inserted at cursor.
void Document::replace_selected_text(const String &text)
{
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(buf, &start, &end);
gtk_text_buffer_delete(buf, &start, &end);
gtk_text_buffer_insert(buf, &start, text.utf8(), -1);
gtk_text_buffer_place_cursor(buf, &start);
}
static String join(const moo::Vector<String> &list, const String &sep)
{
std::stringstream ss;
for (int i = 0, c = list.size(); i < c; ++i)
{
if (i != 0)
ss << sep.utf8();
ss << list[i].utf8();
}
return ss.str();
}
/// @item Document.replace_selected_lines(text)
/// @item Document.replace_selected_lines(lines)
/// replace selected lines with @param{text}. Similar to
/// @method{replace_selected_text()}, but selection is extended to include
/// whole lines. If nothing is selected, then line at cursor is replaced.
void Document::replace_selected_lines(const Variant &repl)
{
String text;
switch (repl.vt())
{
case VtString:
text = repl.value<VtString>();
break;
case VtArray:
{
moo::Vector<String> lines = get_string_list(repl);
text = join(lines, "\n");
}
break;
case VtArgList:
{
moo::Vector<String> lines = get_string_list(repl);
text = join(lines, "\n");
}
break;
default:
Error::raisef("string or list of strings expected, got %s",
get_argument_type_name(repl.vt()));
break;
}
GtkTextBuffer *buf = buffer(this);
GtkTextIter start, end;
bool cursor_at_next_line;
get_selected_lines_bounds(buf, &start, &end, &cursor_at_next_line);
gtk_text_buffer_delete(buf, &start, &end);
gtk_text_buffer_insert(buf, &start, text.utf8(), -1);
if (cursor_at_next_line)
{
gtk_text_iter_forward_line(&start);
gtk_text_buffer_place_cursor(buf, &start);
}
}
/// @end table
} // namespace mom
Reference in New Issue View Git Blame Copy Permalink