def __init__(self, screen, xml):
super(ViewForm, self).__init__(screen, xml)
self.view_type = 'form'
self.widgets = defaultdict(list)
self.state_widgets = []
self.notebooks = []
self.expandables = []
container = self.parse(xml)
vbox = gtk.VBox()
vp = gtk.Viewport()
vp.set_shadow_type(gtk.SHADOW_NONE)
vp.add(container.table)
self.scroll = scroll = gtk.ScrolledWindow()
scroll.add(vp)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.set_placement(gtk.CORNER_TOP_LEFT)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_ETCHED_IN)
viewport.add(scroll)
vbox.pack_start(viewport, expand=True, fill=True)
self.widget = vbox
self._viewport = vp
def __init__(self):
self._entries_div = hippo.CanvasBox()
# props not set properly in constructor
self._entries_div.props.background_color=theme.COLOR_PAGE.get_int()
self._entries_div.props.spacing=style.DEFAULT_SPACING
self._entries_div.props.padding=10
self._entries_div.props.orientation=hippo.ORIENTATION_VERTICAL
# Munge it all up into something we can stick into a gtk.ScrolledWindow
canvas = hippo.Canvas()
canvas.set_root(self._entries_div)
canvas.show()
hbox = gtk.HBox()
hbox.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS)
hbox.pack_start(canvas)
hbox.show()
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(hbox)
viewport.show()
scroller.add(viewport)
scroller.show()
hippo.CanvasWidget.__init__(self,
widget=scroller,
padding=0,
spacing=0,
border=1,
border_color=theme.COLOR_DARK_GREEN.get_int())
def __init__(self, parent_window):
super(HistoryView, self).__init__()
self.parent_window = parent_window
self.calendar = gtk.Calendar()
self.tomato_view = self._create_tomato_view()
self.tomato_model = self.tomato_view.get_model()
self.stat_model = WeeklyStatisticsModel()
self.stat_graph = WeeklyBarChart(self.stat_model)
tomato_wnd = gtk.ScrolledWindow()
tomato_wnd.add(self.tomato_view)
tomato_wnd.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
tomato_view = gtk.Viewport()
tomato_view.add(tomato_wnd)
top_hbox = gtk.HBox(False, 0)
top_hbox.pack_start(self.calendar, False, False, padding=5)
top_hbox.pack_start(tomato_view, True, True, padding=5)
top_vbox = gtk.VBox(False, 0)
top_vbox.pack_start(top_hbox, True, True, padding=5)
self.pack1(top_vbox, shrink=False)
self.pack2(self.stat_graph, shrink=False)
self._on_day_changed(self.calendar)
self.calendar.connect('day-selected', self._on_day_changed)
def __init__(self, game):
super(DibujoClasificacion, self).__init__()
self.set_title("Resultados")
self.set_size_request(680, 480)
self.set_resizable(False)
self.set_position(gtk.WIN_POS_CENTER)
barritas = gtk.ScrolledWindow()
barritas.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
viewport = gtk.Viewport()
darea = gtk.DrawingArea()
darea.connect("expose-event", self.expose)
barritas.add(viewport)
viewport.add(darea)
self.add(barritas)
self.numeroRondas = game.get_number_of_rounds()
self.resultados = []
for q in range(self.numeroRondas):
ss = game.get_round(q).get_round_results()
self.resultados.append(ss)
self.anchoBloque = 140
self.altoBloque = 24
self.separacionHorizontal = 20
self.separacionVertical = 48
self.show_all()
def create_tabcontent(self):
self.buttons = {}
self.tooltips = common.Tooltips()
self.accel_group = Main.get_main().accel_group
self.widget = gtk.VBox(spacing=3)
self.widget.show()
title_box = self.make_title_bar()
self.widget.pack_start(title_box, expand=False, fill=True, padding=3)
self.create_info_bar()
self.widget.pack_start(self.info_bar, False, True)
self.toolbar = self.create_toolbar(self.get_toolbars())
self.toolbar.show_all()
self.widget.pack_start(self.toolbar, False, True)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(self.widget_get())
viewport.show()
self.scrolledwindow = gtk.ScrolledWindow()
self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrolledwindow.add(viewport)
self.scrolledwindow.show()
self.widget.pack_start(self.scrolledwindow)
def __init__(self, window, connection):
#SETTINGS:
self.showTabs = False
self.panelRight = True
self.connectionString = connection
self.resultSet = None
self.action_group = gtk.ActionGroup("SQLActions")
self.runQuery = gtk.Action("SQLquery", _("Run SQL"), _("Run SQL"), gtk.STOCK_EXECUTE)
self.runQuery.connect("activate", self.run)
#self.action_group.add_action_with_accel(self.runQuery, "<Ctrl>Enter")
self.action_group.add_action(self.runQuery)
self.window = window
self.cell = gtk.CellRendererText()
#self.cell.editable = True
self.manager = self.window.get_ui_manager()
self.manager.insert_action_group(self.action_group, -1)
self.manager.add_ui_from_string('<ui><toolbar name="ToolBar"><toolitem name="SQLquery" action="SQLquery" /></toolbar></ui>')
self.textarea = gtk.TextView()
self.textarea.set_wrap_mode(gtk.WRAP_WORD)
self.textarea.show()
self.buffer = self.textarea.get_buffer()
self.scrollable = gtk.ScrolledWindow()
self.scrollable.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scrollable.show()
self.box = gtk.VBox()
self.box.show()
self.container = gtk.VBox()
self.container.show()
self.timearea = gtk.TextView()
self.timearea.set_wrap_mode(gtk.WRAP_WORD)
self.timearea.show()
self.timer = self.timearea.get_buffer()
self.box.pack_start(self.container)
self.box.pack_end(self.timearea)
self.box.pack_end(self.textarea)
self.viewport = gtk.Viewport()
self.viewport.add(self.box)
self.viewport.show()
self.scrollable.add(self.viewport)
self.textarea.hide()
self.container.hide()
self.connect()
panel = self.window.get_bottom_panel()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_MENU)
ui_id = panel.add_item(self.scrollable, "SQL", image)
def add_wnck_window_to_tab(self, wnck_window):
'''将窗口添加到标签
'''
notebook = self.notebook
drawingarea = gtk.Socket()
drawingarea.show()
drawingarea.connect('realize', self._on_add_wnck_window_to_drawingarea, wnck_window, drawingarea)
drawingarea.connect('plug-removed', self._tab_remove)
tabimage = gtk.Image()
tabimage.set_from_pixbuf(wnck_window.get_icon())
tabimage.set_padding(0, 0)
tabimage.show()
tabmenu = gtk.Label(wnck_window.get_name())
box = gtk.Viewport()
box.add(drawingarea)
box.show()
box.set_flags(gtk.CAN_FOCUS)
drawingarea.box = box
drawingarea.tabimage = tabimage
drawingarea.tabmenu = tabmenu
drawingarea.wnck_window = wnck_window
notebook.append_page_menu(box, tabimage, tabmenu)
notebook.set_current_page( notebook.page_num(box) )
notebook.set_tab_reorderable(drawingarea, 1)
self.tabs[wnck_window] = drawingarea
pass
def __init__(self, image_file):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("... APLIKA ...")
self.window.connect("delete_event", self.close_application)
self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.window.set_default_size(800, 600)
self.pixbuf = gtk.gdk.pixbuf_new_from_file(image_file)
self.ancho_pixbuf = float(self.pixbuf.get_width())
self.alto_pixbuf = float(self.pixbuf.get_height())
self.image = gtk.Image()
self.image.set_from_pixbuf(self.pixbuf)
self.viewport = gtk.Viewport()
# No están por defecto, los agrego
self.viewport.add_events(gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.BUTTON1_MOTION_MASK)
self.viewport.connect('button-press-event', self.on_button_pressed)
self.viewport.connect('button-release-event', self.on_button_released)
self.viewport.connect('motion-notify-event', self.on_mouse_moved)
# Lo conecto a la ventana, ya que siempre tiene el foco
self.window.connect('key-press-event', self.on_key_press)
self.viewport.add(self.image)
self.scrolled_wnd = gtk.ScrolledWindow()
self.scrolled_wnd.add(self.viewport)
self.window.add(self.scrolled_wnd)
self.window.show_all()
def __init__(self):
Tab.__init__(self)
glade_tab = gtk.glade.XML(get_resource("pieces_tab.glade"))
self._name = "Pieces"
self._child_widget = glade_tab.get_widget("pieces_tab")
self._tab_label = glade_tab.get_widget("pieces_tab_label")
self._ms = MultiSquare(0,['#000000','#FF0000','#0000FF'],
display=self._child_widget.get_display(),
menu=glade_tab.get_widget("priority_menu"))
vb = gtk.VBox()
vb.add(self._ms)
self.cb = gtk.CheckButton(label="Set priority of first few un-downloaded pieces to High")
self.cb.connect("toggled",self.onPrioTogg)
vb.pack_end(self.cb,expand=False,fill=False,padding=5)
vp = gtk.Viewport()
vp.set_shadow_type(gtk.SHADOW_NONE)
vp.add(vb)
self._child_widget.add(vp)
self._child_widget.get_parent().show_all()
#keep track of the current selected torrent
self._current = -1
self._showed_prio_warn = False
def callback_label(self, widget, event, model, name, src, window=None):
lang_ids = rpc.session.rpc_exec_auth('/object', 'execute',
'res.lang', 'search',
[('translatable', '=', '1')])
if not lang_ids:
common.message(_('No other language available!'),
parent=window)
return False
langs = rpc.session.rpc_exec_auth('/object', 'execute', 'res.lang',
'read', lang_ids,
['code', 'name'])
win = gtk.Dialog(_('Add Translation'), window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
win.vbox.set_spacing(5)
win.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
win.set_icon(common.OPENERP_ICON)
vbox = gtk.VBox(spacing=5)
entries_list = []
for lang in langs:
code = lang['code']
val = rpc.session.rpc_exec_auth('/object', 'execute', model,
'read_string', False, [code],
[name])
if val and code in val:
val = val[code]
else:
val = {'code': code, 'name': src}
label = gtk.Label(lang['name'])
entry = gtk.Entry()
entry.set_text(val[name])
entries_list.append((code, entry))
hbox = gtk.HBox(homogeneous=True)
hbox.pack_start(label, expand=False, fill=False)
hbox.pack_start(entry, expand=True, fill=True)
vbox.pack_start(hbox, expand=False, fill=True)
vp = gtk.Viewport()
vp.set_shadow_type(gtk.SHADOW_NONE)
vp.add(vbox)
sv = gtk.ScrolledWindow()
sv.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sv.set_shadow_type(gtk.SHADOW_NONE)
sv.add(vp)
win.vbox.add(sv)
win.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
win.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
win.resize(400, 200)
win.show_all()
res = win.run()
if res == gtk.RESPONSE_OK:
to_save = map(lambda x: (x[0], x[1].get_text()), entries_list)
while to_save:
code, val = to_save.pop()
rpc.session.rpc_exec_auth('/object', 'execute', model,
'write_string', False, [code],
{name: val})
window.present()
win.destroy()
return res
def CreateSiteConfigurationTab(self, notebook):
sites_config = gtk.Frame()
sites_config.set_shadow_type(gtk.SHADOW_NONE)
notebook.append_page(sites_config, gtk.Label('Website Configuration'))
self.entry_vbox.pack_start(gtk.Label(''), False)
if self.configuration['pages']:
sorted_pages = sorted(self.configuration['pages'].iteritems(),
key=operator.itemgetter(1))
for page in sorted_pages:
pageName = page[0]
order = self.configuration['pages'][pageName][0]
url = self.configuration['pages'][pageName][1]
img = self.configuration['pages'][pageName][2]
self.CreatePageEntry(order, pageName, url, img)
else:
self.CreatePageEntry('1', '', '', '.')
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_shadow_type(gtk.SHADOW_NONE)
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(self.entry_vbox)
scrolled_window.add(viewport)
sites_config.add(scrolled_window)
def __init__(self):
#gtk.VBox.__init__(self, False)
#self.set_border_width(10)
gtk.ScrolledWindow.__init__(self)
self.settings_list = []
#scroll = gtk.ScrolledWindow()
self.set_shadow_type(gtk.SHADOW_NONE)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
general = General()
proxy = Proxy()
self.settings_list.append(general)
self.settings_list.append(proxy)
vbox1 = gtk.VBox(False, 10)
vbox1.set_border_width(10)
vbox1.pack_start(general, False, False)
vbox1.pack_start(proxy, False, False)
view_port = gtk.Viewport()
view_port.set_shadow_type(gtk.SHADOW_NONE)
view_port.add(vbox1)
self.add(view_port)
def __init__(self):
gtk.Entry.__init__(self)
self.tags = None
self.filter = None # currently applied filter string
self.filter_tags = [] #filtered tags
self.popup = gtk.Window(type=gtk.WINDOW_POPUP)
self.scroll_box = gtk.ScrolledWindow()
self.scroll_box.set_shadow_type(gtk.SHADOW_IN)
self.scroll_box.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
self.tag_box = TagBox()
self.tag_box.connect("tag-selected", self.on_tag_selected)
self.tag_box.connect("tag-unselected", self.on_tag_unselected)
viewport.add(self.tag_box)
self.scroll_box.add(viewport)
self.popup.add(self.scroll_box)
self.connect("button-press-event", self._on_button_press_event)
self.connect("key-press-event", self._on_key_press_event)
self.connect("key-release-event", self._on_key_release_event)
self.connect("focus-out-event", self._on_focus_out_event)
self._parent_click_watcher = None # bit lame but works
#runtime.storage.connect('tags-changed', self.refresh_tags)
self.show()
self.populate_suggestions()
def set_message(self, markup):
"""Adds a message on top of the treeview rows
:param markup: PangoMarkup with the text to add
"""
if self._message_label is None:
self._viewport = gtk.Viewport()
self._viewport.set_shadow_type(gtk.SHADOW_NONE)
self.remove(self.hbox)
self.add(self._viewport)
self._message_box = gtk.EventBox()
self._message_box.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse('white'))
self._viewport.add(self._message_box)
self._message_box.show()
self._message_label = gtk.Label()
self._message_label.connect('activate-link',
self._on_message_label__activate_link)
self._message_label.set_use_markup(True)
self._message_label.set_alignment(0, 0)
self._message_label.set_padding(12, 12)
self._message_box.add(self._message_label)
self._message_label.show()
self._message_label.set_label(markup)
self._viewport.show()
def _parse_page(self, node, notebook, attributes):
tab_box = gtk.HBox(spacing=3)
if 'name' in attributes:
field = self.screen.group.fields[attributes['name']]
if attributes['name'] == self.screen.exclude_field:
return
for attr in ('states', 'string'):
if attr not in attributes and attr in field.attrs:
attributes[attr] = field.attrs[attr]
label = gtk.Label('_' + attributes['string'].replace('_', '__'))
label.set_use_underline(True)
tab_box.pack_start(label)
if 'icon' in attributes:
ICONFACTORY.register_icon(attributes['icon'])
pixbuf = tab_box.render_icon(attributes['icon'],
gtk.ICON_SIZE_SMALL_TOOLBAR)
icon = gtk.Image()
icon.set_from_pixbuf(pixbuf)
tab_box.pack_start(icon)
tab_box.show_all()
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow = ScrolledWindow(attrs=attributes)
scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolledwindow.add(viewport)
scrolledwindow.show_all()
self.state_widgets.append(scrolledwindow)
notebook.append_page(scrolledwindow, tab_box)
container = self.parse(node)
viewport.add(container.table)
def __init__(self):
self.main_path = os.path.join(os.getcwd(),
os.path.dirname(sys.argv[0]))
self.parser_dir = None
self.parsers = None
self.set_parser_dir("parsers")
self.comparator_dir = None
self.comparators = None
self.set_comparator_dir("comparators")
self.main_window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.main_window.connect("destroy", self.on_destroy)
self.vbox1 = gtk.VBox(2)
self.main_window.add(self.vbox1)
self.vbox1.set_homogeneous(False)
self.mode_hbox = gtk.HBox(2)
self.vbox1.pack_start(self.mode_hbox)
self.mode_hbox.pack_start(gtk.Label("Mode : "))
self.mode_combobox = gtk.combo_box_new_text()
self.mode_hbox.pack_start(self.mode_combobox)
self.mode_combobox.append_text("DET")
self.mode_combobox.append_text("ROC")
self.mode_combobox.append_text("Display")
self.mode_combobox.append_text("Single file")
self.mode_combobox.set_active(0)
self.mode_combobox.connect("changed", self.on_mode_changed)
self.main_viewport = gtk.Viewport()
self.vbox1.pack_start(self.main_viewport)
self.main_window.show_all()
def __create_tab(self, tab_name, section_name, tab):
log.debug(">>> Tab name: %s" % tab_name)
log.debug(">>>Creating profile editor section: %s" % section_name)
vbox = HIGVBox()
table = HIGTable()
section = HIGSectionLabel(section_name)
vbox._pack_noexpand_nofill(section)
vbox._pack_noexpand_nofill(HIGSpacer(table))
vbox.set_border_width(6)
tab.fill_table(table, True)
self.scrollwindow = HIGScrolledWindow()
self.scrollwindow.set_size_request(600, 300)
vp = gtk.Viewport()
vp.add(vbox)
vp.set_shadow_type(gtk.SHADOW_NONE)
self.scrollwindow.add(vp)
vbox_tmp = HIGVBox()
vbox_tmp.set_border_width(6)
vbox_tmp.set_spacing(12)
vbox_tmp.pack_start(self.scrollwindow)
self.notebook.append_page(vbox_tmp, gtk.Label(tab_name))
def load (self, gmwidg):
self.plot = ScorePlot()
__widget__ = gtk.ScrolledWindow()
__widget__.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
port = gtk.Viewport()
port.add(self.plot)
port.set_shadow_type(gtk.SHADOW_NONE)
__widget__.add(port)
__widget__.show_all()
self.boardview = gmwidg.board.view
self.plot.connect("selected", self.plot_selected)
self.boardview.connect('shown_changed', self.shown_changed)
glock_connect(self.boardview.model, "game_changed", self.game_changed)
glock_connect(self.boardview.model, "moves_undoing", self.moves_undoing)
# Add the initial board
glock_connect(self.boardview.model, "game_started", self.game_changed)
def changed (vadjust):
if not hasattr(vadjust, "need_scroll") or vadjust.need_scroll:
vadjust.set_value(vadjust.upper-vadjust.page_size)
vadjust.need_scroll = True
__widget__.get_vadjustment().connect("changed", changed)
def value_changed (vadjust):
vadjust.need_scroll = abs(vadjust.value + vadjust.page_size - \
vadjust.upper) < vadjust.step_increment
__widget__.get_vadjustment().connect("value-changed", value_changed)
return __widget__
def __init__(self, editable=False, can_empty=False, has_search=False):
gtk.HBox.__init__(self)
self._entryband = gtk.Entry()
self._entryband.set_width_chars(15)
self._entryband.set_alignment(.5)
self._entryyear = gtk.Entry(4)
self._entryyear.set_width_chars(4)
label = gtk.Label("/")
hbox = gtk.HBox()
hbox.pack_start(self._entryband, False, True, 0)
hbox.pack_start(label, False, True, 4)
hbox.pack_start(self._entryyear, False, True, 0)
self._viewport = gtk.Viewport()
self._viewport.add(hbox)
image = gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_BUTTON)
self._button = gtk.Button()
self._button.add(image)
self._button.set_relief(gtk.RELIEF_NONE)
self._button.set_focus_on_click(False)
self._button.set_no_show_all(True)
self._button.connect("clicked", self.on_button_clicked)
self.pack_start(self._viewport, False, False, 0)
self.pack_start(self._button, False, False, 0)
self.show_all()
self.editable = editable
self.can_empty = can_empty
self.has_search = has_search
def _parse_page(self, node, notebook, attributes):
tab_box = gtk.HBox(spacing=3)
if '_' not in attributes['string']:
attributes['string'] = '_' + attributes['string']
label = gtk.Label(attributes['string'])
label.set_use_underline(True)
tab_box.pack_start(label)
if 'icon' in attributes:
ICONFACTORY.register_icon(attributes['icon'])
pixbuf = tab_box.render_icon(attributes['icon'],
gtk.ICON_SIZE_SMALL_TOOLBAR)
icon = gtk.Image()
icon.set_from_pixbuf(pixbuf)
tab_box.pack_start(icon)
tab_box.show_all()
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolledwindow.add(viewport)
scrolledwindow.show_all()
notebook.append_page(scrolledwindow, tab_box)
container = self.parse(node)
viewport.add(container.table)
def add_page(self, name, widget):
"""Add a another page to the notebook"""
# Create a header and scrolled window for the preferences tab
parent = widget.get_parent()
if parent:
parent.remove(widget)
vbox = gtk.VBox()
label = gtk.Label()
label.set_use_markup(True)
label.set_markup("<b><i><big>" + name + "</big></i></b>")
label.set_alignment(0.00, 0.50)
label.set_padding(10, 10)
vbox.pack_start(label, False, True, 0)
sep = gtk.HSeparator()
vbox.pack_start(sep, False, True, 0)
align = gtk.Alignment()
align.set_padding(5, 0, 0, 0)
align.set(0, 0, 1, 1)
align.add(widget)
vbox.pack_start(align, True, True, 0)
scrolled = gtk.ScrolledWindow()
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(vbox)
scrolled.add(viewport)
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.show_all()
# Add this page to the notebook
index = self.notebook.append_page(scrolled)
self.liststore.append([index, name])
return name
def add_header(self, box):
frame_predef_exports = gtk.Frame()
frame_predef_exports.set_border_width(2)
frame_predef_exports.set_shadow_type(gtk.SHADOW_NONE)
box.pack_start(frame_predef_exports, True, True, 0)
viewport_exports = gtk.Viewport()
scrolledwindow_exports = gtk.ScrolledWindow()
scrolledwindow_exports.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
label_predef_exports = gtk.Label(_("<b>Predefined exports</b>"))
label_predef_exports.set_use_markup(True)
frame_predef_exports.set_label_widget(label_predef_exports)
viewport_exports.add(scrolledwindow_exports)
frame_predef_exports.add(viewport_exports)
self.pref_export = gtk.TreeView()
self.pref_export.append_column(
gtk.TreeViewColumn(_('Name'), gtk.CellRendererText(), text=2))
scrolledwindow_exports.add(self.pref_export)
self.pref_export.connect("button-press-event", self.export_click)
self.pref_export.connect("key-press-event", self.export_keypress)
self.predef_model = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_PYOBJECT,
gobject.TYPE_STRING)
self.fill_predefwin()
def __init__(self, screen, xml, children_field, children_definitions=None):
super(ViewTree, self).__init__(screen, xml)
self.view_type = 'tree'
self.widgets = defaultdict(list)
self.state_widgets = []
self.children_field = children_field
self.children_definitions = children_definitions or []
self.sum_widgets = []
self.sum_box = gtk.HBox()
self.reload = False
# ABD: Pass self.attributes.get('editable_open') to constructor
if self.attributes.get('editable'):
self.treeview = EditableTreeView(
self.attributes['editable'], self,
self.attributes.get('editable_open'))
grid_lines = gtk.TREE_VIEW_GRID_LINES_BOTH
else:
self.treeview = TreeView(self)
grid_lines = gtk.TREE_VIEW_GRID_LINES_VERTICAL
self.mnemonic_widget = self.treeview
# ABD set alway expand through attributes
self.always_expand = self.attributes.get('always_expand', False)
self.parse(xml)
self.treeview.set_property('rules-hint', True)
self.treeview.set_property('enable-grid-lines', grid_lines)
self.treeview.set_fixed_height_mode(
all(c.get_sizing() == gtk.TREE_VIEW_COLUMN_FIXED
for c in self.treeview.get_columns()))
self.treeview.connect('button-press-event', self.__button_press)
self.treeview.connect('key-press-event', self.on_keypress)
self.treeview.connect_after('row-activated', self.__sig_switch)
if self.children_field:
self.treeview.connect('test-expand-row', self.test_expand_row)
self.treeview.set_expander_column(self.treeview.get_column(0))
self.treeview.set_rubber_banding(True)
selection = self.treeview.get_selection()
selection.set_mode(gtk.SELECTION_MULTIPLE)
selection.connect('changed', self.__select_changed)
self.set_drag_and_drop()
self.widget = gtk.VBox()
self.scroll = scroll = gtk.ScrolledWindow()
scroll.add(self.treeview)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.set_placement(gtk.CORNER_TOP_LEFT)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_ETCHED_IN)
viewport.add(scroll)
self.widget.pack_start(viewport, expand=True, fill=True)
self.sum_box.show()
self.widget.pack_start(self.sum_box, expand=False, fill=False)
self.display()
def createWidgets(self):
self.transactionWidgets = {}
self.pipes = {}
self.scroll = ScrollContainer()
self.scroll.hAdjust[0].set_property("step-increment", 20)
self.cursor = Types.Observable(-1)
# The ruler at the top is in charge of our time scale
self.ruler = Ruler()
TimeCursor(self.ruler, self.ruler, self.cursor)
self.ruler.canvas.set_hadjustment(self.scroll.hAdjust[0])
# The top heading holds the ruler, and a spacer aligned with the left heading
leftHeadingWidth = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
spacer = gtk.Label()
leftHeadingWidth.add_widget(spacer)
topHeading = gtk.HBox(False)
topHeading.pack_start(spacer, False, padding=self.labelPadding)
topHeading.pack_start(gtk.VSeparator(), False)
topHeading.pack_start(self.ruler.canvas, True)
# Everything except the top heading scrolls vertically using a viewport
viewport = gtk.Viewport(None, self.scroll.vAdjust[0])
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.set_size_request(1, 1)
viewportBox = gtk.VBox(False)
viewportBox.pack_start(topHeading, False)
viewportBox.pack_start(gtk.HSeparator(), False)
viewportBox.pack_start(viewport, True)
self.scroll.add(viewportBox)
# Gnome Canvas has really silly event grabbing semantics. To work around
# all this, we'll just grab all events before gnome-canvas sees them.
for widget in (viewport, self.ruler.canvas):
widget.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.BUTTON_PRESS_MASK)
for event in ('motion-notify-event', 'button-press-event',
'scroll-event'):
widget.connect_after(event, self.mouseEvent)
self.scroll.attachEvent(widget, horizontal=True)
# The left heading holds labels for each canvas in the stack
self.leftHeading = gtk.VBox(False)
leftHeadingWidth.add_widget(self.leftHeading)
# The viewport holds the left heading, then the main canvas stack
scrolledBox = gtk.HBox(False)
self.canvasList = []
self.canvasStack = gtk.VBox(False)
scrolledBox.pack_start(self.leftHeading,
False,
padding=self.labelPadding)
scrolledBox.pack_start(gtk.VSeparator(), False)
scrolledBox.pack_start(self.canvasStack, True)
viewport.add(scrolledBox)
return self.scroll
def update(self, view, defaults, buttons):
for button in buttons:
self._get_button(button)
self.screen = Screen(view['model'], mode=[], context=self.context)
self.screen.add_view(view)
self.screen.switch_view()
self.screen.widget.show()
self.screen.signal_connect(self, 'group-changed',
self._record_changed)
title = gtk.Label()
title.modify_font(pango.FontDescription("bold 14"))
title.set_label(self.name)
title.set_padding(20, 4)
title.set_alignment(0.0, 0.5)
title.set_size_request(0, -1) # Allow overflow
title.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000"))
title.show()
hbox = gtk.HBox()
hbox.pack_start(title, expand=True, fill=True)
hbox.show()
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
frame.add(hbox)
frame.show()
eb = gtk.EventBox()
eb.add(frame)
eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#ffffff"))
eb.show()
self.widget.pack_start(eb, expand=False, fill=True, padding=3)
if self.toolbar_box:
self.widget.pack_start(self.toolbar_box, False, True)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(self.screen.widget)
viewport.show()
self.scrolledwindow = gtk.ScrolledWindow()
self.scrolledwindow.set_shadow_type(gtk.SHADOW_NONE)
self.scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrolledwindow.add(viewport)
self.scrolledwindow.show()
self.widget.pack_start(self.scrolledwindow, expand=True, fill=True)
self.create_info_bar()
self.widget.pack_start(self.info_bar, False, True)
self.screen.new(default=False)
self.screen.current_record.set_default(defaults)
self.update_buttons(self.screen.current_record)
self.screen.set_cursor()
def __init__(self, xml, ksHandler):
self.ks = ksHandler
self.firewall_frame = xml.get_widget("firewall_frame")
self.firewall_vbox = xml.get_widget("firewall_vbox")
self.firewall_label_box = xml.get_widget("firewall_label_box")
self.securityOptionMenu = xml.get_widget("securityOptionMenu")
self.selinuxOptionMenu = xml.get_widget("selinuxOptionMenu")
self.selinuxOptionMenu.set_active(0)
self.firewallDefaultRadio = xml.get_widget("firewallDefaultRadio")
self.trusted_devices_label = xml.get_widget("trusted_devices_label")
self.allow_incoming_label = xml.get_widget("allow_incoming_label")
self.fnnirewall_ports_label = xml.get_widget("firewall_ports_label")
self.firewall_ports_entry = xml.get_widget("firewall_ports_entry")
self.customTable = xml.get_widget("customTable")
self.customFrame = xml.get_widget("customFrame")
self.securityOptionMenu.connect("changed", self.disable_firewall)
self.securityOptionMenu.set_active(0)
self.label2 = gtk.Label (_("Trusted services:"))
self.label2.set_alignment (0.0, 0.0)
self.incomingStore = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING)
self.incomingView = gtk.TreeView()
self.incomingView.set_headers_visible(False)
self.incomingView.set_model(self.incomingStore)
checkbox = gtk.CellRendererToggle()
checkbox.connect("toggled", self.item_toggled, self.incomingStore)
col = gtk.TreeViewColumn('', checkbox, active = 0)
col.set_fixed_width(20)
col.set_clickable(True)
self.incomingView.append_column(col)
col = gtk.TreeViewColumn("", gtk.CellRendererText(), text=1)
self.incomingView.append_column(col)
self.list = {"SSH":"ssh", "Telnet":"telnet", "WWW (HTTP)":"http",
"Mail (SMTP)":"smtp", "FTP":"ftp"}
for item in self.list.keys():
iter = self.incomingStore.append()
self.incomingStore.set_value(iter, 0, False)
self.incomingStore.set_value(iter, 1, item)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_ETCHED_IN)
viewport.add(self.incomingView)
self.customTable.attach (self.label2, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
self.customTable.attach (viewport, 1, 2, 0, 1, gtk.EXPAND|gtk.FILL, gtk.FILL)
self.label3 = gtk.Label (_("Other ports (1029:tcp):"))
self.label3.set_alignment (0.0, 0.5)
self.portsEntry = gtk.Entry ()
self.customTable.attach (self.label3, 0, 1, 2, 3, gtk.FILL, gtk.FILL)
self.customTable.attach (self.portsEntry, 1, 2, 2, 3, gtk.EXPAND|gtk.FILL, gtk.FILL)
self.firewall_vbox.show_all()
def get_scrollable_label():
label = gtk.Label()
label.set_use_markup(True)
label.set_line_wrap(True)
label.set_line_wrap_mode(pango.WRAP_WORD)
viewport = gtk.Viewport()
viewport.add(label)
viewport.show_all()
return label, viewport
def _createUi(self):
# basic initialization
self.set_border_width(5)
# scrolled window
self.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self._no_objs = gtk.Viewport()
self._no_objs.add(gtk.Label(_("No Objects Selected")))
self._contents = self._no_objs
self.add(self._no_objs)
def __init__(self):
super(InfoBoxPage, self).__init__()
self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.vbox = gtk.VBox()
self.vbox.set_spacing(10)
viewport = gtk.Viewport()
viewport.add(self.vbox)
self.add(viewport)
self.expanders = {}
self.label = None
def __init__(self):
HIGScrolledWindow.__init__(self)
self._boxeditable = None
vp = gtk.Viewport()
self._create_widgets()
vp.add(self._box)
vp.set_shadow_type(gtk.SHADOW_NONE)
self.add(vp)
self._profilecore = None
self._selected = None
