def item(displayvalue, item_values={}):
item = QStandardItem()
item.setData(displayvalue, Qt.DisplayRole)
for role, value in item_values.items():
item.setData(value, role)
return item
def calculateP(self):
degree = None
degree1 = None
degree2 = None
degree3 = None
num = None
result, degree, degree1 = self.parametersPanel.pnlStartPosP.method_3()
if (result):
# self.pnlVarStart.Value.smethod_17();
num1 = float(self.parametersPanel.pnlVarFinishP.Value)
value = float(self.parametersPanel.txtForwardTP.Value)
value1 = float(self.parametersPanel.txtForwardTP.Value)
distance = self.parametersPanel.txtDistanceP.Value
result, degree2, degree3, num = Geo.smethod_6(
self.parametersPanel.cmbCalculationTypeP.SelectedItem, degree,
degree1, value, distance)
if (result):
num2 = MathHelper.smethod_3(num - num1)
self.method_29_P()
self.resultPoint3d = Point3D(degree3, degree2)
self.resultLat = degree2
self.resultLon = degree3
latStr = Degrees(degree2, None, None,
DegreesType.Latitude).ToString()
self.resultModelP.setItem(0, 0,
QStandardItem(Captions.LATITUDE))
self.resultModelP.setItem(0, 1, QStandardItem(latStr))
lonStr = Degrees(degree3, None, None,
DegreesType.Longitude).ToString()
if String.Str2QString(lonStr).mid(0, 1) == "0":
lonStr = String.Str2QString(lonStr).mid(
1,
String.Str2QString(lonStr).length() - 1)
self.resultModelP.setItem(1, 0,
QStandardItem(Captions.LONGITUDE))
self.resultModelP.setItem(1, 1, QStandardItem(lonStr))
self.resultModelP.setItem(
2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING))
self.resultModelP.setItem(2, 1,
QStandardItem(str(round(num, 4))))
self.resultModelP.setItem(
3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING))
self.resultModelP.setItem(3, 1,
QStandardItem(str(round(num2, 4))))
dataList = []
dataList.append([
"Latitude (Start)", "Longitude (Start)",
"Variation (Start)", "Forward (° T)", "Forward (° M)",
"Distance (nm)", "Distance (km)", "Latitude (Finish)",
"Longitude (Finish)", "Variation (Finish)",
"Reverse (° T)", "Reverse (° M)"
])
dataList.append([
str(degree),
str(degree1),
str(self.parametersPanel.pnlVarStartP.Value),
str(self.parametersPanel.txtForwardTP.Value),
str(self.parametersPanel.txtForwardMP.Value),
str(distance.NauticalMiles),
str(distance.Kilometres),
str(degree2),
str(degree3),
str(self.parametersPanel.pnlVarFinishP.Value),
str(round(num, 4)),
str(round(num2, 4))
])
GeoDetermineDlg.HistoryDataP.append(dataList)
self.setDataInHistoryModel(dataList)
self.method_28_P(degree2, degree3)
def tblHistory_Click(self, modelIndex):
if modelIndex != None:
if self.parametersPanel.tabGeneral.currentIndex() == 0:
dataList = GeoDetermineDlg.HistoryDataP[modelIndex.row()]
self.parametersPanel.pnlStartPosP.Point3d = Point3D(
float(dataList[1][1]), float(dataList[1][0]))
self.parametersPanel.pnlVarStartP.Value = float(dataList[1][2])
self.parametersPanel.txtForwardTP.Value = float(dataList[1][3])
self.parametersPanel.txtForwardMP.Value = float(dataList[1][4])
self.parametersPanel.txtDistanceP.Value = Distance(
float(dataList[1][5]), DistanceUnits.NM)
self.parametersPanel.pnlVarFinishP.Value = float(
dataList[1][9])
self.method_29_P()
self.resultModelP.setItem(0, 0,
QStandardItem(Captions.LATITUDE))
self.resultModelP.setItem(0, 1, QStandardItem(dataList[1][7]))
self.resultModelP.setItem(1, 0,
QStandardItem(Captions.LONGITUDE))
self.resultModelP.setItem(1, 1, QStandardItem(dataList[1][8]))
self.resultModelP.setItem(
2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING))
self.resultModelP.setItem(2, 1, QStandardItem(dataList[1][10]))
self.resultModelP.setItem(
3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING))
self.resultModelP.setItem(3, 1, QStandardItem(dataList[1][11]))
elif self.parametersPanel.tabGeneral.currentIndex() == 1:
dataList = GeoDetermineDlg.HistoryDataBD[modelIndex.row()]
self.parametersPanel.pnlStartPosBD.ID = dataList[1][0]
self.parametersPanel.pnlStartPosBD.Point3d = Point3D(
float(dataList[1][2]), float(dataList[1][1]))
self.parametersPanel.pnlVarStartBD.Value = float(
dataList[1][3])
self.parametersPanel.pnlFinishPosBD.ID = dataList[1][4]
self.parametersPanel.pnlFinishPosBD.Point3d = Point3D(
float(dataList[1][6]), float(dataList[1][5]))
self.parametersPanel.pnlVarFinishBD.Value = float(
dataList[1][7])
self.method_31_BD()
self.resultModelBD.setItem(
0, 0, QStandardItem(Captions.FORWARD_TRUE_BEARING))
self.resultModelBD.setItem(0, 1, QStandardItem(dataList[1][8]))
self.resultModelBD.setItem(
1, 0, QStandardItem(Captions.FORWARD_MAGNETIC_BEARING))
self.resultModelBD.setItem(1, 1, QStandardItem(dataList[1][9]))
self.resultModelBD.setItem(
2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING))
self.resultModelBD.setItem(2, 1,
QStandardItem(dataList[1][10]))
self.resultModelBD.setItem(
3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING))
self.resultModelBD.setItem(3, 1,
QStandardItem(dataList[1][11]))
self.resultModelBD.setItem(
2, 0, QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS))
self.resultModelBD.setItem(2, 1,
QStandardItem(dataList[1][12]))
self.resultModelBD.setItem(
3, 0, QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS))
self.resultModelBD.setItem(3, 1,
QStandardItem(dataList[1][13]))
else:
dataList = GeoDetermineDlg.HistoryDataMV[modelIndex.row()]
self.parametersPanel.pnlPositionMVD.Point3d = Point3D(
float(dataList[1][1]), float(dataList[1][0]))
self.parametersPanel.pnlPositionMVD.txtAltitudeM.setText(
dataList[1][2])
self.parametersPanel.txtResult.Value = dataList[1][6]
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _onAddAction(self):
item = QStandardItem("")
item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled)
self._listView.model().appendRow(item)
self._listView.setCurrentIndex(item.index())
self._listView.edit(item.index())
def refreshmodel(ruleslist):
"Fill the frontend with rules data"
#empty the model, we're filling it anew, we can't use clear() cause it flushes headers too:
global ruleslock
ruleslock.acquire()
#modelAll contains all rules, modelActive - only those which are currently running and have transfered at least some traffic
modelAll.removeRows(0, modelAll.rowCount())
modelActive.removeRows(0, modelActive.rowCount())
#if there's only one element, it's EOF; dont go through iterations,just leave the model empty
if (len(ruleslist) == 1):
ruleslock.release()
return
for item in ruleslist[0:-1]: #leave out the last EOF from iteration
if (item[0] == "KERNEL_PROCESS"):
#a whole different ball game starts with KERNEL_PROCESS
ker_name = QStandardItem("KERNEL")
ker_pid = QStandardItem("N/A")
ker_perms = QStandardItem("ALLOW_ALWAYS")
ker_fullpath = QStandardItem("KERNEL-> " + item[1])
ker_in_allow_traf = QStandardItem()
ker_out_allow_traf = QStandardItem()
ker_in_deny_traf = QStandardItem()
ker_out_deny_traf = QStandardItem()
modelAll.appendRow(
(ker_name, ker_pid, ker_perms, ker_fullpath, ker_in_allow_traf,
ker_out_allow_traf, ker_in_deny_traf, ker_out_deny_traf))
#see below why del is needed
del ker_fullpath, ker_pid, ker_perms, ker_name, ker_in_allow_traf, ker_out_allow_traf, ker_in_deny_traf, ker_out_allow_traf
else:
fullpath = QStandardItem(item[0])
#item[4] contains nfmark
fullpath.setData(item[4])
if (item[1] == "0"):
pid_string = "N/A"
else:
pid_string = item[1]
pid = QStandardItem(pid_string)
perms = QStandardItem(item[2])
#only the name of the executable after the last /
m_list = string.rsplit(item[0], "/", 1)
m_name = m_list[1]
name = QStandardItem(m_name)
in_allow_traf = QStandardItem()
out_allow_traf = QStandardItem()
in_deny_traf = QStandardItem()
out_deny_traf = QStandardItem()
modelAll.appendRow((name, pid, perms, fullpath, in_allow_traf,
out_allow_traf, in_deny_traf, out_deny_traf))
del fullpath, pid, perms, name, in_allow_traf, out_allow_traf, in_deny_traf, out_deny_traf
print "Received: %s" % (item[0])
if (pid_string != "N/A"):
fullpath2 = QStandardItem(item[0])
fullpath2.setData(item[4])
pid2 = QStandardItem(pid_string)
perms2 = QStandardItem(item[2])
name2 = QStandardItem(m_name)
in_allow_traf2 = QStandardItem()
out_allow_traf2 = QStandardItem()
in_deny_traf2 = QStandardItem()
out_deny_traf2 = QStandardItem()
modelActive.appendRow(
(name2, pid2, perms2, fullpath2, in_allow_traf2,
out_allow_traf2, in_deny_traf2, out_deny_traf2))
del fullpath2, pid2, perms2, name2, in_allow_traf2, out_allow_traf2, in_deny_traf2, out_deny_traf2
#apparently(???) deletion causes its contents to be COPIED into QModel rather than be referenced. If a variable is reused w/out deletion, its contents simply gets re-written
ruleslock.release()
def addRow(self):
items = [QStandardItem('0') for i in xrange(self.tblView.model().columnCount())]
self.tblView.model().appendRow(items)
def _update_stats_model(self):
# Update the results_model with up to date scores.
# Note: The target class specific scores (if requested) are
# computed as needed in this method.
model = self.view.model()
# clear the table model, but preserving the header labels
for r in reversed(range(model.rowCount())):
model.takeRow(r)
target_index = None
if self.data is not None:
class_var = self.data.domain.class_var
if self.data.domain.has_discrete_class and \
self.class_selection != self.TARGET_AVERAGE:
target_index = class_var.values.index(self.class_selection)
else:
class_var = None
errors = []
has_missing_scores = False
for key, slot in self.learners.items():
name = learner_name(slot.learner)
head = QStandardItem(name)
head.setData(key, Qt.UserRole)
if isinstance(slot.results, Try.Fail):
head.setToolTip(str(slot.results.exception))
head.setText("{} (error)".format(name))
head.setForeground(QtGui.QBrush(Qt.red))
errors.append("{name} failed with error:\n"
"{exc.__class__.__name__}: {exc!s}".format(
name=name, exc=slot.results.exception))
row = [head]
if class_var is not None and class_var.is_discrete and \
target_index is not None:
if slot.results is not None and slot.results.success:
ovr_results = results_one_vs_rest(slot.results.value,
target_index)
stats = [
Try(lambda: score(ovr_results))
for score in classification_stats.scores
]
else:
stats = None
else:
stats = slot.stats
if stats is not None:
for stat in stats:
item = QStandardItem()
if stat.success:
item.setText("{:.3f}".format(stat.value[0]))
else:
item.setToolTip(str(stat.exception))
has_missing_scores = True
row.append(item)
model.appendRow(row)
if errors:
self.error(3, "\n".join(errors))
else:
self.error(3)
if has_missing_scores:
self.warning(3, "Some scores could not be computed")
else:
self.warning(3)
def on_add_label(self):
self.labels_model.appendRow([QStandardItem(""), QStandardItem("")])
row = self.labels_model.rowCount() - 1
index = self.labels_model.index(row, 0)
self.labels_edit.edit(index)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (eg, id is more likely to be first)
try:
defaultGeomCol = next(
col for col in cols
if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[
0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(
self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def addFieldDef(self, fieldDef, recover=None):
self.defOrder = [
'fieldName', 'fieldMap', 'fieldLabel', 'fieldType', 'fieldHint',
'fieldRequired', 'fieldDefault', 'fieldQtype', 'fieldWidget',
'fieldChoices', 'fieldAppearance', 'fieldReadOnly',
'fieldCalculation'
]
row = []
self.setIcon(
QIcon(os.path.join(os.path.dirname(__file__), "field.png")))
if not 'fieldReadOnly' in fieldDef:
fieldDef['fieldReadOnly'] = ''
if not 'fieldCalculation' in fieldDef:
fieldDef['fieldCalculation'] = ''
if recover: #backup dict provided if recovering fields state
for fdef in self.defOrder:
if fdef == 'fieldName':
sub_item = QStandardItem(None)
elif fdef == 'fieldRequired':
sub_item = QStandardItem(None)
sub_item.setCheckable(True)
if fieldDef['fieldRequired']:
sub_item.setCheckState(Qt.Checked)
else:
sub_item.setCheckState(Qt.Unchecked)
else:
sub_item = QStandardItem(fieldDef[fdef])
row.append(sub_item)
self.appendRow(row)
self.setCheckable(True)
if fieldDef['fieldEnabled']:
self.setCheckState(Qt.Checked)
else:
self.setCheckState(Qt.Unchecked)
else:
fieldDef['fieldType'] = self.getODKType(fieldDef)
if fieldDef['fieldType'] in appearanceDef.keys():
fieldDef['fieldAppearance'] = appearanceDef[
fieldDef['fieldType']][0]
else:
fieldDef['fieldAppearance'] = 'default'
for fdef in self.defOrder:
if fdef == 'fieldName':
sub_item = QStandardItem(None)
elif fdef == 'fieldRequired':
sub_item = QStandardItem(None)
sub_item.setCheckable(True)
if fieldDef['fieldRequired']:
sub_item.setCheckState(Qt.Checked)
else:
sub_item.setCheckState(Qt.Unchecked)
elif fdef == 'fieldChoices':
sub_item = QStandardItem(json.dumps(fieldDef[fdef]))
else:
sub_item = QStandardItem(fieldDef[fdef] or '')
sub_item.setDropEnabled(False)
sub_item.setDragEnabled(False)
row.append(sub_item)
self.appendRow(row)
self.setCheckable(True)
if fieldDef['fieldEnabled']:
self.setCheckState(Qt.Checked)
else:
self.setCheckState(Qt.Unchecked)
def _buildfromlayer(self, widget, layerconfig):
layername = layerconfig['layer']
keyfield = layerconfig['key']
valuefield = layerconfig['value']
filterexp = layerconfig.get('filter', None)
try:
layer = QgsMapLayerRegistry.instance().mapLayersByName(layername)[0]
except IndexError:
roam.utils.warning("Can't find layer {} in project".format(layername))
return
keyfieldindex = layer.fieldNameIndex(keyfield)
valuefieldindex = layer.fieldNameIndex(valuefield)
if keyfieldindex == -1 or valuefieldindex == -1:
roam.utils.warning("Can't find key or value column")
return
if self.allownulls:
item = QStandardItem('(no selection)')
item.setData(None, Qt.UserRole)
self.listmodel.appendRow(item)
if not filterexp and valuefieldindex == keyfieldindex:
values = layer.uniqueValues(keyfieldindex)
for value in values:
value = nullconvert(value)
item = QStandardItem(value)
item.setData(value, Qt.UserRole)
self.listmodel.appendRow(item)
return
attributes = {keyfieldindex, valuefieldindex}
flags = QgsFeatureRequest.NoGeometry
iconfieldindex = layer.fieldNameIndex('icon')
if iconfieldindex > -1:
attributes.add(iconfieldindex)
expression = None
if filterexp:
expression = QgsExpression(filterexp)
expression.prepare(layer.pendingFields())
if expression.hasParserError():
roam.utils.warning("Expression has parser error: {}".format(expression.parserErrorString()))
return
if expression.needsGeometry():
flags = QgsFeatureRequest.NoFlags
for field in expression.referencedColumns():
index = layer.fieldNameIndex(field)
attributes.add(index)
request = QgsFeatureRequest().setFlags(flags).setSubsetOfAttributes(list(attributes))
for feature in layer.getFeatures(request):
if expression and not expression.evaluate(feature):
continue
keyvalue = nullconvert(feature[keyfieldindex])
valuvalue = nullconvert(feature[valuefield])
try:
path = feature[iconfieldindex]
icon = QIcon(path)
except KeyError:
icon = QIcon()
item = QStandardItem(unicode(keyvalue))
item.setData(unicode(valuvalue), Qt.UserRole)
item.setIcon(icon)
self.listmodel.appendRow(item)
def addObstacleToModel(self, obstacle, checkResult):
ObstacleTable.addObstacleToModel(self, obstacle, checkResult)
row = self.source.rowCount() - 1
item = QStandardItem(str(checkResult[0]))
item.setData(checkResult[0])
self.source.setItem(row, self.IndexIlsX, item)
item = QStandardItem(str(checkResult[1]))
item.setData(checkResult[1])
self.source.setItem(row, self.IndexIlsY, item)
item = QStandardItem(str(checkResult[2]))
item.setData(checkResult[2])
self.source.setItem(row, self.IndexEqAltM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[2])))
item.setData(Unit.ConvertMeterToFeet(checkResult[2]))
self.source.setItem(row, self.IndexEqAltFt, item)
item = QStandardItem(str(checkResult[3]))
item.setData(checkResult[3])
self.source.setItem(row, self.IndexSurfAltM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[3])))
item.setData(Unit.ConvertMeterToFeet(checkResult[3]))
self.source.setItem(row, self.IndexSurfAltFt, item)
item = QStandardItem(str(checkResult[4]))
item.setData(checkResult[4])
self.source.setItem(row, self.IndexDifferenceM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[4])))
item.setData(Unit.ConvertMeterToFeet(checkResult[4]))
self.source.setItem(row, self.IndexDifferenceFt, item)
if checkResult[4] < 0:
item = QStandardItem("")
# item.setData(checkResult[5])
self.source.setItem(row, self.IndexOcaM, item)
else:
item = QStandardItem(str(checkResult[5]))
item.setData(checkResult[5])
self.source.setItem(row, self.IndexOcaM, item)
if checkResult[4] < 0:
item = QStandardItem("")
# item.setData(checkResult[5])
self.source.setItem(row, self.IndexOcaM, item)
else:
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[5])))
item.setData(Unit.ConvertMeterToFeet(checkResult[5]))
self.source.setItem(row, self.IndexOcaFt, item)
item = QStandardItem(str(checkResult[6]))
item.setData(checkResult[5])
self.source.setItem(row, self.IndexCritical, item)
item = QStandardItem(str(checkResult[7]))
item.setData(checkResult[6])
self.source.setItem(row, self.IndexSurface, item)
def __setupUi(self):
"""Set up the UI.
"""
if self.__macUnified:
self.tab = QToolBar()
self.addToolBar(Qt.TopToolBarArea, self.tab)
self.setUnifiedTitleAndToolBarOnMac(True)
# This does not seem to work
self.setWindowFlags(self.windowFlags() & \
~Qt.MacWindowToolBarButtonHint)
self.tab.actionTriggered[QAction].connect(
self.__macOnToolBarAction)
central = QStackedWidget()
central.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
else:
self.tab = central = QTabWidget(self)
# Add a close button to the bottom of the dialog
# (to satisfy GNOME 3 which shows the dialog without a title bar).
container = container_widget_helper()
container.layout().addWidget(central)
buttonbox = QDialogButtonBox(QDialogButtonBox.Close)
buttonbox.rejected.connect(self.close)
container.layout().addWidget(buttonbox)
self.setCentralWidget(container)
self.stack = central
# General Tab
tab = QWidget()
self.addTab(tab,
self.tr("General"),
toolTip=self.tr("General Options"))
form = QFormLayout()
tab.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
nodes = QWidget(self, objectName="nodes")
nodes.setLayout(QVBoxLayout())
nodes.layout().setContentsMargins(0, 0, 0, 0)
cb_anim = QCheckBox(self.tr("Enable node animations"),
objectName="enable-node-animations",
toolTip=self.tr(
"Enable shadow and ping animations for node "
"items in the scheme."))
self.bind(cb_anim, "checked", "schemeedit/enable-node-animations")
nodes.layout().addWidget(cb_anim)
form.addRow(self.tr("Nodes"), nodes)
links = QWidget(self, objectName="links")
links.setLayout(QVBoxLayout())
links.layout().setContentsMargins(0, 0, 0, 0)
cb_show = QCheckBox(self.tr("Show channel names between widgets"),
objectName="show-channel-names",
toolTip=self.tr(
"Show source and sink channel names "
"over the links."))
self.bind(cb_show, "checked", "schemeedit/show-channel-names")
links.layout().addWidget(cb_show)
form.addRow(self.tr("Links"), links)
quickmenu = QWidget(self, objectName="quickmenu-options")
quickmenu.setLayout(QVBoxLayout())
quickmenu.layout().setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("On double click"),
toolTip=self.tr("Open quick menu on a double click "
"on an empty spot in the canvas"))
cb2 = QCheckBox(self.tr("On right click"),
toolTip=self.tr("Open quick menu on a right click "
"on an empty spot in the canvas"))
cb3 = QCheckBox(self.tr("On space key press"),
toolTip=self.tr("On Space key press while the mouse"
"is hovering over the canvas."))
cb4 = QCheckBox(self.tr("On any key press"),
toolTip=self.tr("On any key press while the mouse"
"is hovering over the canvas."))
self.bind(cb1, "checked", "quickmenu/trigger-on-double-click")
self.bind(cb2, "checked", "quickmenu/trigger-on-right-click")
self.bind(cb3, "checked", "quickmenu/trigger-on-space-key")
self.bind(cb4, "checked", "quickmenu/trigger-on-any-key")
quickmenu.layout().addWidget(cb1)
quickmenu.layout().addWidget(cb2)
quickmenu.layout().addWidget(cb3)
quickmenu.layout().addWidget(cb4)
form.addRow(self.tr("Open quick menu on"), quickmenu)
startup = QWidget(self, objectName="startup-group")
startup.setLayout(QVBoxLayout())
startup.layout().setContentsMargins(0, 0, 0, 0)
cb_splash = QCheckBox(self.tr("Show splash screen"),
self,
objectName="show-splash-screen")
cb_welcome = QCheckBox(self.tr("Show welcome screen"),
self,
objectName="show-welcome-screen")
self.bind(cb_splash, "checked", "startup/show-splash-screen")
self.bind(cb_welcome, "checked", "startup/show-welcome-screen")
startup.layout().addWidget(cb_splash)
startup.layout().addWidget(cb_welcome)
form.addRow(self.tr("On startup"), startup)
toolbox = QWidget(self, objectName="toolbox-group")
toolbox.setLayout(QVBoxLayout())
toolbox.layout().setContentsMargins(0, 0, 0, 0)
exclusive = QCheckBox(self.tr("Only one tab can be open at a time"))
self.bind(exclusive, "checked", "mainwindow/toolbox-dock-exclusive")
toolbox.layout().addWidget(exclusive)
form.addRow(self.tr("Tool box"), toolbox)
tab.setLayout(form)
# Output Tab
tab = QWidget()
self.addTab(tab, self.tr("Output"), toolTip="Output Redirection")
form = QFormLayout()
box = QWidget(self, objectName="streams")
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Standard output"))
cb2 = QCheckBox(self.tr("Standard error"))
self.bind(cb1, "checked", "output/redirect-stdout")
self.bind(cb2, "checked", "output/redirect-stderr")
layout.addWidget(cb1)
layout.addWidget(cb2)
box.setLayout(layout)
form.addRow(self.tr("Redirect output"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
combo = QComboBox()
combo.addItems([
self.tr("Critical"),
self.tr("Error"),
self.tr("Warn"),
self.tr("Info"),
self.tr("Debug")
])
cb = QCheckBox(self.tr("Show output on 'Error'"),
objectName="focus-on-error")
self.bind(combo, "currentIndex", "logging/level")
self.bind(cb, "checked", "output/show-on-error")
layout.addWidget(combo)
layout.addWidget(cb)
box.setLayout(layout)
form.addRow(self.tr("Logging"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Stay on top"), objectName="stay-on-top")
cb2 = QCheckBox(self.tr("Dockable"), objectName="output-dockable")
self.bind(cb1, "checked", "output/stay-on-top")
self.bind(cb2, "checked", "output/dockable")
layout.addWidget(cb1)
layout.addWidget(cb2)
box.setLayout(layout)
form.addRow(self.tr("Output window"), box)
box = QWidget()
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
cb1 = QCheckBox(self.tr("Open in external browser"),
objectName="open-in-external-browser")
cb2 = QCheckBox(self.tr("Stay on top"), objectName="help-stay-on-top")
cb3 = QCheckBox(self.tr("Dockable"), objectName="help-dockable")
self.bind(cb1, "checked", "help/open-in-external-browser")
self.bind(cb2, "checked", "help/stay-on-top")
self.bind(cb3, "checked", "help/dockable")
layout.addWidget(cb1)
layout.addWidget(cb2)
layout.addWidget(cb3)
box.setLayout(layout)
form.addRow(self.tr("Help window"), box)
tab.setLayout(form)
# Categories Tab
tab = QWidget()
layout = QVBoxLayout()
view = QListView()
from .. import registry
reg = registry.global_registry()
model = QStandardItemModel()
settings = QSettings()
for cat in reg.categories():
item = QStandardItem()
item.setText(cat.name)
item.setCheckable(True)
visible, _ = category_state(cat, settings)
item.setCheckState(Qt.Checked if visible else Qt.Unchecked)
model.appendRow([item])
view.setModel(model)
layout.addWidget(view)
tab.setLayout(layout)
model.itemChanged.connect(lambda item: save_category_state(
reg.category(str(item.text())),
_State(item.checkState() == Qt.Checked, -1), settings))
self.addTab(tab, "Categories")
if self.__macUnified:
# Need some sensible size otherwise mac unified toolbar 'takes'
# the space that should be used for layout of the contents
self.adjustSize()
def add_device_to_tree(self, device):
# check if device is already added
if len(device['uid']) > 0:
for row in range(self.model_devices.rowCount()):
existing_name = self.model_devices.item(row, 0).text()
exisitng_uid = self.tree_devices.indexWidget(
self.model_devices.item(row, 1).index()).text()
if device['name'] == existing_name and device[
'uid'] == exisitng_uid:
EventLogger.info(
'Ignoring duplicate device "{0}" with UID "{1}"'.
format(device['name'], device['uid']))
return
# add device
name_item = QStandardItem(device['name'])
uid_item = QStandardItem('')
self.model_devices.appendRow([name_item, uid_item])
edit_uid = QLineEdit()
edit_uid.setPlaceholderText('Enter UID')
edit_uid.setValidator(
QRegExpValidator(QRegExp(
'^[{0}]{{1,6}}$'.format(BASE58)))) # FIXME: use stricter logic
edit_uid.setText(device['uid'])
self.tree_devices.setIndexWidget(uid_item.index(), edit_uid)
value_specs = device_specs[device['name']]['values']
parent_item = QStandardItem('Values')
name_item.appendRow([parent_item, QStandardItem('')])
self.tree_devices.expand(parent_item.index())
# add values
for value_spec in value_specs:
value_name_item = QStandardItem(value_spec['name'])
value_interval_item = QStandardItem('')
parent_item.appendRow([value_name_item, value_interval_item])
spinbox_interval = QSpinBox()
spinbox_interval.setRange(0, (1 << 31) - 1)
spinbox_interval.setSingleStep(1)
spinbox_interval.setValue(
device['values'][value_spec['name']]['interval'])
spinbox_interval.setSuffix(' seconds')
self.tree_devices.setIndexWidget(value_interval_item.index(),
spinbox_interval)
if value_spec['subvalues'] != None:
for subvalue_name in value_spec['subvalues']:
subvalue_name_item = QStandardItem(subvalue_name)
subvalue_check_item = QStandardItem('')
value_name_item.appendRow(
[subvalue_name_item, subvalue_check_item])
check_subvalue = QCheckBox()
check_subvalue.setChecked(device['values'][
value_spec['name']]['subvalues'][subvalue_name])
self.tree_devices.setIndexWidget(
subvalue_check_item.index(), check_subvalue)
self.tree_devices.expand(name_item.index())
# add options
option_specs = device_specs[device['name']]['options']
if option_specs != None:
parent_item = QStandardItem('Options')
name_item.appendRow([parent_item, QStandardItem('')])
for option_spec in option_specs:
option_name_item = QStandardItem(option_spec['name'])
option_widget_item = QStandardItem('')
parent_item.appendRow([option_name_item, option_widget_item])
if option_spec['type'] == 'choice':
widget_option_value = QComboBox()
for option_value_spec in option_spec['values']:
widget_option_value.addItem(
option_value_spec[0].decode('utf-8'),
option_value_spec[1])
widget_option_value.setCurrentIndex(
widget_option_value.findText(device['options'][
option_spec['name']]['value'].decode('utf-8')))
elif option_spec['type'] == 'int':
widget_option_value = QSpinBox()
widget_option_value.setRange(option_spec['minimum'],
option_spec['maximum'])
widget_option_value.setSuffix(option_spec['suffix'])
widget_option_value.setValue(
device['options'][option_spec['name']]['value'])
elif option_spec['type'] == 'bool':
widget_option_value = QCheckBox()
widget_option_value.setChecked(
device['options'][option_spec['name']]['value'])
self.tree_devices.setIndexWidget(option_widget_item.index(),
widget_option_value)
def refreshconnections(self):
current_layout_lock.acquire()
if(self.sourcemodel.current_layout != "conn"):
print ("refreshconnections error")
current_layout_lock.release()
return
self.sourcemodel.layoutAboutToBeChanged.emit()
self.sourcemodel.removeRows(0, self.sourcemodel.rowCount())
for conn in psutil.net_connections("inet4"):
if(conn.type == socket.SOCK_STREAM):
proto = QStandardItem("tcp")
else:
proto = QStandardItem("udp")
laddr = QStandardItem(conn.laddr[0])
lport = QStandardItem(str(conn.laddr[1]))
if(len(conn.raddr) == 0):
continue
raddr = QStandardItem(conn.raddr[0])
rport = QStandardItem(str(conn.raddr[1]))
status = QStandardItem(conn.status)
pid = QStandardItem(str(conn.pid))
if(conn.pid != None):
p = psutil.Process(conn.pid)
name = QStandardItem(p.name())
else:
name = QStandardItem("None")
family = QStandardItem("ipv4")
self.sourcemodel.appendRow( (family, proto, laddr, lport, raddr, rport, status, pid, name))
self.sourcemodel.layoutChanged.emit()
current_layout_lock.release()
def fillTree(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels(
[self.tr('Setting'), self.tr('Value')])
text = unicode(self.searchBox.text())
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
priorityKeys = [
self.tr('General'),
self.tr('Models'),
self.tr('Scripts')
]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
for setting in settings[group]:
if setting.hidden:
continue
if text == '' or text.lower() in setting.description.lower():
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
if text != '':
self.tree.expand(groupItem.index())
providersItem = QStandardItem(self.tr('Providers'))
icon = QIcon(os.path.join(pluginPath, 'images', 'alg.png'))
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in settings.keys():
if group in priorityKeys:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
if text == '' or text.lower() in setting.description.lower():
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def scan(self):
#self.treeViewComputer.setEnabled(False)
#self.fileTypesButton.setEnabled(False)
self.files_found = {}
self.category_number_length = {}
self.threads = []
self.stop = False
if not self.selected_file_types:
dialog = FileTypes()
dialog.setModal(True)
self.selected_file_types, ok = dialog.call()
if not ok:
return
files_found_dialog = FilesFound(self)
files_found_dialog.setModal(True)
files_found_dialog.show()
header_counter = 0
for element in self.selected_file_types:
selected = []
for _type, state in element["Types"].items():
if state == Qt.Checked:
selected.append(_type)
if selected:
cat = QStandardItem(
element.keys()[0]) # WARNING! it may be unordered
self.files_found_model.setHorizontalHeaderItem(
header_counter, cat)
self.category_number_length.update(
{element.keys()[0]: [header_counter, 0]})
self.files_found_tree.setColumnWidth(header_counter - 1, 200)
header_counter += 1
for index, state in self.model_computer.checks.items():
self.files_found.update({element.keys()[0]: []})
print("start tread for %s" % element.keys()[0])
th = Thread(target=self.model_computer.exportChecked,
args=(self, {
index: state
}, element.keys()[0], selected,
self.files_found))
th.start()
self.threads.append(th)
status = map(Thread.isAlive, self.threads)
start_time = int(time.time())
while any(status):
qApp.processEvents()
status = map(Thread.isAlive, self.threads)
self.filesFoundLabel.setText("Scanning...")
if (int(time.time()) - start_time) % 2 == 0:
if self.files_found:
self.lock.acquire()
for cat, (num,
length) in self.category_number_length.items():
files = self.files_found[cat]
for i in range(length, len(files)):
fileItem = QStandardItem(
self.files_found[cat][i].split(sep)[-1])
fileItem.setCheckable(True)
fileItem.setCheckState(2)
fileItem.setToolTip(self.files_found[cat][i])
self.files_found_model.invisibleRootItem(
).setChild(i, num, fileItem)
self.category_number_length[cat][1] = len(files)
self.lock.release()
if self.stop:
self.filesFoundLabel.setText("Scanning was stopped by user")
self.files_found = {}
self.threads = []
else:
for cat, (num, length) in self.category_number_length.items():
if self.files_found:
files = self.files_found[cat]
for i in range(length, len(files)):
fileItem = QStandardItem(
self.files_found[cat][i].split(sep)[-1])
fileItem.setCheckable(True)
fileItem.setCheckState(2)
fileItem.setToolTip(self.files_found[cat][i])
self.files_found_model.invisibleRootItem().setChild(
i, num, fileItem)
self.category_number_length[cat][1] = len(files)
self.filesFoundLabel.setText(
"Scanning finished! Files found %s. Click on the Storage tab" %
sum(len(v) for k, v in self.files_found.items()))
self.files_found_bar.setMaximum(1)
self.files_found_bar.setValue(1)
self.files_found_ok_enable.setEnabled(True)
def set_items(self, items):
self.__items = items
model = self.__model
model.clear()
model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"])
for item in items:
if isinstance(item, Installed):
installed = True
ins, dist = item
name = dist.project_name
summary = get_dist_meta(dist).get("Summary", "")
version = ins.version if ins is not None else dist.version
else:
installed = False
(ins, ) = item
dist = None
name = ins.name
summary = ins.summary
version = ins.version
updatable = is_updatable(item)
item1 = QStandardItem()
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable
| (Qt.ItemIsTristate if updatable else 0))
if installed and updatable:
item1.setCheckState(Qt.PartiallyChecked)
elif installed:
item1.setCheckState(Qt.Checked)
else:
item1.setCheckState(Qt.Unchecked)
item2 = QStandardItem(name)
item2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item2.setToolTip(summary)
item2.setData(item, Qt.UserRole)
if updatable:
version = "{} < {}".format(dist.version, ins.version)
item3 = QStandardItem(version)
item3.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item4 = QStandardItem()
item4.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
model.appendRow([item1, item2, item3, item4])
self.__view.resizeColumnToContents(0)
self.__view.setColumnWidth(1, max(150,
self.__view.sizeHintForColumn(1)))
self.__view.setColumnWidth(2, max(150,
self.__view.sizeHintForColumn(2)))
if self.__items:
self.__view.selectionModel().select(
self.__view.model().index(0, 0),
QItemSelectionModel.Select | QItemSelectionModel.Rows)
def setTableView(self, tblView, stdModel, data):
for i in range(7):
for j in range(12 + data["CatOfAcftCount"][0]):
item = QStandardItem("")
item.setEditable(True)
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(i, j, item)
item = QStandardItem("O C A ( H )")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(0, 0, item)
item = QStandardItem("C a t of A C F T")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 0, item)
item = QStandardItem("S t r a i g h t-I n A p p r o a c h")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
if data["Template"][0] >= 0 and data["Template"][0] <= 4:
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
item = QStandardItem(
"F i n a l A p p r o a c h L O C D i s t a n c e F A F-M A P t"
)
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(0, data["CatOfAcftCount"][0] + 3, item)
else:
item = QStandardItem("F i n a l A p p r o a c h F A F-M A P t")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(0, data["CatOfAcftCount"][0] + 3, item)
if data["Template"][0] == 5:
item = QStandardItem("LPV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("LNAV / VNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(5, 0, item)
elif data["Template"][0] == 6:
item = QStandardItem("LNAV / VNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
elif data["Template"][0] == 7:
item = QStandardItem("LPV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
elif data["Template"][0] == 8:
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
elif data["Template"][0] == 9:
item = QStandardItem("RNP 0.3")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
if data["CatOfAcftCount"][0] == 1:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
elif data["CatOfAcftCount"][0] == 2:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
elif data["CatOfAcftCount"][0] == 3:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
elif data["CatOfAcftCount"][0] == 4:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
elif data["CatOfAcftCount"][0] == 5:
if data["CatOfAcftCount"][1] == 4:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
item = QStandardItem("DL")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 7, item)
else:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
item = QStandardItem("E")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 7, item)
elif data["CatOfAcftCount"][0] == 6:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
item = QStandardItem("DL")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 7, item)
item = QStandardItem("E")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 8, item)
# item = QStandardItem("DME MX NM")
# item.setTextAlignment(Qt.AlignCenter)
# stdModel.setItem(1, 6, item)
item = QStandardItem("DME SSA")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("6")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 5, item)
item = QStandardItem("5")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 6, item)
item = QStandardItem("4")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 7, item)
item = QStandardItem("3")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 8, item)
item = QStandardItem("2")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 9, item)
item = QStandardItem("1")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 10, item)
item = QStandardItem("A L T(HGT)")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("G S")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("kt")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 5, item)
item = QStandardItem("80")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 6, item)
item = QStandardItem("100")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 7, item)
item = QStandardItem("120")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 8, item)
item = QStandardItem("140")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 9, item)
item = QStandardItem("160")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 10, item)
item = QStandardItem("180")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 11, item)
item = QStandardItem("T i me")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("mi n:s")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, data["CatOfAcftCount"][0] + 5, item)
item = QStandardItem("Rate Of D e s c e n t")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(5, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("ft/mi n")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(5, data["CatOfAcftCount"][0] + 5, item)
tblView.setModel(stdModel)
for i in range(7):
tblView.setRowHeight(i, int(data["TableHeight"] / 7))
for j in range(12 + data["CatOfAcftCount"][0]):
tblView.setColumnWidth(
j,
int(data["TableWidth"] /
float(12 + data["CatOfAcftCount"][0])))
# tblView.setColumnWidth(0, 25)
# tblView.setColumnWidth(6, 20)
tblView.setSpan(0, 0, 1, data["CatOfAcftCount"][0] + 3)
tblView.setSpan(1, 0, 1, 3)
if data["Template"][0] >= 0 and data["Template"][0] <= 4:
tblView.setSpan(2, 0, 1, 3)
tblView.setSpan(2, 3, 1, data["CatOfAcftCount"][0])
tblView.setSpan(3, 0, 1, data["CatOfAcftCount"][0] + 3)
tblView.setSpan(4, 0, 1, 3)
tblView.setSpan(5, 0, 1, 3)
tblView.setSpan(6, 0, 1, 3)
else:
tblView.setSpan(2, 0, 1, 3)
tblView.setSpan(3, 0, 1, 3)
tblView.setSpan(4, 0, 1, 3)
tblView.setSpan(5, 0, 1, 3)
tblView.setSpan(6, 0, 1, 3)
# tblView.setSpan(data["StraightCount"] + 2, 0, 1, 3)
tblView.setSpan(0, data["CatOfAcftCount"][0] + 3, 1, 9)
# tblView.setSpan(1, data["CatOfAcftCount"][0] + 4, 1, 5)
# tblView.setSpan(1, data["CatOfAcftCount"][0] + 9, 1, 3)
# tblView.setSpan(2, data["CatOfAcftCount"][0] + 5, 1, 4)
# tblView.setSpan(2, data["CatOfAcftCount"][0] + 9, 1, 3)
tblView.setSpan(1, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(2, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(3, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(4, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(5, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(6, data["CatOfAcftCount"][0] + 3, 1, 2)
def addObstacleToModel(self, obstacle, checkResult):
ObstacleTable.addObstacleToModel(self, obstacle, checkResult)
row = self.source.rowCount() - 1
item = QStandardItem(str(checkResult[0]))
item.setData(checkResult[0])
self.source.setItem(row, self.IndexDrM, item)
item = QStandardItem(str(checkResult[1]))
item.setData(checkResult[1])
self.source.setItem(row, self.IndexDoM, item)
item = QStandardItem(str(checkResult[2]))
item.setData(checkResult[2])
self.source.setItem(row, self.IndexMocReqM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[2])))
item.setData(Unit.ConvertMeterToFeet(checkResult[2]))
self.source.setItem(row, self.IndexMocReqFt, item)
item = QStandardItem(str(checkResult[3]))
item.setData(checkResult[3])
self.source.setItem(row, self.IndexAcAltM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[3])))
item.setData(Unit.ConvertMeterToFeet(checkResult[3]))
self.source.setItem(row, self.IndexAcAltFt, item)
item = QStandardItem(str(checkResult[4]))
item.setData(checkResult[4])
self.source.setItem(row, self.IndexAltReqM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[4])))
item.setData(Unit.ConvertMeterToFeet(checkResult[4]))
self.source.setItem(row, self.IndexAltReqFt, item)
item = QStandardItem(str(checkResult[5]))
item.setData(checkResult[5])
self.source.setItem(row, self.IndexPDG, item)
item = QStandardItem(str(checkResult[6]))
item.setData(checkResult[6])
self.source.setItem(row, self.IndexCritical, item)
item = QStandardItem(str(checkResult[7]))
item.setData(checkResult[7])
self.source.setItem(row, self.IndexCloseIn, item)
def addObstacleToModel(self, obstacle, checkResult=None):
standardItemList = []
# obstacle.positionDegree = QgisHelper.Meter2Degree(obstacle.Position.x(), obstacle.Position.y())
standardItem = QStandardItem(str(obstacle.featureId))
standardItem.setData(obstacle.featureId)
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.layerId))
standardItem.setData(obstacle.layerId)
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.name))
standardItem.setData(obstacle.name)
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.Position.x()))
standardItem.setData(obstacle.Position.x())
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.Position.y()))
standardItem.setData(obstacle.Position.y())
standardItemList.append(standardItem)
value = QVariant(QgisHelper.strDegree(obstacle.positionDegree.y()))
standardItem = QStandardItem(value.toString())
standardItem.setData(obstacle.positionDegree.y())
standardItemList.append(standardItem)
strV = QgisHelper.strDegree(obstacle.positionDegree.y())
value = QVariant(QgisHelper.strDegree(obstacle.positionDegree.x()))
standardItem = QStandardItem(value.toString())
standardItem.setData(obstacle.positionDegree.x())
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.Position.z()))
standardItem.setData(obstacle.Position.z())
standardItemList.append(standardItem)
standardItem = QStandardItem(
str(Unit.ConvertMeterToFeet(obstacle.Position.z())))
standardItem.setData(Unit.ConvertMeterToFeet(obstacle.Position.z()))
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.trees))
standardItem.setData(obstacle.trees)
standardItemList.append(standardItem)
standardItem = QStandardItem(
str(Unit.ConvertMeterToFeet(obstacle.trees)))
standardItem.setData(Unit.ConvertMeterToFeet(obstacle.trees))
standardItemList.append(standardItem)
# for i in range(len(standardItemList), self.source.columnCount()):
# standardItemList.append(QStandardItem("None"))
self.source.appendRow(standardItemList)
standardItem = QStandardItem(str(obstacle.mocMultiplier))
standardItem.setData(obstacle.mocMultiplier)
self.source.setItem(self.source.rowCount() - 1,
self.IndexMocMultiplier, standardItem)
def addObstacleToModel(self, obstacle, checkResult):
if self.typeStr == "buffer":
ObstacleTable.addObstacleToModel(self, obstacle, checkResult)
row = self.source.rowCount() - 1
item = QStandardItem(str(checkResult[0]))
item.setData(checkResult[0])
self.source.setItem(row, self.IndexMocAppliedM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[0])))
item.setData(Unit.ConvertMeterToFeet(checkResult[0]))
self.source.setItem(row, self.IndexMocAppliedFt, item)
item = QStandardItem(str(ObstacleTable.MocMultiplier))
item.setData(ObstacleTable.MocMultiplier)
self.source.setItem(row, self.IndexMocMultiplier, item)
item = QStandardItem(str(checkResult[1]))
item.setData(checkResult[1])
self.source.setItem(row, self.IndexOcaM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[1])))
item.setData(Unit.ConvertMeterToFeet(checkResult[1]))
self.source.setItem(row, self.IndexOcaFt, item)
item = QStandardItem(str(checkResult[2]))
item.setData(checkResult[2])
self.source.setItem(row, self.IndexCritical, item)
else:
ObstacleTable.addObstacleToModel(self, obstacle, checkResult)
row = self.source.rowCount() - 1
item = QStandardItem(str(checkResult[0]))
item.setData(checkResult[0])
self.source.setItem(row, self.IndexObstArea, item)
item = QStandardItem(str(checkResult[1]))
item.setData(checkResult[1])
self.source.setItem(row, self.IndexDistInSecM, item)
item = QStandardItem(str(checkResult[2]))
item.setData(checkResult[2])
self.source.setItem(row, self.IndexMocAppliedM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[2])))
item.setData(Unit.ConvertMeterToFeet(checkResult[2]))
self.source.setItem(row, self.IndexMocAppliedFt, item)
item = QStandardItem(str(ObstacleTable.MocMultiplier))
item.setData(ObstacleTable.MocMultiplier)
self.source.setItem(row, self.IndexMocMultiplier, item)
item = QStandardItem(str(checkResult[3]))
item.setData(checkResult[3])
self.source.setItem(row, self.IndexOcaM, item)
item = QStandardItem(str(Unit.ConvertMeterToFeet(checkResult[3])))
item.setData(Unit.ConvertMeterToFeet(checkResult[3]))
self.source.setItem(row, self.IndexOcaFt, item)
item = QStandardItem(str(checkResult[4]))
item.setData(checkResult[4])
self.source.setItem(row, self.IndexCritical, item)
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 addItem(self, *args):
""" Add a new entry in the list
"""
item = QStandardItem(*args)
item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled)
self._listView.model().appendRow(item)
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 calculateBD(self):
degree = None
degree1 = None
degree2 = None
degree3 = None
num = None
result, degree, degree1 = self.parametersPanel.pnlStartPosBD.method_3()
if (result):
num2 = self.parametersPanel.pnlVarStartBD.Value
result1, degree2, degree3 = self.parametersPanel.pnlFinishPosBD.method_3(
)
if (result1):
num3 = self.parametersPanel.pnlVarFinishBD.Value
result2, distance, num, num1 = Geo.smethod_4(
self.parametersPanel.cmbCalculationTypeBD.SelectedItem,
degree, degree1, degree2, degree3)
if define._units == QGis.Meters:
QgisHelper.convertMeasureUnits(QGis.Degrees)
distance = Distance(
MathHelper.calcDistance(
self.parametersPanel.pnlStartPosBD.Point3d,
self.parametersPanel.pnlFinishPosBD.Point3d))
QgisHelper.convertMeasureUnits(QGis.Meters)
else:
distance = Distance(
MathHelper.calcDistance(
self.parametersPanel.pnlStartPosBD.Point3d,
self.parametersPanel.pnlFinishPosBD.Point3d))
if result2:
num4 = MathHelper.smethod_3(num - num2)
num5 = MathHelper.smethod_3(num1 - num3)
self.method_31_BD()
self.resultModelBD.setItem(
0, 0, QStandardItem(Captions.FORWARD_TRUE_BEARING))
self.resultModelBD.setItem(
0, 1, QStandardItem(str(round(num, 4))))
self.resultModelBD.setItem(
1, 0, QStandardItem(Captions.FORWARD_MAGNETIC_BEARING))
self.resultModelBD.setItem(
1, 1, QStandardItem(str(round(num4, 4))))
self.resultModelBD.setItem(
2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING))
self.resultModelBD.setItem(
2, 1, QStandardItem(str(round(num1, 4))))
self.resultModelBD.setItem(
3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING))
self.resultModelBD.setItem(
3, 1, QStandardItem(str(round(num5, 4))))
self.resultModelBD.setItem(
4, 0,
QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS))
self.resultModelBD.setItem(
4, 1,
QStandardItem(
str(round(distance.NauticalMiles, 4)) + " nm"))
self.resultModelBD.setItem(
5, 0,
QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS))
self.resultModelBD.setItem(
5, 1,
QStandardItem(
str(round(distance.Kilometres, 4)) + " km"))
dataList = []
dataList.append([
"ID (Start)", "Latitude (Start)", "Longitude (Start)",
"Variation (Start)", "ID (Finish)",
"Latitude (Finish)", "Longitude (Finish)",
"Variation (Finish)", "Forward (° T)", "Forward (° M)",
"Reverse (° T)", "Reverse (° M)", "Distance (nm)",
"Distance (km)"
])
dataList.append([
self.parametersPanel.pnlStartPosBD.ID,
str(degree),
str(degree1),
str(self.parametersPanel.pnlVarStartBD.Value),
self.parametersPanel.pnlFinishPosBD.ID,
str(degree2),
str(degree3),
str(self.parametersPanel.pnlVarFinishBD.Value),
str(num),
str(num4),
str(round(num, 4)),
str(round(num2, 4)),
str(distance.NauticalMiles),
str(distance.Kilometres)
])
GeoDetermineDlg.HistoryDataBD.append(dataList)
self.setDataInHistoryModel(dataList)
self.method_28_BD()
def fillStartEndPointsCombos(self):
""" Change start and end point combo when an other traversing type selected.
"""
# get selected stations
oldStartPoint = self.ui.StartPointComboBox.itemData(
self.ui.StartPointComboBox.currentIndex())
oldEndPoint = self.ui.EndPointComboBox.itemData(
self.ui.EndPointComboBox.currentIndex())
# clear combos
self.ui.StartPointComboBox.clear()
self.ui.EndPointComboBox.clear()
self.ui.StartPointComboBox.setEnabled(False)
self.ui.EndPointComboBox.setEnabled(False)
#get combobox models
combomodel1 = self.ui.StartPointComboBox.model()
combomodel2 = self.ui.EndPointComboBox.model()
#get stations
known_stations = get_stations(True, False)
oriented_stations = get_stations(True, True)
# fill StartPointComboBox and EndPointComboBox
start_points = []
end_points = []
if oriented_stations is not None and self.ui.ClosedRadio.isChecked():
for stn in oriented_stations:
start_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
end_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.StartPointComboBox.setEnabled(True)
elif known_stations is not None and self.ui.LinkRadio.isChecked():
for stn in known_stations:
start_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
end_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.StartPointComboBox.setEnabled(True)
self.ui.EndPointComboBox.setEnabled(True)
elif oriented_stations is not None and self.ui.OpenRadio.isChecked():
for stn in oriented_stations:
start_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.StartPointComboBox.setEnabled(True)
self.ui.EndPointComboBox.setEnabled(True)
known_points = get_known()
if start_points is not None:
for startpoint in start_points:
item = QStandardItem(startpoint[0])
item.setData(startpoint[1], Qt.UserRole)
if known_points is not None and startpoint[1][
0] in known_points:
itemfont = item.font()
itemfont.setWeight(QFont.Bold)
item.setFont(itemfont)
combomodel1.appendRow(item)
if end_points is not None:
for endpoint in end_points:
item = QStandardItem(endpoint[0])
item.setData(endpoint[1], Qt.UserRole)
if known_points is not None and endpoint[1][0] in known_points:
itemfont = item.font()
itemfont.setWeight(QFont.Bold)
item.setFont(itemfont)
combomodel2.appendRow(item)
# select previously selected start/end point if present in the list
self.ui.StartPointComboBox.setCurrentIndex(
self.ui.StartPointComboBox.findData(oldStartPoint))
self.ui.EndPointComboBox.setCurrentIndex(
self.ui.EndPointComboBox.findData(oldEndPoint))
# in case of closed traverse ens point must be the same as start point
if self.ui.ClosedRadio.isChecked():
self.ui.EndPointComboBox.setCurrentIndex(
self.ui.StartPointComboBox.currentIndex())
def createItem(self, node):
new_item = QStandardItem(node.name())
new_item.setData(node.uid(), Qt.UserRole + 1)
self.itemmap[node.uid()] = new_item
return new_item
def create_file_size_item(size):
item = QStandardItem(get_file_display_size(size))
item.setData(size, USER_ROLE_SIZE)
return item
