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 )