# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*- # BEGIN LICENSE # Copyright (C) 2012, Wolf Vollprecht # This program is free software: you can redistribute it and/or modify it # under the terms of the GNU General Public License version 3, as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranties of # MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR # PURPOSE. See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program. If not, see . # END LICENSE import codecs import locale import logging import os import re import urllib import webbrowser from gettext import gettext as _ import gi from uberwriter.export_dialog import Export from uberwriter.text_view import TextView gi.require_version('Gtk', '3.0') gi.require_version('WebKit2', '4.0') # pylint: disable=wrong-import-position from gi.repository import Gtk, Gdk, GObject, GLib, Gio from gi.repository import WebKit2 as WebKit import cairo from uberwriter import helpers from uberwriter.theme import Theme from uberwriter.helpers import get_builder from uberwriter.gtkspellcheck import SpellChecker from uberwriter.sidebar import Sidebar from uberwriter.search_and_replace import SearchAndReplace from uberwriter.settings import Settings from . import headerbars # Some Globals # TODO move them somewhere for better # accesibility from other files LOGGER = logging.getLogger('uberwriter') CONFIG_PATH = os.path.expanduser("~/.config/uberwriter/") class Window(Gtk.ApplicationWindow): __gsignals__ = { 'save-file': (GObject.SIGNAL_ACTION, None, ()), 'open-file': (GObject.SIGNAL_ACTION, None, ()), 'save-file-as': (GObject.SIGNAL_ACTION, None, ()), 'new-file': (GObject.SIGNAL_ACTION, None, ()), 'toggle-bibtex': (GObject.SIGNAL_ACTION, None, ()), 'toggle-preview': (GObject.SIGNAL_ACTION, None, ()), 'close-window': (GObject.SIGNAL_ACTION, None, ()) } WORDCOUNT = re.compile(r"(?!\-\w)[\s#*\+\-]+", re.UNICODE) def __init__(self, app): """Set up the main window""" Gtk.ApplicationWindow.__init__(self, application=Gio.Application.get_default(), title="Uberwriter") # Set UI self.builder = get_builder('Window') root = self.builder.get_object("FullscreenOverlay") root.connect('style-updated', self.apply_current_theme) self.add(root) self.set_default_size(900, 500) # Preferences self.settings = Settings.new() # Headerbars self.headerbar = headerbars.MainHeaderbar(app) self.set_titlebar(self.headerbar.hb_container) self.fs_headerbar = headerbars.FullscreenHeaderbar(self.builder, app) self.title_end = " – UberWriter" self.set_headerbar_title("New File" + self.title_end) self.word_count = self.builder.get_object('word_count') self.char_count = self.builder.get_object('char_count') # Setup status bar hide after 3 seconds self.status_bar = self.builder.get_object('status_bar_box') self.statusbar_revealer = self.builder.get_object('status_bar_revealer') self.status_bar.get_style_context().add_class('status-bar-box') self.status_bar_visible = True self.was_motion = True self.buffer_modified_for_status_bar = False self.timestamp_last_mouse_motion = 0 if self.settings.get_value("poll-motion"): self.connect("motion-notify-event", self.on_motion_notify) GObject.timeout_add(3000, self.poll_for_motion) self.accel_group = Gtk.AccelGroup() self.add_accel_group(self.accel_group) # Setup text editor self.text_view = TextView() self.text_view.props.halign = Gtk.Align.CENTER self.text_view.connect('focus-out-event', self.focus_out) self.text_view.show() self.text_view.grab_focus() self.text_view.get_buffer().connect('changed', self.on_text_changed) # Setup preview webview self.preview_webview = None self.scrolled_window = self.builder.get_object('editor_scrolledwindow') self.scrolled_window.get_style_context().add_class('uberwriter-scrolled-window') self.scrolled_window.add(self.text_view) self.editor_viewport = self.builder.get_object('editor_viewport') # some people seems to have performance problems with the overlay. # Let them disable it self.overlay_id = None self.toggle_gradient_overlay(self.settings.get_value("gradient-overlay")) # Init file name with None self.set_filename() # Setting up spellcheck self.auto_correct = None self.toggle_spellcheck(self.settings.get_value("spellcheck")) self.did_change = False ### # Sidebar initialization test ### self.paned_window = self.builder.get_object("main_pained") self.sidebar_box = self.builder.get_object("sidebar_box") self.sidebar = Sidebar(self) self.sidebar_box.hide() ### # Search and replace initialization # Same interface as Sidebar ;) ### self.searchreplace = SearchAndReplace(self, self.text_view) # Window resize self.window_resize(self) self.connect("configure-event", self.window_resize) self.connect("delete-event", self.on_delete_called) # Set current theme self.apply_current_theme() self.get_style_context().add_class('uberwriter-window') def apply_current_theme(self, *_): """Adjusts the window, CSD and preview for the current theme. """ # Get current theme theme, changed = Theme.get_current_changed() if changed: # Set theme variant (dark/light) Gtk.Settings.get_default().set_property( "gtk-application-prefer-dark-theme", GLib.Variant("b", theme.is_dark)) # Set theme css style_provider = Gtk.CssProvider() style_provider.load_from_path(theme.gtk_css_path) Gtk.StyleContext.add_provider_for_screen( self.get_screen(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) # Reload preview if it exists self.reload_preview() # Redraw contents of window self.queue_draw() def update_line_and_char_count(self): """it... it updates line and characters count """ if self.status_bar_visible is False: return text = self.text_view.get_text() self.char_count.set_text(str(len(text))) words = re.split(self.WORDCOUNT, text) length = len(words) # Last word a "space" if not words[-1]: length = length - 1 # First word a "space" (happens in focus mode...) if not words[0]: length = length - 1 if length == -1: length = 0 self.word_count.set_text(str(length)) def on_text_changed(self, *_args): """called when the text changes, sets the self.did_change to true and updates the title and the counters to reflect that """ if self.did_change is False: self.did_change = True title = self.get_title() self.set_headerbar_title("* " + title) self.buffer_modified_for_status_bar = True self.update_line_and_char_count() def set_fullscreen(self, state): """Puts the application in fullscreen mode and show/hides the poller for motion in the top border Arguments: state {almost bool} -- The desired fullscreen state of the window """ if state.get_boolean(): self.fullscreen() self.fs_headerbar.events.show() else: self.unfullscreen() self.fs_headerbar.events.hide() self.text_view.grab_focus() def set_focus_mode(self, state): """toggle focusmode """ focus_mode = state.get_boolean() self.text_view.set_focus_mode(focus_mode) if self.spell_checker: self.spell_checker._misspelled.set_property('underline', 0 if focus_mode else 4) self.text_view.grab_focus() def set_hemingway_mode(self, state): """toggle hemingwaymode """ self.text_view.set_hemingway_mode(state.get_boolean()) self.text_view.grab_focus() def window_resize(self, window, event=None): """set paddings dependant of the window size """ # Adjust text editor width depending on window width, so that: # - The number of characters per line is adequate (http://webtypography.net/2.1.2) # - The number of characters stays constant while resizing the window / font # - There is enough text margin for MarkupBuffer to apply indents / negative margins # # TODO: Avoid hard-coding. Font size is clearer than unclear dimensions, but not ideal. w_width = event.width if event else window.get_allocation().width if w_width < 900: font_size = 14 self.get_style_context().add_class("small") self.get_style_context().remove_class("large") elif w_width < 1280: font_size = 16 self.get_style_context().remove_class("small") self.get_style_context().remove_class("large") else: font_size = 18 self.get_style_context().remove_class("small") self.get_style_context().add_class("large") font_width = int(font_size * 1/1.6) # Ratio specific to Fira Mono width = 67 * font_width - 1 # 66 characters horizontal_margin = 8 * font_width # 8 characters width_request = width + horizontal_margin * 2 if self.text_view.props.width_request != width_request: self.text_view.props.width_request = width_request self.text_view.set_left_margin(horizontal_margin) self.text_view.set_right_margin(horizontal_margin) self.scrolled_window.props.width_request = width_request # TODO: refactorizable def save_document(self, _widget=None, _data=None): """provide to the user a filechooser and save the document where he wants. Call set_headbar_title after that """ if self.filename: LOGGER.info("saving") filename = self.filename file_to_save = codecs.open(filename, encoding="utf-8", mode='w') file_to_save.write(self.text_view.get_text()) file_to_save.close() if self.did_change: self.did_change = False title = self.get_title() self.set_headerbar_title(title[2:]) return Gtk.ResponseType.OK filefilter = Gtk.FileFilter.new() filefilter.add_mime_type('text/x-markdown') filefilter.add_mime_type('text/plain') filefilter.set_name('Markdown (.md)') filechooser = Gtk.FileChooserDialog( _("Save your File"), self, Gtk.FileChooserAction.SAVE, ("_Cancel", Gtk.ResponseType.CANCEL, "_Save", Gtk.ResponseType.OK) ) filechooser.set_do_overwrite_confirmation(True) filechooser.add_filter(filefilter) response = filechooser.run() if response == Gtk.ResponseType.OK: filename = filechooser.get_filename() if filename[-3:] != ".md": filename = filename + ".md" try: self.recent_manager.add_item("file:/ " + filename) except: pass file_to_save = codecs.open(filename, encoding="utf-8", mode='w') file_to_save.write(self.text_view.get_text()) file_to_save.close() self.set_filename(filename) self.set_headerbar_title( os.path.basename(filename) + self.title_end) self.did_change = False filechooser.destroy() return response filechooser.destroy() return Gtk.ResponseType.CANCEL def save_document_as(self, _widget=None, _data=None): """provide to the user a filechooser and save the document where he wants. Call set_headbar_title after that """ filechooser = Gtk.FileChooserDialog( "Save your File", self, Gtk.FileChooserAction.SAVE, ("_Cancel", Gtk.ResponseType.CANCEL, "_Save", Gtk.ResponseType.OK) ) filechooser.set_do_overwrite_confirmation(True) if self.filename: filechooser.set_filename(self.filename) response = filechooser.run() if response == Gtk.ResponseType.OK: filename = filechooser.get_filename() if filename[-3:] != ".md": filename = filename + ".md" try: self.recent_manager.remove_item("file:/" + filename) self.recent_manager.add_item("file:/ " + filename) except: pass file_to_save = codecs.open(filename, encoding="utf-8", mode='w') file_to_save.write(self.text_view.get_text()) file_to_save.close() self.set_filename(filename) self.set_headerbar_title( os.path.basename(filename) + self.title_end) try: self.recent_manager.add_item(filename) except: pass filechooser.destroy() self.did_change = False else: filechooser.destroy() return Gtk.ResponseType.CANCEL def copy_html_to_clipboard(self, _widget=None, _date=None): """Copies only html without headers etc. to Clipboard """ output = helpers.pandoc_convert(self.text_view.get_text()) clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) clipboard.set_text(output, -1) clipboard.store() def open_document(self, _widget=None): """open the desired file """ if self.check_change() == Gtk.ResponseType.CANCEL: return markdown_filter = Gtk.FileFilter.new() markdown_filter.add_mime_type('text/markdown') markdown_filter.add_mime_type('text/x-markdown') markdown_filter.set_name(_('Markdown Files')) plaintext_filter = Gtk.FileFilter.new() plaintext_filter.add_mime_type('text/plain') plaintext_filter.set_name(_('Plain Text Files')) filechooser = Gtk.FileChooserDialog( _("Open a .md file"), self, Gtk.FileChooserAction.OPEN, ("_Cancel", Gtk.ResponseType.CANCEL, "_Open", Gtk.ResponseType.OK) ) filechooser.add_filter(markdown_filter) filechooser.add_filter(plaintext_filter) response = filechooser.run() if response == Gtk.ResponseType.OK: filename = filechooser.get_filename() self.load_file(filename) filechooser.destroy() elif response == Gtk.ResponseType.CANCEL: filechooser.destroy() def check_change(self): """Show dialog to prevent loss of unsaved changes """ if self.did_change and self.text_view.get_text(): dialog = Gtk.MessageDialog(self, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.WARNING, Gtk.ButtonsType.NONE, _("You have not saved your changes.") ) dialog.add_button(_("Close without saving"), Gtk.ResponseType.NO) dialog.add_button(_("Cancel"), Gtk.ResponseType.CANCEL) dialog.add_button(_("Save now"), Gtk.ResponseType.YES) # dialog.set_default_size(200, 60) dialog.set_default_response(Gtk.ResponseType.YES) response = dialog.run() if response == Gtk.ResponseType.YES: if self.save_document() == Gtk.ResponseType.CANCEL: dialog.destroy() return self.check_change() dialog.destroy() return response if response == Gtk.ResponseType.NO: dialog.destroy() return response dialog.destroy() return Gtk.ResponseType.CANCEL def new_document(self, _widget=None): """create new document """ if self.check_change() == Gtk.ResponseType.CANCEL: return self.text_view.clear() self.did_change = False self.set_filename() self.set_headerbar_title(_("New File") + self.title_end) def menu_toggle_sidebar(self, _widget=None): """WIP """ self.sidebar.toggle_sidebar() def toggle_spellcheck(self, state): """Enable/disable the autospellchecking Arguments: status {gtk bool} -- Desired status of the spellchecking """ if state.get_boolean(): try: self.spell_checker.enable() except: try: self.spell_checker = SpellChecker( self.text_view, locale.getdefaultlocale()[0], collapse=False) if self.auto_correct: self.auto_correct.set_language(self.spell_checker.language) self.spell_checker.connect_language_change( # pylint: disable=no-member self.auto_correct.set_language) except: self.spell_checker = None dialog = Gtk.MessageDialog(self, Gtk.DialogFlags.MODAL \ | Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.INFO, Gtk.ButtonsType.NONE, _("You can not enable the Spell Checker.") ) dialog.format_secondary_text( _("Please install 'hunspell' or 'aspell' dictionaries" + " for your language from the software center.")) _response = dialog.run() return return else: try: self.spell_checker.disable() except: pass return def toggle_gradient_overlay(self, state): """Toggle the gradient overlay Arguments: state {gtk bool} -- Desired state of the gradient overlay (enabled/disabled) """ if state.get_boolean(): self.overlay_id = self.scrolled_window.connect_after("draw", self.draw_gradient) elif self.overlay_id: self.scrolled_window.disconnect(self.overlay_id) def toggle_preview(self, state): """Toggle the preview mode Arguments: state {gtk bool} -- Desired state of the preview mode (enabled/disabled) """ if state.get_boolean(): self.show_preview() else: self.show_text_editor() return True def show_text_editor(self): self.scrolled_window.remove(self.scrolled_window.get_child()) self.scrolled_window.add(self.text_view) self.text_view.show() self.preview_webview.destroy() self.preview_webview = None self.queue_draw() def show_preview(self, loaded=False): if loaded: self.scrolled_window.remove(self.scrolled_window.get_child()) self.scrolled_window.add(self.preview_webview) self.preview_webview.show() self.queue_draw() else: args = ['--standalone', '--mathjax', '--css=' + Theme.get_current().web_css_path, '--lua-filter=' + helpers.get_script_path('relative_to_absolute.lua'), '--lua-filter=' + helpers.get_script_path('task-list.lua')] output = helpers.pandoc_convert(self.text_view.get_text(), to="html5", args=args) if self.preview_webview is None: self.preview_webview = WebKit.WebView() self.preview_webview.get_settings().set_allow_universal_access_from_file_urls(True) # Show preview once the load is finished self.preview_webview.connect("load-changed", self.on_preview_load_change) # This saying that all links will be opened in default browser, \ # but local files are opened in appropriate apps: self.preview_webview.connect("decide-policy", self.on_click_link) self.preview_webview.load_html(output, 'file://localhost/') def reload_preview(self): if self.preview_webview: self.show_preview() def load_file(self, filename=None): """Open File from command line or open / open recent etc.""" if self.check_change() == Gtk.ResponseType.CANCEL: return if filename: if filename.startswith('file://'): filename = filename[7:] filename = urllib.parse.unquote_plus(filename) self.text_view.clear() try: if os.path.exists(filename): current_file = codecs.open(filename, encoding="utf-8", mode='r') self.text_view.set_text(current_file.read()) current_file.close() self.set_headerbar_title(os.path.basename(filename) + self.title_end) self.set_filename(filename) except Exception: LOGGER.warning("Error Reading File: %r" % Exception) self.did_change = False else: LOGGER.warning("No File arg") def open_uberwriter_markdown(self, _widget=None, _data=None): """open a markdown mini tutorial """ if self.check_change() == Gtk.ResponseType.CANCEL: return self.load_file(helpers.get_media_file('uberwriter_markdown.md')) def open_search_and_replace(self): """toggle the search box """ self.searchreplace.toggle_search() def open_advanced_export(self, _widget=None, _data=None): """open the export and advanced export dialog """ self.export = Export(self.filename) self.export.dialog.set_transient_for(self) response = self.export.dialog.run() if response == 1: self.export.export(bytes(self.text_view.get_text(), "utf-8")) self.export.dialog.destroy() def open_recent(self, _widget, data=None): """open the given recent document """ print("open") if data: if self.check_change() == Gtk.ResponseType.CANCEL: return self.load_file(data) def poll_for_motion(self): """check if the user has moved the cursor to show the headerbar Returns: True -- Gtk things """ if (self.was_motion is False and self.status_bar_visible and self.buffer_modified_for_status_bar and self.text_view.props.has_focus): # pylint: disable=no-member # self.status_bar.set_state_flags(Gtk.StateFlags.INSENSITIVE, True) self.statusbar_revealer.set_reveal_child(False) self.headerbar.hb_revealer.set_reveal_child(False) self.status_bar_visible = False self.buffer_modified_for_status_bar = False self.was_motion = False return True def on_motion_notify(self, _widget, event, _data=None): """check the motion of the mouse to fade in the headerbar """ now = event.get_time() if now - self.timestamp_last_mouse_motion > 150: # filter out accidental motions self.timestamp_last_mouse_motion = now return if now - self.timestamp_last_mouse_motion < 100: # filter out accidental motion return if now - self.timestamp_last_mouse_motion > 100: # react on motion by fading in headerbar and statusbar if self.status_bar_visible is False: self.statusbar_revealer.set_reveal_child(True) self.headerbar.hb_revealer.set_reveal_child(True) self.headerbar.hb.props.opacity = 1 self.status_bar_visible = True self.buffer_modified_for_status_bar = False self.update_line_and_char_count() # self.status_bar.set_state_flags(Gtk.StateFlags.NORMAL, True) self.was_motion = True def focus_out(self, _widget, _data=None): """events called when the window losses focus """ if self.status_bar_visible is False: self.statusbar_revealer.set_reveal_child(True) self.headerbar.hb_revealer.set_reveal_child(True) self.headerbar.hb.props.opacity = 1 self.status_bar_visible = True self.buffer_modified_for_status_bar = False self.update_line_and_char_count() def draw_gradient(self, _widget, cr): """draw fading gradient over the top and the bottom of the TextWindow """ bg_color = self.get_style_context().get_background_color(Gtk.StateFlags.ACTIVE) lg_top = cairo.LinearGradient(0, 0, 0, 35) # pylint: disable=no-member lg_top.add_color_stop_rgba( 0, bg_color.red, bg_color.green, bg_color.blue, 1) lg_top.add_color_stop_rgba( 1, bg_color.red, bg_color.green, bg_color.blue, 0) width = self.scrolled_window.get_allocation().width height = self.scrolled_window.get_allocation().height cr.rectangle(0, 0, width, 35) cr.set_source(lg_top) cr.fill() cr.rectangle(0, height - 35, width, height) lg_btm = cairo.LinearGradient(0, height - 35, 0, height) # pylint: disable=no-member lg_btm.add_color_stop_rgba( 1, bg_color.red, bg_color.green, bg_color.blue, 1) lg_btm.add_color_stop_rgba( 0, bg_color.red, bg_color.green, bg_color.blue, 0) cr.set_source(lg_btm) cr.fill() def on_delete_called(self, _widget, _data=None): """Called when the TexteditorWindow is closed. """ LOGGER.info('delete called') if self.check_change() == Gtk.ResponseType.CANCEL: return True return False def on_mnu_close_activate(self, _widget, _data=None): """Signal handler for closing the Window. Overriden from parent Window Class """ if self.on_delete_called(self): # Really destroy? return self.destroy() return def on_destroy(self, _widget, _data=None): """Called when the TexteditorWindow is closed. """ # Clean up code for saving application state should be added here. Gtk.main_quit() def set_headerbar_title(self, title): """set the desired headerbar title """ self.headerbar.hb.props.title = title self.fs_headerbar.hb.props.title = title self.set_title(title) def set_filename(self, filename=None): """set filename """ if filename: self.filename = filename base_path = os.path.dirname(self.filename) else: self.filename = None base_path = "/" self.settings.set_value("open-file-path", GLib.Variant("s", base_path)) def on_preview_load_change(self, webview, event): """swaps text editor with preview once the load is complete """ if event == WebKit.LoadEvent.FINISHED: self.show_preview(loaded=True) def on_click_link(self, web_view, decision, _decision_type): """provide ability for self.webview to open links in default browser """ if web_view.get_uri().startswith(("http://", "https://", "www.")): webbrowser.open(web_view.get_uri()) decision.ignore() return True # Don't let the event "bubble up"