Inheritance diagram for pycons.console.Console:

Public Member Functions
def	__init__ (self, argv=[], shelltype='python', banner=[], filename=None, size=100, user_local_ns=None, user_global_ns=None)

def	history_init (self, filename, size)

def	history_save (self)

def	history_add (self, item)

def	history_reset (self)

def	history_next (self)

def	history_prev (self)

def	raw_input (self, prompt='')

def	grab_focus (self)

def	write (self, text, style=None)

def	overwrite (self, text, style=None)

def	last_line (self)

def	prompt (self, style=None)

def	key_press_event (self, widget, event)

def	execute (self)

def	quit (self)

Data Fields
	do_quit

	view

	buffer

	color_pat

	killbuffer

	argv

	cout

	shell

	interrupt

	input_mode

	input

	stdout

	stderr

	stdin

	fifoname

	piperead

	pipewrite

	history_file

	history_size

	history_index

Detailed Description

GTK python console

Definition at line 125 of file console.py.

Constructor & Destructor Documentation

◆ init()

def pycons.console.Console.__init__	(	self,
		argv = `[]`,
		shelltype = `'python'`,
		banner = `[]`,
		filename = `None`,
		size = `100`,
		user_local_ns = `None`,
		user_global_ns = `None`
	)

Console interface building + initialization

Definition at line 129 of file console.py.

                  filename=None, size=100, user_local_ns=None, user_global_ns=None):
 
         """ Console interface building + initialization"""
 
         # GTK interface
         self.do_quit = False
         GObject.GObject.__init__(self)
         self.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
         self.set_shadow_type (Gtk.ShadowType.NONE)
         self.set_border_width(0)
         self.view = Gtk.TextView()
         self.view.modify_font (Pango.FontDescription("Mono 10"))
         self.view.set_editable (True)
         self.view.set_wrap_mode(True)
         self.view.set_left_margin(0)
         self.view.set_right_margin(0)
         self.buffer = self.view.get_buffer()
         self.buffer.create_tag ('title',
                                 indent = 2,
                                 weight=Pango.Weight.BOLD,
                                 foreground='blue',
                                 font='Mono 12')
         self.buffer.create_tag ('subtitle',
                                 indent = 2,
                                 foreground='blue',
                                 font='Mono 8')
         self.buffer.create_tag ('output',
                                 foreground = 'blue',
                                 font='Mono 10')
         self.buffer.create_tag ('error',
                                 foreground='red',
                                 style=Pango.Style.OBLIQUE,
                                 font='Mono 10')
         self.buffer.create_tag ('prompt',
                                 foreground='blue',
                                 weight=Pango.Weight.BOLD,
                                 font='Mono 10')
         self.buffer.create_tag('0')
         self.color_pat = re.compile(r'\x01?\x1b\[(.*?)m\x02?')
         for code in ansi_colors:
             self.buffer.create_tag(code,
                                    foreground=ansi_colors[code],
                                    weight=700)
         for text, style in banner:
             self.write (text, style)
         iter = self.buffer.get_iter_at_mark(self.buffer.get_insert())
         self.buffer.create_mark ('linestart', iter, True)
         self.view.add_events(Gdk.EventMask.KEY_PRESS_MASK)
         self.view.connect ('key-press-event', self.key_press_event)
         self.add(self.view)
         self.show_all()
         self.killbuffer = None
 
         # Console stuff
         self.argv = argv
         self.history_init(filename, size)
         self.cout = io.StringIO()
         self.cout.truncate(0)
 
         if not user_local_ns:
             user_local_ns = locals()
         if not user_global_ns:
             user_global_ns = globals()
 
         if shelltype=='ipython':
             self.shell = ishell.Shell(argv,user_local_ns, user_global_ns,
                                 cout=self.cout, cerr=self.cout,
                                 input_func=self.raw_input)
         else:
             self.shell = shell.Shell(user_local_ns,user_global_ns)
         self.interrupt = False
         self.input_mode = False
         self.input = None
         self.stdout = ConsoleOut (self, sys.stdout.fileno(), 'output')
         self.stderr = ConsoleOut (self, sys.stderr.fileno(), 'error')
         self.stdin  = ConsoleIn  (self, sys.stdin.fileno())
 
         # Create a named pipe for system stdout/stderr redirection
         self.fifoname = tempfile.mktemp()
         if not os.path.exists (self.fifoname):
             os.mkfifo (self.fifoname)
         self.piperead  = os.open (self.fifoname, os.O_RDONLY | os.O_NONBLOCK)
         self.pipewrite = os.open (self.fifoname, os.O_WRONLY | os.O_NONBLOCK)
         self.shell.eval(self)
         self.cout.truncate(0)
 

Member Function Documentation

◆ grab_focus()

def pycons.console.Console.grab_focus ( self )

Give focus to the TextView

Definition at line 255 of file console.py.

     def grab_focus (self):
         """ Give focus to the TextView """
 
         self.view.grab_focus()
 

◆ key_press_event()

def pycons.console.Console.key_press_event	(	self,
		widget,
		event
	)

Handle key press event

