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)