def __init__(self, window):
super(_CommentsDialog, self).__init__(_('Comments'), window, 0,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
self.set_resizable(True)
self.set_default_response(gtk.RESPONSE_CLOSE)
self.set_default_size(600, 550)
self.set_border_width(4)
tag = gtk.TextTag()
tag.set_property('editable', False)
tag.set_property('editable-set', True)
tag.set_property('family', 'Monospace')
tag.set_property('family-set', True)
tag.set_property('scale', 0.9)
tag.set_property('scale-set', True)
tag_table = gtk.TextTagTable()
tag_table.add(tag)
self._tag = tag
self._tag_table = tag_table
self._notebook = None
self._window = window
self._comments = []
self._window.filehandler.file_available += self._on_file_available
self._window.filehandler.file_opened += self._update_comments
self._window.filehandler.file_closed += self._update_comments
self._update_comments()
self.show_all()
def __init__(self, *args):
gtk.TextView.__init__(self, *args)
self.set_editable(True)
self.set_wrap_mode(gtk.WRAP_WORD)
self.set_pixels_above_lines(2)
self.set_pixels_inside_wrap(0)
self.set_right_margin(2)
self.set_left_margin(2)
self.set_border_width(10)
f = 64 * 1024 - 1
color = (f,) * 3
self.modify_bg(0, gtk.gdk.Color(*color))
#color = map(lambda x: int(x), (f, f * 0.9, f * 0.5))
#= dark background:
#self.modify_bg(0, gtk.gdk.Color(10000,12000,0))
#self.modify_base(0, gtk.gdk.Color(10000,12000,0))
#self.modify_text(0, gtk.gdk.Color(*color))
#=
self.swindow = create_swindow()
self.swindow.add(self)
self.note = None
self.texttagtable = gtk.TextTagTable()
self.texttag_bold = gtk.TextTag("bold")
self.texttag_bold.set_property("weight", pango.WEIGHT_BOLD)
self.texttagtable.add(self.texttag_bold)
def __init__(self):
super(StatusView, self).__init__()
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.tag_table = gtk.TextTagTable()
self.buffer = gtk.TextBuffer(self.tag_table)
self.view = gtk.TextView(self.buffer)
self.view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.view.set_indent(4)
Prefs()['gui.statustab.font'].connect(self.__modify_font)
self.view.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 16)
self.view.set_editable(False)
# Create various tags
self.view.connect('expose-event', self.__redraw_left_window)
self.view.connect('style-set', self.__on_style)
self.view.connect('realize', self.__on_realize)
self.add(self.view)
self.icons = (get_pixbuf('info_small'), get_pixbuf('warning_small'),
get_pixbuf('error_small'))
self.lines = []
def editor_open(self, *args):
step = 1000
fcd = FileChooserDialog(self, action='open')
fcd.run()
if not self.path:
return
self.editor_path = self.path
self.fcd_dir = os.path.dirname(self.path)
self.path = ''
text = open(self.editor_path).read()
self.path = ''
t_table = gtk.TextTagTable()
tag = gtk.TextTag('output')
t_table.add(tag)
self.editor_buffer = gtk.TextBuffer(t_table)
self.textview_edit.set_buffer(self.editor_buffer)
self.assert_quit = True
size=len(text)
if size < step:
self.editor_buffer.set_text(text)
else:
self.editor_buffer.set_text(text[:step])
while gtk.events_pending():
gtk.main_iteration_do(False)
i = step
while i < size-step:
self.editor_buffer.insert(self.editor_buffer.get_end_iter(), text[i:i+step])
i += step
while gtk.events_pending():
gtk.main_iteration_do(False)
self.editor_buffer.insert(self.editor_buffer.get_end_iter(), text[i:])
def create(descs):
table = gtk.TextTagTable()
for name, properties in descs.items():
tag = gtk.TextTag(name); table.add(tag)
for property, value in properties.items():
tag.set_property(property, value)
return table
def open(self, filename, container=None):
self.type = "gtk"
self.has_data = True
self.tag_table = gtk.TextTagTable()
sheet = self.get_style_sheet()
for name in sheet.get_paragraph_style_names():
tag = gtk.TextTag(name)
style = sheet.get_paragraph_style(name)
font = style.get_font()
if font.get_type_face() == FONT_SERIF:
tag.set_property("family", "Serif")
elif font.get_type_face() == FONT_SANS_SERIF:
tag.set_property("family", "Sans")
elif font.get_type_face() == FONT_MONOSPACE:
tag.set_property("family", "MonoSpace")
tag.set_property("size-points", float(font.get_size()))
if font.get_bold():
tag.set_property("weight", pango.WEIGHT_BOLD)
if style.get_alignment() == PARA_ALIGN_RIGHT:
tag.set_property("justification", gtk.JUSTIFY_RIGHT)
elif style.get_alignment() == PARA_ALIGN_LEFT:
tag.set_property("justification", gtk.JUSTIFY_LEFT)
elif style.get_alignment() == PARA_ALIGN_CENTER:
tag.set_property("justification", gtk.JUSTIFY_CENTER)
else:
tag.set_property("justification", gtk.JUSTIFY_FILL)
if font.get_italic():
tag.set_property("style", pango.STYLE_ITALIC)
if style.get_first_indent():
tag.set_property("indent", pixels(style.get_first_indent()))
#tag.set_property("tabs", [pixels(abs(style.get_first_indent()))])
tag.set_property("left-margin", pixels(style.get_left_margin()))
tag.set_property("right-margin", pixels(style.get_right_margin()))
tag.set_property("pixels-above-lines", pixels(style.get_top_margin()))
tag.set_property("pixels-below-lines", pixels(style.get_bottom_margin()))
tag.set_property("wrap-mode", gtk.WRAP_WORD)
new_tabs = style.get_tabs()
tab_array = pango.TabArray(len(new_tabs)+1,True)
index = 0
for tab in map(pixels, new_tabs):
tab_array.set_tab(index, pango.TAB_LEFT, tab)
index += 1
tag.set_property("tabs", tab_array)
self.tag_table.add(tag)
self.buffer = gtk.TextBuffer(self.tag_table)
if container:
return DocumentManager(_('Quick View'), self, container)
else:
DisplayBuf(_('Quick View'), self)
return
def __init__(self, tagtable=None):
VView.__init__(self)
self.textview = gtk.TextView()
self.textview.connect("populate_popup", self.vwGetPopup)
self.add(self.textview)
if tagtable == None:
tagtable = gtk.TextTagTable()
self.vwSetTagTable(tagtable)
style = gtk.Style()
style.base[gtk.STATE_NORMAL] = gdk.Color(0, 0, 0)
style.text[gtk.STATE_NORMAL] = gdk.Color(0, 0, 0xff)
style.base[gtk.STATE_INSENSITIVE] = gdk.Color(0, 0, 0)
style.text[gtk.STATE_INSENSITIVE] = gdk.Color(20, 20, 20)
self.textview.set_style(style)
self.tagcfg = ConfigParser()
self.curtag = None # Is a current tag selected?
#self.deftag =
self.vwInitTag(VTextTag("default"))
start, end = self.textbuf.get_bounds()
self.textbuf.create_mark("insertend", end)
def __init__(self, window):
gtk.Dialog.__init__(self, _('Comments'), window, 0,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
self.set_has_separator(False)
self.set_resizable(True)
self.set_default_response(gtk.RESPONSE_CLOSE)
self.set_default_size(600, 550)
notebook = gtk.Notebook()
notebook.set_scrollable(True)
self.set_border_width(4)
notebook.set_border_width(6)
self.vbox.pack_start(notebook)
tag = gtk.TextTag()
tag.set_property('editable', False)
tag.set_property('editable-set', True)
tag.set_property('family', 'Monospace')
tag.set_property('family-set', True)
tag.set_property('scale', 0.9)
tag.set_property('scale-set', True)
tag_table = gtk.TextTagTable()
tag_table.add(tag)
for num in xrange(1, window.filehandler.get_number_of_comments() + 1):
page = gtk.VBox(False)
page.set_border_width(8)
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
page.pack_start(scrolled)
outbox = gtk.EventBox()
scrolled.add_with_viewport(outbox)
inbox = gtk.EventBox()
inbox.set_border_width(6)
outbox.add(inbox)
name = os.path.basename(window.filehandler.get_comment_name(num))
text = window.filehandler.get_comment_text(num)
if text is None:
text = _('Could not read %s') % name
text_buffer = gtk.TextBuffer(tag_table)
text_buffer.set_text(i18n.to_unicode(text))
text_buffer.apply_tag(tag, *text_buffer.get_bounds())
text_view = gtk.TextView(text_buffer)
inbox.add(text_view)
bg_color = text_view.get_default_attributes().bg_color
outbox.modify_bg(gtk.STATE_NORMAL, bg_color)
tab_label = gtk.Label(i18n.to_unicode(name))
notebook.insert_page(page, tab_label)
self.show_all()
def __init__(self, option):
tagtable = gtk.TextTagTable()
tag = gtk.TextTag('default')
tag.set_property('font', 'Monospace 8')
tagtable.add(tag)
buffer = gtk.TextBuffer(tagtable)
widget = gtk.TextView(buffer)
registry_widget.__init__(self, widget, option)
def __init__(self):
gtk.TextView.__init__(self)
self.tabla = gtk.TextTagTable()
self.buffer = gtk.TextBuffer(self.tabla)
self.buffer.connect_after("insert-text", self.bufferInsert)
self.set_buffer(self.buffer)
self.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.set_editable(False)
self.set_cursor_visible(False)
def __init__(self, **options):
#UIBase.__init__(self, **options)
self.xml= gtk.glade.XML(os.path.join(rootDir, 'ui', 'glade', 'maindialog.glade'))
self.d = self.xml.get_widget('maindialog')
self.d.connect('delete-event', self.close_button_clicked)
self.about_init()
signals={}##{'browse1':self.browse1}
for attr in dir(self):
signals[attr] = getattr(self, attr)
self.xml.signal_autoconnect(signals)
self.def_widgets(('quitdialog', 'textview_out', 'textview_err', 'maindialog',\
'vpaned1', 'notebook1', 'entry_i', 'entry_o',\
'combobox_i', 'combobox_o', 'checkb_o_det', 'combobox_r_i',\
'entry_r_i', 'entry_r_o', 'combobox_sr', 'progressbar', 'textview_edit',\
'label_convert', 'label_reverse', 'combobox_mode', 'textview_merge', 'button_conv'))
"""## changing colors
self.textview_err.modify_base(0, gtk.gdk.Color(10000, 0, 0))#textview bg color
#self.textview_err.modify_base(1, gtk.gdk.Color(-1, 0, 0))#selected text bg color, when deselect window!
self.textview_err.modify_text(0, gtk.gdk.Color(-1, -1, -1))#normal text color
#self.textview_err.modify_text(1, gtk.gdk.Color(-1, -1, -1))#selected test color, when deselect window!
# modify_bg modify_fg
self.textview_out.modify_base(0, gtk.gdk.Color(0, 10000, 0))#textview bg color
self.textview_out.modify_text(0, gtk.gdk.Color(-1, -1, -1))#normal text color
"""
self.quitdialog.connect('delete-event', self.quitdialog_close)
self.assert_quit = False
self.path = ''
self.glos = Glossary(ui=self)
for f in Glossary.readFormats:
self.combobox_i.append_text(Glossary.formatsDesc[f])
self.combobox_r_i.append_text(Glossary.formatsDesc[f])
for f in Glossary.writeFormats:
self.combobox_o.append_text(Glossary.formatsDesc[f])
self.combobox_sr.set_active(0)
self.editor_path = ''
self.tabIndex = 0
self.fcd_dir = ''
self.ptext = ''
###################################
t_table = gtk.TextTagTable()
tag = gtk.TextTag('filelist')
t_table.add(tag)
self.merge_buffer = gtk.TextBuffer(t_table)
self.textview_merge.set_buffer(self.merge_buffer)
self.merge_buffer.connect('changed', self.textview_merge_changed)
self.combobox_mode.set_active(2)
####################################
self.reverseStop = False
self.pref_init(**options)
#thread.start_new_thread(UI.progressListen,(self,))
#################### Comment folowing two line to see the output in the terminal
self.setupLogging()
def __init__(self):
gtk.HBox.__init__(self, False, 4)
self.set_border_width(4)
self.table = gtk.TextTagTable()
self.tag_offset = gtk.TextTag('hex-o-view') # offset view
self.tag_hex = gtk.TextTag('hex-x-view') # hex view
self.tag_ascii = gtk.TextTag('hex-a-view') # ascii view
self.tag_sec_sel = gtk.TextTag(
'hex-s-selection') # secondary selection
self.table.add(self.tag_offset)
self.table.add(self.tag_hex)
self.table.add(self.tag_ascii)
self.table.add(self.tag_sec_sel)
self._bpl = 16
self._font = "Monospace 10"
self._payload = ""
self._base_addr = 0
self.scroll_mark = None
self.editable = False
self.vadj = gtk.Adjustment()
self.vscroll = gtk.VScrollbar(self.vadj)
self.offset_text = OffsetText(self)
self.hex_text = HexText(self)
self.ascii_text = AsciiText(self)
self.offset_text.set_scroll_adjustments(None, self.vadj)
self.hex_text.set_scroll_adjustments(None, self.vadj)
self.ascii_text.set_scroll_adjustments(None, self.vadj)
self.hex_text.buffer.connect('mark-set', self.__on_hex_change)
self.ascii_text.buffer.connect('mark-set', self.__on_ascii_change)
self.offset_text.connect('scroll-event', self.__on_scroll_event)
self.hex_text.connect('scroll-event', self.__on_scroll_event)
self.ascii_text.connect('scroll-event', self.__on_scroll_event)
def scroll(widget):
widget.set_size_request(-1, 128)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.add(widget)
return frame
self.pack_start(scroll(self.offset_text), False, False)
self.pack_start(scroll(self.hex_text), False, False)
self.pack_start(scroll(self.ascii_text), False, False)
self.pack_end(self.vscroll, False, False)
def __init__(self):
super(ConsolePanel, self).__init__()
self._history = [
'',
] * ConsolePanel.MAX_HISTORY
self._history_i = 0
s_window = gtk.ScrolledWindow()
s_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
s_window.show()
t_table = gtk.TextTagTable()
tag_out = gtk.TextTag("output")
tag_out.set_property("foreground", "blue")
tag_out.set_property("font", "monospace 10")
tag_out.set_property("editable", False)
t_table.add(tag_out)
tag_in = gtk.TextTag("input")
tag_in.set_property("foreground", "black")
tag_in.set_property("font", "monospace 10")
t_table.add(tag_in)
self.tag_table = t_table
self._buffer = gtk.TextBuffer(t_table)
self._view = gtk.TextView(buffer=self._buffer)
self._view.connect("key_press_event", self.actionKeyPress)
self._view.show()
s_window.add(self._view)
self.add(s_window)
evalButton = gtk.Button("Evaluate")
evalButton.connect("clicked", self.evaluateAction, "evaluate")
#evalButton.show()
self.pack_start(evalButton, False, False, 0)
self._evalButton = evalButton
console_info = gtk.Label('')
self._console_info = console_info
self.update_consoleinfo()
console_info.show()
self.pack_start(console_info, False, False, 0)
self.append("> ", "input")
location = self._buffer.get_end_iter()
self._start_mark = self._buffer.create_mark("beginCode",
location,
left_gravity=True)
self._firstEnter = False
def __init__(self):
gtk.VBox.__init__(self, False, 2)
self.set_border_width(4)
self.not_selected_lbl = gtk.Label('')
self.not_selected_lbl.set_markup(
_('<span size=\'large\'><b>'
'No plugin selected.</b></span>'))
self.tagtable = gtk.TextTagTable()
self.bold = gtk.TextTag('bold')
self.bold.set_property('right-margin', 15)
self.bold.set_property('weight', pango.WEIGHT_BOLD)
self.tagtable.add(self.bold)
self.par = gtk.TextTag('par')
self.par.set_property('left-margin', 15)
self.par.set_property('right-margin', 15)
self.par.set_property('justification', gtk.JUSTIFY_FILL)
self.tagtable.add(self.par)
self.link = gtk.TextTag('link')
self.link.set_property('foreground', '#0000FF')
self.link.set_property('right-margin', 15)
self.link.set_property('underline', pango.UNDERLINE_SINGLE)
self.link.connect('event', self.__on_link)
self.tagtable.add(self.link)
self.buff = gtk.TextBuffer(self.tagtable)
self.text = gtk.TextView(self.buff)
self.text.modify_font(pango.FontDescription('Monospace 9'))
self.text.set_editable(False)
self.text.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.sw = gtk.ScrolledWindow()
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.sw.add(self.text)
self.pack_start(self.not_selected_lbl)
self.pack_end(self.sw)
self.current_plugin = None
self.show()
self.not_selected_lbl.show()
self.connect('realize', self.__on_realize)
def __init__(self,parent,title=''):
self.parent = parent
self.frame = gtk.Frame()
self.txttagtable = gtk.TextTagTable()
self.txtbuffer = gtk.TextBuffer(table=self.txttagtable)
self.tag_h = self.txtbuffer.create_tag(background='lightblue')
self.txtview = gtk.TextView(buffer=self.txtbuffer)
self.txtview.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 20)
self.txtview.connect("expose_event", self.line_numbers_expose)
self.parent.add(self.txtview)
self.parent.show_all()
self.old_start_iter = None
def _create_tag_table_(self):
tag_table = gtk.TextTagTable()
tag = gtk.TextTag("bold")
tag.set_property("weight", pango.WEIGHT_BOLD)
tag_table.add(tag)
tag = gtk.TextTag("italic")
tag.set_property("style", pango.STYLE_ITALIC)
tag_table.add(tag)
tag = gtk.TextTag("underline")
tag.set_property("underline", pango.UNDERLINE_SINGLE)
tag_table.add(tag)
tag = gtk.TextTag("center")
tag.set_property("justification", gtk.JUSTIFY_CENTER)
tag_table.add(tag)
tag = gtk.TextTag("left")
tag.set_property("justification", gtk.JUSTIFY_LEFT)
tag_table.add(tag)
tag = gtk.TextTag("right")
tag.set_property("justification", gtk.JUSTIFY_RIGHT)
tag_table.add(tag)
# [TODO]
# priority = Very low
#tag = gtk.TextTag("fill")
#tag.set_property("justification", gtk.JUSTIFY_FILL)
#tag_table.add(tag)
#.
tag = gtk.TextTag("invisible")
tag.set_property("invisible", True)
tag.set_property("editable", False)
tag_table.add(tag)
tag = gtk.TextTag("uneditable")
tag.set_property("editable", False)
tag_table.add(tag)
return tag_table
def __init__(self):
self.view = gtk.Frame()
texttagtable = gtk.TextTagTable()
self.texttag = gtk.TextTag(None)
self.texttag.set_property("weight", pango.WEIGHT_BOLD)
self.texttag.set_property("size-points", 36)
self.texttag.set_property("justification", gtk.JUSTIFY_CENTER)
texttagtable.add(self.texttag)
self.text_buffer = gtk.TextBuffer(texttagtable)
self.textview = gtk.TextView(self.text_buffer)
self.textview.set_editable(False)
self.textview.set_cursor_visible(False)
self.textview.set_wrap_mode(gtk.WRAP_WORD)
self.scrollview = gtk.ScrolledWindow()
self.scrollview.add_with_viewport(self.textview)
self.scrollview.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.view.add(self.scrollview)
self.view.show_all()
def __init__(self):
gtk.ScrolledWindow.__init__(self)
texttagtable = gtk.TextTagTable()
self.buffer = gtk.TextBuffer(texttagtable)
self.tag_bold = gtk.TextTag("bold")
self.tag_bold.set_property("weight", pango.WEIGHT_BOLD)
texttagtable.add(self.tag_bold)
text = gtk.TextView(self.buffer)
text.set_wrap_mode(gtk.WRAP_WORD)
text.set_editable(False)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.add(text)
self.scroll = self
self.line_title = None
def __init__(self, connw, conn):
gtk.VBox.__init__(self, False, 2)
self.connw = connw
self.conn = conn
self.conn.flags |= CN_VIEWING
self.index = 0
if not self.tagtable:
# Create tag table if not yet allocated
self.tagtable = gtk.TextTagTable()
tag = gtk.TextTag('src')
tag.set_property('foreground', 'blue')
self.tagtable.add(tag)
tag = gtk.TextTag('dst')
tag.set_property('foreground', 'red')
self.tagtable.add(tag)
tag = gtk.TextTag('srcinj')
tag.set_property('weight', pango.WEIGHT_BOLD)
tag.set_property('foreground', 'blue')
self.tagtable.add(tag)
tag = gtk.TextTag('dstinj')
tag.set_property('weight', pango.WEIGHT_BOLD)
tag.set_property('foreground', 'red')
self.tagtable.add(tag)
self.buff = gtk.TextBuffer(self.tagtable)
self.endmark = self.buff.create_mark('end', self.buff.get_end_iter(),
0)
self.view = gtk.TextView(self.buff)
self.view.set_wrap_mode(gtk.WRAP_CHAR)
self.view.set_editable(False)
self.view.modify_font(pango.FontDescription('Monospace 9'))
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.add(self.view)
self.pack_start(sw)
bb = gtk.HButtonBox()
bb.set_layout(gtk.BUTTONBOX_END)
btn = gtk.Button(_('Inject file'))
btn.set_relief(gtk.RELIEF_NONE)
btn.connect('clicked', self.__on_inject, True)
bb.pack_start(btn)
btn = gtk.Button(_('Inject data'))
btn.set_relief(gtk.RELIEF_NONE)
btn.connect('clicked', self.__on_inject, False)
bb.pack_start(btn)
btn = gtk.Button(_('Kill connection'))
btn.set_relief(gtk.RELIEF_NONE)
btn.connect('clicked', self.__on_kill)
bb.pack_start(btn)
btn = gtk.Button(stock=gtk.STOCK_CLOSE)
btn.set_relief(gtk.RELIEF_NONE)
btn.connect('clicked', self.__on_close)
bb.pack_start(btn)
self.pack_start(bb, False, False)
class HTMLBuffer(gtk.TextBuffer):
__gtype_name__ = "HTMLBuffer"
global_tagtable = gtk.TextTagTable()
def __init__(self, handler=None, tagtable=None):
self.lines = 0
self.group_string = None
self.group_color = False
if tagtable:
self.tagtable = tagtable
else:
self.tagtable = self.global_tagtable
self.URLHandler = handler
gtk.TextBuffer.__init__(self, self.tagtable)
self.scanner = xml.sax.make_parser()
self.parser = xml.sax.make_parser()
self.scanner.setContentHandler(ScanHandler())
contentHandler = HTMLHandler(self, self.URLHandler)
self.parser.setContentHandler(contentHandler)
def setURLHandler(self, handler):
self.URLHandler = handler
self.parser.getContentHandler().URLHandler = handler
def getURLHandler(self):
return self.URLHandler
def clear(self):
""" Clears the output and resets the tag
table to zero to save memory.
"""
self.set_text("")
# clear the tagtable
tt = self.get_tag_table()
if tt:
tt.foreach(lambda tag,data: data.remove(tag), tt)
def insert(self, iter, text, *x):
" make the buffer a ring buffer with a limit of max_output_lines "
siter = self.get_selection_bounds()
if siter:
soff = siter[0].get_offset()
ioff = siter[1].get_offset()
gtk.TextBuffer.insert(self, iter, text, *x)
self.lines += text.count("\n")
try:
max_lines = int(config.get("tekka",
"max_output_lines"))
except ValueError:
max_lines = int(config.get_default("tekka",
"max_output_lines"))
diff = self.lines - max_lines
if diff > 0:
a = self.get_iter_at_line(0)
b = self.get_iter_at_line(diff)
self.delete(a,b)
self.lines -= diff
if siter:
self.select_range(
self.get_iter_at_offset(soff),
self.get_iter_at_offset(ioff)
)
# FIXME new selection range is off by some bytes
def insert_html(self, iter, text, group_string=None):
""" parse text for HTML markups before adding
it to the buffer at the given iter.
This method is deprecated. Use insert_html.
"""
startoffset = iter.get_offset()
if gtk.TextBuffer.get_char_count(self) > 0:
text = "<br/>" + text
text = URLToTag(text)
if self.group_string != group_string:
self.group_string = group_string
self.group_color = not self.group_color
# color the lines, group coloring by some string
if (config.get_bool("tekka","text_rules")
and self.group_color
and self.group_string):
color = helper.color.get_color_by_key("rules_color").to_string()
text = "<msg paragraph-background='%s'>%s</msg>" % (
color, text)
else:
text = "<msg>%s</msg>" % text
def applyToParser(text):
try:
self.parser.parse(StringIO(text))
except xml.sax.SAXParseException,e:
raise Exception,\
"%s.applyToParser: '%s' raised with '%s'." % (e, text)
while True:
try:
self.scanner.parse(StringIO(text))
except xml.sax.SAXParseException, e:
# Exception while parsing, get (if caused by char)
# the character and delete it. Then try again to
# add the text.
# If the exception is caused by a syntax error,
# abort parsing and print the error with line
# and position.
pos = e.getColumnNumber()
line = e.getLineNumber()
if (pos-2 >= 0 and text[pos-2:pos] == "</"):
logging.error("Syntax error on line %d, "\
"column %d: %s\n\t%s" % (
line,
pos,
text[pos:],
text))
return
logging.error("HTMLBuffer: faulty char on line %d "
"char %d ('%s')" % (line, pos, text[pos]))
# skip the faulty char
text = text[:pos] + text[pos+1:]
continue
else:
# everything went fine, no need
# for looping further.
applyToParser(text)
break
def __init__(self, exaile, options):
self.ops = {'artist-title.lrc' : lambda art, tit, locname: '%s-%s' %(art, tit), \
'title-artist.lrc': lambda art, tit, locname: '%s-%s' %(tit, art), \
'与歌曲文件名相同': lambda art, tit, locname: locname.replace('.mp3','').replace('.wmv','')}
self.exaile = exaile
self.options = options
gtk.VBox.__init__(self)
self.scroller = gtk.ScrolledWindow()
self.scroller.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.pack_start(self.scroller, True, True, 0)
self.TagTable = gtk.TextTagTable()
self.textview = gtk.TextView()
self.textview.set_cursor_visible(False)
self.textview.set_editable(False)
self.textview.set_wrap_mode(gtk.WRAP_WORD)
self.textview.set_justification(gtk.JUSTIFY_LEFT)
self.textview.set_left_margin(4)
self.scroller.add(self.textview)
self.LyricBuffer = gtk.TextBuffer()
self.textview.set_buffer(self.LyricBuffer)
color = gtk.gdk.Color(self.options['LyricColor']).to_string()
self.colortag = self.LyricBuffer.create_tag(foreground=color)
self.lrcDic = {}
self.lrcLines = {}
self.lyric = ''
self.timeChange = 0
self.isLrcFound = False
event.add_callback(self.playTrack, 'playback_track_start')
event.add_callback(self.stopTrack, 'playback_player_end')
event.add_callback(self.timeSeek, 'seek')
event.add_callback(self.colorChange, 'color_change')
event.add_callback(self.nameChange, 'name_change')
self.menu = gtk.Menu()
self.lrcsearch = gtk.MenuItem('手动搜索')
self.scrollable = gtk.CheckMenuItem('歌词微调')
self.savechange = gtk.MenuItem('保存修改')
self.menu.append(self.lrcsearch)
self.menu.append(self.scrollable)
self.menu.append(self.savechange)
self.scrollable.set_active(False)
self.scrollable.show()
self.menu.show()
self.savechange.show()
self.lrcsearch.show()
self.textview.connect('event', self.TVE)
self.savechange.connect('activate', self.SaveChange)
self.lrcsearch.connect('activate', self.lrcList)
if bool(self.exaile.player.current):
artist = self.exaile.player.current.get_tag_display('artist')
title = self.exaile.player.current.get_tag_display('title')
try:
locname = os.path.basename(
self.exaile.player.current.local_file_name())
except AttributeError:
locname = '-'.join([artist, title])
self.lrcSearch(artist, title, locname)
self.InfoPlay('play')
if self.isLrcFound:
self.timeSeek()
else:
self.InfoPlay(OP='stop')
def __init__(self, field_name, model_name, attrs=None):
super(RichTextBox, self).__init__(field_name, model_name, attrs=attrs)
self.table_tag = gtk.TextTagTable()
self.text_buffer = gtk.TextBuffer(self.table_tag)
self.textview.set_buffer(self.text_buffer)
self.textview.connect_after('move-cursor', self.detect_style)
self.textview.connect('button-release-event', self.detect_style)
self.focus_out = True
tags = ('bold', 'italic', 'underline', 'font_family', 'size', 'left',
'center', 'right', 'fill', 'foreground', 'background',
'markup')
# Build all buttons
self.tools = {}
for tag in tags[:3]:
self.tools[tag] = gtk.ToggleToolButton('gtk-%s' % tag)
self.sizes = map(str, range(6, 33))
fonts = self.textview.get_pango_context().list_families()
self.families = sorted([font.get_name() for font in fonts])
for tag, values in zip(tags[3:5], (self.families, self.sizes)):
self.tools[tag] = gtk.ToolItem()
box = gtk.combo_box_new_text()
for value in values:
box.append_text(value)
box.set_focus_on_click(False)
self.tools[tag].add(box)
group = None
for tag in tags[5:9]:
self.tools[tag] = gtk.RadioToolButton(group,
'gtk-justify-%s' % tag)
if not group:
group = self.tools[tag]
for tag in tags[9:11]:
self.tools[tag] = gtk.ToolButton('tryton-text-%s' % tag)
self.tools['markup'] = gtk.ToggleToolButton('tryton-text-markup')
# Set properties to each button
tag_values = (
('bold', 'weight', pango.WEIGHT_BOLD),
('italic', 'style', pango.STYLE_ITALIC),
('underline', 'underline', pango.UNDERLINE_SINGLE),
('left', 'justification', gtk.JUSTIFY_LEFT),
('center', 'justification', gtk.JUSTIFY_CENTER),
('right', 'justification', gtk.JUSTIFY_RIGHT),
('fill', 'justification', gtk.JUSTIFY_FILL),
)
self.text_tags = {}
for tag, name, prop in tag_values:
self.text_tags[tag] = gtk.TextTag(tag)
self.text_tags[tag].set_property(name, prop)
self.table_tag.add(self.text_tags[tag])
self.font_props = {
'font_family': {},
'size': {},
'foreground': {},
'background': {},
}
font_desc = self.textview.get_pango_context().get_font_description()
self.current_font_prop = {
'foreground': gtk.gdk.Color('#000'),
'background': gtk.gdk.Color('#fff'),
'font_family': font_desc.get_family(),
'size': str(font_desc.get_size() / pango.SCALE),
'justify': 'left',
}
self.tools['size'].child.set_active(
self.sizes.index(self.current_font_prop['size']))
font_family = self.current_font_prop['font_family']
if font_family in self.families:
self.tools['font_family'].child.set_active(
self.families.index(font_family))
self.start_tags = {}
self.end_tags = {}
# Connect events
self.tool_ids = {}
for tag in tags[:3]:
self.tool_ids[tag] = self.tools[tag].connect(
'toggled', self.action_style_font, self.text_tags[tag], tag)
for tag in tags[3:5]:
self.tool_ids[tag] = self.tools[tag].child.connect(
'changed', self.action_prop_font, tag)
for tag in tags[5:9]:
self.tool_ids[tag] = self.tools[tag].connect(
'toggled', self.action_justification, tag)
for tag in tags[9:11]:
self.tool_ids[tag] = self.tools[tag].connect(
'clicked', self.action_prop_font, tag)
self.tool_ids['markup'] = self.tools['markup'].connect(
'toggled', self.edit_text_markup)
self.insert_text_id = self.text_buffer.connect_after(
'insert-text', self.persist_style)
# Tooltip text
self.tools['bold'].set_tooltip_text(_('Change text to bold'))
self.tools['italic'].set_tooltip_text(_('Change text to italic'))
self.tools['underline'].set_tooltip_text(_('Change text to underline'))
self.tools['font_family'].set_tooltip_text(_('Choose font-family'))
self.tools['size'].set_tooltip_text(_('Choose font-size'))
self.tools['left'].set_tooltip_text(_('Justify of line to the left'))
self.tools['center'].set_tooltip_text(
_('Justify of line to the center'))
self.tools['right'].set_tooltip_text(_('Justify of line to the right'))
self.tools['fill'].set_tooltip_text(
_('Justify of line to fill window'))
self.tools['foreground'].set_tooltip_text(
_('Change the foreground text'))
self.tools['background'].set_tooltip_text(
_('Change the background text'))
self.tools['markup'].set_tooltip_text(_('Change the markup text view'))
# Packing widgets
self.tool_bar = gtk.Toolbar()
self.tool_bar.set_style(gtk.TOOLBAR_ICONS)
for tag in tags:
self.tool_bar.insert(self.tools[tag], -1)
separator = gtk.SeparatorToolItem
for local in (3, 6, 11, 14):
self.tool_bar.insert(separator(), local)
self.widget.pack_start(self.tool_bar, False)
def __init__(self, lesson, keyboard_images, activity):
gtk.VBox.__init__(self)
self.lesson = lesson
self.keyboard_images = keyboard_images
self.activity = activity
# Build the user interface.
title = gtk.Label()
title.set_markup("<span size='20000'><b>" + lesson['name'] +
"</b></span>")
title.set_alignment(1.0, 0.0)
stoplabel = gtk.Label(_('Go Back'))
stopbtn = gtk.Button()
stopbtn.add(stoplabel)
stopbtn.connect('clicked', self.stop_cb)
# TODO- These will be replaced by graphical displays using gtk.DrawingArea.
self.wpmlabel = gtk.Label()
self.accuracylabel = gtk.Label()
#self.wpmarea = gtk.DrawingArea()
#self.wpmarea.connect('expose-event', self.wpm_expose_cb)
#self.accuracyarea = gtk.DrawingArea()
#self.accuracyarea.connect('expose-event', self.accuracy_expose_cb)
hbox = gtk.HBox()
hbox.pack_start(stopbtn, False, False, 10)
hbox.pack_start(self.wpmlabel, True, False, 10)
hbox.pack_start(self.accuracylabel, True, False, 10)
hbox.pack_end(title, False, False, 10)
# Set up font styles.
self.tagtable = gtk.TextTagTable()
instructions_tag = gtk.TextTag('instructions')
instructions_tag.props.size = 9000
instructions_tag.props.justification = gtk.JUSTIFY_CENTER
self.tagtable.add(instructions_tag)
text_tag = gtk.TextTag('text')
text_tag.props.family = 'Monospace'
text_tag.props.size = 9000
self.tagtable.add(text_tag)
spacer_tag = gtk.TextTag('spacer')
spacer_tag.props.size = 10
self.tagtable.add(spacer_tag)
image_tag = gtk.TextTag('image')
image_tag.props.justification = gtk.JUSTIFY_CENTER
self.tagtable.add(image_tag)
correct_copy_tag = gtk.TextTag('correct-copy')
correct_copy_tag.props.family = 'Monospace'
correct_copy_tag.props.size = 9000
correct_copy_tag.props.foreground = '#0000ff'
self.tagtable.add(correct_copy_tag)
incorrect_copy_tag = gtk.TextTag('incorrect-copy')
incorrect_copy_tag.props.family = 'Monospace'
incorrect_copy_tag.props.size = 9000
incorrect_copy_tag.props.foreground = '#ff0000'
self.tagtable.add(incorrect_copy_tag)
# Set up the scrolling lesson text view.
self.lessonbuffer = gtk.TextBuffer(self.tagtable)
self.lessontext = gtk.TextView(self.lessonbuffer)
self.lessontext.set_editable(False)
self.lessontext.set_left_margin(20)
self.lessontext.set_right_margin(20)
self.lessontext.set_wrap_mode(gtk.WRAP_WORD)
self.lessontext.modify_base(gtk.STATE_NORMAL,
self.get_colormap().alloc_color('#ffffcc'))
self.lessonscroll = gtk.ScrolledWindow()
self.lessonscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.lessonscroll.add(self.lessontext)
frame = gtk.Frame()
frame.add(self.lessonscroll)
self.keyboard = keyboard.KeyboardWidget(self.keyboard_images,
self.activity)
self.keyboard.set_layout(keyboard.OLPC_LAYOUT)
self.pack_start(hbox, False, False, 10)
self.pack_start(frame, True, True)
self.pack_start(self.keyboard, True)
# Connect keyboard grabbing and releasing callbacks.
self.connect('realize', self.realize_cb)
self.connect('unrealize', self.unrealize_cb)
self.show_all()
self.timer_id = None
self.begin_lesson()
def __init__(self):
win = gtk.Window()
win.set_position(gtk.WIN_POS_CENTER)
win.set_title("CodeChat")
win.set_icon_name("gtk-dialog-info")
win.connect("destroy", win_quit)
leftEvent = gtk.EventBox()
rightEvent = gtk.EventBox()
#// main horizontal container, equal 1px spacing
mainBox = gtk.HBox(True, 1)
leftFrame = gtk.Frame("editor")
rightFrame = gtk.Frame("chat")
#// left and right containers, spacing not equal
leftVBox = gtk.VBox(False, 1)
rightVBox = gtk.VBox(False, 1)
#// build up the left side
editWindow = gtk.ScrolledWindow(None, None)
editWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
editWindow.set_shadow_type(gtk.SHADOW_IN)
self.EditBuffer = gtksourceview2.Buffer()
self.EditLangMgr = gtksourceview2.LanguageManager()
self.EditBuffer.set_highlight_syntax(True)
self.EditBuffer.set_highlight_matching_brackets(True)
lang = self.EditLangMgr.get_language("python")
self.EditBuffer.set_language(lang)
self.EditView = gtksourceview2.View(self.EditBuffer)
self.EditView.set_highlight_current_line(True)
self.EditView.set_show_line_numbers(True)
self.EditView.modify_font(pango.FontDescription("Monospace 8"))
self.EditStatusBar = gtk.Statusbar()
editWindow.add(self.EditView)
leftVBox.pack_start(editWindow, True, True, 1)
leftVBox.pack_end(self.EditStatusBar, False, False, 2)
leftFrame.add(leftVBox)
#// build up the right side
chatWindow = gtk.ScrolledWindow(None, None)
chatWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
chatWindow.set_shadow_type(gtk.SHADOW_IN)
chatTagTable = gtk.TextTagTable()
self.ChatBuffer = gtk.TextBuffer(chatTagTable)
self.ChatView = gtk.TextView(self.ChatBuffer)
self.ChatView.set_editable(False)
self.ChatView.set_cursor_visible(False)
chatWindow.add(self.ChatView)
chatHBox = gtk.HBox(False, 0)
self.MessageBuffer = gtk.EntryBuffer("", -1)
self.ChatEntry = gtk.Entry()
self.ChatEntry.set_buffer(self.MessageBuffer)
self.SendBtn = gtk.Button("send")
chatHBox.pack_start(self.ChatEntry, True, True, 0)
chatHBox.pack_end(self.SendBtn, False, False, 0)
rightVBox.pack_start(chatWindow, True, True, 1)
rightVBox.pack_start(chatHBox, False, False, 0)
rightFrame.add(rightVBox)
leftEvent.add(leftFrame)
rightEvent.add(rightFrame)
#// set up interface + layout
mainBox.pack_start(leftEvent, True, True, 0)
mainBox.pack_start(rightEvent, True, True, 0)
#// Show the window
win.add(mainBox)
win.set_size_request(800, 400)
win.show_all()
self.conclient = client.ConnectionClient()
#we need to query the user for username and connection info
self.dialog = gtk.Dialog("Connection Dialog", win, gtk.DIALOG_MODAL)
ulabel = gtk.Label("username")
ilabel = gtk.Label("IP Address:Port")
self.uentry = gtk.Entry()
self.ientry = gtk.Entry()
self.dialog.vbox.add(ulabel)
self.dialog.vbox.add(self.uentry)
self.dialog.vbox.add(ilabel)
self.dialog.vbox.add(self.ientry)
self.button = self.dialog.add_button("connect", gtk.RESPONSE_OK)
self.button.connect("clicked", self.connect)
self.ientry.connect("activate", self.connect)
#self.dialog.response(self.connect)
self.dialog.show_all()
response = self.dialog.run()
print("here- after dialog")
#instantiate read thread
self.read_thread = threading.Thread(None, self.doRead, 'read_thread')
self.read_thread.start()
# Window activity Constants
HILIT = 'h'
TEXT = 't'
EVENT = 'e'
CURRENT = 'c'
ACTIVITY_MARKUP = {
HILIT: "<span style='italic' foreground='#00F'>%s</span>",
TEXT: "<span foreground='#ca0000'>%s</span>",
EVENT: "<span foreground='#363'>%s</span>",
CURRENT: "<span foreground='#000000'>%s</span>",
}
# This holds all tags for all windows ever
tag_table = gtk.TextTagTable()
link_tag = gtk.TextTag('link')
link_tag.set_property('underline', pango.UNDERLINE_SINGLE)
indent_tag = gtk.TextTag('indent')
indent_tag.set_property('indent', -20)
tag_table.add(link_tag)
tag_table.add(indent_tag)
#FIXME: MEH hates dictionaries, they remind him of the bad words
styles = {}
def style_me(widget, style):
