def make_color_combobox(self, row, dex):
c = QComboBox(self)
c.addItem('')
c.addItems(QColor.colorNames())
self.table.setCellWidget(row, 1, c)
if dex >= 0:
c.setCurrentIndex(dex)
return c
def ins_button_clicked(self):
row = self.table.currentRow()
if row < 0:
error_dialog(self, _('Select a cell'),
_('Select a cell before clicking the button'), show=True)
return
self.table.insertRow(row)
self.table.setItem(row, 0, QTableWidgetItem())
c = QComboBox(self)
c.addItem('')
c.addItems(QColor.colorNames())
self.table.setCellWidget(row, 1, c)
def __init__(self, parent, current_row, current_key, standard_colheads, standard_colnames):
QDialog.__init__(self, parent)
self.setup_ui()
self.setWindowTitle(_('Create a custom column'))
self.heading_label.setText('<b>' + _('Create a custom column'))
# Remove help icon on title bar
icon = self.windowIcon()
self.setWindowFlags(self.windowFlags()&(~Qt.WindowType.WindowContextHelpButtonHint))
self.setWindowIcon(icon)
self.simple_error = partial(error_dialog, self, show=True,
show_copy_button=False)
for sort_by in [_('Text'), _('Number'), _('Date'), _('Yes/No')]:
self.composite_sort_by.addItem(sort_by)
self.parent = parent
self.parent.cc_column_key = None
self.editing_col = current_row is not None
self.standard_colheads = standard_colheads
self.standard_colnames = standard_colnames
self.column_type_box.setMaxVisibleItems(len(self.column_types))
for t in self.column_types:
self.column_type_box.addItem(self.column_types[t]['text'])
self.column_type_box.currentIndexChanged.connect(self.datatype_changed)
if not self.editing_col:
self.datatype_changed()
self.exec_()
return
self.setWindowTitle(_('Edit custom column'))
self.heading_label.setText('<b>' + _('Edit custom column'))
self.shortcuts.setVisible(False)
idx = current_row
if idx < 0:
self.simple_error(_('No column selected'), _('No column has been selected'))
return
col = current_key
if col not in parent.custcols:
self.simple_error('', _('Selected column is not a user-defined column'))
return
c = parent.custcols[col]
self.column_name_box.setText(c['label'])
self.column_heading_box.setText(c['name'])
self.column_heading_box.setFocus()
ct = c['datatype']
if c['is_multiple']:
ct = '*' + ct
self.orig_column_number = c['colnum']
self.orig_column_name = col
column_numbers = dict(map(lambda x:(self.column_types[x]['datatype'], x),
self.column_types))
self.column_type_box.setCurrentIndex(column_numbers[ct])
self.column_type_box.setEnabled(False)
if ct == 'datetime':
if c['display'].get('date_format', None):
self.format_box.setText(c['display'].get('date_format', ''))
elif ct in ['composite', '*composite']:
self.composite_box.setText(c['display'].get('composite_template', ''))
sb = c['display'].get('composite_sort', 'text')
vals = ['text', 'number', 'date', 'bool']
if sb in vals:
sb = vals.index(sb)
else:
sb = 0
self.composite_sort_by.setCurrentIndex(sb)
self.composite_make_category.setChecked(
c['display'].get('make_category', False))
self.composite_contains_html.setChecked(
c['display'].get('contains_html', False))
elif ct == 'enumeration':
self.enum_box.setText(','.join(c['display'].get('enum_values', [])))
self.enum_colors.setText(','.join(c['display'].get('enum_colors', [])))
elif ct in ['int', 'float']:
if c['display'].get('number_format', None):
self.format_box.setText(c['display'].get('number_format', ''))
elif ct == 'comments':
idx = max(0, self.comments_heading_position.findData(c['display'].get('heading_position', 'hide')))
self.comments_heading_position.setCurrentIndex(idx)
idx = max(0, self.comments_type.findData(c['display'].get('interpret_as', 'html')))
self.comments_type.setCurrentIndex(idx)
elif ct == 'rating':
self.allow_half_stars.setChecked(bool(c['display'].get('allow_half_stars', False)))
# Default values
dv = c['display'].get('default_value', None)
if dv is not None:
if ct == 'bool':
self.default_value.setText(_('Yes') if dv else _('No'))
elif ct == 'datetime':
self.default_value.setText(_('Now') if dv == 'now' else dv)
elif ct == 'rating':
if self.allow_half_stars.isChecked():
self.default_value.setText(unicode_type(dv/2))
else:
self.default_value.setText(unicode_type(dv//2))
elif ct in ('int', 'float'):
self.default_value.setText(unicode_type(dv))
elif ct not in ('composite', '*composite'):
self.default_value.setText(dv)
self.datatype_changed()
if ct in ['text', 'composite', 'enumeration']:
self.use_decorations.setChecked(c['display'].get('use_decorations', False))
elif ct == '*text':
self.is_names.setChecked(c['display'].get('is_names', False))
self.description_box.setText(c['display'].get('description', ''))
all_colors = [unicode_type(s) for s in list(QColor.colorNames())]
self.enum_colors_label.setToolTip('<p>' + ', '.join(all_colors) + '</p>')
self.exec_()
def accept(self):
col = unicode_type(self.column_name_box.text()).strip()
if not col:
return self.simple_error('', _('No lookup name was provided'))
if col.startswith('#'):
col = col[1:]
if re.match(r'^\w*$', col) is None or not col[0].isalpha() or col.lower() != col:
return self.simple_error('', _('The lookup name must contain only '
'lower case letters, digits and underscores, and start with a letter'))
if col.endswith('_index'):
return self.simple_error('', _('Lookup names cannot end with _index, '
'because these names are reserved for the index of a series column.'))
col_heading = unicode_type(self.column_heading_box.text()).strip()
coldef = self.column_types[self.column_type_box.currentIndex()]
col_type = coldef['datatype']
if col_type[0] == '*':
col_type = col_type[1:]
is_multiple = True
else:
is_multiple = False
if not col_heading:
return self.simple_error('', _('No column heading was provided'))
db = self.parent.gui.library_view.model().db
key = db.field_metadata.custom_field_prefix+col
bad_col = False
if key in self.parent.custcols:
if not self.editing_col or \
self.parent.custcols[key]['colnum'] != self.orig_column_number:
bad_col = True
if bad_col:
return self.simple_error('', _('The lookup name %s is already used')%col)
bad_head = False
for t in self.parent.custcols:
if self.parent.custcols[t]['name'] == col_heading:
if not self.editing_col or \
self.parent.custcols[t]['colnum'] != self.orig_column_number:
bad_head = True
for t in self.standard_colheads:
if self.standard_colheads[t] == col_heading:
bad_head = True
if bad_head:
return self.simple_error('', _('The heading %s is already used')%col_heading)
display_dict = {}
default_val = (unicode_type(self.default_value.text()).strip()
if col_type != 'composite' else None)
if col_type == 'datetime':
if unicode_type(self.format_box.text()).strip():
display_dict = {'date_format':unicode_type(self.format_box.text()).strip()}
else:
display_dict = {'date_format': None}
if default_val:
if default_val == _('Now'):
display_dict['default_value'] = 'now'
else:
try:
tv = parse_date(default_val)
except:
tv = UNDEFINED_DATE
if tv == UNDEFINED_DATE:
return self.simple_error(_('Invalid default value'),
_('The default value must be "Now" or a date'))
display_dict['default_value'] = default_val
elif col_type == 'composite':
if not unicode_type(self.composite_box.text()).strip():
return self.simple_error('', _('You must enter a template for '
'composite columns'))
display_dict = {'composite_template':unicode_type(self.composite_box.text()).strip(),
'composite_sort': ['text', 'number', 'date', 'bool']
[self.composite_sort_by.currentIndex()],
'make_category': self.composite_make_category.isChecked(),
'contains_html': self.composite_contains_html.isChecked(),
}
elif col_type == 'enumeration':
if not unicode_type(self.enum_box.text()).strip():
return self.simple_error('', _('You must enter at least one '
'value for enumeration columns'))
l = [v.strip() for v in unicode_type(self.enum_box.text()).split(',') if v.strip()]
l_lower = [v.lower() for v in l]
for i,v in enumerate(l_lower):
if v in l_lower[i+1:]:
return self.simple_error('', _('The value "{0}" is in the '
'list more than once, perhaps with different case').format(l[i]))
c = unicode_type(self.enum_colors.text())
if c:
c = [v.strip() for v in unicode_type(self.enum_colors.text()).split(',')]
else:
c = []
if len(c) != 0 and len(c) != len(l):
return self.simple_error('', _('The colors box must be empty or '
'contain the same number of items as the value box'))
for tc in c:
if tc not in QColor.colorNames() and not re.match("#(?:[0-9a-f]{3}){1,4}",tc,re.I):
return self.simple_error('', _('The color {0} is unknown').format(tc))
display_dict = {'enum_values': l, 'enum_colors': c}
if default_val:
if default_val not in l:
return self.simple_error(_('Invalid default value'),
_('The default value must be one of the permitted values'))
display_dict['default_value'] = default_val
elif col_type == 'text' and is_multiple:
display_dict = {'is_names': self.is_names.isChecked()}
elif col_type in ['int', 'float']:
if unicode_type(self.format_box.text()).strip():
display_dict = {'number_format':unicode_type(self.format_box.text()).strip()}
else:
display_dict = {'number_format': None}
if default_val:
try:
if col_type == 'int':
msg = _('The default value must be an integer')
tv = int(default_val)
display_dict['default_value'] = tv
else:
msg = _('The default value must be a real number')
tv = float(default_val)
display_dict['default_value'] = tv
except:
return self.simple_error(_('Invalid default value'), msg)
elif col_type == 'comments':
display_dict['heading_position'] = unicode_type(self.comments_heading_position.currentData())
display_dict['interpret_as'] = unicode_type(self.comments_type.currentData())
elif col_type == 'rating':
half_stars = bool(self.allow_half_stars.isChecked())
display_dict['allow_half_stars'] = half_stars
if default_val:
try:
tv = int((float(default_val) if half_stars else int(default_val)) * 2)
except:
tv = -1
if tv < 0 or tv > 10:
if half_stars:
return self.simple_error(_('Invalid default value'),
_('The default value must be a real number between 0 and 5.0'))
else:
return self.simple_error(_('Invalid default value'),
_('The default value must be an integer between 0 and 5'))
display_dict['default_value'] = tv
elif col_type == 'bool':
if default_val:
tv = {_('Yes'): True, _('No'): False}.get(default_val, None)
if tv is None:
return self.simple_error(_('Invalid default value'),
_('The default value must be "Yes" or "No"'))
display_dict['default_value'] = tv
if col_type in ['text', 'composite', 'enumeration'] and not is_multiple:
display_dict['use_decorations'] = self.use_decorations.checkState()
if default_val and 'default_value' not in display_dict:
display_dict['default_value'] = default_val
display_dict['description'] = self.description_box.text().strip()
if not self.editing_col:
self.parent.custcols[key] = {
'label':col,
'name':col_heading,
'datatype':col_type,
'display':display_dict,
'normalized':None,
'colnum':None,
'is_multiple':is_multiple,
}
self.parent.cc_column_key = key
else:
self.parent.custcols[self.orig_column_name]['label'] = col
self.parent.custcols[self.orig_column_name]['name'] = col_heading
# Remove any previous default value
self.parent.custcols[self.orig_column_name]['display'].pop('default_value', None)
self.parent.custcols[self.orig_column_name]['display'].update(display_dict)
self.parent.custcols[self.orig_column_name]['*edited'] = True
self.parent.custcols[self.orig_column_name]['*must_restart'] = True
self.parent.cc_column_key = key
QDialog.accept(self)
def __init__(self, parent, db, key):
QDialog.__init__(self, parent)
self.setWindowTitle(_('Edit permissible values for {0}').format(key))
self.db = db
l = QGridLayout()
bbox = QVBoxLayout()
bbox.addStretch(10)
self.del_button = QToolButton()
self.del_button.setIcon(QIcon(I('trash.png')))
self.del_button.setToolTip(_('Remove the currently selected value'))
self.ins_button = QToolButton()
self.ins_button.setIcon(QIcon(I('plus.png')))
self.ins_button.setToolTip(_('Add a new permissible value'))
self.move_up_button = QToolButton()
self.move_up_button.setIcon(QIcon(I('arrow-up.png')))
self.move_down_button = QToolButton()
self.move_down_button.setIcon(QIcon(I('arrow-down.png')))
bbox.addWidget(self.del_button)
bbox.addStretch(1)
bbox.addWidget(self.ins_button)
bbox.addStretch(1)
bbox.addWidget(self.move_up_button)
bbox.addStretch(1)
bbox.addWidget(self.move_down_button)
bbox.addStretch(10)
l.addItem(bbox, 0, 0)
self.del_button.clicked.connect(self.del_line)
self.all_colors = {unicode_type(s) for s in list(QColor.colorNames())}
tl = QVBoxLayout()
l.addItem(tl, 0, 1)
self.table = t = QTableWidget(parent)
t.setColumnCount(2)
t.setRowCount(1)
t.setHorizontalHeaderLabels([_('Value'), _('Color')])
t.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
tl.addWidget(t)
self.fm = fm = db.field_metadata[key]
permitted_values = fm.get('display', {}).get('enum_values', '')
colors = fm.get('display', {}).get('enum_colors', '')
t.setRowCount(len(permitted_values))
for i, v in enumerate(permitted_values):
t.setItem(i, 0, QTableWidgetItem(v))
c = self.make_color_combobox(i, -1)
if colors:
c.setCurrentIndex(c.findText(colors[i]))
else:
c.setCurrentIndex(0)
t.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeMode.Stretch)
self.setLayout(l)
self.bb = bb = QDialogButtonBox(
QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel)
bb.accepted.connect(self.accept)
bb.rejected.connect(self.reject)
l.addWidget(bb, 1, 0, 1, 2)
self.ins_button.clicked.connect(self.ins_button_clicked)
self.move_down_button.clicked.connect(self.move_down_clicked)
self.move_up_button.clicked.connect(self.move_up_clicked)
geom = gprefs.get('enum-values-edit-geometry')
if geom is not None:
QApplication.instance().safe_restore_geometry(self, geom)
