def init(self):
self.update_switchers()
self.view.style_switcher.set_active_id(
self.settings.get_value('preferences', 'syntax_scheme'))
self.view.style_switcher.connect('changed',
self.on_style_switcher_changed, False)
self.view.style_switcher_dark_mode.set_active_id(
self.settings.get_value('preferences', 'syntax_scheme_dark_mode'))
self.view.style_switcher_dark_mode.connect(
'changed', self.on_style_switcher_changed, True)
dark_mode_state = self.settings.get_value('preferences',
'prefer_dark_mode')
self.view.option_dark_mode.set_active(dark_mode_state)
self.view.option_dark_mode.connect('toggled',
self.on_dark_mode_toggle_toggled)
self.view.style_switcher_stack.set_visible_child_name(
'dark' if dark_mode_state else 'light')
self.update_font_color_preview()
self.update_remove_button()
ip_state = self.settings.get_value('preferences', 'invert_pdf')
self.view.option_invert_preview.set_active(ip_state)
self.view.option_invert_preview.connect('toggled',
self.on_ip_toggle_toggled)
source_language_manager = ServiceLocator.get_source_language_manager()
source_language = source_language_manager.get_language('latex')
self.view.source_buffer.set_language(source_language)
self.update_font_color_preview()
self.view.add_scheme_button.connect('clicked',
self.on_add_scheme_button_clicked)
self.view.remove_scheme_button.connect(
'clicked', self.on_remove_scheme_button_clicked)
self.view.font_chooser_button.set_font(
self.settings.get_value('preferences', 'font_string'))
self.view.font_chooser_button.connect('font-set', self.on_font_set)
self.view.option_use_system_font.set_active(
self.settings.get_value('preferences', 'use_system_font'))
self.view.font_chooser_revealer.set_reveal_child(
not self.view.option_use_system_font.get_active())
self.view.option_use_system_font.connect(
'toggled', self.on_use_system_font_toggled)
def __init__(self, workspace):
self.workspace = workspace
self.main_window = ServiceLocator.get_main_window()
self.main_window.latex_shortcutsbar.button_build_log.set_active(
self.workspace.get_show_build_log())
self.main_window.latex_shortcutsbar.button_build_log.connect(
'clicked', self.on_build_log_button_clicked)
self.main_window.latex_shortcutsbar.button_build_log.get_child(
).set_sensitive(False)
self.workspace.connect('document_removed', self.on_document_removed)
self.workspace.connect('new_active_document',
self.on_new_active_document)
self.workspace.connect('new_inactive_document',
self.on_new_inactive_document)
self.workspace.connect('show_build_log_state_change',
self.on_show_build_log_state_change)
def insert_begin_end_replace(self, start_iter_begin, insert_iter,
replace_previous_command_data):
text = replace_previous_command_data[1]
match_object = replace_previous_command_data[0]
self.document.get_buffer().begin_user_action()
end_iter_begin = insert_iter.copy()
end_iter_begin.forward_chars(match_object.end())
start_iter_offset = start_iter_begin.get_offset()
self.document.get_buffer().replace_range_no_user_action(
start_iter_begin,
end_iter_begin,
text,
indent_lines=False,
select_dot=True)
end_iter_offset = start_iter_offset + len(text)
document_text = self.document.get_text_after_offset(end_iter_offset)
environment_name = ServiceLocator.get_regex_object(
r'(\w*(?:\*){0,1})\{([^\{\[\|\(]+)\}').match(
match_object.group(0)).group(2)
end_match_object = self.get_end_match_object(document_text,
environment_name)
if end_match_object != None:
start_iter_begin = self.document.get_buffer().get_iter_at_offset(
end_iter_offset)
start_iter_end = start_iter_begin.copy()
start_iter_end.forward_chars(end_match_object.start())
end_iter_end = start_iter_begin.copy()
end_iter_end.forward_chars(end_match_object.end())
end_command = text.replace('\\begin', '\\end')
end_command_bracket_position = end_command.find('}')
if end_command_bracket_position:
end_command = end_command[:end_command_bracket_position + 1]
self.document.get_buffer().replace_range_no_user_action(
start_iter_end,
end_iter_end,
end_command,
indent_lines=False,
select_dot=False)
self.document.get_buffer().end_user_action()
def __init__(self, workspace):
self.workspace = workspace
self.main_window = ServiceLocator.get_main_window()
self.main_window.headerbar.document_structure_toggle.connect(
'toggled', self.on_document_structure_toggle_toggled)
self.main_window.headerbar.symbols_toggle.connect(
'toggled', self.on_symbols_toggle_toggled)
self.main_window.headerbar.preview_toggle.connect(
'toggled', self.on_preview_toggle_toggled)
self.main_window.headerbar.help_toggle.connect(
'toggled', self.on_help_toggle_toggled)
# populate workspace
self.workspace.populate_from_disk()
open_documents = self.workspace.open_documents
if len(open_documents) > 0:
self.workspace.set_active_document(open_documents[-1])
def get_screen_offsets_by_iter(self, text_iter):
font_manager = ServiceLocator.get_font_manager()
line_height = font_manager.get_line_height()
iter_location = self.source_view.get_iter_location(text_iter)
gutter = self.source_view.get_window(Gtk.TextWindowType.LEFT)
if gutter != None:
gutter_width = gutter.get_width()
else:
gutter_width = 0
x_offset = -self.document.view.scrolled_window.get_hadjustment(
).get_value()
y_offset = -self.document.view.scrolled_window.get_vadjustment(
).get_value()
x_position = x_offset + iter_location.x - 2 + gutter_width
y_position = y_offset + iter_location.y + line_height
return x_position, y_position
def __init__(self, model, view):
self.model = model
self.view = view
self.source_buffer = self.model.document.source_buffer
self.source_gutter = self.model.document.view.source_view.get_gutter(
Gtk.TextWindowType.LEFT)
self.tag = self.source_buffer.create_tag('invisible_region',
invisible=1)
self.lines_skip_query_data = dict()
self.source_gutter.insert(self.view, 3)
self.view.connect('query-data', self.query_data)
self.model.register_observer(self)
font_manager = ServiceLocator.get_font_manager()
font_manager.register_observer(self)
line_height = font_manager.get_line_height(self.source_buffer.view)
self.view.set_size(line_height)
def __init__(self, preview, layouter, page_renderer, view):
self.preview = preview
self.layouter = layouter
self.page_renderer = page_renderer
self.view = view
self.highlight_duration = 1.5
self.color_manager = ServiceLocator.get_color_manager()
self.view.drawing_area.connect('draw', self.draw)
self.scrolling_queue = queue.Queue()
self.view.drawing_area.connect('size-allocate', self.scrolling_loop)
GObject.timeout_add(50, self.scrolling_loop)
self.preview.register_observer(self)
self.layouter.register_observer(self)
self.page_renderer.register_observer(self)
self.show_blank_slate()
def __init__(self, workspace):
self.workspace = workspace
self.main_window = ServiceLocator.get_main_window()
self.observe_workspace_view()
self.untitled_documents_no = 0
self.p_allocation = 0
self.pp_allocation = 0
self.s_allocation = 0
self.bl_allocation = 0
# populate workspace
self.workspace.populate_from_disk()
open_documents = self.workspace.open_documents
if len(open_documents) > 0:
self.workspace.set_active_document(open_documents[-1])
def get_synctex_word_bounds(self, text, word, context):
if not word: return None
word = word.split(' ')
if len(word) > 2:
word = word[:2]
word = ' '.join(word)
regex_pattern = re.escape(word)
for c in regex_pattern:
if ord(c) > 127:
regex_pattern = regex_pattern.replace(c, '(?:\w)')
matches = list()
top_score = 0.1
regex = ServiceLocator.get_regex_object(
r'(\W{0,1})' +
regex_pattern.replace('\x1b', r'(?:\w{2,3})').replace(
'\x1c', r'(?:\w{2})').replace('\x1d', r'(?:\w{2,3})').replace(
'\-', r'(?:-{0,1})') + r'(\W{0,1})')
for match in regex.finditer(text):
offset1 = context.find(word)
offset2 = len(context) - offset1 - len(word)
match_text = text[max(match.start() - max(offset1, 0), 0
):min(match.end() +
max(offset2, 0), len(text))]
score = difflib.SequenceMatcher(None, match_text, context).ratio()
if bool(match.group(1)) or bool(match.group(2)):
if score > top_score + 0.1:
top_score = score
matches = [[
match.start() + len(match.group(1)),
match.end() - len(match.group(2))
]]
elif score > top_score - 0.1:
matches.append([
match.start() + len(match.group(1)),
match.end() - len(match.group(2))
])
if len(matches) > 0:
return matches
else:
return None
def __init__(self, document, document_view):
self.source_view = document_view.source_view
self.line_height = 0
self.char_width = 0
self.font_desc = None
self.font_size = None
self.font_changed = True
self.glyph_index = None
self.extents = None
self.size = 0
self.visible = False
self.update_size()
document.gutter.add_widget(self)
settings = ServiceLocator.get_settings()
self.set_visibility(settings.get_value('preferences', 'show_line_numbers'))
settings.connect('settings_changed', self.on_settings_changed)
def remove_or_color_synctex_tags(self):
for tag_count in list(self.synctex_highlight_tags):
item = self.synctex_highlight_tags[tag_count]
time_factor = time.time() - item['time']
if time_factor > 1.5:
if time_factor <= 1.75:
opacity_factor = int(
self.ease(1 - (time_factor - 1.5) * 4) * 20)
color_manager = ServiceLocator.get_color_manager()
item['tag'].set_property(
'background-rgba',
color_manager.get_rgba(0.976, 0.941, 0.420,
opacity_factor * 0.03))
else:
start = self.source_buffer.get_start_iter()
end = self.source_buffer.get_end_iter()
self.source_buffer.remove_tag(item['tag'], start, end)
self.source_buffer.get_tag_table().remove(item['tag'])
del (self.synctex_highlight_tags[tag_count])
return bool(self.synctex_highlight_tags)
def __init__(self, main_window, workspace):
self.main_window = main_window
self.workspace = workspace
self.settings = ServiceLocator.get_settings()
self.current_values = dict()
self.page_formats = {'US Letter': 'letterpaper', 'US Legal': 'legalpaper', 'A4': 'a4paper', 'A5': 'a5paper', 'B5': 'b5paper'}
self.view = view.DocumentWizardView(self.main_window)
self.pages = list()
self.pages.append(DocumentClassPage(self.current_values))
self.pages.append(ArticleSettingsPage(self.current_values))
self.pages.append(ReportSettingsPage(self.current_values))
self.pages.append(BookSettingsPage(self.current_values))
self.pages.append(LetterSettingsPage(self.current_values))
self.pages.append(BeamerSettingsPage(self.current_values))
self.pages.append(GeneralSettingsPage(self.current_values))
for page in self.pages: self.view.notebook.append_page(page.view)
self.is_not_setup = True
def __init__(self, document):
Observable.__init__(self)
self.document = document
self.settings = ServiceLocator.get_settings()
self.items = list()
self.view = build_widget_view.BuildWidgetView()
self.view.stop_button.connect('clicked',
self.on_stop_build_button_click)
self.view.clean_button.connect('clicked', self.on_clean_button_click)
self.view.build_button.show_all()
self.view.stop_button.hide()
self.build_button_state = ('idle', int(time.time() * 1000))
self.set_clean_button_state()
self.document.register_observer(self)
self.settings.register_observer(self)
def __init__(self, workspace):
self.workspace = workspace
self.main_window = ServiceLocator.get_main_window()
self.workspace.connect('new_document', self.on_new_document)
self.workspace.connect('document_removed', self.on_document_removed)
self.workspace.connect('new_active_document',
self.on_new_active_document)
self.workspace.connect('new_inactive_document',
self.on_new_inactive_document)
self.workspace.connect('set_show_symbols_or_document_structure',
self.on_set_show_symbols_or_document_structure)
self.workspace.connect('set_show_preview_or_help',
self.on_set_show_preview_or_help)
self.workspace.connect('show_build_log_state_change',
self.on_show_build_log_state_change)
self.workspace.connect('set_dark_mode', self.on_set_dark_mode)
self.activate_welcome_screen_mode()
self.setup_paneds()
def parse_symbols(self, text):
with self.parse_jobs_lock:
self.parse_symbols_job_running = True
labels = set()
included_latex_files = set()
bibliographies = set()
bibitems = set()
packages = set()
packages_detailed = dict()
for match in ServiceLocator.get_regex_object(r'\\(label|include|input|bibliography|addbibresource)\{((?:\s|\w|\:|\.|,)*)\}|\\(usepackage)(?:\[.*\]){0,1}\{((?:\s|\w|\:|,)*)\}|\\(bibitem)(?:\[.*\]){0,1}\{((?:\s|\w|\:)*)\}').finditer(text):
if match.group(1) == 'label':
labels = labels | {match.group(2).strip()}
elif match.group(1) == 'include' or match.group(1) == 'input':
filename = os.path.normpath(os.path.join(self.dirname, match.group(2).strip()))
if not filename.endswith('.tex'):
filename += '.tex'
included_latex_files = included_latex_files | {filename}
elif match.group(1) == 'bibliography':
bibfiles = match.group(2).strip().split(',')
for entry in bibfiles:
bibliographies = bibliographies | {os.path.normpath(os.path.join(self.dirname, entry.strip() + '.bib'))}
elif match.group(1) == 'addbibresource':
bibfiles = match.group(2).strip().split(',')
for entry in bibfiles:
bibliographies = bibliographies | {os.path.normpath(os.path.join(self.dirname, entry.strip()))}
elif match.group(3) == 'usepackage':
packages = packages | {match.group(4).strip()}
packages_detailed[match.group(4).strip()] = match
elif match.group(5) == 'bibitem':
bibitems = bibitems | {match.group(6).strip()}
with self.symbols_lock:
self.symbols['labels'] = labels
self.symbols['included_latex_files'] = included_latex_files
self.symbols['bibliographies'] = bibliographies
self.symbols['bibitems'] = bibitems
self.symbols['packages'] = packages
self.symbols['packages_detailed'] = packages_detailed
self.labels_changed = True
with self.parse_jobs_lock:
self.parse_symbols_job_running = False
def __init__(self, preview, page_renderer, view):
self.preview = preview
self.page_renderer = page_renderer
self.view = view
self.highlight_duration = 1.5
self.color_manager = ServiceLocator.get_color_manager()
self.view.drawing_area.connect('draw', self.draw)
self.scrolling_queue = queue.Queue()
self.view.drawing_area.connect('size-allocate', self.scrolling_loop)
GObject.timeout_add(50, self.scrolling_loop)
self.preview.connect('pdf_changed', self.on_pdf_changed)
self.preview.connect('invert_pdf_changed', self.on_invert_pdf_changed)
self.preview.connect('layout_changed', self.on_layout_changed)
self.page_renderer.connect('rendered_pages_changed',
self.on_rendered_pages_changed)
self.show_blank_slate()
def scroll_cursor_onscreen(self):
text_iter = self.source_buffer.get_iter_at_mark(
self.source_buffer.get_insert())
visible_lines = self.get_number_of_visible_lines()
iter_position = self.source_view.get_iter_location(text_iter).y
end_yrange = self.source_view.get_line_yrange(
self.source_buffer.get_end_iter())
buffer_height = end_yrange.y + end_yrange.height
font_manager = ServiceLocator.get_font_manager()
line_height = font_manager.get_line_height()
window_offset = self.source_view.get_visible_rect().y
window_height = self.source_view.get_visible_rect().height
gap = min(math.floor(max((visible_lines - 2), 0) / 2), 5)
if iter_position < window_offset + gap * line_height:
self.scroll_view(max(iter_position - gap * line_height, 0))
return
gap = min(math.floor(max((visible_lines - 2), 0) / 2), 8)
if iter_position > (window_offset + window_height -
(gap + 1) * line_height):
self.scroll_view(
min(iter_position + gap * line_height - window_height,
buffer_height))
def __init__(self, document, document_view):
self.document = document
self.view = document_view
self.settings = ServiceLocator.get_settings()
self.view.source_view.set_show_line_numbers(
self.settings.get_value('preferences', 'show_line_numbers'))
self.view.source_view.set_insert_spaces_instead_of_tabs(
self.settings.get_value('preferences', 'spaces_instead_of_tabs'))
self.view.source_view.set_tab_width(
self.settings.get_value('preferences', 'tab_width'))
self.view.source_view.set_highlight_current_line(
self.settings.get_value('preferences', 'highlight_current_line'))
self.document.source_buffer.set_highlight_matching_brackets(
self.settings.get_value('preferences',
'highlight_matching_brackets'))
if self.settings.get_value('preferences', 'enable_line_wrapping'):
self.view.source_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
else:
self.view.source_view.set_wrap_mode(Gtk.WrapMode.NONE)
undo_manager = self.document.source_buffer.get_undo_manager()
def can_undo_changed(manager, user_data=None):
self.view.menu_item_undo.set_sensitive(manager.can_undo())
undo_manager.connect('can-undo-changed', can_undo_changed)
can_undo_changed(undo_manager)
def can_redo_changed(manager, user_data=None):
self.view.menu_item_redo.set_sensitive(manager.can_redo())
undo_manager.connect('can-redo-changed', can_redo_changed)
can_redo_changed(undo_manager)
if self.document.is_latex_document():
self.view.menu_item_show_in_preview.set_sensitive(False)
self.document.register_observer(self)
self.settings.register_observer(self)
def update(self, can_activate=False):
line = self.autocomplete.document.get_line_at_cursor()
offset = self.autocomplete.document.get_cursor_line_offset()
line = line[:offset] + '%•%' + line[offset:]
match = ServiceLocator.get_regex_object(
r'.*\\(begin|end)\{((?:[^\{\[\(])*)%•%((?:[^\{\[\(])*)\}.*').match(
line)
if not match:
self.cancel()
return
if self.autocomplete.matching_mark_start.get_deleted(
) or self.autocomplete.matching_mark_end.get_deleted():
self.has_matching_block = False
cursor_offset = self.autocomplete.document.get_cursor_offset()
start_offset = self.source_buffer.get_iter_at_mark(
self.autocomplete.mark_start).get_offset()
end_offset = self.source_buffer.get_iter_at_mark(
self.autocomplete.mark_end).get_offset()
if cursor_offset < start_offset:
self.cancel()
return
if cursor_offset > end_offset:
self.cancel()
return
self.update_current_word()
self.autocomplete.items = self.get_items()
if len(self.autocomplete.items) == 1 and len(self.current_word) == len(
self.autocomplete.items[0]['command']):
self.will_show = False
else:
items_cond = len(self.autocomplete.items) > 0 and len(
self.current_word) != len(
self.autocomplete.items[0]['command'])
self.will_show = self.will_show or (can_activate and items_cond)
self.autocomplete.populate(len(self.current_word))
self.autocomplete.update_visibility()
def __init__(self, document, document_view):
self.document = document
self.view = document_view
self.settings = ServiceLocator.get_settings()
self.view.source_view.set_show_line_numbers(False)
self.view.source_view.set_insert_spaces_instead_of_tabs(
self.settings.get_value('preferences', 'spaces_instead_of_tabs'))
self.view.source_view.set_tab_width(
self.settings.get_value('preferences', 'tab_width'))
self.view.source_view.set_highlight_current_line(
self.settings.get_value('preferences', 'highlight_current_line'))
self.document.source_buffer.set_highlight_matching_brackets(
self.settings.get_value('preferences',
'highlight_matching_brackets'))
if self.settings.get_value('preferences', 'enable_line_wrapping'):
self.view.source_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
else:
self.view.source_view.set_wrap_mode(Gtk.WrapMode.NONE)
self.document.register_observer(self)
self.settings.register_observer(self)
def update(self, can_activate=False):
if self.is_active():
self.session.update(can_activate)
if not self.is_active():
line = self.document.get_line_at_cursor()
offset = self.document.get_cursor_line_offset()
line = line[:offset] + '%•%' + line[offset:]
match = ServiceLocator.get_regex_object(r'.*\\(begin|end)\{((?:[^\{\[\(])*)%•%((?:[^\{\[\(])*)\}.*').match(line)
if match:
word_offset = self.document.get_cursor_offset() - len(match.group(2))
word_len = len(match.group(2)) + len(match.group(3))
self.start_session(session_begin_end.SessionBeginEnd(self, word_offset, word_len))
self.session.update(can_activate)
return
current_word = self.document.get_latex_command_at_cursor()
if can_activate:
items = self.provider.get_items(current_word)
if not items: return
for item in items:
if item['command'] == current_word:
return
self.start_session(session_default.SessionDefault(self, self.document))
def __init__(self, text, tex_filename, latex_interpreter, use_latexmk,
additional_arguments, do_cleanup, synctex_arguments):
Query.__init__(self)
self.text = text
self.tex_filename = tex_filename
self.new_pdf_filename = os.path.splitext(self.tex_filename)[0] + '.pdf'
self.directory_name = os.path.dirname(self.tex_filename)
self.synctex_args = synctex_arguments
self.additional_arguments = additional_arguments
self.do_cleanup = do_cleanup
self.log_messages = list()
self.bibtex_log_messages = list()
self.doc_regex = ServiceLocator.get_build_log_doc_regex()
self.item_regex = ServiceLocator.get_build_log_item_regex()
self.badbox_line_number_regex = ServiceLocator.get_build_log_badbox_line_number_regex(
)
self.other_line_number_regex = ServiceLocator.get_build_log_other_line_number_regex(
)
self.bibtex_log_item_regex = ServiceLocator.get_bibtex_log_item_regex()
self.forward_synctex_regex = ServiceLocator.get_forward_synctex_regex()
self.force_building_to_stop = False
self.latex_interpreter = latex_interpreter
self.build_command_defaults = dict()
self.build_command_defaults[
'pdflatex'] = 'pdflatex -synctex=1 -interaction=nonstopmode -pdf'
self.build_command_defaults[
'xelatex'] = 'xelatex -synctex=1 -interaction=nonstopmode'
self.build_command_defaults[
'lualatex'] = 'lualatex --synctex=1 --interaction=nonstopmode'
if use_latexmk:
if self.latex_interpreter == 'pdflatex':
interpreter_option = 'pdf'
else:
interpreter_option = self.latex_interpreter
self.build_command = 'latexmk -' + interpreter_option + ' -synctex=1 -interaction=nonstopmode' + self.additional_arguments
else:
self.build_command = self.build_command_defaults[
self.latex_interpreter] + self.additional_arguments
self.do_another_latex_build = True
self.do_a_bibtex_build = False
self.done_bibtex_build = False
self.error_count = 0
def __init__(self):
Observable.__init__(self)
self.font_manager = ServiceLocator.get_font_manager()
self.displayname = ''
self.filename = None
self.save_date = None
self.deleted_on_disk_dialog_shown_after_last_save = False
self.last_activated = 0
self.dark_mode = False
self.is_root = False
self.root_is_set = False
self.symbols = dict()
self.symbols['bibitems'] = set()
self.symbols['labels'] = set()
self.symbols['labels_with_offset'] = list()
self.symbols['included_latex_files'] = set()
self.symbols['bibliographies'] = set()
self.symbols['packages'] = set()
self.symbols['packages_detailed'] = dict()
self.symbols['blocks'] = list()
def __init__(self, symbol_folder, symbol_width, is_dark_mode):
SidebarPage.__init__(self)
self.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.symbol_folder = symbol_folder
self.symbol_width = symbol_width
self.size = None
# symbols: icon name, latex code
self.symbols = list()
self.images = list()
self.flowbox = Gtk.FlowBox()
self.flowbox.set_homogeneous(False)
self.flowbox.set_valign(Gtk.Align.START)
self.flowbox.set_max_children_per_line(20)
self.parent_folder = 'dark' if is_dark_mode else 'light'
xml_tree = ET.parse(
os.path.join(ServiceLocator.get_resources_path(), 'symbols',
symbol_folder + '.xml'))
xml_root = xml_tree.getroot()
for symbol_tag in xml_root:
self.symbols.append([
symbol_tag.attrib['file'].rsplit('.')[0],
symbol_tag.attrib['command'],
symbol_tag.attrib.get('package', None),
int(symbol_tag.attrib.get('original_width', 10)),
int(symbol_tag.attrib.get('original_height', 10))
])
self.init_symbols_list()
self.add(self.flowbox)
def __init__(self):
self.view = ServiceLocator.get_main_window().sidebar
# detect dark mode
dm = 'True' if helpers.is_dark_mode(self.view) else 'False'
# tabbed pages: name, icon name, tooltip, widget
self.pages = list()
self.pages.append(['greek_letters', 'own-symbols-greek-letters-symbolic', 'Greek Letters',
'sidebar_view.SidebarPageSymbolsList("greek_letters", 25, ' + dm + ')'])
self.pages.append(['arrows', 'own-symbols-arrows-symbolic', 'Arrows',
'sidebar_view.SidebarPageSymbolsList("arrows", 48, ' + dm + ')'])
self.pages.append(['relations', 'own-symbols-relations-symbolic', 'Relations',
'sidebar_view.SidebarPageSymbolsList("relations", 39, ' + dm + ')'])
self.pages.append(['operators', 'own-symbols-operators-symbolic', 'Operators',
'sidebar_view.SidebarPageSymbolsList("operators", 47, ' + dm + ')'])
self.pages.append(['misc_math', 'own-symbols-misc-math-symbolic', 'Misc. Math',
'sidebar_view.SidebarPageSymbolsList("misc_math", 42, ' + dm + ')'])
self.pages.append(['misc_text', 'own-symbols-misc-text-symbolic', 'Misc. Symbols',
'sidebar_view.SidebarPageSymbolsList("misc_text", 38, ' + dm + ')'])
self.page_views = list()
self.init_page_stack()
self.view.show_all()
def add_recent_symbol_to_flowbox(self, item):
(category, command) = item
xml_tree = ET.parse(os.path.join(ServiceLocator.get_resources_path(), 'symbols', category + '.xml'))
xml_root = xml_tree.getroot()
elements = xml_root.findall('./symbol[@command=\'' + command + '\']')
if len(elements) == 0:
self.remove_recent_symbol(item)
else:
attrib = elements[0].attrib
symbol = [attrib['file'].rsplit('.')[0], attrib['command'], attrib.get('package', None), int(attrib.get('original_width', 10)), int(attrib.get('original_height', 10))]
size = max(symbol[3], symbol[4])
image = Gtk.Image.new_from_icon_name('sidebar-' + symbol[0] + '-symbolic', 0)
image.set_pixel_size(int(size * 1.5))
tooltip_text = symbol[1]
if symbol[2] != None:
tooltip_text += ' (' + _('Package') + ': ' + symbol[2] + ')'
image.set_tooltip_text(tooltip_text)
image.show_all()
symbol.append(image)
self.recent_details.append(symbol)
self.view.symbols_view_recent.insert(image, 0)
self.view.queue_draw()
def __init__(self, document, document_view):
self.document = document
self.document_view = document_view
self.main_window = ServiceLocator.get_main_window()
self.view = view.DocumentAutocompleteView()
self.line_height = 0
self.char_width = 0
self.update_char_size()
self.shortcuts_bar_height = 37
self.number_of_matches = 0
self.insert_iter_offset = None
self.insert_iter_matched = False
self.current_word = ""
self.autocomplete_height = None
self.autocomplete_width = None
self.autocomplete_visible = False
self.autocomplete_focus_was_visible = False
self.static_proposals = dict()
self.dynamic_proposals = dict()
self.generate_proposals()
GObject.timeout_add(500, self.generate_dynamic_proposals)
self.view.list.connect('row-activated', self.on_autocomplete_row_activated)
self.view.list.connect('row-selected', self.on_autocomplete_row_selected)
self.document_view.scrolled_window.get_vadjustment().connect('value-changed', self.on_adjustment_value_changed)
self.document_view.scrolled_window.get_hadjustment().connect('value-changed', self.on_adjustment_value_changed)
self.document_view.source_view.connect('focus-out-event', self.on_focus_out)
self.document_view.source_view.connect('focus-in-event', self.on_focus_in)
self.document.get_buffer().connect('changed', self.on_buffer_changed)
self.document.get_buffer().connect('mark-set', self.on_mark_set)
self.document.get_buffer().connect('mark-deleted', self.on_mark_deleted)
def __init__(self, document):
self.document = document
self.build_system = build_system.BuildSystem()
self.settings = ServiceLocator.get_settings()
self.document.register_observer(self)
self.build_system.register_observer(self)
def change_notification(self, change_code, notifying_object, parameter):
if change_code == 'building_started':
self.document.change_build_state('building_in_progress')
if change_code == 'reset_timer':
self.document.build_widget.view.reset_timer()
self.document.build_widget.view.label.set_text('0:00')
if change_code == 'building_stopped':
self.document.show_build_state('')
self.document.change_build_state('idle')
if change_code == 'building_finished':
result_blob = parameter
if result_blob['build'] != None or result_blob[
'forward_sync'] != None:
if result_blob['build'] != None:
try:
self.document.preview.set_pdf_filename(
result_blob['build']['pdf_filename'])
except KeyError:
pass
if result_blob['forward_sync'] != None:
self.document.preview.set_synctex_rectangles(
result_blob['forward_sync'])
self.document.show_build_state('')
if result_blob['build'] != None:
build_blob = result_blob['build']
if build_blob['error'] == 'interpreter_missing':
self.document.show_build_state('')
self.document.change_build_state('idle')
if DialogLocator.get_dialog('interpreter_missing').run(
build_blob['error_arg']):
DialogLocator.get_dialog('preferences').run()
return
if build_blob['error'] == 'interpreter_not_working':
self.document.show_build_state('')
self.document.change_build_state('idle')
if DialogLocator.get_dialog('building_failed').run(
build_blob['error_arg']):
DialogLocator.get_dialog('preferences').run()
return
self.document.set_build_log_items(
build_blob['log_messages'])
self.document.build_time = time.time(
) - self.document.last_build_start_time
error_count = self.document.get_error_count()
if error_count > 0:
error_color_rgba = ServiceLocator.get_error_color()
error_color = '#' + format(
int(error_color_rgba.red * 255), '02x') + format(
int(error_color_rgba.green * 255),
'02x') + format(
int(error_color_rgba.blue * 255), '02x')
str_errors = ngettext(
'<span color="{color}">Failed</span> ({amount} error)!',
'<span color="{color}">Failed</span> ({amount} errors)!',
error_count)
message = str_errors.format(color=error_color,
amount=str(error_count))
self.document.show_build_state(message)
else:
self.document.show_build_state(_('Success!'))
self.document.set_has_synctex_file(
build_blob['has_synctex_file'])
self.document.has_been_built = True
elif result_blob['backward_sync'] != None:
self.document.set_synctex_position(
result_blob['backward_sync'])
self.document.change_build_state('idle')
if result_blob['build'] != None:
self.document.invalidate_build_log()
def __init__(self, app):
Gtk.Window.__init__(self, application=app)
self.app = app
self.set_size_request(-1, 550)
self.add_events(Gdk.EventMask.KEY_PRESS_MASK)
# window state variables
self.current_width = 0
self.current_height = 0
self.ismaximized = False
# headerbar
self.headerbar = headerbar_view.HeaderBar()
self.set_titlebar(self.headerbar)
# latex notebook
self.latex_notebook = Gtk.Notebook()
self.latex_notebook.set_show_tabs(False)
self.latex_notebook.set_show_border(False)
self.latex_notebook.set_scrollable(True)
self.latex_notebook.set_size_request(550, -1)
self.latex_shortcuts_bar = latex_shortcutsbar_view.LaTeXShortcutsBar()
self.latex_notebook_wrapper = Gtk.VBox()
self.latex_notebook_wrapper.pack_start(self.latex_shortcuts_bar, False,
False, 0)
self.latex_notebook_wrapper.pack_start(self.latex_notebook, True, True,
0)
# bibtex notebook
self.bibtex_notebook = Gtk.Notebook()
self.bibtex_notebook.set_show_tabs(False)
self.bibtex_notebook.set_show_border(False)
self.bibtex_notebook.set_scrollable(True)
self.bibtex_notebook.set_size_request(550, -1)
self.bibtex_shortcuts_bar = bibtex_shortcutsbar_view.BibTeXShortcutsBar(
)
self.bibtex_notebook_wrapper = Gtk.VBox()
self.bibtex_notebook_wrapper.pack_start(self.bibtex_shortcuts_bar,
False, False, 0)
self.bibtex_notebook_wrapper.pack_start(self.bibtex_notebook, True,
True, 0)
# others notebook
self.others_notebook = Gtk.Notebook()
self.others_notebook.set_show_tabs(False)
self.others_notebook.set_show_border(False)
self.others_notebook.set_scrollable(True)
self.others_notebook.set_size_request(550, -1)
self.others_shortcuts_bar = others_shortcutsbar_view.OthersShortcutsBar(
)
self.others_notebook_wrapper = Gtk.VBox()
self.others_notebook_wrapper.pack_start(self.others_shortcuts_bar,
False, False, 0)
self.others_notebook_wrapper.pack_start(self.others_notebook, True,
True, 0)
# build log
self.build_log = build_log_view.BuildLogView()
self.build_log_paned = Gtk.VPaned()
self.build_log_paned.pack1(self.latex_notebook_wrapper, True, False)
self.build_log_paned.pack2(self.build_log, False, True)
self.build_log_visible = None
# preview
self.preview_panel = preview_panel_view.PreviewPanelView()
self.preview_visible = None
# help
self.help_panel = help_panel_view.HelpPanelView()
self.help_visible = None
# sidebar
self.sidebar = sidebar_view.Sidebar()
self.sidebar_visible = None
# paneds
self.preview_paned_overlay = Gtk.Overlay()
self.overlay_widget = None
self.preview_help_stack = Gtk.Stack()
self.preview_help_stack.add_named(self.preview_panel, 'preview')
self.preview_help_stack.add_named(self.help_panel, 'help')
self.preview_paned = Gtk.HPaned()
self.preview_paned.pack1(self.build_log_paned, True, False)
self.preview_paned.pack2(self.preview_help_stack, False, True)
self.preview_paned_overlay.add(self.preview_paned)
self.sidebar_paned = Gtk.HPaned()
self.sidebar_paned.pack1(self.sidebar, False, True)
self.sidebar_paned.pack2(self.preview_paned_overlay, True, False)
self.sidebar_paned.get_style_context().add_class('sidebar_paned')
# welcome screen
self.welcome_screen = welcome_screen_view.WelcomeScreenView()
# mode stack
self.mode_stack = Gtk.Stack()
self.mode_stack.add_named(self.welcome_screen, 'welcome_screen')
self.mode_stack.add_named(self.sidebar_paned, 'latex_documents')
self.mode_stack.add_named(self.bibtex_notebook_wrapper,
'bibtex_documents')
self.mode_stack.add_named(self.others_notebook_wrapper,
'other_documents')
self.add(self.mode_stack)
self.css_provider = Gtk.CssProvider()
resources_path = ServiceLocator.get_resources_path()
self.css_provider.load_from_path(
os.path.join(resources_path, 'style_gtk.css'))
self.style_context = Gtk.StyleContext()
self.style_context.add_provider_for_screen(
self.get_screen(), self.css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
self.css_provider_font_size = Gtk.CssProvider()
self.style_context.add_provider_for_screen(
self.get_screen(), self.css_provider_font_size,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
