def resultitemchanged(self, new_item):
self.IDC_textDetails.setText('')
self.IDC_listRessources.clear()
self.IDC_plainTextLink.clear()
if new_item is None:
return
package = new_item.data(Qt.UserRole)
self.cur_package = package
if package is None:
return
self.IDC_textDetails.setText(
u'{0}\n\n{1}\n{2}\n\n{3}'.format(
package.get('notes', 'no notes'),
package.get('author', 'no author'),
package.get('author_email', 'no author_email'),
package.get('license_id', 'no license_id')
)
)
if package.get('num_resources', 0) > 0:
for res in package['resources']:
item = QListWidgetItem(u'{0}: {1}'.format(
res.get('format', 'no format')
, res.get('name', 'no name')
))
item.setData(Qt.UserRole, res)
item.setCheckState(Qt.Unchecked)
self.IDC_listRessources.addItem(item)
def __init__(self, weboob, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_MessagesManager()
self.ui.setupUi(self)
self.weboob = weboob
self.ui.backendsList.addItem('(All)')
for backend in self.weboob.iter_backends():
if not backend.has_caps(ICapMessages):
continue
item = QListWidgetItem(backend.name.capitalize())
item.setData(Qt.UserRole, backend)
self.ui.backendsList.addItem(item)
self.ui.backendsList.setCurrentRow(0)
self.backend = None
self.thread = None
self.message = None
self.ui.replyButton.setEnabled(False)
self.ui.replyWidget.hide()
self.connect(self.ui.backendsList, SIGNAL('itemSelectionChanged()'), self._backendChanged)
self.connect(self.ui.threadsList, SIGNAL('itemSelectionChanged()'), self._threadChanged)
self.connect(self.ui.messagesTree, SIGNAL('itemClicked(QTreeWidgetItem *, int)'), self._messageSelected)
self.connect(self.ui.messagesTree, SIGNAL('itemActivated(QTreeWidgetItem *, int)'), self._messageSelected)
self.connect(self.ui.replyButton, SIGNAL('clicked()'), self._replyPressed)
self.connect(self.ui.sendButton, SIGNAL('clicked()'), self._sendPressed)
def populate_field_list(self, excluded_fields=None):
"""Helper to add field of the layer to the list.
:param excluded_fields: List of field that want to be excluded.
:type excluded_fields: list
"""
# Populate fields list
if excluded_fields is None:
excluded_fields = []
self.field_list.clear()
for field in self.layer.dataProvider().fields():
# Skip if it's excluded
if field.name() in excluded_fields:
continue
# Skip if it's not number (float, int, etc)
if field.type() not in qvariant_numbers:
continue
field_item = QListWidgetItem(self.field_list)
field_item.setFlags(
Qt.ItemIsEnabled |
Qt.ItemIsSelectable |
Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field.name())
field_item.setText(field.name())
self.field_list.addItem(field_item)
def feel_list(self):
self.lstServices.clear()
ds_list = DataSourcesList(USER_DS_PATHS)
for ds in ds_list.data_sources.itervalues():
item = QListWidgetItem(ds.action.icon(), ds.action.text())
item.setData(Qt.UserRole, ds)
self.lstServices.addItem(item)
def build_list(self, files):
self.listWidget.clear()
for fname in files:
item = QListWidgetItem(fname)
item.setData(Qt.UserRole, fname)
self.listWidget.addItem(item)
self.listWidget.setCurrentRow(0)
def set_widgets(self):
"""Set widgets on the Hazard Category tab."""
self.clear_further_steps()
# Set widgets
self.lstHazardCategories.clear()
self.lblDescribeHazardCategory.setText('')
self.lblSelectHazardCategory.setText(
hazard_category_question)
hazard_categories = self.hazard_categories_for_layer()
for hazard_category in hazard_categories:
if not isinstance(hazard_category, dict):
hazard_category = definition(hazard_category)
item = QListWidgetItem(
hazard_category['name'],
self.lstHazardCategories)
item.setData(QtCore.Qt.UserRole, hazard_category['key'])
self.lstHazardCategories.addItem(item)
# Set values based on existing keywords (if already assigned)
category_keyword = self.parent.get_existing_keyword('hazard_category')
if category_keyword:
categories = []
for index in xrange(self.lstHazardCategories.count()):
item = self.lstHazardCategories.item(index)
categories.append(item.data(QtCore.Qt.UserRole))
if category_keyword in categories:
self.lstHazardCategories.setCurrentRow(
categories.index(category_keyword))
self.auto_select_one_item(self.lstHazardCategories)
def search(self, text):
db = self.db
c = db.cursor()
self.resultsView.clear()
self.resultsView.setEnabled(False)
if not text:
return
if self.fuzzyCheck.isChecked():
search = "* ".join(text.split()) + "*"
else:
search = text
query = c.execute("""SELECT layer, featureid, snippet(search, '[',']') as snippet
FROM search
JOIN featureinfo on search.docid = featureinfo.id
WHERE search match '{}' LIMIT 100""".format(search)).fetchall()
for layer, featureid, snippet in query:
item = QListWidgetItem()
text = "{}\n {}".format(layer, snippet.replace('\n', ' '))
item.setText(text)
item.setData(Qt.UserRole, (layer, featureid, snippet))
self.resultsView.addItem(item)
self.resultsView.setEnabled(True)
if self.resultsView.count() == 0:
self.resultsView.addItem("No Results")
self.resultsView.setEnabled(False)
db.close()
def set_widgets(self):
"""Set widgets on the layer purpose tab."""
self.clear_further_steps()
# Set widgets
self.lstCategories.clear()
self.lblDescribeCategory.setText("")
self.lblIconCategory.setPixmap(QPixmap())
self.lblSelectCategory.setText(category_question % self.parent.layer.name())
purposes = self.purposes_for_layer()
if self.parent.get_layer_geometry_id() == "polygon":
purposes += ["aggregation"]
for purpose in purposes:
if not isinstance(purpose, dict):
purpose = definition(purpose)
item = QListWidgetItem(purpose["name"], self.lstCategories)
item.setData(QtCore.Qt.UserRole, purpose["key"])
self.lstCategories.addItem(item)
# Check if layer keywords are already assigned
purpose_keyword = self.parent.get_existing_keyword("layer_purpose")
# Overwrite the purpose_keyword if it's KW mode embedded in IFCW mode
if self.parent.parent_step:
purpose_keyword = self.parent.get_parent_mode_constraints()[0]["key"]
# Set values based on existing keywords or parent mode
if purpose_keyword:
purposes = []
for index in xrange(self.lstCategories.count()):
item = self.lstCategories.item(index)
purposes.append(item.data(QtCore.Qt.UserRole))
if purpose_keyword in purposes:
self.lstCategories.setCurrentRow(purposes.index(purpose_keyword))
self.auto_select_one_item(self.lstCategories)
def feel_list(self):
self.lstGroups.clear()
ds_groups = GroupsList(USER_GROUP_PATHS)
for ds_group in ds_groups.groups.itervalues():
item = QListWidgetItem(QIcon(ds_group.icon), self.tr(ds_group.alias))
item.setData(Qt.UserRole, ds_group)
self.lstGroups.addItem(item)
def get_input(self, obj, key):
lb = self.lb_objects
for item_index in range(lb.count()):
if lb.item(item_index).data(Qt.UserRole) == key:
break
else:
item_index = None
if obj is None:
if item_index is None:
return
del self.objects[key]
lb.takeItem(item_index)
if not self.objects:
self.send("Object", None)
return
else:
self.objects[key] = obj
item_desc = "{} {}".format(
type(obj).__name__, getattr(obj, "name", ""))
if item_index is None:
item = QListWidgetItem(item_desc)
item.setData(Qt.UserRole, key)
lb.addItem(item)
lb.setCurrentItem(item)
else:
lb.item(item_index).setText(item_desc)
self._on_selection_change()
def set_widgets(self):
"""Set widgets on the Subcategory tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
self.lstSubcategories.clear()
self.lblDescribeSubcategory.setText('')
self.lblIconSubcategory.setPixmap(QPixmap())
self.lblSelectSubcategory.setText(
get_question_text('%s_question' % purpose['key']))
for i in self.subcategories_for_layer():
item = QListWidgetItem(i['name'], self.lstSubcategories)
item.setData(QtCore.Qt.UserRole, i['key'])
self.lstSubcategories.addItem(item)
# Check if layer keywords are already assigned
key = self.parent.step_kw_purpose.selected_purpose()['key']
keyword = self.parent.get_existing_keyword(key)
# Overwrite the keyword if it's KW mode embedded in IFCW mode
if self.parent.parent_step:
keyword = self.parent.get_parent_mode_constraints()[1]['key']
# Set values based on existing keywords or parent mode
if keyword:
subcategories = []
for index in xrange(self.lstSubcategories.count()):
item = self.lstSubcategories.item(index)
subcategories.append(item.data(QtCore.Qt.UserRole))
if keyword in subcategories:
self.lstSubcategories.setCurrentRow(
subcategories.index(keyword))
self.auto_select_one_item(self.lstSubcategories)
def __init__(self, opPixelClassification, parent):
super( QDialog, self ).__init__(parent=parent)
self._op = opPixelClassification
classifier_listwidget = QListWidget(parent=self)
classifier_listwidget.setSelectionMode( QListWidget.SingleSelection )
classifier_factories = self._get_available_classifier_factories()
for name, classifier_factory in classifier_factories.items():
item = QListWidgetItem( name )
item.setData( Qt.UserRole, QVariant(classifier_factory) )
classifier_listwidget.addItem(item)
buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self )
buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
buttonbox.accepted.connect( self.accept )
buttonbox.rejected.connect( self.reject )
layout = QVBoxLayout()
layout.addWidget( classifier_listwidget )
layout.addWidget( buttonbox )
self.setLayout(layout)
self.setWindowTitle( "Select Classifier Type" )
# Save members
self._classifier_listwidget = classifier_listwidget
def set_widgets(self):
"""Set widgets on the Classification tab."""
self.clear_further_steps()
purpose = self.parent.step_kw_purpose.selected_purpose()['name']
subcategory = self.parent.step_kw_subcategory.\
selected_subcategory()['name']
self.lstClassifications.clear()
self.lblDescribeClassification.setText('')
self.lblSelectClassification.setText(
classification_question % (subcategory, purpose))
classifications = self.classifications_for_layer()
for classification in classifications:
if not isinstance(classification, dict):
classification = definition(classification)
item = QListWidgetItem(
classification['name'],
self.lstClassifications)
item.setData(QtCore.Qt.UserRole, classification['key'])
self.lstClassifications.addItem(item)
# Set values based on existing keywords (if already assigned)
classification_keyword = self.parent.get_existing_keyword(
'classification')
if classification_keyword:
classifications = []
for index in xrange(self.lstClassifications.count()):
item = self.lstClassifications.item(index)
classifications.append(item.data(QtCore.Qt.UserRole))
if classification_keyword in classifications:
self.lstClassifications.setCurrentRow(
classifications.index(classification_keyword))
self.auto_select_one_item(self.lstClassifications)
def set_widgets(self):
"""Set widgets on the Field tab."""
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
unit = self.parent.step_kw_unit.selected_unit()
question_text = field_question_name_field % (subcategory['name'])
self.lblSelectField.setText(question_text)
self.lstFields.clear()
default_item = None
type_field = self.parent.step_kw_field.selected_field()
for field in self.parent.layer.dataProvider().fields():
field_name = field.name()
if type_field != field_name:
# We do not use a field already used in the wizard before.
item = QListWidgetItem(field_name, self.lstFields)
item.setData(QtCore.Qt.UserRole, field_name)
# Select the item if it match the unit's default_attribute
if unit and 'default_attribute' in unit \
and field_name == unit['default_attribute']:
default_item = item
if default_item:
self.lstFields.setCurrentItem(default_item)
self.lblDescribeField.clear()
# Set values based on existing keywords (if already assigned)
field_keyword = self.parent.field_keyword_for_the_layer()
field = self.parent.get_existing_keyword(field_keyword)
if field:
fields = []
for index in xrange(self.lstFields.count()):
fields.append(str(self.lstFields.item(index).text()))
if field in fields:
self.lstFields.setCurrentRow(fields.index(field))
self.auto_select_one_item(self.lstFields)
def __init__(self, iface, settings):
self.iface = iface
self.s = settings
QDialog.__init__(self, iface.mainWindow())
# Set up the user interface from Designer.
self.ui = Ui_VoGISRaumplanungPlot()
self.ui.setupUi(self)
try:
self.json_settings = JsonSettings(self.iface, self.s.read(self.s.key_file_settings))
except:
msg = u'Einstellungsdatei konnte nicht geladen werden!\nBitte die Datei auf korrektes JSON-Format überprüfen.\n\n\nFehlerprotokoll:\n{0}'.format(traceback.format_exc())
QMessageBox.warning(self.iface.mainWindow(), DLG_CAPTION, msg)
return
self.dkm_coverage_layer = None
self.gstke = {}
self.curr_gem_name = None
#hold kgs and gnrs if there's already a selection in the active document
self.autoselect_kgs = None
self.autoselect_gnrs = None
self.__add_themen()
#add Gemeinde names
self.gem_src = VRPGemeinden(self.iface, self.s, self.json_settings)
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
gem_names = self.gem_src.get_names()
#if VRP_DEBUG is True: QgsMessageLog.logMessage('\n'.join(gem_names), DLG_CAPTION)
for gem in gem_names:
item = QListWidgetItem(gem)
item.setData(Qt.UserRole, gem)
self.ui.LST_GEMEINDEN.addItem(item)
finally:
QApplication.restoreOverrideCursor()
#insert layouts
for name, layout in self.json_settings.layouts().iteritems():
self.ui.CB_Layout.addItem(name, layout)
#speed up items insertion
self.ui.LST_GSTKE.setLayoutMode( QListWidget.Batched )
self.ui.LST_GSTKE.setBatchSize( 100 )
self.ui.LST_GSTKE.setUniformItemSizes(True)
#check if the active layer is a DKM layer and if there are any selected features
if not self.iface.activeLayer() is None:
act_lyr = self.iface.activeLayer()
if isinstance(act_lyr, QgsVectorLayer):
sel_feats = act_lyr.selectedFeatures()
if len(sel_feats) > 0:
fld_gemname = self.json_settings.fld_pgem_name()
fld_kg = self.json_settings.fld_kg()
fld_gnr = self.json_settings.fld_gnr()
dkm_flds = [fld_gemname, fld_kg, fld_gnr]
if all( dkm_fld in [fld.name() for fld in act_lyr.pendingFields()] for dkm_fld in dkm_flds):
#self.iface.messageBar().pushMessage(u'alles da!', QgsMessageBar.INFO)
self.__apply_selected_features(sel_feats, fld_gemname, fld_kg, fld_gnr)
def reload_key_list(self):
while self.key_list.count() > 0:
self.key_list.takeItem(0)
for key in sorted(self._keys.keys()):
item = QListWidgetItem(unicode(key))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable)
item.setData(Qt.UserRole, unicode(key))
self.key_list.addItem(item)
def addLayer(self, layer):
if (layer is None or not layer.isValid() or layer.type() != QgsMapLayer.VectorLayer):
return
newItem = QListWidgetItem()
newItem.setData(Qt.UserRole, layer.id())
# newItem.setSizeHint(layerWidget.minimumSizeHint())
self._listWidget.addItem(newItem)
self._listWidget.setItemWidget(newItem, LayerSnappingWidget(layer, self))
def fillLayersList( self ):
self.lstLayers.clear()
layers = ftools_utils.getLayerNames( [ QGis.Line, QGis.Point, QGis.Polygon ] )
for lay in layers:
source = ftools_utils.getVectorLayerByName( lay ).source()
item = QListWidgetItem( lay, self.lstLayers )
item.setData( Qt.UserRole, source )
item.setData( Qt.ToolTipRole, source )
def populateListWithDatabasesFromServer(self):
self.serverListWidget.clear()
dbList = self.serverWidget.abstractDb.getEDGVDbsFromServer()
dbList.sort()
for (dbname, dbversion) in dbList:
item = QListWidgetItem(self.serverListWidget)
item.setText(dbname+' (EDGV v. '+dbversion+')')
item.setData(Qt.UserRole, dbname)
def load_profiles(self, load_default):
while self.profile_list.count() > 0:
self.profile_list.takeItem(0)
for profile_name, profile in self._profiles.items():
item = QListWidgetItem(unicode(profile_name) + (u' (default)' if profile['default'] else u''))
item.setData(Qt.UserRole, unicode(profile_name))
self.profile_list.addItem(item)
if load_default and profile['default']:
self._selected_profile = profile
def _project_selected(self):
self.list_templates.clear()
item = self.list_projects.currentItem()
category = item.text()
for template in self.template_registry.list_templates_for_cateogory(
category):
item = QListWidgetItem(template.type_name)
item.setData(Qt.UserRole, template)
item = self.list_templates.addItem(item)
def add_program_to_list(self, program):
program_info = ProgramInfoMain(self.session, self.script_manager, self.image_version, self.executable_versions, program)
program_info.name_changed.connect(self.refresh_program_names)
item = QListWidgetItem(program.cast_custom_option_value('name', unicode, '<unknown>'))
item.setData(Qt.UserRole, program_info)
self.list_programs.addItem(item)
self.stacked_container.addWidget(program_info)
def setCount(self, count):
self.beatList.clear()
for beatNum, beat in enumerate(count):
countIndex = self._registry.lookupIndex(beat)
item = QListWidgetItem("".join(beat.count(beatNum + 1)))
item.setData(Qt.UserRole, QVariant(countIndex))
self.beatList.addItem(item)
self.beatList.setCurrentRow(0)
self.preview()
def refreshMailList (self):
while self.mailList.count() > 0:
self.mailList.takeItem(0)
for message in reversed(self.mailbox.list()):
subject = self.mailbox.fdecode(message['header']['Subject'])
subject = subject if isinstance(subject, str) else '<No subject>'
item = QListWidgetItem(subject)
item.setData(Qt.UserRole, message['id']);
self.mailList.addItem(item)
self.mailList.itemClicked.connect(self.showMail)
def loadprojects(self, projects):
for project in projects:
item = QListWidgetItem(project.name, self.mOptionsListWidget)
item.setData(Qt.UserRole, project)
item.setIcon(QIcon(project.splash))
widget = ProjectPageWidget(project)
widget.updateproject.connect(self.updateproject)
self.mOptionsStackedWidget.addWidget(widget)
self.mOptionsListWidget.adjustSize()
def _gotThread(self, backend, thread):
if not backend:
self.process_threads = None
self.ui.backendsList.setEnabled(True)
self.ui.threadsList.setEnabled(True)
return
item = QListWidgetItem(thread.title)
item.setData(Qt.UserRole, (thread.backend, thread.id))
self.ui.threadsList.addItem(item)
def initializePage(self):
paramNAlts = int(self.field("paramNAlts").toString())
paramNPerm = int(self.field("paramNPerm").toString())
self.question_list.clear()
# Creation of the list section
paramNCols_array = self.field("paramNCols").toString().split(',')
total_questions = 1 + (int(paramNCols_array[0]) \
if len(paramNCols_array) == 1 \
else reduce(lambda x, y: int(x) + int(y),
paramNCols_array))
for i in range(1,total_questions):
questions_list = QListWidgetItem(_('Question ') + str(i))
questions_list.setData(Qt.UserRole,
widgets.ItemList(optionName=_('Question ') + str(i),
optionNumber=i)) # Custom item list
self.question_list.addItem(questions_list)
self.question_list.setCurrentRow(0)
self.question_list.itemClicked.connect(self._on_item_changed)
# Creation of the grid section
add_header = True # Header of the columns (Name of alternatives)
for j in range(0, paramNPerm):
self.permutation_grid.addWidget( \
QLabel(_('Model ') + chr(97 + j).upper()), j, 1)
self.alternatives_rows[j] = {}
for k in range(0, paramNAlts):
if add_header:
if k == 0:
self.permutation_grid.addWidget(QLabel(''), 0, 1)
self.permutation_grid.addWidget( \
QLabel(chr(97 + k).upper()), 0, k + 2)
self.alternatives_rows[j][k] = \
widgets.InputComboBox(self, c_type='alternative',
form=j, alternative=k)
self.alternatives_rows[j][k].addItems( \
[chr(97+x).upper() for x in range(0,paramNAlts)])
self.alternatives_rows[j][k].setCurrentIndex(0)
self.permutation_grid.addWidget(self.alternatives_rows[j][k],
j, k + 2)
add_header = False
self.alternatives_rows[j][k + 1] = \
widgets.InputComboBox(self, c_type='question', form=j,
alternative=self.question_list.\
currentItem().\
data(Qt.UserRole).toPyObject().\
get_question_number())
self.alternatives_rows[j][k + 1].addItems( \
[str(x) for x in range(1,total_questions)])
self.alternatives_rows[j][k + 1].setCurrentIndex(0)
self.permutation_grid.addWidget(QLabel(_('Question Number')),
j, k + 3)
self.permutation_grid.addWidget(self.alternatives_rows[j][k + 1],
j, k + 4)
button_save = QPushButton(_('Save values'))
self.permutation_grid.addWidget(button_save, j + 1, 1, 1, k + 4)
button_save.clicked.connect(self._save_values)
def add_items(self):
characters = self.client.results
for character in characters:
item = QListWidgetItem(self.get_name(character["name"]))
item.setData(Qt.UserRole, character)
item.setSizeHint(QSize(48, 48))
icon = self.get_icon(character)
if icon is not None:
item.setIcon(icon)
self.listWidget.addItem(item)
self.listWidget.setCurrentRow(0)
def initList(self):
self.notebookList.clear()
notebooks = Mikibook.read()
for nb in notebooks:
item = QListWidgetItem()
item.setData(Qt.DisplayRole, nb[0])
item.setData(Qt.UserRole, nb[1])
self.notebookList.addItem(item)
self.updateUi(len(notebooks) != 0)
self.notebookList.setCurrentRow(0)
def set_widgets(self):
"""Set widgets on the Field tab."""
self.clear_further_steps()
purpose = self.parent.step_kw_purpose.selected_purpose()
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
unit = self.parent.step_kw_unit.selected_unit()
if purpose == layer_purpose_aggregation:
question_text = field_question_aggregation
elif self.parent.step_kw_layermode.\
selected_layermode() == layer_mode_continuous and unit:
# unique values, continuous or categorical data
subcategory_unit_relation = get_question_text(
'%s_%s_question' % (subcategory['key'], unit['key']))
question_text = field_question_subcategory_unit % (
purpose['name'],
subcategory['name'],
unit['name'],
subcategory_unit_relation)
else:
question_text = field_question_subcategory_classified % (
subcategory['name'])
self.lblSelectField.setText(question_text)
self.lstFields.clear()
default_item = None
for field in self.parent.layer.dataProvider().fields():
field_name = field.name()
item = QListWidgetItem(field_name, self.lstFields)
item.setData(QtCore.Qt.UserRole, field_name)
# Select the item if it match the unit's default_attribute
if unit and 'default_attribute' in unit \
and field_name == unit['default_attribute']:
default_item = item
# For continuous data, gray out id, gid, fid and text fields
if self.parent.step_kw_layermode.\
selected_layermode() == layer_mode_continuous and unit:
field_type = field.type()
if field_type > 9 or re.match(
'.{0,2}id$', field_name, re.I):
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEnabled)
if default_item:
self.lstFields.setCurrentItem(default_item)
self.lblDescribeField.clear()
# Set values based on existing keywords (if already assigned)
field_keyword = self.parent.field_keyword_for_the_layer()
field = self.parent.get_existing_keyword(field_keyword)
if field:
fields = []
for index in xrange(self.lstFields.count()):
fields.append(str(self.lstFields.item(index).text()))
if field in fields:
self.lstFields.setCurrentRow(fields.index(field))
self.auto_select_one_item(self.lstFields)
def __init__(self, evtxManager, root):
EventLogViewer.__init__(self, None)
self.evtxManager = evtxManager
self.vfs = VFS.Get()
self.evtx_table_view.setColumnCount(7)
self.evtx_table_view.hideColumn(4)
self.evtx_table_view.hideColumn(5)
self.evtx_table_view.hideColumn(6)
self.admin_pannel.hide()
self.list_widget = QListWidget()
file_names = QLabel('Windows events')
ww = QWidget()
l = QVBoxLayout(ww)
l.addWidget(file_names)
l.addWidget(self.list_widget)
l.setSpacing(2)
l.setContentsMargins(2, 2, 2, 2)
for node_name, chunks in self.evtxManager.getData():
node = self.vfs.getNodeById(node_name)
if node.absolute()[:len(root)] != root:
continue
item = QListWidgetItem(
QIcon(':/toggle_log'),
node.name().replace('Microsoft-Windows-',
'').replace('.evtx', ''))
item.setData(QListWidgetItem.UserType, long(node_name))
self.list_widget.addItem(item)
self.list_widget.sortItems()
self.list_widget.itemClicked.connect(self.fill_log_viewer)
self.splitter.insertWidget(0, ww)
ctrl = EvtControlPannel(self.evtx_table_view)
self.splitter.insertWidget(2, ctrl)
self.list_widget.itemClicked.connect(ctrl.reload)
def set_widgets(self):
"""Set widgets on the LayerMode tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
layer_mode_question = (layer_mode_raster_question if is_raster_layer(
self.parent.layer) else layer_mode_vector_question)
self.lblDescribeLayerMode.setText('')
self.lstLayerModes.clear()
layer_modes = get_layer_modes(subcategory['key'])
if is_raster_layer(self.parent.layer):
layer_mode_question = layer_mode_raster_question
else:
if len(layer_modes) == 2:
layer_mode_question = layer_mode_vector_question
elif len(layer_modes) == 1:
if layer_modes[0]['key'] == 'classified':
layer_mode_question = layer_mode_vector_classified_confirm
elif layer_modes[0]['key'] == 'continuous':
layer_mode_question = layer_mode_vector_continuous_confirm
else:
layer_mode_question = layer_mode_vector_question
self.lblSelectLayerMode.setText(layer_mode_question %
(subcategory['name'], purpose['name']))
for layer_mode in layer_modes:
item = QListWidgetItem(layer_mode['name'], self.lstLayerModes)
item.setData(QtCore.Qt.UserRole, layer_mode['key'])
self.lstLayerModes.addItem(item)
# Set value to existing keyword or default value
layer_mode_keys = [m['key'] for m in layer_modes]
layer_mode_keyword = self.parent.get_existing_keyword('layer_mode')
if layer_mode_keyword in layer_mode_keys:
index = layer_mode_keys.index(layer_mode_keyword)
elif layer_mode_continuous['key'] in layer_mode_keys:
# Set default value
index = layer_mode_keys.index(layer_mode_continuous['key'])
else:
index = -1
self.lstLayerModes.setCurrentRow(index)
self.auto_select_one_item(self.lstLayerModes)
def update_list_widget(self):
"""Update list widget when radio button is clicked."""
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
# No radio button checked, then default value = None
if radio_button_checked_id > -1:
selected_dict = self._parameter.options.values()[
radio_button_checked_id]
if selected_dict.get('type') == MULTIPLE_DYNAMIC:
for field in selected_dict.get('value'):
# Update list widget
field_item = QListWidgetItem(self.list_widget)
field_item.setFlags(
Qt.ItemIsEnabled |
Qt.ItemIsSelectable |
Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field)
field_item.setText(field)
self.list_widget.addItem(field_item)
def loadProjectList(self, projects):
self.moduleList.clear()
for project in projects:
if not project.valid:
roam.utils.warning("Project {} is invalid because {}".format(project.name, project.error))
continue
item = QListWidgetItem(self.moduleList, QListWidgetItem.UserType)
item.setData(QListWidgetItem.UserType, project)
item.setSizeHint(QSize(150, 150))
projectwidget = ProjectWidget(self.moduleList)
projectwidget.image = QPixmap(project.splash)
projectwidget.name = project.name
projectwidget.description = project.description
projectwidget.version = project.version
self.moduleList.addItem(item)
self.moduleList.setItemWidget(item, projectwidget)
def showRequest(self, task):
req = task.getRequest()
self.task = task
self.label_remote.setText(req['meta']['remote'])
self.label_transport.setText(req['meta']['scheme'])
self.label_local.setText(req['meta']['local'])
accounts = req['accounts']
for a in accounts:
addr = a['address']
typ = a['type']
url = a['url']
item = QListWidgetItem(addr)
item.setCheckState(Qt.Checked)
item.setData(Qt.StatusTipRole, "{} {}".format(typ, url))
self.accountListWidget.addItem(item)
self.window.show()
def refresh_lists(self, migration):
"""Refresh the list of code suggestions."""
self._migration, base_lineno = migration, -1
self.current_list.clear()
for lineno in sorted(migration.keys()):
linenostr = 'L{line_number}\n'.format(line_number=str(lineno + 1))
data = migration[lineno]
lines = data[0].split('\n')
if base_lineno == data[1]:
continue
base_lineno = data[1]
message = ''
for line in lines:
if line.startswith('-'):
message += '{line_to_load}\n'.format(line_to_load=line)
item = QListWidgetItem(linenostr + message)
item.setToolTip(linenostr + message)
item.setData(Qt.UserRole, lineno)
self.current_list.addItem(item)
def refresh_lists(self, migration):
self._migration = migration
self.current_list.clear()
base_lineno = -1
for lineno in sorted(migration.migration_data.keys()):
linenostr = 'L%s\n' % str(lineno + 1)
data = migration.migration_data[lineno]
lines = data[0].split('\n')
if base_lineno == data[1]:
continue
base_lineno = data[1]
message = ''
for line in lines:
if line.startswith('-'):
message += '%s\n' % line
item = QListWidgetItem(linenostr + message)
item.setToolTip(linenostr + message)
item.setData(Qt.UserRole, lineno)
self.current_list.addItem(item)
def __init__(self, parent, pedalboards):
QDialog.__init__(self)
self.ui = Ui_PedalboardOpen()
self.ui.setupUi(self)
self.fSelectedURI = ""
for pedalboard in pedalboards:
item = QListWidgetItem(self.ui.listWidget)
item.setData(Qt.UserRole, pedalboard['uri'])
item.setIcon(
QIcon(os.path.join(pedalboard['bundle'], "thumbnail.png")))
item.setText(pedalboard['title'])
self.ui.listWidget.addItem(item)
self.ui.listWidget.setCurrentRow(0)
self.accepted.connect(self.slot_setSelectedURI)
self.ui.listWidget.doubleClicked.connect(self.accept)
def fillTargetList(self):
""" Change Target List when an other calculation type selected.
"""
self.ui.TargetList.clear()
self.ui.OrderList.clear()
# get target points
targets = get_stations(False, False)
# fill target list widget
known_list = get_known()
if targets is not None:
for target in targets:
item = QListWidgetItem(u"%s (%s:%s)" %
(target[0], target[1], target[2]))
item.setData(Qt.UserRole, target)
if known_list is not None and target[0] in known_list:
itemfont = item.font()
itemfont.setWeight(QFont.Bold)
item.setFont(itemfont)
self.ui.TargetList.addItem(item)
def addContact(self, contact):
if not contact:
self.ui.refreshButton.setEnabled(True)
return
status = ''
if contact.status == Contact.STATUS_ONLINE:
status = u'Online'
status_color = 0x00aa00
elif contact.status == Contact.STATUS_OFFLINE:
status = u'Offline'
status_color = 0xff0000
elif contact.status == Contact.STATUS_AWAY:
status = u'Away'
status_color = 0xffad16
else:
status = u'Unknown'
status_color = 0xaaaaaa
if contact.status_msg:
status += u' — %s' % contact.status_msg
item = QListWidgetItem()
item.setText('<h2>%s</h2><font color="#%06X">%s</font><br /><i>%s</i>' % (contact.name, status_color, status, contact.backend))
item.setData(Qt.UserRole, contact)
if contact.photos is NotLoaded:
process = QtDo(self.weboob, lambda b, c: self.setPhoto(c, item))
process.do('fillobj', contact, ['photos'], backends=contact.backend)
self.photo_processes[contact.id] = process
elif len(contact.photos) > 0:
if not self.setPhoto(contact, item):
photo = contact.photos.values()[0]
process = QtDo(self.weboob, lambda b, p: self.setPhoto(contact, item))
process.do('fillobj', photo, ['thumbnail_data'], backends=contact.backend)
self.photo_processes[contact.id] = process
for i in xrange(self.ui.contactList.count()):
if self.ui.contactList.item(i).data(Qt.UserRole).toPyObject().status > contact.status:
self.ui.contactList.insertItem(i, item)
return
self.ui.contactList.addItem(item)
def createGroupItem(self, name, content = None):
if not content:
group = self.iface.getGroup(name)
localName, icon_path = unicode(group.localName), group.icon
package_count = len(self.state.groupPackages(name))
if package_count <= 0:
return
else:
localName, icon_path = content[0], content[1]
package_count = content[2]
icon = QIcon(KIconLoader().loadIcon(icon_path, KIconLoader.NoGroup, 22))
if icon.isNull():
icon = self.defaultIcon
text = "%s (%d)" % (localName, package_count)
item = QListWidgetItem(icon, text, self)
item.setToolTip(localName)
item.setData(Qt.UserRole, QVariant(unicode(name)))
item.setSizeHint(QSize(0, KIconLoader.SizeMedium))
self._list[name] = item
def show_add_files_dialog(self):
filenames = get_open_file_names(get_main_window(), 'Add Files',
self.last_directory)
if len(filenames) > 0:
self.last_directory = os.path.split(filenames[0])[0]
for filename in filenames:
if len(self.list_files.findItems(filename,
Qt.MatchFixedString)) > 0:
continue
uploads = [Upload(filename, os.path.split(filename)[1])]
item = QListWidgetItem(filename)
item.setData(Qt.UserRole, uploads)
item.setData(Qt.DecorationRole, self.file_icon)
self.list_files.addItem(item)
self.completeChanged.emit()
def set_widgets(self):
"""Set widgets on the LayerMode tab."""
self.clear_further_steps()
# Set widgets
self.lblBandSelector.setText(
tr('Please select which band that contains the data that you want to '
'use for this layer.'))
self.lstBands.clear()
band_num = self.parent.layer.bandCount()
for i in range(band_num):
item = QListWidgetItem(self.parent.layer.bandName(i + 1),
self.lstBands)
item.setData(QtCore.Qt.UserRole, i + 1)
self.lstBands.addItem(item)
existing_band = self.parent.get_existing_keyword('active_band')
if existing_band:
self.lstBands.setCurrentRow(existing_band - 1)
else:
# Set to Band 1 / index 0
self.lstBands.setCurrentRow(0)
def refresh_lists(self, errors, pep8):
self._outRefresh = False
self.listErrors.clear()
self.listPep8.clear()
for lineno in errors.errorsSummary:
linenostr = 'L%s\t' % str(lineno)
for data in errors.errorsSummary[lineno]:
item = QListWidgetItem(linenostr + data)
item.setData(Qt.UserRole, lineno)
self.listErrors.addItem(item)
self.errorsLabel.setText(
self.tr(ERRORS_TEXT).arg(len(errors.errorsSummary)))
for lineno in pep8.pep8checks:
linenostr = 'L%s\t' % str(lineno)
for data in pep8.pep8checks[lineno]:
item = QListWidgetItem(linenostr + data.split('\n')[0])
item.setData(Qt.UserRole, lineno)
self.listPep8.addItem(item)
self.pep8Label.setText(self.tr(PEP8_TEXT).arg(len(pep8.pep8checks)))
self._outRefresh = True
def loadProjectList(self, projects):
self.ui.moduleList.clear()
for project in projects:
if not project.vaild:
continue
item = QListWidgetItem(self.ui.moduleList, QListWidgetItem.UserType)
item.setData(QListWidgetItem.UserType, project)
item.setSizeHint(QSize(200, 200))
projectwidget = ProjectWidget(self.ui.moduleList)
projectwidget.image = QPixmap(project.splash)
projectwidget.name = project.name
projectwidget.description = project.description
projectwidget.version = project.version
# pix = QPixmap(project.splash)
# icon = QIcon(pix.scaled(200,200))
# item.setIcon(icon)
self.ui.moduleList.addItem(item)
self.ui.moduleList.setItemWidget(item, projectwidget)
def __add_gstke(self, filter):
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.ui.LST_GSTKE.clear()
#show them sorted
for gst, props in sorted(self.gstke.iteritems()):
item = None
if gst == 'EXCEPTION':
item = QListWidgetItem(props)
else:
if filter in gst:
item = QListWidgetItem(gst)
item.setData(Qt.UserRole, props)
if props != 'FEHLER':
item.setFlags(item.flags()
| Qt.ItemIsUserCheckable)
#important! won't work otherwise
item.setCheckState(Qt.Unchecked)
if not item is None:
self.ui.LST_GSTKE.addItem(item)
finally:
QApplication.restoreOverrideCursor()
def set_widgets(self):
"""Set widgets on the layer purpose tab."""
self.clear_further_steps()
# Set widgets
self.lstCategories.clear()
self.lblDescribeCategory.setText('')
self.lblIconCategory.setPixmap(QPixmap())
self.lblSelectCategory.setText(category_question %
self.parent.layer.name())
purposes = self.purposes_for_layer()
if self.parent.get_layer_geometry_id() == 'polygon':
purposes += ['aggregation']
for purpose in purposes:
if not isinstance(purpose, dict):
purpose = definition(purpose)
item = QListWidgetItem(purpose['name'], self.lstCategories)
item.setData(QtCore.Qt.UserRole, purpose['key'])
self.lstCategories.addItem(item)
# Check if layer keywords are already assigned
purpose_keyword = self.parent.get_existing_keyword('layer_purpose')
# Overwrite the purpose_keyword if it's KW mode embedded in IFCW mode
if self.parent.parent_step:
purpose_keyword = self.parent.\
get_parent_mode_constraints()[0]['key']
# Set values based on existing keywords or parent mode
if purpose_keyword:
purposes = []
for index in xrange(self.lstCategories.count()):
item = self.lstCategories.item(index)
purposes.append(item.data(QtCore.Qt.UserRole))
if purpose_keyword in purposes:
self.lstCategories.setCurrentRow(
purposes.index(purpose_keyword))
self.auto_select_one_item(self.lstCategories)
def populate_field_list(self, excluded_fields=None):
"""Helper to add field of the layer to the list.
:param excluded_fields: List of field that want to be excluded.
:type excluded_fields: list
"""
# Populate fields list
if excluded_fields is None:
excluded_fields = []
self.field_list.clear()
for field in self.layer.dataProvider().fields():
# Skip if it's excluded
if field.name() in excluded_fields:
continue
# Skip if it's not number (float, int, etc)
if field.type() not in qvariant_numbers:
continue
field_item = QListWidgetItem(self.field_list)
field_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field.name())
field_item.setText(field.name())
self.field_list.addItem(field_item)
def update_field_values(self, field_name, limit=-1):
active_layer = self.get_active_layer()
if not active_layer:
return
data_provider = active_layer.dataProvider()
self.setCursor(Qt.WaitCursor)
field_ind = data_provider.fieldNameIndex(field_name)
field_type = data_provider.fields()[field_ind].typeName()
self.ui.lstValues.clear()
values = data_provider.uniqueValues(field_ind, limit)
for val in values:
new_item = QListWidgetItem()
if field_type in ('String', 'Date'):
new_item.setText("'" + unicode(val) + "'")
new_item.setData(Qt.UserRole, "u'" + unicode(val) + "'")
else:
#TODO: is too long!!!
new_item.setText(unicode(val))
new_item.setData(Qt.UserRole, unicode(val))
self.ui.lstValues.addItem(new_item)
self.unsetCursor()
def _populate_node_list(self, repo_uuid):
"""
Replace the contents of the node list widget
to show all the nodes for the currently selected repo.
"""
self._node_listwidget.clear()
if self._repos_info is None or repo_uuid is None:
return
# For now, we simply show the nodes in sorted order, without respect to dag order
all_uuids = sorted(self._repos_info[repo_uuid]["DAG"]["Nodes"].keys())
for node_uuid in all_uuids:
node_item = QListWidgetItem(node_uuid,
parent=self._node_listwidget)
node_item.setData(Qt.UserRole, node_uuid)
self._current_repo = repo_uuid
# Select the last one by default.
last_row = self._node_listwidget.count() - 1
last_item = self._node_listwidget.item(last_row)
self._node_listwidget.setCurrentItem(last_item)
self._update_status()
def resultitemchanged(self, new_item):
self.IDC_textDetails.setText('')
self.IDC_listRessources.clear()
self.IDC_plainTextLink.clear()
if new_item is None:
return
package = new_item.data(Qt.UserRole)
self.cur_package = package
if package is None:
return
self.IDC_textDetails.setText(u'{0}\n\n{1}\n{2}\n\n{3}'.format(
package.get('notes', 'no notes'),
package.get('author', 'no author'),
package.get('author_email', 'no author_email'),
package.get('license_id', 'no license_id')))
if package.get('num_resources', 0) > 0:
for res in package['resources']:
item = QListWidgetItem(u'{0}: {1}'.format(
res.get('format', 'no format'), res.get('name',
'no name')))
item.setData(Qt.UserRole, res)
item.setCheckState(Qt.Unchecked)
self.IDC_listRessources.addItem(item)
def set_widgets(self):
"""Set widgets on the Subcategory tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
self.lstSubcategories.clear()
self.lblDescribeSubcategory.setText('')
self.lblIconSubcategory.setPixmap(QPixmap())
self.lblSelectSubcategory.setText(
get_question_text('%s_question' % purpose['key']))
for i in self.subcategories_for_layer():
# noinspection PyTypeChecker
item = QListWidgetItem(i['name'], self.lstSubcategories)
# noinspection PyTypeChecker
item.setData(QtCore.Qt.UserRole, i['key'])
self.lstSubcategories.addItem(item)
# Check if layer keywords are already assigned
key = self.parent.step_kw_purpose.selected_purpose()['key']
keyword = self.parent.get_existing_keyword(key)
# Overwrite the keyword if it's KW mode embedded in IFCW mode
if self.parent.parent_step:
keyword = self.parent.get_parent_mode_constraints()[1]['key']
# Set values based on existing keywords or parent mode
if keyword:
subcategories = []
for index in xrange(self.lstSubcategories.count()):
item = self.lstSubcategories.item(index)
subcategories.append(item.data(QtCore.Qt.UserRole))
if keyword in subcategories:
self.lstSubcategories.setCurrentRow(
subcategories.index(keyword))
self.auto_select_one_item(self.lstSubcategories)
def window_loaded(self):
try:
self.util.msg_log('window_loaded')
self.util.msg_log('before stop')
self.timer.stop()
self.timer = None
self.util.msg_log('before get_groupds')
ok, result = self.cc.get_groups()
if ok is False:
QApplication.restoreOverrideCursor()
self.util.dlg_warning(result)
return
if not result:
self.list_all_clicked()
else:
for entry in result:
item = QListWidgetItem(entry['display_name'])
item.setData(Qt.UserRole, entry)
#item.setCheckState(Qt.Checked)
item.setCheckState(Qt.Unchecked)
self.IDC_listGroup.addItem(item)
finally:
QApplication.restoreOverrideCursor()
def set_widgets(self):
"""Set widgets on the Unit tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
self.lblSelectUnit.setText(
unit_question % (subcategory['name'], purpose['name']))
self.lblDescribeUnit.setText('')
self.lstUnits.clear()
subcat = self.parent.step_kw_subcategory.selected_subcategory()['key']
if purpose == layer_purpose_hazard:
units_for_layer = hazard_units(subcat)
else:
units_for_layer = exposure_units(subcat)
for unit_for_layer in units_for_layer:
item = QListWidgetItem(unit_for_layer['name'], self.lstUnits)
item.setData(QtCore.Qt.UserRole, unit_for_layer['key'])
self.lstUnits.addItem(item)
# Set values based on existing keywords (if already assigned)
if self.parent.step_kw_purpose.\
selected_purpose() == layer_purpose_hazard:
key = continuous_hazard_unit['key']
else:
key = exposure_unit['key']
unit_id = self.parent.get_existing_keyword(key)
if unit_id:
units = []
for index in xrange(self.lstUnits.count()):
item = self.lstUnits.item(index)
units.append(item.data(QtCore.Qt.UserRole))
if unit_id in units:
self.lstUnits.setCurrentRow(units.index(unit_id))
self.auto_select_one_item(self.lstUnits)
def _add_layer_clicked(self):
"""Add layer clicked."""
layer = self.tree.selectedItems()[0]
origin = layer.data(0, LAYER_ORIGIN_ROLE)
if origin == FROM_ANALYSIS['key']:
parent = layer.data(0, LAYER_PARENT_ANALYSIS_ROLE)
key = layer.data(0, LAYER_PURPOSE_KEY_OR_ID_ROLE)
item = QListWidgetItem('%s - %s' % (layer.text(0), parent))
item.setData(LAYER_PARENT_ANALYSIS_ROLE, parent)
item.setData(LAYER_PURPOSE_KEY_OR_ID_ROLE, key)
else:
item = QListWidgetItem(layer.text(0))
layer_id = layer.data(0, LAYER_PURPOSE_KEY_OR_ID_ROLE)
item.setData(LAYER_PURPOSE_KEY_OR_ID_ROLE, layer_id)
item.setData(LAYER_ORIGIN_ROLE, origin)
self.list_layers_in_map_report.addItem(item)
self.tree.invisibleRootItem().removeChild(layer)
self.tree.clearSelection()
def set_widgets(self):
"""Set all widgets on the tab."""
self.project = self.parent.project['information']
self.update_status_label.setText('')
self.project_name_text.setText(self.project['name'])
if self.project['urls']:
self.project_url_text.setText(self.project['urls'][0])
else:
self.project_url_text.setText('')
self.project_desc_text.setText(self.project['description'])
if self.project['access'] == 'private':
private_access = True
else:
private_access = False
self.access_checkbox.setChecked(private_access)
contacts = Contact.get_rows()
project_contacts = self.project['contacts']
self.project_contact_list.clear()
self.project_contact_list.setSelectionMode(
QAbstractItemView.ExtendedSelection)
# From local db
for contact in contacts:
contact_name = contact.name
contact_email = ' - ' + contact.email if contact.email else ''
contact_phone = ' - ' + contact.phone if contact.phone else ''
contact_item = QListWidgetItem(contact_name + contact_email +
contact_phone)
contact_item.setData(Qt.UserRole, contact)
self.project_contact_list.addItem(contact_item)
# From server
for index, contact in enumerate(project_contacts):
contact_name = contact['name']
contact_email = ' - ' + contact['email'] \
if 'email' in contact and contact['email'] else ''
contact_phone = ' - ' + contact['tel'] \
if 'tel' in contact and contact['tel'] else ''
contact_box = self.project_contact_list.findItems(
contact_name + contact_email + contact_phone, Qt.MatchExactly)
if len(contact_box) > 0:
contact_box[0].setSelected(True)
else:
new_contact = Contact()
new_contact.name = contact['name']
new_contact.email = contact['email']
new_contact.phone = contact['tel']
new_contact.save()
selected_item = QListWidgetItem(contact_name + contact_email +
contact_phone)
selected_item.setData(Qt.UserRole, new_contact)
self.project_contact_list.addItem(selected_item)
selected_item.setSelected(True)
self.project_name_text.setFocus()
self.project_desc_text.setTabChangesFocus(True)
def populate_classified_values(
unassigned_values, assigned_values, default_classes,
list_unique_values, tree_mapping_widget):
"""Populate lstUniqueValues and treeClasses.from the parameters.
:param unassigned_values: List of values that haven't been assigned
to a class. It will be put in list_unique_values.
:type unassigned_values: list
:param assigned_values: Dictionary with class as the key and list of
value as the value of the dictionary. It will be put in
tree_mapping_widget.
:type assigned_values: dict
:param default_classes: Default classes from unit.
:type default_classes: list
:param list_unique_values: List Widget for unique values
:type list_unique_values: QListWidget
:param tree_mapping_widget: Tree Widget for classifying.
:type tree_mapping_widget: QTreeWidget
"""
# Populate the unique values list
list_unique_values.clear()
list_unique_values.setSelectionMode(
QAbstractItemView.ExtendedSelection)
for value in unassigned_values:
value_as_string = value is not None and unicode(value) or 'NULL'
list_item = QListWidgetItem(list_unique_values)
list_item.setFlags(
Qt.ItemIsEnabled |
Qt.ItemIsSelectable |
Qt.ItemIsDragEnabled)
list_item.setData(Qt.UserRole, value)
list_item.setText(value_as_string)
list_unique_values.addItem(list_item)
# Populate assigned values tree
tree_mapping_widget.clear()
bold_font = QFont()
bold_font.setItalic(True)
bold_font.setBold(True)
bold_font.setWeight(75)
tree_mapping_widget.invisibleRootItem().setFlags(
Qt.ItemIsEnabled)
for default_class in default_classes:
# Create branch for class
tree_branch = QTreeWidgetItem(tree_mapping_widget)
tree_branch.setFlags(
Qt.ItemIsDropEnabled | Qt.ItemIsEnabled)
tree_branch.setExpanded(True)
tree_branch.setFont(0, bold_font)
if 'name' in default_class:
default_class_name = default_class['name']
else:
default_class_name = default_class['key']
tree_branch.setText(0, default_class_name)
tree_branch.setData(0, Qt.UserRole, default_class['key'])
if 'description' in default_class:
tree_branch.setToolTip(0, default_class['description'])
# Assign known values
for value in assigned_values[default_class['key']]:
string_value = value is not None and unicode(value) or 'NULL'
tree_leaf = QTreeWidgetItem(tree_branch)
tree_leaf.setFlags(
Qt.ItemIsEnabled |
Qt.ItemIsSelectable |
Qt.ItemIsDragEnabled)
tree_leaf.setData(0, Qt.UserRole, value)
tree_leaf.setText(0, string_value)
def make_list_widget(self, item):
n = item.name if item.exists else item.name + _(' (not on any book)')
w = QListWidgetItem(item.icon, n)
w.setData(Qt.UserRole, item.index)
w.setToolTip(_('Category lookup name: ') + item.label)
return w
def buildCityItem(self, city):
item = QListWidgetItem()
item.setText('<b>%s</b> (%s)' % (city.name, city.backend))
item.setData(Qt.UserRole, city)
return item
def insertCity(self, i):
item = QListWidgetItem()
item.setText(i.text())
item.setData(Qt.UserRole, i.data(Qt.UserRole))
self.ui.citiesList.addItem(item)
