def _populateList(self):
"""Get the item selected in the tree, check that it is a folder,
and try to find all files associated with it. The valid files
are then added to the list view in order. The list itself can be
reordered by the user.
"""
tHandle = self.theParent.treeView.getSelectedHandle()
self.sourceItem = tHandle
if tHandle is None:
return
nwItem = self.theProject.projTree[tHandle]
if nwItem is None:
return
if nwItem.itemType is not nwItemType.FOLDER:
self.theParent.makeAlert(
("Element selected in the project tree must be a folder."),
nwAlert.ERROR)
return
for sHandle in self.theParent.treeView.getTreeFromHandle(tHandle):
newItem = QListWidgetItem()
nwItem = self.theProject.projTree[sHandle]
if nwItem.itemType is not nwItemType.FILE:
continue
newItem.setText(nwItem.itemName)
newItem.setData(Qt.UserRole, sHandle)
self.listBox.addItem(newItem)
return
def insert(self, data):
self.result_widget.clear()
for element in data:
list_item = QListWidgetItem(element[1])
list_item.setData(Qt.UserRole, element[0])
self.result_widget.addItem(list_item)
def find_duplicates(self, progress_callback, num_callback):
self.n_copied_list.clear()
if self.media_set is None:
self.media_set = MediaSet(self.dir_path, num_callback)
total = len(self.media_set)
i = 0
for media_file in self.media_set:
i += 1
media_file.metadata.compute_value(SIGNATURE)
progress_callback.emit(int((i * 100) / total))
self.media_set.save_database()
self.duplicates_result = self.media_set.analyze_duplicates_2()
for element in sorted(self.duplicates_result):
item = QListWidgetItem()
item.setText(
"x%s (%s x %s = %s)" %
(str(element), str(len(
self.duplicates_result[element])), str(element),
str(len(self.duplicates_result[element]) * element)))
item.setData(QtCore.Qt.UserRole, element)
self.n_copied_list.addItem(item)
def ui_beika(self):
self.timer.start(900000)
query = "SELECT Id, Name FROM accessories_name WHERE For_Beika = 1"
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
return False
if len(sql_info) == 1:
self.beika_accessories_id = sql_info[0][0]
else:
return False
query = """SELECT Id, Name FROM material_name WHERE For_Beika = 1 ORDER BY Name"""
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
return False
for material in sql_info:
item = QListWidgetItem(material[1])
item.setData(-1, (material[0]))
item.setTextAlignment(Qt.AlignHCenter)
self.lw_material.addItem(item)
self.lw_material.setSpacing(5)
self.sw_main.setCurrentIndex(9)
def _onLanguagesReceived(self, languages):
loc = QLocale.system()
sysLang = QLocale.languageToString(loc.language())
preferredLanguages = self._getPreferredLanguages()
self._langList.clear()
firstCheckedItem = None
for lang in sorted(languages, key=lambda x: x['name']):
langName = lang['name']
langCode = lang['code']
nativeLang = self._getNativeLanguageName(langName)
text = langName
isSystemLang = langName == sysLang
if nativeLang and not isSystemLang:
text += " (" + nativeLang + ")"
item = QListWidgetItem(text)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setData(Qt.UserRole, langCode)
if (preferredLanguages and langCode in preferredLanguages) \
or isSystemLang:
item.setCheckState(Qt.Checked)
firstCheckedItem = item
else:
item.setCheckState(Qt.Unchecked)
self._langList.addItem(item)
self._langList.setMinimumWidth(self._langList.sizeHintForColumn(0))
if firstCheckedItem:
self._langList.scrollToItem(firstCheckedItem)
def __insert_volumes(self, volumes):
# self.volume_icons = []
# volumes = get_storage().fetch_volumes()
# abdig_sort = lambda var: [int(x) if x.isdigit() else x for x in re.findall(r'[^0-9]|[0-9]+', var.name)]
# volumes.sort(key=lambda vnode: vnode.name)
# volumes.sort(key=abdig_sort)
convert = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [
convert(c) for c in re.split(r'([0-9]+)', key.name)
]
volumes.sort(key=alphanum_key)
#
# names = [x.name for x in volumes]
# print(natsorted(names))
for vnode in volumes:
list_item = QListWidgetItem(vnode.name)
# icon = get_volume_icon(vnode.vtype)
list_item.setData(Qt.UserRole + 1, vnode.uuid)
# list_item.setIcon(icon)
# ivolume = volume_icon(vnode.vtype)
# ivolume = ticons.vicon(vnode.vtype)
# self.volume_icons.append(ivolume)
# self.__list.insert('', 'end', vnode.uuid, text=vnode.name, tags=("simple", ), image=ivolume)
# self.__volumes_map[vnode.uuid] = vnode
self.ilist.addItem(list_item)
def addImage(self):
fileName = ""
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setNameFilter("Image Files(*.png *.jpg *.bmp *.gif);;All (*)")
dialog.setWindowTitle("Load Image")
dialog.setOption(QFileDialog.DontUseNativeDialog, True)
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec_():
fileName = dialog.selectedFiles()[0]
del dialog
if not fileName:
return
base = os.path.basename(fileName)
if not os.path.exists(
os.path.join(self.book.source_path, "images", base)):
copy(fileName, os.path.join(self.book.source_path, "images"))
item = QListWidgetItem()
item.setText(Path(fileName).name)
item.setData(
1,
os.path.join(self.book.source_path, "images",
Path(fileName).name))
self.image_list.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 list(classifier_factories.items()):
item = QListWidgetItem(name)
item.setData(Qt.UserRole, 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 loadFromScheduler(self):
# actWhen ComboBox
for row, pair in enumerate(self.scheduler.POSSIBLE_ACTWHENS):
self.comboBox_actWhen.addItem(pair[1])
self.comboBox_actWhen.setItemData(row, pair[0])
self.slotActWhenChanged(self.scheduler.actWhen)
self.comboBox_actWhen.setCurrentIndex(self.scheduler.actWhen)
self.comboBox_actWhen.activated[int].connect(self.slotActWhenChanged)
# tasks list
runningTasks = app.etmpy.runningTasksStat.getTasks()
waitingTaskIds = self.scheduler.waitingTaskIds
for rTaskId, rTask in runningTasks.items():
item = QListWidgetItem(rTask["name"])
item.setData(Qt.UserRole, rTaskId)
self.listWidget_tasks.addItem(item)
# must be set before being added
if rTaskId in waitingTaskIds:
item.setSelected(True)
else:
item.setSelected(False)
# action comboBox
selectedIndex = None
for action in self.scheduler.actions:
if action.command or action.availability == "yes":
self.comboBox_action.addItem(action.displayName)
row = self.comboBox_action.count() - 1
self.comboBox_action.setItemData(row, action.actionId)
if self.scheduler.actionId == action.actionId:
selectedIndex = row
self.comboBox_action.setCurrentIndex(selectedIndex)
def __init__(self, *args, **kwargs):
super(DeliveryAdmin, self).__init__(*args, **kwargs)
# 添加菜单(menu_id为stacked_widget的索引)
for menu_item in [
{
"menu_id": "0",
"menu_name": "仓库编号"
},
{
"menu_id": "1",
"menu_name": "仓库管理"
},
{
"menu_id": "2",
"menu_name": "品种交割信息"
},
]:
item = QListWidgetItem(menu_item["menu_name"])
item.setData(Qt.UserRole, menu_item["menu_id"])
self.menu_list.addItem(item)
# 创建stacked_widget加入
self.warehouse_number_widget = WarehouseNumber(self)
self.stacked_frame.addWidget(self.warehouse_number_widget)
self.warehouse_manger_widget = WarehouseManagerUI(self)
self.stacked_frame.addWidget(self.warehouse_manger_widget)
self.menu_list.itemClicked.connect(self.select_manager_menu)
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 list(classifier_factories.items()):
item = QListWidgetItem( name )
item.setData( Qt.UserRole, 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 __update_list(self):
self.__list_main.clear()
for text, obj in self.__item_list:
item = QListWidgetItem()
item.setText(text)
item.setData(Qt.UserRole, obj)
self.__list_main.addItem(item)
def load_mods(self, mods=[]):
"""
Load mods into the list
:param mods:
:return:
"""
self.listOfMods.clear()
for m in self.get_available_mods():
item = QListWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
# set used mods as active
if m['path'] in mods:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setText(m['name'])
item.setData(Qt.UserRole, m['path'])
# set background for the outdated mods
if not m['version'].startswith(self.app.game_version['release']):
item.setText('{} *OUTDATED*'.format(item.text()))
item.setBackground(QColor('red'))
self.listOfMods.addItem(item)
self.listOfMods.sortItems(Qt.AscendingOrder)
def ui_beika(self):
self.timer.start(900000)
query = "SELECT Id, Name FROM accessories_name WHERE For_Beika = 1"
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
return False
if len(sql_info) == 1:
self.beika_accessories_id = sql_info[0][0]
else:
return False
query = """SELECT Id, Name FROM material_name WHERE For_Beika = 1 ORDER BY Name"""
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
return False
for material in sql_info:
item = QListWidgetItem(material[1])
item.setData(-1, (material[0]))
item.setTextAlignment(Qt.AlignHCenter)
self.lw_material.addItem(item)
self.lw_material.setSpacing(5)
self.sw_main.setCurrentIndex(9)
def add_oar_with_name(self, voi, voi_name):
oar_item = QListWidgetItem()
oar_item.setText(voi_name)
oar_item.setData(Qt.UserRole, voi)
oar_item.setCheckState(Qt.Unchecked)
self.ui.OAR_listWidget.addItem(oar_item)
def addPiece(self, pixmap, location):
pieceItem = QListWidgetItem(self)
pieceItem.setIcon(QIcon(pixmap))
pieceItem.setData(Qt.UserRole, pixmap)
pieceItem.setData(Qt.UserRole + 1, location)
pieceItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
def __init__(self, instruments, track_params, set_params, parent=None):
super(EditParameterGUI, self).__init__(parent)
self.parent = parent
self.instruments = instruments
self.ui = Ui_editParameter()
self.ui.setupUi(self)
self.make_connections()
self.new_track_params = {}
self.new_set_params = {}
for name, dev in self.instruments.items():
self.ui.instrumentBox.addItem(name, dev)
for name, p in track_params.items():
listitem = QListWidgetItem(p.full_name)
listitem.setData(32, p)
self.ui.followParamsWidget.addItem(listitem)
self.new_track_params[p.full_name] = p
for name, p in set_params.items():
listitem = QListWidgetItem(p.full_name)
listitem.setData(32, p)
self.ui.setParamsWidget.addItem(listitem)
self.new_set_params[p.full_name] = p
self.update_avail_instrument_params(0)
self.show()
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 loadStatusChanged(self, status):
if status == 1:
self.book = self.component.create()
if self.book is not None:
self.book.setFilename(self.last_book)
self.book.setWindow(self)
else:
for error in self.component.errors():
print(error.toString())
return
self.content_list.clear()
for part in self.book.parts:
item = QListWidgetItem()
item.setText(part.name)
item.setData(1, part)
self.content_list.addItem(item)
self.loadImages()
self.setWindowTitle(QCoreApplication.applicationName() + " - " + self.book.name)
self.content.setExpanded(True)
self.content_list.setCurrentRow(0)
elif status == 3:
for error in self.component.errors():
print(error.toString())
return
def createListWidget(self):
listWidget = QListWidget()
w, h = self.ITEM_SIZE
scroll_size = 16
listWidget.setFixedWidth(w + scroll_size)
listWidget.setAttribute(Qt.WA_MacShowFocusRect, False)
for x in xrange(self._min_size, self._max_size):
h = max(x + self.MARGIN * 2.0, h)
pixmap = QPixmap(w, h)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
center = h / 2.0
painter.fillRect(QRectF(self.MARGIN, center - x / 2.0,
w - self.MARGIN * 2.0, x), Qt.black)
painter.end()
label = QLabel()
label.setPixmap(pixmap)
item = QListWidgetItem(listWidget)
item.setSizeHint(QSize(w, h))
item.setData(Qt.UserRole, x)
listWidget.addItem(item)
listWidget.setItemWidget(item, label)
if self._size == x:
listWidget.setCurrentItem(item)
return listWidget
def fill(self, items, get_name: Callable, get_color: Callable = None):
self._ui.clear()
self._items.clear()
for item in items:
name = get_name(item)
q_item = QListWidgetItem(name)
if get_color:
size = 13
image = np.full(shape=(size, size, 3),
fill_value=get_color(item),
dtype=np.uint8)
image = QImage(image.data, image.shape[1], image.shape[0],
image.strides[0], QImage.Format_RGB888)
pixmap = QPixmap(image)
q_item.setIcon(QIcon(pixmap))
q_item.setData(Qt.UserRole, item)
if self._checkable:
q_item.setCheckState(Qt.Unchecked)
# From 'default item flags' remove flag allowing user to directly change item's checkbox status.
# The status is exclusively controlled by _on_item_clicked callback,
# so if user clicks within list item boundaries (not only checkbox), the status will be changed.
q_item.setFlags(q_item.flags() & ~Qt.ItemIsUserCheckable)
# Leaving ItemIsUserCheckable flag enabled, causes problems when user clicks on checkbox
# - two callbacks are launched:
# - first - controlled by the flag - checks/unchecks checkbox directly,
# - second - defined by us (_on_item_clicked) also checks/unchecks checkbox.
# In that case user DOES NOT see the change of checkbox status, because
# checkbox is checked by first callback and unchecked by second one (or the other way around)
# and list of checked items effectively stays unchanged,
# while causing side effects (eg. invocation of on_list_item_clicked_callback).
self._items.append(q_item)
self._ui.addItem(q_item)
def _display_annotation_in_qlistwidget(self, annt):
'''Add a line to the annotation list
It does not erase previous lines.
Parameters
----------
annt : list of (dict, str)
dict : contains the key 'annotationtype' and determines the annotation color
also contains all other annotation data needed for right click menu/double click
str : The string to add to the list
'''
# clear the previous annotation box
self.app_window.w_dblist.clear()
for cannt in annt:
details = cannt[0]
newitem = QListWidgetItem(cannt[1])
newitem.setData(QtCore.Qt.UserRole, details)
if details['annotationtype'] == 'diffexp':
ccolor = QtGui.QColor(0, 0, 200)
elif details['annotationtype'] == 'contamination':
ccolor = QtGui.QColor(200, 0, 0)
elif details['annotationtype'] == 'common':
ccolor = QtGui.QColor(0, 200, 0)
elif details['annotationtype'] == 'highfreq':
ccolor = QtGui.QColor(0, 200, 0)
else:
ccolor = QtGui.QColor(0, 0, 0)
newitem.setForeground(ccolor)
self.app_window.w_dblist.addItem(newitem)
def set_start_settings(self):
query = "SELECT Id, Name FROM accessories_name WHERE For_Beika = 1"
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения разрешеной фурнитуры", sql_info.msg, QMessageBox.Ok)
return False
if len(sql_info) > 1:
QMessageBox.critical(self, "Ошибка фурнитуры", "Выбрано 2 фурнитуры! Это не правильно!", QMessageBox.Ok)
self.close()
self.destroy()
return False
elif len(sql_info) == 1:
self.le_accessories_name.setWhatsThis(str(sql_info[0][0]))
self.le_accessories_name.setText(str(sql_info[0][1]))
elif len(sql_info) == 0:
self.le_accessories_name.setWhatsThis("None")
self.le_accessories_name.setText("None")
query = "SELECT Id, Name FROM material_name WHERE For_Beika = 1 ORDER BY Name"
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения разрешеной ткани", sql_info.msg, QMessageBox.Ok)
return False
self.lw_material_name.clear()
for material in sql_info:
item = QListWidgetItem(material[1])
item.setData(-1, material[0])
self.lw_material_name.addItem(item)
def __init__(self, parent):
ChildDialog.__init__(self, parent)
self.ui = ui.startup_dialog.Ui_Dialog()
self.ui.setupUi(self)
self._clicked_action = self.ACTION_NO
self.ui.listWidgetRecentSessions.itemDoubleClicked.connect(self.accept)
for recent_session in self.session.recent_sessions:
session_item = QListWidgetItem(recent_session.replace('/', ' / '),
self.ui.listWidgetRecentSessions)
session_item.setData(Qt.UserRole, recent_session)
self.ui.listWidgetRecentSessions.addItem(session_item)
self.ui.listWidgetRecentSessions.setMinimumHeight(
30 * len(self.session.recent_sessions))
self.ui.listWidgetRecentSessions.setCurrentRow(0)
self.ui.pushButtonNewSession.clicked.connect(self._new_session_clicked)
self.ui.pushButtonOpenSession.clicked.connect(
self._open_session_clicked)
#self.ui.buttonBox.key_event.connect(self._up_down_pressed)
self.ui.pushButtonNewSession.focus_on_list.connect(self._focus_on_list)
self.ui.pushButtonOpenSession.focus_on_list.connect(
self._focus_on_list)
self.ui.pushButtonNewSession.focus_on_open.connect(self._focus_on_open)
self.ui.pushButtonOpenSession.focus_on_new.connect(self._focus_on_new)
self.ui.listWidgetRecentSessions.setFocus(Qt.OtherFocusReason)
def _select(self, choices):
if not choices:
return []
dialog = QDialog(mw)
layout = QVBoxLayout()
listWidget = QListWidget()
listWidget.setSelectionMode(QAbstractItemView.ExtendedSelection)
for c in choices:
item = QListWidgetItem(c['text'])
item.setData(Qt.UserRole, c['data'])
listWidget.addItem(item)
buttonBox = QDialogButtonBox(QDialogButtonBox.Close
| QDialogButtonBox.Save)
buttonBox.accepted.connect(dialog.accept)
buttonBox.rejected.connect(dialog.reject)
buttonBox.setOrientation(Qt.Horizontal)
layout.addWidget(listWidget)
layout.addWidget(buttonBox)
dialog.setLayout(layout)
dialog.setWindowModality(Qt.WindowModal)
dialog.resize(500, 500)
choice = dialog.exec_()
if choice == 1:
return [
listWidget.item(i).data(Qt.UserRole)
for i in range(listWidget.count())
if listWidget.item(i).isSelected()
]
return []
def add_spec(self):
if self.check_mass() & self.check_name() & self.check_alpha():
# add specimen
mass = int(self.tb_mass.text())
name = str(self.tb_name.text())
color = str(self.cb_color.currentText())
alpha_list = [
float(alpha.text()) for alpha in self.list_alpha
if not alpha.isHidden()
]
self.parent.cnf.add_specimen(mass,
name=name,
color=color,
alpha_list=alpha_list)
# add to list
specimen = QListWidgetItem()
specimen.setText(name)
specimen.setData(QListWidgetItem.UserType, [
self.parent.list_specimen.count(), mass, name, color,
alpha_list
])
self.parent.list_specimen.addItem(specimen)
# check integrity
self.check_integrity()
# resetting boxes
self.list_alpha.append(QLineEdit())
self.refresh_ui()
def open_team_helper(self, user_teamname, match_number):
self.my_team_listWidget.clear()
userteam_details = get_userteam_details(user_teamname, match_number)
used_points = userteam_details[0]
player_ids = list(int(player_id) for player_id in userteam_details[2][1:-1].split(", "))
available_points = 1000 - used_points
team_1_code,_,team_2_code = str(get_versus(match_number)[0]).split(" ")
team_1_fullname, team_2_fullname = str(get_full_teamname(team_1_code)[0]), str(get_full_teamname(team_2_code)[0])
num_batsmen, num_bowlers, num_allrounders, num_wicketkeepers, playersNum_team_1, playersNum_team_2 = 0, 0, 0, 0, 0, 0
for player_id in player_ids:
player_details = get_player_details(player_id)
player_text = self.build_player_text_right(player_details)
player_team_code, player_role = str(player_details[1]), str(player_details[2])
if player_team_code == team_1_code:
playersNum_team_1 = playersNum_team_1 + 1
else:
playersNum_team_2 = playersNum_team_2 + 1
if player_role == 'BAT':
num_batsmen = num_batsmen + 1
elif player_role == 'BWL':
num_bowlers = num_bowlers + 1
elif player_role == 'AR':
num_allrounders = num_allrounders + 1
elif player_role == 'WK':
num_wicketkeepers = num_wicketkeepers + 1
item = QListWidgetItem()
item.setText(str(player_text))
item.setData(QtCore.Qt.UserRole, player_id)
self.my_team_listWidget.addItem(item)
self.set_fields("Match " + match_number, user_teamname, str(num_batsmen), str(num_bowlers), str(num_allrounders), str(num_wicketkeepers), str(available_points), str(used_points), team_1_fullname, team_2_fullname, team_1_code, str(playersNum_team_1), team_2_code, str(playersNum_team_2))
self.enable_disable_buttons(True)
self.my_team_listWidget.sortItems()
self.display_players()
def load_obs(self):
load = QFileDialog()
load.setDefaultSuffix(".json")
load.setNameFilter("JSON files (*.json)")
load.setAcceptMode(QFileDialog.AcceptOpen)
load.setOption(QFileDialog.DontUseNativeDialog)
if load.exec_() == QFileDialog.Accepted:
filename = load.selectedFiles()[0]
with open(filename) as json_file:
obs_dict = json.load(json_file)
self.observationList.clear()
for key in obs_dict:
if key in self.targetsDict:
targetName = key
ra = self.targetsDict[targetName]["ra"]
dec = self.targetsDict[targetName]["dec"]
coord = SkyCoord(frame='icrs', ra=ra, dec=dec, obstime="J2000")
target = FixedTarget(coord=coord, name=targetName)
for date in obs_dict[key]['times']:
print(date)
# TODO Te pielikt date parbaudes, vai atkekset ja ir vai iznemt ja nav
data = PlannedObs(target, int(obs_dict[key]['priority']), int(obs_dict[key]['obs_per_week']),
int(obs_dict[key]['scans_per_obs']), obs_dict[key]['times'],
obs_dict[key]['global_time'])
item = QListWidgetItem(str(data), self.observationList)
item.setData(Qt.UserRole, data)
self.observationList.addItem(item)
self.plannedTargets.append(target.name)
else:
self.show_error("Target error", key + " not in targets, skipping it")
else:
print("Something went wrong")
def __init__(self, parent, sweep):
super(EditSweepGUI, self).__init__(parent)
self.parent = parent
self.ui = Ui_editSweep()
self.ui.setupUi(self)
self.setWindowTitle("Edit Sweep")
self.sweep = sweep
self.ui.deleteButton.clicked.connect(lambda: self.done(2))
self.ui.paramBox.addItem('time', 'time')
for name, p in self.parent.set_params.items():
self.ui.paramBox.addItem(p.label, p)
if isinstance(self.sweep, Sweep0D):
self.ui.paramBox.setCurrentIndex(0)
elif isinstance(self.sweep, Sweep1D):
for n in range(self.ui.paramBox.count()):
if self.ui.paramBox.itemData(n) is sweep.set_param:
self.ui.paramBox.setCurrentIndex(n)
txt = self.ui.paramBox.currentText()
if self.ui.paramBox.currentText() != 'time':
self.ui.startEdit.setReadOnly(False)
p = self.ui.startEdit.palette()
p.setColor(self.ui.startEdit.backgroundRole(), Qt.white)
self.ui.startEdit.setPalette(p)
self.ui.stepEdit.setReadOnly(False)
q = self.ui.stepEdit.palette()
q.setColor(self.ui.stepEdit.backgroundRole(), Qt.white)
self.ui.stepEdit.setPalette(q)
self.ui.startEdit.setText(str(sweep.begin))
self.ui.endEdit.setText(str(sweep.end))
self.ui.stepEdit.setText(str(sweep.step))
self.ui.stepsecEdit.setText(str(1.0 / sweep.inter_delay))
self.ui.bidirectionalBox.setChecked(sweep.bidirectional)
self.ui.continualBox.setChecked(sweep.continuous)
else:
self.ui.startEdit.setReadOnly(True)
p = self.ui.startEdit.palette()
p.setColor(self.ui.startEdit.backgroundRole(), Qt.gray)
self.ui.startEdit.setPalette(p)
self.ui.stepEdit.setReadOnly(True)
q = self.ui.stepEdit.palette()
q.setColor(self.ui.stepEdit.backgroundRole(), Qt.gray)
self.ui.stepEdit.setPalette(q)
self.ui.endEdit.setText(str(sweep.max_time))
self.ui.stepsecEdit.setText(str(1.0 / sweep.inter_delay))
self.ui.saveBox.setChecked(sweep.save_data)
self.ui.livePlotBox.setChecked(sweep.plot_data)
self.ui.plotbinEdit.setText(str(sweep.plot_bin))
self.ui.paramBox.currentIndexChanged.connect(
self.update_param_combobox)
for param in sweep._params:
listitem = QListWidgetItem(param.label)
listitem.setData(32, param)
self.ui.followParamWidget.addItem(listitem)
def load_endpoints(self):
self.choose_endpoint.endpoints.clear()
for name in listdir(str(BASE_PATH / 'endpoints')):
if name.endswith('.json'):
item = QListWidgetItem(
name.split('.json')[0], self.choose_endpoint.endpoints)
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
pb_msg_to_endpoints = defaultdict(list)
with open(str(BASE_PATH / 'endpoints' / name)) as fd:
for endpoint in load(fd, object_pairs_hook=OrderedDict):
pb_msg_to_endpoints[endpoint['request']['proto_msg'].
split('.')[-1]].append(endpoint)
for pb_msg, endpoints in pb_msg_to_endpoints.items():
item = QListWidgetItem(' ' * 4 + pb_msg,
self.choose_endpoint.endpoints)
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
for endpoint in endpoints:
path_and_qs = '/' + endpoint['request']['url'].split(
'/', 3).pop()
item = QListWidgetItem(' ' * 8 + path_and_qs,
self.choose_endpoint.endpoints)
item.setData(Qt.UserRole, endpoint)
self.set_view(self.choose_endpoint)
def handleAssetUpdate(self, _status, _data):
self.__ui.lwAssetList.clear()
for asset_name in _status.asset:
item_asset = QListWidgetItem() # 资源列表
item_asset.setData(Qt.UserRole, asset_name) # 设置item的uid
item_asset.setText(item_asset.data(Qt.UserRole))
self.__ui.lwAssetList.addItem(item_asset)
def deviceChanged(self, item: QtWidgets.QListWidgetItem):
if item is None:
return
self.currentBaudRateBps = None
self.currentPhase = None
self.btParamLabel.setText(self.BT_PARAM_LABEL)
self.arbitrationBaudRateList.clear()
self.dataBaudRateList.clear()
self.bitTimingTable.clearContents()
self.bitTimingTable.setRowCount(0)
self.canvas.scene.clear()
device: CanDevice = item.data(QtCore.Qt.UserRole)
self.f_in_MHz_value.setValue(int(device.F_in / 1e6))
self.f_in_MHz_value.setStyleSheet('background-color: white;')
for timingInfo in device.TimingInfos.values():
if timingInfo.Phase is CanPhase.Arbitration:
brList = [
br * 1000 for br in CanBaudRatesKbps
if br <= device.MaxBaudRate
]
listWidget = self.arbitrationBaudRateList
elif timingInfo.Phase is CanPhase.Data:
brList = [
br * 1000 for br in CanFDBaudRatesKbps
if br <= device.MaxFDBaudRate
]
listWidget = self.dataBaudRateList
else:
raise TypeError
for baudRateBps in brList:
item = QtWidgets.QListWidgetItem(f'{baudRateBps/1000:.1f}')
item.setData(QtCore.Qt.UserRole,
(timingInfo.Phase, baudRateBps))
listWidget.addItem(item)
def loadFromScheduler(self):
# actWhen ComboBox
for row, pair in enumerate(self.scheduler.POSSIBLE_ACTWHENS):
self.comboBox_actWhen.addItem(pair[1])
self.comboBox_actWhen.setItemData(row, pair[0])
self.slotActWhenChanged(self.scheduler.actWhen)
self.comboBox_actWhen.setCurrentIndex(self.scheduler.actWhen)
self.comboBox_actWhen.activated[int].connect(self.slotActWhenChanged)
# tasks list
runningTasks = app.etmpy.runningTasksStat.getTasks()
waitingTaskIds = self.scheduler.waitingTaskIds
for rTaskId, rTask in runningTasks.items():
item = QListWidgetItem(rTask["name"])
item.setData(Qt.UserRole, rTaskId)
self.listWidget_tasks.addItem(item)
# must be set before being added
if rTaskId in waitingTaskIds:
item.setSelected(True)
else:
item.setSelected(False)
# action comboBox
selectedIndex = None
for action in self.scheduler.actions:
if action.command or action.availability == "yes":
self.comboBox_action.addItem(action.displayName)
row = self.comboBox_action.count() - 1
self.comboBox_action.setItemData(row, action.actionId)
if self.scheduler.actionId == action.actionId:
selectedIndex = row
self.comboBox_action.setCurrentIndex(selectedIndex)
def showReviewers(self):
self.reviewersWidget.clear()
allReviewers = Service().reviewersListCheck()
for reviewer in allReviewers:
reviewerItem = QListWidgetItem(str(reviewer.memberID))
reviewerItem.setData(1, reviewer)
self.reviewersWidget.addItem(reviewerItem)
def __init__(self, wizard: AccountWizard):
super().__init__(wizard)
self.setTitle(_("Add Account"))
self.setFinalPage(False)
option_list = self.option_list = QListWidget()
option_list.setIconSize(QSize(30, 30))
option_list.setStyleSheet("""
QListView::item:selected {
background-color: #F5F8FA;
color: black;
}
""")
for entry in self._get_entries():
if entry.get("disabled", False):
continue
list_item = QListWidgetItem()
list_item.setSizeHint(QSize(40, 40))
list_item.setIcon(read_QIcon(entry['icon_filename']))
list_item.setText(entry['description'])
list_item.setData(Qt.UserRole, entry)
option_list.addItem(list_item)
option_list.setMaximumWidth(400)
option_list.setWordWrap(True)
option_detail = self.optionDetail = QLabel()
option_detail.setMinimumWidth(200)
option_detail.setAlignment(Qt.AlignTop | Qt.AlignLeft)
option_detail.setTextFormat(Qt.RichText)
option_detail.setWordWrap(True)
option_detail.setOpenExternalLinks(True)
option_detail.setText(self._get_entry_detail())
layout = QHBoxLayout()
# It looks tidier with more separation between the list and the detail pane.
layout.setSpacing(15)
layout.addWidget(option_list)
layout.addWidget(option_detail)
self.setLayout(layout)
def _on_item_selection_changed():
selected_items = self.option_list.selectedItems()
if len(selected_items):
entry = selected_items[0].data(Qt.UserRole)
self.optionDetail.setText(self._get_entry_detail(entry))
else:
self.optionDetail.setText(self._get_entry_detail())
self.completeChanged.emit()
def _on_item_double_clicked(clicked_item: QListWidgetItem) -> None:
self.option_list.setCurrentItem(clicked_item)
self.completeChanged.emit()
wizard.next()
option_list.itemDoubleClicked.connect(_on_item_double_clicked)
option_list.itemSelectionChanged.connect(_on_item_selection_changed)
def build_list(self):
"""Builds listWidget"""
self.listWidget.clear()
for choice in sorted(self.choices, key=lambda choice: choice[1]):
value, name = choice
item = QListWidgetItem(name.replace('"', ''))
item.setData(Qt.UserRole, value)
self.listWidget.addItem(item)
def generate_hotkey_list(self):
"""Generate the hotkey list."""
for option in self.model.options('Hotkeys'):
if not option.startswith(';'):
item = QListWidgetItem()
item.setText(option)
item.setData(Qt.UserRole, self.model.get('Hotkeys', option))
self.ui.listWidget_hotkey.addItem(item)
def add_exist(self, name, dir):
self.exist_projects.append((name, dir))
item = QListWidgetItem()
item.setText(name)
item.setData(self._PROJECT_DIR_ROLE, dir)
item.setIcon(QIcon.fromTheme("package_games"))
self.projects_list.addItem(item)
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 load_next_items(self):
for i in range(self.items_loaded, min(self.items_loaded + ITEM_LOAD_BATCH, len(self.data_items) - 1)):
item = QListWidgetItem(self)
item.setSizeHint(QSize(-1, 60))
data_item = self.data_items[i]
item.setData(Qt.UserRole, data_item[1])
widget_item = data_item[0](self, data_item[1])
self.addItem(item)
self.setItemWidget(item, widget_item)
self.items_loaded += ITEM_LOAD_BATCH
def load_materials(self):
material_dict = self.materials.material_dict
self.material_list_widget.clear()
for name, material in material_dict.items():
item = QListWidgetItem()
item.setText(name)
item.setData(Qt.UserRole + 1, material)
self.material_list_widget.addItem(item)
self.material_list_widget.sortItems(Qt.AscendingOrder)
self.material_list_widget.setCurrentRow(0)
self.load_material_data()
def createArticles(self):
# load articles from library
# and add them to the list
for article in library.SCIENTIFIC_ARTICLES:
# list widget item with it's data
item = QListWidgetItem()
item.setText(article[0].strip())
item.setData(Qt.UserRole, article[1].strip())
# add the item to the list widget
self.listWidget.addItem(item)
def updateList(self):
self.scenelistList.clear()
for i, scene in enumerate(self.gui.song.scenes):
item = QListWidgetItem('{}. {}'.format(i + 1, scene))
item.setData(self.ITEM_IT_ROLE, i)
if self.gui.song.initial_scene == scene:
item.setBackground(QColor('red'))
self.scenelistList.addItem(item)
anyScenes = bool(self.gui.song.scenes)
self.loadScenesBtn.setEnabled(anyScenes)
self.removeScenesBtn.setEnabled(anyScenes)
self.initPreview()
def load(self):
self.ui.backendsList.clear()
self.ui.backendsList.addItem('(All)')
for backend in self.weboob.iter_backends():
if not backend.has_caps(CapMessages):
continue
item = QListWidgetItem(backend.name.capitalize())
item.setData(Qt.UserRole, backend)
self.ui.backendsList.addItem(item)
self.refreshThreads()
def received_download_details(self, json_result):
self.file_list.clear()
results = json.loads(json_result)
for result in results['download']['files']:
item = QListWidgetItem(self.file_list)
item.setData(Qt.UserRole, result)
is_selected = self.parent().ACTIVE_INDEX == result['index']
widget_item = VideoFileListItem(self.file_list, result, is_selected)
item.setSizeHint(widget_item.sizeHint())
self.file_list.addItem(item)
self.file_list.setItemWidget(item, widget_item)
def update(self):
self.list.clear()
item = self._index.internalPointer()
rev = item.revisions()
# Sort revisions
rev = sorted(rev, key=lambda x: x[0], reverse=True)
for r in rev:
timestamp = datetime.datetime.fromtimestamp(r[0]).strftime('%Y-%m-%d %H:%M:%S')
readable = self.readableDelta(r[0])
i = QListWidgetItem(readable)
i.setData(Qt.UserRole, r[0])
i.setData(Qt.UserRole + 1, timestamp)
self.list.addItem(i)
def set_element_list(self):
self.ui.listWidget_elements.clear()
for element in self.elements:
element_name = element.name
if not (element_name in self.element_name_dict): # no element to that name yet
element_wrapper = GraphicElementsWrapper(element)
self.element_name_dict[element_name] = element_wrapper
item = QListWidgetItem()
item.setText(element_name)
item.setData(Qt.UserRole + 2, element_wrapper)
self.element_list_item_dict[element_name] = item
self.ui.listWidget_elements.addItem(item)
self.ui.listWidget_elements.sortItems(Qt.AscendingOrder)
def update_lists(self):
self.window().playlist_manage_in_channel_list.clear()
self.window().playlist_manage_in_playlist_list.clear()
for torrent in self.torrents_in_channel:
item = QListWidgetItem(torrent["name"], self.window().playlist_manage_in_channel_list)
item.setData(Qt.UserRole, torrent)
self.window().playlist_manage_in_channel_list.addItem(item)
for torrent in self.torrents_in_playlist:
item = QListWidgetItem(torrent["name"], self.window().playlist_manage_in_playlist_list)
item.setData(Qt.UserRole, torrent)
self.window().playlist_manage_in_playlist_list.addItem(item)
def loadFromFile(self, path):
"""Load project from file"""
self.filePath = path
with open(path, "r") as f:
data = json.load(f)
for sheetdata in data["sheets"]:
newTreeItem = QListWidgetItem(sheetdata["name"], self.ui.sheetListWidget)
newTreeItem.setData(Qt.UserRole, sheetdata["uuid"]) # Add some uniquely identifying data to make it hashable
self.newSheet(newTreeItem, sheetdata)
def set_sql_salary_date(self):
query = """(SELECT Date_Pay FROM pack_operation WHERE Pay = 1 GROUP BY Date_Pay ORDER BY Date_Pay DESC)
UNION
(SELECT Date_Pay FROM pay_worker WHERE Pay = 1 GROUP BY Date_Pay ORDER BY Date_Pay DESC)
ORDER BY Date_Pay DESC"""
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
raise RuntimeError("Не смог получыить даты закрытых месяцов")
for date in sql_info:
date_item = QListWidgetItem(date[0].strftime("%d.%m.%Y"))
date_item.setData(-1, date[0])
self.lw_date_salary.addItem(date_item)
def addSpec(self, fileName, title):
# import spectra from file
j = self.selectPane.currentIndex()
l = self.spec[j].nSpec()
listWidget = self.selectPane.currentWidget()
self.selectPane.setTabText(j, title)
self.spec[j].addSpec(fileName, np.array([[0, 0, 0]]))
for i in range(l + 1, self.spec[j]._coord.shape[0]):
newItem = QListWidgetItem("[%d %d %d]" % \
tuple(self.spec[j]._coord[i]), listWidget)
newItem.setData(Qt.UserRole,
QVariant([j, i]))
listWidget.addItem(newItem)
listWidget.itemDoubleClicked.connect(self.updatePlot2)
def updateListFromData(self):
self.list.clear()
for cat in self.data:
filtered = [i for i in self.data[cat] if self.txtFilter.text().lower() in i[0].lower() or
self.txtFilter.text().lower() in cat[0].lower()]
if filtered:
self.addCategory(cat[0])
for item in filtered:
i = QListWidgetItem(item[0])
i.setData(Qt.UserRole, Ref.EmptyRef.format(cat[1], item[1], item[0]))
i.setData(Qt.UserRole + 1, item[2])
self.list.addItem(i)
self.list.setCurrentRow(1)
def set_sql_salary_date(self):
query = """(SELECT Date_Pay FROM pack_operation WHERE Pay = 1 AND Worker_Id = %s GROUP BY Date_Pay ORDER BY Date_Pay DESC)
UNION
(SELECT Date_Pay FROM pay_worker WHERE Pay = 1 AND Worker_Id = %s GROUP BY Date_Pay ORDER BY Date_Pay DESC)
ORDER BY Date_Pay DESC LIMIT 3"""
sql_info = my_sql.sql_select(query, (self.work, self.work))
if "mysql.connector.errors" in str(type(sql_info)):
return False
for date in sql_info:
date_item = QListWidgetItem(date[0].strftime("%d.%m.%Y"))
date_item.setData(-1, date[0])
date_item.setTextAlignment(Qt.AlignHCenter)
self.lw_date_salary.addItem(date_item)
def __toolbarComboBox_currentIndexChanged(self, index):
"""
Private slot called upon a selection of the current toolbar.
@param index index of the new current toolbar (integer)
"""
itemID = self.toolbarComboBox.itemData(index)
self.__currentToolBarItem = self.__toolbarItems[itemID]
self.toolbarActionsList.clear()
for actionID in self.__currentToolBarItem.actionIDs:
item = QListWidgetItem(self.toolbarActionsList)
if actionID is None:
item.setText(self.__separatorText)
else:
action = self.__manager.actionById(actionID)
item.setText(action.text())
item.setIcon(action.icon())
item.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item.setData(E5ToolBarDialog.ActionIdRole, int(id(action)))
item.setData(E5ToolBarDialog.WidgetActionRole, False)
if self.__manager.isWidgetAction(action):
item.setData(E5ToolBarDialog.WidgetActionRole, True)
item.setData(Qt.TextColorRole, QColor(Qt.blue))
self.toolbarActionsList.setCurrentRow(0)
self.__setupButtons()
def testErrored(self, test, exc, id):
"""
Public method called if a test errors.
@param test name of the test (string)
@param exc string representation of the exception (string)
@param id id of the test (string)
"""
self.errorCount += 1
self.progressCounterErrorCount.setText(str(self.errorCount))
itm = QListWidgetItem(self.tr("Error: {0}").format(test))
itm.setData(Qt.UserRole, (test, exc))
self.errorsListWidget.insertItem(0, itm)
self.__failedTests.append(id)
def updateListFromData(self):
data = mainWindow().cheatSheet.data
self.list.clear()
for cat in data:
filtered = [i for i in data[cat] if self.text.text().lower() in i[0].lower()]
if filtered:
self.addCategory(cat[0])
for item in filtered:
i = QListWidgetItem(item[0])
i.setData(Qt.UserRole, Ref.EmptyRef.format(cat[1], item[1], item[0]))
i.setData(Qt.UserRole + 1, item[2])
self.list.addItem(i)
self.list.setCurrentRow(1)
self.text.setFocus(Qt.PopupFocusReason)
def add_items(self):
"""Adds available ROMs"""
self.listWidget.clear()
for rom in self.rom_list:
if len(rom) == 4:
crc, goodname, path, fname = rom
if isinstance(goodname, bytes):
goodname = goodname.decode()
list_item = QListWidgetItem(goodname)
list_item.setData(Qt.UserRole, (crc, goodname, path, fname))
self.listWidget.addItem(list_item)
self.progressBar.setValue(0)
self.progressBar.hide()
self.pushOpen.setEnabled(True)
self.pushRefresh.setEnabled(True)
self.labelAvailable.setText("%s ROMs. " % len(self.rom_list))
def updateSheets(self):
if self.sheets is not None and self.ownsheet is not None:
self.listSheetItems = {}
self.listWidget.clear()
for sheetId in self.sheets:
if not sheetId == self.ownsheet:
newItem = QListWidgetItem(self.sheets[sheetId])
newItem.setToolTip(str(sheetId))
newItem.setData(Qt.UserRole, sheetId)
self.listSheetItems[sheetId] = newItem
self.listWidget.addItem(newItem)
if sheetId == self.selectedSheet:
boldFont = QFont()
boldFont.setBold(True)
newItem.setFont(boldFont)
def __init__(self, unsaved_files, parent=None):
super().__init__(parent)
self._ninja = parent
self.setWindowTitle(translations.TR_IDE_CONFIRM_EXIT_TITLE)
vbox = QVBoxLayout(self)
self._unsave_files_list = QListWidget()
self._unsave_files_list.setSelectionMode(QListWidget.ExtendedSelection)
vbox.addWidget(QLabel(translations.TR_IDE_CONFIRM_EXIT_BODY))
vbox.addWidget(self._unsave_files_list)
button_box = QDialogButtonBox(self)
standard_icon = self.style().standardIcon
btn = button_box.addButton(
translations.TR_CANCEL, QDialogButtonBox.RejectRole)
btn.setIcon(standard_icon(self.style().SP_DialogCloseButton))
self._btn_save_selected = button_box.addButton(
translations.TR_SAVE_SELECTED, QDialogButtonBox.AcceptRole)
self._btn_save_selected.setIcon(
standard_icon(self.style().SP_DialogSaveButton))
btn_save_all = button_box.addButton(
translations.TR_SAVE_ALL, QDialogButtonBox.AcceptRole)
btn_save_all.setIcon(standard_icon(self.style().SP_DialogApplyButton))
btn_donot_save = button_box.addButton(
translations.TR_DONOT_SAVE, QDialogButtonBox.DestructiveRole)
btn_donot_save.setIcon(standard_icon(self.style().SP_DialogNoButton))
vbox.addWidget(button_box)
for nfile in unsaved_files:
item = QListWidgetItem(nfile.display_name)
item.setData(Qt.UserRole, nfile)
item.setToolTip(nfile.file_path)
self._unsave_files_list.addItem(item)
# Connections
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self._save_selected)
btn_donot_save.clicked.connect(self._discard)
btn_save_all.clicked.connect(self._save_all)
self._unsave_files_list.itemSelectionChanged.connect(
self._on_selection_changed)
self._unsave_files_list.selectAll()
