def __init__(self, textview, textbuffer):
self.text_view = textview
self.buffer = textbuffer
self.suggestion = ""
self.bubble = self.bubble_label = None
self.buffer.connect_after('insert-text', self.text_insert)
self.text_view.connect('key-press-event', self.key_pressed)
self.language = "en_US"
self.frequency_dict = {}
self.get_frequency_dict(self.language)
self.enchant_dict = enchant.Dict(self.language)
self.use_pressagio = False
config_file = get_media_path("pressagio_config.ini")
pres_config = configparser.ConfigParser()
pres_config.read(config_file)
pres_config.set("Database", "database",
get_media_path("corpora/" + self.language + ".sqlite"))
self.callback = PressagioCallback("")
self.predictor_registry = pressagio.predictor.PredictorRegistry(
pres_config)
self.context_tracker = pressagio.context_tracker.ContextTracker(
pres_config, self.predictor_registry, self.callback)
self.prsgio = self.predictor_registry[0]
def get_frequency_dict(self, _language):
self.frequency_dict = {}
pp_pickled = get_media_path("frequency_dict_" + self.language +
".pickle")
if pp_pickled and os.path.isfile(pp_pickled):
frequency_file = open(pp_pickled, 'rb')
self.frequency_dict = pickle.load(frequency_file)
frequency_file.close()
else:
pp = get_media_path('wordlists/en_us_wordlist.xml')
frequencies = ET.parse(pp)
root = frequencies.getroot()
for child in root:
self.frequency_dict[child.text] = int(child.attrib['f'])
frequency_file = open('pickled_dict', 'wb+')
pickle.dump(self.frequency_dict, frequency_file)
frequency_file.close()
def __do_convert(self):
while True:
while True:
(text, callback, user_data) = self.queue.get()
if text is None and callback is None:
return
if self.queue.empty():
break
args = [
'--standalone', '--mathjax',
'--css=' + Theme.get_current().web_css_path, '--lua-filter=' +
helpers.get_media_path('/lua/relative_to_absolute.lua'),
'--lua-filter=' + helpers.get_media_path('/lua/task-list.lua')
]
text = helpers.pandoc_convert(text, to="html5", args=args)
GLib.idle_add(callback, text, *user_data)
def set_language(self, language):
print("Language changed to: %s" % language)
# handle 2 char cases e.g. "en"
if len(language) == 2:
if "en":
language = "en_US"
if self.language == language:
return
self.language = language
print("Language changing")
config_file = get_media_path("pressagio_config.ini")
pres_config = configparser.ConfigParser()
pres_config.read(config_file)
pres_config.set("Database", "database",
get_media_path("corpora/" + self.language + ".sqlite"))
self.context_tracker = pressagio.context_tracker.ContextTracker(
pres_config, self.predictor_registry, self.callback)
self.prsgio = self.predictor_registry[0]
self.enchant_dict = enchant.Dict(self.language)
def export(self, widget):
self.retrieve_args()
if self.exports_multiple_files:
export_dialog = Gtk.FileChooserNative.new(
_("Export"), None, Gtk.FileChooserAction.SELECT_FOLDER,
_("Select folder"), _("Cancel"))
else:
export_dialog = Gtk.FileChooserNative.new(
_("Export"), None, Gtk.FileChooserAction.SAVE,
_("Export to %s") %
self.formats_list.get_selected_row().item.name, _("Cancel"))
export_dialog.set_current_name(
self.file.name + '.' +
self.formats_list.get_selected_row().item.ext)
export_dialog.set_transient_for(self)
export_dialog.set_do_overwrite_confirmation(True)
response = export_dialog.run()
if self.exports_multiple_files:
folder = export_dialog.get_file()
with ZipFile(helpers.get_media_path("/media/reveal.js.zip"),
"r") as zipObj:
zipObj.extractall(folder.get_path())
export_file = folder.get_child(
self.file.name + '.' +
self.formats_list.get_selected_row().item.ext)
else:
export_file = export_dialog.get_file()
fmt = self.formats_list.get_selected_row().item.to
args = self.retrieve_args()
if response == Gtk.ResponseType.ACCEPT:
try:
export(self.text, export_file, fmt, args)
except (NotADirectoryError, RuntimeError) as e:
helpers.show_error(
None,
_("An error happened while trying to export:\n\n{err_msg}")
.format(err_msg=str(e).encode().decode("unicode-escape")))
export_dialog.destroy()
self.destroy()
def retrieve_args(self):
args = []
if self.formats_list.get_selected_row().item.ext == "pdf":
args.append("--pdf-engine=xelatex")
if self.sw_standalone.get_active():
args.append("--standalone")
if self.sw_toc.get_active():
args.append("--toc")
if self.sw_numbers.get_active():
args.append("--number-sections")
if (self.show_page_size_options
and self.cmb_page_size.get_selected_index() == 0):
if ((fmt := self.formats_list.get_selected_row().item.to)
in {"pdf", "latex", "context"}):
args.append("--variable=papersize:a4")
elif fmt in ("odt", "docx"):
args.append("--reference-doc=" + helpers.get_media_path(
"/reference_files/reference-a4." + fmt))
def __init__(self, file, text, **kwargs):
super().__init__(**kwargs)
self.file = file
self.text = text
if not self.formats:
with open(helpers.get_media_path("/media/formats.json")) as f:
_formats_list = json.load(f)
for _i, format in enumerate(_formats_list):
self.formats.append(
Format(format["name"], format["ext"], format["to"]))
self.formats_list.bind_model(self.formats, self.row_constructor, None)
self.formats_list.select_row(self.formats_list.get_row_at_index(0))
page_sizes_list = helpers.liststore_from_list(self.page_sizes)
self.cmb_page_size.bind_name_model(page_sizes_list, self.get_hdy_name,
None, None)
syntax_styles_list = helpers.liststore_from_list(self.syntax_styles)
self.cmb_syntax_highlighting.bind_name_model(syntax_styles_list,
self.get_hdy_name, None,
None)
class ExportDialog:
__gtype_name__ = "ExportDialog"
formats = {
"pdf": {
"name": "PDF",
"extension": "pdf",
"to": "pdf",
"mimetype": "application/pdf",
"args": ["--pdf-engine=xelatex", "--variable=papersize:a4"]
},
"html": {
"name":
"HTML",
"extension":
"html",
"to":
"html5",
"mimetype":
"text/html",
"args": [
"--self-contained",
"--css=%s" % Theme.get_current().web_css_path, "--mathjax",
"--lua-filter=%s" %
helpers.get_media_path('/lua/relative_to_absolute.lua'),
"--lua-filter=%s" %
helpers.get_media_path('/lua/task-list.lua')
]
},
"odt": {
"name": "ODT",
"extension": "odt",
"to": "odt",
"mimetype": "application/vnd.oasis.opendocument.text",
"args": ["--variable=papersize:a4"]
}
}
def __init__(self, file, _format, text):
self.format = _format
self.text = text
self._show_texlive_warning = (self.format == "pdf" and
not helpers.exist_executable("pdftex"))
if (self._show_texlive_warning):
self.dialog = Gtk.MessageDialog(
None,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.ERROR, Gtk.ButtonsType.CLOSE)
self.dialog.get_message_area().add(TexliveWarning())
else:
self.dialog = Gtk.FileChooserNative.new(
_("Export"), None, Gtk.FileChooserAction.SAVE,
_("Export to %s") % self.formats[self.format]["name"],
_("Cancel"))
dialog_filter = Gtk.FileFilter.new()
dialog_filter.set_name(self.formats[self.format]["name"])
dialog_filter.add_mime_type(self.formats[self.format]["mimetype"])
self.dialog.add_filter(dialog_filter)
self.dialog.set_do_overwrite_confirmation(True)
self.dialog.set_current_name(
file.name + '.' + self.formats[self.format]["extension"])
def export(self):
response = self.dialog.run()
if not self._show_texlive_warning:
file = self.dialog.get_file()
fmt = self.formats[self.format]["to"]
args = self.formats[self.format]["args"]
if response == Gtk.ResponseType.ACCEPT:
try:
export(self.text, file, fmt, args)
except (NotADirectoryError, RuntimeError) as e:
helpers.show_error(
None,
_("An error happened while trying to export:\n\n"
"{err_msg}").format(err_msg=str(e).encode().decode(
"unicode-escape")))
self.dialog.destroy()
class AdvancedExportDialog(Handy.Window):
__gtype_name__ = "AdvancedExportDialog"
headerbar = Gtk.Template.Child()
formats_list = Gtk.Template.Child()
leaflet = Gtk.Template.Child()
options_page = Gtk.Template.Child()
formats_page = Gtk.Template.Child()
# #### --option properties-- #####
sw_standalone = Gtk.Template.Child()
sw_toc = Gtk.Template.Child()
sw_numbers = Gtk.Template.Child()
cmb_page_size = Gtk.Template.Child()
sw_self_contained = Gtk.Template.Child()
sw_syntax_highlighting = Gtk.Template.Child()
cmb_syntax_highlighting = Gtk.Template.Child()
sw_incremental_bullets = Gtk.Template.Child()
# #### ---------------------- #####
formats = Gio.ListStore.new(Format)
page_sizes = ['A4', 'Letter']
syntax_styles = [
'pygments', 'kate', 'monochrome', 'espresso', 'zenburn', 'haddock',
'tango'
]
def __init__(self, file, text, **kwargs):
super().__init__(**kwargs)
self.file = file
self.text = text
if not self.formats:
with open(helpers.get_media_path("/media/formats.json")) as f:
_formats_list = json.load(f)
for _i, format in enumerate(_formats_list):
self.formats.append(
Format(format["name"], format["ext"], format["to"]))
self.formats_list.bind_model(self.formats, self.row_constructor, None)
self.formats_list.select_row(self.formats_list.get_row_at_index(0))
page_sizes_list = helpers.liststore_from_list(self.page_sizes)
self.cmb_page_size.bind_name_model(page_sizes_list, self.get_hdy_name,
None, None)
syntax_styles_list = helpers.liststore_from_list(self.syntax_styles)
self.cmb_syntax_highlighting.bind_name_model(syntax_styles_list,
self.get_hdy_name, None,
None)
@GObject.Property(type=str)
def title(self):
name = self.formats_list.get_selected_row().item.name
return _("Export to {}").format(name)
@GObject.Property(type=bool, default=False)
def show_page_size_options(self):
return self.formats_list.get_selected_row().item.has_pages
@GObject.Property(type=bool, default=False)
def show_html_options(self):
return self.formats_list.get_selected_row().item.is_html
@GObject.Property(type=bool, default=False)
def show_syntax_options(self):
return self.formats_list.get_selected_row().item.has_syntax
@GObject.Property(type=bool, default=False)
def show_presentation_options(self):
return self.formats_list.get_selected_row().item.is_presentation
@GObject.Property(type=bool, default=False)
def show_texlive_warning(self):
is_tex = self.formats_list.get_selected_row().item.requires_texlive
texlive_installed = helpers.exist_executable("pdftex")
return is_tex and not texlive_installed
@GObject.Property(type=bool, default=False)
def show_go_back_button(self):
folded = self.leaflet.props.folded
on_options_page = (
self.leaflet.get_visible_child() == self.options_page)
return folded and on_options_page
@GObject.Property(type=str, default="options")
def options_page_name(self):
name = "texlive_warning" if self.show_texlive_warning else "options"
return name
@GObject.Property(type=bool, default=False)
def exports_multiple_files(self):
return self.formats_list.get_selected_row().item.to == "revealjs"
def row_constructor(self, item, _user_data):
row = Handy.ActionRow.new()
row.item = item
row.set_title(item.name)
return row
def get_hdy_name(self, item, _user_data, _user_data_free):
return item.dup_string()
def get_hdy_comborow_name(self, hdy_cmbrow):
model = hdy_cmbrow.get_model()
index = hdy_cmbrow.get_selected_index()
item = model.get_item(index)
return item.dup_string()
@Gtk.Template.Callback()
def reveal_go_back(self, _widget, *args):
self.notify("show_go_back_button")
@Gtk.Template.Callback()
def go_back(self, _widget):
self.leaflet.set_visible_child(self.formats_page)
@Gtk.Template.Callback()
def on_format_selected(self, _widget, _row):
self.leaflet.set_visible_child(self.options_page)
self.notify("show_page_size_options")
self.notify("show_html_options")
self.notify("show_syntax_options")
self.notify("show_presentation_options")
self.notify("show_texlive_warning")
self.notify("options_page_name")
self.notify("title")
@Gtk.Template.Callback()
def on_destroy(self, _widget):
self.destroy()
@Gtk.Template.Callback()
def export(self, widget):
self.retrieve_args()
if self.exports_multiple_files:
export_dialog = Gtk.FileChooserNative.new(
_("Export"), None, Gtk.FileChooserAction.SELECT_FOLDER,
_("Select folder"), _("Cancel"))
else:
export_dialog = Gtk.FileChooserNative.new(
_("Export"), None, Gtk.FileChooserAction.SAVE,
_("Export to %s") %
self.formats_list.get_selected_row().item.name, _("Cancel"))
export_dialog.set_current_name(
self.file.name + '.' +
self.formats_list.get_selected_row().item.ext)
export_dialog.set_transient_for(self)
export_dialog.set_do_overwrite_confirmation(True)
response = export_dialog.run()
if self.exports_multiple_files:
folder = export_dialog.get_file()
with ZipFile(helpers.get_media_path("/media/reveal.js.zip"),
"r") as zipObj:
zipObj.extractall(folder.get_path())
export_file = folder.get_child(
self.file.name + '.' +
self.formats_list.get_selected_row().item.ext)
else:
export_file = export_dialog.get_file()
fmt = self.formats_list.get_selected_row().item.to
args = self.retrieve_args()
if response == Gtk.ResponseType.ACCEPT:
try:
export(self.text, export_file, fmt, args)
except (NotADirectoryError, RuntimeError) as e:
helpers.show_error(
None,
_("An error happened while trying to export:\n\n{err_msg}")
.format(err_msg=str(e).encode().decode("unicode-escape")))
export_dialog.destroy()
self.destroy()
def retrieve_args(self):
args = []
if self.formats_list.get_selected_row().item.ext == "pdf":
args.append("--pdf-engine=xelatex")
if self.sw_standalone.get_active():
args.append("--standalone")
if self.sw_toc.get_active():
args.append("--toc")
if self.sw_numbers.get_active():
args.append("--number-sections")
if (self.show_page_size_options
and self.cmb_page_size.get_selected_index() == 0):
if ((fmt := self.formats_list.get_selected_row().item.to)
in {"pdf", "latex", "context"}):
args.append("--variable=papersize:a4")
elif fmt in ("odt", "docx"):
args.append("--reference-doc=" + helpers.get_media_path(
"/reference_files/reference-a4." + fmt))
if self.show_html_options:
args.append("--css=%s" % Theme.get_current().web_css_path)
args.append("--mathjax")
args.append(
"--lua-filter=%s" %
helpers.get_media_path('/lua/relative_to_absolute.lua'))
args.append("--lua-filter=%s" %
helpers.get_media_path('/lua/task-list.lua'))
if self.sw_self_contained.get_active():
args.append("--self-contained")
if self.show_syntax_options:
if self.sw_syntax_highlighting.get_enable_expansion():
selected_style = self.get_hdy_comborow_name(
self.cmb_syntax_highlighting)
args.append("--highlight-style={}".format(selected_style))
if self.show_presentation_options:
if self.sw_incremental_bullets.get_active():
args.append("--incremental")
if self.formats_list.get_selected_row().item.to == "revealjs":
args.extend(["-V", "revealjs-url=reveal.js"])
return args
@classmethod
def get_current(cls):
current_theme, _ = cls.get_current_changed()
return current_theme
def __eq__(self, other):
return isinstance(other, self.__class__) and \
self.name == other.name and \
self.web_css_path == other.web_css_path and \
self.is_dark == other.is_dark and \
self.inverse_name == other.inverse_name
defaultThemes = [
# https://gitlab.gnome.org/GNOME/gtk/tree/master/gtk/theme/Adwaita
Theme('Adwaita', get_media_path('/media/css/web/adwaita.css'), False,
'Adwaita-dark'),
Theme('Adwaita-dark', get_media_path('/media/css/web/adwaita.css'), True,
'Adwaita'),
# https://github.com/NicoHood/arc-theme/tree/master/common/gtk-3.0/3.20/sass
Theme('Arc', get_media_path('/media/css/web/arc.css'), False, 'Arc-Dark'),
Theme('Arc-Darker', get_media_path('/media/css/web/arc.css'), False,
'Arc-Dark'),
Theme('Arc-Dark', get_media_path('/media/css/web/arc.css'), True, 'Arc'),
# https://gitlab.gnome.org/GNOME/gtk/tree/master/gtk/theme/HighContrast
Theme('HighContrast', get_media_path('/media/css/web/highcontrast.css'),
False, 'HighContrastInverse'),
Theme('HighContrastInverse',
get_media_path('/media/css/web/highcontrast_inverse.css'), True,
'HighContrast')
]
