tags = dict()

for (name, value) in color_scheme.iteritems():

tag = tags[name] = text_buffer.create_tag(name)

for (char, prop) in zip(value, ['foreground', 'background']):

if char.lower() == 'd':

continue

tag.set_property(prop, _COLORS[char.lower()])

if char.isupper():

tag.set_property('weight', pango.WEIGHT_BOLD)

"""

def format(self, args, varargs, varkw, defaults, in_arg):

self.args_seen = 0

self.in_arg = in_arg

return inspect.formatargspec(args, varargs, varkw, defaults,

self.formatarg,

formatvalue=self.formatvalue)

def formatarg(self, name):

if name == self.in_arg or self.args_seen == self.in_arg:

string = '<b><i>%s</i></b>' % (name, )

else:

string = name

self.args_seen += 1

return string

def formatvalue(self, value):

def __init__(self, exc_type, exc_value, tb, text=None):

if text is None:

text = _('An error occurred.')

gtk.MessageDialog.__init__(self, buttons=gtk.BUTTONS_CLOSE,

type=gtk.MESSAGE_ERROR,

message_format=text)

self.set_resizable(True)

import cgitb

text = cgitb.text((exc_type, exc_value, tb), 5)

expander = gtk.Expander(_('Exception details'))

self.vbox.pack_start(expander)

textview = gtk.TextView()

textview.get_buffer().set_text(text)

scrolled_window = gtk.ScrolledWindow()

scrolled_window.add(textview)

expander.add(scrolled_window)

"""

def __init__(self, DialogType, text=None):

self.DialogType = DialogType

self.text = text or _('An error occurred.')

def __enter__(self):

return self

def __exit__(self, exc_type, exc_value, traceback):

if not (exc_value is None or

issubclass(exc_type, (KeyboardInterrupt, SystemExit))):

dialog = self.DialogType(exc_type, exc_value, traceback, self.text)

dialog.run()

"""

def __init__(self):

self.counter = 0

def __enter__(self):

self.counter += 1

return self

def __exit__(self, exc_type, exc_value, exc_tb):

self.counter -= 1

def __nonzero__(self):

"""Contains feedback messages"""

def __init__(self):

gtk.Statusbar.__init__(self)

self.context_id = self.get_context_id(_('Statusbar'))

def message(self, s, n=3):

self.clear()

self.push(self.context_id, s)

gobject.timeout_add(n*1000, self.clear)

def clear(self):

self.pop(self.context_id)

# To stop the timeout from firing again

"""

__gsignals__ = dict(expose_event=None,

selection_changed=(gobject.SIGNAL_RUN_LAST, None,

(str, )))

def __init__(self):

gtk.Window.__init__(self, gtk.WINDOW_POPUP)

self.set_app_paintable(True)

self.set_border_width(4)

self.set_decorated(False)

self.set_name('gtk-tooltips')

self.argspec_formatter = ArgspecFormatter()

vbox = gtk.VBox(homogeneous=False)

vbox.set_style(self.get_style())

self.argspec_label = gtk.Label()

self.argspec_label.set_alignment(0, 0)

self.argspec_label.set_line_wrap(True)

self.argspec_label.set_use_markup(True)

vbox.pack_start(self.argspec_label, expand=False)

self.docstring_label = gtk.Label()

self.docstring_label.set_alignment(0, 0)

style = self.docstring_label.get_style()

#color = _COLORS[self.config.color_scheme['comment'].lower()]

#color = gtk.gdk.color_parse(color)

#style.fg[gtk.STATE_NORMAL] = color

self.docstring_label.set_style(style)

vbox.pack_start(self.docstring_label, expand=False)

self.model = gtk.ListStore(str, str)

self.view = gtk.TreeView(self.model)

self.view.set_headers_visible(False)

self.view.set_style(self.get_style())

column = gtk.TreeViewColumn(None, gtk.CellRendererText(),

text=0, background=1)

self.view.append_column(column)

self.view.get_selection().connect('changed', self.on_selection_changed)

sw = gtk.ScrolledWindow()

sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

sw.add(self.view)

vbox.pack_start(sw)

self.add(vbox)

self.resize(300, 150)

self.show_all()

def back(self):

if len(self.model):

self.select(-1)

def do_expose_event(self, event):

"""

width, height = self.get_size()

self.style.paint_flat_box(self.window, gtk.STATE_NORMAL,

gtk.SHADOW_OUT, None, self,

_('tooltip'), 0, 0, width, height)

gtk.Window.do_expose_event(self, event)

def forward(self):

if len(self.model):

self.select(1)

def on_selection_changed(self, selection):

model, iter_ = selection.get_selected()

if iter_ is not None:

value = model.get_value(iter_, 0)

self.emit('selection-changed', value)

def select(self, offset):

"""

