def rows_text_insert(self,
where_to=None,
editable=None,
clickable=None,
alignment=None): # text -> table item
if where_to is None:
where_to = self.rowCount()
if editable is None:
editable = self.col_editable
if clickable is None:
clickable = self.col_clickable
if alignment is None:
alignment = self.col_alignment
n = 0
while True:
to_insert = (yield)
if to_insert is None: # 꼼수
where_to = self.rowCount()
n = 0
continue
self.insertRow(where_to + n)
for col in range(self.columnCount()):
item = QTableWidgetItem(to_insert[col])
if not editable[col]: # false 일때 플래그 제거
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
if not clickable[col]:
item.setFlags(item.flags() ^ Qt.ItemIsEnabled)
if alignment[col]:
item.setTextAlignment(alignment[col]) # ex) Qt.AlignCenter
self.setItem(where_to + n, col, item)
n += 1
def update_locations(self):
self.locations_table.setUpdatesEnabled(False)
self.locations_table.setRowCount(0)
for i in range(2):
if i == 0:
if self.scope() == QSettings.SystemScope:
continue
actualScope = QSettings.UserScope
else:
actualScope = QSettings.SystemScope
for j in range(2):
if j == 0:
if not self.application():
continue
actualApplication = self.application()
else:
actualApplication = ''
settings = QSettings(self.format(), actualScope,
self.organization(), actualApplication)
row = self.locations_table.rowCount()
self.locations_table.setRowCount(row + 1)
item0 = QTableWidgetItem()
item0.setText(settings.fileName())
item1 = QTableWidgetItem()
disable = not (settings.childKeys() or settings.childGroups())
if row == 0:
if settings.isWritable():
item1.setText("Read-write")
disable = False
else:
item1.setText("Read-only")
self.button_box.button(QDialogButtonBox.Ok).setDisabled(disable)
else:
item1.setText("Read-only fallback")
if disable:
item0.setFlags(item0.flags() & ~Qt.ItemIsEnabled)
item1.setFlags(item1.flags() & ~Qt.ItemIsEnabled)
self.locations_table.setItem(row, 0, item0)
self.locations_table.setItem(row, 1, item1)
self.locations_table.setUpdatesEnabled(True)
def add_element(self, port, service):
self.table.insertRow(self.items)
port_item = QTableWidgetItem(str(port))
port_item.setTextAlignment(Qt.AlignCenter)
port_item.setFlags(port_item.flags() ^ Qt.ItemIsEditable)
service_item = QTableWidgetItem(str(service))
service_item.setFlags(service_item.flags() ^ Qt.ItemIsEditable)
service_item.setToolTip("Open in Exploit-db")
self.table.setItem(self.items, 0, port_item)
self.table.setItem(self.items, 1, service_item)
self.items += 1
def add_element(self, status_code, url):
self.table.insertRow(self.items)
status_code_item = QTableWidgetItem(str(status_code))
status_code_item.setTextAlignment(Qt.AlignCenter)
status_code_item.setFlags(status_code_item.flags() ^ Qt.ItemIsEditable)
url_item = QTableWidgetItem(url)
url_item.setFlags(url_item.flags() ^ Qt.ItemIsEditable)
url_item.setToolTip("Open in Browser")
self.table.setItem(self.items, 0, status_code_item)
self.table.setItem(self.items, 1, url_item)
self.items += 1
def _set_item(view, row, column, text, editable=True):
if not text:
text = ""
item = QTableWidgetItem(text)
if not editable:
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
view.setItem(row, column, item)
def table_setup(self, series, item):
"""Generates table elements based on series.
Clears any existing elements in the table, then uses series to
generate a two-column table, with headings in the first column
and data in the second. The first column is not editable,
and the second column is editable.
"""
headings = ["Name", "Alt. Names", "Author", "Volumes Owned",
"Next Volume", "Publisher", "Completed"]
data = [series.name, series.alt_names, series.author,
series.volumes_owned_readable, series.next_volume,
series.publisher, "Yes" if series.is_completed else "No"]
# Prepare table
self.edit_series_table.clear()
self.edit_series_table.setRowCount(len(headings))
self.edit_series_table.setColumnCount(2)
self.edit_series_table.setEditTriggers(
QAbstractItemView.AllEditTriggers)
header = self.edit_series_table.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.Stretch)
# Populate table
for i in range(len(headings)):
headerItem = QTableWidgetItem(headings[i])
headerItem.setFlags(headerItem.flags() & ~int(Qt.ItemIsEditable))
dataItem = None
self.edit_series_table.setItem(i, 0, headerItem)
if headings[i] == "Completed":
dataItem = QComboBox()
dataItem.insertItem(0, "No")
dataItem.insertItem(1, "Yes")
if str(data[i]) == "No":
dataItem.setCurrentIndex(0)
else:
dataItem.setCurrentIndex(1)
self.edit_series_table.setCellWidget(i, 1, dataItem)
else:
dataItem = QTableWidgetItem(str(data[i]))
if headings[i] == "Next Volume":
dataItem.setFlags(dataItem.flags()
& ~int(Qt.ItemIsEditable))
self.edit_series_table.setItem(i, 1, dataItem)
# set property editable if series_info_display double-clicked
if headings[i] == item and item not in ["Next Volume",
"Completed"]:
self.edit_series_table.editItem(dataItem)
def update_table_item(self, row, timelog_info):
column = -1
for timelog in timelog_info:
column += 1
item = QTableWidgetItem()
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable)
if column == 2:
timelog += " hour"
item.setText(timelog)
if not column == 3:
item.setTextAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.tableWidgetTimelog.setItem(row, column, item)
def add_row(self,
row: int,
item_text: str,
item_text_color: QColor = color.TABLE_CODE_TEXT_COLOR,
item_background_color=color.TABLE_CODE_BACKGROUND_COLOR,
header_text: str = ''):
self.table_widget.setRowCount(row + 1)
table_header = QTableWidgetItem(header_text)
self.table_widget.setVerticalHeaderItem(row, table_header)
table_item = QTableWidgetItem(item_text)
table_item.setTextColor(item_text_color)
table_item.setFlags(table_item.flags() ^ Qt.ItemIsEditable)
table_item.setBackgroundColor(item_background_color)
self.table_widget.setItem(row, 0, table_item)
def update_table_opacities(self, allalpha=None):
bin_opacitieslst = eval(self.bin_opacities)
self.binstable_isready = False
for binopacity in bin_opacitieslst:
if not allalpha:
alpha = float(binopacity.split(",")[0])
else:
alpha = allalpha
bin = int(binopacity.split(",")[1])
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
if alpha < 0.5:
item.setCheckState(Qt.Unchecked)
else:
item.setCheckState(Qt.Checked)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.binstable.setItem(bin, 3, item)
self.binstable_isready = True
def table_setup(self):
"""Generates table elements for creation of a new series.
Clears any existing elements in the table, then generates a
two-column table, with headings in the first column and space
for series info in the second. The first column is not
editable, and the second column is editable. By default, only
two fields are filled in when the table is completed: 'Name'
and 'Completed'.
"""
headings = ["Name", "Alt. Names", "Author", "Volumes Owned",
"Publisher", "Completed"]
data = ["Unknown", "", "", "", "", "No"]
# Prepare table
self.add_series_table.clear()
self.add_series_table.setRowCount(len(headings))
self.add_series_table.setColumnCount(2)
header = self.add_series_table.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.Stretch)
# Populate table
for i in range(len(headings)):
headerItem = QTableWidgetItem(headings[i])
headerItem.setFlags(headerItem.flags() & ~int(Qt.ItemIsEditable))
self.add_series_table.setItem(i, 0, headerItem)
if headings[i] == "Completed":
dataItem = QComboBox()
dataItem.insertItem(0, "No")
dataItem.insertItem(1, "Yes")
if str(data[i]) == "No":
dataItem.setCurrentIndex(0)
else:
dataItem.setCurrentIndex(1)
self.add_series_table.setCellWidget(i, 1, dataItem)
else:
dataItem = QTableWidgetItem(str(data[i]))
self.add_series_table.setItem(i, 1, dataItem)
self.add_series_table.itemChanged.connect(self.validate_cells)
def update(self):
if self.cctbxproc:
if self.cctbxproc.stdout:
print(self.cctbxproc.stdout.read().decode("utf-8"))
if self.cctbxproc.stderr:
print(self.cctbxproc.stderr.read().decode("utf-8"))
if self.out:
print(self.out.decode("utf-8"))
if self.err:
print(self.err.decode("utf-8"))
if self.zmq_context:
try:
msg = self.socket.recv(
flags=zmq.NOBLOCK
) #To empty the socket from previous messages
msgstr = msg.decode()
self.infodict = eval(msgstr)
#print("received from cctbx: " + str(self.infodict))
if self.infodict:
if self.infodict.get("hklscenes_arrays"):
self.hklscenes_arrays = self.infodict.get(
"hklscenes_arrays", [])
if self.infodict.get("array_infotpls"):
self.array_infotpls = self.infodict.get(
"array_infotpls", [])
if self.infodict.get("bin_data_label"):
self.BinDataComboBox.setCurrentText(
self.infodict["bin_data_label"])
if self.infodict.get("bin_infotpls"):
self.bin_infotpls = self.infodict["bin_infotpls"]
self.nbins = len(self.bin_infotpls)
self.updatingNbins = True
self.Nbins_spinBox.setValue(self.nbins)
self.updatingNbins = False
self.binstable.clearContents()
self.binstable.setRowCount(self.nbins)
for row, bin_infotpl in enumerate(self.bin_infotpls):
for col, elm in enumerate(bin_infotpl):
# only allow changing the last column with opacity values
if col != 3:
item = QTableWidgetItem(str(elm))
else:
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
item.setCheckState(Qt.Checked)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.binstable.setItem(row, col, item)
if self.bin_opacities:
self.update_table_opacities()
if self.infodict.get("bin_opacities"):
self.bin_opacities = self.infodict["bin_opacities"]
if self.binstable.rowCount() > 0:
self.update_table_opacities()
if self.infodict.get("html_url"):
self.html_url = self.infodict["html_url"]
if self.UseOSbrowser == False:
self.BrowserBox.setUrl(self.html_url)
# workaround for background colour bug in chromium
# https://bugreports.qt.io/browse/QTBUG-41960
self.BrowserBox.page().setBackgroundColor(
QColor(100, 100, 100, 1.0))
if self.infodict.get("spacegroups"):
self.spacegroups = self.infodict.get("spacegroups", [])
self.SpaceGroupComboBox.clear()
self.SpaceGroupComboBox.addItems(self.spacegroups)
if self.infodict.get("merge_data"):
self.mergedata = self.infodict["merge_data"]
currentinfostr = ""
if self.infodict.get("info"):
currentinfostr = self.infodict.get("info", [])
if self.infodict.get("NewFileLoaded"):
self.NewFileLoaded = self.infodict.get(
"NewFileLoaded", False)
if self.infodict.get("NewHKLscenes"):
self.NewHKLscenes = self.infodict.get(
"NewHKLscenes", False)
self.fileisvalid = True
#print("ngl_hkl_infodict: " + str(ngl_hkl_infodict))
if currentinfostr:
#print(currentinfostr)
self.infostr += currentinfostr + "\n"
# display no more than self.bufsize bytes of text
self.infostr = self.infostr[-self.bufsize:]
self.textInfo.setPlainText(self.infostr)
self.textInfo.verticalScrollBar().setValue(
self.textInfo.verticalScrollBar().maximum())
if self.NewFileLoaded and self.NewHKLscenes:
#if self.mergedata == True : val = Qt.CheckState.Checked
#if self.mergedata == None : val = Qt.CheckState.PartiallyChecked
#if self.mergedata == False : val = Qt.CheckState.Unchecked
#self.mergecheckbox.setCheckState(val )
#print("got hklscenes: " + str(self.hklscenes_arrays))
self.MillerComboBox.clear()
self.MillerComboBox.addItems(
[e[3] for e in self.hklscenes_arrays])
self.MillerComboBox.setCurrentIndex(
-1) # unselect the first item in the list
self.comboviewwidth = 0
for e in self.hklscenes_arrays:
self.comboviewwidth = max(
self.comboviewwidth,
self.MillerComboBox.fontMetrics().width(e[3]))
self.MillerComboBox.view().setMinimumWidth(
self.comboviewwidth)
self.millertable.clearContents()
self.millertable.setRowCount(len(
self.hklscenes_arrays))
for n, millarr in enumerate(self.array_infotpls):
for m, elm in enumerate(millarr):
self.millertable.setItem(
n, m, QTableWidgetItem(str(elm)))
self.functionTabWidget.setDisabled(True)
self.NewFileLoaded = False
if self.NewHKLscenes:
self.BinDataComboBox.clear()
self.BinDataComboBox.addItems(
["Resolution"] +
[e[3] for e in self.hklscenes_arrays])
self.BinDataComboBox.view().setMinimumWidth(
self.comboviewwidth)
#self.BinDataComboBox.setCurrentIndex(-1) # unselect the first item in the list
self.NewHKLscenes = False
except Exception as e:
errmsg = str(e)
if "Resource temporarily unavailable" not in errmsg:
print(errmsg + traceback.format_exc(limit=10))
pass
def tableWidgetItem(self, value):
item = QTableWidgetItem(value)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
return item
def build_analysis(self) -> None:
""""""
columns = ['Data analisys',
'PID',
'CPU%',
'Memory',
'Status',
]
start_index = self.parent_frame.tableWidget_anlaysis.rowCount() - 1
if self.parent_frame.tableWidget_anlaysis.rowCount() == 0:
self.parent_frame.tableWidget_anlaysis.clear()
self.parent_frame.tableWidget_anlaysis.setRowCount(0)
self.parent_frame.tableWidget_anlaysis.setColumnCount(len(columns))
self.parent_frame.tableWidget_anlaysis.setHorizontalHeaderLabels(
columns)
already_items = []
to_remove = []
to_add = [self.parent_frame.listWidget_projects_analysis.item(i).text(
) for i in range(self.parent_frame.listWidget_projects_analysis.count())]
else:
# start_index = 0
already_items = [self.parent_frame.tableWidget_anlaysis.item(
i, 0).text() for i in range(self.parent_frame.tableWidget_anlaysis.rowCount())]
new_ones = [self.parent_frame.listWidget_projects_analysis.item(
i).text() for i in range(self.parent_frame.listWidget_projects_analysis.count())]
to_remove = set(already_items) - set(new_ones)
to_add = set(new_ones) - set(already_items)
for i, script_name in enumerate(to_add):
if script_name.startswith('_'):
continue
if script_name in already_items:
continue
# if item.text().startswith('Tutorial |'):
# continue
self.parent_frame.tableWidget_anlaysis.insertRow(start_index + i)
for j in range(len(columns)):
if j == 0:
item = QTableWidgetItem(script_name)
item.setCheckState(Qt.Unchecked)
item.is_running = False
else:
item = QTableWidgetItem()
if 0 < j < 4:
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(item.flags() & ~Qt.ItemIsEditable
& ~Qt.ItemIsSelectable)
self.parent_frame.tableWidget_anlaysis.setItem(
start_index + i, j, item)
self.parent_frame.tableWidget_anlaysis.cellWidget(
start_index + i, j)
for script_name in to_remove:
for i in range(self.parent_frame.tableWidget_anlaysis.rowCount()):
item = self.parent_frame.tableWidget_anlaysis.item(i, 0)
if item.text() == script_name:
if not item.checkState() == Qt.Checked:
self.parent_frame.tableWidget_anlaysis.removeRow(i)
else:
item.to_remove = True
break
self.parent_frame.tableWidget_anlaysis.sortByColumn(0)
def get_juso(self, location_code, sc_name):
dic_result = {
'번호': [],
'학교명': [],
'관할지역청': [],
'공사립': [],
'우편번호': [],
'도로명주소': []
}
url = 'http://open.neis.go.kr/hub/schoolInfo'
queryparams = '?' + urlencode({
quote_plus('KEY'): self.auth_key,
quote_plus('Type'): 'json',
quote_plus('pIndex'): '1',
quote_plus('pSize'): '100',
quote_plus('ATPT_OFCDC_SC_CODE'): location_code,
quote_plus('SCHUL_NM'): sc_name
})
req = Request(url + queryparams)
req.get_method = lambda: 'GET'
response_body = urlopen(req).read()
root_json = json.loads(response_body)
# print(root_json)
try:
result_code = root_json['RESULT']
self.ui.table_result.clearContents()
self.ui.info_result.setText('검색 결과 없음')
return -1
except KeyError:
pass
result_cnt = root_json['schoolInfo'][0]['head'][0]['list_total_count']
data_body = root_json['schoolInfo'][1]['row']
# print(data_body)
for i in range(0, result_cnt):
if i > 99:
result_cnt = 99
break
dic_result['번호'].append(i + 1)
dic_result['학교명'].append(data_body[i]['SCHUL_NM'])
dic_result['관할지역청'].append(data_body[i]['JU_ORG_NM'])
dic_result['공사립'].append(data_body[i]['FOND_SC_NM'])
dic_result['우편번호'].append(data_body[i]['ORG_RDNZC'])
dic_result['도로명주소'].append(data_body[i]['ORG_RDNMA'])
# print(dic_result)
str_result = '검색 결과 : ' + str(result_cnt) + '개'
self.ui.info_result.setText(str_result)
row_cnt = self.ui.table_result.rowCount()
diff_row_cnt = result_cnt - row_cnt
if diff_row_cnt < 0:
# print(">>")
for i in range(1, abs(diff_row_cnt) + 1):
self.ui.table_result.removeRow(row_cnt - i)
# print(i)
else:
for i in range(0, abs(diff_row_cnt)):
self.ui.table_result.insertRow(row_cnt + i)
for i in range(0, self.ui.table_result.rowCount()):
for j in range(0, self.ui.table_result.columnCount()):
item = QTableWidgetItem()
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.ui.table_result.setItem(i, j, item)
for i in range(0, result_cnt):
self.ui.table_result.item(i, 0).setText(str(i + 1))
self.ui.table_result.item(i, 1).setText(dic_result['학교명'][i])
self.ui.table_result.item(i, 2).setText(dic_result['관할지역청'][i])
self.ui.table_result.item(i, 3).setText(dic_result['공사립'][i])
self.ui.table_result.item(i, 4).setText(dic_result['우편번호'][i])
self.ui.table_result.item(i, 5).setText(dic_result['도로명주소'][i])
def _add_record_view(self, record: PatientBoneAgeRecord):
row = self.rowCount()
self.insertRow(row)
self._records_rows[record] = row
name = '' if record.image is None else record.image.path.stem
name_item = QTableWidgetItem(name)
name_item.setTextAlignment(Qt.AlignCenter)
# Add the |record| reference to the |name_item|
name_item.setData(TableItemDataRole.RECORD_REF, record)
self.setItem(row, self.column_number(TableNameColumn), name_item)
gender_widget = GenderWidget(embedded=True)
gender_widget.man = record.male
gender_widget.gender_changed.connect(
partial(self._on_gender_changed, record))
record.male_changed.connect(
partial(self._on_record_male_changed, gender_widget))
self.setCellWidget(row, self.column_number(TableGenderColumn),
gender_widget)
birthdate_edit_widget = DateEditWidget(record.birthdate, embedded=True)
birthdate_edit_widget.dateChanged.connect(
partial(self._on_birthdate_changed, record))
self.setCellWidget(row, self.column_number(TableBirthdateColumn),
birthdate_edit_widget)
image_date_edit_widget = DateEditWidget(record.image_date,
embedded=True)
image_date_edit_widget.dateChanged.connect(
partial(self._on_image_date_changed, record))
self.setCellWidget(row, self.column_number(TableImageDateColumn),
image_date_edit_widget)
age_in_image_item = QTableWidgetItem()
age_in_image_item.setFlags(age_in_image_item.flags()
& ~Qt.ItemIsEditable)
age_in_image_item.setTextAlignment(Qt.AlignCenter)
record.age_in_image_changed.connect(
partial(self._set_age_to_table_item, age_in_image_item))
self.setItem(row, self.column_number(TableAgeInImageColumn),
age_in_image_item)
bone_age_item = QTableWidgetItem()
bone_age_item.setFlags(bone_age_item.flags() & ~Qt.ItemIsEditable)
record.bone_age_changed.connect(
partial(self._set_age_to_table_item, bone_age_item))
record.skeletal_development_rate_changed.connect(
partial(self._on_skeletal_development_rate_changed, record))
self.setItem(row, self.column_number(TableDenseNetBoneAgeColumn),
bone_age_item)
self._update_bone_age_table_item_foreground(record)
height_spin_box = QDoubleSpinBox()
height_spin_box.setAlignment(Qt.AlignCenter)
height_spin_box.setFrame(False)
height_spin_box.setDecimals(1)
height_spin_box.setMaximum(300)
self._set_height_to_table_item_widget(height_spin_box, record.height)
record.height_changed.connect(
partial(self._set_height_to_table_item_widget, height_spin_box))
height_spin_box.valueChanged.connect(
partial(self._on_height_table_item_widget_value_changed, record))
self.setCellWidget(row, self.column_number(TableHeightColumn),
height_spin_box)
max_height_item = QTableWidgetItem()
max_height_item.setFlags(max_height_item.flags() & ~Qt.ItemIsEditable)
max_height_item.setTextAlignment(Qt.AlignCenter)
self._set_max_height_to_table_item(max_height_item, record.max_height)
record.max_height_changed.connect(
partial(self._set_max_height_to_table_item, max_height_item))
self.setItem(row, self.column_number(TableMaxHeightColumn),
max_height_item)
self._update_age_column_contents_for_row(row)
