def makeModel(self, results, index = 2):
getAttr = [lambda obj: obj.name,
lambda obj: obj.size[0]*(1024**obj.size[1]),
lambda obj: obj.seed,
lambda obj: obj.leach]
col = len(results)
ascending = False if index == self.currentColumnSort[0] and self.currentColumnSort[1] else True
self.currentColumnSort = [index, ascending]
model = QStandardItemModel(col, 4, self)
columnHeaderItems = [QStandardItem(column) for column in "Name", "Size", "Seeds", "Leachs"]
columnHeaderItems[index].setIcon(self.ascendingIcon if ascending else self.descendingIcon)
for i in range(4):
model.setHorizontalHeaderItem(i, columnHeaderItems[i])
if results:
results = list_to_tree(results, lambda x, y: getAttr[index](x) > getAttr[index](y))
if ascending: results = results.postOrder()
else: results = results.preOrder()
self.results = results
for i in range(col):
result = results[i]
size = from_bit_to(result.size[0]*1024**result.size[1])
model.setItem(i, 0, QStandardItem(result.name))
model.setItem(i, 1, QStandardItem(size))
model.setItem(i, 2, QStandardItem(str(result.seed)))
model.setItem(i, 3, QStandardItem(str(result.leach)))
return model
def _guiUpdate_table(self,uuid):
""
self.dbconn=DbConn()
# self.uuid=self.dbconn.get_uuid()
uuid=''
self.meta=self.dbconn.get_meta_kv()[uuid]
keys=self.meta.keys()
model=QStandardItemModel()
model.setHorizontalHeaderItem(0,QStandardItem("Attribute"))
model.setHorizontalHeaderItem(1,QStandardItem("Value"))
for k in keys:
name=self.meta[k]['Attribute']
item1 = QStandardItem(k)
item2 = QStandardItem(name)
item1.setCheckable(True)
model.appendRow([item1,item2])
# model.itemChanged.connect(lambda: on_item_changed())
self.model=model
self.ui.metaeditor.setModel(model)
self.ui.metaeditor.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.ui.metaeditor.sortByColumn(1)
self.ui.metaeditor.resizeColumnsToContents()
def on_ions_updated(self, new_ions):
qmodel = QStandardItemModel()
qmodel.setColumnCount(2)
qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion'))
qmodel.setHorizontalHeaderItem(1, QStandardItem('Abundance (%)'))
root = qmodel.invisibleRootItem()
element_keyfunc = lambda x: x.isotope.element
sorted_ions = sorted(new_ions, key=element_keyfunc)
for element, ions in itertools.groupby(sorted_ions, key=element_keyfunc):
element_item = QStandardItem(element)
element_item.setCheckable(True)
element_item.setCheckState(2)
root.appendRow(element_item)
for ion in ions:
ion_name = QStandardItem(ion.name)
ion_name.setData(ion,32)
ion_name.emitDataChanged()
ion_abundance = QStandardItem(str(ion.isotope.abundance))
element_item.appendRow([ion_name, ion_abundance])
self.ionlistTree.setModel(qmodel)
self.ionlistTree.expandAll()
self.addionsButton.setEnabled(True)
self._qmodel=qmodel
def on_analyses_viewmodel_updated(self, view_model):
qmodel = QStandardItemModel()
qmodel.itemChanged.connect(self.on_qmodel_itemChanged)
qmodel.setColumnCount(5)
qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion'))
qmodel.setHorizontalHeaderItem(1, QStandardItem('Method'))
qmodel.setHorizontalHeaderItem(2, QStandardItem('Start'))
qmodel.setHorizontalHeaderItem(3, QStandardItem('End'))
qmodel.setHorizontalHeaderItem(4, QStandardItem('Reason'))
root = qmodel.invisibleRootItem()
for ion, analysis in view_model.analyses.items():
ion_name = QStandardItem(ion.name)
ion_name.setData(ion, Qt.UserRole)
method = QStandardItem(analysis.method)
start = QStandardItem(str(round(analysis.range.start,2)))
end = QStandardItem(str(round(analysis.range.end,2)))
reason = QStandardItem(analysis.reason)
root.appendRow([ion_name, method, start, end, reason])
self.rangedTable.setModel(qmodel)
self.rangedTable.setItemDelegateForColumn(1, MethodsComboDelegate(view_model.methods, self.rangedTable))
for row in range(0, qmodel.rowCount()):
self.rangedTable.openPersistentEditor(qmodel.index(row, 1))
self.rangedTable.setColumnWidth(1, 95)
self.rangedTable.setContextMenuPolicy(3)
self.rangedTable.customContextMenuRequested.connect(self._context_menu_requested)
shortcut = QShortcut(QKeySequence('Del'), self.rangedTable, self._delete_ion,self._delete_ion, context=0)
def _guiUpdate_status(self,data):
""
model=QStandardItemModel()
model.setHorizontalHeaderItem(0,QStandardItem("attribute"))
model.setHorizontalHeaderItem(1,QStandardItem("status"))
for key in data.keys():
value=data[key]
item1 = QStandardItem(key)
item2 = QStandardItem(value)
# item1.setCheckable(True)
model.appendRow([item1,item2])
self.ui.outStatus.setModel(model)
self.ui.outStatus.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.ui.outStatus.resizeColumnsToContents()
class Menu(TreeViewTela):
def __init__(self, altura, parent=None):
super().__init__(altura, parent)
self._model = QStandardItemModel(0, 1)
self._model.setHorizontalHeaderItem(0, QStandardItem("Menu"))
self._itemsFuncoes = []
def setMenu(self, menu):
self._adicionarSubMenu(menu, self._model.invisibleRootItem())
self.setSelecionado(self._model.index(0,0))
def getMenuSelecionado(self):
sel = self.getSelecionado()
s = ''
while sel.isValid():
s = '/' + sel.data() + s
sel = sel.parent()
return s
def getFuncaoItem(self, item):
for i in self._itemsFuncoes:
if i.item == item.data():
return i.funcao
def getFuncaoItemSelecionado(self):
return self.getFuncaoItem(self.getSelecionado())
def _adicionarSubMenu(self, subMenu, pai):
if isinstance(subMenu, ItemFuncao):
item = QStandardItem(subMenu.item)
self._itemsFuncoes.append(subMenu)
pai.appendRow(item)
elif isinstance(subMenu, str):
pai.appendRow(QStandardItem(subMenu))
elif isinstance(subMenu, (tuple, list)):
for i in subMenu:
self._adicionarSubMenu(i, pai)
else:
for key, value in subMenu.items():
p = QStandardItem(key)
pai.appendRow(p)
self._adicionarSubMenu(value, p)
def update(self):
model = QStandardItemModel()
model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account')))
model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message')))
self.list_.setModel(model)
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
row = 0
for status in self.base.core.list_statuses_queue():
username = get_username_from(status.account_id)
protocol_image = "%s.png" % get_protocol_from(status.account_id)
item = QStandardItem(QString.fromUtf8(username))
item.setIcon(QIcon(self.base.load_image(protocol_image, True)))
model.setItem(row, 0, item)
model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text)))
row += 1
humanized_interval = self.base.humanize_time_intervals(
self.base.core.get_queue_interval())
humanized_est_time = self.base.humanize_time_intervals(est_time)
warning = i18n.get('messages_will_be_send') % humanized_interval
next_message = ' '.join(
[i18n.get('next_message_should_be_posted_in'), humanized_est_time])
self.caption.setText(warning)
if row == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.list_.resizeColumnsToContents()
self.__enable()
def _guiUpdate_UUID(self):
""
self.dbconn=DbConn()
self.uuid=self.dbconn.get_uuid()
keys=self.uuid.keys()
model=QStandardItemModel()
model.setHorizontalHeaderItem(0,QStandardItem("UUID"))
model.setHorizontalHeaderItem(1,QStandardItem("Path"))
def on_item_changed():
i = 0
list=[]
while model.item(i):
if not model.item(i,0).checkState():
""
# return
else:
# print model.item(i,0).text()
list.append(model.item(i,0).text())
i += 1
self.UUIDList=list
for key in keys:
name=self.uuid[key]['Path']
item1 = QStandardItem(key)
item2 = QStandardItem(name)
# item1.setCheckable(True)
model.appendRow([item1,item2])
model.itemChanged.connect(lambda: on_item_changed())
self.ui.model=model
self.ui.inUUIDList.setModel(model)
self.ui.inUUIDList.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.ui.inUUIDList.sortByColumn(1)
self.ui.inUUIDList.resizeColumnsToContents()
def update(self):
model = QStandardItemModel()
model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account')))
model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message')))
self.list_.setModel(model)
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
row = 0
for status in self.base.core.list_statuses_queue():
username = get_username_from(status.account_id)
protocol_image = "%s.png" % get_protocol_from(status.account_id)
item = QStandardItem(QString.fromUtf8(username))
item.setIcon(QIcon(self.base.load_image(protocol_image, True)))
model.setItem(row, 0, item)
model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text)))
row += 1
humanized_interval = self.base.humanize_time_intervals(self.base.core.get_queue_interval())
humanized_est_time = self.base.humanize_time_intervals(est_time)
warning = i18n.get('messages_will_be_send') % humanized_interval
next_message = ' '.join([i18n.get('next_message_should_be_posted_in'), humanized_est_time])
self.caption.setText(warning)
if row == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.list_.resizeColumnsToContents()
self.__enable()
def _guiInit(self):
""
keys=self.uuid.keys()
# self.selUUIDList=[]
model=QStandardItemModel()
model.setHorizontalHeaderItem(0,QStandardItem("UUID"))
model.setHorizontalHeaderItem(1,QStandardItem("Path"))
def on_item_changed():
i = 0
list=[]
while model.item(i):
if not model.item(i,0).checkState():
""
# return
else:
list.append(model.item(i,0).text())
i += 1
self.UUIDList=list
for key in keys:
name=self.uuid[key]['Path']
item1 = QStandardItem(key)
item2 = QStandardItem(name)
item1.setCheckable(True)
model.appendRow([item1,item2])
model.itemChanged.connect(lambda: on_item_changed())
self.ui.inUUIDList.setModel(model)
self.ui.inUUIDList.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.ui.inUUIDList.sortByColumn(1)
class LookupValueSelector(QDialog, Ui_LookupValueSelector):
"""
A dialog that enables to select a value and code from a lookup.
.. versionadded:: 1.5
"""
def __init__(self, parent, lookup_entity_name, profile=None):
"""
"""
QDialog.__init__(self, parent, Qt.WindowTitleHint|Qt.WindowCloseButtonHint)
self.setupUi(self)
self.value_and_code = None
if profile is None:
self._profile = current_profile()
else:
self._profile = profile
self.lookup_entity = self._profile.entity_by_name(
'{}_{}'.format(self._profile.prefix, lookup_entity_name)
)
self.notice = NotificationBar(self.notice_bar)
self._view_model = QStandardItemModel()
self.value_list_box.setModel(self._view_model)
header_item = QStandardItem(lookup_entity_name)
self._view_model.setHorizontalHeaderItem(0, header_item)
self.populate_value_list_view()
self.selected_code = None
self.selected_value_code = None
self.value_list_box.clicked.connect(self.validate_selected_code)
def populate_value_list_view(self):
self.value_and_code = self.lookup_entity.values
for value, code in self.value_and_code.iteritems():
value_code = QStandardItem('{} ({})'.format(value, code.code))
value_code.setData(code.code)
self._view_model.appendRow(value_code)
def validate_selected_code(self):
self.notice.clear()
self.selected_code_value()
if self.selected_code == '':
notice = QApplication.tr(self, 'The selected value has no code.')
self.notice.insertWarningNotification(notice)
def selected_code_value(self):
index = self.value_list_box.currentIndex()
item = self._view_model.itemFromIndex(index)
self.selected_code = item.data()
self.selected_value_code = item.text()
def accept(self):
self.selected_code_value()
self.done(1)
def reject(self):
self.selected_code = None
self.selected_value_code = None
self.done(0)
class FileTypes(base2, form2):
def __init__(self, parent=None):
super(base2, self).__init__(parent)
self.setupUi(self)
self.model = QStandardItemModel()
self.model.itemChanged.connect(self.on_item_changed)
self.model.setHorizontalHeaderItem(0, QStandardItem(""))
self.model_init()
self.saveButton.clicked.connect(self.save)
self.okCancelBox.accepted.connect(self.accept)
self.okCancelBox.rejected.connect(self.reject)
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.openMenu)
self.treeView.setToolTip(
'Here you can select file types that you want to find. Also you can\nadd new category or file type. Click right button on it.'
)
def model_init(self):
categories = {}
if not categories:
with open('categories.json') as f:
categories = load(f)
for element in categories:
catItem = QStandardItem(element.keys()[0])
catItem.setCheckable(True)
catItem.setCheckState(element[element.keys()[0]])
for type_name, check_state in element["Types"].items():
typeItem = QStandardItem(type_name)
typeItem.setCheckable(True)
typeItem.setCheckState(check_state)
catItem.appendRow(typeItem)
self.model.appendRow(catItem)
self.treeView.setModel(self.model)
self.submit_file_types()
def quit(self):
self.close()
def on_item_changed(self, item):
if item.checkState() == Qt.Checked:
if item.hasChildren():
for row in range(item.rowCount()):
item.child(row).setCheckState(Qt.Checked)
else:
item.parent().setCheckState(Qt.PartiallyChecked)
elif item.checkState() == Qt.Unchecked:
if item.hasChildren():
for row in range(item.rowCount()):
item.child(row).setCheckState(Qt.Unchecked)
else:
children = range(item.parent().rowCount())
children.pop(item.index().row())
for row in children:
if item.parent().child(row).checkState():
return
item.parent().setCheckState(Qt.Unchecked)
def submit_file_types(self):
categories = []
root = self.model.invisibleRootItem()
for num_cat in range(root.rowCount()):
category = root.child(num_cat, 0)
categories.append({
str(category.text()): category.checkState(),
"Types": {}
})
for num_type in range(category.rowCount()):
type = category.child(num_type, 0)
categories[-1]["Types"].update(
{str(type.text()): type.checkState()})
return categories
def openMenu(self, position):
level = 0
index = self.treeView.selectedIndexes()[0]
while index.parent().isValid():
index = index.parent()
level += 1
menu = QMenu()
if level == 0:
menu.addAction(self.tr("Add category"), self.add_category)
menu.addAction(self.tr("Add type"), self.add_type)
menu.addAction(self.tr("Remove"), self.remove)
elif level == 1:
menu.addAction(self.tr("Add type"), self.add_type)
menu.addAction(self.tr("Remove"), self.remove)
menu.exec_(self.treeView.viewport().mapToGlobal(position))
def add_category(self):
text, ok = QInputDialog.getText(self, 'Create new category',
'Category name:')
if ok:
catItem = QStandardItem(text)
catItem.setCheckable(True)
self.model.appendRow(catItem)
#self.label.setText(unicode(text))
def add_type(self):
text, ok = QInputDialog.getText(self, 'Add new type', 'Postfix:')
if ok:
catType = QStandardItem(text)
catType.setCheckable(True)
index = self.treeView.selectedIndexes()[0]
if self.model.itemFromIndex(index).hasChildren():
self.model.itemFromIndex(index).appendRow(catType)
else:
self.model.itemFromIndex(index).parent().appendRow(catType)
def save(self):
with open('categories.json', 'w') as f:
dump(self.submit_file_types(), f)
def remove(self):
index = self.treeView.selectedIndexes()[0]
parent = self.model.itemFromIndex(index).parent()
if parent:
self.model.removeRow(index.row(), parent.index())
else:
parent = self.model.invisibleRootItem()
self.model.removeRow(index.row(), parent.index())
@staticmethod
def call():
dialog = FileTypes()
result = dialog.exec_()
categories = dialog.submit_file_types()
return categories, result == QDialog.Accepted
item = QStandardItem(str(i))
parent.appendRow(item)
parent.appendRow(QStandardItem(str(i+1)))
parent = item"""
"""model = QStandardItemModel(10, 4)
for i in range(10):
for j in range(4):
item = QStandardItem("({0}, {1})".format(i, j))
model.setItem(i, j, item)
if i == 1:
item.appendRow([QStandardItem("..({0}, {1})".format(i*3, k)) for k in range(4)])
"""
model = QStandardItemModel(2,1)
model.setHorizontalHeaderItem(0,QStandardItem("Menu"))
cadastro = QStandardItem("Cadastro")
model.setItem(0,0,cadastro)
pesquisa = QStandardItem("Pesquisa")
model.setItem(1,0,pesquisa)
for i in ["Usuarios", "Empresas"]:
cadastro.appendRow(QStandardItem(i))
pesquisa.appendRow(QStandardItem(i))
parent = QModelIndex()
"""model = QDirModel()
model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
parent = model.index(QDir.currentPath())"""
def find_rules(self):
if self.data is None or not len(self.data):
return
if self._is_running:
return
self._is_running = True
data = self.data
self.table.model().clear()
n_examples = len(data)
NumericItem = self.NumericItem
StandardItem = self.StandardItem
filterSearch = self.filterSearch
itemsetMin = self.filterAntecedentMin + self.filterConsequentMin
itemsetMax = self.filterAntecedentMax + self.filterConsequentMax
isSizeMatch = self.isSizeMatch
isRegexMatch = self.isRegexMatch
X, mapping = OneHot.encode(data, self.classify)
self.error(911)
if X is None:
self.error(911, 'Need some discrete data to work with.')
self.onehot_mapping = mapping
ITEM_FMT = '{}' if issparse(data.X) else '{}={}'
names = {
item:
('{}={}' if var is data.domain.class_var else ITEM_FMT).format(
var.name, val)
for item, var, val in OneHot.decode(mapping, data, mapping)
}
# Items that consequent must include if classifying
class_items = {
item
for item, var, val in OneHot.decode(mapping, data, mapping)
if var is data.domain.class_var
} if self.classify else set()
assert bool(class_items) == bool(self.classify)
model = QStandardItemModel(self.table)
for col, (label, tooltip) in enumerate([
("Supp", "Support"),
("Conf", "Confidence (support / antecedent support)"),
("Covr", "Coverage (antecedent support / number of examples)"),
("Strg", "Strength (consequent support / antecedent support)"),
("Lift",
"Lift (number of examples * confidence / consequent support)"),
("Levr",
"Leverage ((support * number of examples - antecedent support * consequent support) / (number of examples)²)"
), ("Antecedent", None), ("", None), ("Consequent", None)
]):
item = QStandardItem(label)
item.setToolTip(tooltip)
model.setHorizontalHeaderItem(col, item)
#~ # Aggregate rules by common (support,confidence) for scatterplot
#~ scatter_agg = defaultdict(list)
# Find itemsets
nRules = 0
itemsets = {}
with self.progressBar(self.maxRules + 1) as progress:
for itemset, support in frequent_itemsets(X,
self.minSupport / 100):
itemsets[itemset] = support
if class_items and not class_items & itemset:
continue
# Filter itemset by joined filters before descending into it
itemset_str = ' '.join(names[i] for i in itemset)
if (filterSearch and
(len(itemset) < itemsetMin or itemsetMax < len(itemset)
or not isRegexMatch(itemset_str, itemset_str))):
continue
for rule in association_rules(itemsets,
self.minConfidence / 100,
itemset):
left, right, support, confidence = rule
if class_items and right - class_items:
continue
if filterSearch and not isSizeMatch(len(left), len(right)):
continue
left_str = ', '.join(names[i] for i in sorted(left))
right_str = ', '.join(names[i] for i in sorted(right))
if filterSearch and not isRegexMatch(left_str, right_str):
continue
# All filters matched, calculate stats and add table row
_, _, _, _, coverage, strength, lift, leverage = next(
rules_stats((rule, ), itemsets, n_examples))
support_item = NumericItem(support / n_examples)
# Set row data on first column
support_item.setData(
(itemset - class_items, class_items and
(class_items & itemset).pop()), self.ROW_DATA_ROLE)
left_item = StandardItem(left_str, len(left))
left_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
model.appendRow([
support_item,
NumericItem(confidence),
NumericItem(coverage),
NumericItem(strength),
NumericItem(lift),
NumericItem(leverage), left_item,
StandardItem('→'),
StandardItem(right_str, len(right))
])
#~ scatter_agg[(round(support / n_examples, 2), round(confidence, 2))].append((left, right))
nRules += 1
progress.advance()
if nRules >= self.maxRules:
break
if nRules >= self.maxRules:
break
# Populate the TableView
table = self.table
table.setHidden(True)
table.setSortingEnabled(False)
proxy_model = self.proxy_model
proxy_model.setSourceModel(model)
table.setModel(proxy_model)
for i in range(model.columnCount()):
table.resizeColumnToContents(i)
table.setSortingEnabled(True)
table.setHidden(False)
self.nRules = nRules
self.nFilteredRules = proxy_model.rowCount(
) # TODO: continue; also add in owitemsets
self.nSelectedRules = 0
self.nSelectedExamples = 0
self._is_running = False
def set_groups(self, keys, groups, relevant_keys, relevant_items,
all_values, uniquepos):
"""Set the current data groups and update the Group widget
"""
layout = QVBoxLayout()
header_widths = []
header_views = []
palette = self.palette()
all_values = all_values.keys()
def for_print(rd):
attrs = []
for d in rd:
attr = Orange.data.ContinuousVariable(next(inactive_name_gen))
attr.attributes.update(d)
attrs.append(attr)
return Orange.data.Domain(attrs, None)
for separatev, domain in [(None, for_print(relevant_items))] + groups:
label = None
if separatev is not None:
ann_vals = " <b>|</b> ".join(["<b>{0}</ b> = {1}".format(key,val) \
for key, val in zip(keys, separatev)])
label = QLabel(ann_vals)
model = QStandardItemModel()
for i, attr in enumerate(domain.attributes):
item = QStandardItem()
if separatev is not None:
isunique = uniquepos[separatev][i]
else:
isunique = all(a[i] for a in uniquepos.values())
if str(attr.name).startswith(
"!!missing "
): # TODO: Change this to not depend on name
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(
header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setFlags(Qt.NoItemFlags)
item.setData(QColor(Qt.red), Qt.ForegroundRole)
item.setData(
palette.color(QPalette.Disabled, QPalette.Window),
Qt.BackgroundRole)
item.setData("Missing feature.", Qt.ToolTipRole)
elif str(attr.name).startswith("!!inactive "):
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key in relevant_items[i]]
header_text = "\n".join(
header_text) if header_text else "No descriptor"
item.setData(header_text, Qt.DisplayRole)
item.setData(
palette.color(QPalette.Disabled, QPalette.Window),
Qt.BackgroundRole)
else:
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(
header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setData(attr.name, Qt.ToolTipRole)
if not isunique:
item.setData(QColor(Qt.red), Qt.ForegroundRole)
model.setHorizontalHeaderItem(i, item)
attr_count = len(domain.attributes)
view = MyHeaderView(Qt.Horizontal)
view.setResizeMode(QHeaderView.Fixed)
view.setModel(model)
hint = view.sizeHint()
view.setMaximumHeight(hint.height())
widths = [view.sectionSizeHint(i) for i in range(attr_count)]
header_widths.append(widths)
header_views.append(view)
if label:
layout.addWidget(label)
layout.addWidget(view)
layout.addSpacing(8)
# Make all header sections the same width
width_sum = 0
max_header_count = max([h.count() for h in header_views])
for i in range(max_header_count):
max_width = max([w[i] for w in header_widths if i < len(w)] or [0])
for view in header_views:
if i < view.count():
view.resizeSection(i, max_width)
width_sum += max_width + 2
for h in header_views:
h.setMinimumWidth(h.length() + 4)
widget = QWidget()
widget.setLayout(layout)
widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum)
layout.activate()
max_width = max(h.length() for h in header_views) + 20
left, _, right, _ = self.getContentsMargins()
widget.setMinimumWidth(width_sum)
widget.setMinimumWidth(max_width + left + right)
self.groups_scroll_area.setWidget(widget)
class GPSV2(COMCUPluginBase, Ui_GPSV2):
qtcb_pps = pyqtSignal()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletGPSV2, *args)
self.setupUi(self)
self.gps = self.device
self.cbe_universal = CallbackEmulator(self.get_universal,
self.cb_universal,
self.increase_error_count)
self.cbe_universal_gps = CallbackEmulator(self.get_universal_gps,
self.cb_universal_gps,
self.increase_error_count)
self.cbe_universal_glo = CallbackEmulator(self.get_universal_glo,
self.cb_universal_glo,
self.increase_error_count)
self.qtcb_pps.connect(self.cb_pps)
self.gps.register_callback(self.gps.CALLBACK_PULSE_PER_SECOND,
self.qtcb_pps.emit)
self.format_combobox.currentIndexChanged.connect(self.format_changed)
self.show_pos.clicked.connect(self.show_pos_clicked)
self.hot_start.clicked.connect(lambda: self.restart_clicked(0))
self.warm_start.clicked.connect(lambda: self.restart_clicked(1))
self.cold_start.clicked.connect(lambda: self.restart_clicked(2))
self.factory_reset.clicked.connect(lambda: self.restart_clicked(3))
self.had_fix = False
self.last_lat = 0
self.last_ns = 'U'
self.last_long = 0
self.last_ew = 'U'
self.gps_counter = 0
self.glo_counter = 0
self.gps_model = QStandardItemModel(32, 3, self)
self.gps_table.setModel(self.gps_model)
self.gps_model.setHorizontalHeaderItem(0,
QStandardItem(u'Elevation (°)'))
self.gps_model.setHorizontalHeaderItem(1,
QStandardItem(u'Azimuth (°)'))
self.gps_model.setHorizontalHeaderItem(2, QStandardItem(u'SNR (dB)'))
for i in range(32):
self.gps_model.setVerticalHeaderItem(
i, QStandardItem(u'Sat ' + str(i + 1)))
self.gps_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.glo_model = QStandardItemModel(32, 3, self)
self.glo_table.setModel(self.glo_model)
self.glo_model.setHorizontalHeaderItem(0,
QStandardItem(u'Elevation (°)'))
self.glo_model.setHorizontalHeaderItem(1,
QStandardItem(u'Azimuth (°)'))
self.glo_model.setHorizontalHeaderItem(2, QStandardItem(u'SNR (dB)'))
for i in range(32):
self.glo_model.setVerticalHeaderItem(
i, QStandardItem(u'Sat ' + str(i + 1 + 64)))
self.glo_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.fix_led_off_action = QAction('Off', self)
self.fix_led_off_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_OFF))
self.fix_led_on_action = QAction('On', self)
self.fix_led_on_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.FIX_LED_CONFIG_ON
))
self.fix_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.fix_led_show_heartbeat_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_HEARTBEAT))
self.fix_led_show_fix_action = QAction('Show Fix', self)
self.fix_led_show_fix_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_FIX))
self.fix_led_show_pps_action = QAction('Show PPS', self)
self.fix_led_show_pps_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_PPS))
self.extra_configs += [(1, 'Fix LED:', [
self.fix_led_off_action, self.fix_led_on_action,
self.fix_led_show_heartbeat_action, self.fix_led_show_fix_action,
self.fix_led_show_pps_action
])]
def cb_pps(self):
self.fix.setStyleSheet("QLabel { color : green; }")
QTimer.singleShot(200, self.cb_pps_off)
def cb_pps_off(self):
self.fix.setStyleSheet("")
def get_universal(self):
return self.gps.get_coordinates(
), self.gps.get_status(), self.gps.get_altitude(), self.gps.get_motion(
), self.gps.get_date_time()
def get_universal_gps(self):
counter = self.gps_counter
self.gps_counter = (self.gps_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(
self.gps.SATELLITE_SYSTEM_GPS)
else:
return counter, self.gps.get_satellite_status(
self.gps.SATELLITE_SYSTEM_GPS, counter)
def get_universal_glo(self):
counter = self.glo_counter
self.glo_counter = (self.glo_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(
self.gps.SATELLITE_SYSTEM_GLONASS)
else:
return counter, self.gps.get_satellite_status(
self.gps.SATELLITE_SYSTEM_GLONASS, counter)
def cb_universal_gps(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.gps_fix, self.gps_dop,
self.gps_satallites_used, x)
else:
self.update_table(self.gps_model, counter, x)
except:
pass
def cb_universal_glo(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.glo_fix, self.glo_dop,
self.glo_satallites_used, x)
else:
self.update_table(self.glo_model, counter, x)
except:
pass
def update_dop(self, fix, dop, used, data):
if data.fix == 1:
fix.setText("No Fix")
elif data.fix == 2:
fix.setText("2D Fix")
elif data.fix == 3:
fix.setText("3D Fix")
else:
fix.setText("Unknown")
str_pdop = '%.2f' % (data.pdop / 100.0, )
str_hdop = '%.2f' % (data.hdop / 100.0, )
str_vdop = '%.2f' % (data.vdop / 100.0, )
dop.setText(
str(str_vdop) + ' / ' + str(str_hdop) + ' / ' + str(str_pdop))
if len(data.satellite_numbers) == 0:
used.setText('None')
else:
used.setText(', '.join(map(str, data.satellite_numbers)))
def update_table(self, table_model, num, data):
table_model.setItem(num - 1, 0, QStandardItem(str(data.elevation)))
table_model.setItem(num - 1, 1, QStandardItem(str(data.azimuth)))
table_model.setItem(num - 1, 2, QStandardItem(str(data.snr)))
def cb_universal(self, data):
try:
coordinates, status, altitude, motion, date_time = data
self.cb_coordinates(*coordinates)
self.cb_status(*status)
self.cb_altitude(*altitude)
self.cb_motion(*motion)
self.cb_date_time(*date_time)
except:
pass
def show_pos_clicked(self):
if self.had_fix:
google_str = self.last_ns + self.make_dd_dddddd(
self.last_lat,
True) + '+' + self.last_ew + self.make_dd_dddddd(
self.last_long, True)
QDesktopServices.openUrl(
QUrl('https://maps.google.com/maps?q=' + google_str))
else:
QDesktopServices.openUrl(
QUrl('http://www.google.com/moon/')) # :-)
def format_changed(self, index):
self.cb_coordinates(self.last_lat, self.last_ns, self.last_long,
self.last_ew)
def restart_clicked(self, restart_type):
if restart_type > 0:
self.had_fix = False # don't show cached data
self.last_lat = 0
self.last_ns = 'U'
self.last_long = 0
self.last_ew = 'U'
self.satellites_view.setText('0')
self.latitude.setText("Unknown")
self.ns.setText('U')
self.longitude.setText("Unknown")
self.ew.setText('U')
self.gps_dop.setText("Unknown")
self.glo_dop.setText("Unknown")
self.gps_satallites_used.setText("None")
self.glo_satallites_used.setText("None")
self.gps_fix.setText("No Fix")
self.glo_fix.setText("No Fix")
self.fix.setText("No")
for i in range(32):
self.gps_model.setItem(i, 0, QStandardItem('0'))
self.gps_model.setItem(i, 1, QStandardItem('0'))
self.gps_model.setItem(i, 2, QStandardItem('0'))
self.glo_model.setItem(i, 0, QStandardItem('0'))
self.glo_model.setItem(i, 1, QStandardItem('0'))
self.glo_model.setItem(i, 2, QStandardItem('0'))
self.altitude.setText("Unknown")
self.course.setText("(Unknown)")
self.speed.setText("Unknown")
if restart_type > 1:
self.time.setText("Unknown")
self.gps.restart(restart_type)
def get_fix_led_config_async(self, config):
if config == BrickletGPSV2.FIX_LED_CONFIG_OFF:
self.fix_led_off_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_ON:
self.fix_led_on_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_HEARTBEAT:
self.fix_led_show_heartbeat_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_FIX:
self.fix_led_show_fix_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_PPS:
self.fix_led_show_pps_action.trigger()
def start(self):
async_call(self.gps.get_fix_led_config, None,
self.get_fix_led_config_async, self.increase_error_count)
self.cbe_universal.set_period(250)
self.cbe_universal_gps.set_period(100)
self.cbe_universal_glo.set_period(100)
def stop(self):
self.cbe_universal.set_period(0)
self.cbe_universal_gps.set_period(0)
self.cbe_universal_glo.set_period(0)
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletGPSV2.DEVICE_IDENTIFIER
def make_ddmm_mmmmm(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
mmmmm = (mm - int(mm)) * 100000
dd_str = str(dd)
mm_str = str(int(mm))
mmmmm_str = str(int(mmmmm + 0.5))
while len(mm_str) < 2:
mm_str = '0' + mm_str
while len(mmmmm_str) < 5:
mmmmm_str = '0' + mmmmm_str
return u'{0}° {1}.{2}’'.format(dd_str, mm_str, mmmmm_str)
def make_dd_dddddd(self, degree, url=False):
if url:
return '%2.6f' % (degree / 1000000.0)
else:
return u'%2.6f°' % (degree / 1000000.0)
def make_ddmmss_sss(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
ss = (mm - int(mm)) * 60
sss = (ss - int(ss)) * 1000
dd_str = str(dd)
mm_str = str(int(mm))
ss_str = str(int(ss))
sss_str = str(int(sss + 0.5))
while len(mm_str) < 2:
mm_str = '0' + mm_str
while len(ss_str) < 2:
ss_str = '0' + ss_str
while len(sss_str) < 3:
sss_str = '0' + sss_str
return u'{0}° {1}’ {2}.{3}’’'.format(dd_str, mm_str, ss_str, sss_str)
def cb_coordinates(self, lat, ns, long_, ew):
if not self.had_fix:
return
self.last_lat = lat
self.last_ns = ns
self.last_long = long_
self.last_ew = ew
if not ns in ('N', 'S'):
self.latitude.setText("Unknown")
self.ns.setText('U')
else:
self.ns.setText(ns)
if self.format_combobox.currentIndex() == 0:
self.latitude.setText(self.make_ddmmss_sss(lat))
elif self.format_combobox.currentIndex() == 1:
self.latitude.setText(self.make_dd_dddddd(lat))
elif self.format_combobox.currentIndex() == 2:
self.latitude.setText(self.make_ddmm_mmmmm(lat))
if not ew in ('E', 'W'):
self.longitude.setText("Unknown")
self.ew.setText('U')
else:
self.ew.setText(ew)
if self.format_combobox.currentIndex() == 0:
self.longitude.setText(self.make_ddmmss_sss(long_))
elif self.format_combobox.currentIndex() == 1:
self.longitude.setText(self.make_dd_dddddd(long_))
elif self.format_combobox.currentIndex() == 2:
self.longitude.setText(self.make_ddmm_mmmmm(long_))
def cb_status(self, has_fix, satellites_view):
if has_fix:
self.fix.setText("Yes")
self.had_fix = True
else:
self.fix.setText("No")
self.satellites_view.setText(str(satellites_view))
def cb_altitude(self, altitude, geoidal_separation):
if not self.had_fix:
return
self.altitude.setText('%.2f m (Geoidal Separation: %.2f m)' %
(altitude / 100.0, geoidal_separation / 100.0))
def cb_motion(self, course, speed):
if not self.had_fix:
return
self.course.setText(u'(%.2f°)' % (course / 100.0, ))
self.speed.setText('%.2f km/h' % (speed / 100.0, ))
def cb_date_time(self, date, time):
yy = date % 100
yy += 2000
date /= 100
mm = date % 100
date /= 100
dd = date
time /= 1000
ss = time % 100
time /= 100
mins = time % 100
time /= 100
hh = time
try:
date_str = str(datetime.datetime(yy, mm, dd, hh, mins,
ss)) + " UTC"
except:
date_str = "Unknown"
self.time.setText(date_str)
class GPS(COMCUPluginBase, Ui_GPS):
qtcb_pps = pyqtSignal()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletGPSV2, *args)
self.setupUi(self)
self.gps = self.device
self.cbe_universal = CallbackEmulator(self.get_universal, self.cb_universal, self.increase_error_count)
self.cbe_universal_gps = CallbackEmulator(
self.get_universal_gps, self.cb_universal_gps, self.increase_error_count
)
self.cbe_universal_glo = CallbackEmulator(
self.get_universal_glo, self.cb_universal_glo, self.increase_error_count
)
self.qtcb_pps.connect(self.cb_pps)
self.gps.register_callback(self.gps.CALLBACK_PULSE_PER_SECOND, self.qtcb_pps.emit)
self.format_combobox.currentIndexChanged.connect(self.format_changed)
self.show_pos.clicked.connect(self.show_pos_clicked)
self.hot_start.clicked.connect(lambda: self.restart_clicked(0))
self.warm_start.clicked.connect(lambda: self.restart_clicked(1))
self.cold_start.clicked.connect(lambda: self.restart_clicked(2))
self.factory_reset.clicked.connect(lambda: self.restart_clicked(3))
self.had_fix = False
self.last_lat = 0
self.last_ns = "U"
self.last_long = 0
self.last_ew = "U"
self.gps_counter = 0
self.glo_counter = 0
self.gps_model = QStandardItemModel(32, 3, self)
self.gps_table.setModel(self.gps_model)
self.gps_model.setHorizontalHeaderItem(0, QStandardItem(u"Elevation (°)"))
self.gps_model.setHorizontalHeaderItem(1, QStandardItem(u"Azimuth (°)"))
self.gps_model.setHorizontalHeaderItem(2, QStandardItem(u"SNR (dB)"))
for i in range(32):
self.gps_model.setVerticalHeaderItem(i, QStandardItem(u"Sat " + str(i + 1)))
self.gps_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.glo_model = QStandardItemModel(32, 3, self)
self.glo_table.setModel(self.glo_model)
self.glo_model.setHorizontalHeaderItem(0, QStandardItem(u"Elevation (°)"))
self.glo_model.setHorizontalHeaderItem(1, QStandardItem(u"Azimuth (°)"))
self.glo_model.setHorizontalHeaderItem(2, QStandardItem(u"SNR (dB)"))
for i in range(32):
self.glo_model.setVerticalHeaderItem(i, QStandardItem(u"Sat " + str(i + 1 + 64)))
self.glo_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
def cb_pps(self):
self.fix.setStyleSheet("QLabel { color : green; }")
QTimer.singleShot(200, self.cb_pps_off)
def cb_pps_off(self):
self.fix.setStyleSheet("QLabel { color : black; }")
def get_universal(self):
return (
self.gps.get_coordinates(),
self.gps.get_status(),
self.gps.get_altitude(),
self.gps.get_motion(),
self.gps.get_date_time(),
)
def get_universal_gps(self):
counter = self.gps_counter
self.gps_counter = (self.gps_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(self.gps.SATELLITE_SYSTEM_GPS)
else:
return counter, self.gps.get_satellite_status(self.gps.SATELLITE_SYSTEM_GPS, counter)
def get_universal_glo(self):
counter = self.glo_counter
self.glo_counter = (self.glo_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(self.gps.SATELLITE_SYSTEM_GLONASS)
else:
return counter, self.gps.get_satellite_status(self.gps.SATELLITE_SYSTEM_GLONASS, counter)
def cb_universal_gps(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.gps_fix, self.gps_dop, self.gps_satallites_used, x)
else:
self.update_table(self.gps_model, counter, x)
except:
pass
def cb_universal_glo(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.glo_fix, self.glo_dop, self.glo_satallites_used, x)
else:
self.update_table(self.glo_model, counter, x)
except:
pass
def update_dop(self, fix, dop, used, data):
if data.fix == 1:
fix.setText("No Fix")
elif data.fix == 2:
fix.setText("2D Fix")
elif data.fix == 3:
fix.setText("3D Fix")
else:
fix.setText("Error")
str_pdop = "%.2f" % (data.pdop / 100.0,)
str_hdop = "%.2f" % (data.hdop / 100.0,)
str_vdop = "%.2f" % (data.vdop / 100.0,)
dop.setText(str(str_pdop) + " / " + str(str_hdop) + " / " + str(str_vdop))
sats = []
for sat in data.satellites:
if sat != 0:
sats.append(sat)
if len(sats) == 0:
used.setText("None")
else:
used.setText(", ".join(map(str, sats)))
def update_table(self, table_model, num, data):
table_model.setItem(num - 1, 0, QStandardItem(str(data.elevation)))
table_model.setItem(num - 1, 1, QStandardItem(str(data.azimuth)))
table_model.setItem(num - 1, 2, QStandardItem(str(data.snr)))
def cb_universal(self, data):
try:
coordinates, status, altitude, motion, date_time = data
self.cb_coordinates(*coordinates)
self.cb_status(*status)
self.cb_altitude(*altitude)
self.cb_motion(*motion)
self.cb_date_time(*date_time)
except:
pass
def show_pos_clicked(self):
if self.had_fix:
google_str = (
self.last_ns
+ self.make_dd_dddddd(self.last_lat, True)
+ "+"
+ self.last_ew
+ self.make_dd_dddddd(self.last_long, True)
)
QDesktopServices.openUrl(QUrl("https://maps.google.com/maps?q=" + google_str))
else:
QDesktopServices.openUrl(QUrl("http://www.google.com/moon/")) # :-)
def format_changed(self, index):
self.cb_coordinates(self.last_lat, self.last_ns, self.last_long, self.last_ew)
def restart_clicked(self, restart_type):
if restart_type > 0:
self.had_fix = False # don't show cached data
self.last_lat = 0
self.last_ns = "U"
self.last_long = 0
self.last_ew = "U"
self.satellites_view.setText("0")
self.latitude.setText("Unknown")
self.ns.setText("U")
self.longitude.setText("Unknown")
self.ew.setText("U")
self.gps_dop.setText("Unknown")
self.glo_dop.setText("Unknown")
self.gps_satallites_used.setText("None")
self.glo_satallites_used.setText("None")
self.gps_fix.setText("No Fix")
self.glo_fix.setText("No Fix")
self.fix.setText("No")
for i in range(32):
self.gps_model.setItem(i, 0, QStandardItem("0"))
self.gps_model.setItem(i, 1, QStandardItem("0"))
self.gps_model.setItem(i, 2, QStandardItem("0"))
self.glo_model.setItem(i, 0, QStandardItem("0"))
self.glo_model.setItem(i, 1, QStandardItem("0"))
self.glo_model.setItem(i, 2, QStandardItem("0"))
self.altitude.setText("Unknown")
self.course.setText("(Unknown)")
self.speed.setText("Unknown")
if restart_type > 1:
self.time.setText("Unknown")
self.gps.restart(restart_type)
def start(self):
self.cbe_universal.set_period(250)
self.cbe_universal_gps.set_period(100)
self.cbe_universal_glo.set_period(100)
def stop(self):
self.cbe_universal.set_period(0)
self.cbe_universal_gps.set_period(0)
self.cbe_universal_glo.set_period(0)
def destroy(self):
pass
def get_url_part(self):
return "gps"
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletGPSV2.DEVICE_IDENTIFIER
def make_ddmm_mmmmm(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
mmmmm = (mm - int(mm)) * 100000
dd_str = str(dd)
mm_str = str(int(mm))
mmmmm_str = str(int(mmmmm + 0.5))
while len(mm_str) < 2:
mm_str = "0" + mm_str
while len(mmmmm_str) < 5:
mmmmm_str = "0" + mmmmm_str
return u"{0}° {1}.{2}’".format(dd_str, mm_str, mmmmm_str)
def make_dd_dddddd(self, degree, url=False):
if url:
return "%2.6f" % (degree / 1000000.0)
else:
return u"%2.6f°" % (degree / 1000000.0)
def make_ddmmss_sss(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
ss = (mm - int(mm)) * 60
sss = (ss - int(ss)) * 1000
dd_str = str(dd)
mm_str = str(int(mm))
ss_str = str(int(ss))
sss_str = str(int(sss + 0.5))
while len(mm_str) < 2:
mm_str = "0" + mm_str
while len(ss_str) < 2:
ss_str = "0" + ss_str
while len(sss_str) < 3:
sss_str = "0" + sss_str
return u"{0}° {1}’ {2}.{3}’’".format(dd_str, mm_str, ss_str, sss_str)
def cb_coordinates(self, lat, ns, long_, ew):
if not self.had_fix:
return
self.last_lat = lat
self.last_ns = ns
self.last_long = long_
self.last_ew = ew
if not ns in ("N", "S"):
self.latitude.setText("Unknown")
self.ns.setText("U")
else:
self.ns.setText(ns)
if self.format_combobox.currentIndex() == 0:
self.latitude.setText(self.make_ddmmss_sss(lat))
elif self.format_combobox.currentIndex() == 1:
self.latitude.setText(self.make_dd_dddddd(lat))
elif self.format_combobox.currentIndex() == 2:
self.latitude.setText(self.make_ddmm_mmmmm(lat))
if not ew in ("E", "W"):
self.longitude.setText("Unknown")
self.ew.setText("U")
else:
self.ew.setText(ew)
if self.format_combobox.currentIndex() == 0:
self.longitude.setText(self.make_ddmmss_sss(long_))
elif self.format_combobox.currentIndex() == 1:
self.longitude.setText(self.make_dd_dddddd(long_))
elif self.format_combobox.currentIndex() == 2:
self.longitude.setText(self.make_ddmm_mmmmm(long_))
def cb_status(self, has_fix, satellites_view):
if has_fix:
self.fix.setText("Yes")
self.had_fix = True
else:
self.fix.setText("No")
self.satellites_view.setText(str(satellites_view))
def cb_altitude(self, altitude, geoidal_separation):
if not self.had_fix:
return
self.altitude.setText("%.2f m (Geoidal Separation: %.2f m)" % (altitude / 100.0, geoidal_separation / 100.0))
def cb_motion(self, course, speed):
if not self.had_fix:
return
self.course.setText(u"(%.2f°)" % (course / 100.0,))
self.speed.setText("%.2f km/h" % (speed / 100.0,))
def cb_date_time(self, date, time):
yy = date % 100
yy += 2000
date /= 100
mm = date % 100
date /= 100
dd = date
time /= 1000
ss = time % 100
time /= 100
mins = time % 100
time /= 100
hh = time
try:
date_str = str(datetime.datetime(yy, mm, dd, hh, mins, ss)) + " UTC"
except:
date_str = "Unknown"
self.time.setText(date_str)
def set_groups(self, keys, groups, relevant_keys, relevant_items,
all_values, uniquepos):
"""Set the current data groups and update the Group widget
"""
layout = QVBoxLayout()
header_widths = []
header_views = []
palette = self.palette()
all_values = all_values.keys()
def for_print(rd):
attrs = []
for d in rd:
attr = Orange.data.ContinuousVariable(next(inactive_name_gen))
attr.attributes.update(d)
attrs.append(attr)
return Orange.data.Domain(attrs, None)
for separatev, domain in [(None, for_print(relevant_items))] + groups:
label = None
if separatev is not None:
ann_vals = " <b>|</b> ".join(["<b>{0}</ b> = {1}".format(key,val) \
for key, val in zip(keys, separatev)])
label = QLabel(ann_vals)
model = QStandardItemModel()
for i, attr in enumerate(domain.attributes):
item = QStandardItem()
if separatev is not None:
isunique = uniquepos[separatev][i]
else:
isunique = all(a[i] for a in uniquepos.values())
if str(attr.name).startswith("!!missing "): # TODO: Change this to not depend on name
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setFlags(Qt.NoItemFlags)
item.setData(QColor(Qt.red), Qt.ForegroundRole)
item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole)
item.setData("Missing feature.", Qt.ToolTipRole)
elif str(attr.name).startswith("!!inactive "):
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "No descriptor"
item.setData(header_text, Qt.DisplayRole)
item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole)
else:
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setData(attr.name, Qt.ToolTipRole)
if not isunique:
item.setData(QColor(Qt.red), Qt.ForegroundRole)
model.setHorizontalHeaderItem(i, item)
attr_count = len(domain.attributes)
view = MyHeaderView(Qt.Horizontal)
view.setResizeMode(QHeaderView.Fixed)
view.setModel(model)
hint = view.sizeHint()
view.setMaximumHeight(hint.height())
widths = [view.sectionSizeHint(i) for i in range(attr_count)]
header_widths.append(widths)
header_views.append(view)
if label:
layout.addWidget(label)
layout.addWidget(view)
layout.addSpacing(8)
# Make all header sections the same width
width_sum = 0
max_header_count = max([h.count() for h in header_views])
for i in range(max_header_count):
max_width = max([w[i] for w in header_widths if i < len(w)] or [0])
for view in header_views:
if i < view.count():
view.resizeSection(i, max_width)
width_sum += max_width + 2
for h in header_views:
h.setMinimumWidth(h.length() + 4)
widget = QWidget()
widget.setLayout(layout)
widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum)
layout.activate()
max_width = max(h.length() for h in header_views) + 20
left, _, right, _ = self.getContentsMargins()
widget.setMinimumWidth(width_sum)
widget.setMinimumWidth(max_width + left + right)
self.groups_scroll_area.setWidget(widget)
class TreeLegend(QObject):
toggledLegend = pyqtSignal(list)
descriptionLegend = pyqtSignal(str)
def __init__(self, treeView):
def init():
self.setHeader()
self.tree.setModel(self.model)
self.headerView.setMovable(False)
self.headerView.setClickable(True)
self.tree.setSelectionMode(0) # no selection
super(TreeLegend, self).__init__()
self.tree = treeView
#
self.hasConnect = self.layer = self.legendItems = None
self.visibleItems = []
self.model = QStandardItemModel(0, 1)
self.headerView = self.tree.header()
#
init()
self._connect()
def __del__(self):
if self.hasConnect:
self._connect(False)
self.model.clear()
self.layer.legendChanged.disconnect(self.updateLegendItems)
def _connect(self, isConnect=True):
ss = [{
'signal': self.tree.clicked,
'slot': self.toggleItem
}, {
'signal': self.headerView.sectionClicked,
'slot': self.toggleHeader
}, {
'signal': self.headerView.sectionDoubleClicked,
'slot': self.emitDescription
}]
if isConnect:
self.hasConnect = True
for item in ss:
item['signal'].connect(item['slot'])
else:
self.hasConnect = False
for item in ss:
item['signal'].disconnect(item['slot'])
def setHeader(self, data=None):
if data is None:
self.model.clear()
nameHeader = 'Select Raster Layer(Palette)'
font = QFont()
font.setStrikeOut(False)
headerModel = QStandardItem(nameHeader)
headerModel.setData(font, Qt.FontRole)
tip = "Raster with Palette(Single Band)"
headerModel.setData(tip, Qt.ToolTipRole)
self.model.setHorizontalHeaderItem(0, headerModel)
else:
headerModel = self.model.horizontalHeaderItem(0)
label = "%s" % data['name']
formatMgs = "Layer: %s\nSource: %s\nNumber Class: %d\nWidth: %d\nHeight: %d\nRes.X: %f\nRes.Y: %f\n\n* Double click copy to Clipboard"
dataMsg = (data['name'], data['source'], data['num_class'],
data['width'], data['height'], data['resX'],
data['resY'])
tip = formatMgs % dataMsg
headerModel.setData(data, Qt.UserRole)
headerModel.setData(label, Qt.DisplayRole)
headerModel.setData(tip, Qt.ToolTipRole)
def setLayer(self, layer):
self.legendItems = layer.legendSymbologyItems()
total = len(self.legendItems)
self.visibleItems = [True for x in range(total)]
data = {
'name': layer.name(),
'source': layer.source(),
'num_class': total,
'width': layer.width(),
'height': layer.height(),
'resX': layer.rasterUnitsPerPixelX(),
'resY': layer.rasterUnitsPerPixelY()
}
self.setHeader(data)
#
if not self.layer is None:
self.layer.legendChanged.disconnect(self.updateLegendItems)
layer.legendChanged.connect(self.updateLegendItems)
self.layer = layer
def setLegend(self, values):
def setHeader():
headerModel = self.model.horizontalHeaderItem(0)
data = headerModel.data(Qt.UserRole)
data['num_class'] = len(values)
self.setHeader(data)
def createItem(item):
(pixel, total) = item
(legend, color) = self.legendItems[pixel]
name = "[%d] %s" % (pixel, legend)
tip = "Value pixel: %d\nTotal pixels: %d\nClass name: %s" % (
pixel, total, legend)
pix = QPixmap(16, 16)
pix.fill(color)
font.setStrikeOut(not self.visibleItems[pixel])
#
itemModel = QStandardItem(QIcon(pix), name)
itemModel.setEditable(False)
itemModel.setData(font, Qt.FontRole)
itemModel.setData(tip, Qt.ToolTipRole)
itemModel.setData(item, Qt.UserRole)
#
return itemModel
setHeader()
self.model.removeRows(0, self.model.rowCount())
#
font = QFont()
for item in values:
self.model.appendRow(createItem(item))
def setEnabled(self, isEnable=True):
self._connect(isEnable)
self.tree.setEnabled(isEnable)
def getLayerName(self):
headerModel = self.model.horizontalHeaderItem(0)
return headerModel.data(Qt.UserRole)['name']
@pyqtSlot()
def updateLegendItems(self):
self.legendItems = self.layer.legendSymbologyItems()
# Refresh legend
rows = self.model.rowCount()
row = 0
while row < rows:
index = self.model.index(row, 0)
(pixel, total) = self.model.data(index, Qt.UserRole)
(legend, color) = self.legendItems[pixel]
pix = QPixmap(16, 16)
pix.fill(color)
self.model.setData(index, QIcon(pix), Qt.DecorationRole)
row += 1
@pyqtSlot('QModelIndex')
def toggleItem(self, index):
font = index.data(Qt.FontRole)
strike = not font.strikeOut()
font.setStrikeOut(strike)
self.model.setData(index, font, Qt.FontRole)
#
(pixel, total) = index.data(Qt.UserRole)
visible = not strike
self.visibleItems[pixel] = visible
#
self.toggledLegend.emit(self.visibleItems)
@pyqtSlot(int)
def toggleHeader(self, logical):
rowCount = self.model.rowCount()
if rowCount == 0:
return
header = self.model.horizontalHeaderItem(0)
font = header.data(Qt.FontRole)
strike = not font.strikeOut()
font.setStrikeOut(strike)
header.setData(font, Qt.FontRole)
#
items = []
row = 0
while row < self.model.rowCount():
index = self.model.index(row, 0)
self.model.setData(index, font, Qt.FontRole)
items.append(index.data(Qt.UserRole))
row += 1
visible = not strike
for item in items:
(pixel, total) = item
self.visibleItems[pixel] = visible
#
self.toggledLegend.emit(self.visibleItems)
@pyqtSlot(int)
def emitDescription(self):
def getDescription():
data = self.model.horizontalHeaderItem(0).data(Qt.UserRole)
formatMgs = "Layer: %s\nSource: %s\nNumber Class: %d\nWidth: %d\nHeight: %d\nRes.X: %f\nRes.Y: %f"
dataMsg = (data['name'], data['source'], data['num_class'],
data['width'], data['height'], data['resX'],
data['resY'])
descHeader = formatMgs % dataMsg
#
descItems = ["Value pixel;Total pixels;Class name"]
rows = self.model.rowCount()
row = 0
while row < rows:
index = self.model.index(row, 0)
(pixel, total) = self.model.data(index, Qt.UserRole)
(legend, color) = self.legendItems[pixel]
descItems.append("%d;%d;%s" % (pixel, total, legend))
row += 1
return "%s\n\n%s" % (descHeader, '\n'.join(descItems))
if self.model.rowCount() > 0:
self.descriptionLegend.emit(getDescription())
class LookupValueSelector(QDialog, Ui_LookupValueSelector):
"""
A dialog that enables to select a value and code from a lookup.
.. versionadded:: 1.5
"""
def __init__(self, parent, lookup_entity_name, profile=None):
"""
Initializes LookupValueSelector.
:param parent: The parent of the dialog.
:type parent: QWidget
:param lookup_entity_name: The lookup entity name
:type lookup_entity_name: String
:param profile: The current profile object
:type profile: Object
"""
QDialog.__init__(self, parent, Qt.WindowTitleHint |
Qt.WindowCloseButtonHint)
self.setupUi(self)
self.value_and_code = None
if profile is None:
self._profile = current_profile()
else:
self._profile = profile
self.lookup_entity = self._profile.entity_by_name(
'{}_{}'.format(self._profile.prefix, lookup_entity_name)
)
self.notice = NotificationBar(self.notice_bar)
self._view_model = QStandardItemModel()
self.value_list_box.setModel(self._view_model)
header_item = QStandardItem(lookup_entity_name)
self._view_model.setHorizontalHeaderItem(0, header_item)
self.populate_value_list_view()
self.selected_code = None
self.selected_value_code = None
self.value_list_box.clicked.connect(self.validate_selected_code)
def populate_value_list_view(self):
"""
Populates the lookup values and codes.
"""
self.value_and_code = self.lookup_entity.values
for value, code in self.value_and_code.iteritems():
u_value = unicode(value)
code_value = self.lookup_entity.values[u_value]
value_code = QStandardItem('{} ({})'.format(
code_value.value, code.code
)
)
value_code.setData(code.code)
self._view_model.appendRow(value_code)
def validate_selected_code(self):
"""
Validate the selected code for the presence of Code or not.
"""
self.notice.clear()
self.selected_code_value()
if self.selected_code == '':
notice = QApplication.tr(self, 'The selected value has no code.')
self.notice.insertWarningNotification(notice)
def selected_code_value(self):
"""
Get the selected lookup value.
"""
index = self.value_list_box.currentIndex()
item = self._view_model.itemFromIndex(index)
self.selected_code = item.data()
self.selected_value_code = item.text()
def accept(self):
"""
Overridden QDialog accept method.
"""
self.selected_code_value()
self.done(1)
def reject(self):
"""
Overridden QDialog accept method.
"""
self.selected_code = None
self.selected_value_code = None
self.done(0)
class LookupValueSelector(QDialog, Ui_LookupValueSelector):
"""
A dialog that enables to select a value and code from a lookup.
.. versionadded:: 1.5
"""
def __init__(self, parent, lookup_entity_name, profile=None):
"""
Initializes LookupValueSelector.
:param parent: The parent of the dialog.
:type parent: QWidget
:param lookup_entity_name: The lookup entity name
:type lookup_entity_name: String
:param profile: The current profile object
:type profile: Object
"""
QDialog.__init__(self, parent,
Qt.WindowTitleHint | Qt.WindowCloseButtonHint)
self.setupUi(self)
self.value_and_code = None
if profile is None:
self._profile = current_profile()
else:
self._profile = profile
self.lookup_entity = self._profile.entity_by_name('{}_{}'.format(
self._profile.prefix, lookup_entity_name))
self.notice = NotificationBar(self.notice_bar)
self._view_model = QStandardItemModel()
self.value_list_box.setModel(self._view_model)
header_item = QStandardItem(lookup_entity_name)
self._view_model.setHorizontalHeaderItem(0, header_item)
self.populate_value_list_view()
self.selected_code = None
self.selected_value_code = None
self.value_list_box.clicked.connect(self.validate_selected_code)
def populate_value_list_view(self):
"""
Populates the lookup values and codes.
"""
self.value_and_code = self.lookup_entity.values
for value, code in self.value_and_code.iteritems():
u_value = unicode(value)
code_value = self.lookup_entity.values[u_value]
value_code = QStandardItem('{} ({})'.format(
code_value.value, code.code))
value_code.setData(code.code)
self._view_model.appendRow(value_code)
def validate_selected_code(self):
"""
Validate the selected code for the presence of Code or not.
"""
self.notice.clear()
self.selected_code_value()
if self.selected_code == '':
notice = QApplication.tr(self, 'The selected value has no code.')
self.notice.insertWarningNotification(notice)
def selected_code_value(self):
"""
Get the selected lookup value.
"""
index = self.value_list_box.currentIndex()
item = self._view_model.itemFromIndex(index)
self.selected_code = item.data()
self.selected_value_code = item.text()
def accept(self):
"""
Overridden QDialog accept method.
"""
self.selected_code_value()
self.done(1)
def reject(self):
"""
Overridden QDialog accept method.
"""
self.selected_code = None
self.selected_value_code = None
self.done(0)
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setCentralWidget(self.ui.mangaTableView)
self.newMangaDialog = NewMangaDialog()
self.mangaDownloadDialog = MangaDownloadDialog()
self.mangaTableModel = QStandardItemModel(0, 3, self)
self.mangaTableModel.setHorizontalHeaderItem(0, QStandardItem(QString("Manga")))
self.mangaTableModel.setHorizontalHeaderItem(1, QStandardItem(QString("Latest Chapter")))
self.mangaTableModel.setHorizontalHeaderItem(2, QStandardItem(QString("Status")))
self.ui.mangaTableView.setModel(self.mangaTableModel)
newMangaAction = QAction(QIcon("./icon/add.ico"),'New Manga', self)
newMangaAction.setShortcut('Ctrl+N')
newMangaAction.triggered.connect(self.newMangaDialog.show)
removeMangaAction = QAction(QIcon("./icon/delete.ico"),'Remove Manga', self)
removeMangaAction.setShortcut('Delete')
preferencesAction = QAction(QIcon("./icon/preferences.ico"),'Preferences', self)
aboutAction = QAction(QIcon("./icon/about.ico"),'About', self)
self.ui.toolBar.addAction(newMangaAction)
self.ui.toolBar.addAction(removeMangaAction)
self.ui.toolBar.addSeparator()
self.ui.toolBar.addAction(preferencesAction)
self.ui.toolBar.addSeparator()
self.ui.toolBar.addAction(aboutAction)
self.progressBar = QProgressBar(self.ui.statusbar)
self.ui.statusbar.addPermanentWidget(self.progressBar)
self.progressBar.hide()
def closeEvent(self, QCloseEvent):
mangaList = []
for i in range(self.mangaTableModel.rowCount()):
mangaList.append({
"name" : str(self.mangaTableModel.item(i, 0).text()),
"latestChapter" : str(self.mangaTableModel.item(i, 1).text()),
"status" : "Updated",
"link" : "/trial.html"
})
self.emit(SIGNAL("applicationClosed"),mangaList)
def initializeProgressBar(self, size):
self.progressBar.setRange(0, size)
self.progressBar.setValue(0)
self.progressBar.show()
def updateProgressBar(self, value):
self.progressBar.setValue(value)
def updateStatusBar(self, msg):
self.ui.statusbar.showMessage(msg)
def updateMangaTable(self, chapter):
isFound = False
for i in range(self.mangaTableModel.rowCount()):
mangaItem = self.mangaTableModel.item(i)
if mangaItem.text() == chapter["name"]:
self.mangaTableModel.item(i, 1).setText(chapter["latestChapter"])
self.mangaTableModel.item(i, 2).setText(chapter["status"])
isFound = True
break
if not isFound:
self.addRowToMangaTable(chapter)
def addMangaListToMangaTable(self, mangaList):
for i in range(len(mangaList)):
self.addRowToMangaTable(mangaList[i])
def addRowToMangaTable(self, manga):
i = self.mangaTableModel.rowCount()
mangaItem = QStandardItem(QString(manga["name"]))
latestChapterItem = QStandardItem(QString(manga["latestChapter"]))
statusItem = QStandardItem(QString(manga["status"]))
brush = QBrush(QColor(255, 255, 255)) if i%2==0 else QBrush(QColor(200, 200, 200))
mangaItem.setBackground(brush)
latestChapterItem.setBackground(brush)
statusItem.setBackground(brush)
self.mangaTableModel.setItem(i, 0, mangaItem)
self.mangaTableModel.setItem(i, 1, latestChapterItem)
self.mangaTableModel.setItem(i, 2, statusItem)
def find_rules(self):
if self.data is None: return
data = self.data
self.table.model().clear()
n_examples = len(data)
NumericItem = self.NumericItem
StandardItem = self.StandardItem
filterSearch = self.filterSearch
itemsetMin = self.filterAntecedentMin + self.filterConsequentMin
itemsetMax = self.filterAntecedentMax + self.filterConsequentMax
isSizeMatch = self.isSizeMatch
isRegexMatch = self.isRegexMatch
X, mapping = OneHot.encode(data, self.classify)
self.onehot_mapping = mapping
names = {item: '{}={}'.format(var.name, val)
for item, var, val in OneHot.decode(mapping, data, mapping)}
# Items that consequent must include if classifying
class_items = {item
for item, var, val in OneHot.decode(mapping, data, mapping)
if var is data.domain.class_var} if self.classify else set()
assert bool(class_items) == bool(self.classify)
model = QStandardItemModel(self.table)
for col, (label, tooltip) in enumerate([("Supp", "Support"),
("Conf", "Confidence (support / antecedent support)"),
("Covr", "Coverage (antecedent support / number of examples)"),
("Strg", "Strength (consequent support / antecedent support)"),
("Lift", "Lift (number of examples * confidence / consequent support)"),
("Levr", "Leverage ((support * number of examples - antecedent support * consequent support) / (number of examples)²)"),
("Antecedent", None),
("", None),
("Consequent", None)]):
item = QStandardItem(label)
item.setToolTip(tooltip)
model.setHorizontalHeaderItem(col, item)
#~ # Aggregate rules by common (support,confidence) for scatterplot
#~ scatter_agg = defaultdict(list)
# Find itemsets
nRules = 0
itemsets = {}
progress = gui.ProgressBar(self, self.maxRules + 1)
for itemset, support in frequent_itemsets(X, self.minSupport / 100):
itemsets[itemset] = support
if class_items and not class_items & itemset:
continue
# Filter itemset by joined filters before descending into it
itemset_str = ' '.join(names[i] for i in itemset)
if (filterSearch and
(len(itemset) < itemsetMin or
itemsetMax < len(itemset) or
not isRegexMatch(itemset_str, itemset_str))):
continue
for rule in gen_assoc_rules(itemsets,
self.minConfidence / 100,
itemset):
(left, right), support, confidence = rule
if class_items and right - class_items:
continue
if filterSearch and not isSizeMatch(len(left), len(right)):
continue
left_str = ' '.join(names[i] for i in sorted(left))
right_str = ' '.join(names[i] for i in sorted(right))
if filterSearch and not isRegexMatch(left_str, right_str):
continue
# All filters matched, calculate stats and add table row
_, _, _, coverage, strength, lift, leverage = next(
rules_stats((rule,), itemsets, n_examples))
support_item = NumericItem(support / n_examples)
# Set row data on first column
support_item.setData((itemset - class_items,
class_items and (class_items & itemset).pop()),
self.ROW_DATA_ROLE)
left_item = StandardItem(left_str, len(left))
left_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
model.appendRow([support_item,
NumericItem(confidence),
NumericItem(coverage),
NumericItem(strength),
NumericItem(lift),
NumericItem(leverage),
left_item,
StandardItem('→'),
StandardItem(right_str, len(right))])
#~ scatter_agg[(round(support / n_examples, 2), round(confidence, 2))].append((left, right))
nRules += 1
progress.advance()
if nRules >= self.maxRules:
break
if nRules >= self.maxRules:
break
# Populate the TableView
table = self.table
table.setHidden(True)
table.setSortingEnabled(False)
proxy_model = self.proxy_model
proxy_model.setSourceModel(model)
table.setModel(proxy_model)
for i in range(model.columnCount()):
table.resizeColumnToContents(i)
table.setSortingEnabled(True)
table.setHidden(False)
progress.finish()
self.nRules = nRules
self.nFilteredRules = proxy_model.rowCount() # TODO: continue; also add in owitemsets
self.nSelectedRules = 0
self.nSelectedExamples = 0
def _guiUpdate_metaTable(self,uuid):
dbconn=DbConn()
meta=dbconn.get_meta_kv()
stream=meta[str(uuid)]
print stream
model=QStandardItemModel()
model.setHorizontalHeaderItem(0,QStandardItem("Attribute"))
model.setHorizontalHeaderItem(1,QStandardItem("Value"))
while model.rowCount() > 0:
model.removeRow(0)
for k in stream.keys():
name=stream[k]
# print name
# print k
item1 = QStandardItem(k)
item2 = QStandardItem(name)
# item=QTableWidgetItem()
# item.setText(1,name)
# item.setText(2,k)
# self.ui.metaEditor
# model.appendRow([item1,item2])
# self.ui.metaEditor.appendI
model.appendRow([item1,item2])
self.ui.metaEditor.setModel(model)
# self.ui.metaEditor.addTopLevelItem(item)
# self.ui.metaEditor.
# model.itemChanged.connect(lambda: on_item_changed())
self.metamodel=model
# self.ui.met
self.ui.metaEditor.setModel(model)
# self.ui.metaEditor.setEditTriggers(QAbstractItemView.NoEditTriggers)
# self.ui.metaEditor.sortByColumn(1)
self.ui.metaEditor.resizeColumnsToContents()