selection = self.view.get_selection()

model, iter_ = selection.get_selected()

if iter_ is not None:

row = model.get_path(iter_)[0]

row += offset

else:

row = 0

if row < 0:

row = len(model) - 1

elif row >= len(model):

row = 0

iter_ = model.get_iter(row)

selection.select_iter(iter_)

self.view.scroll_to_cell(row)

def update_argspec(self, argspec):

if argspec:

func_name, args, is_bound_method, in_arg = argspec[:4]

args, varargs, varkw, defaults = args[:4]

if is_bound_method and isinstance(in_arg, int):

in_arg += 1

argspec = self.argspec_formatter.format(args, varargs, varkw,

defaults, in_arg)

markup = '<b>%s</b>%s' % (func_name, argspec)

self.argspec_label.set_markup(markup)

self.argspec_label.set_property('visible', bool(argspec))

def update_docstring(self, docstring):

self.docstring_label.set_text(docstring)

self.docstring_label.set_property('visible', bool(docstring))

def update_matches(self, matches):

self.model.clear()

bg = self.get_style().bg[gtk.STATE_NORMAL]

for match in matches:

self.model.append([match, bg.to_string()])

def __init__(self, config, statusbar):

repl.Interaction.__init__(self, config, statusbar)

def confirm(self, q):

dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO,

gtk.BUTTONS_YES_NO, q)

response = dialog.run()

dialog.destroy()

return response == gtk.RESPONSE_YES

def file_prompt(self, s):

chooser = gtk.FileChooserDialog(title=_("File to save to"),

action=gtk.FILE_CHOOSER_ACTION_SAVE,

buttons=(gtk.STOCK_CANCEL,

gtk.RESPONSE_CANCEL,

gtk.STOCK_OPEN,

gtk.RESPONSE_OK))

chooser.set_default_response(gtk.RESPONSE_OK)

chooser.set_current_name('test.py')

chooser.set_current_folder(os.path.expanduser('~'))

pyfilter = gtk.FileFilter()

pyfilter.set_name(_("Python files"))

pyfilter.add_pattern("*.py")

chooser.add_filter(pyfilter)

allfilter = gtk.FileFilter()

allfilter.set_name(_("All files"))

allfilter.add_pattern("*")

chooser.add_filter(allfilter)

response = chooser.run()

if response == gtk.RESPONSE_OK:

fn = chooser.get_filename()

else:

fn = False

chooser.destroy()

return fn

def notify(self, s, n=10):

__gsignals__ = dict(button_press_event=None,

focus_in_event=None,

focus_out_event=None,

realize=None,

exit_event=(gobject.SIGNAL_RUN_LAST, None, ()))

def __init__(self, interpreter, config):

gtk.TextView.__init__(self)

repl.Repl.__init__(self, interpreter, config)

self.interp.writetb = self.writetb

self.editing = Nested()

self.reset_indent = False

self.modify_font(pango.FontDescription(self.config.gtk_font))

self.set_wrap_mode(gtk.WRAP_CHAR)

self.list_win = SuggestionWindow()

self.list_win.connect('selection-changed',

self.on_suggestion_selection_changed)

self.list_win.hide()

self.modify_base('normal', gtk.gdk.color_parse(_COLORS[self.config.color_gtk_scheme['background']]))

self.text_buffer = self.get_buffer()

self.interact = GTKInteraction(self.config, Statusbar())

tags = add_tags_to_buffer(self.config.color_gtk_scheme, self.text_buffer)

tags['prompt'].set_property('editable', False)

self.text_buffer.connect('delete-range', self.on_buf_delete_range)

self.text_buffer.connect('insert-text', self.on_buf_insert_text)

self.text_buffer.connect('mark-set', self.on_buf_mark_set)

def change_line(self, line):

"""

with self.editing:

self.text_buffer.delete(self.get_line_start_iter(),

self.get_line_end_iter())

if self.config.syntax:

self.insert_highlighted(self.get_line_start_iter(), line)

else:

self.text_buffer.insert(self.get_line_start_iter(), line)

def clear_current_line(self):

"""

repl.Repl.clear_current_line(self)

self.reset_indent = True

def complete(self):

if self.config.auto_display_list:

self.list_win_visible = repl.Repl.complete(self)

if self.list_win_visible:

self.list_win.update_argspec(self.argspec)

