def __init__(self, *a, **kw):
gtksourceview.View.__init__(self, *a, **kw)
self.filename = None
self.mark = None
self.offset = 0
self.program_length = 0
self.buf = gtksourceview.Buffer()
self.buf.set_max_undo_levels(20)
self.buf.connect('changed', self.update_iter)
self.set_buffer(self.buf)
self.lm = gtksourceview.LanguageManager()
if 'EMC2_HOME' in os.environ:
path = os.path.join(os.environ['EMC2_HOME'],
'share/gtksourceview-2.0/language-specs/')
self.lm.set_search_path(self.lm.get_search_path() + [path])
self.buf.set_language(self.lm.get_language('.ngc'))
self.set_show_line_numbers(True)
self.set_show_line_marks(True)
self.set_highlight_current_line(True)
self.set_mark_category_icon_from_icon_name('motion', 'gtk-forward')
self.set_mark_category_background('motion', gtk.gdk.Color('#ff0'))
self.found_text_tag = self.buf.create_tag(background="yellow")
self.update_iter()
self.connect('button-release-event', self.button_pressed)
def setup_bugview(self):
self.bugbuf = gtksourceview2.Buffer()
lm = gtksourceview2.LanguageManager()
lang = lm.guess_language(None, "text/x-lua")
self.bugbuf.set_highlight_syntax(True)
self.bugbuf.set_language(lang)
def set_bt_markers(blubb):
begin, end = self.bugbuf.get_bounds()
self.bugbuf.remove_source_marks(begin, end)
for creature, line in self.conn.bt:
if line:
self.bugbuf.create_source_mark(None, "bt", line)
self.conn.connect("new_bt", set_bt_markers)
self.bugview = gtksourceview2.View(self.bugbuf)
self.bugview.props.show_line_numbers = True
self.bugview.props.show_line_marks = True
self.bugview.props.auto_indent = True
#self.bugview.props.insert_spaces_instead_of_tabs = True
icon = gtk.gdk.pixbuf_new_from_file(PREFIX + 'marker.png')
self.bugview.set_mark_category_pixbuf("bt", icon)
def create_tbtv(lang="python"):
# rely on gtksourceview2
if usegtksv2:
tb = gtksourceview2.Buffer()
tv = gtksourceview2.View(tb)
if lang == "python":
lm = gtksourceview2.LanguageManager()
lp = lm.get_language(lang)
tb.set_language(lp)
tb.set_highlight_syntax(True)
tb.set_max_undo_levels(16)
tb.set_highlight_matching_brackets(False)
tv.set_show_line_marks(True)
tv.set_show_line_numbers(True)
tv.set_draw_spaces(True)
tv.set_tab_width(4)
tv.set_smart_home_end(True)
tv.set_auto_indent(True)
tv.set_property("draw-spaces",51) # space, tab, leading, text
else:
tv = gtk.TextView()
tb = tv.get_buffer()
fontdesc = pango.FontDescription("Monospace")
tv.modify_font(fontdesc)
return tb,tv
def _init_source_view(self):
# Creating the buffer.
self._source_buffer = gtksourceview.Buffer()
self._source_buffer.connect('changed', self.on_source_buffer_changed)
self._source_buffer.connect('modified-changed',
self.on_source_buffer_modified_changed)
self._source_buffer.set_highlight_matching_brackets(True)
manager = gtksourceview.LanguageManager()
manager.set_search_path(
[os.path.join(self._data_dir, 'gtksourceview')])
language = manager.get_language('tiger')
self._source_buffer.set_language(language)
self._source_buffer.set_highlight_syntax(True)
self._update_undo_redo()
# Creating the viewer.
self._source_view = gtksourceview.View(self._source_buffer)
self._source_view.modify_font(pango.FontDescription('monospace'))
self._source_view.set_show_line_numbers(True)
self._source_view.set_show_line_marks(False)
self._source_view.set_show_right_margin(False)
self._source_view.set_insert_spaces_instead_of_tabs(False)
self._source_view.set_highlight_current_line(True)
self._source_view.set_auto_indent(True)
# Add the source view to the window.
scrolledwindow = self._builder.get_object('source_scrolledwindow')
scrolledwindow.add(self._source_view)
def __init__(self, config):
gtksourceview2.View.__init__(self)
self.actualizador = False
self.control = False
self.archivo = False
self.lenguaje = False
self.tab = " "
self.set_show_line_numbers(config['numeracion'])
self.lenguaje_manager = gtksourceview2.LanguageManager()
self.lenguajes = {}
for id in self.lenguaje_manager.get_language_ids():
lang = self.lenguaje_manager.get_language(id)
self.lenguajes[id] = lang.get_mime_types()
self.set_insert_spaces_instead_of_tabs(True)
self.set_tab_width(4)
self.set_auto_indent(True)
font = "%s %s" % (config['fuente'], config['tamanio'])
self.modify_font(pango.FontDescription(font))
self.show_all()
self.connect("key-press-event", self.__key_press_event)
def _create_buffer(self, key, sections, head_paragraph):
manager = gtksourceview.LanguageManager()
lan = manager.get_language(key)
buffer = textbuffer.Buffer()
buffer.create_tag("fixed", editable=False, background="lightgray")
buffer.create_tag("normal")
buffer.begin_not_undoable_action()
if head_paragraph:
buffer.create_tag("fixed-paragraph",
editable=False,
paragraph_background="lightgray")
buffer.insert_with_tags_by_name(buffer.get_end_iter(),
head_paragraph, "fixed-paragraph")
for name, start_string, middle_string, end_string in sections:
self._create_section(buffer, name, start_string, middle_string,
end_string)
buffer.end_not_undoable_action()
buffer.set_language(lan)
buffer.set_highlight_syntax(True)
buffer.set_highlight_matching_brackets(True)
buffer.connect("changed", lambda w: self.buffer_changed())
self.buffer = buffer
return buffer
def add_text_view(self):
scrolledWindow = self.add_scrolled_window()
self.set_child_packing(self.frame, True, True, 0, gtk.PACK_START)
try:
import gtksourceview2
buf = gtksourceview2.Buffer()
lang_manager = gtksourceview2.LanguageManager()
buf.set_highlight_matching_brackets(True)
if self.node is not None and self.node.is_python_code():
python = lang_manager.get_language("python")
buf.set_language(python)
buf.set_highlight_syntax(True)
textview = gtksourceview2.View(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_python_code():
textview.set_show_line_numbers(True)
font_desc = pango.FontDescription("monospace")
if font_desc:
textview.modify_font(font_desc)
except ImportError:
textview = gtk.TextView()
textview.set_pixels_above_lines(2)
textview.set_pixels_below_lines(2)
textview.set_wrap_mode(gtk.WRAP_WORD)
textview.connect("focus-in-event", self.entry_focus_in)
scrolledWindow.add(textview)
textview.show()
return textview
def __init__ (self, get_file_fn, languages = []):
self.get_fn = get_file_fn
man = gtksourceview2.LanguageManager()
language = None
old_lang = None
for lang in languages:
if old_lang:
warning(_("No %(old)s language file installed. Falling back to %(new)s."), {"old" : old_lang, "new" : lang})
language = man.get_language(lang)
if language:
break
else:
old_lang = lang
if not language and old_lang:
warning(_("No %(old)s language file installed. Disabling highlighting."), {"old" : old_lang})
buf = gtksourceview2.Buffer()
buf.set_language(language)
gtksourceview2.View.__init__(self, buf)
LazyView.__init__(self)
self.set_editable(False)
self.set_cursor_visible(False)
def __init__(self, *a, **kw):
gtksourceview.View.__init__(self, *a, **kw)
self.filename = None
self.mark = None
self.offset = 0
self.program_length = 0
self.idle_line_reset = True
self.buf = gtksourceview.Buffer()
self.buf.set_max_undo_levels(20)
self.buf.connect('changed', self.update_iter)
self.set_buffer(self.buf)
self.lm = gtksourceview.LanguageManager()
self.sm = gtksourceview.StyleSchemeManager()
if 'EMC2_HOME' in os.environ:
path = os.path.join(os.environ['EMC2_HOME'],
'share/gtksourceview-2.0/language-specs/')
self.lm.set_search_path(self.lm.get_search_path() + [path])
self.buf.set_language(self.lm.get_language('.ngc'))
self.set_show_line_numbers(True)
self.set_show_line_marks(True)
self.set_highlight_current_line(True)
# This gets the 'selected text' color
# This is before the widget is realized so gives the system theme color
style = self.get_style()
selected_color = style.base[gtk.STATE_SELECTED].to_string()
self.set_mark_category_icon_from_icon_name('motion', 'gtk-forward')
self.set_mark_category_background('motion',
gtk.gdk.Color(selected_color))
self.found_text_tag = self.buf.create_tag(background=selected_color)
self.update_iter()
self.connect('button-release-event', self.button_pressed)
def __init__(self, ventana, notebook, firmware_ruta, nombre_arch,
etiqueta):
# create buffer
lm = gtksourceview2.LanguageManager()
self.buffer = gtksourceview2.Buffer()
self.buffer.set_data('languages-manager', lm)
self.firmware_ruta = firmware_ruta
self.nombre_arch = nombre_arch
view = gtksourceview2.View(self.buffer)
view.set_show_line_numbers(True)
self.ventana = ventana
vbox = gtk.VBox(0, True)
notebook.append_page(vbox, gtk.Label(etiqueta))
tool1 = gtk.Toolbar()
tool1.show()
iconw = gtk.Image()
iconw.set_from_stock(gtk.STOCK_EXECUTE, 15)
vbox.pack_start(tool1, fill=False, expand=False)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(view)
vbox.pack_start(sw, fill=True, expand=True)
vbox.show_all()
# main loop
self.dir_conf = os.path.expanduser(
'~') + "/" + self.firmware_ruta + "/firmware/"
self.cadena_user_c = self.dir_conf + self.nombre_arch
self.buf = self.open_file(self.buffer, self.cadena_user_c)
iconw = gtk.Image()
iconw.set_from_stock(gtk.STOCK_NEW, 15)
tool_button = tool1.append_item("recargar", "", "Private", iconw,
self.recargar)
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 = gtksourceview2.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 = gtksourceview2.Buffer()
self.buffer.create_tag("green-background",
background="green",
foreground="black")
self.buffer.set_data('languages-manager', lm)
self.view = gtksourceview2.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.WRAP_NONE, gtk.WRAP_CHAR, gtk.WRAP_WORD...
self.view.set_wrap_mode(gtk.WRAP_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 = gtksourceview2.style_scheme_manager_get_default()
# Scrolled Window
self.repr_scrolled_window = gtk.ScrolledWindow()
self.repr_scrolled_window.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.repr_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_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 init_sourceview(self):
sv = self.sourceview
sb = self.sourcebuffer
lm = gtksourceview2.LanguageManager()
python = lm.get_language('python')
sb.set_language(python)
self.scrolledwindow_sourceview.add(sv)
sv.show()
def __init__(self, preview=False):
gobject.GObject.__init__(self)
self.is_preview = preview
# Module init
self.prefs = Preferences
self.keyboard = Keyboard
# create buffer
self.buf = gtksourceview.Buffer()
self.gtksourceview = gtksourceview.View(self.buf)
# setup style and lang managers
self.lm = gtksourceview.LanguageManager()
self.sm = gtksourceview.StyleSchemeManager()
self.lm.set_search_path([LANGDIR])
self.sm.set_search_path([STYLEDIR])
self.buf.set_style_scheme(self.sm.get_scheme('gcode'))
self.buf.set_language(self.lm.get_language('gcode'))
self.buf.set_max_undo_levels(20)
self.gtksourceview.set_show_line_numbers(True)
self.gtksourceview.set_show_line_marks(False)
self.gtksourceview.set_highlight_current_line(False)
# Only allow edit if gcode preview
self.gtksourceview.set_editable(self.is_preview)
self.holder_text = "\t\t\t****No file to preview****"
# Only highlight motion line if not preview
if not self.is_preview:
self.gtksourceview.set_can_focus(False)
self.holder_text = ""
self.gtksourceview.connect('button-press-event', self.on_button_press)
self.gtksourceview.connect('key-press-event', self.on_key_press)
# Set line highlight styles
self.gtksourceview.set_mark_category_background(
'none', gtk.gdk.Color('#ffffff'))
self.gtksourceview.set_mark_category_background(
'motion', gtk.gdk.Color('#c5c5c5'))
self.gtksourceview.set_mark_category_background(
'selected', gtk.gdk.Color('#96fef6'))
self.gtksourceview.set_mark_category_background(
'error', gtk.gdk.Color('#ff7373'))
self.mark = None
self.current_file = None
self.error_line = None
self.gtksourceview.show()
def __init__(self,ventana):
# create buffer
lm = gtksourceview2.LanguageManager()
buffer = gtksourceview2.Buffer()
buffer.set_data('languages-manager', lm)
view = gtksourceview2.View(buffer)
self.ventana=ventana
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_border_width(0)
self.window.set_title('codigo fuente generado por el sistema')
#windows.append(window) # this list contains all view windows
self.window.set_default_size(500, 500)
self.window.show()
vbox = gtk.VBox(0, True)
self.window.add(vbox)
tool1=gtk.Toolbar()
tool1.show()
iconw = gtk.Image()
iconw.set_from_stock(gtk.STOCK_EXECUTE,15)
tool_button = tool1.append_item(
_("Compile"),
"compila la version modificada en el editor.",
"Private",
iconw,
self.compilar)
iconw = gtk.Image()
iconw.set_from_stock(gtk.STOCK_NEW,15)
tool_button = tool1.append_item(
_("Exit"),
self.ventana.tooltip["salir"],
"Private",
iconw,
self.close)
vbox.pack_start(tool1, fill=False, expand=False)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(view)
vbox.pack_start(sw, fill=True, expand=True)
#~
#~ toolbar = gtk.HBox(spacing=0)
#~ vbox.pack_start(toolbar,False,False)
#~ button = gtk.Button('salir')
#~ button.connect('clicked',self.close)
#~ toolbar.pack_start(button,False,False,0)
vbox.show_all()
# main loop
dir_conf=os.path.expanduser('~') + "/.icaro/np05/"
cadena_user_c=dir_conf+"source/user.c"
self.buf=self.open_file(buffer,cadena_user_c)
def __set_octave_enviroment(self, p_active):
#FIXME: documentacion
doc = self.__doc
view = self.__view
octave_env = self.__octave_env
if p_active and not octave_env:
# Estableciendo lenguaje
manager = gtksourceview2.LanguageManager()
doc.set_language(manager.get_language("octave"))
# Estableciendo indentado automatico
view.set_auto_indent(True)
# Mostrando breakpoints
self.__set_show_breakpoints(True)
# Mostrando arrows
self.__set_show_arrows(True)
# Mostrando folding
self.__set_show_folding(True)
# Parsear
self.__document_changed_handler_id = doc.connect(
"changed", self.__on_document_changed)
self.__timeout_add()
elif not p_active and octave_env:
# Quitando lenguaje
doc.set_language(None)
# Quitando indentado automatico
view.set_auto_indent(False)
# Ocultando breakpoints
self.__set_show_breakpoints(False)
# Ocultando arrows
self.__set_show_arrows(False)
# Ocultando folding
self.__set_show_folding(False)
# No parsear
doc.disconnect(self.__document_changed_handler_id)
self.__remove_timeout()
self.__parse_result = None
if octave_env != p_active:
self.__octave_env = p_active
self.__update_locked()
self.emit("octave_mode_toggled", p_active)
def get_language_manager():
global manager
if not manager:
dirs = []
for d in Library().systemdirs:
dirs.append(os.path.join(d, 'lang'))
manager = gsv.LanguageManager()
manager.set_search_path(dirs + manager.get_search_path())
return manager
def __init__(self, *args, **kwargs):
gtksourceview2.View.__init__(self, *args, **kwargs)
#self.set_overwrite(True)
#self.set_show_line_marks(True)
self.set_editable(False)
self.set_wrap_mode(gtk.WRAP_WORD)
self.buffers = {}
self.breakpoints = {}
self.pos = None
self.set_position(None)
self.set_mark_category_background('position', COLOR_CUR_POS)
self.set_mark_category_background('breakpoint', COLOR_BREAKPOINT)
self.langman = gtksourceview2.LanguageManager()
def init_languages(self, languages):
manager = gsv.LanguageManager()
langs = pluma.language_manager_list_languages_sorted(manager, True)
self.model.append([_('All languages'), None, not languages])
self.model.append(['-', None, False])
self.model.append([_('Plain Text'), 'plain', 'plain' in languages])
self.model.append(['-', None, False])
for lang in langs:
self.model.append(
[lang.get_name(),
lang.get_id(),
lang.get_id() in languages])
def new_apache_sourceview():
bufferS = gtksourceview2.Buffer()
manager = gtksourceview2.LanguageManager()
#language = manager.get_language_from_mime_type("text/xml")
manager.set_search_path([Configuration.GLADEPATH] +
manager.get_search_path())
language = manager.get_language('apache')
bufferS.set_language(language)
bufferS.set_highlight_syntax(True)
sourceview = gtksourceview2.View(bufferS)
sourceview.set_show_line_numbers(True)
#TODO sniff gnome default monospace font
sourceview.modify_font(pango.FontDescription("monospace 10"))
return sourceview
def fill_languages_button(self):
if not self.current_node or not self.current_node.languages:
self['languages_label'].set_text(_('All Languages'))
else:
manager = gsv.LanguageManager()
langs = []
for lang in self.current_node.languages:
if lang == 'plain':
langs.append(_('Plain Text'))
else:
l = manager.get_language(lang)
if l:
langs.append(l.get_name())
self['languages_label'].set_text(', '.join(langs))
def add_tool(self, tool):
manager = gsv.LanguageManager()
ret = None
for lang in tool.languages:
l = manager.get_language(lang)
if l:
ret = self.add_tool_to_language(tool, l)
elif lang == 'plain':
ret = self.add_tool_to_language(tool, 'plain')
if not ret:
ret = self.add_tool_to_language(tool, None)
self.add_accelerator(tool)
return ret
def main(args):
# create buffer
lm = gtksourceview2.LanguageManager()
buffer = gtksourceview2.Buffer()
buffer.set_data('languages-manager', lm)
# parse arguments
if len(args) >= 2:
open_file(buffer, args[1])
# create first window
window = create_main_window(buffer)
window.set_default_size(1000, 1000)
window.show()
# main loop
gtk.main()
def __init__(self, *a, **kw):
gtksourceview.View.__init__(self, *a, **kw)
self.filename = None
self.mark = None
self.buf = gtksourceview.Buffer()
self.set_buffer(self.buf)
lm = gtksourceview.LanguageManager()
if 'EMC2_HOME' in os.environ:
path = os.path.join(os.environ['EMC2_HOME'],
'share/gtksourceview-2.0/language-specs/')
lm.set_search_path(lm.get_search_path() + [path])
self.buf.set_language(lm.get_language('.ngc'))
self.set_show_line_numbers(True)
self.set_show_line_marks(True)
self.set_highlight_current_line(True)
self.set_mark_category_icon_from_icon_name('motion', 'gtk-forward')
self.set_mark_category_background('motion', gtk.gdk.Color('#f44'))
def __init__(self, get_file_fn, languages=[]):
"""@param get_file_fn: function to return a filename from a pkg object
@param get_file_fn: if None, then it will use pkg as the filename to show
@param languages: list of languages to use for highlighting eg. ['gentoo', 'shell']
"""
if get_file_fn:
self.get_fn = get_file_fn
else: # assume it is passed a filename already
self.get_fn = self._get_fn
man = gtksourceview2.LanguageManager()
language = None
old_lang = None
for lang in languages:
if old_lang:
debug.dprint(
"HIGHLIGHT: No %(old)s language file installed. Falling back to %(new)s."
% {
"old": old_lang,
"new": lang
})
language = man.get_language(lang)
if language:
break
else:
old_lang = lang
if not language and old_lang:
debug.dprint(
"HIGHLIGHT: No %(old)s language file installed. Disable highlighting."
% {"old": old_lang})
buf = gtksourceview2.Buffer()
buf.set_language(language)
gtksourceview2.View.__init__(self, buf)
LazyView.__init__(self)
self.set_editable(False)
self.set_cursor_visible(False)
def __init__(self, w3af):
gtk.VBox.__init__(self)
self.is_request = True
self.w3af = w3af
# Create the textview where the text is going to be shown
self.textView = gtksourceview.View(gtksourceview.Buffer())
# User controlled options
self.textView.set_highlight_current_line(False)
self.textView.set_show_line_numbers(False)
# Other options
# Font
self.set_wrap(True)
self.textView.set_border_width(5)
fontDesc = pango.FontDescription('monospace')
if fontDesc:
self.textView.modify_font(fontDesc)
# Syntax highlight
self._lang_man = gtksourceview.LanguageManager()
spath = self._lang_man.get_search_path()
spath.append('core' + os.path.sep + 'ui' + os.path.sep + 'gui')
self._lang_man.set_search_path(spath)
self.set_language('http')
#b.set_highlight_syntax(True)
self.reset_bg_color()
for sev in SEVERITY_TO_COLOR:
self.textView.get_buffer(
).create_tag(sev, background=SEVERITY_TO_COLOR[sev])
self.textView.show()
# Scroll where the textView goes
sw1 = gtk.ScrolledWindow()
sw1.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw1.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw1.add(self.textView)
sw1.show()
self.pack_start(sw1, expand=True, fill=True)
# Create the search widget
Searchable.__init__(self, self.textView, small=True)
def __init__(self, window, handler):
gtk.Dialog.__init__(
self,
title=_('Quick Highlight Mode'),
parent=window,
flags=gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_NO_SEPARATOR | gtk.DIALOG_MODAL
)
self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
self._ok_button = self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
self._lang_manager = gtksourceview2.LanguageManager()
self._lang_ids = self._lang_manager.get_language_ids()
self._handler = handler
self._cursor = None
self._build_ui()
ag = gtk.AccelGroup()
ag.connect_group(gtk.keysyms.l, gtk.gdk.CONTROL_MASK, 0, self.on_focus_entry)
self.add_accel_group(ag)
def _init_code_view(self):
# Creating the buffer.
code_buffer = gtksourceview.Buffer()
code_buffer.set_highlight_matching_brackets(True)
manager = gtksourceview.LanguageManager()
manager.set_search_path([os.path.join(self._data_dir, 'gtksourceview')])
language = manager.get_language('c')
code_buffer.set_language(language)
code_buffer.set_highlight_syntax(True)
# Creating the viewer.
code_view = gtksourceview.View(code_buffer)
code_view.modify_font(pango.FontDescription('monospace'))
code_view.set_show_line_numbers(True)
code_view.set_show_line_marks(False)
code_view.set_show_right_margin(False)
code_view.set_editable(False)
code_view.set_highlight_current_line(True)
# Add the source view to the window.
scrolledwindow = self._builder.get_object('scrolledwindow')
scrolledwindow.add(code_view)
# Setting the text of the buffer.
with open(self._c_filename) as fd:
code_buffer.set_text(fd.read())
def main(args):
# create buffer
lm = gtksourceview2.LanguageManager()
sm = gtksourceview2.StyleSchemeManager()
buffer = gtksourceview2.Buffer()
buffer.set_data('languages-manager', lm)
buffer.set_data('styles-scheme-manager', sm)
# parse arguments
if len(args) >= 2:
open_file(buffer, args[1])
else:
sys.exit("Aucun argument")
open_file(buffer, args[0])
# create first window
window = create_main_window(buffer)
window.set_default_size(683, 700)
# window.set_icon_from_file("/home/lilian/.mocaml/.mocamlViewFile.jpg")
window.show()
# main loop
gtk.main()
import pango
try:
import gtksourceview2
except:
gtksourceview2 = None
from zim.plugins import PluginClass, WindowExtension, extends
from zim.actions import action
from zim.objectmanager import ObjectManager, CustomObjectClass
from zim.gui.widgets import Dialog
from zim.gui.pageview import CustomObjectBin, POSITION_BEGIN, POSITION_END
from zim.formats.html import html_encode
lm = gtksourceview2.LanguageManager()
lang_ids = lm.get_language_ids()
lang_names = [lm.get_language(i).get_name() for i in lang_ids]
LANGUAGES = dict((lm.get_language(i).get_name(), i) for i in lang_ids)
#~ print LANGUAGES
OBJECT_TYPE = 'code'
class SourceViewPlugin(PluginClass):
plugin_info = {
'name': _('Source View'), # T: plugin name
'description': _('''\
This plugin allows inserting 'Code Blocks' in the page. These will be
def __init__(self):
builder = gtk.Builder()
builder.add_from_file('gui.glade')
builder.connect_signals(self)
self.window = builder.get_object('window')
self.toolbutton_run = builder.get_object('toolbutton_run')
self.toolbutton_abort = builder.get_object('toolbutton_abort')
self.main_notebook = builder.get_object('main_notebook')
self.left_notebook = builder.get_object('left_notebook')
self.templates_menu_item = builder.get_object(
'imagemenuitem_new_template')
submenu = self.create_templates_menu()
self.templates_menu_item.set_submenu(submenu)
self.textbuffer_script = gtksourceview2.Buffer()
lm = gtksourceview2.LanguageManager()
lang = lm.get_language('python')
self.textbuffer_script.set_highlight_syntax(True)
self.textbuffer_script.set_language(lang)
#syntax_loader = SyntaxLoader('python')
#self.textbuffer_script = CodeBuffer(None, syntax_loader)
self.textbuffer_script.connect('delete-range',
self.on_textbuffer_script_delete_range)
self.textbuffer_script.connect('insert-text',
self.on_textbuffer_script_insert_text)
self.source_view = gtksourceview2.View(self.textbuffer_script)
self.source_view.set_auto_indent(True)
self.source_view.set_indent_on_tab(True)
self.source_view.set_indent_width(2)
self.source_view.set_insert_spaces_instead_of_tabs(True)
self.source_view.set_show_line_numbers(True)
self.source_view.set_smart_home_end(True)
self.source_view.set_show_line_marks(True)
scheme = gtksourceview2.style_scheme_manager_get_default().get_scheme(
'tango')
self.textbuffer_script.set_style_scheme(scheme)
self.source_view.set_show_line_marks(True)
font_desc = pango.FontDescription('monospace 10')
if font_desc:
self.source_view.modify_font(font_desc)
#self.source_view = gtk.TextView(self.textbuffer_script)
self.source_view.set_size_request(500, -1)
scrolled_win = gtk.ScrolledWindow()
scrolled_win.show()
scrolled_win.add(self.source_view)
self.source_view.show()
self.left_notebook.append_page(scrolled_win, gtk.Label('Code'))
scrolled_win_control_box = gtk.ScrolledWindow()
scrolled_win_control_box.show()
self.left_notebook.append_page(scrolled_win_control_box,
gtk.Label('Controls'))
self.left_notebook.show_all()
self.control_box_manager = ControlBoxManager(scrolled_win_control_box)
self.control_box_manager.add_widget(
'Welcome! Use File->New from template to start a new project.',
gtk.Label())
self.left_notebook.set_current_page(1)
self.script = Script()
self.script.text_inserted += self.on_script_text_inserted
self.script.range_deleted += self.on_script_range_deleted
# configuer logging for the application:
logging.getLogger('').setLevel(logging.DEBUG)
self.textview_log = builder.get_object('textview_log')
self.gui_handler = TextViewHandler(self.textview_log)
stream_handler = logging.StreamHandler()
formatter = logging.Formatter(
"%(asctime)s - %(levelname)s - %(message)s")
self.gui_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
# Not adding by default (see view->show logs)
#logging.getLogger('').addHandler(gui_handler)
logging.getLogger('').addHandler(stream_handler)
self.file_manager = FileManager(self.script)
self.file_manager.current_file_changed += self.on_current_file_changed
self.file_manager.need_save_changed += self.on_need_save_changed
# TODO(daniv): These are ugly hacks to pervent raising events when the
# is not the user.
self.ignore_next_on_textbuffer_script_delete_range = False
self.ignore_next_on_textbuffer_script_insert_text = False
self.space_manager = SpaceManager(self.main_notebook)
self.changer_manager = ParameterChangerManager(self.script)
self.script_server = ScriptServer(self.changer_manager)
self.script_server.script_started += self.on_script_started
self.script_server.script_ended += self.on_script_ended
global services
services.init(self.space_manager,
self.changer_manager, self.script_server,
self.window.get_toplevel(), self.control_box_manager,
self.textview_log)
self._updateWindowTitle()