Definition at line 309 of file console.py.

     def key_press_event (self, widget, event):
         """ Handle key press event """
 
         keyname = Gdk.keyval_name (event.keyval)
 
         # New command
         if keyname in ['Return', 'KP_Enter']:
             line = self.last_line()
             self.history_add (line)
             if self.input_mode:
                 self.input_mode = False
                 self.input = self.last_line()
                 self.write('\n')
             else:
                 self.execute()
             return True
 
         # Prevent cursor to go back past prompt
         elif keyname in ['Left', 'BackSpace']:
             mark = self.buffer.get_mark('linestart')
             linestart = self.buffer.get_iter_at_mark(mark)
             iter = self.buffer.get_iter_at_mark(self.buffer.get_insert())
             if iter.compare(linestart) <= 0:
                 return True
 
         elif keyname == 'Right':
             return False
         
         # Next history item
         elif keyname == 'Down':
             self.overwrite (self.history_next())
             return True
 
         # Previous history item
         elif keyname == 'Up':
             self.overwrite (self.history_prev())
             return True
 
         # Move cursor just after prompt
         elif keyname == 'Home':
             mark = self.buffer.get_mark('linestart')
             linestart = self.buffer.get_iter_at_mark(mark)
             self.buffer.place_cursor (linestart)
             return True
 
         # Completion if line not empty
         elif keyname == 'Tab':
             line = self.last_line()
             if not line.strip():
                 return False
             completed, possibilities = self.shell.complete(line)
             if len(possibilities) > 1:
                 slice = line
                 self.write('\n')
                 for symbol in possibilities:
                     self.write(symbol+'\n')
                 self.prompt('prompt')
             self.overwrite(completed or slice)
             return True
 
         # Controls
         elif event.get_state() & Gdk.ModifierType.CONTROL_MASK:
             if keyname in ['a','A']:
                 mark = self.buffer.get_mark('linestart')
                 linestart = self.buffer.get_iter_at_mark(mark)
                 self.buffer.place_cursor (linestart)
                 return True
             elif keyname in ['e','E']:
                 end = self.buffer.get_end_iter()
                 self.buffer.place_cursor (end)
                 return True
             elif keyname in ['k','K']:
                 start = self.buffer.get_iter_at_mark (self.buffer.get_insert())
                 end = self.buffer.get_end_iter()
                 self.killbuffer = self.buffer.get_text(start,end)
                 self.buffer.delete(start,end)
                 return True
             elif keyname in ['y','Y']:
                 if self.killbuffer:
                     iter = self.buffer.get_iter_at_mark (self.buffer.get_insert())
                     self.buffer.insert(iter, self.killbuffer)
                 return True
             elif keyname in ['l', 'L']:
                 start = self.buffer.get_start_iter()
                 end = self.buffer.get_end_iter()
                 end.backward_sentence_start()
                 self.buffer.delete (start,end)
             elif keyname in ['d', 'D']:
                 if not len(self.last_line().strip()):
                     self.quit()
 
         # Editing before prompt is forbidden
         else:
             mark = self.buffer.get_mark('linestart')
             linestart = self.buffer.get_iter_at_mark(mark)
             iter = self.buffer.get_iter_at_mark(self.buffer.get_insert())
             if iter.compare(linestart) < 0:
                 iter = self.buffer.get_end_iter()
                 self.buffer.place_cursor (iter)
         return False
 
 

◆ last_line()

def pycons.console.Console.last_line ( self )

Get last line (without prompt)

Definition at line 287 of file console.py.

     def last_line (self):
         """ Get last line (without prompt) """
         
         mark = self.buffer.get_mark('linestart')
         start = self.buffer.get_iter_at_mark(mark)
         end = self.buffer.get_end_iter()
         return self.buffer.get_text (start,end,True)
 
 

◆ overwrite()

def pycons.console.Console.overwrite	(	self,
		text,
		style = `None`
	)

Overwrite text after prompt with text

Definition at line 278 of file console.py.

     def overwrite (self, text, style=None):
         """ Overwrite text after prompt with text """
 
         mark = self.buffer.get_mark('linestart')
         start = self.buffer.get_iter_at_mark(mark)
         end = self.buffer.get_end_iter()
         self.buffer.delete (start,end)
         self.write (text, style)
 

◆ prompt()

def pycons.console.Console.prompt	(	self,
		style = `None`
	)

Display prompt

Definition at line 296 of file console.py.

     def prompt (self, style=None):
         """ Display prompt """
 
         iter = self.buffer.get_end_iter()
         self.buffer.place_cursor (iter)
         self.write (self.shell.prompt, style)
         iter = self.buffer.get_iter_at_mark(self.buffer.get_insert())
         self.buffer.move_mark (self.buffer.get_mark('linestart'), iter)
         self.history_reset()
         self.view.scroll_mark_onscreen(self.buffer.get_insert())
         while Gtk.events_pending():
             Gtk.main_iteration()
 

◆ quit()

def pycons.console.Console.quit ( self )

Quit console

Definition at line 440 of file console.py.

     def quit(self):
         """ Quit console """
 
         self.history_save()
         try:
             os.close (self.piperead)
             os.close (self.pipewrite)
         except:
             pass
         if os.path.exists (self.fifoname):
             os.remove (self.fifoname)
         self.do_quit = True
 

◆ write()

def pycons.console.Console.write	(	self,
		text,
		style = `None`
	)

Write text using given style (if any)

Definition at line 260 of file console.py.

     def write (self, text, style=None):
         """ Write text using given style (if any) """
         segments = self.color_pat.split(text)
         segment = segments.pop(0)
         start,end = self.buffer.get_bounds()
         if style==None:
             self.buffer.insert(end, segment)
         else:
             self.buffer.insert_with_tags_by_name(end, segment, style)
         if segments:
             ansi_tags = self.color_pat.findall(text)
             for tag in ansi_tags:
                 i = segments.index(tag)
                 self.buffer.insert_with_tags_by_name(self.buffer.get_end_iter(),
                                                      segments[i+1], tag)
                 segments.pop(i)
         self.view.scroll_mark_onscreen(self.buffer.get_insert())
 

The documentation for this class was generated from the following file:

console.py

Public Member Functions

Data Fields