def createsrcview(status, f=None):
sbuffer = gtksourceview2.Buffer()
if f:
content = file(f).read()
sbuffer.set_language(get_lang_for_content(content))
text = unicode(content, 'utf-8', 'ignore')
sbuffer.set_text(text)
else:
manager = gtksourceview2.language_manager_get_default()
sbuffer.set_language(manager.get_language("c"))
sv = gtksourceview2.View(sbuffer)
p = prefs.preferences()
misc.set_widget_font(sv, config.cur_editor_font)
manager = gtksourceview2.StyleSchemeManager()
manager.append_search_path(misc.getArduinoUiPath())
manager.force_rescan()
scheme = manager.get_scheme("arduino")
sbuffer.set_style_scheme(scheme);
sv.set_size_request(300, 100)
sv.set_editable(True)
sv.set_auto_indent(True)
if config.show_numbers == 'true':
sv.set_show_line_numbers(True)
sv.set_cursor_visible(True)
sv.set_wrap_mode(gtk.WRAP_CHAR)
sv.set_right_margin_position(80)
updatePos(sbuffer, status)
sbuffer.connect("mark_set", markCb, status)
sbuffer.connect("insert_text", instextCallback)
sv.set_highlight_current_line(True)
resetCursor(sbuffer)
return sbuffer, sv
def __init__(self):
gtk.VBox.__init__(self)
self._b = gtksourceview.Buffer()
style_scheme = gtksourceview.style_scheme_manager_get_default(
).get_scheme('classic')
if style_scheme:
self._b.set_style_scheme(style_scheme)
self._b.set_language(
gtksourceview.language_manager_get_default().get_language("cpp"))
self._b.set_highlight_syntax(True)
#self._b.connect('mark-set', move_cursor_cb, view)
#self._b.connect('changed', update_cursor_position, view)
self._v = gtksourceview.View(self._b)
self._v.set_show_line_numbers(True)
#self._v.set_show_line_marks(action.get_active())
#self._v.set_show_right_margin(action.get_active())
#self._v.set_auto_indent(action.get_active())
#self._v.set_insert_spaces_instead_of_tabs(action.get_active())
#self._v.set_tab_width(action.get_current_value())
#self._v.connect('button-press-event', button_press_cb)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_IN)
self.pack_start(sw, True, True, 0)
sw.add(self._v)
# setup view
font_desc = pango.FontDescription('monospace')
if font_desc:
self._v.modify_font(font_desc)
def __init__(self, filename, mimetype=None):
self.filename = filename
if SV2:
self.buffer = gtksourceview2.Buffer()
self.buffer.set_highlight_syntax(True)
else:
self.buffer = gtksourceview.SourceBuffer()
self.buffer.set_highlight(True)
self.buffer.set_max_undo_levels(1000)
if SV2:
self.view = gtksourceview2.View(self.buffer)
else:
self.view = gtksourceview.SourceView(self.buffer)
self.view.set_auto_indent(True)
self.view.modify_font(pango.FontDescription('Ubuntu Mono 12'))
self.view.connect('key_press_event', self.on_key_press_event)
self.touch()
language = self.get_language(mimetype)
if language:
self.buffer.set_language(language)
self.file_signature = None
self.file_text = ''
self.sync_from_disk()
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_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 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 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_view(self, buffer):
view = gtksourceview.View(buffer)
view.set_auto_indent(True)
font_desc = pango.FontDescription("monospace 10")
if font_desc:
view.modify_font(font_desc)
return view
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 make_source_view(text_buffer):
text_view = sourceview.View(text_buffer)
text_view.set_editable(True)
text_view.set_wrap_mode(gtk.WRAP_WORD)
text_view.show()
return text_view
def __init__(self, filename):
self.filename = filename
if SV2:
self.buffer = gtksourceview2.Buffer()
self.buffer.set_highlight_syntax(True)
else:
self.buffer = gtksourceview.SourceBuffer()
self.buffer.set_highlight(True)
self.buffer.set_max_undo_levels(1000)
if SV2:
self.view = gtksourceview2.View(self.buffer)
else:
self.view = gtksourceview.SourceView(self.buffer)
self.view.set_auto_indent(True)
self.view.modify_font(pango.FontDescription('monospace'))
mimetype = mimetypes.guess_type(filename)[0]
if mimetype:
self.buffer.set_language(get_language_from_mime_type(mimetype))
if not os.path.exists(filename):
open(filename, 'wb').close()
self.file_signature = None
self.file_text = ''
self.sync_from_disk()
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__(self, fullPath, activity):
"""
Do any initialization here.
"""
global mark_seq
mark_seq = 0
self.fullPath = fullPath
self._activity = activity
self.breakpoints = {}
self.embeds = {}
gtk.ScrolledWindow.__init__(self)
self.text_buffer = gtksourceview2.Buffer()
self.text_buffer.create_tag(BREAKPOINT_CAT,
background=BREAKPOINT_COLOR)
self.text_buffer.create_tag(SHELL_CAT, background=EMBEDED_SHELL_COLOR)
self.text_buffer.create_tag(TRACE_CAT,
background=EMBEDED_BREAKPOINT_COLOR)
self.text_view = gtksourceview2.View(self.text_buffer)
self.text_view.connect('button_press_event', self._pd_button_press_cb)
self.text_view.set_size_request(900, 350)
self.text_view.set_editable(True)
self.text_view.set_cursor_visible(True)
self.text_view.set_highlight_current_line(True)
self.text_view.set_show_line_numbers(True)
self.text_view.set_insert_spaces_instead_of_tabs(True)
if hasattr(self.text_view, 'set_tabs_width'):
self.text_view.set_tabs_width(4)
else:
self.text_view.set_tab_width(4)
self.text_view.set_auto_indent(True)
self.text_view.set_wrap_mode(gtk.WRAP_CHAR)
#self.text_view.modify_font(pango.FontDescription("Monospace 6.5"))
self.set_font_size(self._activity.font_size)
# We could change the color theme here, if we want to.
""" folowing does not work on build 650
mgr = gtksourceview2.StyleSchemeManager()
mgr.prepend_search_path(self._activity.pydebug_path)
_logger.debug('search path for gtksourceview is %r'%mgr.get_search_path())
"""
#build 650 doesn't seem to have the same means of specifying the search directory
if self._activity.sugar_minor > 80:
mgr = gtksourceview2.StyleSchemeManager()
else:
mgr = gtksourceview2.StyleManager()
mgr.prepend_search_path(self._activity.pydebug_path)
style_scheme = mgr.get_scheme('vibrant')
if style_scheme:
self.text_buffer.set_style_scheme(style_scheme)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.add(self.text_view)
self.text_view.show()
self.load_text()
self.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 glade_custom_handler(glade, function_name, widget_name,
str1, str2, int1, int2):
if function_name == "create_sourceview":
widget = gtksourceview2.View()
else:
debug("Unknown custom widget : %s/%s", function_name, widget_name )
widget = None
if widget:
widget.show()
return widget
def __init_gui(self, glade):
scrolledwindow6 = glade.get_widget("scrolledwindow6")
self.__gtksourceview = gtksourceview2.View()
self.__sourcebuffer = gtksourceview2.Buffer()
view = self.__gtksourceview
buff = self.__sourcebuffer
view.set_buffer(buff)
scrolledwindow6.add(view)
view.set_auto_indent(True)
view.set_highlight_current_line(True)
view.set_show_line_numbers(True)
view.set_show_line_marks(True)
view.set_show_right_margin(True)
view.set_insert_spaces_instead_of_tabs(True)
view.set_tab_width(4)
view.set_indent_width(-1)
view.set_right_margin_position(80)
view.set_smart_home_end(True)
view.set_indent_on_tab(True)
view.set_left_margin(2)
view.set_right_margin(2)
view.modify_font(pango.FontDescription("mono 10"))
view.set_wrap_mode(gtk.WRAP_NONE)
# playhead text attributes
tag = buff.create_tag("playhead")
tag.props.background = "black"
tag.props.background_set = True
tag.props.foreground = "white"
tag.props.foreground_set = True
# error text attributes
tag = buff.create_tag("error")
tag.props.background = "red"
tag.props.background_set = True
# playhead marker
self.LINE_MARKER = 'lineMarker'
pixbuf = gtk.gdk.pixbuf_new_from_file(Glob.LINE_MARKER)
view.set_mark_category_pixbuf(self.LINE_MARKER, pixbuf)
# error marker
self.ERROR_MARKER = 'errorMarker'
pixbuf = gtk.gdk.pixbuf_new_from_file(Glob.ERROR_MARKER)
view.set_mark_category_pixbuf(self.ERROR_MARKER, pixbuf)
# buff parameters
buff.set_highlight_syntax(True)
buff.set_highlight_matching_brackets(True)
buff.set_max_undo_levels(50)
# when buff modified save needed
buff.connect("modified-changed", self.__modified_changed)
# and show it
self.__gtksourceview.show()
def __init__(self, obj, buffer):
CustomObjectWidget.__init__(self)
self.set_has_cursor(True)
self.buffer = buffer
self.obj = obj
self.view = gtksourceview2.View(self.buffer)
self.view.modify_font(pango.FontDescription('monospace'))
self.view.set_auto_indent(True)
self.view.set_smart_home_end(True)
self.view.set_highlight_current_line(True)
self.view.set_right_margin_position(80)
self.view.set_show_right_margin(True)
self.view.set_tab_width(4)
# simple toolbar
#~ bar = gtk.HBox() # FIXME: use gtk.Toolbar stuff
#~ lang_selector = gtk.combo_box_new_text()
#~ lang_selector.append_text('(None)')
#~ for l in lang_names: lang_selector.append_text(l)
#~ try:
#~ lang_selector.set_active(lang_ids.index(self._attrib['lang'])+1)
#~ self.set_language(self._attrib['lang'] or None, False)
#~ except (ValueError, KeyError):
#~ lang_selector.set_active(0)
#~ self.set_language(None, False)
#~ lang_selector.connect('changed', self.on_lang_changed)
#~ bar.pack_start(lang_selector, False, False)
#~ line_numbers = gtk.ToggleButton('Line numbers')
#~ try:
#~ line_numbers.set_active(self._attrib['linenumbers']=='true')
#~ self.show_line_numbers(self._attrib['linenumbers'], False)
#~ except (ValueError, KeyError):
#~ line_numbers.set_active(True)
#~ self.show_line_numbers(True, False)
#~ line_numbers.connect('toggled', self.on_line_numbers_toggled)
#~ bar.pack_start(line_numbers, False, False)
# TODO: other toolbar options
# TODO: autohide toolbar if textbuffer is not active
# Pack everything
#~ self.vbox.pack_start(bar, False, False)
win = ScrolledWindow(self.view, gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER,
gtk.SHADOW_NONE)
# only horizontal scroll
self.vbox.pack_start(win)
# Hook up signals
self.view.connect('populate-popup', self.on_populate_popup)
self.view.connect('move-cursor', self.on_move_cursor)
def __init__(self, handle):
'''We want to set up the buffer et al. early on
sure there's early_setup, but that's not early enough
'''
self.buffer = gtksourceview.Buffer()
self.refresh_buffer = False
self.text_view = gtksourceview.View(self.buffer)
self.scrollwindow = gtk.ScrolledWindow()
self.scrollwindow.add(self.text_view)
sugar_tools.GroupActivity.__init__(self, handle)
def __init__(self, token, uuid, **args):
gtk.Window.__init__(self, **args)
self.token = token
self.uuid = uuid
self.timer = -1
self.set_title('Kobita')
self.connect('show', self.on_show)
self.set_default_size(800, 600)
self.set_border_width(5)
hbox = gtk.HBox(True, 5)
vbox = gtk.VBox(False, 5)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.buffer = gtksourceview2.Buffer()
self.buffer.set_max_undo_levels(1000)
self.buffer.connect('changed', self.on_changed)
self.edit = gtksourceview2.View(self.buffer)
sw.add(self.edit)
vbox.pack_start(sw, True, True, 0)
hhbox = gtk.HBox(False, 5)
self.tags = []
for n in range(5):
tag = gtk.Entry()
tag.set_usize(20, -1)
hhbox.add(tag)
self.tags.append(tag)
vbox.pack_start(hhbox, False, False, 0)
hhbox = gtk.HBox(True, 5)
self.check = gtk.CheckButton('Private')
hhbox.add(self.check)
button = gtk.Button("Publish")
button.connect('clicked', self.on_publish)
hhbox.add(button)
vbox.pack_end(hhbox, False, False, 0)
hbox.pack_start(vbox, False, True, 0)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.view = webkit.WebView()
self.view.set_settings(settings)
sw.add(self.view)
hbox.pack_start(sw, False, True, 0)
self.add(hbox)
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 setup_editor(self):
self.lang = "js"
self.content_pane = self.wTree.get_widget("text_scroll")
self.buffer = JsBuffer()
self.editor = gtksourceview.View(self.buffer)
self.editor.set_show_line_numbers(True)
self.content_pane.add(self.editor)
self.editor.show()
accel_group = gtk.AccelGroup()
self.window.add_accel_group(accel_group)
self.editor.add_accelerator("paste-clipboard", accel_group, ord('v'),
gtk.gdk.CONTROL_MASK, 0)
self.editor.add_accelerator("copy-clipboard", accel_group, ord('c'),
gtk.gdk.CONTROL_MASK, 0)
self.editor.add_accelerator("cut-clipboard", accel_group, ord('x'),
gtk.gdk.CONTROL_MASK, 0)
def __init__(self):
gtk.ScrolledWindow.__init__(self)
self.props.hscrollbar_policy = gtk.POLICY_AUTOMATIC
self.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC
self._buffer = gtksourceview2.Buffer()
self._buffer.set_highlight_syntax(True)
self._source_view = gtksourceview2.View(self._buffer)
self._source_view.set_editable(False)
self._source_view.set_cursor_visible(True)
self._source_view.set_show_line_numbers(True)
self._source_view.set_show_right_margin(True)
self._source_view.set_right_margin_position(80)
#self._source_view.set_highlight_current_line(True) #FIXME: Ugly color
self._source_view.modify_font(_SOURCE_FONT)
self.add(self._source_view)
self._source_view.show()
self._file_path = None
def setup_source_view(self):
self._buffer = gtksourceview2.Buffer()
lang_manager = gtksourceview2.language_manager_get_default()
if 'python' in lang_manager.get_language_ids():
lang = lang_manager.get_language('python')
self._buffer.set_language(lang)
self._source_view = gtksourceview2.View(self._buffer)
self._source_view.set_editable(True)
self._source_view.set_cursor_visible(True)
self._source_view.set_show_line_numbers(True)
self._source_view.set_wrap_mode(gtk.WRAP_CHAR)
self._source_view.modify_font(pango.FontDescription("Monospace 10"))
self._source_win = gtk.ScrolledWindow()
self._source_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._source_win.add(self._source_view)
self._find_tag = self._buffer.create_tag('find')
self._find_tag.props.background = 'gray'
self._find_tag.props.foreground = 'yellow'
def __init__(self, application):
GObject.GObject.__init__(self)
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
adjustment = self.get_vadjustment()
adjustment.need_scroll = True
adjustment.connect("changed", self.update_adjustment)
adjustment.connect("value-changed", self.update_value)
self.buffer = gtksourceview.Buffer()
entry = gtksourceview.View(self.buffer)
entry.set_size_request(-1, 100)
#self.disconnect_handler = buffer.connect("changed", self.changed)
self.buffer.connect("insert-text", self.update_scroll, entry)
#self.add_with_viewport(entry)
self.add(entry)
entry.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
entry.set_wrap_mode(Gtk.WrapMode.CHAR)
font = Pango.FontDescription('monospace')
entry.modify_font(font)
entry.set_show_line_numbers(True)
entry.set_show_line_marks(True)
entry.set_tab_width(8)
entry.set_auto_indent(True)
entry.set_insert_spaces_instead_of_tabs(False)
entry.set_show_right_margin(True)
entry.set_right_margin(30)
#entry.set_marker_pixbuf(marker_type, pixbuf)
entry.set_smart_home_end(True)
entry.connect("focus-in-event", self.focus_in)
entry.connect("focus-out-event", self.focus_out)
self.buffer.set_highlight_syntax(True)
self.buffer.set_max_undo_levels(10)
self.buffer.set_highlight_matching_brackets(True)
self.set_language("python") # default
#from application import Application
#self.application = Application()
self.application = application
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 __create_text(self, is_source=False):
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.set_shadow_type(gtk.SHADOW_IN)
buffer = gtksourceview2.Buffer(None)
text_view = gtksourceview2.View(buffer)
text_view.set_wrap_mode(gtk.WRAP_WORD)
scrolled_window.add(text_view)
if not is_source:
# context = text_view.get_pango_context()
# fonts = context.list_families()
# for font in fonts:
# print font.get_name()
font = pango.FontDescription('Indie Flower 16')
text_view.modify_font(font)
text_view.connect("key-press-event", self.key_press_event)
text_view.connect("event-after", self.event_after)
text_view.connect("motion-notify-event", self.motion_notify_event)
text_view.connect("visibility-notify-event",
self.visibility_notify_event)
return scrolled_window, buffer
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 codebox_insert(self,
iter_insert,
codebox_dict,
codebox_justification=None,
text_buffer=None,
cursor_pos=0):
"""Insert Code Box"""
if not text_buffer: text_buffer = self.dad.curr_buffer
anchor = text_buffer.create_child_anchor(iter_insert)
self.curr_codebox_anchor = anchor
anchor.frame_width = codebox_dict['frame_width']
anchor.frame_height = codebox_dict['frame_height']
anchor.width_in_pixels = codebox_dict['width_in_pixels']
anchor.syntax_highlighting = codebox_dict['syntax_highlighting']
anchor.highlight_brackets = codebox_dict['highlight_brackets']
anchor.show_line_numbers = codebox_dict['show_line_numbers']
anchor.sourcebuffer = gtksourceview2.Buffer()
anchor.sourcebuffer.set_style_scheme(
self.dad.sourcestyleschememanager.get_scheme(
self.dad.style_scheme))
if anchor.syntax_highlighting != cons.PLAIN_TEXT_ID:
self.dad.set_sourcebuffer_syntax_highlight(
anchor.sourcebuffer, anchor.syntax_highlighting)
anchor.sourcebuffer.set_highlight_matching_brackets(
anchor.highlight_brackets)
anchor.sourcebuffer.connect('insert-text', self.dad.on_text_insertion)
anchor.sourcebuffer.connect('delete-range', self.dad.on_text_removal)
anchor.sourcebuffer.connect('modified-changed',
self.dad.on_modified_changed)
if codebox_dict['fill_text']:
anchor.sourcebuffer.set_text(codebox_dict['fill_text'])
anchor.sourcebuffer.place_cursor(
anchor.sourcebuffer.get_iter_at_offset(cursor_pos))
anchor.sourcebuffer.set_modified(False)
anchor.sourceview = gtksourceview2.View(anchor.sourcebuffer)
anchor.sourceview.set_smart_home_end(
gtksourceview2.SMART_HOME_END_BEFORE)
if self.dad.highl_curr_line:
anchor.sourceview.set_highlight_current_line(True)
if self.dad.show_white_spaces:
anchor.sourceview.set_draw_spaces(DRAW_SPACES_FLAGS)
if anchor.syntax_highlighting == cons.PLAIN_TEXT_ID:
anchor.sourceview.modify_font(
pango.FontDescription(self.dad.text_font))
else:
anchor.sourceview.modify_font(
pango.FontDescription(self.dad.code_font))
anchor.sourceview.set_show_line_numbers(anchor.show_line_numbers)
anchor.sourceview.set_insert_spaces_instead_of_tabs(
self.dad.spaces_instead_tabs)
anchor.sourceview.set_tab_width(self.dad.tabs_width)
anchor.sourceview.set_auto_indent(self.dad.auto_indent)
anchor.sourceview.connect('populate-popup',
self.on_sourceview_populate_popup_codebox,
anchor)
anchor.sourceview.connect('key_press_event',
self.on_key_press_sourceview_codebox, anchor)
anchor.sourceview.connect('button-press-event',
self.on_mouse_button_clicked_codebox, anchor)
anchor.sourceview.connect("event-after",
self.on_sourceview_event_after_codebox,
anchor)
anchor.sourceview.connect(
"motion-notify-event",
self.on_sourceview_motion_notify_event_codebox)
anchor.sourceview.connect("copy-clipboard",
self.dad.clipboard_handler.copy, True)
anchor.sourceview.connect("cut-clipboard",
self.dad.clipboard_handler.cut, True)
if self.dad.line_wrapping:
anchor.sourceview.set_wrap_mode(gtk.WRAP_WORD)
else:
anchor.sourceview.set_wrap_mode(gtk.WRAP_NONE)
anchor.scrolledwindow = gtk.ScrolledWindow()
anchor.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
anchor.scrolledwindow.add(anchor.sourceview)
anchor.scrolledwindow.get_vscrollbar().connect(
'event-after', self.on_vscrollbar_event_after, anchor)
anchor.scrolledwindow.get_hscrollbar().connect(
'event-after', self.on_hscrollbar_event_after, anchor)
anchor.frame = gtk.Frame()
self.codebox_apply_width_height(anchor)
anchor.frame.add(anchor.scrolledwindow)
anchor.frame.set_shadow_type(gtk.SHADOW_NONE)
anchor.eventbox = gtk.EventBox()
anchor.eventbox.add(anchor.frame)
self.dad.sourceview.add_child_at_anchor(anchor.eventbox, anchor)
anchor.eventbox.show_all()
self.dad.widget_set_colors(anchor.sourceview, self.dad.rt_def_fg,
self.dad.rt_def_bg, True)
for win in [
gtk.TEXT_WINDOW_LEFT, gtk.TEXT_WINDOW_RIGHT,
gtk.TEXT_WINDOW_TOP, gtk.TEXT_WINDOW_BOTTOM
]:
anchor.sourceview.set_border_window_size(win, 1)
if codebox_justification:
text_iter = text_buffer.get_iter_at_child_anchor(anchor)
self.dad.state_machine.apply_object_justification(
text_iter, codebox_justification, text_buffer)
elif self.dad.user_active:
# if I apply a justification, the state is already updated
self.dad.state_machine.update_state(
self.dad.treestore[self.dad.curr_tree_iter][3])
def __init__(self, config, gladefile, parent):
self.is_initializing = True
SimpleGladeApp.__init__(self, gladefile, 'config_dialog')
self.config_dialog.set_transient_for(parent)
self.config = config
self.fontsel.props.font_name = config.get('font')
self.cur_font = self.fontsel.props.font_name
self.pprint_chk.props.active = config.get_bool('pprint')
self.reshist_chk.props.active = config.get_bool('use-reshist')
self.on_reshist_chk_toggled(self.reshist_chk)
self.reshist_spin.props.value = config.get_int('reshist-size')
self.autofold_chk.props.active = config.get_bool('autofold')
self.on_autofold_chk_toggled(self.autofold_chk)
self.autofold_spin.props.value = config.get_int('autofold-numlines')
self.viewer_entry.props.text = eval(config.get('viewer'))
self.autoparen_chk.props.active = config.get_bool('autoparen')
self.expects_str_entry.props.text = config.get('expects-str-2')
self.vertical_layout_rad.props.active = config.get_bool(
'vertical-layout')
self.horizontal_layout_rad.props.active = not config.get_bool(
'vertical-layout')
self.leave_code_chk.props.active = config.get_bool('leave-code')
self.swap_panes_chk.props.active = config.get_bool('swap-panes')
self.hide_defs_chk.props.active = config.get_bool('hide-defs')
switch = config.get_bool('matplotlib-ia-switch')
warn = config.get_bool('matplotlib-ia-warn')
if switch:
self.matplotlib_ia_switch_rad.props.active = True
elif warn:
self.matplotlib_ia_warn_rad.props.active = True
else:
self.matplotlib_ia_ignore_rad.props.active = True
self.ask_on_quit_chk.props.active = config.get_bool('ask-on-quit')
self.themes = dict((name, tags.get_theme(config, name))
for name in tags.get_theme_names(config))
self.cur_theme = self.themes[config.get('current-theme')]
self.fg_default_rad.set_group(self.fg_special_rad)
self.bg_default_rad.set_group(self.bg_special_rad)
TYPE_STRING = gobject.TYPE_STRING
self.themes_list = gtk.ListStore(TYPE_STRING)
self.themes_trv.set_model(self.themes_list)
self.init_themes_list()
# tag, desc, fg, bg
self.elements_list = gtk.ListStore(TYPE_STRING, TYPE_STRING,
TYPE_STRING, TYPE_STRING)
self.elements_trv.set_model(self.elements_list)
# cur_tag is the currently selected tag. It is set to None when props
# are changed, to mark that they weren't changed as a result of a user
# action.
self.cur_tag = None
self.init_elements_list()
self.textbuffer = self.textview.get_buffer()
self.init_textview()
self.sourcebuffer = gtksourceview2.Buffer()
self.sourceview = gtksourceview2.View(self.sourcebuffer)
self.sourcebuffer.set_text(eval(config.get('init-code')))
self.init_sourceview()
self.font_changed()
self.theme_changed()
self.is_initializing = False
