def _create_widgets(self):
self._optionlist = OptionList()
label = gtk.Label('Items at the %s ' % self._name)
self._box = gtk.HPaned()
ol = self._optionlist
ol.reload()
self.vbox.pack_start(label, False, False, 0)
self._box.add(ol)
self.vbox.pack_start(self._box)
self._box.show_all()
self._move_box = HIGVBox()
self._add_bt = HIGButton(stock='gtk-add')
self._add_bt.connect('clicked', self._on_add_press)
self._remove_bt = HIGButton(stock='gtk-remove')
self._remove_bt.connect('clicked', self._on_remove_press)
#XXX - moves don't work yet: lack the connect
self._move_up_bt = HIGButton(stock='gtk-go-up')
self._move_down_bt = HIGButton(stock='gtk-go-down')
self._move_box.pack_start(self._add_bt, False, False)
self._move_box.pack_start(self._remove_bt, False, False)
self._move_box.pack_start(self._move_up_bt, False, False)
self._move_box.pack_start(self._move_down_bt, False, False)
self._create_option_tv()
self._box.set_position(200)
self._box_other = gtk.HPaned()
self._box.add(self._box_other)
self._box_other.add(self._move_box)
self._box_other.add(self._sw)
self._move_box.show_all()
self.vbox.show_all()
label.show()
def horz(params, cols, pack):
if len(cols) > 2:
hpaned = gtk.HPaned()
make(cols[0],
lambda w: hpaned.pack1(w, resize=True, shrink=True))
horz(params, cols[1:],
lambda w: hpaned.pack2(w, resize=True, shrink=True))
pack(hpaned)
elif len(cols) == 2:
hpaned = gtk.HPaned()
make(cols[0],
lambda w: hpaned.pack1(w, resize=True, shrink=True))
make(cols[1],
lambda w: hpaned.pack2(w, resize=True, shrink=True))
pack(hpaned)
elif len(cols) == 1:
hpaned = gtk.HBox()
make(
cols[0],
lambda w: hpaned.pack_start(w, expand=True, fill=True)) #?
pack(hpaned)
process_common_params(hpaned, params)
hpaned.show_all()
def __init__(self):
self.session = SteamPoweredSession()
self.session.set_captcha_img(self.session.captchagid)
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(1)
self.window.set_resizable(False)
self.window.set_title("Steam Account Creator")
self.hpane = gtk.HPaned()
self.hpane2 = gtk.HPaned()
self.vpane = gtk.VPaned()
self.entry = gtk.Entry(max=0)
self.button = gtk.Button("Hit Me")
self.button2 = gtk.Button("Try Again")
self.button.connect("clicked", self.submit_and_refresh, None)
self.button2.connect("clicked", self.refresh, None)
self.hpane.add1(self.entry)
self.hpane.add2(self.button)
self.hpane2.add1(self.hpane)
self.hpane2.add2(self.button2)
self.vpane.add1(self.hpane2)
self.image = gtk.Image()
self.image.set_from_file("captcha.png")
self.image.show()
self.vpane.show()
self.vpane.add2(self.image)
self.window.add(self.vpane)
self.hpane.show()
self.hpane2.show()
self.button.show()
self.button2.show()
self.entry.show()
self.window.show()
def _pack_panes(self, bufferview, pluginview):
p0 = gtk.HPaned()
self.__mainbox.pack_start(p0)
sidebar_width = self.__manager.opt('layout', 'sidebar_width')
sidebar_on_right = self.__manager.opt('layout', 'sidebar_on_right')
sidebar = self._create_sidebar(bufferview, pluginview)
p1 = gtk.VPaned()
if sidebar_on_right:
side_func = p0.pack2
main_func = p0.pack1
main_pos = 800 - sidebar_width
else:
side_func = p0.pack1
main_func = p0.pack2
main_pos = sidebar_width
side_func(sidebar, resize=False)
main_func(p1, resize=True)
p0.set_position(main_pos)
editor = contentbook.Contentholder(show_tabs=False)
self.__viewbooks['edit'] = editor
p1.pack1(editor, resize=True)
viewbook = contentbook.Contentholder()
self.__viewbooks['view'] = viewbook
p1.pack2(viewbook, resize=False)
extb = self.__viewbooks['ext'] = external_book()
p1.set_position(430)
self.resize(800, 600)
def _init_elements(self):
"""Initialize main window elements."""
self._init_statusbar()
self._init_panes()
vbox = gtk.VBox()
self.add(vbox)
vbox.pack_start(self._init_menubar(), False, False)
vbox.pack_start(self._init_toolbar(), False, False)
hpaned = gtk.HPaned()
vbox.pack_start(hpaned, True, True)
hpaned.show()
vpaned = gtk.VPaned()
hpaned.add2(vpaned)
vpaned.show()
hpaned.add1(self.side_pane)
vpaned.add2(self.bottom_pane)
self.queries = pane.CenterPane(self)
vpaned.add1(self.queries)
self.queries.show()
# Connect to realize to set paned position when window is ready.
self.connect('realize', self.on_set_paned_position, vpaned)
self.connect('realize', self.on_set_paned_position, hpaned)
vbox.pack_start(self.statusbar, False, False)
vbox.show()
self.browser = Browser(self.app, self)
self.side_pane.add_item(self.browser)
self.side_pane.set_active_item('navigator')
menu = self.ui.get_widget('/MenuBar/Query/Connection')
menu.connect('activate', self.on_connection_menu_activate)
menu = self.ui.get_widget('/MenuBar/Query')
menu.connect('activate', self.on_query_menu_activate)
self._init_file_open()
def __init__(self, main_view):
BACKEND.refresh_cache()
gtk.VBox.__init__(self, False, 5)
self.pack_start(
long_text_label(
_('Ailurus helps you keep track of what software you have installed/removed. '
'If you often try to use new software, you do not have to worry about messing up your system now.'
)), False)
self.store = _snapshot_store()
self.snapshot_list = _snapshot_list(self.store)
self.diff_list = _diff_list()
self.snapshot_list.connect(
'snapshot_selected',
lambda w, sn: self.diff_list.show_difference(sn))
paned = gtk.HPaned()
paned.pack1(self.snapshot_list)
paned.pack2(self.diff_list)
b_add = image_stock_button(gtk.STOCK_ADD, _('Create a snapshot'))
b_add.connect('clicked', lambda *w: self.store.create_snapshot_now())
b_delete = stock_image_only_button(gtk.STOCK_DELETE)
b_delete.set_tooltip_text(_('Delete selected snapshot'))
b_delete.connect('clicked',
lambda *w: self.snapshot_list.remove_selected())
b_apply = image_stock_button(gtk.STOCK_APPLY, _('Apply'))
b_apply.connect('clicked', lambda *w: self.apply_change())
b_box = gtk.HBox(False, 10)
b_box.pack_start(b_add, False)
b_box.pack_start(b_delete, False)
b_box.pack_start(b_apply, False)
self.pack_start(paned)
self.pack_start(b_box, False)
def make_view(self):
#################
### gtk Vbox
#################
sys_contents = gtk.VBox()
logo = gtk.HBox()
self.main_box = gtk.HPaned()
# title_paned.pack_start(logo,0,0)
######################## left tree ##########################################
left_tree = self.init_left_tree()
left_tree.connect("cursor-changed",self.select_host)
self.left_tree_view,left_tree_window = left_tree.make_view(expend=False)
self.left_tree_view.connect('button_press_event', self.show_popup_menu)
self.create_popup()
self.current_page = self.init_host_page()
self.main_box.set_position(self.pane_position)
self.main_box.pack1(left_tree_window,resize=True, shrink=False)
self.main_box.pack2(self.current_page,resize=True, shrink=False)
sys_contents.pack_start(logo,0,0)
sys_contents.pack_start(self.main_box,1,1)
return sys_contents
def __init__(self):
gtk.Window.__init__(self)
self.connect("destroy", self.destroy)
self.preferences = pref.preferences(pref_fn)
# subdivisor para menu y resto
vb = gtk.VBox()
self.add(vb)
mnu = main_menu()
vb.pack_start(mnu, expand=False)
# subdivisor para editor/archivos
hp = gtk.HPaned()
vb.pack_start(hp, expand=False)
l = gtk.Label("Espacio panel izquierdo")
f1 = gtk.Frame()
f1.set_shadow_type(gtk.SHADOW_ETCHED_IN)
f1.add(l)
hp.add1(f1)
self.ed_mgr = editor_mgr.editor_manager()
self.ed_mgr.add_editor("Inicial")
f2 = gtk.Frame()
f2.set_shadow_type(gtk.SHADOW_ETCHED_IN)
f2.add(self.ed_mgr)
hp.add2(f2)
pdb.set_trace()
self.show_all()
def create_ui(self):
self.pane = gtk.HPaned()
self.widget.add(self.pane)
self.listing = PersonList()
self.detail = PersonForm()
self.pane.pack1(self.listing.widget)
self.pane.pack2(self.detail.widget)
def build_interface(self):
"""
Builds the container widget for the interface.
Returns a gtk container widget.
"""
defaults = self.get_default_gramplets()
self.sidebar = GrampsBar(self.dbstate, self.uistate, self,
self.ident + "_sidebar",
defaults[0])
self.bottombar = GrampsBar(self.dbstate, self.uistate, self,
self.ident + "_bottombar",
defaults[1])
hpane = gtk.HPaned()
vpane = gtk.VPaned()
hpane.pack1(vpane, resize=True, shrink=False)
hpane.pack2(self.sidebar, resize=False, shrink=True)
hpane.show()
vpane.show()
widget = self.build_widget()
widget.show_all()
vpane.pack1(widget, resize=True, shrink=False)
vpane.pack2(self.bottombar, resize=False, shrink=True)
self.sidebar_toggled(self.sidebar.get_property('visible'))
return hpane
def __init__(self, platform, action_handler_callback):
"""
MainWindow contructor
Setup the menu, toolbar, flowgraph editor notebook, block selection window...
"""
self._platform = platform
gen_opts = platform.blocks['options'].get_param('generate_options')
generate_mode_default = gen_opts.get_value()
generate_modes = [(o.get_key(), o.get_name(),
o.get_key() == generate_mode_default)
for o in gen_opts.get_options()]
# load preferences
Preferences.load(platform)
#setup window
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
vbox = gtk.VBox()
self.hpaned = gtk.HPaned()
self.add(vbox)
#create the menu bar and toolbar
self.add_accel_group(Actions.get_accel_group())
self.menu_bar = Bars.MenuBar(generate_modes, action_handler_callback)
vbox.pack_start(self.menu_bar, False)
self.tool_bar = Bars.Toolbar(generate_modes, action_handler_callback)
vbox.pack_start(self.tool_bar, False)
vbox.pack_start(self.hpaned)
#create the notebook
self.notebook = gtk.Notebook()
self.page_to_be_closed = None
self.current_page = None
self.notebook.set_show_border(False)
self.notebook.set_scrollable(True) #scroll arrows for page tabs
self.notebook.connect('switch-page', self._handle_page_change)
#setup containers
self.flow_graph_vpaned = gtk.VPaned()
#flow_graph_box.pack_start(self.scrolled_window)
self.flow_graph_vpaned.pack1(self.notebook)
self.hpaned.pack1(self.flow_graph_vpaned)
self.btwin = BlockTreeWindow(platform, self.get_flow_graph)
self.hpaned.pack2(self.btwin, False) #dont allow resize
#create the reports window
self.text_display = TextDisplay()
#house the reports in a scrolled window
self.reports_scrolled_window = gtk.ScrolledWindow()
self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.reports_scrolled_window.add(self.text_display)
self.reports_scrolled_window.set_size_request(
-1, DEFAULT_REPORTS_WINDOW_WIDTH)
self.flow_graph_vpaned.pack2(self.reports_scrolled_window,
False) #dont allow resize
#load preferences and show the main window
self.resize(*Preferences.main_window_size())
self.flow_graph_vpaned.set_position(
Preferences.reports_window_position())
self.hpaned.set_position(Preferences.blocks_window_position())
self.show_all()
self.reports_scrolled_window.hide()
self.btwin.hide()
def __init__(self, parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title(self.__class__.__name__)
self.set_border_width(0)
rootbox = gtk.HBox(False, 0)
self.add(rootbox)
hpaned = gtk.HPaned()
hpaned.set_border_width(5)
rootbox.pack_start(hpaned, True, True)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.set_size_request(200, 80)
button_l = gtk.Button("Left")
frame.add(button_l)
hpaned.add(frame)
frame2 = gtk.Frame()
frame2.set_shadow_type(gtk.SHADOW_IN)
frame2.set_size_request(200, 80)
self.button_r = gtk.Button("Close me")
self.button_r.connect("clicked", self.switch, hpaned, frame2)
frame2.add(self.button_r)
hpaned.add2(frame2)
self.show_all()
def __init__(self, title=None, type=gtk.WINDOW_TOPLEVEL):
gtk.Window.__init__(self, type)
self.set_default_size(Width, Height)
self.da = gtk.DrawingArea()
self.da.connect('expose-event', self.da_expose_event)
def put_in_frame(widget):
frame = gtk.Frame(label=None)
frame.set_property('shadow_type', gtk.SHADOW_IN)
frame.add(widget)
return frame
vpaned = gtk.VPaned()
self.add(vpaned)
sv = self.create_text_view()
vpaned.pack1(put_in_frame(sv), True, True)
sv.set_size_request(Width, int(Height / 2))
hpaned = gtk.HPaned()
vpaned.pack2(hpaned, True, False)
sl = self.create_snippet_list()
hpaned.pack1(put_in_frame(sl), True, True)
hpaned.pack2(put_in_frame(self.da), True, True)
self.da.set_size_request(int(Width / 2), int(Height / 2))
# set focus to snippet list
sl.get_child().grab_focus()
def __init__(self, app, presenter):
gtk.VBox.__init__(self)
self.app = app
self.presenter = presenter
self.caption = presenter.doc_name
self.tab_caption = TabDocCaption(self, self.caption)
self.tb = DocToolbar(app, self)
self.pack_start(self.tb, False, True, 0)
self.hpaned = gtk.HPaned()
self.hpaned.set_border_width(0)
self.hpaned.set_position(250)
self.modelbrowser = ModelViewWidget(app, presenter)
self.hpaned.pack1(self.modelbrowser, True, False)
self.modelbrowser.set_size_request(250, -1)
self.inspect = ObjectIntrospectionWidget(app, presenter)
self.hexview = ObjectVisualizerWidget(app, presenter)
self.hpaned.pack2(self.hexview if config.bin_view else self.inspect,
True, False)
self.view = config.bin_view
self.pack_start(self.hpaned, True, True, 0)
self.show_all()
def __init__(self):
gtk.Window.__init__(self)
self.connect("destroy", self.destroy)
self.preferences = pref.preferences(pref_fn)
# subdivisor para menu y resto
vb = gtk.VBox()
self.add(vb)
#itemBarra={"_File",{{"_Save",self.save},{"", None},{"_Quit", self.destroy}}}
itemBarra = {
"_File": {
"_Save": self.save,
"": None,
"_Quit": self.destroy,
"_New": self.new,
"_Open": self.openn
},
"_Edit": {
"_Copy": self.copy,
"_Cut": self.cut,
"_Paste": self.paste
},
"_Help": {
"_About": about_window
}
}
barra = barraHerramientas()
barra.add_items(itemBarra)
vb.pack_start(barra, expand=False)
# subdivisor para editor/archivos
self.hp = gtk.HPaned()
#~ vb.pack_start(hp, expand = False)
vb.add(self.hp)
l = gtk.Label("Espacio panel izquierdo")
f1 = gtk.Frame()
f1.set_shadow_type(gtk.SHADOW_ETCHED_IN)
f1.add(l)
#~ hp.add1(f1)
self.hp.add(f1)
self.ed_mgr = editor_mgr.editor_manager()
self.editor = self.ed_mgr.add_editor("Inicial")
self.editor2 = self.ed_mgr.add_editor("Final")
#~ print(self.ed_mgr.get_current_page())
self.f2 = gtk.Frame()
self.f2.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.f2.add(self.ed_mgr)
#~ hp.add2(f2)
self.hp.add(self.f2)
self.show_all()
def __init__(self, kind, children):
self.widget = gtk.VPaned() if kind == 'v' else gtk.HPaned()
child1, child2 = children
child1.show()
child2.show()
self.widget.pack1(child1, resize=True, shrink=True)
self.widget.pack2(child2, resize=True, shrink=True)
def _create_sidebar(self, bufferview, pluginview):
sidebar_horiz = self.__manager.opt('layout', 'vertical_sidebar_split')
if sidebar_horiz:
box = gtk.HPaned()
else:
box = gtk.VPaned()
bar = gtk.VBox()
box.pack1(bar, resize=True)
bufs = expander.expander()
bufs.set_body_widget(bufferview)
l = gtk.Label('Buffer list')
l.set_alignment(0, 0.5)
bufs.set_label_widget(l)
bufs.expand()
bar.pack_start(bufs, expand=True)
bar.pack_start(pluginview)
bar2 = gtk.VBox()
box.pack2(bar2, resize=True)
vb = self.__viewbooks['language'] = contentbook.contentbook(
'Languages')
bar2.pack_start(vb)
vb.collapse()
vb = self.__viewbooks['content'] = contentbook.contentbook(
'Quick View')
bar2.pack_start(vb)
vb.collapse()
return box
def addTreeView(self):
hpaned = gtk.HPaned()
hpaned.set_name(
"VCS dialog separator"
) # Mostly so we can filter the proportions, which we don't set
# We need buffer when creating treeview, so create right-hand side first ...
self.textBuffer = gtk.TextBuffer()
textView = gtk.TextView(self.textBuffer)
textView.set_editable(False)
textView.set_name("VCS Output View")
window2 = gtk.ScrolledWindow()
window2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
window2.add(textView)
hpaned.pack2(window2, True, True)
self.createTreeView()
window1 = gtk.ScrolledWindow()
window1.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
window1.add(self.treeView)
hpaned.pack1(window1, False, True)
if len(self.pages) > 0:
parentSize = self.topWindow.get_size()
self.dialog.resize(parentSize[0], int(parentSize[0] / 1.5))
self.vbox.pack_start(hpaned, expand=True, fill=True)
self.dialog.vbox.pack_start(self.vbox, expand=True, fill=True)
def setupGUI(self):
self.set_default_size(700, 500)
self.set_title(self.programName)
# Set a handler for delete_event that immediately
# exits GTK.
self.connect("delete_event", self.delete_event)
# Sets the border width of the window.
self.set_border_width(0)
self.hpane = gtk.HPaned()
self.add(self.hpane)
#self.setupMenu()
self.inner_pane = gtk.VPaned()
self.hpane.add1(self.inner_pane)
self.upper_hbox = gtk.HBox()
self.lower_vbox = gtk.VBox()
self.inner_pane.add1(self.upper_hbox)
self.inner_pane.add2(self.lower_vbox)
self.setupCanvas()
#self.setupLog()
self.set_icon_list(eegpy_logo("small"), eegpy_logo("large"))
self.show_all()
self.panePosDef = self.hpane.get_position()
def __init__(self, config, input_mods, _mstdout, mstderr):
try:
topic_continuum_set = TopicContinuumSet(input_mods, config)
except RMTException as rmte:
mstderr.write(
"+++ ERROR: Problem reading in the continuum [%s]\n" % rmte)
return
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("rmtoo - Read only GUI")
self.window.set_default_size(800, 600)
# create a vpaned widget and add it to our toplevel window
hpaned = gtk.HPaned()
self.window.add(hpaned)
hpaned.show()
# Now create the contents of the two halves of the window
list = self.create_tree(topic_continuum_set)
hpaned.add1(list)
list.show()
text = self.create_text()
hpaned.add2(text)
text.show()
self.window.show()
def __init__(self, querylist, config, parent, debug=True):
"""Constructor for GraphViewer"""
self.sql = querylist
self.conf = config
self.debug = debug
self.parent = parent
#print "start of GraphViewer constructor"
self.db = Database.Database(self.conf, sql=self.sql)
filters_display = {
"Heroes": True,
"Sites": True,
"Games": False,
"Currencies": True,
"Limits": False,
"LimitSep": False,
"LimitType": False,
"Type": False,
"UseType": 'tour',
"Seats": False,
"SeatSep": False,
"Dates": True,
"GraphOpsTour": True,
"Groups": False,
"Button1": True,
"Button2": True
}
self.filters = Filters.Filters(self.db,
self.conf,
self.sql,
display=filters_display)
self.filters.registerButton1Name(_("Refresh _Graph"))
self.filters.registerButton1Callback(self.generateGraph)
self.filters.registerButton2Name(_("_Export to File"))
self.filters.registerButton2Callback(self.exportGraph)
self.mainHBox = gtk.HBox(False, 0)
self.mainHBox.show()
self.leftPanelBox = self.filters.get_vbox()
self.hpane = gtk.HPaned()
self.hpane.pack1(self.leftPanelBox)
self.mainHBox.add(self.hpane)
# hierarchy: self.mainHBox / self.hpane / self.graphBox / self.canvas / self.fig / self.ax
self.graphBox = gtk.VBox(False, 0)
self.graphBox.show()
self.hpane.pack2(self.graphBox)
self.hpane.show()
self.fig = None
#self.exportButton.set_sensitive(False)
self.canvas = None
self.db.rollback()
#update the graph at entry (simulate a "Refresh Graph" click)
gobject.GObject.emit(self.filters.Button1, "clicked")
def __init__(self, plugin, window):
self.window = window
self.plugin = plugin
self.popup = None
self.popup_tab_list = gtk.VBox()
# Read preferences
self.config = ConfigParser.ConfigParser()
self.read_prefs()
# Determines which tab must be placed on right
self.right_tab_indexes, self.load = [], []
if self.config.has_option('right_pane', 'tabs'):
for i in self.config.get('right_pane', 'tabs').split(','):
if self.config.has_option('right_pane', 'tab' + i):
self.load.append(self.config.get('right_pane', 'tab' + i))
self.config.remove_option('right_pane', 'tab' + i)
# gedit elements
self.gbox = self.window.get_child()
self.old_hpaned = self.gbox.get_children()[2]
self.new_hpaned = gtk.HPaned()
self.left_pane = self.old_hpaned.get_child1()
self.left_head = self.left_pane.get_children()[0]
self.left_notebook = self.left_pane.get_children()[1]
self.right_pane = gedit.Panel()
self.view_menu = self.gbox.get_children()[0].get_children(
)[2].get_submenu()
# Insert the menu + right pane
self.insert_menu()
self.position_items_in_menu()
self.insert_right_pane()
self.window.connect("show", self.on_gedit_show)
self.window.connect('delete-event', self.on_gedit_delete)
self.lock, self.delete = False, False
self.show = self.window.get_property("visible")
if self.show:
self.on_gedit_show()
def __init__(self, parent):
self.app = parent
gtk.Frame.__init__(self)
self.file_name = ""
self.width = 640
self.height = 480
self.m_frame = 5
self.complist = []
self.siglist = []
sw = gtk.ScrolledWindow()
canvas_frame = gtk.Frame(label="HAL Editor")
clist_frame = gtk.Frame(label="Components")
self.canvas = HalCanvas(self)
canvas_frame.add(sw)
sw.add(self.canvas)
sw.set_shadow_type(gtk.SHADOW_IN)
self.clist = ComponentList(self)
clist_frame.add(self.clist)
paned = gtk.HPaned()
paned.set_border_width(2)
paned.pack1(canvas_frame, True, True)
paned.pack2(clist_frame, False, True)
paned.set_position(800)
self.add(paned)
def __init__(self, arguments):
import getopt, glob, operator
gtk.Window.__init__(self)
#z48 = Devices.get_instance("z48", "usb")
options, arguments = getopt.getopt(arguments, '?p')
d = DirectoryNode("c:\\j\\mpc1000\\akpakm\\joe")
self.hpaned = gtk.HPaned()
self.treestore_dir = d.get_treestore()
self.treestore_files = gtk.TreeStore(str, str) # temp
# scrolling treeviews
self.sw_dir = BrowserScrolledWindow(self.treestore_dir)
self.sw_files = BrowserScrolledWindow(self.treestore_files)
# hook up events
self.sw_dir.treeview.connect("button-press-event",
self.on_treeview_event)
selection = self.sw_dir.treeview.get_selection()
selection.connect("changed", self.on_dir_selection_changed)
self.sw_files.treeview.connect("button-press-event",
self.on_treeview_event)
selection = self.sw_files.treeview.get_selection()
selection.connect("changed", self.on_file_selection_changed)
self.init_files(d.path)
self.hpaned.add1(self.sw_dir)
self.hpaned.add2(self.sw_files)
self.add(self.hpaned)
self.show_all()
self.connect("delete-event", gtk.main_quit)
def __init__(self):
gtk.Window.__init__(self)
self.connect("destroy", gtk.main_quit)
split = gtk.HPaned()
self.add(split)
self.movies = gtk.TreeView(gtk.ListStore(str, str))
self.movies.append_column(
gtk.TreeViewColumn("Movies", gtk.CellRendererText(), text=0))
self.movies.connect("row-activated", self.on_row_activated)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(self.movies)
searchbox = gtk.HBox()
txtsearch = gtk.Entry()
searchbox.pack_start(txtsearch, True, True)
btnsearch = gtk.Button("Search")
searchbox.pack_start(btnsearch, False)
btnsearch.connect("clicked",
lambda b: self.query(txtsearch.get_text()))
leftside = gtk.VBox()
leftside.pack_start(searchbox, False)
leftside.pack_start(scroll, True)
split.add1(leftside)
self.browse = gtkmozembed.MozEmbed()
split.add2(self.browse)
self.show_all()
def _build_ui(self):
self._display = gtk.Table(20, 2)
self._store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
self._tree = gtk.TreeView(self._store)
rend = gtk.CellRendererText()
tvc = gtk.TreeViewColumn('Element', rend, text=0)
self._tree.append_column(tvc)
self._tree.connect('button_press_event', self._tree_click)
self.root = gtk.HPaned()
self.root.set_position(200)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self._tree)
sw.show()
self.root.add1(sw)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add_with_viewport(self._display)
sw.show()
self.root.add2(sw)
self._tree.show()
self._display.show()
self.root.show()
def __init__(self):
gtk.Window.__init__(self)
self.set_title("Dependency Explorer")
self.set_default_size(500, 500)
self.connect("delete-event", gtk.main_quit)
# Create the data models
self.pkg_model = gtk.ListStore(gobject.TYPE_STRING)
self.pkg_model.set_sort_column_id(COL_PKG_NAME, gtk.SORT_ASCENDING)
self.depends_model = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.depends_model.set_sort_column_id(COL_DEP_PACKAGE, gtk.SORT_ASCENDING)
pane = gtk.HPaned()
pane.set_position(250)
self.add(pane)
# The master list of packages
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.pkg_treeview = gtk.TreeView(self.pkg_model)
self.pkg_treeview.get_selection().connect("changed", self.on_cursor_changed)
column = gtk.TreeViewColumn("Package", gtk.CellRendererText(), text=COL_PKG_NAME)
self.pkg_treeview.append_column(column)
pane.add1(scrolled)
scrolled.add(self.pkg_treeview)
box = gtk.VBox(homogeneous=True, spacing=4)
# Runtime Depends
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.rdep_treeview = PackageDepView(self.depends_model, TYPE_RDEP, "Runtime Depends")
self.rdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
scrolled.add(self.rdep_treeview)
box.add(scrolled)
# Build Depends
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.dep_treeview = PackageDepView(self.depends_model, TYPE_DEP, "Build Depends")
self.dep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
scrolled.add(self.dep_treeview)
box.add(scrolled)
pane.add2(box)
# Reverse Depends
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.revdep_treeview = PackageReverseDepView(self.depends_model, "Reverse Depends")
self.revdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PARENT)
scrolled.add(self.revdep_treeview)
box.add(scrolled)
pane.add2(box)
self.show_all()
def set_view_mode(self, mode):
"""
Sets view mode for ThreePaneViewer
modes:
"vertical"
"horizontal"
"""
vsash = self.paned2.get_position()
# detach widgets
self.paned2.remove(self.listview_sw)
self.paned2.remove(self.editor_pane)
self.hpaned.remove(self.paned2)
# remake paned2
if mode == "vertical":
# create a vertical paned widget
self.paned2 = gtk.VPaned()
else:
# create a horizontal paned widget
self.paned2 = gtk.HPaned()
self.paned2.set_position(vsash)
self.paned2.show()
self.hpaned.add2(self.paned2)
self.hpaned.show()
self.paned2.add1(self.listview_sw)
self.paned2.add2(self.editor_pane)
# record preference
self._view_mode = mode
def __init__(self, model):
gtk.VBox.__init__(self)
self.model = model
self.gc = gconf.client_get_default()
# Build the side navigation bar
self.navigation = Navigation(self.model)
self.navigation.connect("stream-selected", self.on_stream_change)
self.navigation.connect("stream-closed", self.on_stream_closed)
self.navigation.render()
self.navigation_scroll = gtk.ScrolledWindow()
self.navigation_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
self.navigation_scroll.add(self.navigation)
self.messages = MessageStream(self.model)
self.messages.message_view.connect("action", self.on_action)
self.search_box = GwibberSearch()
self.search_box.connect("search", self.on_search)
layout = gtk.VBox(spacing=5)
layout.pack_start(self.search_box, False)
layout.pack_start(self.messages, True)
# Build the pane layout
self.splitter = gtk.HPaned()
self.splitter.add1(self.navigation_scroll)
self.splitter.add2(layout)
self.splitter.connect("notify", self.on_splitter_drag)
self.pack_start(self.splitter, True)
def split( self, direction, childSubPanelIndex=0, position=0.5 ) : assert( not self.isSplit() ) if not isinstance( direction, Splittable.SplitDirection ) or not direction : raise TypeError( "Split direction not valid" ) if childSubPanelIndex < 0 or childSubPanelIndex > 1 : raise IndexError( "Panel index out of range." ) child = self.getChild() if child : self.setChild( None ) if direction==self.SplitDirection.Vertical : self.__paned = gtk.HPaned() else : self.__paned = gtk.VPaned() self.__subPanels = [ Splittable(), Splittable() ] self.__paned.pack1( self.__subPanels[0].gtkWidget(), True, True ) self.__paned.pack2( self.__subPanels[1].gtkWidget(), True, True ) if child : self.__subPanels[childSubPanelIndex].setChild( child ) self.__paned.show() self.__eventBox.add( self.__paned ) self.setSplitPosition( position )