self.list_win.update_docstring(self.docstring or '')

self.list_win.update_matches(self.matches)

iter_rect = self.get_iter_location(self.get_cursor_iter())

x, y = self.window.get_origin()

_, height = self.get_line_yrange(self.get_cursor_iter())

self.list_win.move(x + iter_rect.x,

y + iter_rect.y + height)

self.list_win.show()

else:

self.list_win.hide()

@property

def cpos(self):

cpos = (self.get_line_end_iter().get_offset() -

self.get_cursor_iter().get_offset())

if cpos and not self.get_overwrite():

cpos += 1

return cpos

def cw(self):

"""

return self.text_buffer.get_text(self.get_word_start_iter(),

self.get_cursor_iter())

def current_line(self):

"""

return self.text_buffer.get_slice(self.get_line_start_iter(),

self.get_line_end_iter())

def echo(self, string):

with self.editing:

self.text_buffer.insert_with_tags_by_name(self.get_cursor_iter(),

string, 'output')

self.move_cursor(len(string))

def get_cursor_iter(self):

"""

cursor_marker = self.text_buffer.get_insert()

return self.text_buffer.get_iter_at_mark(cursor_marker)

def get_line_start_iter(self):

"""

line_start_marker = self.text_buffer.get_mark('line_start')

if line_start_marker is None:

return self.text_buffer.get_start_iter()

return self.text_buffer.get_iter_at_mark(line_start_marker)

def get_line_end_iter(self):

"""

iter_ = self.get_line_start_iter()

if not iter_.ends_line() and not iter_.forward_to_line_end():

iter_ = self.text_buffer.get_end_iter()

return iter_

def get_word_start_iter(self):

iter_ = self.get_cursor_iter()

pred = lambda char, _: not (char.isalnum() or char in '_.')

if iter_.backward_find_char(pred, None, self.get_line_start_iter()):

iter_.forward_char()

return iter_

def do_button_press_event(self, event):

if self.list_win_visible:

self.list_win.hide()

return gtk.TextView.do_button_press_event(self, event)

def do_focus_in_event(self, event):

if self.list_win_visible:

self.list_win.show()

return gtk.TextView.do_focus_in_event(self, event)

def do_focus_out_event(self, event):

if self.list_win_visible:

self.list_win.hide()

return gtk.TextView.do_focus_out_event(self, event)

def do_key_press_event(self, event):

state = event.state & (gtk.gdk.CONTROL_MASK |

gtk.gdk.MOD1_MASK |

gtk.gdk.MOD4_MASK |

gtk.gdk.SHIFT_MASK)

if not state:

if event.keyval == gtk.keysyms.F2:

source = self.get_source_of_current_name()

if source is not None:

show_source_in_new_window(source, self.config.color_gtk_scheme,

self.config.syntax)

else:

self.interact.notify(_('Cannot show source.'))

elif event.keyval == gtk.keysyms.Return:

if self.list_win_visible:

self.list_win_visible = False

self.list_win.hide()

self.rl_history.reset()

line = self.current_line()

more = self.push_line()

self.prompt(more)

if self.reset_indent:

self.reset_indent = False

else:

indentation = self.next_indentation()

if indentation:

with self.editing:

self.text_buffer.insert(self.get_cursor_iter(),

'\t' * indentation)

self.move_cursor(indentation)

return True

elif event.keyval == gtk.keysyms.Tab and self.list_win_visible:

self.list_win.forward()

return True

elif event.keyval == gtk.keysyms.Up:

if self.list_win_visible:

self.list_win.back()

else:

if not self.rl_history.is_at_end:

self.rl_history.enter(self.current_line())

self.change_line(self.rl_history.back())

self.text_buffer.place_cursor(self.get_line_end_iter())

return True

elif event.keyval == gtk.keysyms.Down:

if self.list_win_visible:

self.list_win.forward()

else:

if not self.rl_history.is_at_start:

self.rl_history.enter(self.current_line())

self.change_line(self.rl_history.forward())

self.text_buffer.place_cursor(self.get_line_end_iter())

return True

elif state & gtk.gdk.SHIFT_MASK:

if (event.keyval == gtk.keysyms.ISO_Left_Tab and

self.list_win_visible):

self.list_win.back()

return True

elif state & gtk.gdk.CONTROL_MASK:

if event.string == chr(4) and not self.current_line():

self.emit('exit-event')

return True

return gtk.TextView.do_key_press_event(self, event)

def do_realize(self):

gtk.TextView.do_realize(self)

self.prompt(False)

def highlight(self, start_iter, tokens):

"""

