def __init__(self, column_title, tree_model, quantity_store_idx, is_multi_entitled_store_idx, available_store_idx=None, editable=True): self.quantity_store_idx = quantity_store_idx self.is_multi_entitled_store_idx = is_multi_entitled_store_idx self.available_store_idx = available_store_idx self.quantity_renderer = gtk.CellRendererSpin() self.quantity_renderer.set_property("xalign", 0.5) self.quantity_renderer.set_property( "adjustment", gtk.Adjustment(lower=1, upper=100, step_incr=1)) self.quantity_renderer.set_property("editable", editable) self.quantity_renderer.connect("edited", self._on_edit, tree_model) self.quantity_renderer.connect("editing-started", self._setup_editor) gtk.TreeViewColumn.__init__(self, column_title, self.quantity_renderer, text=self.quantity_store_idx) self.set_cell_data_func(self.quantity_renderer, self._update_cell_based_on_data)
def _initialize_renderer(self, editable, index): """_initialize_renderer - internal function called to set up the CellRenderer for the column. arguments: editable - True if the column should support user editing. index - the position of the column in the grid """ self.renderer = gtk.CellRendererSpin() adj = gtk.Adjustment(0, -10000000000, 10000000000, 1) self.renderer.set_property("adjustment", adj) self.renderer.set_property("editable", editable) self.renderer.set_property("digits", 2) self.renderer.connect("edited", self._cell_edited) #make sure the value was edited to something that can be #turned into an int try: float(new_text) except: return #get an iterator that points to the edited row if self.list_store is not None: iter = self.list_store.get_iter(path) #update the ListStore with the new text self.list_store.set_value(iter, self.index, self.display_val(new_text)) dictionary = self.list_store.get_value(iter, self.dictionary_index) dictionary[self.key] = self.real_val(new_text)
def _build_view_rules(self): self.lstore_rules = gtk.ListStore(str, str, str, str, float) view = gtk.TreeView(model=self.lstore_rules) # Create field to set the type of rule tracker/label liststore_field_type = gtk.ListStore(str) for item in ["Tracker", "Label"]: liststore_field_type.append([item]) crc = gtk.CellRendererCombo() crc.set_property("editable", True) crc.set_property("model", liststore_field_type) crc.set_property("text-column", 0) crc.set_property("has-entry", False) crc.connect("edited", self._on_combo_type_changed) # crc.set_active(0) colc = gtk.TreeViewColumn(_("Type"), crc, text=0) view.append_column(colc) # Create text field for label or tracker names crt = gtk.CellRendererText() crt.set_property("editable", True) crt.connect("edited", self._on_name_changed) colt = gtk.TreeViewColumn(_("Name"), crt, text=1) view.append_column(colt) # Create field to set the type of selection and/or liststore_field_logic = self.sel_func_store crl = gtk.CellRendererCombo() crl.set_property("editable", True) crl.set_property("model", liststore_field_logic) crl.set_property("text-column", 0) crl.set_property("has-entry", False) crl.connect("edited", self._on_combo_logic_changed) #crl.set_active(0) #TODO coll = gtk.TreeViewColumn(_("Operator"), crl, text=2) view.append_column(coll) # Create field for remove rule selection liststore_field_rules = self.rules crrr = gtk.CellRendererCombo() crrr.set_property("editable", True) crrr.set_property("model", liststore_field_rules) crrr.set_property("text-column", 1) crrr.set_property("has-entry", False) crrr.connect("edited", self._on_combo_rules_changed) colrr = gtk.TreeViewColumn(_("Remove Rule"), crrr, text=3) view.append_column(colrr) # Spin button for minimum value crm = gtk.CellRendererSpin() crm.set_property("editable", True) crm.set_property("digits", 3) crm.set_property("adjustment", gtk.Adjustment(0, 0, 10000.0, 0.5, 10, 0)) crm.connect("edited", self._on_spin_min_changed) colm = gtk.TreeViewColumn(_("Minimum"), crm, text=4) view.append_column(colm) return view
def __init__(self): gtk.ScrolledWindow.__init__(self) self.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) self.data = ConstraintsStore() self.tv = gtk.TreeView(self.data) tvcolumn = gtk.TreeViewColumn(_('Constraint')) self.tv.append_column(tvcolumn) cell = gtk.CellRendererText() tvcolumn.pack_start(cell,True) tvcolumn.set_attributes(cell,text=0) tvcolumn.set_sort_column_id(0) tvcolumn = gtk.TreeViewColumn(_('Min')) self.tv.append_column(tvcolumn) cell = gtk.CellRendererSpin() tvcolumn.pack_start(cell,True) tvcolumn.set_attributes(cell,text=1) cell.set_property('editable',True) cell.set_property('digits',3) cell.set_property('adjustment',gtk.Adjustment(-90,-90,90,1,10)) cell.connect('edited',self.min_edited) tvcolumn = gtk.TreeViewColumn(_('Max')) self.tv.append_column(tvcolumn) cell = gtk.CellRendererSpin() tvcolumn.pack_start(cell,True) tvcolumn.set_attributes(cell,text=2) cell.set_property('editable',True) cell.set_property('digits',3) cell.set_property('adjustment',gtk.Adjustment(-90,-90,90,1,10)) cell.connect('edited',self.max_edited) self.tv.set_search_column(0) self.tv.set_reorderable(True) self.add(self.tv) self.show_all()
def __init__(self): gtk.ScrolledWindow.__init__(self) Signalizable.__init__(self) self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) units = gtk.ListStore(str) units.append([_("millimeters")]) units.append([_("inches")]) units.append([_("pixels")]) self.liststore = gtk.ListStore(str, int, str) treeview = gtk.TreeView(self.liststore) treeview.set_size_request(-1, 100) treeview.set_rules_hint(True) treeview.set_grid_lines(True) self.add(treeview) cell = gtk.CellRendererText() cell.connect("edited", self.title_edited) cell.set_property("editable", True) column = gtk.TreeViewColumn(_("Title")) column.pack_start(cell, True) column.set_attributes(cell, text=COLUMN_TITLE) treeview.append_column(column) treeview.set_search_column(COLUMN_TITLE) adjustment = gtk.Adjustment(0, 0, 100, 1) cell = gtk.CellRendererSpin() cell.connect("edited", self.width_edited) cell.set_property("editable", True) cell.set_property("adjustment", adjustment) cell.set_property("xalign", 1.0) column = gtk.TreeViewColumn(_("Width")) column.pack_start(cell, True) column.set_attributes(cell, text=COLUMN_WIDTH) treeview.append_column(column) cell = gtk.CellRendererCombo() cell.set_property("editable", True) cell.set_property("has-entry", False) cell.set_property("model", units) cell.set_property("text-column", 0) column = gtk.TreeViewColumn(_("Unit")) column.pack_start(cell, True) column.set_attributes(cell, text=COLUMN_UNIT) treeview.append_column(column) self.install_signals()
def __init__(self, parent=None, facts=None): gtk.Object.__init__(self) self.source = conf.get("activities_source") if self.source == "redmine": self.rt_url = conf.get("rt_url") self.rt_apikey = conf.get("rt_apikey") if self.rt_url and self.rt_apikey: try: self.tracker = redmine.Redmine(self.rt_url, auth=(self.rt_apikey, "placeholder")) if not self.tracker: self.source = "" except: self.source = "" else: self.source = "" print self.source + " source" self._gui = load_ui_file("export_rt.ui") self.window = self.get_widget('report_rt_window') self.parent, self.facts = parent, facts self.done_button = self.get_widget("done_button") # self.done_button.set_sensitive(False) # Model self.tree_store = gtk.TreeStore(gobject.TYPE_PYOBJECT) self.rows = list([ExportRow(fact) for fact in facts]) self.rows.sort(key=lambda row: row.id) tickets = {} for ticket, rows in groupby(self.rows, lambda export_row: export_row.id): tickets[ticket] = list(rows) for item in tickets.keys(): #please name the ticket ticket = {} if self.source == "redmine": issue = self.tracker.getIssue(item) ticket['id'] = issue.id ticket['Subject'] = issue.subject if ticket: parent = self.tree_store.append(None, (TicketRow(ticket), )) for row in tickets[item]: row.activity = self.tracker.getRedmineActivities( row.activity) self.tree_store.append(parent, (row, )) # self.tree_store.append(parent, (row.comment)) self.view = gtk.TreeView(self.tree_store) self.view.set_headers_visible(False) id_cell = gtk.CellRendererText() id_column = gtk.TreeViewColumn("", id_cell, text=0) id_column.set_cell_data_func(id_cell, id_painter) id_column.set_max_width(100) self.view.append_column(id_column) name_comment_cell = gtk.CellRendererText() name_comment_cell.connect("edited", self.on_comment_edited) name_comment_column = gtk.TreeViewColumn("", name_comment_cell, text=0) name_comment_column.set_cell_data_func(name_comment_cell, name_comment_painter) name_comment_column.set_expand(True) self.view.append_column(name_comment_column) time_cell = gtk.CellRendererSpin() time_cell.connect("edited", self.on_time_worked_edited) time_column = gtk.TreeViewColumn("", time_cell, text=0) time_column.set_cell_data_func(time_cell, time_painter) time_column.set_min_width(60) self.view.append_column(time_column) self.view.expand_all() self.start_button = self.get_widget("start_button") self.get_widget("activities").add(self.view) self.aggregate_comments_checkbox = self.get_widget( "aggregate_comments_checkbox") self.aggregate_comments_checkbox.set_active(True) self.test_checkbox = self.get_widget("test_checkbox") self.test_checkbox.set_active(False) self.progressbar = self.get_widget("progressbar") self.progressbar.set_text(_("Waiting for action")) self.progressbar.set_orientation(gtk.PROGRESS_LEFT_TO_RIGHT) self._gui.connect_signals(self) self.window.show_all()
def create_interior(self): self.mainbox = gtk.ScrolledWindow() self.mainbox.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.window.add(self.mainbox) # model creation # URL, recursion_depth, download, processed part, what to download self.model = gtk.ListStore(str, int, bool, float, str) for url, download in (["http://root.cz", True], ["http://slashdot.org", True], ["http://mozilla.org", False]): adj = gtk.Adjustment(value=0, lower=0, upper=10, step_incr=1) self.model.append([url, 0, download, 0.0, "HTML only"]) # the treeview treeview = gtk.TreeView(self.model) # individual columns # URL column col = gtk.TreeViewColumn("URL") treeview.append_column(col) cell = gtk.CellRendererText() col.pack_start(cell, expand=False) col.set_attributes(cell, text=0) col.set_sort_column_id(0) # recursion_depth column col = gtk.TreeViewColumn("Depth") treeview.append_column(col) cell = gtk.CellRendererSpin() cell.set_property("adjustment", gtk.Adjustment(lower=0, upper=10, step_incr=1)) cell.set_property("editable", True) col.pack_start(cell, expand=False) col.set_attributes(cell, text=1) cell.connect('edited', self._recursion_depth_changed, 1) # State col = gtk.TreeViewColumn("State") treeview.insert_column(col, 0) cell = gtk.CellRendererPixbuf() col.pack_start(cell, expand=False) col.set_cell_data_func(cell, self._render_icon) # Download column col = gtk.TreeViewColumn("Download") treeview.append_column(col) cell = gtk.CellRendererToggle() cell.set_property("activatable", True) col.pack_start(cell, expand=False) col.set_attributes(cell, active=2) col.set_sort_column_id(2) cell.connect('toggled', self._download_toggled, 2) # What to download column col = gtk.TreeViewColumn("What") treeview.append_column(col) cell = gtk.CellRendererCombo() cell.set_property("editable", True) # we need a separate model for the combo model = gtk.ListStore(str) for value in ["HTML only", "HTML+CSS", "Everything"]: model.append([value]) cell.set_property("model", model) cell.set_property("text-column", 0) col.pack_start(cell, expand=False) col.set_attributes(cell, text=4) col.set_sort_column_id(4) cell.connect('edited', self._what_to_download_changed, 4) # Progress column col = gtk.TreeViewColumn("Progress") treeview.append_column(col) cell = gtk.CellRendererProgress() col.pack_start(cell, expand=True) col.set_attributes(cell, value=3) col.set_sort_column_id(3) # pack the treeview self.mainbox.add(treeview) # show the box self.mainbox.set_size_request(500, 260) self.mainbox.show() # set up timer self._timer = gobject.timeout_add(200, self._timeout)
def __init__(self, parent, application): SettingsPage.__init__(self, parent, application, 'item_list', _('Item List')) notebook = gtk.Notebook() # create frames label_look_and_feel = gtk.Label(_('Look & feel')) label_operation = gtk.Label(_('Operation')) label_directories = gtk.Label(_('Directories')) label_columns = gtk.Label(_('Columns')) # vertical boxes vbox_look_and_feel = gtk.VBox(False, 0) vbox_operation = gtk.VBox(False, 0) vbox_directory = gtk.VBox(False, 0) vbox_columns = gtk.VBox(False, 0) vbox_look_and_feel.set_border_width(5) vbox_operation.set_border_width(5) vbox_directory.set_border_width(5) vbox_directory.set_spacing(5) vbox_columns.set_border_width(5) # file list options self._checkbox_row_hinting = gtk.CheckButton(_('Row hinting')) self._checkbox_show_hidden = gtk.CheckButton(_('Show hidden files')) self._checkbox_case_sensitive = gtk.CheckButton(_('Case sensitive item sorting')) self._checkbox_number_sensitive = gtk.CheckButton(_('Number sensitive item sorting')) self._checkbox_single_click = gtk.CheckButton(_('Single click navigation')) self._checkbox_right_click = gtk.CheckButton(_('Right click selects items')) self._checkbox_show_headers = gtk.CheckButton(_('Show list headers')) self._checkbox_media_preview = gtk.CheckButton(_('Fast media preview')) self._checkbox_show_expanders = gtk.CheckButton(_('Show tree expanders')) self._checkbox_hide_scrollbar = gtk.CheckButton(_('Hide horizontal scrollbar')) self._checkbox_second_extension = gtk.CheckButton(_('Support second level extension')) self._checkbox_row_hinting.connect('toggled', self._parent.enable_save) self._checkbox_show_hidden.connect('toggled', self._parent.enable_save) self._checkbox_case_sensitive.connect('toggled', self._parent.enable_save) self._checkbox_number_sensitive.connect('toggled', self._parent.enable_save) self._checkbox_single_click.connect('toggled', self._parent.enable_save) self._checkbox_right_click.connect('toggled', self._parent.enable_save) self._checkbox_show_headers.connect('toggled', self._parent.enable_save) self._checkbox_media_preview.connect('toggled', self._parent.enable_save) self._checkbox_show_expanders.connect('toggled', self._parent.enable_save) self._checkbox_hide_scrollbar.connect('toggled', self._parent.enable_save) self._checkbox_second_extension.connect('toggled', self._parent.enable_save) # bread crumbs type hbox_breadcrumbs = gtk.HBox(False, 5) label_breadcrumbs = gtk.Label(_('Breadcrumbs:')) label_breadcrumbs.set_alignment(0, 0.5) list_breadcrumbs = gtk.ListStore(str, int) list_breadcrumbs.append((_('None'), Breadcrumbs.TYPE_NONE)) list_breadcrumbs.append((_('Normal'), Breadcrumbs.TYPE_NORMAL)) list_breadcrumbs.append((_('Smart'), Breadcrumbs.TYPE_SMART)) cell_breadcrumbs = gtk.CellRendererText() self._combobox_breadcrumbs = gtk.ComboBox(list_breadcrumbs) self._combobox_breadcrumbs.connect('changed', self._parent.enable_save) self._combobox_breadcrumbs.pack_start(cell_breadcrumbs) self._combobox_breadcrumbs.add_attribute(cell_breadcrumbs, 'text', 0) # file access mode format hbox_mode_format = gtk.HBox(False, 5) label_mode_format = gtk.Label(_('Access mode format:')) label_mode_format.set_alignment(0, 0.5) list_mode_format = gtk.ListStore(str, int) list_mode_format.append((_('Octal'), AccessModeFormat.OCTAL)) list_mode_format.append((_('Textual'), AccessModeFormat.TEXTUAL)) cell_mode_format = gtk.CellRendererText() self._combobox_mode_format = gtk.ComboBox(list_mode_format) self._combobox_mode_format.connect('changed', self._parent.enable_save) self._combobox_mode_format.pack_start(cell_mode_format) self._combobox_mode_format.add_attribute(cell_mode_format, 'text', 0) # grid lines hbox_grid_lines = gtk.HBox(False, 5) label_grid_lines = gtk.Label(_('Show grid lines:')) label_grid_lines.set_alignment(0, 0.5) list_grid_lines = gtk.ListStore(str, int) list_grid_lines.append((_('None'), gtk.TREE_VIEW_GRID_LINES_NONE)) list_grid_lines.append((_('Horizontal'), gtk.TREE_VIEW_GRID_LINES_HORIZONTAL)) list_grid_lines.append((_('Vertical'), gtk.TREE_VIEW_GRID_LINES_VERTICAL)) list_grid_lines.append((_('Both'), gtk.TREE_VIEW_GRID_LINES_BOTH)) cell_grid_lines = gtk.CellRendererText() self._combobox_grid_lines = gtk.ComboBox(list_grid_lines) self._combobox_grid_lines.connect('changed', self._parent.enable_save) self._combobox_grid_lines.pack_start(cell_grid_lines) self._combobox_grid_lines.add_attribute(cell_grid_lines, 'text', 0) # selection color hbox_selection_color = gtk.HBox(False, 5) label_selection_color = gtk.Label(_('Selection color:')) label_selection_color.set_alignment(0, 0.5) self._button_selection_color = gtk.ColorButton() self._button_selection_color.set_use_alpha(False) self._button_selection_color.connect('color-set', self._parent.enable_save) # selection indicator hbox_indicator = gtk.HBox(False, 5) label_indicator = gtk.Label(_('Selection indicator:')) label_indicator.set_alignment(0, 0.5) list_indicator = gtk.ListStore(str) list_indicator.append((u'\u25b6',)) list_indicator.append((u'\u25e2',)) list_indicator.append((u'\u25c8',)) list_indicator.append((u'\u263b',)) list_indicator.append((u'\u2771',)) list_indicator.append((u'\u2738',)) list_indicator.append((u'\u2731',)) self._combobox_indicator = gtk.ComboBoxEntry(list_indicator, 0) self._combobox_indicator.connect('changed', self._parent.enable_save) self._combobox_indicator.set_size_request(100, -1) # quick search label_quick_search = gtk.Label(_('Quick search combination:')) label_quick_search.set_alignment(0, 0.5) label_quick_search.set_use_markup(True) self._checkbox_control = gtk.CheckButton(_('Control')) self._checkbox_alt = gtk.CheckButton(_('Alt')) self._checkbox_shift = gtk.CheckButton(_('Shift')) self._checkbox_control.connect('toggled', self._parent.enable_save) self._checkbox_alt.connect('toggled', self._parent.enable_save) self._checkbox_shift.connect('toggled', self._parent.enable_save) hbox_quick_search = gtk.HBox(False, 5) vbox_time_format = gtk.VBox(False, 0) label_time_format = gtk.Label(_('Date format:')) label_time_format.set_alignment(0, 0.5) self._entry_time_format = gtk.Entry() self._entry_time_format.set_tooltip_markup( '<b>' + _('Time is formed using the format located at:') + '</b>\n' 'http://docs.python.org/library/time.html#time.strftime' ) self._entry_time_format.connect('changed', self._parent.enable_save) # create list of directories container_directory = gtk.ScrolledWindow() container_directory.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) container_directory.set_shadow_type(gtk.SHADOW_IN) self._checkbox_load_directories = gtk.CheckButton(_('Load specified tabs instead of saved')) self._checkbox_load_directories.connect('toggled', self._parent.enable_save) self._directory_store = gtk.ListStore(str, bool, bool) self._directory_list = gtk.TreeView(model=self._directory_store) cell_directory = gtk.CellRendererText() cell_left_list = gtk.CellRendererToggle() cell_right_list = gtk.CellRendererToggle() cell_left_list.connect('toggled', self._toggle_path, Source.LEFT) cell_right_list.connect('toggled', self._toggle_path, Source.RIGHT) col_directory = gtk.TreeViewColumn(_('Directory'), cell_directory, text=DirectoryColumn.PATH) col_directory.set_min_width(200) col_directory.set_resizable(True) col_directory.set_expand(True) col_left_list = gtk.TreeViewColumn(_('Left list'), cell_left_list, active=DirectoryColumn.LEFT_LIST) col_right_list = gtk.TreeViewColumn(_('Right list'), cell_right_list, active=DirectoryColumn.RIGHT_LIST) self._directory_list.append_column(col_directory) self._directory_list.append_column(col_left_list) self._directory_list.append_column(col_right_list) hbox_directory = gtk.HBox(False, 5) button_add_directory = gtk.Button(stock=gtk.STOCK_ADD) button_add_directory.connect('clicked', self.__button_add_clicked) button_delete_directory = gtk.Button(stock=gtk.STOCK_DELETE) button_delete_directory.connect('clicked', self._delete_path) image_up = gtk.Image() image_up.set_from_stock(gtk.STOCK_GO_UP, gtk.ICON_SIZE_BUTTON) button_directory_move_up = gtk.Button(label=None) button_directory_move_up.add(image_up) button_directory_move_up.set_tooltip_text(_('Move Up')) button_directory_move_up.connect('clicked', self._move_path, -1) image_down = gtk.Image() image_down.set_from_stock(gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_BUTTON) button_directory_move_down = gtk.Button(label=None) button_directory_move_down.add(image_down) button_directory_move_down.set_tooltip_text(_('Move Down')) button_directory_move_down.connect('clicked', self._move_path, 1) self._menu_add_directory = gtk.Menu() menu_item_custom = gtk.MenuItem(_('Custom directory')) menu_item_separator = gtk.SeparatorMenuItem() menu_item_left_directory = gtk.MenuItem(_('Left directory')) menu_item_right_directory = gtk.MenuItem(_('Right directory')) menu_item_custom.connect('activate', self._add_path, Source.CUSTOM) menu_item_left_directory.connect('activate', self._add_path, Source.LEFT) menu_item_right_directory.connect('activate', self._add_path, Source.RIGHT) self._menu_add_directory.append(menu_item_custom) self._menu_add_directory.append(menu_item_separator) self._menu_add_directory.append(menu_item_left_directory) self._menu_add_directory.append(menu_item_right_directory) self._menu_add_directory.show_all() # create columns editor hbox_columns = gtk.HBox(False, 5) container_columns = gtk.ScrolledWindow() container_columns.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) container_columns.set_shadow_type(gtk.SHADOW_IN) container_plugin = gtk.ScrolledWindow() container_plugin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) container_plugin.set_shadow_type(gtk.SHADOW_IN) # create variable to store active extension to self._extensions = {} self._active_extension = None # create column list self._columns_store = gtk.ListStore(str, int, bool, str) self._columns_list = gtk.TreeView() self._columns_list.set_model(self._columns_store) self._columns_list.set_rules_hint(True) self._columns_list.set_enable_search(True) self._columns_list.set_search_column(Column.NAME) cell_name = gtk.CellRendererText() cell_size = gtk.CellRendererText() cell_visible = gtk.CellRendererToggle() cell_font_size = gtk.CellRendererSpin() cell_size.set_property('editable', True) cell_size.set_property('mode', gtk.CELL_RENDERER_MODE_EDITABLE) cell_size.connect('edited', self._edited_column_size) cell_font_size.set_property('editable', True) cell_font_size.set_property('mode', gtk.CELL_RENDERER_MODE_EDITABLE) adjustment = gtk.Adjustment(0, 0, 100, 1, 10, 0) cell_font_size.set_property('adjustment', adjustment) cell_font_size.connect('edited', self._edited_column_font_size) cell_visible.connect('toggled', self._toggle_column_visible) col_name = gtk.TreeViewColumn(_('Column'), cell_name, text=Column.NAME) col_name.set_min_width(150) col_name.set_resizable(True) col_name.set_expand(True) col_size = gtk.TreeViewColumn(_('Size'), cell_size, text=Column.SIZE) col_size.set_min_width(50) col_visible = gtk.TreeViewColumn(_('Visible'), cell_visible, active=Column.VISIBLE) col_visible.set_min_width(50) col_font_size = gtk.TreeViewColumn(_('Font'), cell_font_size, text=Column.FONT_SIZE) col_font_size.set_min_width(50) self._columns_list.append_column(col_name) self._columns_list.append_column(col_size) self._columns_list.append_column(col_font_size) self._columns_list.append_column(col_visible) # create plugin list self._extension_store = gtk.ListStore(str, str) self._extension_list = gtk.TreeView() self._extension_list.set_model(self._extension_store) self._extension_list.set_size_request(130, -1) self._extension_list.set_headers_visible(False) self._extension_list.connect('cursor-changed', self._handle_cursor_change) cell_name = gtk.CellRendererText() col_name = gtk.TreeViewColumn(None, cell_name, text=ExtensionColumn.NAME) self._extension_list.append_column(col_name) # pack interface container_directory.add(self._directory_list) container_columns.add(self._columns_list) container_plugin.add(self._extension_list) hbox_directory.pack_start(button_add_directory, False, False, 0) hbox_directory.pack_start(button_delete_directory, False, False, 0) hbox_directory.pack_end(button_directory_move_down, False, False, 0) hbox_directory.pack_end(button_directory_move_up, False, False, 0) hbox_columns.pack_start(container_plugin, False, False, 0) hbox_columns.pack_start(container_columns, True, True, 0) hbox_indicator.pack_start(label_indicator, False, False, 0) hbox_indicator.pack_start(self._combobox_indicator, False, False, 0) hbox_selection_color.pack_start(label_selection_color, False, False, 0) hbox_selection_color.pack_start(self._button_selection_color, False, False, 0) hbox_quick_search.pack_start(label_quick_search, False, False, 0) hbox_quick_search.pack_start(self._checkbox_control, False, False, 0) hbox_quick_search.pack_start(self._checkbox_alt, False, False, 0) hbox_quick_search.pack_start(self._checkbox_shift, False, False, 0) hbox_breadcrumbs.pack_start(label_breadcrumbs, False, False, 0) hbox_breadcrumbs.pack_start(self._combobox_breadcrumbs, False, False, 0) hbox_mode_format.pack_start(label_mode_format, False, False, 0) hbox_mode_format.pack_start(self._combobox_mode_format, False, False, 0) hbox_grid_lines.pack_start(label_grid_lines, False, False, 0) hbox_grid_lines.pack_start(self._combobox_grid_lines, False, False, 0) vbox_time_format.pack_start(label_time_format, False, False, 0) vbox_time_format.pack_start(self._entry_time_format, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_row_hinting, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_show_headers, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_media_preview, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_show_hidden, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_show_expanders, False, False, 0) vbox_look_and_feel.pack_start(self._checkbox_hide_scrollbar, False, False, 0) vbox_look_and_feel.pack_start(hbox_breadcrumbs, False, False, 5) vbox_look_and_feel.pack_start(hbox_mode_format, False, False, 5) vbox_look_and_feel.pack_start(hbox_grid_lines, False, False, 5) vbox_look_and_feel.pack_start(hbox_selection_color, False, False, 5) vbox_look_and_feel.pack_start(hbox_indicator, False, False, 5) vbox_operation.pack_start(self._checkbox_case_sensitive, False, False, 0) vbox_operation.pack_start(self._checkbox_number_sensitive, False, False, 0) vbox_operation.pack_start(self._checkbox_single_click, False, False, 0) vbox_operation.pack_start(self._checkbox_right_click, False, False, 0) vbox_operation.pack_start(self._checkbox_second_extension, False, False, 0) vbox_operation.pack_start(hbox_quick_search, False, False, 5) vbox_operation.pack_start(vbox_time_format, False, False, 5) vbox_directory.pack_start(self._checkbox_load_directories, False, False, 0) vbox_directory.pack_start(container_directory, True, True, 0) vbox_directory.pack_start(hbox_directory, False, False, 0) vbox_columns.pack_start(hbox_columns, True, True, 0) notebook.append_page(vbox_look_and_feel, label_look_and_feel) notebook.append_page(vbox_operation, label_operation) notebook.append_page(vbox_directory, label_directories) notebook.append_page(vbox_columns, label_columns) self.pack_start(notebook, True, True, 0)
def __init__(self, active, latent, var_ops, modes, arg_str=None): super(PageWithVariableTable, self).__init__(False, 1) self.__drawing_suspended = True self.__var_ops = var_ops # Parse the given arguments to work out which variables to include in the table parser = optparse.OptionParser() parser.add_option('-n', '--nvar', action = "store", type = "string", dest = "nvar", default = "nvars") (args, vars) = parser.parse_args(arg_str.split() if arg_str else []) # Store the names for easy looking up later self.__var_names = [args.nvar] + vars # Work out which variables we will explicitly manage and which variables we will defer # to the default page self.__nvar = None self.__vars = [] for var in active[:]: if var.name == args.nvar: self.__nvar = var active.remove(var) for var in latent[:]: if var.name == args.nvar: self.__nvar = var latent.remove(var) for var_name in vars: for var in active[:]: if var.name == var_name: self.__vars.append(var) active.remove(var) for var in latent[:]: if var.name == var_name: self.__vars.append(var) latent.remove(var) # Correct the sizes of all the variables to match the current value of self.__nvar for var in self.__vars: value = self.__python_list_for_variable(var) self.__var_ops.set_var_value(var, ",".join([self.__value_to_string(var, v) for v in value])) # Build the default table for all the other variables and insert it as the first element self.__table = rose.config_editor.pagewidget.table.PageTable(active, latent, var_ops, modes, arg_str) self.pack_start(self.__table) # Add another panel to contain the table self.__table_panel = gtk.VBox(False, 0) self.pack_start(self.__table_panel) toolbar = gtk.HBox() error_panel = gtk.HBox() self.__error_icon = gtk.image_new_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU) self.__error_icon.set_padding(5, 3) self.__error_icon.show() error_panel.pack_start(self.__error_icon, expand = False, fill = False) self.__error_label = gtk.Label() self.__error_label.set_alignment(xalign=0, yalign=0.5) self.__error_label.show() error_panel.pack_start(self.__error_label, expand = True, fill = True) error_panel.show() toolbar.pack_start(error_panel, expand = True, fill = True) add_button = gtk.Button(stock=gtk.STOCK_ADD) add_button.connect("clicked", self.__handle_add_row) toolbar.pack_end(add_button, expand = False, fill = False) self.__table_panel.pack_start(toolbar) add_button.show() toolbar.show() # Build the initial state of our store col_types = [] renderers = [] col_idx = 0 for var in self.__vars: if 'values' in var.metadata: col_types.append(str) values_store = gtk.ListStore(str) for item in var.metadata['values']: values_store.append([item]) renderer = gtk.CellRendererCombo() renderer.set_property('has-entry', False) renderer.set_property('editable', True) renderer.set_property('model', values_store) renderer.set_property("text-column", 0) renderer.connect("edited", self.__handle_text_edit, var, col_idx) else: type = var.metadata.get('type', None) if type == 'integer': col_types.append(int) renderer = gtk.CellRendererSpin() renderer.set_property('editable', True) renderer.set_property('adjustment', 1) renderer.connect("edited", self.__handle_text_edit, var, col_idx) elif type == 'boolean': col_types.append(bool) renderer = gtk.CellRendererToggle() renderer.set_property('active', 0) renderer.connect("toggled", self.__handle_toggle, var, col_idx) elif type == 'logical': col_types.append(bool) renderer = gtk.CellRendererToggle() renderer.set_property('active', 0) renderer.connect("toggled", self.__handle_toggle, var, col_idx) elif type == 'real': col_types.append(float) renderer = gtk.CellRendererText() renderer.set_property('editable', True) renderer.connect("edited", self.__handle_text_edit, var, col_idx) else: col_types.append(str) renderer = gtk.CellRendererText() renderer.set_property('editable', True) renderer.connect("edited", self.__handle_text_edit, var, col_idx) renderer.set_property("xpad", 8) renderer.set_property("ypad", 5) renderers.append(renderer) col_idx += 1 self.__store = gtk.ListStore(*col_types) treeview = gtk.TreeView(self.__store) self.__columns = [] for col in range(len(self.__vars)): var = self.__vars[col] title = var.metadata.get('title', var.name) # We have to create a separate label widget for the column headers to enable tooltips column = gtk.TreeViewColumn('', renderers[col], text = col, active = col) column_header = gtk.Label(title) column_header.modify_font(pango.FontDescription("bold")) column_header.show() column.set_widget(column_header) column.connect("clicked", self.__handle_header_click, var) if 'description' in var.metadata: tooltips = gtk.Tooltips() tooltips.set_tip(column_header, var.metadata['description']) self.__columns.append(column) treeview.append_column(column) treeview.set_headers_clickable(True) table_viewport = gtk.Viewport() table_viewport.set_shadow_type(gtk.SHADOW_OUT) table_viewport.add(treeview) self.__table_panel.pack_start(table_viewport) treeview.show() table_viewport.show() self.__table_panel.show() # Add the right click context menu to the treeview body treeview.connect("button-press-event", self.__handle_mouse_click) # Add the right click context menu to the treeview headers for col in range(len(self.__vars)): var = self.__vars[col] button = self.__columns[col].get_widget() while not isinstance(button, gtk.Button): button = button.get_parent() button.connect("button-press-event", self.__handle_header_button_press, var) self.__drawing_suspended = False self.__redraw() self.show()
def __init__(self, parent=None, facts=None): gtk.Object.__init__(self) self.source = conf.get("activities_source") self._gui = load_ui_file("exporter.ui") self.window = self.get_widget('exporter_window') self.parent, self.facts = parent, facts self.done_button = self.get_widget("done_button") # Model self.tree_store = gtk.TreeStore(gobject.TYPE_PYOBJECT) self.rows = list([ExportRow(fact) for fact in facts]) self.rows.sort(key = lambda row: row.id) grouped_rows = {} for issue_id, rows in groupby(self.rows, lambda export_row: export_row.id): grouped_rows[issue_id] = list(rows) for issue_id in grouped_rows.keys(): # ściągnąć nazwę ticketa row_data = None if self.source == SOURCE_RT: row_data = runtime.get_external().rt.get_ticket(issue_id) elif self.source == SOURCE_REDMINE: issue = runtime.get_external().redmine.getIssue(issue_id) row_data = {'id': issue.id, 'Subject': str(issue_id) + ': ' + issue.fields.summary} elif self.source == SOURCE_JIRA and runtime.get_external().is_issue_from_existing_jira_project(issue_id): try: issue = runtime.get_external().jira.issue(issue_id) row_data = {'id': issue.key, 'Subject': issue.fields.summary} except: logging.error("Issue not found: %s" % (issue_id)) if row_data: parent = self.tree_store.append(None, (TicketRow(row_data),)) for row in grouped_rows[issue_id]: self.tree_store.append(parent, (row, )) self.view = gtk.TreeView(self.tree_store) self.view.set_headers_visible(False) id_cell = gtk.CellRendererText() id_column = gtk.TreeViewColumn("", id_cell, text=0) id_column.set_cell_data_func(id_cell, id_painter) id_column.set_max_width(100) self.view.append_column(id_column) name_comment_cell = gtk.CellRendererText() name_comment_cell.connect("edited", self.on_comment_edited) name_comment_column = gtk.TreeViewColumn("", name_comment_cell, text=0) name_comment_column.set_cell_data_func(name_comment_cell, name_comment_painter) name_comment_column.set_expand(True) self.view.append_column(name_comment_column) time_cell = gtk.CellRendererSpin() time_cell.connect("edited", self.on_time_worked_edited) time_column = gtk.TreeViewColumn("", time_cell, text=0) time_column.set_cell_data_func(time_cell, time_painter) time_column.set_min_width(60) self.view.append_column(time_column) self.view.expand_all() self.start_button = self.get_widget("start_button") self.get_widget("activities").add(self.view) self.aggregate_comments_checkbox = self.get_widget("aggregate_comments_checkbox") self.test_checkox = self.get_widget("test_checkbox") self.test_checkox.set_active(False) self.progressbar = self.get_widget("progressbar") self.progressbar.set_text(_("Waiting for action")) self.progressbar.set_orientation(gtk.PROGRESS_LEFT_TO_RIGHT) self._gui.connect_signals(self) self.window.show_all()
def make_frames_view(self, layers): import gobject texture_format = self.cb_tf.get_active() self.liststore = gtk.ListStore(gobject.TYPE_PYOBJECT, gtk.gdk.Pixbuf, str, gobject.TYPE_BOOLEAN, gobject.TYPE_INT, gobject.TYPE_INT, gobject.TYPE_PYOBJECT) for l in layers: frames = [gl for gl in reversed(l.layers) ] if pdb.gimp_item_is_group(l) else [l] for f in frames: thumbnail_data = make_thumbnail_data(f) pixbuf = get_thumbnail(thumbnail_data, texture_format) size_info = '<b>Size</b>: %d x %d' % (f.width, f.height) parasite_origins = f.parasite_find('spr_origins') if parasite_origins: origin_x, origin_y = unpack('<2i', parasite_origins.data[:8]) else: origin_x, origin_y = -f.width // 2, f.height // 2 self.liststore.append([ f, pixbuf, size_info, True, origin_x, origin_y, thumbnail_data ]) self.export_frames_num = len(self.liststore) self.iconview = gtk.TreeView(self.liststore) self.iconview.set_reorderable(True) self.iconview.set_enable_search(False) self.iconview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) # Column 'Export' def on_cb_export_toggled(widget, path): export = not self.liststore[path][LS_EXPORT] self.liststore[path][LS_EXPORT] = export self.export_frames_num += 1 if export else -1 self.set_btn_export_sensitive(self.export_frames_num > 0) self.img_view_frame.set_label('Frames to export: %d' % self.export_frames_num) cb_export = gtk.CellRendererToggle() cb_export.connect('toggled', on_cb_export_toggled) col_export = gtk.TreeViewColumn('Export', cb_export, active=LS_EXPORT) col_export_header = gtk.Label('Export') col_export_header.show() tt_export = gtk.Tooltips() tt_export.set_tip(col_export_header, 'Export frame to file.') col_export.set_sort_order(gtk.SORT_DESCENDING) col_export.set_sort_column_id(4) col_export.set_widget(col_export_header) self.iconview.append_column(col_export) # Column 'Frame' pixrend = gtk.CellRendererPixbuf() col_pixbuf = gtk.TreeViewColumn('Frame', pixrend, pixbuf=LS_PIXBUF) col_pixbuf.set_min_width(THUMB_MAXSIZE) self.iconview.append_column(col_pixbuf) # Column 'Settings' col_info = gtk.TreeViewColumn() col_info_header = gtk.Label('Settings') col_info_header.show() col_info.set_widget(col_info_header) tt_info = gtk.Tooltips() tt_info.set_tip(col_info_header, 'Frame export options.') # Info text renderer = gtk.CellRendererText() renderer.set_property('yalign', 0.3) renderer.set_property('xalign', 0.0) renderer.set_property('width', 0) renderer.set_property('height', THUMB_MAXSIZE) col_info.pack_start(renderer, False) col_info.set_attributes(renderer, markup=LS_SIZE_INFO) # Label origin X adjustment = gtk.Adjustment(lower=MIN_FRAME_ORIGIN, upper=MAX_FRAME_ORIGIN, step_incr=1) renderer = gtk.CellRendererText() renderer.set_property('markup', '<b>Origin X</b>:') renderer.set_property('width', 64) col_info.pack_start(renderer, False) # crs origin x adjustment = gtk.Adjustment(lower=MIN_FRAME_ORIGIN, upper=MAX_FRAME_ORIGIN, step_incr=1) renderer = gtk.CellRendererSpin() renderer.set_property('editable', True) renderer.set_property('adjustment', adjustment) def on_crs_origin_x_changed(widget, path, val): val = min(max(int(val), MIN_FRAME_ORIGIN), MAX_FRAME_ORIGIN) self.liststore[path][LS_ORIGIN_X] = val renderer.connect('edited', on_crs_origin_x_changed) col_info.pack_start(renderer) col_info.set_attributes(renderer, markup=LS_ORIGIN_X) # Label origin y renderer = gtk.CellRendererText() renderer.set_property('markup', '<b>Origin Y</b>:') renderer.set_property('width', 64) col_info.pack_start(renderer, False) # crs origin y renderer = gtk.CellRendererSpin() renderer.set_property('editable', True) renderer.set_property('adjustment', adjustment) def on_crs_origin_x_changed(widget, path, val): val = min(max(int(val), MIN_FRAME_ORIGIN), MAX_FRAME_ORIGIN) self.liststore[path][LS_ORIGIN_Y] = val renderer.connect('edited', on_crs_origin_x_changed) col_info.pack_start(renderer) col_info.set_attributes(renderer, markup=LS_ORIGIN_Y) self.iconview.append_column(col_info) scrl_win = gtk.ScrolledWindow() scrl_win.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) scrl_win.add(self.iconview) scrl_win.set_size_request(THUMB_MAXSIZE, THUMB_MAXSIZE * 4) frame_imgs = gimpui.Frame('Frames to export: %d' % self.export_frames_num) frame_imgs.set_property('label-xalign', 0.05) frame_imgs.set_shadow_type(gtk.SHADOW_IN) frame_imgs.add(scrl_win) frame_imgs.set_size_request(535, -1) return frame_imgs
def __init__(self, widget_tree): """ Initialises some class variables. """ self.x_entry = widget_tree.get_widget('x_position') self.y_entry = widget_tree.get_widget('y_position') self.w_entry = widget_tree.get_widget('width') self.h_entry = widget_tree.get_widget('height') self.vec_x_entry = widget_tree.get_widget('x_vector') self.vec_y_entry = widget_tree.get_widget('y_vector') self.tex_entry = widget_tree.get_widget('texture') self.rel_check = widget_tree.get_widget('relative_checkbox') self.patterns_treeview = \ widget_tree.get_widget('patterns_treeview') self.pos_group = widget_tree.get_widget('pos_group') self.size_group = widget_tree.get_widget('size_group') self.vector_group = widget_tree.get_widget('vector_group') self.texture_group = widget_tree.get_widget('texture_group') self.rel_group = widget_tree.get_widget('rel_group') self.pattern_group = widget_tree.get_widget('pattern_group') self.button_group = widget_tree.get_widget('button_group') self.none_group = widget_tree.get_widget('none_group') self.properties = widget_tree.get_widget('entity_properties') self.mapping = { 'block': self.show_block_tool, 'entry': self.show_entry_tool, 'water': self.show_water_tool, 'moving': self.show_moving_tool, 'vector': self.show_vector_tool, 'select': self.show_select_tool, 'delete': self.show_delete_tool, } self.model = gtk.ListStore(str, str, str) self.patterns_treeview.set_model(self.model) self.patterns_treeview.set_property('height-request', 125) adj = [] for i in range(3): adj.append(gtk.Adjustment( 0, -5000, 5000, 1, 10, 0, )) x_cell = gtk.CellRendererSpin() x_cell.connect('edited', self.changed, self.model, 0) x_cell.set_property('editable', True) x_cell.set_property('adjustment', adj[0]) y_cell = gtk.CellRendererSpin() y_cell.connect('edited', self.changed, self.model, 1) y_cell.set_property('editable', True) y_cell.set_property('adjustment', adj[1]) t_cell = gtk.CellRendererSpin() t_cell.connect('edited', self.changed, self.model, 2) t_cell.set_property('editable', True) t_cell.set_property('adjustment', adj[2]) x_col = gtk.TreeViewColumn('X Pos', x_cell, text=0) y_col = gtk.TreeViewColumn('Y Pos', y_cell, text=1) t_col = gtk.TreeViewColumn('Time', t_cell, text=2) x_col.set_min_width(50) y_col.set_min_width(50) t_col.set_min_width(50) self.patterns_treeview.append_column(x_col) self.patterns_treeview.append_column(y_col) self.patterns_treeview.append_column(t_col)
def _initialize_renderer(self, editable, index): self.renderer = gtk.CellRendererSpin() adj = gtk.Adjustment(0, -10000000000, 10000000000, 1) self.renderer.set_property("adjustment", adj) self.renderer.set_property("editable", editable) self.renderer.connect("edited", self._cell_edited)
def __init__(self, tab_id): """ Initialize the treeview. Call the parent constructor, store some references, define some class constants, add columns to the treeview and glue this together. The exciting part is the clomuns schemata setup, which tells the columns how they look like and what they should do when edited (connect callbacks). ARGUMENTS ========= - tab_id: Schema based (LOCAL_STATUS) tab id PROPERTIES ========== - liststore: probably the most interseting property, as it stores the data of the table. It can be accessed by index, like liststore[row][column], both starting with 0. - col: reference to the tree view columns the class has. Not really interesting outside init, but may come in handy for plugin development. """ # Call parrent constructor gtk.TreeView.__init__(self) # Mal tab type id self.tab_id = tab_id self.data = {} # This one is used to keep the db keys addresseble with the row indices self.keylist = list() # Some treeview specific constants (column id's) ( self.NAME, self.EPISODE, self.STATUS, self.SCORE, self.PROGRESS ) = \ range (5) # Add columns to self and store references by name self.col = dict() for colname in ['Title', 'Episodes', 'Status', 'Score', 'Progress']: self.col[colname] = gtk.TreeViewColumn(colname) self.append_column(self.col[colname]) ## Set up the column schemata # Title column schema titlecell = gtk.CellRendererText() self.col['Title'].pack_start(titlecell, True) self.col['Title'].add_attribute(titlecell, 'text', 0) # Episode column schema # Editable spin column that is connected with a callback epcell = gtk.CellRendererSpin() epcell.set_property("editable", True) adjustment = gtk.Adjustment(0, 0, 999, 1) epcell.set_property("adjustment", adjustment) epcell.connect('edited', self.cell_episode_edited) self.col['Episodes'].pack_start(epcell, False) self.col['Episodes'].add_attribute(epcell, 'text', 1) # Status column schema # Combo box column with selectable status # The first part contains the choices combomodel = gtk.ListStore(str) for i, item in LOCAL_STATUS: combomodel.append([item]) statuscell = gtk.CellRendererCombo() statuscell.set_property('model', combomodel) statuscell.set_property('has-entry', False) statuscell.set_property('editable', True) statuscell.set_property('text-column', 0) statuscell.connect('edited', self.cell_status_edited) self.col['Status'].pack_start(statuscell, False) self.col['Status'].add_attribute(statuscell, 'text', 2) # Score column schema # Basically the same as the episodes one. scorecell = gtk.CellRendererSpin() scorecell.set_property("editable", True) adjustment = gtk.Adjustment(0, 0, 10, 1) scorecell.set_property("adjustment", adjustment) scorecell.connect('edited', self.cell_score_edited) self.col['Score'].pack_start(scorecell, False) self.col['Score'].add_attribute(scorecell, 'text', 3) # Progress column schema # Progress bar, nothing fancy progresscell = gtk.CellRendererProgress() self.col['Progress'].pack_start(progresscell, True) self.col['Progress'].add_attribute(progresscell, 'value', 4) ## Create liststore model (table containing the treeview data) and hook # it up to the treeview (self). self.liststore = gtk.ListStore(str, str, str, int, int) self.set_model(self.liststore)
def __window2_init(self, *a): """ Initialize and build window and treeview widget underlining structure with all its funcionality. """ self.window2.type2colid = { "combo": 2, "spin": 3, "text": 4, "check": 5 } # see below # Get the model and attach it to the view self.window2.mdl = gtk.TreeStore( gobject.TYPE_PYOBJECT, # id 0: (hidden data) gobject.TYPE_STRING, # id 1: column 1 option label/name gobject.TYPE_STRING, # id 2: column 2 combo gobject.TYPE_LONG, # id 3: column 2 spin gobject.TYPE_STRING, # id 4: column 2 text gobject.TYPE_BOOLEAN) # id 5: column 2 check/toggle self.window2.treeview2.set_model(self.window2.mdl) # list store and adjustment for cell renderers self.window2.m = gtk.ListStore(gobject.TYPE_STRING) #self.window2.m.append(["(empty)"]) adjust = gtk.Adjustment(0, 0, 100, 1) # setup the text cell renderer # The text/label cellrenderer is setup (non-changeable by the user). # Connect column0 of the display with column 0 in our list model self.window2.renderer1 = gtk.CellRendererText() # column 1 renderer self.window2.column0 = gtk.TreeViewColumn("Setting", self.window2.renderer1, text=1) # column 1 # Setup the data cell with 4 renderers and allows these # renderers to be edited. In order to do this we have to # setup the columns first. self.window2.column1 = gtk.TreeViewColumn("Value") # column 2 self.window2.renderer2_1 = gtk.CellRendererCombo( ) # column 2 renderer 1: ComboBoxEntry #self.window2.renderer2_1.set_properties(editable=True, model=self.window2.m, text_column=0) # self.window2.renderer2_1.set_property('editable', True) # self.window2.renderer2_1.set_property('model', self.window2.m) # self.window2.renderer2_1.set_property('text_column', 0) # if not ( os.name == 'nt' ): # not for PyGTK <= 2.14 (http://www.python-forum.de/viewtopic.php?p=138475&sid=594b72d32face545ac08801f9f10b3ba) self.window2.renderer2_1.connect('changed', self.on_columnvalue_modified, self.window2.mdl, ("combo", )) # self.window2.renderer2_1.connect('edited', self.on_columnvalue_modified, self.window2.mdl, ("combo", )) # self.window2.column1.pack_start(self.window2.renderer2_1, True) # self.window2.renderer2_2 = gtk.CellRendererSpin( ) # column 2 renderer 2: SpinEntry #self.window2.renderer2_2.set_properties(adjustment=adjust, editable=True) # self.window2.renderer2_2.set_property('adjustment', adjust) # self.window2.renderer2_2.set_property('editable', True) # self.window2.renderer2_2.connect('edited', self.on_columnvalue_modified, self.window2.mdl, ("spin", )) # self.window2.column1.pack_start(self.window2.renderer2_2, True) # self.window2.renderer2_3 = gtk.CellRendererText( ) # column 2 renderer 3: TextEntry self.window2.renderer2_3.set_property('editable', True) # self.window2.renderer2_3.connect('edited', self.on_columnvalue_modified, self.window2.mdl, ("text", )) # self.window2.column1.pack_start(self.window2.renderer2_3, True) # self.window2.renderer2_4 = gtk.CellRendererToggle( ) # column 2 renderer 4: CheckBox/ToggleButton self.window2.renderer2_4.set_property('activatable', True) # self.window2.renderer2_4.connect('toggled', self.on_columnvalue_modified, self.window2.mdl, ("check", )) # self.window2.column1.pack_start(self.window2.renderer2_4, False) # # The columns state/data is attached to the columns in the model. self.window2.column1.set_attributes(self.window2.renderer2_1, text=2) self.window2.column1.set_attributes(self.window2.renderer2_2, text=3) self.window2.column1.set_attributes(self.window2.renderer2_3, text=4) self.window2.column1.add_attribute(self.window2.renderer2_4, "active", 5) # Handle the visiblility of the different renderer per cell. self.window2.column1.set_cell_data_func(self.window2.renderer2_1, self.on_celldatamethod, ("combo", )) self.window2.column1.set_cell_data_func(self.window2.renderer2_2, self.on_celldatamethod, ("spin", )) self.window2.column1.set_cell_data_func(self.window2.renderer2_3, self.on_celldatamethod, ("text", )) self.window2.column1.set_cell_data_func(self.window2.renderer2_4, self.on_celldatamethod, ("check", )) self.window2.treeview2.append_column(self.window2.column0) self.window2.treeview2.append_column(self.window2.column1)