forked from Mirrors/apostrophe
1143 lines
42 KiB
Python
1143 lines
42 KiB
Python
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
|
||
# BEGIN LICENSE
|
||
# Copyright (C) 2012, Wolf Vollprecht <w.vollprecht@gmail.com>
|
||
# 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 <http://www.gnu.org/licenses/>.
|
||
# END LICENSE
|
||
|
||
import locale
|
||
import subprocess
|
||
import os
|
||
import codecs
|
||
import webbrowser
|
||
import urllib
|
||
import logging
|
||
|
||
import mimetypes
|
||
import re
|
||
|
||
from gettext import gettext as _
|
||
|
||
import gi
|
||
gi.require_version('WebKit2', '4.0') # pylint: disable=wrong-import-position
|
||
from gi.repository import Gtk, Gdk, GObject, GLib, Gio # pylint: disable=E0611
|
||
from gi.repository import WebKit2 as WebKit
|
||
from gi.repository import Pango # pylint: disable=E0611
|
||
|
||
import cairo
|
||
# import cairo.Pattern, cairo.SolidPattern
|
||
|
||
from . import headerbars
|
||
from uberwriter_lib import helpers
|
||
from uberwriter_lib.helpers import get_builder
|
||
from uberwriter_lib.gtkspellcheck import SpellChecker
|
||
|
||
from .MarkupBuffer import MarkupBuffer
|
||
from .UberwriterTextEditor import TextEditor
|
||
from .UberwriterInlinePreview import UberwriterInlinePreview
|
||
from .UberwriterSidebar import UberwriterSidebar
|
||
from .UberwriterSearchAndReplace import UberwriterSearchAndReplace
|
||
from .Settings import Settings
|
||
# from .UberwriterAutoCorrect import UberwriterAutoCorrect
|
||
|
||
from .UberwriterExportDialog import Export
|
||
# from .plugins.bibtex import BibTex
|
||
# Some Globals
|
||
# TODO move them somewhere for better
|
||
# accesibility from other files
|
||
|
||
LOGGER = logging.getLogger('uberwriter')
|
||
|
||
CONFIG_PATH = os.path.expanduser("~/.config/uberwriter/")
|
||
|
||
# See texteditor_lib.Window.py for more details about how this class works
|
||
|
||
class UberwriterWindow(Gtk.ApplicationWindow):
|
||
|
||
#__gtype_name__ = "UberwriterWindow"
|
||
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")
|
||
|
||
self.builder = get_builder('UberwriterWindow')
|
||
self.add(self.builder.get_object("FullscreenOverlay"))
|
||
|
||
self.set_default_size(850, 500)
|
||
|
||
# preferences
|
||
self.settings = Settings.new()
|
||
|
||
self.set_name('UberwriterWindow')
|
||
|
||
# Headerbars
|
||
self.headerbar = headerbars.MainHeaderbar(app)
|
||
self.set_titlebar(self.headerbar.hb_container)
|
||
self.fs_headerbar = headerbars.FsHeaderbar(self.builder, app)
|
||
|
||
self.title_end = " – UberWriter"
|
||
self.set_headerbar_title("New File" + self.title_end)
|
||
|
||
self.focusmode = False
|
||
|
||
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.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 light background
|
||
self.text_editor = TextEditor()
|
||
self.text_editor.set_name('UberwriterEditor')
|
||
self.get_style_context().add_class('uberwriter_window')
|
||
|
||
base_leftmargin = 100
|
||
self.text_editor.set_left_margin(base_leftmargin)
|
||
self.text_editor.set_left_margin(40)
|
||
self.text_editor.set_top_margin(80)
|
||
self.text_editor.props.width_request = 600
|
||
self.text_editor.props.halign = Gtk.Align.CENTER
|
||
self.text_editor.set_vadjustment(self.builder.get_object('vadjustment1'))
|
||
self.text_editor.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
|
||
self.text_editor.connect('focus-out-event', self.focus_out)
|
||
self.text_editor.get_style_context().connect('changed', self.style_changed)
|
||
|
||
self.text_editor.set_top_margin(80)
|
||
self.text_editor.set_bottom_margin(16)
|
||
|
||
self.text_editor.set_pixels_above_lines(4)
|
||
self.text_editor.set_pixels_below_lines(4)
|
||
self.text_editor.set_pixels_inside_wrap(8)
|
||
|
||
tab_array = Pango.TabArray.new(1, True)
|
||
tab_array.set_tab(0, Pango.TabAlign.LEFT, 20)
|
||
self.text_editor.set_tabs(tab_array)
|
||
|
||
self.text_editor.show()
|
||
self.text_editor.grab_focus()
|
||
|
||
self.editor_alignment = self.builder.get_object('editor_alignment')
|
||
self.scrolled_window = self.builder.get_object('editor_scrolledwindow')
|
||
self.scrolled_window.props.width_request = 600
|
||
self.scrolled_window.add(self.text_editor)
|
||
self.alignment_padding = 40
|
||
self.editor_viewport = self.builder.get_object('editor_viewport')
|
||
self.scrolled_window.connect_after("draw", self.draw_gradient)
|
||
|
||
self.smooth_scroll_starttime = 0
|
||
self.smooth_scroll_endtime = 0
|
||
self.smooth_scroll_acttarget = 0
|
||
self.smooth_scroll_data = {
|
||
'target_pos': -1,
|
||
'source_pos': -1,
|
||
'duration': 0
|
||
}
|
||
self.smooth_scroll_tickid = -1
|
||
|
||
self.text_buffer = self.text_editor.get_buffer()
|
||
self.text_buffer.set_text('')
|
||
|
||
# Init Window height for top/bottom padding
|
||
self.window_height = self.get_size()[1]
|
||
|
||
self.text_change_event = self.text_buffer.connect(
|
||
'changed', self.text_changed)
|
||
|
||
# Init file name with None
|
||
self.set_filename()
|
||
|
||
self.style_provider = Gtk.CssProvider()
|
||
self.style_provider.load_from_path(helpers.get_media_path('style.css'))
|
||
|
||
Gtk.StyleContext.add_provider_for_screen(
|
||
Gdk.Screen.get_default(), self.style_provider,
|
||
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
|
||
)
|
||
|
||
# Markup and Shortcuts for the TextBuffer
|
||
self.markup_buffer = MarkupBuffer(
|
||
self, self.text_buffer, base_leftmargin)
|
||
self.markup_buffer.markup_buffer()
|
||
|
||
# Setup dark mode if so
|
||
self.toggle_dark_mode(self.settings.get_value("dark-mode"))
|
||
|
||
# Scrolling -> Dark or not?
|
||
self.textchange = False
|
||
self.scroll_count = 0
|
||
self.timestamp_last_mouse_motion = 0
|
||
self.text_buffer.connect_after('mark-set', self.mark_set)
|
||
|
||
# Drag and drop
|
||
|
||
# self.TextEditor.drag_dest_unset()
|
||
# self.TextEditor.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY)
|
||
self.target_list = Gtk.TargetList.new([])
|
||
self.target_list.add_uri_targets(1)
|
||
self.target_list.add_text_targets(2)
|
||
|
||
self.text_editor.drag_dest_set_target_list(self.target_list)
|
||
self.text_editor.connect_after(
|
||
'drag-data-received', self.on_drag_data_received)
|
||
|
||
def on_drop(_widget, *_args):
|
||
print("drop")
|
||
self.text_editor.connect('drag-drop', on_drop)
|
||
|
||
self.text_buffer.connect('paste-done', self.paste_done)
|
||
# self.connect('key-press-event', self.alt_mod)
|
||
|
||
# Events for Typewriter mode
|
||
|
||
# Setting up inline preview
|
||
self.inline_preview = UberwriterInlinePreview(
|
||
self.text_editor, self.text_buffer)
|
||
|
||
# Vertical scrolling
|
||
self.vadjustment = self.scrolled_window.get_vadjustment()
|
||
self.vadjustment.connect('value-changed', self.scrolled)
|
||
|
||
# Setting up spellcheck
|
||
self.auto_correct = None
|
||
try:
|
||
self.spell_checker = SpellChecker(
|
||
self.text_editor, 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)
|
||
|
||
self.spellcheck = True
|
||
except:
|
||
self.spell_checker = None
|
||
self.spellcheck = False
|
||
|
||
if self.spellcheck:
|
||
self.spell_checker.append_filter('[#*]+', SpellChecker.FILTER_WORD)
|
||
|
||
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 = UberwriterSidebar(self)
|
||
self.sidebar_box.hide()
|
||
|
||
###
|
||
# Search and replace initialization
|
||
# Same interface as Sidebar ;)
|
||
###
|
||
self.searchreplace = UberwriterSearchAndReplace(self)
|
||
|
||
# Window resize
|
||
self.window_resize(self)
|
||
self.connect("configure-event", self.window_resize)
|
||
self.connect("delete-event", self.on_delete_called)
|
||
|
||
__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, ())
|
||
}
|
||
|
||
def scrolled(self, widget):
|
||
"""if window scrolled + focusmode make font black again"""
|
||
# if self.focusmode:
|
||
# if self.textchange == False:
|
||
# if self.scroll_count >= 4:
|
||
# self.TextBuffer.apply_tag(
|
||
# self.MarkupBuffer.blackfont,
|
||
# self.TextBuffer.get_start_iter(),
|
||
# self.TextBuffer.get_end_iter())
|
||
# else:
|
||
# self.scroll_count += 1
|
||
# else:
|
||
# self.scroll_count = 0
|
||
# self.textchange = False
|
||
|
||
def paste_done(self, *_):
|
||
self.markup_buffer.markup_buffer(0)
|
||
|
||
def init_typewriter(self):
|
||
"""put the cursor at the center of the screen by setting top and
|
||
bottom margins to height/2
|
||
"""
|
||
|
||
editor_height = self.text_editor.get_allocation().height
|
||
self.text_editor.props.top_margin = editor_height / 2
|
||
self.text_editor.props.bottom_margin = editor_height / 2
|
||
|
||
def remove_typewriter(self):
|
||
"""set margins to default values
|
||
"""
|
||
|
||
self.text_editor.props.top_margin = 80
|
||
self.text_editor.props.bottom_margin = 16
|
||
self.text_change_event = self.text_buffer.connect(
|
||
'changed', self.text_changed)
|
||
|
||
def get_text(self):
|
||
"""get text from self.text_buffer
|
||
"""
|
||
|
||
start_iter = self.text_buffer.get_start_iter()
|
||
end_iter = self.text_buffer.get_end_iter()
|
||
return self.text_buffer.get_text(start_iter, end_iter, False)
|
||
|
||
def update_line_and_char_count(self):
|
||
"""it... it updates line and characters count
|
||
"""
|
||
|
||
if self.status_bar_visible is False:
|
||
return
|
||
self.char_count.set_text(str(self.text_buffer.get_char_count()))
|
||
text = self.get_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 mark_set(self, _buffer, _location, mark, _data=None):
|
||
if mark.get_name() in ['insert', 'gtk_drag_target']:
|
||
self.check_scroll(mark)
|
||
return True
|
||
|
||
def 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.markup_buffer.markup_buffer(1)
|
||
self.textchange = True
|
||
|
||
self.buffer_modified_for_status_bar = True
|
||
self.update_line_and_char_count()
|
||
self.check_scroll(self.text_buffer.get_insert())
|
||
|
||
def toggle_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_editor.grab_focus()
|
||
|
||
def set_focusmode(self, state):
|
||
"""toggle focusmode
|
||
"""
|
||
|
||
if state.get_boolean():
|
||
self.init_typewriter()
|
||
self.markup_buffer.focusmode_highlight()
|
||
self.focusmode = True
|
||
self.text_editor.grab_focus()
|
||
self.check_scroll(self.text_buffer.get_insert())
|
||
if self.spellcheck:
|
||
self.spell_checker._misspelled.set_property('underline', 0)
|
||
self.click_event = self.text_editor.connect("button-release-event",
|
||
self.on_focusmode_click)
|
||
else:
|
||
self.remove_typewriter()
|
||
self.focusmode = False
|
||
self.text_buffer.remove_tag(self.markup_buffer.grayfont,
|
||
self.text_buffer.get_start_iter(),
|
||
self.text_buffer.get_end_iter())
|
||
self.text_buffer.remove_tag(self.markup_buffer.blackfont,
|
||
self.text_buffer.get_start_iter(),
|
||
self.text_buffer.get_end_iter())
|
||
|
||
self.markup_buffer.markup_buffer(1)
|
||
self.text_editor.grab_focus()
|
||
self.update_line_and_char_count()
|
||
self.check_scroll()
|
||
if self.spellcheck:
|
||
self.spell_checker._misspelled.set_property('underline', 4)
|
||
_click_event = self.text_editor.disconnect(self.click_event)
|
||
|
||
def on_focusmode_click(self, *_args):
|
||
"""call MarkupBuffer to mark as bold the line where the cursor is
|
||
"""
|
||
|
||
self.markup_buffer.markup_buffer(1)
|
||
|
||
def scroll_smoothly(self, widget, frame_clock, _data=None):
|
||
if self.smooth_scroll_data['target_pos'] == -1:
|
||
return True
|
||
|
||
def ease_out_cubic(time):
|
||
time = time - 1
|
||
return pow(time, 3) + 1
|
||
|
||
now = frame_clock.get_frame_time()
|
||
if self.smooth_scroll_acttarget != self.smooth_scroll_data['target_pos']:
|
||
self.smooth_scroll_starttime = now
|
||
self.smooth_scroll_endtime = now + \
|
||
self.smooth_scroll_data['duration'] * 100
|
||
self.smooth_scroll_acttarget = self.smooth_scroll_data['target_pos']
|
||
|
||
if now < self.smooth_scroll_endtime:
|
||
time = float(now - self.smooth_scroll_starttime) / float(
|
||
self.smooth_scroll_endtime - self.smooth_scroll_starttime)
|
||
else:
|
||
time = 1
|
||
pos = self.smooth_scroll_data['source_pos'] \
|
||
+ (time * (self.smooth_scroll_data['target_pos']
|
||
- self.smooth_scroll_data['source_pos']))
|
||
widget.get_vadjustment().props.value = pos
|
||
self.smooth_scroll_data['target_pos'] = -1
|
||
return True
|
||
|
||
time = ease_out_cubic(time)
|
||
pos = self.smooth_scroll_data['source_pos'] \
|
||
+ (time * (self.smooth_scroll_data['target_pos']
|
||
- self.smooth_scroll_data['source_pos']))
|
||
widget.get_vadjustment().props.value = pos
|
||
return True # continue ticking
|
||
|
||
def check_scroll(self, mark=None):
|
||
gradient_offset = 80
|
||
buf = self.text_editor.get_buffer()
|
||
if mark:
|
||
ins_it = buf.get_iter_at_mark(mark)
|
||
else:
|
||
ins_it = buf.get_iter_at_mark(buf.get_insert())
|
||
loc_rect = self.text_editor.get_iter_location(ins_it)
|
||
|
||
# alignment offset added from top
|
||
pos_y = loc_rect.y + loc_rect.height + self.text_editor.props.top_margin # pylint: disable=no-member
|
||
|
||
ha = self.scrolled_window.get_vadjustment()
|
||
if ha.props.page_size < gradient_offset:
|
||
return
|
||
pos = pos_y - ha.props.value
|
||
# print("pos: %i, pos_y %i, page_sz: %i, val: %i" % (pos, pos_y, ha.props.page_size
|
||
# - gradient_offset, ha.props.value))
|
||
# global t, amount, initvadjustment
|
||
target_pos = -1
|
||
if self.focusmode:
|
||
# print("pos: %i > %i" % (pos, ha.props.page_size * 0.5))
|
||
if pos != (ha.props.page_size * 0.5):
|
||
target_pos = pos_y - (ha.props.page_size * 0.5)
|
||
elif pos > ha.props.page_size - gradient_offset - 60:
|
||
target_pos = pos_y - ha.props.page_size + gradient_offset + 40
|
||
elif pos < gradient_offset:
|
||
target_pos = pos_y - gradient_offset
|
||
self.smooth_scroll_data = {
|
||
'target_pos': target_pos,
|
||
'source_pos': ha.props.value,
|
||
'duration': 2000
|
||
}
|
||
if self.smooth_scroll_tickid == -1:
|
||
self.smooth_scroll_tickid = self.scrolled_window.add_tick_callback(
|
||
self.scroll_smoothly)
|
||
|
||
def window_resize(self, widget, _data=None):
|
||
"""set paddings dependant of the window size
|
||
"""
|
||
|
||
# To calc padding top / bottom
|
||
self.window_height = widget.get_allocation().height
|
||
w_width = widget.get_allocation().width
|
||
# Calculate left / right margin
|
||
width_request = 600
|
||
if w_width < 900:
|
||
self.markup_buffer.set_multiplier(8)
|
||
self.current_font_size = 12
|
||
self.alignment_padding = 30
|
||
lm = 7 * 8
|
||
self.get_style_context().remove_class("medium")
|
||
self.get_style_context().remove_class("large")
|
||
self.get_style_context().add_class("small")
|
||
|
||
elif w_width < 1400:
|
||
self.markup_buffer.set_multiplier(10)
|
||
width_request = 800
|
||
self.current_font_size = 15
|
||
self.alignment_padding = 40
|
||
lm = 7 * 10
|
||
self.get_style_context().remove_class("small")
|
||
self.get_style_context().remove_class("large")
|
||
self.get_style_context().add_class("medium")
|
||
|
||
else:
|
||
self.markup_buffer.set_multiplier(13)
|
||
self.current_font_size = 17
|
||
width_request = 1000
|
||
self.alignment_padding = 60
|
||
lm = 7 * 13
|
||
self.get_style_context().remove_class("medium")
|
||
self.get_style_context().remove_class("small")
|
||
self.get_style_context().add_class("large")
|
||
|
||
self.editor_alignment.props.margin_bottom = 0
|
||
self.editor_alignment.props.margin_top = 0
|
||
self.text_editor.set_left_margin(lm)
|
||
self.text_editor.set_right_margin(lm)
|
||
|
||
self.markup_buffer.recalculate(lm)
|
||
|
||
if self.focusmode:
|
||
self.remove_typewriter()
|
||
self.init_typewriter()
|
||
|
||
if self.text_editor.props.width_request != width_request: # pylint: disable=no-member
|
||
self.text_editor.props.width_request = width_request
|
||
self.scrolled_window.props.width_request = width_request
|
||
alloc = self.text_editor.get_allocation()
|
||
alloc.width = width_request
|
||
self.text_editor.size_allocate(alloc)
|
||
|
||
def style_changed(self, _widget, _data=None):
|
||
pgc = self.text_editor.get_pango_context()
|
||
mets = pgc.get_metrics()
|
||
self.markup_buffer.set_multiplier(
|
||
Pango.units_to_double(mets.get_approximate_char_width()) + 1)
|
||
|
||
# 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.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.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.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
|
||
"""
|
||
|
||
args = ['pandoc', '--from=markdown', '--to=html5']
|
||
proc = subprocess.Popen(args, stdin=subprocess.PIPE,
|
||
stdout=subprocess.PIPE)
|
||
|
||
text = bytes(self.get_text(), "utf-8")
|
||
output = proc.communicate(text)[0]
|
||
|
||
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
|
||
clipboard.set_text(output.decode("utf-8"), -1)
|
||
clipboard.store()
|
||
|
||
def open_document(self, _widget=None):
|
||
"""open the desired file
|
||
"""
|
||
|
||
if self.check_change() == Gtk.ResponseType.CANCEL:
|
||
return
|
||
|
||
filefilter = Gtk.FileFilter.new()
|
||
filefilter.add_mime_type('text/x-markdown')
|
||
filefilter.add_mime_type('text/plain')
|
||
filefilter.set_name(_('MarkDown or Plain Text'))
|
||
|
||
filechooser = Gtk.FileChooserDialog(
|
||
_("Open a .md-File"),
|
||
self,
|
||
Gtk.FileChooserAction.OPEN,
|
||
("_Cancel", Gtk.ResponseType.CANCEL,
|
||
"_Open", Gtk.ResponseType.OK)
|
||
)
|
||
filechooser.add_filter(filefilter)
|
||
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.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_title(_('Unsaved changes'))
|
||
dialog.set_default_size(200, 150)
|
||
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_buffer.set_text('')
|
||
self.text_editor.undos = []
|
||
self.text_editor.redos = []
|
||
|
||
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, status):
|
||
"""Enable/disable the autospellchecking
|
||
|
||
Arguments:
|
||
status {gtk bool} -- Desired status of the spellchecking
|
||
"""
|
||
|
||
if self.spellcheck:
|
||
if status.get_boolean():
|
||
self.spell_checker.enable()
|
||
else:
|
||
self.spell_checker.disable()
|
||
|
||
elif status.get_boolean():
|
||
self.spell_checker = SpellChecker(
|
||
self.text_editor, self, 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)
|
||
try:
|
||
self.spellcheck = True
|
||
except:
|
||
self.spell_checker = None
|
||
self.spellcheck = False
|
||
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' dictionarys"
|
||
+ " for your language from the software center."))
|
||
_response = dialog.run()
|
||
return
|
||
return
|
||
|
||
def on_drag_data_received(self, _widget, drag_context, _x, _y,
|
||
data, info, time):
|
||
"""Handle drag and drop events"""
|
||
if info == 1:
|
||
# uri target
|
||
uris = data.get_uris()
|
||
for uri in uris:
|
||
uri = urllib.parse.unquote_plus(uri)
|
||
mime = mimetypes.guess_type(uri)
|
||
|
||
if mime[0] is not None and mime[0].startswith('image'):
|
||
if uri.startswith("file://"):
|
||
uri = uri[7:]
|
||
text = "" % uri
|
||
limit_left = 2
|
||
limit_right = 23
|
||
else:
|
||
text = "[Insert link title here](%s)" % uri
|
||
limit_left = 1
|
||
limit_right = 22
|
||
self.text_buffer.place_cursor(self.text_buffer.get_iter_at_mark(
|
||
self.text_buffer.get_mark('gtk_drag_target')))
|
||
self.text_buffer.insert_at_cursor(text)
|
||
insert_mark = self.text_buffer.get_insert()
|
||
selection_bound = self.text_buffer.get_selection_bound()
|
||
cursor_iter = self.text_buffer.get_iter_at_mark(insert_mark)
|
||
cursor_iter.backward_chars(len(text) - limit_left)
|
||
self.text_buffer.move_mark(insert_mark, cursor_iter)
|
||
cursor_iter.forward_chars(limit_right)
|
||
self.text_buffer.move_mark(selection_bound, cursor_iter)
|
||
|
||
elif info == 2:
|
||
# Text target
|
||
self.text_buffer.place_cursor(self.text_buffer.get_iter_at_mark(
|
||
self.text_buffer.get_mark('gtk_drag_target')))
|
||
self.text_buffer.insert_at_cursor(data.get_text())
|
||
Gtk.drag_finish(drag_context, True, True, time)
|
||
self.present()
|
||
return False
|
||
|
||
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():
|
||
|
||
# Insert a tag with ID to scroll to
|
||
# self.TextBuffer.insert_at_cursor('<span id="scroll_mark"></span>')
|
||
# TODO
|
||
# Find a way to find the next header, scroll to the next header.
|
||
# TODO: provide a local version of mathjax
|
||
|
||
# We need to convert relative routes to absolute ones
|
||
# For that first we need to know if the file is saved:
|
||
if self.filename:
|
||
base_path = os.path.dirname(self.filename)
|
||
else:
|
||
base_path = ''
|
||
os.environ['PANDOC_PREFIX'] = base_path + '/'
|
||
|
||
# Set the styles according the color theme
|
||
if self.settings.get_value("dark-mode"):
|
||
stylesheet = helpers.get_media_path('uberwriter_dark.css')
|
||
else:
|
||
stylesheet = helpers.get_media_path('uberwriter.css')
|
||
|
||
args = ['pandoc',
|
||
'-s',
|
||
'--from=markdown',
|
||
'--to=html5',
|
||
'--mathjax',
|
||
'--css=' + stylesheet,
|
||
'--lua-filter=' +
|
||
helpers.get_script_path('relative_to_absolute.lua'),
|
||
'--lua-filter=' + helpers.get_script_path('task-list.lua')]
|
||
|
||
proc = subprocess.Popen(
|
||
args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
|
||
|
||
text = bytes(self.get_text(), "utf-8")
|
||
output = proc.communicate(text)[0]
|
||
|
||
# Load in Webview and scroll to #ID
|
||
self.preview_webview = WebKit.WebView()
|
||
webview_settings = self.preview_webview.get_settings()
|
||
webview_settings.set_allow_universal_access_from_file_urls(
|
||
True)
|
||
self.preview_webview.load_html(output.decode("utf-8"), 'file://localhost/')
|
||
|
||
# Delete the cursor-scroll mark again
|
||
# cursor_iter = self.TextBuffer.get_iter_at_mark(self.TextBuffer.get_insert())
|
||
# begin_del = cursor_iter.copy()
|
||
# begin_del.backward_chars(30)
|
||
# self.TextBuffer.delete(begin_del, cursor_iter)
|
||
|
||
self.scrolled_window.remove(self.text_editor)
|
||
self.scrolled_window.add(self.preview_webview)
|
||
self.preview_webview.show()
|
||
|
||
# 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)
|
||
else:
|
||
self.scrolled_window.remove(self.preview_webview)
|
||
self.preview_webview.destroy()
|
||
self.scrolled_window.add(self.text_editor)
|
||
self.text_editor.show()
|
||
|
||
self.queue_draw()
|
||
return True
|
||
|
||
def toggle_dark_mode(self, state):
|
||
"""Toggle the dark mode, both for the window and for the CSD
|
||
|
||
Arguments:
|
||
state {gtk bool} -- Desired state of the dark mode (enabled/disabled)
|
||
"""
|
||
|
||
# Save state for saving settings later
|
||
|
||
if state:
|
||
# Dark Mode is on
|
||
self.get_style_context().add_class("dark_mode")
|
||
self.headerbar.hb_container.get_style_context().add_class("dark_mode")
|
||
self.markup_buffer.dark_mode(True)
|
||
else:
|
||
# Dark mode off
|
||
self.get_style_context().remove_class("dark_mode")
|
||
self.headerbar.hb_container.get_style_context().remove_class("dark_mode")
|
||
self.markup_buffer.dark_mode(False)
|
||
|
||
# Redraw contents of window (self)
|
||
self.queue_draw()
|
||
|
||
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)
|
||
try:
|
||
if not os.path.exists(filename):
|
||
self.text_buffer.set_text("")
|
||
else:
|
||
current_file = codecs.open(filename, encoding="utf-8", mode='r')
|
||
self.text_buffer.set_text(current_file.read())
|
||
current_file.close()
|
||
self.markup_buffer.markup_buffer(0)
|
||
|
||
self.set_headerbar_title(
|
||
os.path.basename(filename) + self.title_end)
|
||
self.text_editor.undo_stack = []
|
||
self.text_editor.redo_stack = []
|
||
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.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_editor.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 use_experimental_features(self, _val):
|
||
"""use experimental features
|
||
"""
|
||
pass
|
||
# try:
|
||
# self.auto_correct = UberwriterAutoCorrect(
|
||
# self.text_editor, self.text_buffer)
|
||
# except:
|
||
# LOGGER.debug("Couldn't install autocorrect.")
|
||
|
||
# self.plugins = [BibTex(self)]
|
||
|
||
# def alt_mod(self, _widget, event, _data=None):
|
||
# # TODO: Click and open when alt is pressed
|
||
# if event.state & Gdk.ModifierType.MOD2_MASK:
|
||
# LOGGER.info("Alt pressed")
|
||
# return
|
||
|
||
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 UberwriterWindow.
|
||
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_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"
|