def load_and_show_themes(self):
# Set theme.
self.themeManager = GtkSource.StyleSchemeManager()
# Map from theme id to StyleScheme.
self.themes = {
tid: self.themeManager.get_scheme(tid)
for tid in self.themeManager.get_scheme_ids()
}
# Holds the currently selected theme info.
self.theme = None
celltheme = Gtk.CellRendererText()
self.comboTheme.pack_start(celltheme, True)
self.comboTheme.add_attribute(celltheme, 'text', 0)
self.bufferOutput = GtkSource.Buffer()
self.langManager = GtkSource.LanguageManager()
self.bufferLang = self.langManager.get_language('python3')
self.bufferOutput.set_language(self.bufferLang)
self.bufferOutput.set_highlight_syntax(True)
self.bufferOutput.set_highlight_matching_brackets(True)
if not self.set_theme_config():
# Use first preferred theme if available.
themeprefs = ('oblivion', 'tomorrownighteighties', 'twilight',
'kate')
for themeid in themeprefs:
theme = self.themes.get(themeid, None)
if theme:
self.set_theme(theme)
break
self.build_theme_list()
def __init__(self, config, begin, end):
super(changesWindow, self).__init__()
builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
builder.add_from_file(
pkg_resources.resource_filename("snappergui",
"glade/changesWindow.glade"))
builder.get_object("titlelabel").set_text("%s -> %s" % (begin, end))
self.window = builder.get_object("changesWindow")
self.statusbar = builder.get_object("statusbar1")
self.pathstreeview = builder.get_object("pathstreeview")
self.fileview = builder.get_object("fileview")
self.choicesviewgroup = builder.get_object("actiongroup")
builder.connect_signals(self)
# save mountpoints for begin and end snapshots
self.beginpath = snapper.GetMountPoint(config, begin)
self.endpath = snapper.GetMountPoint(config, end)
self.config = config
self.snapshot_begin = begin
self.snapshot_end = end
self.choicesviewgroup.get_action("begin").set_label(str(begin))
self.choicesviewgroup.get_action("end").set_label(str(end))
self.sourcebuffer = GtkSource.Buffer()
self.fileview.set_buffer(self.sourcebuffer)
self.window.show_all()
GObject.idle_add(self.on_idle_init_paths_tree)
def __init__(self, *args, **kwargs):
self.label = Gtk.Label(label='Edit')
"""The :py:class:`Gtk.Label` representing this tabs name."""
super(MailSenderEditTab, self).__init__(*args, **kwargs)
self.textview = self.gobjects['view_html_file']
"""The :py:class:`Gtk.TextView` object of the editor."""
self.textbuffer = GtkSource.Buffer()
"""The :py:class:`Gtk.TextBuffer` used by the :py:attr:textview` attribute."""
self.textview.set_buffer(self.textbuffer)
self.textview.modify_font(
Pango.FontDescription(self.config['text_font']))
self.language_manager = GtkSource.LanguageManager()
self.textbuffer.set_language(
self.language_manager.get_language('html'))
self.textbuffer.set_highlight_syntax(True)
self.toolbutton_save_html_file = self.gobjects[
'toolbutton_save_html_file']
self.textview.connect('populate-popup',
self.signal_textview_populate_popup)
scheme_manager = GtkSource.StyleSchemeManager()
style_scheme_name = self.config['text_source_theme']
style_scheme = scheme_manager.get_scheme(style_scheme_name)
if style_scheme:
self.textbuffer.set_style_scheme(style_scheme)
else:
self.logger.error(
"invalid GTK source theme: '{0}'".format(style_scheme_name))
self.file_monitor = None
def __init__(self):
Gtk.Plug.__init__(self)
Gtk.Plug.construct(self, wid)
lang_manager = GtkSource.LanguageManager()
lang = lang_manager.guess_language(path)
style_manager = GtkSource.StyleSchemeManager.get_default()
style = style_manager.get_scheme("classic")
f = open(path, "r", encoding=ENCODING, errors="replace")
txt = f.read()
f.close()
self.srcbuf = GtkSource.Buffer()
self.srcbuf.set_style_scheme(style)
self.srcbuf.set_language(lang)
self.srcbuf.set_text(txt)
scroll = Gtk.ScrolledWindow()
view = GtkSource.View.new_with_buffer(self.srcbuf)
view.set_show_line_numbers(True)
view.set_highlight_current_line(True)
view.get_space_drawer().set_enable_matrix(True)
view.set_editable(False)
view.set_tab_width(8)
#view.override_font(Pango.FontDescription('mono 12'))
view.set_name("sourceview")
cssprovider = Gtk.CssProvider()
cssprovider.load_from_path(
os.path.dirname(sys.argv[0]) + "/gtksourceview.css")
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), cssprovider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
scroll.add(view)
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self.lbl_search = Gtk.Label()
button = Gtk.Button.new_with_label("Set text")
button.connect("pressed", self.search_dialog)
self.btn_case = Gtk.ToggleButton.new_with_label("Case sensitive")
self.btn_case.connect("pressed", self.search_case)
self.btn_regex = Gtk.ToggleButton.new_with_label("RegEx")
self.btn_regex.connect("pressed", self.search_regex)
hbox.pack_start(self.btn_case, False, True, 2)
hbox.pack_start(self.btn_regex, False, True, 2)
hbox.pack_start(button, False, True, 2)
hbox.pack_end(self.lbl_search, True, True, 1)
hbox.set_border_width(5)
win = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
win.pack_start(scroll, True, True, 1)
win.pack_end(hbox, False, True, 1)
self.sopts = GtkSource.SearchSettings()
self.scontext = GtkSource.SearchContext(buffer=self.srcbuf,
settings=self.sopts)
self.add(win)
def __init__(self, db):
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file(UI_FILE)
self.builder.connect_signals(self)
self.db = db
language_manager = GtkSource.LanguageManager()
self.source_view = self.builder.get_object('gtksourceview1')
self.source_buffer = GtkSource.Buffer()
self.source_view.set_buffer(self.source_buffer)
self.source_buffer.set_language(language_manager.get_language('sql'))
completion = self.source_view.get_completion()
keyword_provider = GtkSource.CompletionWords.new('Keywords')
keyword_provider.register(self.source_buffer)
completion.add_provider(keyword_provider)
self.window = self.builder.get_object('window1')
self.window.show_all()
self.populate_sql_commands()
cursor = self.db.cursor()
cursor.execute("SELECT command FROM sql.history WHERE current = True")
command = cursor.fetchone()[0]
self.source_buffer.set_text(command)
cursor.close()
def __init__(self, note):
"""Initializes the stickynotes window"""
self.path = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..'))
self.note = note
self.noteset = note.noteset
self.locked = self.note.properties.get("locked", False)
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file(os.path.join(self.path,
"StickyNotes.glade"))
self.builder.connect_signals(self)
# Get necessary objects
self.winMain = self.builder.get_object("MainWindow")
self.winMain.set_name("main-window")
widgets = [
"txtNote", "bAdd", "imgAdd", "imgResizeR", "eResizeR", "bLock",
"imgLock", "imgUnlock", "bClose", "confirmDelete"
]
for w in widgets:
setattr(self, w, self.builder.get_object(w))
# Create menu
self.menu = Gtk.Menu()
self.populate_menu()
# Load CSS template and initialize Gtk.CssProvider
with open(os.path.join(self.path, "style.css")) as css_file:
self.css_template = Template(css_file.read())
self.css = Gtk.CssProvider()
self.style_contexts = [
self.winMain.get_style_context(),
self.txtNote.get_style_context()
]
# Update window-specific style. Global styles are loaded initially!
self.update_style()
self.update_font()
# Ensure buttons are displayed with images
settings = Gtk.Settings.get_default()
settings.props.gtk_button_images = True
# Set text buffer
self.bbody = GtkSource.Buffer()
self.bbody.begin_not_undoable_action()
self.bbody.set_text(self.note.body)
self.bbody.set_highlight_matching_brackets(False)
self.bbody.end_not_undoable_action()
self.txtNote.set_buffer(self.bbody)
# Make resize work
self.winMain.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self.eResizeR.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
# Move Window
self.winMain.move(*self.note.properties.get("position", (10, 10)))
self.winMain.resize(*self.note.properties.get("size", (200, 150)))
# Show the window
self.winMain.show()
# Mouse over
self.eResizeR.get_window().set_cursor(
Gdk.Cursor.new_for_display(
self.eResizeR.get_window().get_display(),
Gdk.CursorType.BOTTOM_RIGHT_CORNER))
# Set locked state
self.set_locked_state(self.locked)
def create_source_view(self):
font_desc = Pango.FontDescription('monospace 11')
if GtkSource:
lang_mgr = GtkSource.LanguageManager()
lang = lang_mgr.get_language('python')
buffer = GtkSource.Buffer()
buffer.set_language(lang)
buffer.set_highlight_syntax(True)
view = GtkSource.View()
view.set_buffer(buffer)
view.set_show_line_numbers(True)
scrolled_window = self.create_scrolled_window()
scrolled_window.add(view)
else:
scrolled_window, buffer = self.create_text_view()
view = scrolled_window.get_child()
view.modify_font(font_desc)
view.set_wrap_mode(Gtk.WrapMode.NONE)
return scrolled_window, buffer
def __init__(self, main_app):
"""Create the source view window and init its properties"""
self.main = main_app
self.model = main_app.model
self.clipboard = Gtk.Clipboard()
control_viewport = self.main.builder.get_object('control_view')
manager = GtkSource.LanguageManager()
lang_python = manager.get_language('python')
self.buffer = GtkSource.Buffer(language=lang_python)
self.buffer.props.highlight_syntax = True
self.control_view = GtkSource.View(buffer=self.buffer)
self.buffer.place_cursor(self.buffer.get_start_iter())
self.control_view.connect('button-press-event',
self.on_control_view_clicked)
self.buffer.connect('changed', self.on_buffer_changed)
self.buffer.connect('notify::can-undo',
lambda o, p: self.main.update_undo_redo_menuitem())
self.buffer.connect('notify::can-redo',
lambda o, p: self.main.update_undo_redo_menuitem())
self.tag_error = self.buffer.create_tag("error", background="red")
debug_textview = self.main.builder.get_object('trace_textview')
self.debug_buffer = LogBuffer(sys.stdout)
sys.stdout = self.debug_buffer
debug_textview.set_buffer(self.debug_buffer)
self.control_view.show()
#hide trace window by default
#self.main.builder.get_object('hboxdebug').hide()
control_viewport.add(self.control_view)
def __init__(self, *args, **kwargs):
self.label = Gtk.Label(label='Edit')
"""The :py:class:`Gtk.Label` representing this tabs name."""
super(MailSenderEditTab, self).__init__(*args, **kwargs)
self.textview = self.gobjects['view_html_file']
"""The :py:class:`Gtk.TextView` object of the editor."""
self.textbuffer = GtkSource.Buffer()
"""The :py:class:`Gtk.TextBuffer` used by the :py:attr:textview` attribute."""
self.textview.set_buffer(self.textbuffer)
self.textview.modify_font(Pango.FontDescription(self.config['text_font']))
self.language_manager = GtkSource.LanguageManager()
self.textbuffer.set_language(self.language_manager.get_language('html'))
self.textbuffer.set_highlight_syntax(True)
self.toolbutton_save_html_file = self.gobjects['toolbutton_save_html_file']
self.textview.connect('populate-popup', self.signal_textview_populate_popup)
self.textview.connect('key-press-event', self.signal_textview_key_pressed)
scheme_manager = GtkSource.StyleSchemeManager()
style_scheme_name = self.config['text_source_theme']
style_scheme = scheme_manager.get_scheme(style_scheme_name)
if style_scheme:
self.textbuffer.set_style_scheme(style_scheme)
else:
self.logger.error("invalid GTK source theme: '{0}'".format(style_scheme_name))
self.file_monitor = None
source_completion = self.textview.get_completion()
source_completion.set_property('accelerators', 0)
source_completion.set_property('auto-complete-delay', 250)
source_completion.set_property('show-icons', False)
source_completion.add_provider(completion_providers.HTMLComletionProvider())
source_completion.add_provider(completion_providers.JinjaEmailCompletionProvider())
def __init__(self, filediff):
super().__init__("patch-dialog.ui", "patchdialog")
self.widget.set_transient_for(filediff.widget.get_toplevel())
self.filediff = filediff
buf = GtkSource.Buffer()
self.textview.set_buffer(buf)
lang = LanguageManager.get_language_from_mime_type("text/x-diff")
buf.set_language(lang)
buf.set_highlight_syntax(True)
self.textview.modify_font(meldsettings.font)
self.textview.set_editable(False)
self.index_map = {
self.left_radiobutton: (0, 1),
self.right_radiobutton: (1, 2)
}
self.left_patch = True
self.reverse_patch = self.reverse_checkbutton.get_active()
if self.filediff.num_panes < 3:
self.side_selection_label.hide()
self.side_selection_box.hide()
meldsettings.connect('changed', self.on_setting_changed)
def set_auto_completation(self):
"""
1)
Set up a provider that get words from what has already been entered
in the gtkSource.Buffer that is tied to the GtkSourceView
2)
Set up a second buffer that stores the keywords we want to be available
3)
Setup an instance of our custome completion class to handle special characters with
auto complete.
"""
# This gets the GtkSourceView completion that's already tied to the GtkSourceView
# We need it to attached our providers to it
self.gsv_completion = self.editor.get_completion()
# 1) Make a new provider, attach it to the main buffer add to view_autocomplete
self.gsv_autocomplete = GtkSource.CompletionWords.new('main')
self.gsv_autocomplete.register(self.textbuff)
self.gsv_completion.add_provider(self.gsv_autocomplete)
# 2) Make a new buffer, add a str to it, make a provider, add it to the view_autocomplete
self.keybuff = GtkSource.Buffer()
self.keybuff.begin_not_undoable_action()
self.keybuff.set_text(self.keywords)
self.keybuff.end_not_undoable_action()
self.gsv_keyword_complete = GtkSource.CompletionWords.new('keyword')
self.gsv_keyword_complete.register(self.keybuff)
self.gsv_completion.add_provider(self.gsv_keyword_complete)
# 3) Set up our custom provider for syntax completion.
custom_completion_provider = CustomCompletionProvider()
self.gsv_completion.add_provider(custom_completion_provider)
self.custom_completion_provider = custom_completion_provider
return
def build_note(self):
self.builder = Gtk.Builder()
GObject.type_register(GtkSource.View)
self.builder.add_from_file(os.path.join(self.path, "StickyNotes.ui"))
self.builder.connect_signals(self)
self.winMain = self.builder.get_object("MainWindow")
# Get necessary objects
self.winMain.set_name("main-window")
widgets = [
"txtNote", "bAdd", "imgAdd", "imgResizeR", "eResizeR", "bLock",
"imgLock", "imgUnlock", "imgClose", "imgDropdown", "bClose",
"confirmDelete", "movebox1", "movebox2"
]
for w in widgets:
setattr(self, w, self.builder.get_object(w))
self.style_contexts = [
self.winMain.get_style_context(),
self.txtNote.get_style_context()
]
# Update window-specific style. Global styles are loaded initially!
self.update_style()
self.update_font()
# Ensure buttons are displayed with images
settings = Gtk.Settings.get_default()
settings.props.gtk_button_images = True
# Set text buffer
self.bbody = GtkSource.Buffer()
self.bbody.begin_not_undoable_action()
self.bbody.set_text(self.note.body)
self.bbody.set_highlight_matching_brackets(False)
self.bbody.end_not_undoable_action()
self.txtNote.set_buffer(self.bbody)
# Make resize work
self.winMain.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self.eResizeR.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
# Move Window
self.winMain.move(*self.note.properties.get("position", (10, 10)))
self.winMain.resize(*self.note.properties.get("size", (200, 150)))
# Show the window
self.winMain.set_skip_pager_hint(True)
self.winMain.show_all()
# Mouse over
self.eResizeR.get_window().set_cursor(
Gdk.Cursor.new_for_display(
self.eResizeR.get_window().get_display(),
Gdk.CursorType.BOTTOM_RIGHT_CORNER))
# Set locked state
self.set_locked_state(self.locked)
# call set_keep_above just to have the note appearing
# above everything else.
# without it, it still won't appear above a window
# in which a cursor is active
self.winMain.set_keep_above(True)
# immediately undo the set keep above after the window
# is shown, so that windows won't stay up if we switch to
# a different window
self.winMain.set_keep_above(False)
def __init__(self, code_type, text=None):
Gtk.ScrolledWindow.__init__(self)
self.get_style_context().add_class(code_type)
self._view = GtkSource.View()
self.add(self._view)
text_buffer = GtkSource.Buffer()
lang_manager = GtkSource.LanguageManager.get_default()
lang_ids = lang_manager.get_language_ids()
langs = [lang_manager.get_language(lang_id)
for lang_id in lang_ids]
for lang in langs:
for m in lang.get_mime_types():
if m == 'text/' + code_type:
text_buffer.set_language(lang)
text_buffer.set_highlight_syntax(True)
# "- 2" accounts for the border width
self.set_size_request(
int(Gdk.Screen.width() * 0.5) - 2,
int((Gdk.Screen.height()-style.GRID_CELL_SIZE) * 0.5) - 2)
self._view.set_buffer(text_buffer)
self._view.set_editable(True)
self._view.set_cursor_visible(True)
self._view.set_wrap_mode(Gtk.WrapMode.CHAR)
self._view.set_insert_spaces_instead_of_tabs(True)
self._view.set_tab_width(4)
self._view.set_can_focus(True)
self._view.modify_font(Pango.FontDescription('Monospace 14'))
if text is not None:
self.set(text)
def __init__(self,ebeveyn, title = "Talimat Editör"):
Gtk.Window.__init__(self)
self.ebeveyn = ebeveyn
self.degistimi = False
self.acilan_dosya = ""
self.kaydirma = Gtk.ScrolledWindow()
self.kaydirma.set_hexpand(True)
self.kaydirma.set_vexpand(True)
self.editor = GtkSource.View()
self.editor.set_show_line_numbers(1)
self.editor.set_indent_on_tab(1)
self.editor.set_tab_width(4)
self.editor.set_show_line_marks(1)
self.kaydirma.add(self.editor)
self.pack_start(self.kaydirma, expand = True, fill = True, padding = 5)
self.textbuff = GtkSource.Buffer()
self.textbuff.connect("changed",self.yazi_degisti)
self.editor.set_buffer(self.textbuff)
self.lm = GtkSource.LanguageManager()
self.textbuff.set_language(self.lm.get_language('ini'))
self.keywords = """
GtkSourceView
Completion
"""
self.set_auto_completation()
def get_buffer(self, symtab, filename):
if filename in self.buffers:
return self.buffers[filename]
if not self.lang_manager:
self.lang_manager = GtkSource.LanguageManager.get_default()
buff = GtkSource.Buffer()
if filename:
buff.set_language(self.lang_manager.guess_language(filename))
buff.set_style_scheme(gui.params.source_theme.get_scheme())
buff.begin_not_undoable_action()
try:
contents = open(filename).read()
except:
return None
buff.set_text(contents)
buff.end_not_undoable_action()
buff.set_modified(False)
buff.filename = filename
if symtab is not None:
gdb.post_event(lambda: self._get_lines_update(buff, symtab))
self.buffers[filename] = buff
return buff
def _create_buffer(self, file_path=None):
# 支持的语言
# ada awk boo c c-sharp changelog chdr cpp css d def desktop diff
# docbook dot dpatch dtd eiffel erlang forth fortran gap gettext-translation
# gtk-doc gtkrc haddock haskell haskell-literate html idl ini java js latex
# libtool lua m4 makefile msil nemerle objc objective-caml ocl octave pascal
# perl php pkgconfig python r rpmspec ruby scheme sh sql tcl texinfo vala vbnet
# verilog vhdl xml xslt yacc
manager = GtkSource.LanguageManager()
src_buffer = GtkSource.Buffer()
# TODO:以后如果有算法，需要根据内容来判断文件的类型。
if file_path is not None:
language = manager.guess_language(file_path, None) # 设定语法的类型
src_buffer.set_language(language)
src_buffer.set_highlight_syntax(True) # 语法高亮
#src_buffer.connect("changed", self.on_src_bufer_changed)
# 可以利用 styleSchemeManager.get_scheme_ids() 得到所有的id
# ['cobalt', 'kate', 'oblivion', 'solarized-dark', 'solarized-light', 'tango', 'classic']
styleSchemeManager = GtkSource.StyleSchemeManager.get_default()
styleScheme = styleSchemeManager.get_scheme("cobalt")
if styleScheme is not None:
self.styleScheme = styleScheme # 不能丢弃
src_buffer.set_style_scheme(self.styleScheme)
return src_buffer
def __init__(self, parent_window=None):
Gtk.Window.__init__(self)
self.parent_window = parent_window
self.set_title("Informe de Introspección")
self.set_transient_for(self.parent_window)
self.set_border_width(5)
self.source = GtkSource.View()
self.source.set_insert_spaces_instead_of_tabs(True)
self.source.set_tab_width(4)
self.source.set_auto_indent(True)
self.source.set_highlight_current_line(True)
self.source.set_editable(False)
self.source.set_border_width(5)
self.source.set_buffer(GtkSource.Buffer())
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scroll.add(self.source)
self.resize(w / 3, h - 40)
self.move(w - w / 3, 40)
#text = ""
#_dict = self.infonotebook.introspeccion._dict
#for key in _dict:
# text = "%s\n%s" % (text, _dict[key])
#source.get_buffer().set_text(text)
self.add(scroll)
self.show_all()
def make_source(self):
scheme = GtkSource.StyleSchemeManager()
scheme.set_search_path()
language = GtkSource.LanguageManager()
buffer = GtkSource.Buffer()
buffer.set_language(language.get_language('php'))
buffer.set_style_scheme(scheme.get_scheme('tango'))
buffer.set_highlight_syntax(True)
font = Pango.FontDescription()
font.set_family(
'Droid Sans Mono, DejaVu Sans Mono, Ubuntu Mono, Monospace')
font.set_absolute_size(11 * Pango.SCALE)
self.source = GtkSource.View.new_with_buffer(buffer)
self.source.override_font(font)
self.source.set_show_line_numbers(True)
self.source.set_insert_spaces_instead_of_tabs(False)
self.source.set_auto_indent(True)
self.source.set_tab_width(4)
self.source.set_indent_width(4)
self.source.set_smart_home_end(True)
self.source.set_highlight_current_line(True)
def add_text_view(self):
scrolledWindow = self.add_scrolled_window()
self.set_child_packing(self.frame, True, True, 0, gtk.PackType.START)
buf = gtksource.Buffer()
lang_manager = gtksource.LanguageManager()
buf.set_highlight_matching_brackets(True)
if self.node is not None and self.node.is_code():
codelanguage = self.node.get_code_language()
if codelanguage in lang_manager.get_language_ids():
language = lang_manager.get_language(codelanguage)
else:
language = lang_manager.get_language("python")
buf.set_language(language)
buf.set_highlight_syntax(True)
textview = gtksource.View.new_with_buffer(buf)
textview.set_auto_indent(True)
textview.set_insert_spaces_instead_of_tabs(True)
textview.set_tab_width(2)
if self.node is not None and self.node.is_code():
textview.set_show_line_numbers(True)
font_desc = pango.FontDescription("monospace")
if font_desc:
textview.modify_font(font_desc)
textview.set_pixels_above_lines(2)
textview.set_pixels_below_lines(2)
textview.set_wrap_mode(gtk.WrapMode.WORD)
textview.connect("focus-in-event", self.entry_focus_in)
scrolledWindow.add(textview)
textview.show()
return textview
def __init__(self):
super().__init__()
self.document = None
self.buffer = GtkSource.Buffer()
self.manager = GtkSource.LanguageManager()
self.buffer.set_language(self.manager.get_language("markdown"))
self.view = GtkSource.View()
self.view.set_buffer(self.buffer)
self.view.set_wrap_mode(Gtk.WrapMode.WORD)
self.view.set_auto_indent(True)
self.view.set_smart_home_end(True)
self.view.set_insert_spaces_instead_of_tabs(True)
self.view.set_tab_width(4)
self.view.set_pixels_above_lines(4)
self.view.set_pixels_below_lines(4)
self.view.set_left_margin(8)
self.view.set_right_margin(8)
self.view.get_style_context().add_class('norka-editor')
self.view.connect('key-release-event', self.on_key_release_event)
self.font_desc = Pango.FontDescription()
self.spellchecker = GtkSpell.Checker()
self.add(self.view)
def new_buffer(self):
style_scheme_manager = GtkSource.StyleSchemeManager()
b = GtkSource.Buffer()
b.set_language(self.language_manager.get_language(self.language))
b.set_highlight_syntax(True)
user_editor_style = global_gui_config.get_config_value(
self.editor_style, "classic")
if user_editor_style.startswith("rafcon"):
user_editor_style = "rafcon"
dark_theme = global_gui_config.get_config_value(
'THEME_DARK_VARIANT', True)
if dark_theme:
user_editor_style = "rafcon-dark"
if is_custom_design_enabled():
user_editor_style = global_design_config.get_config_value(
"SOURCE_VIEW_THEME")
scheme = style_scheme_manager.get_scheme(user_editor_style)
if scheme:
self.style_scheme = scheme
else:
logger.debug(
"The editor style '{}' is not supported. Using the default 'classic'"
.format(user_editor_style))
self.style_scheme = style_scheme_manager.get_scheme('classic')
b.set_style_scheme(self.style_scheme)
return b
def init_buffer(self):
self.source_buffer = GtkSource.Buffer()
resources_path = ServiceLocator.get_resources_path()
# set source language for syntax highlighting
self.source_language_manager = GtkSource.LanguageManager()
self.source_language_manager.set_search_path(
(os.path.join(resources_path, 'gtksourceview',
'language-specs'), ))
self.source_language = self.source_language_manager.get_language(
self.get_gsv_language_name())
self.source_buffer.set_language(self.source_language)
self.source_style_scheme_manager = GtkSource.StyleSchemeManager()
self.source_style_scheme_manager.set_search_path(
(os.path.join(resources_path, 'gtksourceview', 'styles'), ))
self.source_style_scheme_light = self.source_style_scheme_manager.get_scheme(
'setzer')
self.source_style_scheme_dark = self.source_style_scheme_manager.get_scheme(
'setzer-dark')
self.search_settings = GtkSource.SearchSettings()
self.search_context = GtkSource.SearchContext.new(
self.source_buffer, self.search_settings)
self.search_context.set_highlight(True)
self.source_buffer.connect('changed', self.on_buffer_changed)
self.source_buffer.connect('insert-text', self.on_insert_text)
self.add_change_code('buffer_ready')
def render_prop(self, prop, value, callback, callback_data, sdfg):
widget = None
if prop.dtype == bool and value is not None:
widget = Gtk.Switch()
widget.set_active(value)
widget.connect("state-set", callback, callback_data)
elif isinstance(prop, dace.properties.CodeProperty):
buf = GtkSource.Buffer()
value = prop.to_string(value)
widget = GtkSource.View.new_with_buffer(buf)
lang_manager = GtkSource.LanguageManager()
language = lang_manager.get_language("python")
buf.set_language(language)
buf.set_text(value)
buf.set_highlight_syntax(True)
buf.connect("changed", callback, callback_data)
elif prop.enum is not None:
widget = Gtk.ComboBoxText()
if isinstance(prop, dace.properties.DataProperty):
enum = prop.enum(sdfg)
else:
enum = prop.enum
for i, option in enumerate(enum):
widget.append_text(prop.to_string(option))
if option == value:
widget.set_active(i)
widget.connect("changed", callback, callback_data)
else:
widget = Gtk.Entry()
widget.set_text(prop.to_string(value))
widget.connect("changed", callback, callback_data)
return widget
def __init__(self):
super().__init__()
self.document = None
self.buffer = GtkSource.Buffer()
self.manager = GtkSource.LanguageManager()
self.language = self.manager.get_language("markdown")
self.buffer.set_language(self.language)
self.buffer.create_tag('match', background="#66ff00")
self.view = GtkSource.View()
self.view.set_buffer(self.buffer)
self.view.set_wrap_mode(Gtk.WrapMode.WORD)
self.view.set_auto_indent(True)
self.view.set_smart_home_end(True)
self.view.set_insert_spaces_instead_of_tabs(True)
self.view.set_tab_width(4)
# self.view.set_pixels_above_lines(4)
# self.view.set_pixels_below_lines(4)
self.view.set_left_margin(8)
self.view.set_right_margin(8)
self.view.get_style_context().add_class('norka-editor')
self.view.connect('key-release-event', self.on_key_release_event)
self.scrolled = Gtk.ScrolledWindow(hexpand=True, vexpand=True)
self.scrolled.add(self.view)
# SearchBar
self.search_bar = SearchBar()
self.search_revealer = Gtk.Revealer()
self.search_revealer.add(self.search_bar)
self.search_bar.connect('find-changed', self.do_next_match)
self.search_bar.connect('find-next', self.do_next_match)
self.search_bar.connect('find-prev', self.do_previous_match)
self.search_bar.connect('stop-search', self.do_stop_search)
content_grid = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
content_grid.pack_start(self.search_revealer, False, True, 0)
content_grid.pack_start(self.scrolled, True, True, 0)
content_grid.show_all()
self.overlay = Gtk.Overlay()
self.overlay.add(content_grid)
self.stats_overlay = Granite.WidgetsOverlayBar.new(self.overlay)
self.stats_handler = StatsHandler(overlay_bar=self.stats_overlay, buffer=self.buffer)
self.stats_handler.update_default_stat()
self.add(self.overlay)
self.font_desc = Pango.FontDescription()
self.spellchecker = GtkSpell.Checker()
self.search_settings = GtkSource.SearchSettings(wrap_around=True)
self.search_context = GtkSource.SearchContext(buffer=self.buffer, settings=self.search_settings)
self.search_iter = None
def add_tab(self, label=None, buffer_text=None, path=None):
text_buffer = GtkSource.Buffer()
lang_manager = GtkSource.LanguageManager.get_default()
if hasattr(lang_manager, 'list_languages'):
langs = lang_manager.list_languages()
else:
lang_ids = lang_manager.get_language_ids()
langs = [lang_manager.get_language(lang_id)
for lang_id in lang_ids]
for lang in langs:
for m in lang.get_mime_types():
if m == 'text/x-python':
text_buffer.set_language(lang)
if hasattr(text_buffer, 'set_highlight'):
text_buffer.set_highlight(True)
else:
text_buffer.set_highlight_syntax(True)
if buffer_text:
text_buffer.set_text(buffer_text)
text_buffer.set_modified(False)
text_view = GtkSource.View()
text_view.set_buffer(text_buffer)
text_view.set_size_request(0, int(Gdk.Screen.height() * 0.5))
text_view.set_editable(True)
text_view.set_cursor_visible(True)
text_view.set_show_line_numbers(True)
text_view.set_wrap_mode(Gtk.WrapMode.CHAR)
text_view.set_insert_spaces_instead_of_tabs(True)
text_view.set_tab_width(2)
text_view.set_auto_indent(True)
text_view.modify_font(
Pango.FontDescription('Monospace ' +
str(font_zoom(style.FONT_SIZE))))
codesw = Gtk.ScrolledWindow()
codesw.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
codesw.add(text_view)
text_view.show()
text_view.set_can_focus(True)
text_view.grab_focus()
tabdex = self.get_n_pages() + 1
if label:
self.tablabel = TabLabel(codesw, label, path, self)
else:
self.tablabel = TabLabel(codesw,
_('New Source File %d' % tabdex),
path, self)
self.tablabel.connect('tab-close', self._tab_closed_cb)
self.connect('key-press-event', self._key_press_cb)
codesw.show_all()
index = self.append_page(codesw, self.tablabel)
self.props.page = index # Set new page as active tab
def __init__(self, core, textviews):
super(ReprTextView, self).__init__(False, 1)
#################################################################
# Right Textview
#################################################################
self.uicore = core
self.textviews = textviews
# Use GtkSourceView to add eye candy :P
# create buffer
lm = GtkSource.LanguageManager()
# Add ui dir to language paths
paths = lm.get_search_path()
paths.append(os.path.dirname(__file__) + os.sep + 'data' + os.sep)
lm.set_search_path(paths)
self.buffer = GtkSource.Buffer()
self.buffer.create_tag("green-background",
background="green",
foreground="black")
self.buffer.set_data('languages-manager', lm)
self.view = GtkSource.View(self.buffer)
# FIXME options must be user selectable (statusbar)
self.view.set_editable(False)
self.view.set_highlight_current_line(True)
# posible values: Gtk.WrapMode.NONE, Gtk.WrapMode.CHAR, Gtk.WrapMode.WORD...
self.view.set_wrap_mode(Gtk.WrapMode.WORD)
# setup view
font_desc = Pango.FontDescription('monospace 9')
if font_desc:
self.view.modify_font(font_desc)
self.buffer.set_highlight_syntax(False)
manager = self.buffer.get_data('languages-manager')
language = manager.get_language('asm')
self.buffer.set_language(language)
self.mgr = GtkSource.StyleSchemeManager.get_default()
# Scrolled Window
self.repr_scrolled_window = Gtk.ScrolledWindow()
self.repr_scrolled_window.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
self.repr_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.repr_scrolled_window.show()
# Add Textview to Scrolled Window
self.repr_scrolled_window.add(self.view)
self.pack_start(self.repr_scrolled_window, expand=True, fill=True)
# Create the search widget
Searchable.__init__(self, self.view, small=True)
# Used for code navidation on _search function
self.match_start = None
self.match_end = None
self.search_string = ''
def add_completion(self, header, words_arr):
keybuff = GtkSource.Buffer()
keybuff.begin_not_undoable_action()
keybuff.set_text('\n'.join(words_arr))
keybuff.end_not_undoable_action()
autocomplete = GtkSource.CompletionWords.new(header)
autocomplete.register(keybuff)
self.custom_completors.append(autocomplete)
def __init__(self):
GtkSource.View.__init__(self)
self.set_buffer(GtkSource.Buffer())
from gi.repository import Pango
self.modify_font(Pango.FontDescription('Monospace 10'))
self.show_all()
def do_query_tooltip(self, it, area, x, y, tooltip):
line = it.get_line() + 1
line_context = self.file_context.get(line, None)
if line_context is None:
return False
# Check that the context is the same not the line this
# way contexts that span multiple times are handled correctly
if self.file_context.get(self.tooltip_line, None) is line_context:
tooltip.set_custom(None)
tooltip.set_custom(self.tooltip)
return True
if line_context.line_type not in (
DiffType.REMOVED,
DiffType.MODIFIED,
):
return False
tooltip_buffer = GtkSource.Buffer()
tooltip_view = GtkSource.View.new_with_buffer(tooltip_buffer)
# Propagate the view's settings
content_view = self.get_view()
tooltip_view.set_indent_width(content_view.get_indent_width())
tooltip_view.set_tab_width(content_view.get_tab_width())
# Propagate the buffer's settings
content_buffer = content_view.get_buffer()
tooltip_buffer.set_highlight_syntax(
content_buffer.get_highlight_syntax())
tooltip_buffer.set_language(content_buffer.get_language())
tooltip_buffer.set_style_scheme(content_buffer.get_style_scheme())
# Fix some styling issues
tooltip_buffer.set_highlight_matching_brackets(False)
tooltip_view.set_border_width(4)
tooltip_view.set_cursor_visible(False)
# Set the font
content_style_context = content_view.get_style_context()
content_font = content_style_context.get_font(Gtk.StateFlags.NORMAL)
tooltip_view.override_font(content_font)
# Only add what can be shown, we
# don't want to add hundreds of lines
allocation = content_view.get_allocation()
lines = allocation.height // area.height
removed = "\n".join(map(str, line_context.removed_lines[:lines]))
tooltip_buffer.set_text(removed)
# Avoid having to create the tooltip multiple times
self.tooltip = tooltip_view
self.tooltip_line = line
tooltip.set_custom(tooltip_view)
return True
def set_archivo(self, archivo):
"""
Setea el archivo cuyo codigo debe mostrarse.
"""
if archivo and archivo != None:
archivo = os.path.join(archivo.replace("//", "/"))
if os.path.exists(archivo):
self.archivo = archivo
texto_file = open(self.archivo, 'r')
texto = texto_file.read()
texto_file.close()
self.set_buffer(GtkSource.Buffer())
self.get_buffer().begin_not_undoable_action()
self.__set_lenguaje(archivo)
self.get_buffer().set_text(texto)
nombre = os.path.basename(self.archivo)
GObject.idle_add(self.__set_label, nombre)
self.control = os.path.getmtime(self.archivo)
else:
self.set_buffer(GtkSource.Buffer())
self.get_buffer().begin_not_undoable_action()
self.get_buffer().end_not_undoable_action()
self.get_buffer().set_modified(False)
completion = self.get_completion()
prov_words = GtkSource.CompletionWords.new(None, None)
prov_words.register(self.get_buffer())
autocompletado = AutoCompletado(self.get_buffer(), self.archivo, self)
completion.add_provider(autocompletado)
completion.set_property("remember-info-visibility", True)
completion.set_property("select-on-show", True)
completion.set_property("show-headers", True)
completion.set_property("show-icons", True)
self.new_handle(True)
