def populateList(self):
model = QStandardItemModel()
for option in self.selectedoptions:
item = QStandardItem(option)
model.appendRow(item)
self.lstLayers.setModel(model)
def __init__(self, terms, parent):
items = {}
model = QStandardItemModel(parent)
for term in terms:
parts = str(term).split('.')
for i in range(len(parts)):
parent_key = '.'.join(parts[:i])
item_key = '.'.join(parts[:i + 1])
if (item_key in items):
continue
parent_item = items.get(parent_key)
item = QStandardItem(parts[i])
if (parent_item):
parent_item.appendRow(item)
else:
model.appendRow(item)
items[item_key] = item
self._model = model
super(XQueryCompleter, self).__init__(model, parent)
def __addFirstRowToModel(self, oldModel, newRow):
"""
:type oldModel: QAbstractItemModel
:type newRow: list
:return: QStandardItemModel
"""
model = QStandardItemModel(self)
items = []
for str in newRow:
items.append(QStandardItem(str))
model.appendRow(items)
for i in xrange(oldModel.rowCount()):
items = []
for j in xrange(oldModel.columnCount()):
index = QModelIndex(oldModel.index(i, j))
data = oldModel.data(index)
item = QStandardItem(data)
items.append(item)
model.appendRow(items)
return model
def _select_tags(self):
tag_dialog = SelectTagsDialog()
# if the user has their own taglist, use it
user_tag_list = os.path.join(os.path.expanduser("~"), '.plugin_tags.txt')
if os.path.exists(user_tag_list):
tag_file = user_tag_list
else:
tag_file = os.path.join(str(self.plugin_builder_path),
'taglist.txt')
with open(tag_file) as tf:
tags = tf.readlines()
model = QStandardItemModel()
for tag in tags:
item = QStandardItem(tag[:-1])
model.appendRow(item)
tag_dialog.listView.setModel(model)
tag_dialog.show()
ok = tag_dialog.exec_()
if ok:
selected = tag_dialog.listView.selectedIndexes()
seltags = []
for tag in selected:
seltags.append(tag.data())
taglist = ", ".join(seltags)
self.dialog.tags.setText(taglist)
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 __init__( self, terms, parent ):
items = {}
model = QStandardItemModel(parent)
for term in terms:
parts = str(term).split('.')
for i in range(len(parts)):
parent_key = '.'.join(parts[:i])
item_key = '.'.join(parts[:i+1])
if ( item_key in items ):
continue
parent_item = items.get(parent_key)
item = QStandardItem(parts[i])
if ( parent_item ):
parent_item.appendRow(item)
else:
model.appendRow(item)
items[item_key] = item
self._model = model
super(XQueryCompleter, self).__init__(model, parent)
def __addFirstRowToModel(self, oldModel, newRow):
"""
:type oldModel: QAbstractItemModel
:type newRow: list
:return: QStandardItemModel
"""
model = QStandardItemModel(self)
items = []
for str in newRow:
items.append(QStandardItem(str))
model.appendRow(items)
for i in xrange(oldModel.rowCount()):
items = []
for j in xrange(oldModel.columnCount()):
index = QModelIndex(oldModel.index(i, j))
data = oldModel.data(index)
item = QStandardItem(data)
items.append(item)
model.appendRow(items)
return model
def setupChecklist(widget, names, checks = None):
tp = type(widget)
# Prepare checks
if checks is None:
checks = []
for name in names:
checks.append(Qt.Unchecked)
else:
newChecks = []
for check in checks:
if check: newChecks.append(Qt.Checked)
else: newChecks.append(Qt.Unchecked)
checks = newChecks
## QListView
if tp is QListView:
model = QStandardItemModel()
for i in xrange(len(names)):
item = QStandardItem(names[i])
item.setCheckable(True)
item.setCheckState(checks[i])
model.appendRow(item)
widget.setModel(model)
## QListWidget
elif tp is QListWidget:
for i in xrange(len(names)):
item = QListWidgetItem(names[i])
item.setFlags(Qt.ItemFlags(48)) # 48 = checkable(16), enabled(32)
item.setCheckState(checks[i])
widget.addItem(item)
## NOT SUPPORTED
else: raise TypeError('Class ' + str(tp) + ' is not supported.')
def test_tooltree(self):
tree = ToolTree()
role = tree.actionRole()
model = QStandardItemModel()
tree.setModel(model)
item = QStandardItem("One")
item.setData(QAction("One", tree), role)
model.appendRow([item])
cat = QStandardItem("A Category")
item = QStandardItem("Two")
item.setData(QAction("Two", tree), role)
cat.appendRow([item])
item = QStandardItem("Three")
item.setData(QAction("Three", tree), role)
cat.appendRow([item])
model.appendRow([cat])
def p(action):
print "triggered", action.text()
tree.triggered.connect(p)
tree.show()
self.app.exec_()
def __loadRules(self, the_rules, tree_view):
model = QStandardItemModel(self)
for r in the_rules:
item = QStandardItem(r)
model.appendRow(item)
model.setHeaderData(0, Qt.Horizontal, "Regular Expression")
tree_view.setModel(model)
def init_cmd_table(self):
model = QStandardItemModel()
model.setColumnCount(3)
model.setHeaderData(0, Qt.Horizontal, "Command")
model.setHeaderData(1, Qt.Horizontal, "Tag")
model.setHeaderData(2, Qt.Horizontal, "Description")
import json
print sys.path[0]
os.chdir(sys.path[0])
f = file('command.txt')
cmds = json.load(f)
f.close()
for cmd in cmds:
l = []
for field in cmd:
if type(field) is types.ListType:
f = '\n'.join(field)
else:
f = field
l.append(QStandardItem(f))
model.appendRow(l)
self.tableView.setModel(model)
self.tableView.resizeRowsToContents()
self.model = model
class CurvePanel(QListView):
def __init__(self, curve_source):
QListView.__init__(self)
self.curve_source = curve_source
self.setViewMode(QListView.IconMode)
self.setIconSize(QSize(64,64))
self.model = QStandardItemModel()
for curve in curve_source._curves:
self.add_curve(curve)
self.setModel(self.model)
self.setWrapping(True)
self.show()
def edit(self, index, trigger, event):
if trigger == QAbstractItemView.DoubleClicked:
item = self.model.item(index.row())
curve = item.curve
print curve.name()
return True
else:
return False
def add_new_curve(self):
pass
def add_curve(self, curve):
name = curve.name()
plot = self._create_plot(name)
item = PlotItem(plot)
item.curve = curve
self.model.appendRow(item)
def _create_plot(self, xcurve_name):
index = self.curve_source.index()
return Plot.of(xcurve_name, index.name()).from_(self.curve_source)
def generateLeftListLogTypeModel(self):
'''Returns all LogType list model '''
existingLogTypes = []
logType = LogType.GAMMA
#get type for each log
if self._logs is not None and len(self._logs)>0:
for log in self._logs:
existingLogTypes.append(log.log_type_name)
generalSettings = GeneralSettings()
if generalSettings.workflowType == WorkflowType.petrophysics:
logTypeList = logType.getAllLogTypesPetrophysicsStringList()
elif generalSettings.workflowType == WorkflowType.rockphysics:
logTypeList = logType.getAllLogTypesRockPhysicsStringList()
else:
logTypeList = logType.getAllLogTypesStringList()
model = QStandardItemModel(self._dataListToListWidget.leftDataTypeListView)
for logType in logTypeList:
item = QStandardItem(logType)
# checkboxes are confusing
item.setCheckable(False)
if logType not in existingLogTypes:
item.setForeground(Qt.gray)
model.appendRow(item)
return model
def test_tooltree(self):
tree = ToolTree()
role = tree.actionRole()
model = QStandardItemModel()
tree.setModel(model)
item = QStandardItem("One")
item.setData(QAction("One", tree), role)
model.appendRow([item])
cat = QStandardItem("A Category")
item = QStandardItem("Two")
item.setData(QAction("Two", tree), role)
cat.appendRow([item])
item = QStandardItem("Three")
item.setData(QAction("Three", tree), role)
cat.appendRow([item])
model.appendRow([cat])
def p(action):
print "triggered", action.text()
tree.triggered.connect(p)
tree.show()
self.app.exec_()
def __loadRules(self, the_rules, tree_view): model = QStandardItemModel(self) for r in the_rules: item = QStandardItem(r) model.appendRow(item) model.setHeaderData(0, Qt.Horizontal, "Regular Expression") tree_view.setModel(model)
class dockUrlMonitor(QTreeView):
''' dock widget for get all credentials logger netcreds'''
def __init__(self, parent=None,info={}):
super(dockUrlMonitor, self).__init__(parent)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(['URL','HTTP-Headers'])
self.setModel(self.model)
self.setUniformRowHeights(True)
self.setColumnWidth(0,130)
def writeModeData(self,data):
''' get data output and add on QtableWidgets '''
ParentMaster = QStandardItem('[ {0[src]} > {0[dst]} ] {1[Method]} {1[Host]}{1[Path]}'.format(
data['urlsCap']['IP'], data['urlsCap']['Headers']))
ParentMaster.setIcon(QIcon('icons/accept.png'))
ParentMaster.setSizeHint(QSize(30,30))
for item in data['urlsCap']['Headers']:
ParentMaster.appendRow([QStandardItem('{}'.format(item)),
QStandardItem(data['urlsCap']['Headers'][item])])
self.model.appendRow(ParentMaster)
self.setFirstColumnSpanned(ParentMaster.row(),
self.rootIndex(), True)
self.scrollToBottom()
def clear(self):
self.model.clear()
def stopProcess(self):
self.clearSelection()
def list_view(self):
list = QListView()
# Create an empty model for the list's data
# model = QStandardItemModel(list)
repo = LocusRepository()
locusList = repo.get_all_locus()
# Create an empty model for the list's data
model = QStandardItemModel(list)
for locus in locusList:
# Create an item with a caption
item = QStandardItem(locus.locus_id)
# Add the item to the model
model.appendRow(item)
model.itemChanged.connect(self.on_item_changed)
# current_index = 0
# list.currentChanged(current_index)
# list.selectionModel().currentChanged.connect(on_current_changed)
# self.listWidget.itemClicked.connect(self.printItemText)
# app.connect(list, SIGNAL("currentChanged()"),
# printItemText)
# Apply the model to the list view
list.setModel(model)
list.selectionModel().currentChanged.connect(self.on_current_changed)
self.horizontalLayout_1.addWidget(list)
def onConnectClick(self):
# On remplit le champ Serveur s'il était vide
if self.dlg.url.text() == "":
self.dlg.url.setText("localhost")
# On prépare la liste
listView = self.dlg.layerList
model = QStandardItemModel(listView)
try:
# On ouvre une connexion à la base
self.connector = EsConnector(self.dlg.url.text(),
self.dlg.port.text())
# On parcourt les index
aliases = self.connector.makeGetCallToES("_aliases")
for index in aliases:
# On parcourt les types
metadata = self.connector.makeGetCallToES(index)
mappings = metadata[index]["mappings"]
for type in mappings:
# On parcourt les champs
mapping = mappings[type]["properties"]
for field in mapping:
# Si le champ est de type geo_shape ou geo_point
if mapping[field]["type"] == "geo_point" or mapping[
field]["type"] == "geo_shape":
# On mémorise ce champ
self.connector.addGeoField({
"index":
index,
"type":
type,
"field":
field,
"geotype":
mapping[field]["type"]
})
# On affiche ce champ dans la liste
item = QStandardItem('- Index "' + index +
'" / Type "' + type +
'" / Champ "' + field +
'" (' +
mapping[field]["type"] + ')')
model.appendRow(item)
# Si au moins un champ a été trouvé
if model.rowCount() > 0:
# On met à jour le contenu de la liste
listView.setModel(model)
# On active le bouton "Ajouter"
self.dlg.addLayers.setEnabled(True)
else:
self.iface.messageBar().pushMessage(
"ElasticSearch Connector",
'Aucun champ "geo_shape" ou "geo_point" disponible',
level=QgsMessageBar.WARNING,
duration=5)
# On se déconnecte de la base
except ESConnectorException, e:
self.iface.messageBar().pushMessage("ElasticSearch Connector",
str(e),
level=QgsMessageBar.CRITICAL,
duration=5)
def _select_tags(self):
tag_dialog = SelectTagsDialog()
# if the user has their own taglist, use it
user_tag_list = os.path.join(os.path.expanduser("~"),
'.plugin_tags.txt')
if os.path.exists(user_tag_list):
tag_file = user_tag_list
else:
tag_file = os.path.join(str(self.plugin_builder_path),
'taglist.txt')
with open(tag_file) as tf:
tags = tf.readlines()
model = QStandardItemModel()
for tag in tags:
item = QStandardItem(tag[:-1])
model.appendRow(item)
tag_dialog.listView.setModel(model)
tag_dialog.show()
ok = tag_dialog.exec_()
if ok:
selected = tag_dialog.listView.selectedIndexes()
seltags = []
for tag in selected:
seltags.append(tag.data())
taglist = ", ".join(seltags)
self.dialog.tags.setText(taglist)
class dockUrlMonitor(QTreeView):
''' dock widget for get all credentials logger netcreds'''
def __init__(self, parent=None, info={}):
super(dockUrlMonitor, self).__init__(parent)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(['URL', 'HTTP-Headers'])
self.setModel(self.model)
self.setUniformRowHeights(True)
self.setColumnWidth(0, 130)
def writeModeData(self, data):
''' get data output and add on QtableWidgets '''
ParentMaster = QStandardItem(
'[ {0[src]} > {0[dst]} ] {1[Method]} {1[Host]}{1[Path]}'.format(
data['urlsCap']['IP'], data['urlsCap']['Headers']))
ParentMaster.setIcon(QIcon('icons/accept.png'))
ParentMaster.setSizeHint(QSize(30, 30))
for item in data['urlsCap']['Headers']:
ParentMaster.appendRow([
QStandardItem('{}'.format(item)),
QStandardItem(data['urlsCap']['Headers'][item])
])
self.model.appendRow(ParentMaster)
self.setFirstColumnSpanned(ParentMaster.row(), self.rootIndex(), True)
self.scrollToBottom()
def clear(self):
self.model.clear()
def stopProcess(self):
self.clearSelection()
def createComboBoxWithStrings(self, array):
dbList = QComboBox()
dbsListModel = QStandardItemModel(dbList)
for f in array:
item = QStandardItem(f)
dbsListModel.appendRow(item)
dbList.setModel(dbsListModel)
return dbList
def generateLeftListLogModel(self):
'''Returns log model using all logs in self._logs '''
model = QStandardItemModel(self._dataListToListWidget.leftDataTypeListView)
for log in self._logs:
item = QStandardItem(log.name)
# checkboxes are confusing
item.setCheckable(False)
model.appendRow(item)
return model
def populateList(self):
model = QStandardItemModel()
for i, option in enumerate(self.options):
item = QStandardItem(option)
item.setCheckState(Qt.Checked if i in self.selectedoptions else Qt.Unchecked)
item.setCheckable(True)
model.appendRow(item)
self.lstLayers.setModel(model)
def populateList(self):
model = QStandardItemModel()
for i, option in enumerate(self.options):
item = QStandardItem(option)
item.setCheckState(Qt.Checked if i in
self.selectedoptions else Qt.Unchecked)
item.setCheckable(True)
model.appendRow(item)
self.lstLayers.setModel(model)
def on_show_history_wifi_name(self):
self.history_wifi_list = get_history_connected_wifi()
model = QStandardItemModel(self.showWIFIListView)
# Get each history wifi name
for wifi_name in self.history_wifi_list:
item = QStandardItem(wifi_name)
# Add the item to the model
model.appendRow(item)
self.showWIFIListView.setModel(model)
self.showWIFIListView.show()
class FlowItemTreeWidget(QTreeView):
def __init__(self, parent=None):
QTreeView.__init__(self, parent)
self.setAnimated(True)
self.setDragEnabled(True)
self.setRootIsDecorated(False)
self.setFrameShape(QFrame.NoFrame)
self.setIconSize(QSize(22, 22))
self.header().setStretchLastSection(True)
# background color
palette = self.viewport().palette()
palette.setColor(self.viewport().backgroundRole(), Qt.transparent)
palette.setColor(self.viewport().foregroundRole(),
palette.color(QPalette.WindowText))
self.viewport().setPalette(palette)
# Model
self._model = QStandardItemModel()
self.proxy = FlowItemSortFilterProxyModel(self)
self.proxy.setSourceModel(self._model)
self.setModel(self.proxy)
self.header().hide()
def addCategory(self, category, items):
# Items
root = QStandardItem(category)
root.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._model.appendRow(root)
# Styling
root.setFlags(Qt.ItemIsEnabled)
f = root.font()
f.setPointSize(10)
f.setBold(True)
root.setFont(f)
for item in items:
ins = item()
child = QStandardItem(QIcon.fromTheme(ins.iconname),
ins.description)
child.setData(QVariant(item), Qt.UserRole)
child.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
if ins.__doc__ is not None and len(ins.__doc__) > 0:
child.setWhatsThis(ins.__doc__)
root.appendRow(child)
def setFilter(self, pattern):
self.proxy.setFilterRegExp(
QRegExp(pattern, Qt.CaseInsensitive, QRegExp.FixedString))
self.expandAll()
def populateRightListView(self, rightDataList):
assert all(isinstance(item, str) for item in rightDataList)
model = self.rightListView.model()
if model is None:
model = QStandardItemModel(self.rightListView)
for data in rightDataList:
item = QStandardItem(data)
# disable checkbox as is confusing
item.setCheckable(False)
model.appendRow(item)
self.rightListView.setModel(model)
def loadData(self): model = QStandardItemModel() self.games = Game.loadFromFile() items = [] for g in self.games: items.append(str(g)) for i in items: model.appendRow( QStandardItem(i) ) self.ui.listView.setModel(model)
def show_result(self, search_time):
self.set_results_heading_text("{} Ergebnisse in {:.2f} Sekunden".format(len(self.result), search_time))
result = self.result
model = QStandardItemModel(self.list_results)
for index in range(min(len(result), self.max_results)):
node = result.get_node(index)
context = result.get_context(index)
item_text = [str(index + 1) + ". " + node.get_title(),
node.get_urls()[0],
"\t" + context]
item = QStandardItem("\n".join(item_text))
model.appendRow(item)
self.list_results.setModel(model)
self.list_results.show()
class FlowItemTreeWidget( QTreeView ):
def __init__( self, parent = None ):
QTreeView.__init__( self, parent )
self.setAnimated( True )
self.setDragEnabled( True )
self.setRootIsDecorated( False )
self.setFrameShape( QFrame.NoFrame )
self.setIconSize( QSize( 22, 22 ) )
self.header().setStretchLastSection( True )
# background color
palette = self.viewport().palette()
palette.setColor( self.viewport().backgroundRole(), Qt.transparent )
palette.setColor( self.viewport().foregroundRole(), palette.color( QPalette.WindowText ) )
self.viewport().setPalette( palette )
# Model
self._model = QStandardItemModel()
self.proxy = FlowItemSortFilterProxyModel( self )
self.proxy.setSourceModel( self._model )
self.setModel( self.proxy )
self.header().hide()
def addCategory( self, category, items ):
# Items
root = QStandardItem( category )
root.setFlags( Qt.ItemIsEnabled | Qt.ItemIsSelectable )
self._model.appendRow( root )
# Styling
root.setFlags( Qt.ItemIsEnabled )
f = root.font()
f.setPointSize( 10 )
f.setBold( True )
root.setFont( f )
for item in items:
ins = item()
child = QStandardItem( QIcon.fromTheme( ins.iconname ), ins.description )
child.setData( QVariant( item ), Qt.UserRole )
child.setFlags( Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled )
if ins.__doc__ is not None and len( ins.__doc__ ) > 0: child.setWhatsThis( ins.__doc__ )
root.appendRow( child )
def setFilter( self, pattern ):
self.proxy.setFilterRegExp( QRegExp( pattern, Qt.CaseInsensitive, QRegExp.FixedString ) )
self.expandAll()
class HistoryDialog(QDialog, Ui_HistoryDialogPythonConsole):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.setWindowTitle(
QCoreApplication.translate("PythonConsole",
"Python Console - Command History"))
self.listView.setToolTip(
QCoreApplication.translate("PythonConsole",
"Double click on item to execute"))
self.model = QStandardItemModel(self.listView)
self._reloadHistory()
self.deleteScut = QShortcut(QKeySequence(Qt.Key_Delete), self)
self.deleteScut.activated.connect(self._deleteItem)
self.listView.doubleClicked.connect(self._runHistory)
self.reloadHistory.clicked.connect(self._reloadHistory)
self.saveHistory.clicked.connect(self._saveHistory)
def _runHistory(self, item):
cmd = item.data(Qt.DisplayRole)
self.parent.runCommand(unicode(cmd))
def _saveHistory(self):
self.parent.writeHistoryFile(True)
def _reloadHistory(self):
self.model.clear()
for i in self.parent.history:
item = QStandardItem(i)
if sys.platform.startswith('win'):
item.setSizeHint(QSize(18, 18))
self.model.appendRow(item)
self.listView.setModel(self.model)
self.listView.scrollToBottom()
def _deleteItem(self):
itemsSelected = self.listView.selectionModel().selectedIndexes()
if itemsSelected:
item = itemsSelected[0].row()
## Remove item from the command history (just for the current session)
self.parent.history.pop(item)
self.parent.historyIndex -= 1
## Remove row from the command history dialog
self.model.removeRow(item)
class NameList(QDockWidget):
def __init__(self, window):
super(NameList, self).__init__('Current Plots')
self.namelist_model = QStandardItemModel()
self.namelist_view = QListView()
self.namelist_view.setModel(self.namelist_model)
self.setWidget(self.namelist_view)
self.window = window
self.plot_dict = {}
self.namelist_view.doubleClicked.connect(self.activate_item)
self.namelist_view.setContextMenuPolicy(QtConst.ActionsContextMenu)
delete_action = QAction("Delete Selected", self.namelist_view)
delete_action.triggered.connect(self.delete_item)
self.namelist_view.addAction(delete_action)
def activate_item(self, index):
item = self.namelist_model.itemFromIndex(index)
plot = self.plot_dict[str(item.text())]
if plot.closed:
plot.closed = False
self.window.add_plot(plot)
def delete_item(self):
index = self.namelist_view.currentIndex()
item = self.namelist_model.itemFromIndex(index)
del self[str(item.text())]
def __getitem__(self, item):
return self.plot_dict[item]
def __setitem__(self, name, plot):
model = QStandardItem(name)
model.setEditable(False)
self.namelist_model.appendRow(model)
self.plot_dict[name] = plot
def __contains__(self, value):
return value in self.plot_dict
def __delitem__(self, name):
self.namelist_model.removeRow(
self.namelist_model.findItems(name)[0].index().row())
self.plot_dict[name].close()
del self.plot_dict[name]
def keys(self):
return self.plot_dict.keys()
class HistoryDialog(QDialog, Ui_HistoryDialogPythonConsole):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.setWindowTitle(QCoreApplication.translate("PythonConsole",
"Python Console - Command History"))
self.listView.setToolTip(QCoreApplication.translate("PythonConsole",
"Double click on item to execute"))
self.model = QStandardItemModel(self.listView)
self._reloadHistory()
self.deleteScut = QShortcut(QKeySequence(Qt.Key_Delete), self)
self.deleteScut.activated.connect(self._deleteItem)
self.listView.doubleClicked.connect(self._runHistory)
self.reloadHistory.clicked.connect(self._reloadHistory)
self.saveHistory.clicked.connect(self._saveHistory)
def _runHistory(self, item):
cmd = item.data(Qt.DisplayRole)
self.parent.runCommand(unicode(cmd))
def _saveHistory(self):
self.parent.writeHistoryFile(True)
def _reloadHistory(self):
self.model.clear()
for i in self.parent.history:
item = QStandardItem(i)
if sys.platform.startswith('win'):
item.setSizeHint(QSize(18, 18))
self.model.appendRow(item)
self.listView.setModel(self.model)
self.listView.scrollToBottom()
def _deleteItem(self):
itemsSelected = self.listView.selectionModel().selectedIndexes()
if itemsSelected:
item = itemsSelected[0].row()
## Remove item from the command history (just for the current session)
self.parent.history.pop(item)
self.parent.historyIndex -= 1
## Remove row from the command history dialog
self.model.removeRow(item)
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()
def setupList(widget, items):
# QListWidget
if type(widget) is QListWidget:
widget.clear()
for item in items:
widget.addItem(item)
# QListView
elif type(widget) is QListView:
model = QStandardItemModel()
for item in items:
row = QStandardItem(item)
model.appendRow(row)
widget.setModel(model)
elif type(widget) is QPlainTextEdit:
widget.clear()
widget.insertPlainText(str.join('\n', items))
# Not supported
else: raise TypeError('Class ' + str(type(widget)) + ' is not supported.')
class DataModel(object):
def __init__(self):
super(DataModel,self).__init__()
self.servers = QStandardItemModel(0,3)
self.selected = ''
self.autoconnect = False
def loadSettings(self):
settings = QSettings()
servers = settings.value("servers", None)
self.servers.clear()
if servers:
for s in servers:
self.servers.appendRow([QStandardItem(str(i)) for i in s])
self.selected = str(settings.value("selected", self.selected))
self.autoconnect = int(settings.value("autoconnect", self.autoconnect))
def saveSettings(self):
settings = QSettings()
servers = []
if self.servers:
for row in xrange(self.servers.rowCount()):
entry = []
for col in xrange(self.servers.columnCount()):
entry += [self.servers.item(row,col).text()]
servers += [entry]
if len(servers):
settings.setValue("servers", servers)
else:
settings.setValue("servers", None)
settings.setValue("selected", str(self.selected))
settings.setValue("autoconnect", int(self.autoconnect))
def selectedServer(self):
selectedServer = []
if self.selected:
result = self.servers.findItems( self.selected)
if len(result):
mi = result[0]
row = mi.row()
for col in xrange(self.servers.columnCount()):
selectedServer += [self.servers.item(row,col).text()]
return selectedServer
def initListView(self):
"""Init status table"""
# List Box model
model = QStandardItemModel()
# Init list objects
for i, frame in enumerate(self.task.videoLabelHandler.files):
item = QStandardItem(frame + "\t{0} Objects".format(len(self.task.videoLabelHandler.objects)))
item.setCheckState(Qt.Checked)
item.setCheckable(True)
model.appendRow(item)
if self.segmentation_mode:
model.item(0).setEnabled(False)
else:
model.item(i).setCheckState(Qt.Unchecked)
model.item(i).setEnabled(False)
# Set model
self.view.setModel(model)
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 __init__(self, data, parent=None):
"""Constructor."""
super(GDALLocationInfoForm, self).__init__(parent)
self.setupUi(self)
self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
model = QStandardItemModel()
model.setHorizontalHeaderLabels([self.tr('object/attribute'), self.tr('value')])
self.treeView.setModel(model)
self.treeView.setUniformRowHeights(True)
for object_name, object_attrs in data.items():
parent = QStandardItem(object_name)
for attr_name, attr_value in object_attrs.items():
attr_name_item = QStandardItem(attr_name)
attr_value_item = QStandardItem(attr_value)
parent.appendRow([attr_name_item, attr_value_item])
model.appendRow(parent)
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)
def fillCheckboxes(self, layers, name):
"""
Function for filling listView with checkboxes
:param layers: layers from Qgis legend
:param name: name of current layer from comboBox
:return:
"""
layer = None
model = QStandardItemModel()
self.dlg.listView.reset()
for layer in layers:
if layer.name() == name:
fields = layer.pendingFields()
fieldNames = [field.name() for field in fields]
for fieldName in fieldNames:
item = QStandardItem(fieldName)
item.setCheckable(True)
item.setText(fieldName)
model.appendRow(item)
self.dlg.listView.setModel(model)
class GameListWidget(QListView):
def __init__(self, parent=None):
QListView.__init__(self, parent)
self.game_list = []
self.model = QStandardItemModel()
self.setModel(self.model)
self.setWordWrap(True)
self.setUniformItemSizes(True)
self.setGridSize(QSize(self.rect().width(), 30))
self.setFont(QFont("Microsoft YaHei", 10))
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
# self.setFocusPolicy(Qt.NoFocus)
self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
#self.setAcceptDrops(True)
self.game_controller = GameController()
self.game_controller.connector.connect(SIGNAL('game_list'),
self.add_game_item)
self.game_controller.connector.connect(SIGNAL('game_list_clear'),
self.clear)
self.clicked.connect(self.double_click_on_item) ## ??????
def double_click_on_item(self, idx):
print('%d was clicked' % (idx))
self.emit(SIGNAL("enter_room(QString, QString)"),
self.game_list[idx][0], self.game_list[idx][1])
def add_game_item(self, txt, id):
self.game_list.append((id, txt))
item = QStandardItem(txt)
item.setTextAlignment(Qt.AlignCenter)
self.model.appendRow(item)
def clear(self):
self.model.clear()
def comboProjectChanged(self):
if len(self.ui.comboProject.currentText()) > 0:
self.project_id = self.projects_id[self.ui.comboProject.currentText()]
#get project tasks
qsubtasks = QStandardItemModel()
for proj_tasks in self.asana_api.tasks.find_by_project(self.project_id, { 'completed_since': 'now'}):
item = QStandardItem(proj_tasks['name'])
item.setEditable(True)
item.setToolTip('Double click to edit')
if not proj_tasks['name'].endswith(':'):
check = Qt.Unchecked
item.setCheckState(check)
item.setCheckable(True)
self.projects_id[proj_tasks['name']] = proj_tasks['id']
item.setStatusTip(str(proj_tasks['id']))
else:
font = QFont()
font.setWeight(QFont.Bold)
item.setFont(font)
#populate the listview
qsubtasks.appendRow(item)
self.ui.listTasks.setModel(qsubtasks)
QApplication.setOverrideCursor(QCursor(Qt.ArrowCursor))
qsubtasks.itemChanged.connect(self.checkTasks)
def __init__(self):
QWidget.__init__(self)
layout = QVBoxLayout()
self.model = DataTypeKeysListModel()
self.filter_model = DataTypeProxyModel(self.model)
self.search_box = SearchBox()
self.search_box.filterChanged.connect(self.setSearchString)
layout.addWidget(self.search_box)
data_type_model = QStandardItemModel(0, 1)
item = QStandardItem("Select data types...")
data_type_model.appendRow(item)
self.__summary_item = QStandardItem("Summary")
self.__summary_item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
self.__summary_item.setData(Qt.Checked, Qt.CheckStateRole)
data_type_model.appendRow(self.__summary_item)
self.__block_item = QStandardItem("Block")
self.__block_item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
self.__block_item.setData(Qt.Checked, Qt.CheckStateRole)
data_type_model.appendRow(self.__block_item)
data_type_model.itemChanged.connect(self.onItemChanged)
combo = QComboBox()
combo.setModel(data_type_model)
layout.addWidget(combo)
self.data_type_keys_widget = QListView()
self.data_type_keys_widget.setModel(self.filter_model)
self.data_type_keys_widget.selectionModel().selectionChanged.connect(self.itemSelected)
layout.addSpacing(15)
layout.addWidget(self.data_type_keys_widget, 2)
layout.addWidget(Legend("Default types", DataTypeKeysListModel.DEFAULT_DATA_TYPE))
layout.addWidget(Legend("Observations available", DataTypeKeysListModel.HAS_OBSERVATIONS))
self.setLayout(layout)
class TemplateDocumentSelector(QDialog, Ui_frmDocumentSelector):
"""
Dialog for selecting a document template from the saved list.
"""
def __init__(self, parent=None, selectMode=True):
QDialog.__init__(self, parent)
self.setupUi(self)
self.notifBar = NotificationBar(self.vlNotification)
if selectMode:
self.buttonBox.setVisible(True)
self.manageButtonBox.setVisible(False)
currHeight = self.size().height()
self.resize(200, currHeight)
else:
self.buttonBox.setVisible(False)
self.manageButtonBox.setVisible(True)
self.setWindowTitle(
QApplication.translate("TemplateDocumentSelector",
"Template Manager"))
#Configure manage buttons
btnEdit = self.manageButtonBox.button(QDialogButtonBox.Ok)
btnEdit.setText(
QApplication.translate("TemplateDocumentSelector", "Edit..."))
btnEdit.setIcon(QIcon(":/plugins/stdm/images/icons/edit.png"))
btnDelete = self.manageButtonBox.button(QDialogButtonBox.Save)
btnDelete.setText(
QApplication.translate("TemplateDocumentSelector", "Delete"))
btnDelete.setIcon(QIcon(":/plugins/stdm/images/icons/delete.png"))
#Connect signals
self.buttonBox.accepted.connect(self.onAccept)
btnEdit.clicked.connect(self.onEditTemplate)
btnDelete.clicked.connect(self.onDeleteTemplate)
#Get saved document templates then add to the model
templates = documentTemplates()
self._docItemModel = QStandardItemModel(parent)
self._docItemModel.setColumnCount(2)
for name, path in templates.iteritems():
docNameItem = self._createDocNameItem(name)
filePathItem = QStandardItem(path)
self._docItemModel.appendRow([docNameItem, filePathItem])
self.lstDocs.setModel(self._docItemModel)
def _createDocNameItem(self, docName):
"""
Create a template document standard item.
"""
#Set icon
icon = QIcon()
icon.addPixmap(QPixmap(":/plugins/stdm/images/icons/document.png"),
QIcon.Normal, QIcon.Off)
dnItem = QStandardItem(icon, docName)
return dnItem
def onEditTemplate(self):
"""
Slot raised to edit document template.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document template to edit"))
return
templateName, filePath = self.documentMapping()
docName,ok = QInputDialog.getText(self, \
QApplication.translate("TemplateDocumentSelector","Edit Template"), \
QApplication.translate("TemplateDocumentSelector","Please enter the new template name below"), \
text = templateName)
if ok and docName == "":
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Template name cannot be empty"))
return
elif docName == templateName:
return
elif ok and docName != "":
result, newTemplatePath = self._editTemplate(filePath, docName)
if result:
#Update view
mIndices = self._selectedMappings()
docNameItem = self._docItemModel.itemFromIndex(mIndices[0])
filePathItem = self._docItemModel.itemFromIndex(mIndices[1])
docNameItem.setText(docName)
filePathItem.setText(newTemplatePath)
self.notifBar.insertInfoNotification(QApplication.translate("TemplateDocumentSelector", \
"'{0}' template has been successfully updated".format(docName)))
else:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Error: '{0}' template could not be updated".format(templateName)))
def onDeleteTemplate(self):
"""
Slot raised to delete document template.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document template to delete"))
return
templateName, filePath = self.documentMapping()
result = QMessageBox.warning(self, QApplication.translate("TemplateDocumentSelector", \
"Confirm delete"),
QApplication.translate("TemplateDocumentSelector", \
"Are you sure you want to delete '{0}' template?" \
"This action cannot be undone.\nClick Yes to proceed " \
"or No to cancel.".format(templateName)),
QMessageBox.Yes|QMessageBox.No)
if result == QMessageBox.No:
return
status = self._deleteDocument(filePath)
if status:
#Remove item from list using model index row number
selectedDocNameIndices = self.lstDocs.selectionModel(
).selectedRows(0)
row = selectedDocNameIndices[0].row()
self._docItemModel.removeRow(row)
self.notifBar.insertInfoNotification(QApplication.translate("TemplateDocumentSelector", \
"'{0}' template has been successfully removed".format(templateName)))
else:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Error: '{0}' template could not be removed".format(templateName)))
def onAccept(self):
"""
Slot raised to close the dialog only when a selection has been made by the user.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document"))
return
self.accept()
def _selectedMappings(self):
"""
Returns the model indices for the selected row.
"""
selectedDocNameIndices = self.lstDocs.selectionModel().selectedRows(0)
selectedFilePathIndices = self.lstDocs.selectionModel().selectedRows(1)
if len(selectedDocNameIndices) == 0:
return None
docNameIndex = selectedDocNameIndices[0]
filePathIndex = selectedFilePathIndices[0]
return (docNameIndex, filePathIndex)
def documentMapping(self):
"""
Returns a tuple containing the selected document name and the corresponding file name.
"""
mIndices = self._selectedMappings()
if mIndices == None:
return None
docNameItem = self._docItemModel.itemFromIndex(mIndices[0])
filePathItem = self._docItemModel.itemFromIndex(mIndices[1])
return (docNameItem.text(), filePathItem.text())
def _editTemplate(self, templatePath, newName):
"""
Updates the template document to use the new name.
"""
templateFile = QFile(templatePath)
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Open Operation Error"), \
"{0}\n{1}".format(QApplication.translate("TemplateDocumentSelector","Cannot read template file."), \
templateFile.errorString()
))
return (False, "")
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
composerElement = templateDoc.documentElement()
titleAttr = composerElement.attributeNode("title")
if not titleAttr.isNull():
titleAttr.setValue(newName)
#Try remove file
status = templateFile.remove()
if not status:
return (False, "")
#Create new file
newTemplatePath = self._composerTemplatesPath(
) + "/" + newName + ".sdt"
newTemplateFile = QFile(newTemplatePath)
if not newTemplateFile.open(QIODevice.WriteOnly):
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Save Operation Error"), \
"{0}\n{1}".format(QApplication.translate("TemplateDocumentSelector","Could not save template file."), \
newTemplateFile.errorString()
))
return (False, "")
if newTemplateFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Save Error"), \
QApplication.translate("TemplateDocumentSelector","Could not save template file."))
return (False, "")
newTemplateFile.close()
return (True, newTemplatePath)
def _deleteDocument(self, templatePath):
"""
Delete the document template from the file system.
"""
docFile = QFile(templatePath)
return docFile.remove()
def _composerTemplatesPath(self):
"""
Reads the path of composer templates in the registry.
"""
regConfig = RegistryConfig()
keyName = "ComposerTemplates"
valueCollection = regConfig.read([keyName])
if len(valueCollection) == 0:
return None
else:
return valueCollection[keyName]
class dbmanagerUI(QMainWindow, ui_dbmanager.Ui_dbmanagerUI):
"""Main UI for MASAR database manager."""
def __init__(self):
""""""
super(dbmanagerUI, self).__init__()
self.setupUi(self)
self.statusbar.showMessage("Ready")
exitAction = QtGui.QAction(QtGui.QIcon('exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit Masar Configuration Manager.')
exitAction.triggered.connect(QtGui.qApp.quit)
self.groupdatabasemenubar()
#default database source, could be 0: SQLite, 1: MongoDB, and 2: MySQL
self.dbsource = None
self.defaultdbinfo = self._loadmasarconfig()
self.usedefaultdb = True
self.comboxboxSignalMapper = QtCore.QSignalMapper(self)
self.comboxboxSignalMapper.mapped[QtGui.QWidget].connect(
self.comboboxSignalMapperMapped)
self.pushbuttonSignalMapper = QtCore.QSignalMapper(self)
self.pushbuttonSignalMapper.mapped[QtGui.QWidget].connect(
self.pushbuttonSignalMapperMapped)
self.showpvbuttonSignalMapper = QtCore.QSignalMapper(self)
self.showpvbuttonSignalMapper.mapped[QtGui.QWidget].connect(
self.showpvbuttonSignalMapperMapped)
self.choosepvbuttonSignalMapper = QtCore.QSignalMapper(self)
self.choosepvbuttonSignalMapper.mapped[QtGui.QWidget].connect(
self.choosepvbuttonSignalMapperMapped)
self.currentselectedrow4config = -1
self.selectedsystem = "Others"
# self.pvgrouptreeview = QTreeView()
self.pvGroupTreeView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.pvgroupmodel = QStandardItemModel()
# self.pvgroupmodel.setHorizontalHeaderLabels(['id', 'date', 'version', "description"])
self.pvgroupmodel.setHorizontalHeaderLabels(["PV Groups"])
self.pvGroupTreeView.setModel(self.pvgroupmodel)
self.pvGroupTreeView.setUniformRowHeights(True)
@QtCore.pyqtSlot(QtGui.QWidget)
def comboboxSignalMapperMapped(self, comboBox):
if self.masarConfigTableWidget.cellWidget(
comboBox.row, comboBox.column + 1).isEnabled():
self.masarConfigTableWidget.cellWidget(
comboBox.row, comboBox.column + 1).setEnabled(False)
button = self.masarConfigTableWidget.cellWidget(
comboBox.row, comboBox.column + 1)
palette = QtGui.QPalette(
button.palette()) # make a copy of the palette
palette.setColor(QtGui.QPalette.ButtonText, QtGui.QColor('grey'))
button.setPalette(palette)
else:
self.masarConfigTableWidget.cellWidget(
comboBox.row, comboBox.column + 1).setEnabled(True)
button = self.masarConfigTableWidget.cellWidget(
comboBox.row, comboBox.column + 1)
palette = QtGui.QPalette(
button.palette()) # make a copy of the palette
palette.setColor(QtGui.QPalette.ButtonText, QtGui.QColor('red'))
button.setPalette(palette)
@QtCore.pyqtSlot(QtGui.QWidget)
def pushbuttonSignalMapperMapped(self, pushbutton):
configstatus = str(
self.masarConfigTableWidget.cellWidget(
pushbutton.row, pushbutton.column - 1).currentText())
cid = str(self.masarConfigTableWidget.item(pushbutton.row, 0).text())
cname = str(self.masarConfigTableWidget.item(pushbutton.row, 1).text())
if self.updatemasarconfigstatus(configstatus, cid, configname=cname):
palette = QtGui.QPalette(
pushbutton.palette()) # make a copy of the palette
palette.setColor(QtGui.QPalette.ButtonText, QtGui.QColor('grey'))
pushbutton.setPalette(palette)
pushbutton.setEnabled(False)
@QtCore.pyqtSlot(QtGui.QWidget)
def showpvbuttonSignalMapperMapped(self, showpvbutton):
if self.newConfigTableWidget.item(showpvbutton.row,
showpvbutton.column + 2) is None:
raise RuntimeError("Unknown pv file")
pvfilename = self.newConfigTableWidget.item(
showpvbutton.row, showpvbutton.column + 2).text()
if not os.path.isfile(pvfilename):
raise RuntimeError(
"Invalid pv file name for (row, col): (%s, %s)" %
(showpvbutton.row, showpvbutton.column + 2))
text = ", ".join(np.loadtxt(str(pvfilename), dtype=str, comments="#"))
if self.newConfigTableWidget.item(showpvbutton.row, 0) is not None:
head = self.newConfigTableWidget.item(showpvbutton.row, 0).text()
else:
head = ""
msg = QMessageBox(self,
windowTitle='PVs for group %s' % head,
text="The following PVs to be added:")
msg.setDetailedText(text)
msg.exec_()
@QtCore.pyqtSlot(QtGui.QWidget)
def choosepvbuttonSignalMapperMapped(self, chhosepvbutton):
self.newConfigTableWidget.setItem(
chhosepvbutton.row, chhosepvbutton.column + 1,
QTableWidgetItem(QFileDialog.getOpenFileName(self, "Open File")))
def _loadmasarconfig(self):
cf = ConfigParser.SafeConfigParser()
cf.read([
os.path.expanduser('~/.masarservice.conf'),
'/etc/masarservice.conf', 'masarservice.conf',
"%s/masarservice.conf" % os.path.abspath(os.path.dirname(__file__))
])
return cf
def groupdatabasemenubar(self):
"""Group 3 Databases menu together to make selection exclusive."""
group = QtGui.QActionGroup(self)
self.actionSQLite.setActionGroup(group)
self.actionMongoDB.setActionGroup(group)
self.actionMySQL.setActionGroup(group)
def actionsqlitemenu(self):
"""Answer action when SQLite is selected."""
if self.actionSQLite.isChecked():
self.dbsource = 0
self.defaultsqlitedb()
self.listPvGroupPushButton.setEnabled(True)
def actionmongodbmenu(self):
"""Answer action when MongoDB is selected."""
if self.actionMongoDB.isChecked():
self.dbsource = 1
self.defaultmongodb()
self.listPvGroupPushButton.setEnabled(False)
def actionmysqlmenu(self):
"""Answer action when MySQL is selected."""
if self.actionMySQL.isChecked():
QMessageBox.warning(self, 'Warning',
"MySQL support not implemented yet.")
self.actionMySQL.setChecked(False)
if self.dbsource == 0:
self.actionSQLite.setChecked(True)
elif self.dbsource == 1:
self.actionMongoDB.setChecked(True)
def showdefaultdbinfo(self):
""""""
if self.dbsource == 0:
self.defaultsqlitedb()
elif self.dbsource == 1:
self.defaultmongodb()
elif self.dbsource == 2:
QMessageBox.warning(self, 'Warning',
"MySQL support not implemented yet.")
def defaultsqlitedb(self):
""""""
if self.defaultdbinfo.has_section("sqlite"):
self.databaseDefault.setText(
self.defaultdbinfo.get("sqlite", "database"))
self.hostDefault.clear()
self.portDefault.clear()
self.userDefault.clear()
def defaultmongodb(self):
""""""
if self.defaultdbinfo.has_section("mongodb"):
self.databaseDefault.setText(
self.defaultdbinfo.get("mongodb", "database"))
self.hostDefault.setText(self.defaultdbinfo.get("mongodb", "host"))
self.portDefault.setText(self.defaultdbinfo.get("mongodb", "port"))
self.userDefault.setText(
self.defaultdbinfo.get("mongodb", "username"))
def getdatabasename(self):
""""""
self.database = self.databaseLineEdit.text()
def getdatabaseport(self):
""""""
self.databaseport = self.databaseportLineEdit.text()
def getdatabasehost(self):
""""""
self.databasehost = self.databaseHostLineEdit.text()
def getdatabasepw(self):
""""""
self.databasepw = self.databasePwLineEdit.text()
def showmasarconfigs(self):
""""""
result = None
if self.dbsource == 0:
# get data from sqlite
if self.usedefaultdb:
# masardb = str(self.databaseDefault.text())
masardb = str(self.databaseDefault.toPlainText())
else:
masardb = str(self.databaseLineEdit.text())
if masardb != "":
os.environ["MASAR_SQLITE_DB"] = masardb
else:
raise RuntimeError("Cannot find MASAR SQLite Database")
import pymasarsqlite
conn = pymasarsqlite.utils.connect()
result = pymasarsqlite.service.retrieveServiceConfigs(
conn, servicename="masar")
pymasarsqlite.utils.close(conn)
elif self.dbsource == 1:
# get data from mongodb
if self.usedefaultdb:
database = str(self.databaseDefault.toPlainText())
host = str(self.hostDefault.toPlainText())
port = str(self.portDefault.toPlainText())
else:
database = str(self.databaseLineEdit.text())
host = str(self.databaseHostLineEdit.text())
port = str(self.databasePortLineEdit.text())
import pymasarmongo
mongoconn, collection = pymasarmongo.db.utils.conn(host=host,
port=port,
db=database)
resultdict = pymasarmongo.pymasarmongo.pymasar.retrieveconfig(
mongoconn, collection)
pymasarmongo.db.utils.close(mongoconn)
result = [['id', 'name', 'desc', 'date', 'version', 'status']]
for res in resultdict:
result.append([
res['configidx'], res['name'], res['desc'],
res['created_on'], res['version'], res['status']
])
# res['system']
if result is not None:
self._setconfigtable(result)
def choosedbsrc(self, bool):
"""Choose DB source"""
if bool:
self.usedefaultdb = True
else:
self.usedefaultdb = False
def _setconfigtable(self, content):
""""""
# head = self.masarConfigTableWidget.horizontalHeader()
self.masarConfigTableWidget.clearContents()
# self.masarConfigTableWidget.setHorizontalHeaderLabels(head)
if len(content) > 1:
self.masarConfigTableWidget.setRowCount(len(content) - 1)
n = 0
data = sorted(content[1:], key=itemgetter(0), reverse=True)
for res in data:
m = 0
for item in res:
if not isinstance(item, basestring):
item = str(item)
if item:
if m == 5:
newitem = QtGui.QComboBox()
newitem.addItem("active")
newitem.addItem("inactive")
if item == "active":
newitem.setCurrentIndex(0)
else:
newitem.setCurrentIndex(1)
newitem.row = n
newitem.column = m
self.masarConfigTableWidget.setCellWidget(
n, m, newitem)
self.comboxboxSignalMapper.setMapping(
newitem, newitem)
newitem.currentIndexChanged.connect(
self.comboxboxSignalMapper.map)
updatebutton = QtGui.QPushButton()
updatebutton.setText("Update")
updatebutton.setEnabled(False)
updatebutton.row = n
updatebutton.column = m + 1
self.pushbuttonSignalMapper.setMapping(
updatebutton, updatebutton)
self.masarConfigTableWidget.setCellWidget(
n, m + 1, updatebutton)
updatebutton.clicked.connect(
self.pushbuttonSignalMapper.map)
else:
newitem = QTableWidgetItem(item)
newitem.setFlags(Qt.ItemIsEnabled
| Qt.ItemIsSelectable)
self.masarConfigTableWidget.setItem(n, m, newitem)
m += 1
n += 1
self.masarConfigTableWidget.resizeColumnsToContents()
def updatemasarconfigstatus(self, configstatus, cid, configname=None):
if self.dbsource == 0:
# get data from sqlite
if self.usedefaultdb:
masardb = str(self.databaseDefault.toPlainText())
else:
masardb = str(self.databaseLineEdit.text())
if masardb != "":
os.environ["MASAR_SQLITE_DB"] = masardb
else:
raise RuntimeError("Cannot find MASAR SQLite Database")
import pymasarsqlite
conn = pymasarsqlite.utils.connect()
pymasarsqlite.service.updateServiceConfigStatus(
conn, cid, status=configstatus)
pymasarsqlite.utils.save(conn)
pymasarsqlite.utils.close(conn)
elif self.dbsource == 1:
# get data from mongodb
if self.usedefaultdb:
database = str(self.databaseDefault.toPlainText())
host = str(self.hostDefault.toPlainText())
port = str(self.portDefault.toPlainText())
else:
database = str(self.databaseLineEdit.text())
host = str(self.databaseHostLineEdit.text())
port = str(self.databasePortLineEdit.text())
import pymasarmongo
mongoconn, collection = pymasarmongo.db.utils.conn(host=host,
port=port,
db=database)
pymasarmongo.pymasarmongo.pymasar.updateconfig(mongoconn,
collection,
configname,
configidx=int(cid),
status=configstatus)
pymasarmongo.db.utils.close(mongoconn)
return True
def addnewpvgrouprow(self):
"""Add a new row to add pv group to MASAR configuration"""
print("""Add a new row to add pv group to MASAR configuration""")
currowcount = self.newConfigTableWidget.rowCount()
self.newConfigTableWidget.setRowCount(currowcount + 1)
showpvbutton = QtGui.QPushButton()
showpvbutton.setText("Show PVs")
showpvbutton.setEnabled(True)
showpvbutton.row = currowcount
showpvbutton.column = 2
self.showpvbuttonSignalMapper.setMapping(showpvbutton, showpvbutton)
self.newConfigTableWidget.setCellWidget(currowcount,
showpvbutton.column,
showpvbutton)
showpvbutton.clicked.connect(self.showpvbuttonSignalMapper.map)
choosepvbutton = QtGui.QPushButton()
choosepvbutton.setText("PV File")
choosepvbutton.setEnabled(True)
choosepvbutton.row = currowcount
choosepvbutton.column = 3
self.choosepvbuttonSignalMapper.setMapping(choosepvbutton,
choosepvbutton)
self.newConfigTableWidget.setCellWidget(currowcount,
choosepvbutton.column,
choosepvbutton)
choosepvbutton.clicked.connect(self.choosepvbuttonSignalMapper.map)
def removepvgrouprow(self):
"""Remove selected pv group from the configuration to be added into MASAR database"""
if self.currentselectedrow4config == -1:
raise RuntimeError("No pv group selected.")
rownametobedelete = self.newConfigTableWidget.item(
self.currentselectedrow4config, 0)
if rownametobedelete is not None:
rownametobedelete = rownametobedelete.text()
self.newConfigTableWidget.removeRow(self.currentselectedrow4config)
if rownametobedelete is not None:
print("Successfully delete pv group: ", rownametobedelete)
else:
print("Successfully delete row: ", self.currentselectedrow4config)
self.currentselectedrow4config = -1
def savemasarsqlite(self):
""""""
# get data from sqlite
if self.usedefaultdb:
masardb = str(self.databaseDefault.toPlainText())
else:
masardb = str(self.databaseLineEdit.text())
if masardb != "":
os.environ["MASAR_SQLITE_DB"] = masardb
else:
QMessageBox.warning(self, "Warning",
"Cannot find MASAR SQLite Database")
return
import pymasarsqlite
conn = pymasarsqlite.utils.connect()
existedresult = pymasarsqlite.service.retrieveServiceConfigs(
conn, servicename="masar")
newcfgdata = self._getnewconfigurationdata(existedresult)
if newcfgdata is None:
QMessageBox.warning(
self, "Warning",
"Not enough information for a new configuration.")
return
newcfgname = newcfgdata[0]
desc = newcfgdata[1]
msystem = newcfgdata[2]
# config data format: [[name], [desc], [pv files]]
cfgdata = newcfgdata[3]
if newcfgname is None or msystem is None or newcfgdata is None:
# Nothing to be added.
QMessageBox.warning(
self, "Warning",
"No name or system is given, or empty configuration data.")
return
for i in range(len(cfgdata[0])):
if cfgdata[0][i] is None:
QMessageBox.warning(self, "Warning", "Wrong PV group name")
return
if cfgdata[2][i] is not None and os.path.isfile(cfgdata[2][i]):
pvs = list(np.loadtxt(cfgdata[2][i], dtype=str, comments="#"))
if len(pvs) > 0:
for j, pv in enumerate(pvs):
pvs[j] = pv.strip()
pymasarsqlite.pvgroup.savePvGroup(conn,
cfgdata[0][i],
func=cfgdata[1][i])
pymasarsqlite.pvgroup.saveGroupPvs(conn, cfgdata[0][i],
pvs)
try:
pymasarsqlite.service.saveServiceConfig(conn,
"masar",
newcfgname,
configdesc=desc,
system=msystem)
pymasarsqlite.service.saveServicePvGroup(conn, newcfgname,
cfgdata[0])
except Exception as e:
QMessageBox.warning(self, "Error", e.message)
return
pymasarsqlite.utils.save(conn)
QMessageBox.information(
self, "Congratulation",
"A new configuration has been added successfully.")
pymasarsqlite.utils.close(conn)
def savemasarmongodb(self):
""""""
# get data from mongodb
if self.usedefaultdb:
database = str(self.databaseDefault.toPlainText())
host = str(self.hostDefault.toPlainText())
port = str(self.portDefault.toPlainText())
else:
database = str(self.databaseLineEdit.text())
host = str(self.databaseHostLineEdit.text())
port = str(self.databasePortLineEdit.text())
import pymasarmongo
mongoconn, collection = pymasarmongo.db.utils.conn(host=host,
port=port,
db=database)
existedresult = pymasarmongo.pymasarmongo.pymasar.retrieveconfig(
mongoconn, collection)
existedcfg = []
for res in existedresult:
existedcfg.append([
res['configidx'], res['name'], res['desc'], res['created_on'],
res['version'], res['status']
])
newcfgdata = self._getnewconfigurationdata(existedcfg)
if newcfgdata is None:
# Nothing to be added.
raise ValueError("Empty configuration.")
newcfgname = newcfgdata[0]
desc = newcfgdata[1]
msystem = newcfgdata[2]
# config data format: [[name], [desc], [pv files]]
cfgdata = newcfgdata[3]
pvs = []
for pvf in cfgdata[2]:
if pvf is not None and os.path.isfile(pvf):
pvs += list(np.loadtxt(pvf, dtype=str, comments="#"))
if pvs:
for i, pv in enumerate(pvs):
pvs[i] = pv.strip()
pymasarmongo.pymasarmongo.pymasar.saveconfig(mongoconn,
collection,
newcfgname,
desc=desc,
system=msystem,
pvlist={"names": pvs})
QMessageBox.information(
self, "Congratulation",
"A new configuration has been added successfully.")
else:
QMessageBox.warning(self, "Warning",
"No PVs available for the new configuration.")
pymasarmongo.db.utils.close(mongoconn)
def submitmasarconfig(self):
"""submit a new configuration to MASAR database"""
if self.dbsource is None:
QMessageBox.warning(
self, "Warning",
"Unknown database source.\nPlease select which database should be use."
)
return
if self.dbsource == 0:
self.savemasarsqlite()
elif self.dbsource == 1:
self.savemasarmongodb()
def _getnewconfigurationdata(self, existedresult):
""""""
newcfgname = self.newConfigurationLineEdit.text()
if newcfgname is None or str(newcfgname) == "":
QMessageBox.warning(self, "Warning",
"Name of configuration is empty.")
return None
elif str(newcfgname) in np.array(existedresult)[:, 1]:
QMessageBox.warning(
self, "Warning",
"Configuration (%s) exists already." % str(newcfgname))
return None
else:
newcfgname = str(newcfgname)
desc = self.newConfigurationDescription.text()
if str(desc) == "":
desc = None
else:
desc = str(desc)
msystem = str(self.systemComboBox.currentText())
if msystem == "Others":
msystem = self.systemLineEdit.text()
if msystem is None or str(msystem) == "":
QMessageBox.warning(
self, "Warning",
"System for configuration (%s) not specified yet." %
str(newcfgname))
return None
else:
msystem = str(msystem)
pvgroups = self.newConfigTableWidget.rowCount()
if pvgroups == 0:
QMessageBox.warning(
self, "Warning",
"No PV founded for new configuration (%s)." % str(newcfgname))
return None
pvgroupnames = []
pvgroupdescs = []
pvgroupfiles = []
for count in range(pvgroups):
# Collect PV group name information
if self.newConfigTableWidget.item(count, 0) is not None and str(
self.newConfigTableWidget.item(count, 0).text()) != "":
pvgname = str(self.newConfigTableWidget.item(count, 0).text())
if pvgname in pvgroupnames:
QMessageBox.warning(
self, "Warning",
"Duplicated pv group name: %s." % str(pvgname))
return None
pvgroupnames.append(pvgname)
elif self.newConfigTableWidget.item(count, 4) is None or str(
self.newConfigTableWidget.item(count, 4)) == "":
continue
elif self.dbsource == 1:
pvgroupnames.append(None)
else:
QMessageBox.warning(self, "Warning", "Empty pv group name.")
return None
# reply = QMessageBox.question(self, "Message",
# "pv group name not specified for row {}.\nContinue?".format(count),
# QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
# if reply == QMessageBox.Yes:
# pvgroupnames.append(None)
# else:
# return None
# Collection PV group descriptions
if self.newConfigTableWidget.item(count, 1) is not None:
pvgroupdescs.append(
str(self.newConfigTableWidget.item(count, 1).text()))
else:
pvgroupdescs.append(None)
# PV files for the pv group.
if self.newConfigTableWidget.item(count, 4) is not None:
pvgroupfiles.append(
str(self.newConfigTableWidget.item(count, 4).text()))
else:
pvgroupfiles.append(None)
if pvgroupfiles:
return newcfgname, desc, msystem, [
pvgroupnames, pvgroupdescs, pvgroupfiles
]
else:
return None
def currentselectedrow(self, row, col):
"""Cache current selected row in MASAR configuration Table Widget."""
self.currentselectedrow4config = row
def updateselectedsystem(self, system):
"""Update selected system if value changed"""
self.selectedsystem = str(system)
def updatesystemcombobox(self):
"""Update selected system if value changed"""
self.systemComboBox.clear()
if self.dbsource == 0:
# get data from sqlite
if self.usedefaultdb:
# masardb = str(self.databaseDefault.text())
masardb = str(self.databaseDefault.toPlainText())
else:
masardb = str(self.databaseLineEdit.text())
if masardb != "":
os.environ["MASAR_SQLITE_DB"] = masardb
else:
raise RuntimeError("Cannot find MASAR SQLite Database")
import pymasarsqlite
conn = pymasarsqlite.utils.connect()
result = pymasarsqlite.service.retrieveServiceConfigProps(
conn, propname="system", servicename="masar")
index = 0
if len(result) > 1:
res = sorted(set(list(np.array(result[1:])[:, 3])))
#for res in result[1:]:
self.systemComboBox.addItems(res)
index = len(res)
self.systemComboBox.addItem("Others")
self.systemComboBox.setCurrentIndex(index)
pymasarsqlite.utils.close(conn)
elif self.dbsource == 1:
# get data from mongodb
if self.usedefaultdb:
database = str(self.databaseDefault.toPlainText())
host = str(self.hostDefault.toPlainText())
port = str(self.portDefault.toPlainText())
else:
database = str(self.databaseLineEdit.text())
host = str(self.databaseHostLineEdit.text())
port = str(self.databasePortLineEdit.text())
import pymasarmongo
mongoconn, collection = pymasarmongo.db.utils.conn(host=host,
port=port,
db=database)
result = pymasarmongo.pymasarmongo.pymasar.retrieveconfig(
mongoconn, collection)
pymasarmongo.db.utils.close(mongoconn)
results = []
for res in result:
if res["system"] not in results:
results.append(res["system"])
res = sorted(set(results))
self.systemComboBox.addItems(res)
index = len(res)
self.systemComboBox.addItem("Others")
self.systemComboBox.setCurrentIndex(index)
def listpvgroups(self):
""""""
self.pvgroupmodel.clear()
self.pvgroupmodel.setHorizontalHeaderLabels(["PV Groups"])
if self.dbsource == 0:
# get data from sqlite
if self.usedefaultdb:
# masardb = str(self.databaseDefault.text())
masardb = str(self.databaseDefault.toPlainText())
else:
masardb = str(self.databaseLineEdit.text())
if masardb != "":
os.environ["MASAR_SQLITE_DB"] = masardb
else:
raise RuntimeError("Cannot find MASAR SQLite Database")
import pymasarsqlite
conn = pymasarsqlite.utils.connect()
result = pymasarsqlite.pvgroup.retrievePvGroups(conn)
if len(result) > 0:
result = sorted(result, key=itemgetter(0), reverse=True)
for res in result:
parent1 = QStandardItem(res[1])
child1 = QStandardItem('id: {}'.format(res[0]))
child2 = QStandardItem('description: {}'.format(res[2]))
child3 = QStandardItem('date: {}'.format(res[3]))
child4 = QStandardItem('version: {}'.format(res[4]))
parent1.appendColumn([child1, child2, child3, child4])
self.pvgroupmodel.appendRow(parent1)
selmod = self.pvGroupTreeView.selectionModel()
index2 = self.pvgroupmodel.indexFromItem(child3)
selmod.select(
index2, QItemSelectionModel.Select | QItemSelectionModel.Rows)
pymasarsqlite.utils.close(conn)
self.pvGroupTreeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.pvGroupTreeView.clicked.connect(self.showpvsinpvgroup)
# self.connect(self.pvGroupTreeView,
# QtCore.SIGNAL("clicked(QModelIndex)"),
# #QtCore.SIGNAL("customContextMenuRequested(const QPoint &)"),
# self.doMenu)
elif self.dbsource == 1:
# get data from mongodb
if self.usedefaultdb:
database = str(self.databaseDefault.toPlainText())
host = str(self.hostDefault.toPlainText())
port = str(self.portDefault.toPlainText())
else:
database = str(self.databaseLineEdit.text())
host = str(self.databaseHostLineEdit.text())
port = str(self.databasePortLineEdit.text())
import pymasarmongo
def showpvsinpvgroup(self, point):
if point.model().itemFromIndex(point).child(0) is None:
return
reply = QMessageBox.question(
self, 'Message', "show all pvs belong to group {} ?".format(
point.model().itemFromIndex(point).text()),
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
pvgroupidx = int(
str(point.model().itemFromIndex(point).child(0).text().split(
":")[1]).strip())
# msg = QMessageBox(self)
msg = ShowPvMessageBox()
msg.setWindowTitle('PVs for group {}'.format(
point.model().itemFromIndex(point).text()))
msg.setText("Click show details to see all pvs.")
# windowTitle = 'PVs for group {}'.format(point.model().itemFromIndex(point).text())
if self.dbsource == 0:
# get data from sqlite
if self.usedefaultdb:
# masardb = str(self.databaseDefault.text())
masardb = str(self.databaseDefault.toPlainText())
else:
masardb = str(self.databaseLineEdit.text())
if masardb != "":
os.environ["MASAR_SQLITE_DB"] = masardb
else:
raise RuntimeError("Cannot find MASAR SQLite Database")
import pymasarsqlite
conn = pymasarsqlite.utils.connect()
result = pymasarsqlite.pvgroup.retrieveGroupPvs(
conn, pvgroupidx)
text = "\n".join(list(np.array(result)[:, 0]))
msg.setDetailedText(text)
msg.exec_()
elif self.dbsource == 1:
# get data from mongodb
if self.usedefaultdb:
database = str(self.databaseDefault.toPlainText())
host = str(self.hostDefault.toPlainText())
port = str(self.portDefault.toPlainText())
else:
database = str(self.databaseLineEdit.text())
host = str(self.databaseHostLineEdit.text())
port = str(self.databasePortLineEdit.text())
import pymasarmongo
def get_gds_model(progress=lambda val: None):
"""
Initialize and return a GDS datasets model.
:param progress: A progress callback.
:rval tuple:
A tuple of (QStandardItemModel, geo.GDSInfo, [geo.GDS])
.. note::
The returned QStandardItemModel's thread affinity is set to
the GUI thread.
"""
progress(1)
info = geo.GDSInfo()
search_keys = ["dataset_id", "title", "platform_organism", "description"]
cache_dir = serverfiles.localpath(geo.DOMAIN)
gds_link = "http://www.ncbi.nlm.nih.gov/sites/GDSbrowser?acc={0}"
pm_link = "http://www.ncbi.nlm.nih.gov/pubmed/{0}"
gds_list = []
def is_cached(gds):
return os.path.exists(
os.path.join(cache_dir, gds["dataset_id"]) + ".soft.gz")
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 gds_to_row(gds):
#: Text for easier full search.
search_text = " | ".join(
[gds.get(key, "").lower() for key in search_keys])
row = [
item(" " if is_cached(gds) else "", {TextFilterRole: search_text}),
item(gds["dataset_id"],
{LinkRole: gds_link.format(gds["dataset_id"])}),
item(gds["title"]),
item(gds["platform_organism"]),
item(len(gds["samples"])),
item(gds["feature_count"]),
item(gds["gene_count"]),
item(len(gds["subsets"])),
item(
gds.get("pubmed_id", ""), {
LinkRole:
pm_link.format(gds["pubmed_id"])
if gds.get("pubmed_id") else None
})
]
return row
model = QStandardItemModel()
model.setHorizontalHeaderLabels([
"", "ID", "Title", "Organism", "Samples", "Features", "Genes",
"Subsets", "PubMedID"
])
progress(20)
for gds in info.values():
model.appendRow(gds_to_row(gds))
gds_list.append(gds)
progress(50)
if QThread.currentThread() is not QCoreApplication.instance().thread():
model.moveToThread(QCoreApplication.instance().thread())
return model, info, gds_list
class ListWidget(EditorWidget):
widgettype = 'List'
def __init__(self, *args, **kwargs):
super(ListWidget, self).__init__(*args)
self.listmodel = QStandardItemModel()
self._bindvalue = None
def createWidget(self, parent):
return QComboBox(parent)
def _buildfromlist(self, widget, listconfig):
items = listconfig['items']
for item in items:
parts = item.split(';')
data = parts[0]
try:
desc = parts[1]
except IndexError:
desc = data
try:
path = parts[2]
path = path.strip()
icon = QIcon(path)
except:
icon = QIcon()
item = QStandardItem(desc)
item.setData(data, Qt.UserRole)
item.setIcon(icon)
self.listmodel.appendRow(item)
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)
attributes = {keyfieldindex, valuefieldindex}
iconfieldindex = layer.fieldNameIndex('icon')
if iconfieldindex > -1:
attributes.add(iconfieldindex)
if not filterexp and valuefieldindex == keyfieldindex and iconfieldindex == -1:
values = layer.uniqueValues(keyfieldindex)
for value in values:
value = nullconvert(value)
item = QStandardItem(value)
item.setData(value, Qt.UserRole)
self.listmodel.appendRow(item)
return
flags = QgsFeatureRequest.NoGeometry
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 initWidget(self, widget, config):
if widget.isEditable():
widget.editTextChanged.connect(self.emitvaluechanged)
widget.currentIndexChanged.connect(self.emitvaluechanged)
widget.setModel(self.listmodel)
widget.showPopup = self.showpopup
widget.setIconSize(QSize(24, 24))
widget.setStyleSheet(
"QComboBox::drop-down {border-width: 0px;} QComboBox::down-arrow {image: url(noimg); border-width: 0px;}"
)
widget.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
def showpopup(self):
if self.listmodel.rowCount() == 0:
return
self.largewidgetrequest.emit(
BigListWidget, self.widget.currentIndex(), self._biglistitem,
dict(model=self.listmodel, label=self.labeltext))
def updatefromconfig(self):
super(ListWidget, self).updatefromconfig()
self.listmodel.clear()
if 'list' in self.config:
listconfig = self.config['list']
self._buildfromlist(self.widget, listconfig)
elif 'layer' in self.config:
layerconfig = self.config['layer']
self._buildfromlayer(self.widget, layerconfig)
super(ListWidget, self).endupdatefromconfig()
@property
def allownulls(self):
return self.config.get('allownull', False)
def validate(self, *args):
if (not self.widget.currentText() == ''
and not self.widget.currentText() == "(no selection)"):
return True
else:
return False
def _biglistitem(self, index):
self.widget.setCurrentIndex(index.row())
def setvalue(self, value):
self._bindvalue = value
index = self.widget.findData(value)
self.widget.setCurrentIndex(index)
if index == -1 and self.widget.isEditable():
if value is None and not self.config['allownull']:
return
self.widget.addItem(str(value))
index = self.widget.count() - 1
self.widget.setCurrentIndex(index)
def value(self):
index = self.widget.currentIndex()
value = self.widget.itemData(index)
text = self.widget.currentText()
if value is None and self.widget.isEditable(
) and not text == '(no selection)':
return self.widget.currentText()
return value
class MultipleSelectTreeView(QListView):
"""
Custom QListView implementation that displays checkable items from a
multiple select column type.
"""
def __init__(self, column, parent=None):
"""
Class constructor.
:param column: Multiple select column object.
:type column: MultipleSelectColumn
:param parent: Parent widget for the control.
:type parent: QWidget
"""
QListView.__init__(self, parent)
#Disable editing of lookup values
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.column = column
self._item_model = QStandardItemModel(self)
self._value_list = self.column.value_list
#Stores lookup objects based on primary keys
self._lookup_cache = {}
self._initialize()
self._association = self.column.association
self._first_parent_col = self._association.first_reference_column.name
self._second_parent_col = self._association.second_reference_column.name
#Association model
self._assoc_cls = entity_model(self._association)
def reset_model(self):
"""
Resets the item model.
"""
self._item_model.clear()
self._item_model.setColumnCount(2)
def clear(self):
"""
Clears all items in the model.
"""
self._item_model.clear()
@property
def association(self):
"""
:return: Returns the association object corresponding to the column.
:rtype: AssociationEntity
"""
return self._association
@property
def value_list(self):
"""
:return: Returns the ValueList object corresponding to the configured
column object.
:rtype: ValueList
"""
return self._value_list
@property
def item_model(self):
"""
:return: Returns the model corresponding to the checkable items.
:rtype: QStandardItemModel
"""
return self._item_model
def _add_item(self, id, value):
"""
Adds a row corresponding to id and corresponding value from a lookup
table.
:param id: Primary key of a lookup record.
:type id: int
:param value: Lookup value
:type value: str
"""
value_item = QStandardItem(value)
value_item.setCheckable(True)
id_item = QStandardItem(str(id))
self._item_model.appendRow([value_item, id_item])
def _initialize(self):
#Populate list with lookup items
self.reset_model()
#Add all lookup values in the value list table
vl_cls = entity_model(self._value_list)
if not vl_cls is None:
vl_obj = vl_cls()
res = vl_obj.queryObject().all()
for r in res:
self._lookup_cache[r.id] = r
self._add_item(r.id, r.value)
self.setModel(self._item_model)
def clear_selection(self):
"""
Unchecks all items in the view.
"""
for i in range(self._item_model.rowCount()):
value_item = self._item_model.item(i, 0)
if value_item.checkState() == Qt.Checked:
value_item.setCheckState(Qt.Unchecked)
if value_item.rowCount() > 0:
value_item.removeRow(0)
def selection(self):
"""
:return: Returns a list of selected items.
:rtype: list
"""
selection = []
for i in range(self._item_model.rowCount()):
value_item = self._item_model.item(i, 0)
if value_item.checkState() == Qt.Checked:
id_item = self._item_model.item(i, 1)
id = int(id_item.text())
#Get item from the lookup cache and append to selection
if id in self._lookup_cache:
lookup_rec = self._lookup_cache[id]
selection.append(lookup_rec)
return selection
def set_selection(self, models):
"""
Checks items corresponding to the specified models.
:param models: List containing model values in the view for selection.
:type models: list
"""
for m in models:
search_value = m.value
v_items = self._item_model.findItems(search_value)
#Loop through result and check items
for vi in v_items:
if vi.checkState() == Qt.Unchecked:
vi.setCheckState(Qt.Checked)
class GroupPhotoWindow(QMainWindow, Ui_main_win):
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.image_model = QStandardItemModel()
self.image_list.setModel(self.image_model)
QObject.connect(self.add_btn, QtCore.SIGNAL('clicked()'),
self.on_add_image)
QObject.connect(self.delete_btn, QtCore.SIGNAL('clicked()'),
self.on_remove_image)
QObject.connect(
self.image_list.selectionModel(),
QtCore.SIGNAL(
'currentChanged (const QModelIndex &, const QModelIndex &)'),
self.on_row_changed)
QObject.connect(self.harris_btn, QtCore.SIGNAL('clicked()'),
self.on_harris_detect)
QObject.connect(self.stitch_btn, QtCore.SIGNAL('clicked()'),
self.on_stitch)
def on_add_image(self):
image_path = QFileDialog.getOpenFileName(
self, 'Select image', filter='Images (*.png *.jpg *.bmp)')
ignored, name = os.path.split(unicode(image_path))
self.image_model.appendRow(
[QStandardItem(name),
QStandardItem(image_path)])
def on_remove_image(self):
row = self.image_list.selectionModel().currentIndex().row()
if row == -1:
return
self.image_model.removeRows(row, 1)
def on_row_changed(self, current, previous):
row = current.row()
if row == -1:
file_path = PLACE_HOLDER
else:
file_path = self.image_model.item(row, 1).text()
self.set_pixmap(QPixmap(file_path))
def on_harris_detect(self):
row = self.image_list.selectionModel().currentIndex().row()
if row == -1:
return
file_path = self.image_model.item(row, 1).text()
image_pfm = convert_to_pfm(imread(unicode(file_path)))
image = image_to_gray(image_pfm)
kernel = self.ksize_slider.value()
cornerness = harris_corner(image, ksize=kernel)
is_corner = cornerness > 0.000001
suppress = non_max_suppression(cornerness, ksize=kernel)
result = np.array(is_corner * suppress)
zero = np.zeros_like(result)
gray_img = np.dstack((zero, zero, draw_cross(result)))
self.set_pixmap(
QPixmap.fromImage(
image_from_ndarray(np.array(gray_img + image_pfm))))
def on_stitch(self):
i = 0
images = []
while self.image_model.item(i):
file_path = self.image_model.item(i, 1).text()
image = image_to_gray(convert_to_pfm(imread(unicode(file_path))))
images.append(image)
i += 1
stitch(self.ksize_slider.value(), images)
def set_pixmap(self, pixmap):
self.image_label.setPixmap(
pixmap.scaled(self.image_label.size(), QtCore.Qt.KeepAspectRatio))
class TreeView(QTreeView):
def __init__(self, parent):
QTreeView.__init__(self, parent)
while not isinstance(parent, QDialog) and not isinstance(parent, QMainWindow):
parent = parent.parent()
self.setObjectName("TreeView" + str(len(parent.findChildren(TreeView))))
# self.setObjectName("TreeViewWidget")
# self.hLayout = QHBoxLayout(self)
# self.hLayout.setObjectName("hLayout")
#
# sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
# sizePolicy.setHorizontalStretch(0)
# sizePolicy.setVerticalStretch(0)
# sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
# self.setSizePolicy(sizePolicy)
#
# # self.frame = Frame()
# self = QTreeView(self)
# self.hLayout.addWidget(self)
self.stdModel = QStandardItemModel()
self.setModel(self.stdModel)
self.hasObject = False
self.treeNodeList = []
self.checkBoxList = []
self.setHeaderHidden(True)
# self.stdModel.appendRow(TreeNode("P"))
# rootIndex = self.rootIndex()
# rootItem = self.stdModel.itemFromIndex(rootIndex)
# rootItem.setText("Root")
def mouseMoveEvent(self, mouseEvent):
pt = mouseEvent.pos()
pass
def Clear(self):
self.stdModel.clear()
self.hasObject = False
self.treeNodeList = []
def Add(self, caption):
item = TreeNode(caption)
if len(self.treeNodeList) > 0:
item.PrevNode = self.treeNodeList[len(self.treeNodeList) - 1]
item.PrevNode.NextNode = item
item.Index = len(self.treeNodeList)
# item.nodeIndex = len(self.treeNodeList)
self.treeNodeList.append(item)
self.stdModel.appendRow(item)
return item
def RemoveNode(self, i):
self.stdModel.removeRow(i)
self.treeNodeList.pop(i)
for j in range(i, len(self.treeNodeList)):
self.treeNodeList[j].nodeIndex -= 1
def Remove(self, item):
removedIndex = self.treeNodeList.index(item)
if removedIndex == 0:
self.treeNodeList[1].PrevNode = None
elif removedIndex == len(self.treeNodeList) - 1:
self.treeNodeList[len(self.treeNodeList) - 2].NextNode = None
else:
self.treeNodeList[removedIndex + 1].PrevNode = self.treeNodeList[removedIndex - 1]
self.treeNodeList[removedIndex - 1].NextNode = self.treeNodeList[removedIndex + 1]
self.treeNodeList.pop(removedIndex)
self.stdModel.removeRow(removedIndex)
i = 0
for node in self.treeNodeList:
node.Index = i
node.LastNode = self.treeNodeList[len(self.treeNodeList) - 1]
i += 1
def Insert(self, index, text):
if index == 0 and len(self.treeNodeList) == 0:
self.Add(text)
return
node = TreeNode(text)
node.Parent = self
self.treeNodeList.insert(index, node)
i = 0
for node0 in self.treeNodeList:
node0.Index = i
i += 1
if index == 0:
self.treeNodeList[index].PrevNode = None
if len(self.treeNodeList) == 1:
self.treeNodeList[index].NextNode = None
self.treeNodeList[index].LastNode = self.treeNodeList[index]
else:
self.treeNodeList[index].NextNode = self.treeNodeList[index + 1]
self.treeNodeList[index].LastNode = self.treeNodeList[len(self.treeNodeList) - 1]
self.treeNodeList[index + 1].PrevNode = self.treeNodeList[index]
else:
self.treeNodeList[index].PrevNode = self.treeNodeList[index - 1]
self.treeNodeList[index].NextNode = self.treeNodeList[index + 1]
self.treeNodeList[index].LastNode = self.treeNodeList[len(self.treeNodeList) - 1]
self.treeNodeList[index + 1].PrevNode = self.treeNodeList[index]
self.treeNodeList[index - 1].NextNode = self.treeNodeList[index]
self.stdModel.insertRow(index, node)
return node
def get_Items(self):
return self.treeNodeList
Nodes = property(get_Items, None, None, None)
def Node(self, index):
if not self.stdModel.rowCount() > 0:
return None
return self.treeNodeList[index]
def getSelectedNode(self):
if not self.stdModel.rowCount() > 0:
return None
index = self.currentIndex()
return self.stdModel.itemFromIndex(index)
def setSelectedNode(self, node):
if not self.stdModel.rowCount() > 0:
return
# self.s
index = self.stdModel.indexFromItem(node)
self.setCurrentIndex(index)
# self.treeNodeList.pop(index)
# self.treeNodeList.insert(index, node)
# self.stdModel.setItem(index, node)
SelectedNode = property(getSelectedNode, setSelectedNode, None, None)
def get_Enabled(self):
return self.isEnabled()
def set_Enabled(self, bool):
self.setEnabled(bool)
Enabled = property(get_Enabled, set_Enabled, None, None)
def get_Visible(self):
return self.isVisible()
def set_Visible(self, bool):
self.setVisible(bool)
Visible = property(get_Visible, set_Visible, None, None)
class ObstacleTable(QSortFilterProxyModel):
MocMultiplier = 1
SelectionMode = SelectionModeType.Automatic
def __init__(self, surfacesList, fileWriter=None):
QSortFilterProxyModel.__init__(self)
ObstacleTable.SelectionMode = SelectionModeType.Automatic
self.manualPolygon = None
self.surfacesList = surfacesList
self.surfaceType = None
self.source = QStandardItemModel()
self.setSourceModel(self.source)
# tableView.hideColumn(self.IndexObjectId)
# tableView.hideColumn(self.IndexLayerId)
# tableView.hideColumn(self.IndexX)
# tableView.hideColumn(self.IndexY)
# tableView.hideColumn(self.IndexLat)
# tableView.hideColumn(self.IndexLon)
# tableView.hideColumn(self.IndexSurface)
self.hideColumnLabels = [
ObstacleTableColumnType.ObjectId, ObstacleTableColumnType.LayerId,
ObstacleTableColumnType.X, ObstacleTableColumnType.Y,
ObstacleTableColumnType.Lat, ObstacleTableColumnType.Lon,
ObstacleTableColumnType.Surface
]
self.fixedColumnLabels = [
ObstacleTableColumnType.ObjectId, ObstacleTableColumnType.LayerId,
ObstacleTableColumnType.Name, ObstacleTableColumnType.X,
ObstacleTableColumnType.Y, ObstacleTableColumnType.Lat,
ObstacleTableColumnType.Lon, ObstacleTableColumnType.AltM,
ObstacleTableColumnType.AltFt, ObstacleTableColumnType.TreesM,
ObstacleTableColumnType.TreesFt
]
self.IndexObjectId = 0
self.IndexLayerId = 1
self.IndexName = 2
self.IndexX = 3
self.IndexY = 4
self.IndexLat = 5
self.IndexLon = 6
self.IndexAltM = 7
self.IndexAltFt = 8
self.IndexTreesM = 9
self.IndexTreesFt = 10
self.IndexOcaM = -1
self.IndexOcaFt = -1
self.IndexOchM = -1
self.IndexOchFt = -1
self.IndexObstArea = -1
self.IndexDistInSecM = -1
self.IndexMocAppliedM = -1
self.IndexMocAppliedFt = -1
self.IndexMocMultiplier = -1
self.IndexMocReqM = -1
self.IndexMocReqFt = -1
self.IndexDoM = -1
self.IndexDrM = -1
self.IndexDzM = -1
self.IndexDxM = -1
self.IndexDsocM = -1
self.IndexHeightLossM = -1
self.IndexHeightLossFt = -1
self.IndexAcAltM = -1
self.IndexAcAltFt = -1
self.IndexAltReqM = -1
self.IndexAltReqFt = -1
self.IndexCritical = -1
self.IndexMACG = -1
self.IndexPDG = -1
self.IndexSurfAltM = -1
self.IndexSurfAltFt = -1
self.IndexDifferenceM = -1
self.IndexDifferenceFt = -1
self.IndexIlsX = -1
self.IndexIlsY = -1
self.IndexEqAltM = -1
self.IndexEqAltFt = -1
self.IndexSurfaceName = -1
self.IndexDisregardable = -1
self.IndexCloseIn = -1
self.IndexTag = -1
self.IndexSurface = -1
self.IndexArea = -1
self.IndexHLAppliedM = -1
self.setHeaderLabels()
self.setFilterKeyColumn(self.IndexSurface)
self.setSortRole(Qt.UserRole + 1)
self.layoutChanged.connect(self.setVerticalHeader)
self.btnLocate = None
self.tblObstacles = None
def FilterDisregardableObstacles(self, state):
if state:
self.setFilterKeyColumn(self.IndexDisregardable)
self.setFilterFixedString("Yes")
self.setFilterKeyColumn(self.IndexSurface)
def setSurfaceType(self, surfaceType):
self.surfaceType = surfaceType
def setFilterFixedString(self, filterString):
QSortFilterProxyModel.setFilterFixedString(self, filterString)
self.setVerticalHeader()
if self.btnLocate != None and self.tblObstacles != None:
selectedIndexes = self.tblObstacles.selectedIndexes()
if len(selectedIndexes) == 0:
self.btnLocate.setEnabled(False)
else:
self.btnLocate.setEnabled(True)
def setLocateBtn(self, btnLocate):
self.btnLocate = btnLocate
self.btnLocate.setEnabled(False)
self.btnLocate.clicked.connect(self.btnLocateClicked)
def btnLocateClicked(self):
if self.tblObstacles == None:
return
selectedIndexes = self.tblObstacles.selectedIndexes()
self.locate(selectedIndexes)
def tblObstaclesClicked(self, idx):
if len(self.tblObstacles.selectedIndexes()) > 0:
self.btnLocate.setEnabled(True)
def setTableView(self, tblObstacles):
self.tblObstacles = tblObstacles
self.tblObstacles.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tblObstacles.setSortingEnabled(True)
self.tblObstacles.clicked.connect(self.tblObstaclesClicked)
self.tblObstacles.verticalHeader().sectionClicked.connect(
self.tblObstaclesClicked)
pass
def setHeaderLabels(self):
# print self.setHeaderData(1, Qt.Vertical, 1, Qt.DisplayRole)
pass
def setVerticalHeader(self):
for i in range(self.rowCount()):
self.setHeaderData(i, Qt.Vertical, i + 1, Qt.DisplayRole)
def setHiddenColumns(self, tableView):
tableView.hideColumn(self.IndexObjectId)
tableView.hideColumn(self.IndexLayerId)
tableView.hideColumn(self.IndexX)
tableView.hideColumn(self.IndexY)
tableView.hideColumn(self.IndexLat)
tableView.hideColumn(self.IndexLon)
tableView.hideColumn(self.IndexSurface)
def getExtentForLocate(self, sourceRow):
extent = None
surfaceType = None
if self.IndexSurface < 0:
surfaceType = self.surfaceType
else:
surfaceType = self.source.item(sourceRow, self.IndexSurface).text()
surfaceLayers = QgisHelper.getSurfaceLayers(self.surfaceType)
for sfLayer in surfaceLayers:
lId = sfLayer.name()
if lId.contains(surfaceType):
extent = sfLayer.extent()
break
return extent
def clear(self):
self.source.clear()
self.source.setHorizontalHeaderLabels(self.fixedColumnLabels)
# self.setHeaderLabels()
def locate(self, selectedRowIndexes):
if selectedRowIndexes == None or len(selectedRowIndexes) <= 0:
return
sourceRow = self.mapToSource(selectedRowIndexes[0]).row()
objectId = int(self.source.item(sourceRow, self.IndexObjectId).text())
layerId = self.source.item(sourceRow, self.IndexLayerId).text()
QgisHelper.selectFeature(layerId, objectId)
layer = QgsMapLayerRegistry.instance().mapLayer(layerId)
crs = define._canvas.mapSettings().destinationCrs()
if crs.mapUnits() == QGis.Meters:
x = float(self.source.item(sourceRow, self.IndexX).text())
y = float(self.source.item(sourceRow, self.IndexY).text())
extent = QgsRectangle(x - 350, y - 350, x + 350, y + 350)
else:
x, result1 = self.source.item(sourceRow,
self.IndexLon).data().toDouble()
y, result2 = self.source.item(sourceRow,
self.IndexLat).data().toDouble()
extent = QgsRectangle(x - 0.005, y - 0.005, x + 0.005, y + 0.005)
point = QgsPoint(x, y)
# extent = self.getExtentForLocate(sourceRow)
if extent is None:
return
QgisHelper.zoomExtent(point, extent, 2)
pass
def loadObstacles(self, surfaceLayers):
if self.source.rowCount() > 0:
self.source.clear()
self.source.setHorizontalHeaderLabels(self.fixedColumnLabels)
demEvaluateAg = None
existingDemFlag = False
obstacleLayersDEM = QgisHelper.getSurfaceLayers(SurfaceTypes.DEM)
obstacleLayers = QgisHelper.getSurfaceLayers(SurfaceTypes.Obstacles)
if obstacleLayersDEM != None and len(obstacleLayersDEM) > 0:
if QMessageBox.question(
None, "Question",
"Do you want to use DEM for evaluating Obstacle?",
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
self.loadObstaclesDEM(obstacleLayersDEM, surfaceLayers)
if obstacleLayers != None and len(obstacleLayers) > 0:
# if QMessageBox.question(None, "Question", "Do you want to use DEM for evaluating Obstacle?", QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
self.loadObstaclesVector(obstacleLayers, surfaceLayers)
return True
def loadObstaclesDEM(self, obstacleLayersDEM, surfaceLayers):
progressMessageBar = define._messagBar.createMessage(
"Loading DEM Obstacles...")
self.progress = QProgressBar()
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
define._messagBar.pushWidget(progressMessageBar,
define._messagBar.INFO)
maxium = 0
offset = 0.0
self.progress.setValue(0)
wCount = 0
hCount = 0
for ly in obstacleLayersDEM:
demDataProvider = ly.dataProvider()
boundDem = demDataProvider.extent()
xMin = boundDem.xMinimum()
xMax = boundDem.xMaximum()
yMin = boundDem.yMinimum()
yMax = boundDem.yMaximum()
bound = QgisHelper.getIntersectExtent(
ly, QgsGeometry.fromRect(boundDem), surfaceLayers)
# boundGeom = QgsGeometry.fromRect(bound)
if bound == None:
continue
block = ly.dataProvider().block(0, ly.extent(), ly.width(),
ly.height())
xMinimum = ly.dataProvider().extent().xMinimum()
yMaximum = ly.dataProvider().extent().yMaximum()
yMinimum = ly.dataProvider().extent().yMinimum()
xMaximum = ly.dataProvider().extent().xMaximum()
xOffSet = ly.extent().width() / ly.width()
yOffSet = ly.extent().height() / ly.height()
offset = xOffSet
if bound.xMinimum() < xMinimum:
wStartNumber = 0
xStartValue = xMinimum
else:
wStartNumber = int((bound.xMinimum() - xMinimum) / xOffSet)
xStartValue = bound.xMinimum()
if yMaximum < bound.yMaximum():
hStartNumber = 0
yStartValue = yMaximum
else:
hStartNumber = int((yMaximum - bound.yMaximum()) / yOffSet)
yStartValue = bound.yMaximum()
if bound.xMaximum() > xMaximum:
xEndValue = xMaximum
else:
xEndValue = bound.xMaximum()
if yMinimum > bound.yMinimum():
yEndValue = yMinimum
else:
yEndValue = bound.yMinimum()
wCount = int(math.fabs(xEndValue - xStartValue) / xOffSet)
hCount = int(math.fabs(yEndValue - yStartValue) / yOffSet)
pixelCount = hCount
maxium += pixelCount
cellSizeWnd = cellsizeWnd(offset, wCount * hCount, maxium * 0.04)
cellSizeWnd.setWindowTitle("Input Cell Size")
result = cellSizeWnd.exec_()
cellRate = 1
if result == 1:
offset = cellSizeWnd.cellsize
maxium = cellSizeWnd.cellCount + 2
cellRate = cellSizeWnd.cellRate
# print cellSizeWnd.textedit1.text()
if maxium == 0:
return False
self.progress.setMaximum(maxium)
trees = define._treesDEM
tolerance = define._toleranceDEM
for obstacleLayer in obstacleLayersDEM:
obstacleUnits = obstacleLayer.crs().mapUnits()
demDataProvider = obstacleLayer.dataProvider()
boundDem = demDataProvider.extent()
bound = QgisHelper.getIntersectExtent(
obstacleLayer, QgsGeometry.fromRect(boundDem), surfaceLayers)
if bound == None:
continue
boundGeom = QgsGeometry.fromRect(bound)
if not boundGeom.intersects(QgsGeometry.fromRect(boundDem)):
continue
block = obstacleLayer.dataProvider().block(1,
obstacleLayer.extent(),
obstacleLayer.width(),
obstacleLayer.height())
xMinimum = obstacleLayer.extent().xMinimum()
yMaximum = obstacleLayer.extent().yMaximum()
yMinimum = obstacleLayer.extent().yMinimum()
xMaximum = obstacleLayer.extent().xMaximum()
xOffSet = obstacleLayer.extent().width() / obstacleLayer.width()
yOffSet = obstacleLayer.extent().height() / obstacleLayer.height()
if bound.xMinimum() < xMinimum:
hStartNumber = 0
xStartValue = xMinimum
else:
hStartNumber = int((bound.xMinimum() - xMinimum) / xOffSet)
xStartValue = bound.xMinimum()
if yMaximum < bound.yMaximum():
wStartNumber = 0
yStartValue = yMaximum
else:
wStartNumber = int((yMaximum - bound.yMaximum()) / yOffSet)
yStartValue = bound.yMaximum()
if bound.xMaximum() > xMaximum:
xEndValue = xMaximum
else:
xEndValue = bound.xMaximum()
if yMinimum > bound.yMinimum():
yEndValue = yMinimum
else:
yEndValue = bound.yMinimum()
wCount = int(math.fabs(xEndValue - xStartValue) / offset)
hCount = int(math.fabs(yEndValue - yStartValue) / offset)
xPixelWidth = 0.0
yPixelWidth = 0.0
featureID = 0
# i = 0
# k = 0
# altitudeList = []
# self.progress.setValue(0)
# while i <= hCount - 1:
# j = 0
# while j <= wCount - 1:
# if block.isNoData(j * int(cellRate) + wStartNumber, i* int(cellRate) + hStartNumber):
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# altitudeList.append(None)
# continue
# altitude = block.value(j * int(cellRate) + wStartNumber, i * int(cellRate) + hStartNumber)
# altitudeList.append(altitude)
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# i += 1
i = 0
k = 0
name = "DEM"
semiXoffset = xOffSet / 2
semiYoffset = yOffSet / 2
while i <= hCount - 1:
j = 0
while j <= wCount - 1:
if block.isNoData(j * cellRate + wStartNumber,
i * cellRate + hStartNumber):
self.progress.setValue(k)
QApplication.processEvents()
j += 1
k += 1
continue
altitude = block.value(j * cellRate + wStartNumber,
i * cellRate + hStartNumber)
# # if block.isNoData(j * int(cellRate) + wStartNumber, i* int(cellRate) + hStartNumber):
# # j += 1
# # self.progress.setValue(self.progress.value() + 1)
# # QApplication.processEvents()
# # continue
# # altitude = block.value(j* int(cellRate) + wStartNumber, i* int(cellRate)+ hStartNumber)
# altitude = altitudeList[k]
# if altitude == None:
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# continue
point = QgsPoint(
xStartValue + (i * cellRate) * xOffSet + semiXoffset,
yStartValue - (j * cellRate - 1) * yOffSet -
semiYoffset)
position = Point3D()
positionDegree = Point3D()
if define._canvas.mapUnits() == QGis.Meters:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
position = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
position = Point3D(point.x(), point.y(), altitude)
else:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
positionDegree = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
positionDegree = Point3D(point.x(), point.y(),
altitude)
obstacle = Obstacle(name, position, obstacleLayer.id(),
featureID, None, trees,
ObstacleTable.MocMultiplier, tolerance)
obstacle.positionDegree = positionDegree
if self.manualPolygon != None:
if not self.manualPolygon.contains(obstacle.Position):
continue
self.checkObstacle(obstacle)
self.progress.setValue(k)
QApplication.processEvents()
j += 1
featureID += 1
k += 1
i += 1
self.progress.setValue(maxium)
define._messagBar.hide()
self.manualPolygon = None
def loadObstaclesVector(self, obstacleLayers, surfaceLayers):
progressMessageBar = define._messagBar.createMessage(
"Loading Vector Obstacles...")
self.progress = QProgressBar()
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
define._messagBar.pushWidget(progressMessageBar,
define._messagBar.INFO)
maxium = 0
self.progress.setValue(0)
for ly in obstacleLayers:
maxium += ly.featureCount()
if maxium == 0:
return False
self.progress.setMaximum(maxium)
for obstacleLayer in obstacleLayers:
obstacleUnits = obstacleLayer.crs().mapUnits()
features = QgisHelper.getFeaturesInLayerExtent(
define._canvas, obstacleLayer, surfaceLayers,
SelectionModeType.Automatic)
# print len(features)
for feature in features:
name = feature.attribute("Name").toString()
altitude = feature.attribute("Altitude").toFloat()[0]
trees = define._trees
tolerance = define._tolerance
point = feature.geometry().asPoint()
position = Point3D()
positionDegree = Point3D()
if define._canvas.mapUnits() == QGis.Meters:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
position = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
position = Point3D(point.x(), point.y(), altitude)
else:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
positionDegree = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
positionDegree = Point3D(point.x(), point.y(),
altitude)
featureId = feature.id()
layerId = obstacleLayer.id()
obstacle = Obstacle(name, position, layerId, featureId, None,
trees, ObstacleTable.MocMultiplier,
tolerance)
obstacle.positionDegree = positionDegree
# obstacle.positionDegree = positionDegree
self.checkObstacle(obstacle)
self.progress.setValue(self.progress.value() + 1)
QApplication.processEvents()
QApplication.processEvents()
self.progress.setValue(maxium)
define._messagBar.hide()
self.manualPolygon = None
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 checkObstacle(self, obstacle):
pass
def CompareObstacleRows(self, newRow, row, ignore):
pass
def method_0(self, obstacle_0):
colCount = self.columnCount()
objectId = range(colCount)
objectId[0] = (obstacle_0.featureId)
objectId[1] = (obstacle_0.name)
objectId[2] = (obstacle_0.position.x())
objectId[3] = (obstacle_0.position.y())
objectId[4] = (obstacle_0.Position.z())
position = obstacle_0.position
objectId[6] = (Unit.ConvertMeterToFeet(position.z()))
objectId[7] = (obstacle_0.trees)
objectId[8] = (Unit.ConvertMeterToFeet(obstacle_0.Trees))
if (self.IndexMocMultiplier > -1):
objectId[self.IndexMocMultiplier] = obstacle_0.MocMultiplier
return objectId
def method_1(self, object_0):
pass
class Main(QtGui.QMainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setup_signals()
self.initialize_project()
def initialize_project(self):
print 'initializing'
prj_files = glob.glob('../data/*.conf')
self.projects = {}
for config in prj_files:
path_fname = list(os.path.split(os.path.abspath(config)))
config_name = os.path.splitext(path_fname[1])[0]
self.projects[config_name] = path_fname
self.prj_model = QStandardItemModel(self.ui.ProjectsListView)
for prj_name in self.projects:
item = QStandardItem(prj_name)
print "Adding " + prj_name
self.prj_model.appendRow(item)
self.ui.ProjectsListView.setModel(self.prj_model)
self.ui.ProjectsListView.selectionModel().select(
self.prj_model.index(0, 0, QModelIndex()),
QtGui.QItemSelectionModel.Select)
def show_about(self):
print "its all about me!"
dlg = QtGui.QDialog()
ui = Ui_aboutDialog()
ui.setupUi(dlg)
dlg.show()
dlg.exec_()
def show_help(self):
print "show Help!"
pass
def new_prj(self):
print "create new tag name"
dlg = QtGui.QDialog()
TagNames(dlg)
dlg.show()
dlg.exec_()
def delete_prj(self):
print "Delete"
def do_save(self):
print "save it"
def do_save_as(self):
print "save as this"
def prj_menu(self, QPos):
self.listMenu = QtGui.QMenu(self.ui.ProjectsListView)
menu_item = self.listMenu.addAction("New")
self.connect(menu_item, QtCore.SIGNAL("triggered()"), self.new_prj)
menu_item = self.listMenu.addAction("Save")
self.connect(menu_item, QtCore.SIGNAL("triggered()"), self.do_save)
menu_item = self.listMenu.addAction("Save as")
self.connect(menu_item, QtCore.SIGNAL("triggered()"), self.do_save_as)
menu_item = self.listMenu.addAction("Delete")
self.connect(menu_item, QtCore.SIGNAL("triggered()"), self.delete_prj)
parentPosition = self.ui.ProjectsListView.mapToGlobal(
QtCore.QPoint(0, 0))
self.listMenu.move(parentPosition + QPos)
self.listMenu.show()
def setup_signals(self):
# will be setting up slots and signals here
print "setting up slots and signals"
QtCore.QObject.connect(self.ui.actionAbout,
QtCore.SIGNAL(_fromUtf8("activated()")),
self.show_about)
QtCore.QObject.connect(self.ui.actionNew,
QtCore.SIGNAL(_fromUtf8("activated()")),
self.new_prj)
QtCore.QObject.connect(self.ui.actionSave,
QtCore.SIGNAL(_fromUtf8("activated()")),
self.do_save)
QtCore.QObject.connect(self.ui.actionSave_as,
QtCore.SIGNAL(_fromUtf8("activated()")),
self.do_save_as)
QtCore.QObject.connect(self.ui.actionHelp,
QtCore.SIGNAL(_fromUtf8("activated()")),
self.show_help)
self.ui.ProjectsListView.setContextMenuPolicy(
QtCore.Qt.CustomContextMenu)
self.ui.ProjectsListView.connect(
self.ui.ProjectsListView,
QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.prj_menu)
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 GroupPhotoWindow(QMainWindow, Ui_main_win):
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.image_model = QStandardItemModel()
self.image_list.setModel(self.image_model)
QObject.connect(self.add_btn, QtCore.SIGNAL('clicked()'), self.on_add_image)
QObject.connect(self.delete_btn, QtCore.SIGNAL('clicked()'), self.on_remove_image)
QObject.connect(self.image_list.selectionModel(), QtCore.SIGNAL(
'currentChanged (const QModelIndex &, const QModelIndex &)'), self.on_row_changed)
QObject.connect(self.harris_btn, QtCore.SIGNAL('clicked()'), self.on_harris_detect)
QObject.connect(self.stitch_btn, QtCore.SIGNAL('clicked()'), self.on_stitch)
def on_add_image(self):
image_path = QFileDialog.getOpenFileName(self, 'Select image', filter='Images (*.png *.jpg *.bmp)')
ignored, name = os.path.split(unicode(image_path))
self.image_model.appendRow([QStandardItem(name), QStandardItem(image_path)])
def on_remove_image(self):
row = self.image_list.selectionModel().currentIndex().row()
if row == -1:
return
self.image_model.removeRows(row, 1)
def on_row_changed(self, current, previous):
row = current.row()
if row == -1:
file_path = PLACE_HOLDER
else:
file_path = self.image_model.item(row, 1).text()
self.set_pixmap(QPixmap(file_path))
def on_harris_detect(self):
row = self.image_list.selectionModel().currentIndex().row()
if row == -1:
return
file_path = self.image_model.item(row, 1).text()
image_pfm = convert_to_pfm(imread(unicode(file_path)))
image = image_to_gray(image_pfm)
kernel = self.ksize_slider.value()
cornerness = harris_corner(image, ksize=kernel)
is_corner = cornerness > 0.000001
suppress = non_max_suppression(cornerness, ksize=kernel)
result = np.array(is_corner * suppress)
zero = np.zeros_like(result)
gray_img = np.dstack((zero, zero, draw_cross(result)))
self.set_pixmap(QPixmap.fromImage(image_from_ndarray(np.array(gray_img + image_pfm))))
def on_stitch(self):
i = 0
images = []
while self.image_model.item(i):
file_path = self.image_model.item(i, 1).text()
image = image_to_gray(convert_to_pfm(imread(unicode(file_path))))
images.append(image)
i += 1
stitch(self.ksize_slider.value(), images)
def set_pixmap(self, pixmap):
self.image_label.setPixmap(pixmap.scaled(self.image_label.size(), QtCore.Qt.KeepAspectRatio))
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)
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()