token_start_iter = start_iter.copy()

token_end_iter = start_iter.copy()

for (token, value) in tokens:

while token not in theme_map:

token = token.parent

token_end_iter.forward_chars(len(value))

self.text_buffer.apply_tag_by_name(theme_map[token],

token_start_iter, token_end_iter)

token_start_iter.forward_chars(len(value))

def highlight_current_line(self):

"""

if self.config.syntax:

if self.highlighted_paren is not None:

self.reprint_line(*self.highlighted_paren)

self.highlighted_paren = None

start = self.get_line_start_iter()

self.text_buffer.remove_all_tags(start, self.get_line_end_iter())

self.highlight(start, self.tokenize(self.current_line()))

def insert_highlighted(self, iter_, string):

offset = iter_.get_offset()

newline = iter_.forward_to_line_end()

# self.tokenize() may call self.reprint_line(), which will

# invalidate iters.

tokens = self.tokenize(string, newline)

iter_ = self.text_buffer.get_iter_at_offset(offset)

self.insert_highlighted_tokens(iter_, tokens)

def insert_highlighted_tokens(self, iter_, tokens):

offset = iter_.get_offset()

buffer = self.text_buffer

for (token, value) in tokens:

while token not in theme_map:

token = token.parent

iter_ = buffer.get_iter_at_offset(offset)

with self.editing:

buffer.insert_with_tags_by_name(iter_, value,

theme_map[token])

offset += len(value)

def move_cursor(self, offset):

"""

iter_ = self.get_cursor_iter()

iter_.forward_chars(offset)

self.text_buffer.place_cursor(iter_)

return iter_

def on_buf_delete_range(self, buffer, start, end):

if self.editing:

return

buffer.emit_stop_by_name('delete-range')

# Only allow editing of the current line and not of previous ones

line_start = self.get_line_start_iter()

if end.compare(line_start) < 0:

return

elif start.compare(line_start) < 0:

start = line_start

with self.editing:

buffer.delete(start, end)

self.highlight_current_line()

self.complete()

def on_buf_insert_text(self, buffer, iter_, text, length):

if self.editing:

return

self.set_cursor_to_valid_insert_position()

buffer.emit_stop_by_name('insert-text')

for (i, line) in enumerate(text.splitlines()):

if i:

self.prompt(self.push_line())

with self.editing:

buffer.insert_at_cursor(line)

self.highlight_current_line()

self.complete()

def on_buf_mark_set(self, buffer, iter_, textmark):

if (textmark.get_name() == 'insert' and

self.get_line_start_iter().compare(iter_) < 0):

self.highlight_current_line()

def on_suggestion_selection_changed(self, selection, word):

with self.editing:

self.text_buffer.delete(self.get_word_start_iter(),

self.get_cursor_iter())

self.text_buffer.insert_at_cursor(word)

def do_paste(self, widget):

clipboard = gtk.clipboard_get()

paste_url = self.pastebin()

if paste_url:

clipboard.set_text(paste_url)

clipboard.store()

def do_write2file(self, widget):

self.write2file()

def do_partial_paste(self, widget):

bounds = self.text_buffer.get_selection_bounds()

if bounds == ():

# FIXME show a nice status bar message

pass

else:

self.pastebin(self.text_buffer.get_text(bounds[0], bounds[1]))

def write(self, s):

"""For overriding stdout defaults"""

if '\x04' in s:

for block in s.split('\x04'):

self.write(block)

return

if s.rstrip() and '\x03' in s:

t = s.split('\x03')[1]

else:

t = s

if not py3 and isinstance(t, unicode):

t = t.encode(getpreferredencoding())

self.echo(s)

self.s_hist.append(s.rstrip())

def prompt(self, more):

"""

if more:

text = self.ps2

else:

text = self.ps1

with self.editing:

iter_ = self.get_cursor_iter()

self.text_buffer.insert_with_tags_by_name(iter_, text, 'prompt')

iter_.forward_chars(len(text))

mark = self.text_buffer.create_mark('line_start', iter_, True)

self.text_buffer.place_cursor(iter_)

self.scroll_to_mark(mark, 0.2)

def push_line(self):

line = self.current_line()

# Save mark for easy referencing later

self.text_buffer.create_mark('line%i_start' % (len(self.buffer), ),

self.get_line_start_iter(), True)

iter_ = self.get_line_end_iter()

self.text_buffer.place_cursor(iter_)

with self.editing:

self.text_buffer.insert(iter_, '\n')

self.move_cursor(1)

self.highlight_current_line()

try:

return self.push(line + '\n')

except SystemExit:

self.emit('exit-event')

return False

def reprint_line(self, lineno, tokens):

"""

