def init_ui(self):
self.box = gtk.Notebook()
self.box.set_show_tabs(False)
self.box.set_show_border(False)
align = gtk.Alignment()
align.set_padding(2, 2, 2, 2)
evbox = gtk.EventBox()
evbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
terminalbox = gtk.HBox()
scrollbar = gtk.VScrollbar()
self.error_label = gtk.Label()
self.error_label.set_width_chars(40)
self.error_label.set_line_wrap(True)
if self.terminal:
scrollbar.set_adjustment(self.terminal.get_adjustment())
align.add(self.terminal)
evbox.add(align)
terminalbox.pack_start(evbox)
terminalbox.pack_start(scrollbar, expand=False, fill=False)
self.box.append_page(terminalbox)
self.box.append_page(self.error_label)
self.box.show_all()
def on_NewToolBar_clicked(self, *args):
"""
Callback function called when NewToolBar is clicked. Creates a new tab with an empty diagram.
"""
# maybe pass to a s2iView base class
new_diagram = GcDiagram(self) # created new diagram
table = gtk.Table(2, 2, False)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
table.attach(frame, 0, 1, 0, 1,
gtk.EXPAND | gtk.FILL | gtk.SHRINK,
gtk.EXPAND | gtk.FILL | gtk.SHRINK)
frame.add(new_diagram)
t_oVAdjustment = gtk.VScrollbar(new_diagram.get_vadjustment())
t_oHAdjustment = gtk.HScrollbar(new_diagram.get_hadjustment())
table.attach(t_oVAdjustment, 1, 2, 0, 1, gtk.FILL, gtk.EXPAND | gtk.FILL | gtk.SHRINK)
table.attach(t_oHAdjustment, 0, 1, 1, 2, gtk.EXPAND | gtk.FILL | gtk.SHRINK, gtk.FILL)
table.show_all()
# tab label
current_page = self.widgets['WorkArea'].get_current_page()
label = gtk.Label(_("Unnamed ") + str(current_page + 1) + "[*]")
self.widgets['WorkArea'].set_show_tabs(True)
self.widgets['WorkArea'].append_page(table, label)
t_nSelectedPage = self.widgets['WorkArea'].get_n_pages() - 1
self.widgets['WorkArea'].set_current_page(t_nSelectedPage)
self.diagrams[self.widgets['WorkArea'].get_current_page()] = new_diagram
def create_ui(self):
self.widget.set_data('delegate', self)
self.pid = None
self.cwd = None
self.box = gtk.HBox()
self.box.set_spacing(3)
self.widget.add(self.box)
self.tools = gtk.VBox()
self.tools2 = gtk.VBox()
self.box.pack_start(self.tools, expand=False)
self.stack = gtk.VBox()
self.box.pack_start(self.stack)
self.terminal = vte.Terminal()
self.config = TerminalConfiguration()
self.config.update(self.model.config.get('terminal', {}))
self.config.configure(self.terminal)
self.add_contexts()
# Fix the size because by default it is huge.
self.terminal.set_size_request(50, 50)
self.stack.pack_start(self.terminal)
self.scrollbar = gtk.VScrollbar()
self.scrollbar.set_adjustment(self.terminal.get_adjustment())
self.box.pack_start(self.scrollbar, expand=False)
self.box.pack_start(self.tools2, expand=False)
self.create_tools()
self.create_finder()
def _read_gtk_theme_info(self):
"""
Reads some info from the GTK theme to better adapt to it
"""
scrollbar = gtk.VScrollbar()
self.scrollbar_width = scrollbar.style_get_property('slider-width')
def vte_con(ct, ttynum):
print("Doing console in a VTE widget...")
masterfd = ct.console_getfd(ttynum)
term = vte.Terminal()
term.set_cursor_blinks(True)
term.set_scrollback_lines(1000)
term.connect('eof', gtk_exit_cb)
term.set_pty(masterfd)
term.feed_child('\n')
#term.feed_child('ps aux\n')
vscrollbar = gtk.VScrollbar()
vscrollbar.set_adjustment(term.get_adjustment())
hbox = gtk.HBox()
hbox.pack_start(term)
hbox.pack_start(vscrollbar)
window = gtk.Window()
window.add(hbox)
window.connect('delete-event', lambda window, event: gtk.main_quit())
window.show_all()
gtk.main()
print("Console done")
def __init__(sfelf, handle):
import gtk, pango, vte
super(VteActivity, self).__init__(handle)
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# creates vte widget
self._vte = vte.Terminal()
self._vte.set_size(30, 5)
self._vte.set_size_request(200, 300)
font = 'Monospace 10'
self._vte.set_font(pango.FontDescription(font))
self._vte.set_colors(gtk.gdk.color_parse('#000000'),
gtk.gdk.color_parse('#E7E7E7'), [])
# ...and its scrollbar
vtebox = gtk.HBox()
vtebox.pack_start(self._vte)
vtesb = gtk.VScrollbar(self._vte.get_adjustment())
vtesb.show()
vtebox.pack_start(vtesb, False, False, 0)
self.set_canvas(vtebox)
self.show_all()
# now start subprocess.
self._vte.grab_focus()
bundle_path = activity.get_bundle_path()
# the 'sleep 1' works around a bug with the command dying before
# the vte widget manages to snarf the last bits of its output
self._pid = self._vte.fork_command \
(command='/bin/sh',
argv=['/bin/sh','-c',
'python %s/pippy_app.py; sleep 1' % bundle_path],
envv=["PYTHONPATH=%s/library" % bundle_path],
directory=bundle_path)
def __init__(self):
gtk.Window.__init__(self)
self.set_default_size(800, 600)
button1 = gtk.Button("Button 1")
button2 = gtk.Button("Button 2")
layout = gtk.Layout()
layout.set_size(800, 1200)
layout.put(button1, 20, 20)
layout.put(button2, 700, 350)
vadjust = layout.get_vadjustment()
hadjust = layout.get_hadjustment()
self.vscroll = gtk.VScrollbar(vadjust)
self.vscroll.connect("change-value", self.vscroll_changed)
self.hscroll = gtk.HScrollbar(hadjust)
self.hscroll.connect("change-value", self.hscroll_changed)
table = gtk.Table(2, 2, False)
table.attach(layout, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND)
table.attach(self.vscroll, 1, 2, 0, 1, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK)
table.attach(self.hscroll, 0, 1, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK)
self.add(table)
self.show_all()
self.connect("destroy", lambda w: gtk.main_quit())
def __init__(self):
gtk.HBox.__init__(self, False, 4)
gconf_client.add_dir(self.GCONF_PROFILE_DIR,
gconf.CLIENT_PRELOAD_RECURSIVE)
self._vte = vte.Terminal()
self.reconfigure_vte()
self._vte.set_size(self._vte.get_column_count(), 5)
self._vte.set_size_request(200, 50)
self._vte.show()
self.pack_start(self._vte)
self._scrollbar = gtk.VScrollbar(self._vte.get_adjustment())
self._scrollbar.show()
self.pack_start(self._scrollbar, False, False, 0)
gconf_client.notify_add(self.GCONF_PROFILE_DIR,
self.on_gconf_notification)
# we need to reconf colors if the style changes
self._vte.connect("style-set",
lambda term, oldstyle: self.reconfigure_vte())
self._vte.connect("key-press-event", self.on_vte_key_press)
self._vte.connect("button-press-event", self.on_vte_button_press)
self._vte.connect("popup-menu", self.on_vte_popup_menu)
self._vte.connect("child-exited", lambda term: term.fork_command())
self._vte.fork_command()
def __init__(self):
super(TerminalWidget, self).__init__()
self.__termbox = gtk.HBox()
self.add(self.__termbox)
try:
import vte
self.term = vte.Terminal()
self.term.fork_command()
self.term.connect('child-exited',
lambda *w: self.term.fork_command())
self.__scroll = gtk.VScrollbar(self.term.get_adjustment())
border = gtk.Frame()
border.set_shadow_type(gtk.SHADOW_ETCHED_IN)
border.add(self.term)
self.__termbox.pack_start(border)
self.__termbox.pack_start(self.__scroll, False)
self.term.set_size_request(0, 0)
except ImportError:
label = gtk.Label(
_("<b>Loser!</b> You don't have vte python bindings installed.\n" \
"Download it from <tt>http://ftp.acc.umu.se/pub/GNOME/sources/vte/</tt>")
)
label.set_use_markup(True)
label.set_selectable(True)
self.__termbox.pack_start(label)
self.show_all()
def init_sub_win(self):
self.builder2 = gtk.Builder()
self.builder2.add_from_file("./glade/gui2.glade")
self.sub_win = self.builder2.get_object('window1')
self.sub_win.connect('destroy', self.on_sub_win_closed)
self.sub_win.set_title('UCloner')
#self.sub_win.set_icon_from_file('ucloner.png')
self.sub_win.set_position(gtk.WIN_POS_CENTER)
self.sub_win.set_resizable(True)
self.vte1 = vte.Terminal()
self.vte1.set_size_request(600, 380)
self.vte1.connect("child-exited", self.on_vte_exit, None)
scrollbar = gtk.VScrollbar()
adjustment = self.vte1.get_adjustment()
scrollbar.set_adjustment(adjustment)
hbox_vte = self.builder2.get_object('hbox_vte')
hbox_vte.pack_start(self.vte1)
hbox_vte.pack_start(scrollbar, expand=False)
self.button_stop_task = self.builder2.get_object('button_stop_task')
self.button_stop_task.connect('clicked', self.stop_task)
self.sub_win.show_all()
def __init__(self, parent=None, title='Terminal'):
gtk.Dialog.__init__(self,
parent=parent,
title=title,
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
label = gtk.Label(title)
label.set_alignment(xalign=0.0, yalign=0.5)
self.vbox.pack_start(label)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
self.vbox.pack_end(frame)
hbox = gtk.HBox()
frame.add(hbox)
self.terminal = vte.Terminal()
self.terminal.set_scrollback_lines(8192)
#self.terminal.set_font_from_string('monospace 12')
hbox.pack_start(self.terminal)
scrollbar = gtk.VScrollbar()
scrollbar.set_adjustment(self.terminal.get_adjustment())
hbox.pack_end(scrollbar)
self.show_all()
def __init__(self):
gtk.DrawingArea.__init__(self)
self.set_flags(gtk.CAN_FOCUS | gtk.SENSITIVE)
self.set_events( gtk.gdk.ALL_EVENTS_MASK )
self.pangolayout = self.create_pango_layout("a")
self.connect("expose-event", self.area_expose_cb)
self.colormap = gtk.widget_get_default_colormap()
self.items = []; self.coords = []; self.curr = 0
self.scrolly = 0; self.scrollx = 0
self.limit = 1000
self.txcol = self.colormap.alloc_color(FGCOLOR)
self.bgcol = self.colormap.alloc_color(BGCOLOR)
self.hlcol = self.colormap.alloc_color(HICOLOR)
# Get Pango steps
self.cxx, self.cyy = self.pangolayout.get_pixel_size()
# Create scroll items
#sm = len(self.items) + self.get_height() / self.cyy + 10
self.hadj = gtk.Adjustment(0, 0, 200, 1, 15, 25);
self.vadj = gtk.Adjustment(0, 0, 200, 1, 15, 25)
self.vscroll = gtk.VScrollbar(self.vadj)
self.hscroll = gtk.HScrollbar(self.hadj)
# We connect scrollers after construction
self.hadj.connect("value-changed", self.hscroll_cb)
self.vadj.connect("value-changed", self.vscroll_cb)
self.connect("key-press-event", self.key_press_event)
self.connect("button-press-event", self.button_press_event)
def __init__(self):
super(ViewSidebarLayout, self).__init__(self)
self.view = None
self.sidebar = None
self.__vscrollbar = gtk.VScrollbar()
self.__main_hscrollbar = gtk.HScrollbar()
self.__sidebar_hscrollbar = gtk.HScrollbar()
self.sidebar_open = False
self.__sidebar_width = DEFAULT_SIDEBAR_WIDTH
self.__in_resize = False
self.add(self.__vscrollbar)
self.add(self.__main_hscrollbar)
self.add(self.__sidebar_hscrollbar)
self.__main_hscrollbar_changed_id = \
self.__main_hscrollbar.get_adjustment().connect('changed', self.on_main_hadjustment_changed)
self.__sidebar_hscrollbar_changed_id = \
self.__sidebar_hscrollbar.get_adjustment().connect('changed', self.on_sidebar_hadjustment_changed)
self.__vscrollbar_changed_id = \
self.__vscrollbar.get_adjustment().connect('changed', self.on_vadjustment_changed)
self.__main_hscrollbar_visible = False
self.__sidebar_hscrollbar_visible = True
self.__vscrollbar_visible = True
self.__resize_window = None
self.set_redraw_on_allocate(True)
self.connect('destroy', self.on_destroy)
def __init__(self, codec):
gtk.Window.__init__(self)
self.codec = codec
self.connect('destroy', self.__destroy)
self.set_default_size(800, 600)
self.set_title(self.__class__.__name__ + ' ' + self.codec.name)
self.set_border_width(0)
table = gtk.Table(2, 3, False)
self.add(table)
statusbar = gtk.Statusbar()
self.layout = CodecGraphLayout(None, None, codec, self.get_title(),
statusbar)
table.attach(self.layout, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
vScrollbar = gtk.VScrollbar(None)
table.attach(vScrollbar, 1, 2, 0, 1, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
hScrollbar = gtk.HScrollbar(None)
table.attach(hScrollbar, 0, 1, 1, 2, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
vAdjust = self.layout.get_vadjustment()
vScrollbar.set_adjustment(vAdjust)
hAdjust = self.layout.get_hadjustment()
hScrollbar.set_adjustment(hAdjust)
table.attach(statusbar, 0, 2, 2, 3, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
self.show_all()
GRAPH_WINDOWS[codec] = self
TRACKER.add(self)
def __init__(self, cell_class, cell_sizes=None, cell_numbers=None):
gtk.HBox.__init__(self)
self._cell_class = cell_class
self._cell_sizes = cell_sizes
self._cell_numbers = cell_numbers
self._rows = 0
self._columns = 0
self._cells = []
self._model = None
self._table = None
self._hover_selection = False
self.connect('scroll-event', self._scroll_event_cb)
self.connect('key-press-event', self._key_press_event_cb)
self.table_box = gtk.EventBox()
self.table_box.show()
self.pack_start(self.table_box)
self._adj = gtk.Adjustment(value=0,
lower=0,
upper=0,
step_incr=1,
page_incr=0,
page_size=0)
self._adj.connect('value-changed', self._fillin)
self._scrollbar = gtk.VScrollbar(self._adj)
self._scrollbar.show()
self.pack_end(self._scrollbar, expand=False, fill=False)
def do_create(self):
label = moo.PaneLabel(icon_name=moo.STOCK_TERMINAL,
label_text=_("Terminal"))
self.terminal = Terminal()
self.terminal.set_scrollback_lines(1000000)
self.terminal.connect("child-exited", self.start)
self.start()
frame = gtk.Frame()
hbox = gtk.HBox()
frame.add(hbox)
hbox.pack_start(self.terminal)
scrollbar = gtk.VScrollbar(self.terminal.get_adjustment())
hbox.pack_start(scrollbar, False, False, 0)
frame.show_all()
self.terminal.set_size(self.terminal.get_column_count(), 10)
self.terminal.set_size_request(10, 10)
self.pane = self.get_window().add_pane(TERMINAL_PLUGIN_ID, frame,
label, moo.PANE_POS_BOTTOM)
self.icon_title_changed_cb_id = self.terminal.connect(
'icon-title-changed', self.terminal_icon_title_changed)
self.terminal_icon_title_changed()
return True
def __init__(self, model):
gtk.HBox.__init__(self, spacing=5)
self.previous_threshold = 100
self.previous_position = 0
self.previous_stream = None
self.messages = None
self.add_events(gtk.gdk.SCROLL_MASK)
self.connect("scroll-event", self.on_viewport_scroll)
self.message_view = MessageStreamView(model)
self.message_view.connect("load-finished", self.on_scroll)
self.message_scroll = gtk.ScrolledWindow()
self.message_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
self.message_scroll.set_shadow_type(gtk.SHADOW_IN)
self.message_scroll.add(self.message_view)
self.scrollbar = gtk.VScrollbar()
self.scrollbar.set_range(0, 100)
self.scrollbar.set_increments(1, 10)
self.scrollbar.connect("value-changed", self.on_scroll)
self.pack_start(self.message_scroll, True, True)
self.pack_start(self.scrollbar, False)
def add_scroll_bar(self):
"""Packs the scrollbar.
"""
adj = self.terminal.get_adjustment()
scroll = gtk.VScrollbar(adj)
scroll.set_no_show_all(True)
self.pack_start(scroll, False, False)
def build(self, key):
cmd = self.build_cmd(key)
if cmd != None:
background = None
blink = 1
font = "monospace 10"
scrollback = 100
terminal = vte.Terminal()
terminal.get_pty()
if (background):
terminal.set_background_image(background)
terminal.set_cursor_blinks(blink)
terminal.set_font_from_string(font)
terminal.set_scrollback_lines(scrollback)
master, slave = os.openpty()
self.terminals_prc[key] = Popen(["/bin/bash", "-c", cmd],
stdin=slave,
stdout=slave,
stderr=slave)
self.terminals_hope[key] = 5
os.close(slave)
terminal.set_pty(master)
terminal.show()
scrollbar = gtk.VScrollbar()
scrollbar.set_adjustment(terminal.get_adjustment())
box = gtk.HBox()
box.pack_start(terminal)
box.pack_start(scrollbar)
return box
else:
return None
def __init__(self, handle):
import gtk, pango, platform, sys
from ctypes import cdll
if platform.machine().startswith('arm'):
pass # FIXME
else:
if platform.architecture()[0] == '64bit':
vte_path = "x86-64"
else:
vte_path = "x86"
vte = cdll.LoadLibrary("lib/%s/libvte.so.9" % vte_path)
sys.path.append("lib/%s" % vte_path)
import vte
super(VteActivity, self).__init__(handle, create_jobject=False)
self.__source_object_id = None
# creates vte widget
self._vte = vte.Terminal()
if DEBUG_TERMINAL:
toolbox = activity.ActivityToolbox(self)
toolbar = toolbox.get_activity_toolbar()
self.set_toolbox(toolbox)
self._vte.set_size(30, 5)
self._vte.set_size_request(200, 300)
font = 'Monospace 10'
self._vte.set_font(pango.FontDescription(font))
self._vte.set_colors(gtk.gdk.color_parse('#E7E7E7'),
gtk.gdk.color_parse('#000000'), [])
vtebox = gtk.HBox()
vtebox.pack_start(self._vte)
vtesb = gtk.VScrollbar(self._vte.get_adjustment())
vtesb.show()
vtebox.pack_start(vtesb, False, False, 0)
self.set_canvas(vtebox)
toolbox.show()
self.show_all()
toolbar.share.hide()
toolbar.keep.hide()
# now start subprocess.
self._vte.connect('child-exited', self.on_child_exit)
self._vte.grab_focus()
bundle_path = activity.get_bundle_path()
self._pid = self._vte.fork_command \
(command='/bin/sh',
argv=['/bin/sh','-c',
'python %s/blocku.py' % bundle_path],
envv=["PYTHONPATH=%s/library" % bundle_path],
directory=bundle_path)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
logging.debug('Starting the Frotz activity')
self.set_title(_('Frotz'))
self.connect('key-press-event', self.__key_press_cb)
toolbox = activity.ActivityToolbox(self)
self._edit_toolbar = activity.EditToolbar()
toolbox.add_toolbar(_('Edit'), self._edit_toolbar)
self._edit_toolbar.show()
self._edit_toolbar.undo.props.visible = False
self._edit_toolbar.redo.props.visible = False
self._edit_toolbar.separator.props.visible = False
self._edit_toolbar.copy.connect('clicked', self._copy_cb)
self._edit_toolbar.paste.connect('clicked', self._paste_cb)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
activity_toolbar.keep.props.visible = False
# Add a button that will send you to the ifarchive to get more games
activity_toolbar.get_games = ToolButton('activity-get-games')
activity_toolbar.get_games.set_tooltip(_('Get More Games'))
activity_toolbar.get_games.connect('clicked', self._get_games_cb)
activity_toolbar.insert(activity_toolbar.get_games, 2)
activity_toolbar.get_games.show()
self.set_toolbox(toolbox)
toolbox.show()
box = gtk.HBox(False, 4)
self._vte = VTE()
self._vte.show()
self._vte.connect("child-exited", self._quit_cb)
scrollbar = gtk.VScrollbar(self._vte.get_adjustment())
scrollbar.show()
box.pack_start(self._vte)
box.pack_start(scrollbar, False, False, 0)
self.set_canvas(box)
box.show()
self._vte.grab_focus()
self.game_started = False
default_game_file = os.path.join(activity.get_bundle_path(),
"Advent.z5")
# when we return to the idle state, launch the default game
# if read_file is called, that will override this
gobject.idle_add(self.start_game, default_game_file)
def __init__(self, orientation='horizontal'):
super(ScrollBar, self).__init__()
if orientation == 'horizontal':
self.widget = gtk.HScrollbar()
else:
self.widget = gtk.VScrollbar()
self.widget.connect('value-changed', self._cb_redirect)
self.enable_callback('activated')
def __init__(self):
gobject.threads_init()
gtk.HBox.__init__(self)
self.connect("destroy", self._destroy_cb)
self._ready = False
self._paginator = None
self._loaded_page = -1
#self._old_scrollval = -1
self._loaded_filename = None
self._pagecount = -1
self.__going_fwd = True
self.__going_back = False
self.__page_changed = False
self._has_selection = False
self.scale = 1.0
self._epub = None
self._findjob = None
self.__in_search = False
self.__search_fwd = True
self._sw = gtk.ScrolledWindow()
self._view = widgets._WebView()
self._view.load_string(LOADING_HTML, 'text/html', 'utf-8', '/')
settings = self._view.get_settings()
settings.props.default_font_family = 'DejaVu LGC Serif'
settings.props.enable_plugins = False
settings.props.default_encoding = 'utf-8'
self._view.connect('load-finished', self._view_load_finished_cb)
self._view.connect('scroll-event', self._view_scroll_event_cb)
self._view.connect('key-press-event', self._view_keypress_event_cb)
self._view.connect('button-release-event',
self._view_buttonrelease_event_cb)
self._view.connect('selection-changed',
self._view_selection_changed_cb)
self._view.connect_after('populate-popup',
self._view_populate_popup_cb)
self._sw.add(self._view)
self._sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
self._v_vscrollbar = self._sw.get_vscrollbar()
self._v_scrollbar_value_changed_cb_id = \
self._v_vscrollbar.connect('value-changed', \
self._v_scrollbar_value_changed_cb)
self._scrollbar = gtk.VScrollbar()
self._scrollbar.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
self._scrollbar_change_value_cb_id = \
self._scrollbar.connect('change-value', \
self._scrollbar_change_value_cb)
self.pack_start(self._sw, expand=True, fill=True)
self.pack_start(self._scrollbar, expand=False, fill=False)
self._view.set_flags(gtk.CAN_DEFAULT | gtk.CAN_FOCUS)
def __init__(self):
super(VteTerminalScreen, self).__init__()
self.term = vte.Terminal()
self.__termbox = gtk.HBox()
self.__scroll = gtk.VScrollbar(self.term.get_adjustment())
border = gtk.Frame()
border.set_shadow_type(gtk.SHADOW_ETCHED_IN)
border.add(self.term)
self.__termbox.pack_start(border)
self.__termbox.pack_start(self.__scroll, False)
self.add(self.__termbox)
def __init__(self, app, presenter): gtk.Table.__init__(self) self.app = app self.presenter = presenter self.caption = presenter.doc_name self.tab_caption = TabCaption(self, self.caption) da_box = gtk.Table(3, 3, False) self.corner = RulerCorner(self) da_box.attach(self.corner, 0, 1, 0, 1, gtk.SHRINK, gtk.SHRINK) self.hruler = Ruler(self, uc2const.HORIZONTAL) da_box.attach(self.hruler, 1, 3, 0, 1, gtk.EXPAND | gtk.FILL, gtk.SHRINK) self.vruler = Ruler(self, uc2const.VERTICAL) da_box.attach(self.vruler, 0, 1, 1, 3, gtk.SHRINK, gtk.EXPAND | gtk.FILL) hbox = gtk.HBox() line = gtk.VSeparator() hbox.pack_start(line, False, False, 0) self.v_adj = gtk.Adjustment() self.vscroll = gtk.VScrollbar(self.v_adj) hbox.pack_start(self.vscroll, True, True, 0) da_box.attach(hbox, 2, 3, 1, 2, gtk.SHRINK, gtk.EXPAND | gtk.FILL) vbox = gtk.VBox() line = gtk.HSeparator() vbox.pack_start(line, False, False, 0) hbox = gtk.HBox() sbox = gtk.VBox() self.h_adj = gtk.Adjustment() self.hscroll = gtk.HScrollbar(self.h_adj) sbox.pack_start(self.hscroll, False, True, 0) hbox.pack_end(sbox, True, True, 0) vbox.pack_start(hbox, True, True, 0) da_box.attach(vbox, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL, gtk.SHRINK) self.canvas = AppCanvas(self) da_box.attach(self.canvas, 1, 2, 1, 2, gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND, 0, 0) if system.get_os_family() == system.WINDOWS: xpad = 2; ypad = 0 else: xpad = ypad = 0 self.attach(da_box, 0, 1, 0, 1, gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, xpadding=xpad, ypadding=ypad)
def __init__(self,
fixed_height=False,
fixed_width=False,
max_height=MAX_HEIGHT,
can_focus=True):
Popup.__init__(self)
self.__fixed_height = fixed_height
self.__fixed_width = fixed_width
self.__max_height = max_height
self.__can_focus = can_focus
self.__view = gtk.TextView()
self.__view.set_editable(False)
bg_color = gtk.gdk.Color(0xffff, 0xffff, 0xbfbf)
self.__view.modify_base(gtk.STATE_NORMAL, bg_color)
self.modify_bg(gtk.STATE_NORMAL, bg_color)
self.set_app_paintable(True)
self.__view.modify_text(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
self.__view.set_parent(self)
self.__view.show()
self.__view.grab_focus()
global_settings.watch('doc-tooltip-font-is-custom', self.__update_font)
global_settings.watch('doc-tooltip-font-name', self.__update_font)
self.__update_font()
self.__scrollbar = gtk.VScrollbar()
self.__scrollbar.set_parent(self)
self.__scrollbar.show()
self.__view.emit('set-scroll-adjustments', None,
self.__scrollbar.get_adjustment())
self.__view.connect('scroll-event', self.on_scroll_event)
self.__vscrolled = False
self.set_resizable(False)
buf = self.__view.get_buffer()
self.__bold_tag = buf.create_tag(None, weight=pango.WEIGHT_BOLD)
self.__heading_type_tag = buf.create_tag(None,
weight=pango.WEIGHT_BOLD,
pixels_below_lines=5)
self.__inline_type_tag = self.__bold_tag
self.__value_tag = buf.create_tag(None, family="monospace")
self.__target = None
self.focused = False
self.connect('destroy', self.on_destroy)
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, app, presenter):
gtk.Table.__init__(self)
self.app = app
self.presenter = presenter
self.caption = presenter.doc_name
self.tab_caption = TabCaption(self, self.caption)
da_box = gtk.Table(3, 3, False)
self.corner = RulerCorner(self)
da_box.attach(self.corner, 0, 1, 0, 1, gtk.SHRINK, gtk.SHRINK)
self.hruler = Ruler(self, 0)
da_box.attach(self.hruler, 1, 3, 0, 1, gtk.EXPAND | gtk.FILL,
gtk.SHRINK)
self.vruler = Ruler(self, 1)
da_box.attach(self.vruler, 0, 1, 1, 3, gtk.SHRINK,
gtk.EXPAND | gtk.FILL)
self.v_adj = gtk.Adjustment()
self.vscroll = gtk.VScrollbar(self.v_adj)
da_box.attach(self.vscroll, 2, 3, 1, 2, gtk.SHRINK,
gtk.EXPAND | gtk.FILL)
self.h_adj = gtk.Adjustment()
self.hscroll = gtk.HScrollbar(self.h_adj)
da_box.attach(self.hscroll, 1, 2, 2, 3, gtk.EXPAND | gtk.FILL,
gtk.SHRINK)
self.canvas = AppCanvas(self)
da_box.attach(self.canvas, 1, 2, 1, 2, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
if system.get_os_family() == system.WINDOWS:
xpad = 2
ypad = 0
else:
xpad = ypad = 3
self.attach(da_box,
0,
1,
0,
1,
gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL,
xpadding=xpad,
ypadding=ypad)
def display_canvas_view(view):
global item_factory
view.set_scroll_region(0.0, 0.0, 600.0, 450.0)
win = gtk.Window()
win.connect ('destroy', mainquit)
win.set_title ('DiaCanvas Python example')
win.set_default_size (400, 400)
vbox = gtk.VBox(homogeneous=gtk.FALSE)
win.add (vbox)
vbox.show()
accelgroup = gtk.AccelGroup()
win.add_accel_group(accelgroup)
item_factory = gtk.ItemFactory(gtk.MenuBar, '<main>', accelgroup)
item_factory.create_items(menu_items, view)
menubar = item_factory.get_widget('<main>')
vbox.pack_start(menubar, gtk.FALSE, gtk.FALSE, 0)
menubar.show()
table = gtk.Table(2,2, gtk.FALSE)
table.set_row_spacings (4)
table.set_col_spacings (4)
vbox.pack_start (table)
table.show()
frame = gtk.Frame()
frame.set_shadow_type (gtk.SHADOW_IN)
table.attach (frame, 0, 1, 0, 1,
gtk.EXPAND | gtk.FILL | gtk.SHRINK,
gtk.EXPAND | gtk.FILL | gtk.SHRINK)
frame.show()
# view.set_usize(600, 450)
frame.add (view)
view.show()
sbar = gtk.VScrollbar (view.get_vadjustment())
table.attach (sbar, 1, 2, 0, 1, gtk.FILL,
gtk.EXPAND | gtk.FILL | gtk.SHRINK)
sbar.show()
sbar = gtk.HScrollbar (view.get_hadjustment())
table.attach (sbar, 0, 1, 1, 2, gtk.EXPAND | gtk.FILL | gtk.SHRINK,
gtk.FILL)
sbar.show()
win.show()
def __init__(self):
gtk.HBox.__init__(self, False, 4)
self._vte = vte.Terminal()
self._vte.set_size(self._vte.get_column_count(), 10)
self._vte.set_size_request(200, 50)
self._vte.set_scrollback_lines(-1)
self._vte.show()
self._vte.connect('button_press_event', self._button_press_cb)
scrbar = gtk.VScrollbar(self._vte.get_adjustment())
scrbar.show()
self.pack_start(self._vte)
self.pack_start(scrbar, False, False, 0)
self.show_all()
self._pid = self._vte.fork_command()
