def fill_listing(self):
playlists = self.controller.model().get_playlist_ids(self.kind)
self.lst_lists.clear()
for name, pid in playlists.items():
item = QListWidgetItem(name, self.lst_lists)
item.playlist_id = pid # For click callback.
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 createCellWidget(self, qmlDict, attr, count):
"""
Creates specific widgets for each attribute, which can be a QCombobox, a QLineEdit or a QListWidget.
"""
if attr in qmlDict.keys():
enableIgnoreOption = False
#case the type is dict the cell widget must be a combobox
if isinstance(qmlDict[attr],dict):
comboItem = DsgCustomComboBox()
comboItem.addItems(sorted(qmlDict[attr].keys()))
self.attributeTableWidget.setCellWidget(count, 1, comboItem)
#case the type is tuple the cell widget must be a listwidget
if isinstance(qmlDict[attr],tuple):
(table, filterKeys) = qmlDict[attr]
#getting the value relation dictionary used to make the listwidget
valueRelation = self.makeValueRelationDict(table, filterKeys)
list = QListWidget()
for key in valueRelation.keys():
listItem = QListWidgetItem(key)
listItem.setCheckState(Qt.Unchecked)
list.addItem(listItem)
self.attributeTableWidget.setCellWidget(count, 1, list)
#this is the normal case, a simple lineedit
else:
textItem = QLineEdit()
self.attributeTableWidget.setCellWidget(count, 1, textItem)
enableIgnoreOption = True
#insert here aditional parameters
self.createAditionalParameters(count, enableIgnoreOption)
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 _update_pyqt_object_from_config(self, obj, config_data, index=None):
if index:
obj = obj[index]
if type(obj) == QPushButton: # QPushButton
obj.setText(config_data[0])
obj.setStyleSheet(config_data[1])
# return obj
elif hasattr(obj, 'isChecked'): # [QCheckBox,QRadioButton]:
obj.setChecked(config_data[0])
elif hasattr(obj, 'text'): # QLabel, QLineEdit
obj.setText(config_data[0])
# return obj
elif hasattr(obj, 'count') and hasattr(obj, 'itemText') and hasattr(obj,
'currentIndex'): # QComboBox
obj.clear()
obj.addItems(config_data[0])
obj.setCurrentIndex(config_data[1])
# return obj
elif hasattr(obj, 'count') and hasattr(obj,
'selectedIndexes'): #
# QListWidget
# removing old items
obj.clear()
for itemlabel in config_data[0]:
item = QListWidgetItem()
item.setText(itemlabel)
obj.addItem(item)
for itemid in range(obj.count()):
if itemid in config_data[1]:
obj.item(itemid).setSelected(True)
else:
obj.item(itemid).setSelected(False)
def __init__(self, workspace, documents):
super(_UISaveFiles, self).__init__(workspace)
self.cancelled = False
uic.loadUi(os.path.join(DATA_FILES_PATH, 'ui/SaveFiles.ui'), self)
self.buttonBox.clicked.connect(self._onButtonClicked)
self._itemToDocument = {}
for document in documents:
name = document.fileName()
if name is None:
name = 'untitled'
item = QListWidgetItem( name, self.listWidget )
if document.filePath() is not None:
item.setToolTip( document.filePath() )
item.setCheckState( Qt.Checked )
self._itemToDocument[item] = document
# Retitle buttons, add first letter shortcuts for them.
bb = self.buttonBox
self._shortcut = (
self._firstLetterShortcut(bb.Discard, 'close &Without saving'),
self._firstLetterShortcut(bb.Cancel, '&Cancel close'),
self._firstLetterShortcut(bb.Save, '&Save checked') )
self.buttonBox.button(QDialogButtonBox.Cancel).setFocus()
def __init__(self, main):
QListWidget.__init__(self)
self.setStyleSheet("""
WebPluginList {
color: black;
background-color: white;
selection-color: blue;
border-radius: 10px;
selection-background-color: #437DCD;
}
WebPluginList:Item {
border-radius: 10px;
border-style: solid;
background-color: white;
}
WebPluginList:Item:hover {
border-radius: 10px;
border-style: solid;
background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #FAFBFE, stop: 1 #6181E0);
}""")
self.connect(self, SIGNAL("itemSelectionChanged()"), self.openSelected)
self._main = main
settings = QSettings()
i = 1
for recent_project in settings.value('recentProjects', []).toStringList():
if manage_files.folder_exists(str(recent_project)):
item = QListWidgetItem(str(recent_project.split('/')[-1]))
item.setToolTip(recent_project)
item.setIcon(QIcon(resources.images['tree-app']))
self.addItem(item)
i = i + 1
if i == 10:
break
def fileProcessed(self, path, rv):
if isinstance(rv, Exception):
try:
raise rv
except IOError as exc:
if exc.errno == errno.ENOENT:
msg = "ERROR: File doesn't exist"
else:
msg = "ERROR: %s" % os.strerror(exc.errno)
except UnicodeDecodeError:
msg = "ERROR: Cannot read file using %s encoding" % self.processor.input_encoding
except UnicodeEncodeError:
msg = "ERROR: Cannot write file using %s encoding (try setting output encoding to UTF-8)" % self.processor.output_encoding
except pysubs2.FormatAutodetectionError:
msg = "ERROR: Unknown subtitle format (malformed file?)"
except Exception as exc:
msg = "ERROR: %r" % exc
else:
msg = None
self.processed_ok += 1
self.processed += 1
self.progressBar.setValue(self.progressBar.value() + 1)
if msg:
item = QListWidgetItem(msg)
item.setForeground(QColor("darkred" if msg.startswith("ERROR") else "darkgreen"))
self.logList.addItem(item)
scroll_to_bottom(self.logList)
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 __init__(self, workspace, documents):
super(_UISaveFiles, self).__init__(workspace)
self.cancelled = False
uic.loadUi(os.path.join(DATA_FILES_PATH, 'ui/SaveFiles.ui'), self)
self.buttonBox.clicked.connect(self._onButtonClicked)
self._itemToDocument = {}
for document in documents:
name = document.fileName()
if name is None:
name = 'untitled'
item = QListWidgetItem( name, self.listWidget )
if document.filePath() is not None:
item.setToolTip( document.filePath() )
item.setCheckState( Qt.Checked )
self._itemToDocument[item] = document
self.buttonBox.button(self.buttonBox.Discard).setText(self.tr('close &Without saving'))
self.buttonBox.button(self.buttonBox.Cancel).setText(self.tr('&Cancel close'))
self.buttonBox.button(self.buttonBox.Save).setText(self.tr('&Save checked'))
# Provide first-letter only shortcuts (not Alt+first letter which is
# already present because of the & before letters) for each button.
self.shortcut = []
for letter, button in (("W", self.buttonBox.Discard),
("C", self.buttonBox.Cancel),
("S", self.buttonBox.Save)):
shortcut = QShortcut(QKeySequence(letter), self)
shortcut.activated.connect(self.buttonBox.button(button).click)
self.shortcut.append(shortcut)
self.buttonBox.button(QDialogButtonBox.Cancel).setFocus()
def __init__(self, mainwin, pdfs):
KDialog.__init__(self, mainwin)
self.mainwin = mainwin
self.setAttribute(Qt.WA_DeleteOnClose)
self.setButtons(KDialog.ButtonCode(
KDialog.User1 | KDialog.Ok | KDialog.Cancel))
self.setButtonGuiItem(KDialog.Ok, KStandardGuiItem.print_())
self.setButtonIcon(KDialog.User1, KIcon("edit-select-all"))
self.setButtonText(KDialog.User1, i18n("Select all"))
self.setCaption(i18n("Print documents"))
b = KVBox(self)
b.setSpacing(4)
QLabel(i18n("Please select the files you want to print:"), b)
fileList = QListWidget(b)
fileList.setIconSize(QSize(22, 22))
fileList.setWhatsThis(i18n(
"These are the PDF documents that are up-to-date (i.e. newer than "
"the LilyPond source document). "
"Check the documents you want to send to the printer."))
for pdf in pdfs:
i = QListWidgetItem(KIcon("application-pdf"), os.path.basename(pdf),
fileList)
i.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable)
i.setCheckState(Qt.Unchecked)
fileList.item(0).setCheckState(Qt.Checked)
self.fileList = fileList
self.setMainWidget(b)
self.resize(350, 200)
self.pdfs = pdfs
self.user1Clicked.connect(self.selectAll)
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, 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 updateList(self, visualizations):
self.ui.tablesList.clear()
for visualization in visualizations:
item = QListWidgetItem(self.ui.tablesList)
owner = None
owner = visualization['permission']['owner']['username']
widget = CartoDBDatasetsListItem(
visualization['name'], owner, visualization['table']['size'], visualization['table']['row_count'],
shared=(owner != self.currentUser), multiuser=self.currentMultiuser)
# item.setText(visualization['name'])
readonly = False
# qDebug('Vis:' + json.dumps(visualization, sort_keys=True, indent=2, separators=(',', ': ')))
if visualization['permission'] is not None and owner != self.currentUser and \
visualization['permission']['acl'] is not None:
for acl in visualization['permission']['acl']:
if acl['type'] == 'user' and 'username' in acl['entity'] and acl['entity']['username'] == self.currentUser and \
acl['access'] == 'r':
readonly = True
break
widget.readonly = readonly
if readonly:
widget.setTextColor('#999999')
item.setSizeHint(widget.sizeHint())
# item.setIcon(QIcon(":/plugins/qgis-cartodb/images/icons/layers.png"))
self.ui.tablesList.setItemWidget(item, widget)
def add_item_list(self, items):
if not self.isVisible():
self.show()
for i in items:
item = QListWidgetItem(i)
item.setTextAlignment(Qt.AlignHCenter)
self._list_widget.addItem(item)
def popularListaAlimentos(self):
self.alimentos = {}
#busca todos os arquivos
for root, dirs, files in os.walk(MY_DIR_ALIMENTO):
#para cada arquivo
for f in files:
#pega o arquivo, carrega e fecha
arq = file(MY_DIR_ALIMENTO + f)
alim = pickle.load(arq)
arq.close()
#adiciona o item na lista de alimento
self.alimentos[str(alim.nome)] = alim
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(alim.imagem), QtGui.QIcon.Normal, QtGui.QIcon.Off)
item = QListWidgetItem()
item.setIcon(icon)
item.setText(alim.nome)
self.listaAlimentos.addItem(item)
def __init__(self, data, parent=None):
self.data = data
if isinstance(data, Species):
text = data.name
self.amounts_index = data.index
elif isinstance(data, Compartment):
text = data.compartment_name_and_xy_coords()
self.amounts_index = data.index
elif isinstance(data, Run):
text = "%s" % (data._run_number)
self.amounts_index = data._run_number - 1
# elif isinstance(data, Simulation):
# text = "%s %s" % (data.model_input_file, data.simulation_start_time)
# self.amounts_index = None
else:
raise TypeError("type of data is not recognised")
QListWidgetItem.__init__(self, text, parent, QListWidgetItem.UserType) # QObject::startTimer: QTimer can only be used with threads started with QThread
if isinstance(self.amounts_index, int):
self.setToolTip('%d' % self.amounts_index)
def __init__(self, iface, toolbar, parent=None):
CartoDBPluginUserDialog.__init__(self, toolbar, parent)
self.iface = iface
self.ui = Ui_Upload()
self.ui.setupUi(self)
self.ui.bar = QgsMessageBar()
self.ui.bar.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.ui.verticalLayout.insertWidget(0, self.ui.bar)
self.ui.uploadBT.clicked.connect(self.upload)
self.ui.cancelBT.clicked.connect(self.reject)
self.ui.layersList.itemSelectionChanged.connect(self.validateButtons)
layers = QgsMapLayerRegistry.instance().mapLayers()
# TODO Implement add to project
# self.ui.convertCH.hide()
self.ui.overideCH.hide()
self.ui.layersList.clear()
self.ui.uploadBar.setValue(0)
self.ui.uploadBar.hide()
self.ui.uploadingLB.hide()
for id_ly, ly in layers.iteritems():
qDebug('Layer id {}'.format(stripAccents(id_ly)))
if ly.type() == QgsMapLayer.VectorLayer and not isinstance(ly, CartoDBLayer):
item = QListWidgetItem(self.ui.layersList)
widget = CartoDBLayerListItem(ly.name(), ly, getSize(ly), ly.dataProvider().featureCount())
item.setSizeHint(widget.sizeHint())
self.ui.layersList.setItemWidget(item, widget)
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 __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 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, toolbar, parent=None):
QDialog.__init__(self, parent)
self.toolbar = toolbar
self.settings = QSettings()
self.ui = Ui_Upload()
self.ui.setupUi(self)
self.ui.uploadBT.clicked.connect(self.upload)
self.ui.cancelBT.clicked.connect(self.reject)
self.currentUser = self.toolbar.currentUser
self.currentApiKey = self.toolbar.currentApiKey
self.currentMultiuser = self.toolbar.currentMultiuser
layers = QgsMapLayerRegistry.instance().mapLayers()
self.ui.layersList.clear()
self.ui.uploadBar.setValue(0)
self.ui.uploadBar.hide()
self.ui.uploadingLB.hide()
for id, ly in layers.iteritems():
if ly.type() == QgsMapLayer.VectorLayer and not isinstance(ly, CartoDBLayer):
item = QListWidgetItem(self.ui.layersList)
widget = CartoDBLayerListItem(ly.name(), ly, self.getSize(ly), ly.dataProvider().featureCount())
item.setSizeHint(widget.sizeHint())
self.ui.layersList.setItemWidget(item, widget)
worker = CartoDBPluginWorker(self, 'connectUser')
worker.start()
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 on_OpenPlaylist_clicked(self):
"""
Load and parse a .pla.refs file
"""
self.playlistname = toPython(QFileDialog.getOpenFileName(\
None,
self.trUtf8("Select playlist to edit"),
self.playlistname,
self.trUtf8("*.pla"),
None))
if self.playlistname:
unicodeplaylist = toPython(self.playlistname)
prefix = mountpoint(unicodeplaylist)
if os.name == 'nt':
prefix = prefix + "\\"
PL = open(self.playlistname + ".refs", "r")
self.playlistWidget.clear()
for song in PL.readlines():
song = toPython(QString(song))
song = song.strip()
pcsong = prefix + song[7:]
cover = os.path.join(os.path.split(pcsong)[0], "folder.jpg")
listItem = QListWidgetItem(song)
if os.path.isfile(cover):
listItem.setIcon(QIcon(cover))
print "Loading " + cover
else:
print "Album art'" + cover +" not found"
self.playlistWidget.addItem(listItem)
PL.close()
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 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 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 __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 __init__(self, text, parent=None, italic=False):
QListWidgetItem.__init__(self, text, parent)
font = self.font()
font.setPointSize(10)
if italic:
font.setItalic(True)
self.setFont(font)
self.clickeable = False
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 add_list_items(self, proposals):
self.completion_list.clear()
for p in proposals:
self.completion_list.addItem(
QListWidgetItem(QIcon(
self._icons.get(p[0], resources.IMAGES['attribute'])),
p[1],
type=ord(p[0])))
def populateAreaList(self):
'''
Populate the area ID listbox
'''
[
self.lstAreas.addItem(QListWidgetItem(str(intOrString(label))))
for label in self.model.getOutputAreaIDs()
]
def loadModules(self):
self.ui.modulesList.clear()
for name, module in sorted(
self.weboob.repositories.get_all_modules_info(
self.caps).iteritems()):
item = QListWidgetItem(name.capitalize())
self.set_icon(item, module)
self.ui.modulesList.addItem(item)
def FillSurveys(self):
self.AS = AllSurveys(self.ODB)
FullName = self.AS.GetCombo()
for fn in FullName:
item = QListWidgetItem(fn)
self.AvailSurveys.addItem(item)
self.AvailSurveys.setSelectionMode(
QtGui.QAbstractItemView.MultiSelection)
def add_last_used_services(self):
services = CachedServices().get_cached_services()
if len(services) == 0:
return
self.lstSearchResult.insertItem(0, self.tr("Last used:"))
# l = QLabel(self.tr("Last used:"))
# l.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
# self.lSearchResult.addWidget(l)
for attributes, image_qByteArray in services:
custom_widget = QmsSearchResultItemWidget(attributes,
image_qByteArray)
new_item = QListWidgetItem(self.lstSearchResult)
new_item.setSizeHint(custom_widget.sizeHint())
self.lstSearchResult.addItem(new_item)
self.lstSearchResult.setItemWidget(new_item, custom_widget)
def uncommit(self):
path = self.plugin.editor.get_project_owner()
for pos in reversed(xrange(self.added_files.count())):
item = self.added_files.item(pos)
widget = self.added_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, str(widget.text()))
self.added_files.removeItemWidget(item)
self.added_files.takeItem(pos)
item = QListWidgetItem()
self.untracked_files.addItem(item)
check_box = QCheckBox(text)
self.untracked_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.s_modified_files.count())):
item = self.s_modified_files.item(pos)
widget = self.s_modified_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, widget.text())
self.s_modified_files.removeItemWidget(item)
self.s_modified_files.takeItem(pos)
item = QListWidgetItem()
self.modified_files.addItem(item)
check_box = QCheckBox(text)
self.modified_files.setItemWidget(item, check_box)
for pos in reversed(xrange(self.s_deleted_files.count())):
item = self.s_deleted_files.item(pos)
widget = self.s_deleted_files.itemWidget(item)
text = widget.text()
if widget.isChecked():
self.git.uncommit(path, widget.text())
self.s_deleted_files.removeItemWidget(item)
self.s_deleted_files.takeItem(pos)
item = QListWidgetItem()
self.deleted_files.addItem(item)
check_box = QCheckBox(text)
self.deleted_files.setItemWidget(item, check_box)
def load_data_list(self):
folder_path = Path(CONF.data_root) / \
CONF.current_survey / "Seismics"
for name in get_data_files(folder_path):
new_item = QListWidgetItem(name, self.data_list_Widget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def populate_well_listWidget(self):
survey_file = CONF.survey_dir / '.survey'
if survey_file.exists():
for name in get_data_files(CONF.well_dir):
new_item = QListWidgetItem(name, self.wells_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def updateOrder(self):
self.listbox.clear()
self.macros = self.loadMacros()
cparser = PuddleConfig()
to_check = cparser.get('actions', 'checked', [])
for i, m in sorted(self.macros.items()):
func_name = m.name
item = QListWidgetItem(func_name)
item.setFlags(item.flags() | Qt.ItemIsEditable)
if func_name in to_check:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.listbox.addItem(item)
def setupPluginList(self, pluginList):
"""setup plugin list from configuration file"""
fts = ConfManager.getManager().getValue('common', 'plugins')
i = 0
for ft in fts:
flistItem = QListWidgetItem(QIcon('icon/plugin.png'), ft['name'],
pluginList)
pluginList.insertItem(i, flistItem)
i += 1
def setupFolderList(self, folderList):
"""setup folder list for showing"""
fts = ConfManager.getManager().getValue('common', 'folders')
i = 0
for ft in fts:
flistItem = QListWidgetItem(QIcon('icon/folder.png'), ft,
folderList)
folderList.insertItem(i, flistItem)
i += 1
def on_operation_commands_add_clicked(self):
tx_packets = dict([ (packet.name, num)
for num, packet in self.instr_cfg.instrument.tx_packets.iteritems() ])
(text, ok) = QInputDialog.getItem(\
self,
self.trUtf8("Add operation command"),
self.trUtf8("Select command to send:"),
tx_packets.keys(),
0, False)
if ok and text:
cmd_num = tx_packets[str(text)]
command = self.instr_cfg.add_operation_command(cmd_num)
item = QListWidgetItem(str(cmd_num))
item.cmd = command
self.operation_commands_list.addItem(item)
self.operation_commands_list.setCurrentItem(item)
def __init__(self):
QMainWindow.__init__(self)
# finger scrolling effect
self.charm = FlickCharm() # make instance (in QMainwindow as parent)
self.listwidget = QListWidget()
self.setCentralWidget(self.listwidget)
#populate ListWidget with a set of Items...
for i in range(1000):
newItem = QListWidgetItem(
self.listwidget
) # create new ListWidgetItem (parent= ListWidget)
newItem.setText("This is entry no {0}".format(i))
#self.m_firstColor.append(newItem)
self.charm.activateOn(self.listwidget) # activate on widget
def add_file(self, f):
item = QListWidgetItem(f)
self.ui.listWidgetFiles.addItem(item)
#the following happens multiple times if you open multiple files, but who cares
self.ui.actionAdd_Comment.setEnabled(True)
self.ui.actionAdd_Comment_radius_0.setEnabled(True)
self.ui.actionSave.setEnabled(True)
def addPiece(self, comp):
"""
adds a Component instance,
and returns the QListWidgetItem created
"""
if self.hideItem(comp, False) >= 0: return
blockItem = QListWidgetItem(self)
comp.toListWidgetItem(blockItem)
return blockItem
def show_result(self, geoservice, image_ba):
if geoservice:
custom_widget = QmsSearchResultItemWidget(geoservice, image_ba)
new_item = QListWidgetItem(self.lstSearchResult)
new_item.setSizeHint(custom_widget.sizeHint())
self.lstSearchResult.addItem(new_item)
self.lstSearchResult.setItemWidget(new_item, custom_widget)
# self.lSearchResult.addWidget(custom_widget)
else:
new_item = QListWidgetItem()
new_item.setText(self.tr('No results!'))
new_item.setData(Qt.UserRole, None)
self.lstSearchResult.addItem(new_item)
# l = QLabel(self.tr("No results!"))
# l.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
# self.lSearchResult.addWidget(l)
self.lstSearchResult.update()
def _tabListValue_setup(self):
self.tabListValue_list_values.clear()
self.tabListValue_tx_value.clear()
prop = self.property_selected
if prop == 'geom':
return
property_list = self._get_property(self.resource, prop)
for elem in property_list:
k, v = elem.items()[0]
item = QListWidgetItem()
item.setText(unicode(v))
self.tabListValue_list_values.addItem(item)
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 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:
subcategory_unit_relation = get_question_text(
'%s_%s_question' % (subcategory['key'], unit['key']))
if 'MISSING' in subcategory_unit_relation:
subcategory_unit_relation = self.tr(
'{subcategory} in {unit} unit').format(
subcategory=subcategory['name'].lower(),
unit=unit['plural_name'])
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()
inasafe_field = self.parent.get_existing_keyword('inasafe_fields')
if inasafe_field:
field = inasafe_field.get(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 load_instrument(self, instrument):
self.clear_instrument()
self.instrument = instrument
# base info
self.instrument_name.setText(self.instrument.name)
self.instrument_short_name.setText(self.instrument.short_name)
self.byte_order.setCurrentIndex(self.byte_order.findText(self.instrument.byte_order))
# connection
self.conn_type.setCurrentIndex(self.conn_type.findText(self.instrument.connection.type))
self.load_connection()
# packet format
for i, field in enumerate(self.instrument.packet_format.rx_format):
combo_box = getattr(self, 'pf_rx_format_{0}'.format(i))
combo_box.setCurrentIndex(combo_box.findText(field))
for i, field in enumerate(self.instrument.packet_format.tx_format):
combo_box = getattr(self, 'pf_tx_format_{0}'.format(i))
combo_box.setCurrentIndex(combo_box.findText(field))
for start_byte in self.instrument.packet_format.start_bytes:
item = QListWidgetItem(hex(start_byte))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.pf_start_bytes.addItem(item)
for end_byte in self.instrument.packet_format.end_bytes:
item = QListWidgetItem(hex(end_byte))
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.pf_end_bytes.addItem(item)
# rx packets
for num in self.instrument.rx_packets:
self.rx_packets_list.addItem(str(num))
if self.rx_packets_list.count():
self.rx_packets_list.setCurrentItem(self.rx_packets_list.item(0))
# tx packets
for num in self.instrument.tx_packets:
self.tx_packets_list.addItem(str(num))
if self.tx_packets_list.count():
self.tx_packets_list.setCurrentItem(self.tx_packets_list.item(0))
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 load_data_list(self):
for name in get_data_files(
Path(CONF.data_root, CONF.current_survey, "Seismics")):
# only initialize this way can it be set checkable
new_item = QListWidgetItem(name,
self.control_widget.data_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
def populate_classified_values(self, unassigned_values, assigned_values,
default_classes):
"""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 self.lstUniqueValues.
: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
self.treeClasses.
:type assigned_values: dict
:param default_classes: Default classes from unit.
:type default_classes: list
"""
# Populate the unique values list
self.lstUniqueValues.clear()
self.lstUniqueValues.setSelectionMode(
QAbstractItemView.ExtendedSelection)
for value in unassigned_values:
value_as_string = value is not None and unicode(value) or 'NULL'
list_item = QListWidgetItem(self.lstUniqueValues)
list_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
list_item.setData(Qt.UserRole, value)
list_item.setText(value_as_string)
self.lstUniqueValues.addItem(list_item)
# Populate assigned values tree
self.treeClasses.clear()
self.treeClasses.invisibleRootItem().setFlags(Qt.ItemIsEnabled)
for default_class in default_classes:
# Create branch for class
tree_branch = QTreeWidgetItem(self.treeClasses)
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 data(self, role):
if role == Qt.DisplayRole:
if self.nodesCount :
return QString.fromUtf8(self.__tag.name() + ' (' + str(self.nodesCount) + ')')
else:
return QString.fromUtf8(self.__tag.name())
elif role == Qt.BackgroundRole:
color = self.__tag.color()
return QColor(color.r, color.g, color.b)
return QListWidgetItem.data(self, role)
def FillTranChar(self):
for fieldname in [
'SurveyTitle', 'SubSampleLocation', 'Year', 'StatArea',
'SubArea'
]:
item = QListWidgetItem(fieldname)
self.TransectCharacteristics.addItem(item)
#pdb.set_trace()
self.TransectCharacteristics.setSelectionMode(
QtGui.QAbstractItemView.MultiSelection)
def grabNewData(self):
self.data = self.data.append(self.servThread.newData,
ignore_index=True)
newNames = [
x for x in self.data.columns.values.tolist()
if x not in self.varNames
]
for name in newNames:
self.xAxis.addItem(QListWidgetItem(name))
self.yAxis.addItem(QListWidgetItem(name))
for index in self.servThread.newData['FileNumber']:
self.indexList.addItem(QListWidgetItem(str(index)))
if self.varNames == []:
self.xAxis.setCurrentRow(0)
self.yAxis.setCurrentRow(0)
self.indexList.setCurrentRow(0)
self.plotData()
self.varNames = self.varNames + newNames
self.servThread.newData = pd.DataFrame()
def add_new_item(self, name, project, is_new=False, is_valid=True):
item = QListWidgetItem(self.moduleList, QListWidgetItem.UserType)
item.setData(QListWidgetItem.UserType, project)
item.setSizeHint(QSize(150, 150))
if not is_valid:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
projectwidget = ProjectWidget(self.moduleList, project, is_new=is_new)
projectwidget.install_project.connect(self.projectInstall.emit)
projectwidget.update_project.connect(self.projectUpdate.emit)
projectwidget.setEnabled(is_valid)
self.moduleList.addItem(item)
self.moduleList.setItemWidget(item, projectwidget)
self.projectitems[name] = item
def update_well_listWidget(self):
survey_file = CONF.survey_dir / '.survey'
if survey_file.exists():
dnames = get_data_files(CONF.well_dir)
# self.well_listWidget.addItems(dnames)
for name in dnames:
new_item = QListWidgetItem(name, self.well_listWidget)
new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable)
new_item.setCheckState(Qt.Unchecked)
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)