if not self.buffer or lineno == len(self.buffer):

return

mark = self.text_buffer.get_mark('line%i_start' % (lineno, ))

start = self.text_buffer.get_iter_at_mark(mark)

end = start.copy()

end.forward_to_line_end()

self.text_buffer.remove_all_tags(start, end)

self.highlight(start, tokens)

def set_cursor_to_valid_insert_position(self):

cursor_iter = self.get_cursor_iter()

line_start_iter = self.get_line_start_iter()

if line_start_iter.compare(cursor_iter) > 0:

self.text_buffer.place_cursor(line_start_iter)

def getstdout(self):

bounds = self.text_buffer.get_bounds()

text = self.text_buffer.get_text(bounds[0], bounds[1])

return text

def writetb(self, lines):

with ExceptionManager(ExceptionDialog,

'An error occured while trying to display '

'an error. Please contact the bpython '

'developers.'):

string = ''.join(lines)

with self.editing:

self.text_buffer.insert_with_tags_by_name(

self.get_cursor_iter(), string, 'error'

)

win = gtk.Window()

sw = gtk.ScrolledWindow()

view = gtk.TextView()

buffer = view.get_buffer()

if highlight:

add_tags_to_buffer(color_scheme, buffer)

for (token, value) in PythonLexer().get_tokens(source):

while token not in theme_map:

token = token.parent

iter_ = buffer.get_end_iter()

buffer.insert_with_tags_by_name(iter_, value, theme_map[token])

else:

buffer.insert(buffer.get_end_iter(), source)

sw.add(view)

win.add(sw)

try:

importcompletion.find_iterator.next()

except StopIteration:

return False

else:

translations.init()

gtk_options = (_('gtk-specific options'),

_("Options specific to bpython's Gtk+ front end"),

[optparse.Option('--socket-id', dest='socket_id',

type='int', help=_('Embed bpython'))])

config, options, exec_args = bpython.args.parse(args, gtk_options,

True)

interpreter = repl.Interpreter(None, getpreferredencoding())

repl_widget = ReplWidget(interpreter, config)

repl_widget.connect('exit-event', gtk.main_quit)

gobject.idle_add(init_import_completion)

if not exec_args:

sys.path.insert(0, '')

gobject.idle_add(repl_widget.startup)

else:

if options.interactive:

gobject.idle_add(bpython.args.exec_code, interpreter, exec_args)

else:

bpython.args.exec_code(interpreter, exec_args)

return 0

sys.stderr = repl_widget

sys.stdout = repl_widget

if not options.socket_id:

parent = gtk.Window()

parent.connect('delete-event', lambda widget, event: gtk.main_quit())

# branding

# fix icon to be distributed and loaded from the correct path

icon = gtk.gdk.pixbuf_new_from_file(os.path.join(os.path.dirname(__file__),

'logo.png'))

parent.set_title('bpython')

parent.set_icon(icon)

parent.resize(600, 300)

else:

parent = gtk.Plug(options.socket_id)

parent.connect('destroy', gtk.main_quit)

container = gtk.VBox()

parent.add(container)

mb = gtk.MenuBar()

filemenu = gtk.Menu()

filem = gtk.MenuItem("File")

filem.set_submenu(filemenu)

save = gtk.ImageMenuItem(gtk.STOCK_SAVE)

save.connect("activate", repl_widget.do_write2file)

filemenu.append(save)

pastebin = gtk.MenuItem("Pastebin")

pastebin.connect("activate", repl_widget.do_paste)

filemenu.append(pastebin)

pastebin_partial = gtk.MenuItem(_("Pastebin selection"))

pastebin_partial.connect("activate", repl_widget.do_partial_paste)

filemenu.append(pastebin_partial)

exit = gtk.ImageMenuItem(gtk.STOCK_QUIT)

exit.connect("activate", gtk.main_quit)

filemenu.append(exit)

mb.append(filem)

vbox = gtk.VBox(False, 2)

vbox.pack_start(mb, False, False, 0)

container.pack_start(vbox, expand=False)

# read from config

sw = gtk.ScrolledWindow()

sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)

sw.add(repl_widget)

container.add(sw)

sb = repl_widget.interact.statusbar

container.pack_end(sb, expand=False)

parent.set_focus(repl_widget)

parent.show_all()

parent.connect('delete-event', lambda widget, event: gtk.main_quit())

try:

gtk.main()

except KeyboardInterrupt:

pass