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)
