def set_inspection(self, projectId, sectionId, inspectionId):
self.clearContents()
self.projectId = projectId
self.sectionId = sectionId
self.inspectionId = inspectionId
for r in range(self.rowCount() - 1, -1, -1):
self.removeRow(r)
if self.projectId is None or self.sectionId is None or self.inspectionId is None:
return
for o_id, obs in self.data[self.projectId]['Sections'][self.sectionId]['Inspections'][self.inspectionId]['Observations'].iteritems():
r = self.rowCount()
self.insertRow(r)
for c, col in enumerate(ColumnData):
item = QTableWidgetItem(u'{}'.format(obs[col] if c < 6 else ''))
if c in (0,6):
data_column = 'Import' if c == 0 else 'ForceImport'
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if obs[data_column] else Qt.Unchecked)
item.setData(Qt.UserRole, o_id)
item.setData(Qt.UserRole+1, data_column)
else:
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
font = item.font()
font.setPointSize(font.pointSize() - 2)
item.setFont(font)
self.setItem(r, c, item)
self.resizeColumnsToContents()
def load_items(self):
"""
Load items from the indexed_items list and add them in the
self.indexedItems QTableWidget.
"""
count = 0
# get the list of already indexed stuff and add them in the qtablewidget
# with a not-editable check box indicating if it has been indexed
# recursively or not
for i in self.indexed_items:
node = VFS.Get().getNodeFromPointer(long(i))
if node == None:
continue
recurse = self.indexed_items[i]
new_item = QTableWidgetItem(QIcon(":/folder.png"), node.name())
self.indexedItems.setRowCount(count + 1)
new_item.setData(Qt.UserRole + 1, QVariant(long(node.this)))
self.indexedItems.setItem(count, 0, new_item)
new_item2 = QTableWidgetItem()
new_item2.setFlags(Qt.ItemIsUserCheckable)
if recurse:
new_item2.setCheckState(Qt.Checked)
else:
new_item2.setCheckState(Qt.Unchecked)
self.indexedItems.setItem(count, 1, new_item2)
count += 1
return count
def _add_task_to_table(self, row, task):
self._ignore_cell_changed = True
self.setItem(row, self._dict_header['id'],
QTableWidgetItem(str(task.identifier)))
self.item(row, self._dict_header['id']) \
.setTextAlignment(Qt.AlignCenter)
self.setItem(row, self._dict_header['name'],
QTableWidgetItem(str(task.name)))
combo = QComboBox()
items = [task_type for task_type in Task.task_types_names]
combo.addItems(items)
# FIXME: only until I get an access to the documentation.
for i, t in enumerate(Task.task_types_names):
if t == task.task_type:
combo.setCurrentIndex(i)
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['task_type']))
self.setCellWidget(row, self._dict_header['task_type'], combo)
item = QTableWidgetItem(task.abort_on_miss and 'Yes' or 'No')
item.setFlags(
Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setCheckState(task.abort_on_miss and Qt.Checked or Qt.Unchecked)
self.setItem(row, self._dict_header['abort'], item)
self.setItem(row, self._dict_header['list_activation_dates'],
QTableWidgetItem(
', '.join(map(str, task.list_activation_dates))))
self.item(row, self._dict_header['list_activation_dates']) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
for i in ['activation_date', 'period',
'deadline', 'wcet', 'base_cpi', 'n_instr', 'mix', 'acet',
'et_stddev', 'preemption_cost']:
self.setItem(row, self._dict_header[i],
QTableWidgetItem(str(task.__dict__[i])))
self.item(row, self._dict_header[i]) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
stack_item = QTableWidgetItem(str(task.stack_file))
stack_item.setFlags(stack_item.flags() ^ (Qt.ItemIsEditable))
self.setItem(row, self._dict_header['sdp'], stack_item)
combo = QComboBox()
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['followed']))
self.setCellWidget(row, self._dict_header['followed'], combo)
for col in range(len(self._custom_fields)):
key = self._custom_fields[col]
if key in task.data and task.data[key] is not None:
item = QTableWidgetItem(str(task.data[key]))
else:
item = QTableWidgetItem('')
item.setBackgroundColor(QColor.fromRgb(200, 255, 200))
self.setItem(row, col + len(self._header), item)
self._ignore_cell_changed = False
self._show_period(task, row)
def updatePackages(self):
library_ = robjects.r.get('library', mode='function')
packages_ = robjects.r.get('.packages', mode='function')
loaded = list(packages_())
packages = list(library_()[1])
length = len(packages)
self.packageTable.clearContents()
#self.table.setRowCount(length/3)
packageList = []
for i in range(length/3):
package = unicode(packages[i])
if not package in packageList:
packageList.append(package)
self.packageTable.setRowCount(len(packageList))
item = QTableWidgetItem("Loaded")
item.setFlags(
Qt.ItemIsUserCheckable|Qt.ItemIsEnabled|Qt.ItemIsSelectable)
if package in loaded:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.packageTable.setItem(i, 0, item)
item = QTableWidgetItem(unicode(packages[i]))
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.packageTable.setItem(i, 1, item)
item = QTableWidgetItem(unicode(packages[i+(2*(length/3))]))
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.packageTable.setItem(i, 2, item)
item = QTableWidgetItem(unicode(packages[i+(length/3)]))
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.packageTable.setItem(i, 3, item)
self.packageTable.resizeColumnsToContents()
def create_table_widget(table, parent):
formats = table.getColFormats()
names = table.getColNames()
indices_of_visible_columns = [j for (j, f) in enumerate(formats) if f is not None]
headers = ["ok"] + [names[j] for j in indices_of_visible_columns]
n_rows = len(table)
widget = QTableWidget(n_rows, 1 + len(indices_of_visible_columns), parent=parent)
widget.setHorizontalHeaderLabels(headers)
widget.setMinimumSize(200, 200)
widget.horizontalHeader().setResizeMode(QHeaderView.Interactive)
for i, row in enumerate(table.rows):
item = QTableWidgetItem()
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
widget.setItem(i, 0, item)
for j0, j in enumerate(indices_of_visible_columns):
value = row[j]
formatter = table.colFormatters[j]
item = QTableWidgetItem(formatter(value))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
widget.setItem(i, j0 + 1, item)
return widget
def create_table_widget(table, parent):
formats = table.getColFormats()
names = table.getColNames()
indices_of_visible_columns = [
j for (j, f) in enumerate(formats) if f is not None
]
headers = ["ok"] + [names[j] for j in indices_of_visible_columns]
n_rows = len(table)
widget = QTableWidget(n_rows,
1 + len(indices_of_visible_columns),
parent=parent)
widget.setHorizontalHeaderLabels(headers)
widget.setMinimumSize(200, 200)
widget.horizontalHeader().setResizeMode(QHeaderView.Interactive)
for i, row in enumerate(table.rows):
item = QTableWidgetItem()
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable)
widget.setItem(i, 0, item)
for j0, j in enumerate(indices_of_visible_columns):
value = row[j]
formatter = table.colFormatters[j]
item = QTableWidgetItem(formatter(value))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
widget.setItem(i, j0 + 1, item)
return widget
def populateTable(self,filePath):
self.filePath = filePath
ui = self
table = ui.tableWidget
# table.clear()
table.setRowCount(0)
xml = file(filePath).read()
d = QtXml.QDomDocument()
d.setContent(xml)
maps = d.elementsByTagName("maplayer")
self.maps=maps
for i in range(maps.length()):
table.setRowCount(table.rowCount()+1)
info = getMapInfo(maps.item(i))
nameItem = QTableWidgetItem(info['name'])
nameItem.setFlags(QtCore.Qt.ItemIsUserCheckable|QtCore.Qt.ItemIsSelectable|QtCore.Qt.ItemIsEnabled)
nameItem.setCheckState(QtCore.Qt.Unchecked)
nameItem.setData(QtCore.Qt.UserRole,str(i))
table.setItem(i,0,nameItem)
table.setItem(i,1,FixedWidgetItem(info['mtype']))
table.setItem(i,2,FixedWidgetItem(info['geom']))
table.setItem(i,3,FixedWidgetItem(info['provider']))
ds = FixedWidgetItem(info['ds'])
ds.setData(QtCore.Qt.ToolTipRole,info['ds'])
table.setItem(i,4,ds)
def on_create_super_group(self):
inames = [
iname for iname, check in enumerate(self.checks)
if bool(check.checkState())
]
if not len(inames):
# TODO: add logging
print('nothing is checked...')
return
if inames[0] == 0:
# TODO: add logging
print("cannot include 'ALL' in supergroup...")
return
name = 'SuperGroup'
# popup gui and get a name
irow = self.table.rowCount()
self.table.insertRow(irow)
check = QTableWidgetItem()
check.setCheckState(False)
name_text = QTableWidgetItem(str(name))
self.names.extend(name)
self.names_text.append(name_text)
self.checks.append(check)
self.table.setItem(irow, 0, check)
self.table.setItem(irow, 1, name_text)
def render_result(self):
query = self.query_edit.text()
if not query:
return
self.feed = FeedBooks()
response = self.feed.search(str(query))
if not response:
QMessageBox.critical(self, 'Error', 'Could not get any result')
return
self.table.clear()
self.table.setHorizontalHeaderLabels(['Select', 'Title', 'URL'])
self.table.setRowCount(len(response[1]))
for i, name in enumerate(zip(response[1], response[3])):
item = QTableWidgetItem(1)
item.data(Qt.CheckStateRole)
item.setCheckState(Qt.Checked)
self.table.setItem(i, 0, item)
for j in range(2):
item = QTableWidgetItem(name[j])
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.table.setItem(i, j+1, item)
self.table.resizeColumnsToContents()
def on_create_super_group(self):
inames = [iname for iname, check in enumerate(self.checks)
if bool(check.checkState())]
if not len(inames):
# TODO: add logging
print('nothing is checked...')
return
if inames[0] == 0:
# TODO: add logging
print("cannot include 'ALL' in supergroup...")
return
name = 'SuperGroup'
# popup gui and get a name
irow = self.table.rowCount()
self.table.insertRow(irow)
check = QTableWidgetItem()
check.setCheckState(False)
name_text = QTableWidgetItem(str(name))
self.names.extend(name)
self.names_text.append(name_text)
self.checks.append(check)
self.table.setItem(irow, 0, check)
self.table.setItem(irow, 1, name_text)
def loadSentencesInTable(self): self.col = 0 if len(self.sentenceList) > 0: self.sentenceTable.setRowCount(len(self.sentenceList)) cellList = [] ## Create QTableWidgetItems from the sentence list for sentence in self.sentenceList: item = QTableWidgetItem(QString(sentence)) item.setFlags(Qt.ItemFlags(Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)) item.setCheckState(Qt.Unchecked) cellList.append(item) cellList.reverse() # set the widget items in the table for item in range(0, len(self.sentenceList)): self.sentenceTable.setItem(item, self.col, cellList.pop()) for index in range(0, len(self.sentenceList)): self.sentenceTable.verticalHeader().resizeSection(index, 100) if len(self.sentenceList) == 5: self.sentenceTable.setFixedHeight(500) if len(self.sentenceList) == 4: self.sentenceTable.setFixedHeight(400) elif len(self.sentenceList) == 3: self.sentenceTable.setFixedHeight(300) elif len(self.sentenceList) == 2: self.sentenceTable.setFixedHeight(200) elif len(self.sentenceList) == 1: self.sentenceTable.setFixedHeight(100) else: self.sentenceTable.clearContents()
def addMachine(self,name,ip,status=''):
for row in self.machinesData.values:
if row.has_key('nameItem'):
if row['nameItem'] == name:
isAlive = True
else:
rowNumber = self.tbl.rowCount()
nameItem = QTableWidgetItem(name)
IPItem = QTableWidgetItem(self.machinesData[name])
statusItem = QTableWidgetItem(status)
checkboxItem = QTableWidgetItem()
checkboxItem.setFlags(Qt.ItemIsEnabled|Qt.ItemIsUserCheckable)
checkboxItem.setCheckState(Qt.Checked)
transferItem = QTableWidgetItem('')
self.allItemsChecked = True
self.tbl.insertRow(rowNumber)
self.tbl.setItem(rowNumber,NAME,nameItem)
self.tbl.setItem(rowNumber,IP,IPItem)
self.tbl.setItem(rowNumber,STATUS,statusItem)
self.tbl.setItem(rowNumber,CHECKED,checkboxItem)
self.tbl.setItem(rowNumber,TRANSFER,transferItem)
self.machinesData[rowNumber] = {'checkboxItem':checkboxItem,
'nameItem':nameItem,
'IPItem':IPItem,
'statusItem':statusItem,
'transferItem':transferItem}
row = self.machinesData[rowNumber]
isAlive = None
self.emit(SIGNAL('updateStatus'),row,isAlive)
return
def _add_task_to_table(self, row, task):
self._ignore_cell_changed = True
self.setItem(row, self._dict_header['id'],
QTableWidgetItem(str(task.identifier)))
self.item(row, self._dict_header['id']) \
.setTextAlignment(Qt.AlignCenter)
self.setItem(row, self._dict_header['name'],
QTableWidgetItem(str(task.name)))
combo = QComboBox()
items = [task_type for task_type in Task.task_types_names]
combo.addItems(items)
combo.setCurrentIndex(combo.findText(task.task_type))
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['task_type']))
self.setCellWidget(row, self._dict_header['task_type'], combo)
item = QTableWidgetItem(task.abort_on_miss and 'Yes' or 'No')
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled
| Qt.ItemIsSelectable)
item.setCheckState(task.abort_on_miss and Qt.Checked or Qt.Unchecked)
self.setItem(row, self._dict_header['abort'], item)
self.setItem(
row, self._dict_header['list_activation_dates'],
QTableWidgetItem(', '.join(map(str, task.list_activation_dates))))
self.item(row, self._dict_header['list_activation_dates']) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
for i in [
'activation_date', 'period', 'deadline', 'wcet', 'base_cpi',
'n_instr', 'mix', 'acet', 'et_stddev', 'preemption_cost'
]:
self.setItem(row, self._dict_header[i],
QTableWidgetItem(str(task.__dict__[i])))
self.item(row, self._dict_header[i]) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
stack_item = QTableWidgetItem(str(task.stack_file))
stack_item.setFlags(stack_item.flags() ^ (Qt.ItemIsEditable))
self.setItem(row, self._dict_header['sdp'], stack_item)
combo = QComboBox()
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['followed']))
self.setCellWidget(row, self._dict_header['followed'], combo)
for col in range(len(self._custom_fields)):
key = self._custom_fields[col]
if key in task.data and task.data[key] is not None:
item = QTableWidgetItem(str(task.data[key]))
else:
item = QTableWidgetItem('')
item.setBackgroundColor(QColor.fromRgb(200, 255, 200))
self.setItem(row, col + len(self._header), item)
self._ignore_cell_changed = False
self._show_period(task, row)
def initWithExtents(self, axes, shape, start, stop):
self.setColumnCount(3)
self.setHorizontalHeaderLabels(["range", "[start,", "stop)"])
self.resizeColumnsToContents()
tagged_shape = collections.OrderedDict(zip(axes, shape))
tagged_start = collections.OrderedDict(zip(axes, start))
tagged_stop = collections.OrderedDict(zip(axes, stop))
self._tagged_shape = tagged_shape
self.setRowCount(len(tagged_shape))
self.setVerticalHeaderLabels(tagged_shape.keys())
self._boxes.clear()
for row, (axis_key, extent) in enumerate(tagged_shape.items()):
# Init 'full' checkbox
checkbox_item = QTableWidgetItem("All")
if tagged_start[axis_key] is None:
checkbox_item.setCheckState(Qt.Checked)
else:
checkbox_item.setCheckState(Qt.Unchecked)
checkbox_item.setFlags(
Qt.ItemFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled))
self.setItem(row, 0, checkbox_item)
# Init min/max spinboxes
default_start = tagged_start[axis_key] or 0
default_stop = tagged_stop[axis_key] or extent or DEFAULT_MAX_EXTENT
extent = extent or DEFAULT_MAX_EXTENT
startBox = RoiSpinBox(self, 0, extent - 1, 0)
stopBox = RoiSpinBox(self, 1, extent, extent)
startBox.setPartner(stopBox)
stopBox.setPartner(startBox)
startBox.setEnabled(tagged_start[axis_key] is not None)
stopBox.setEnabled(tagged_stop[axis_key] is not None)
if startBox.isEnabled():
startBox.setValue(default_start)
if stopBox.isEnabled():
stopBox.setValue(default_stop)
startBox.valueChanged.connect(self._updateRoi)
stopBox.valueChanged.connect(self._updateRoi)
self.setCellWidget(row, 1, startBox)
self.setCellWidget(row, 2, stopBox)
self._boxes[axis_key] = (checkbox_item, startBox, stopBox)
self._updateRoi()
self.resizeColumnsToContents()
def populate(self, modules):
i = 0
for k, v in modules.iteritems():
item = QTableWidgetItem(str(k))
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Checked)
itemv = QTableWidgetItem(str(v))
itemv.setFlags(Qt.ItemIsEnabled)
self.setItem(i, 0, item)
self.setItem(i, 1, itemv)
i += 1
def initWithExtents(self, axes, shape, start, stop):
self.setColumnCount( 3 )
self.setHorizontalHeaderLabels(["range", "[start,", "stop)"])
self.resizeColumnsToContents()
tagged_shape = collections.OrderedDict( zip(axes, shape) )
tagged_start = collections.OrderedDict( zip(axes, start) )
tagged_stop = collections.OrderedDict( zip(axes, stop) )
self._tagged_shape = tagged_shape
self.setRowCount( len(tagged_shape) )
self.setVerticalHeaderLabels( tagged_shape.keys() )
self._boxes.clear()
for row, (axis_key, extent) in enumerate(tagged_shape.items()):
# Init 'full' checkbox
checkbox_item = QTableWidgetItem("All")
if tagged_start[axis_key] is None:
checkbox_item.setCheckState( Qt.Checked )
else:
checkbox_item.setCheckState( Qt.Unchecked )
checkbox_item.setFlags( Qt.ItemFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) )
self.setItem(row, 0, checkbox_item)
# Init min/max spinboxes
default_start = tagged_start[axis_key] or 0
default_stop = tagged_stop[axis_key] or extent or DEFAULT_MAX_EXTENT
extent = extent or DEFAULT_MAX_EXTENT
startBox = RoiSpinBox(self, 0, extent-1, 0 )
stopBox = RoiSpinBox(self, 1, extent, extent )
startBox.setPartner( stopBox )
stopBox.setPartner( startBox )
startBox.setEnabled( tagged_start[axis_key] is not None )
stopBox.setEnabled( tagged_stop[axis_key] is not None )
if startBox.isEnabled():
startBox.setValue( default_start )
if stopBox.isEnabled():
stopBox.setValue( default_stop )
startBox.valueChanged.connect( self._updateRoi )
stopBox.valueChanged.connect( self._updateRoi )
self.setCellWidget( row, 1, startBox )
self.setCellWidget( row, 2, stopBox )
self._boxes[axis_key] = (checkbox_item, startBox, stopBox)
self._updateRoi()
self.resizeColumnsToContents()
def load(self, error=True):
s = QSettings("norBIT", "norGIS-ALKIS-Erweiterung")
s.setValue("service", self.leSERVICE.text())
s.setValue("host", self.leHOST.text())
s.setValue("port", self.lePORT.text())
s.setValue("dbname", self.leDBNAME.text())
s.setValue("uid", self.leUID.text())
s.setValue("pwd", self.lePWD.text())
modelle = s.value("modellarten", ['DLKM', 'DKKM1000'])
(db, conninfo) = self.plugin.opendb()
if db:
qry = QSqlQuery(db)
if qry.exec_("""
SELECT modell,count(*)
FROM (
SELECT unnest(modell) AS modell FROM po_points UNION ALL
SELECT unnest(modell) AS modell FROM po_lines UNION ALL
SELECT unnest(modell) AS modell FROM po_polygons UNION ALL
SELECT unnest(modell) AS modell from po_lines UNION ALL
SELECT unnest(modell) AS modell from po_labels
) AS foo
GROUP BY modell
ORDER BY count(*) DESC
"""):
self.twModellarten.clearContents()
res = {}
while qry.next():
res[qry.value(0)] = qry.value(1)
self.twModellarten.setRowCount(len(res))
i = 0
for k, n in sorted(res.iteritems(),
key=operator.itemgetter(1),
reverse=True):
item = QTableWidgetItem(k)
item.setCheckState(Qt.Checked if (
item.text() in modelle) else Qt.Unchecked)
self.twModellarten.setItem(i, 0, item)
item = QTableWidgetItem(str(n))
self.twModellarten.setItem(i, 1, item)
i += 1
self.twModellarten.resizeColumnsToContents()
elif error:
modelle = []
self.twModellarten.clearContents()
self.twModellarten.setDisabled(True)
else:
modelle = []
elif error:
QMessageBox.critical(None, "ALKIS",
u"Datenbankverbindung schlug fehl.")
def populateList(self):
dicts = self.manager.dictionnaries()
currow = 0
for _dict in dicts.iterkeys():
self.dicos.setRowCount(currow + 1)
item = QTableWidgetItem(QString.fromUtf8(dicts[_dict].fileName()))
item.setFlags(Qt.ItemIsUserCheckable|Qt.ItemIsEnabled|Qt.ItemIsSelectable)
item.setCheckState(Qt.Unchecked)
self.dicos.setItem(currow, 0, item)
name = QTableWidgetItem(QString.fromUtf8(_dict))
name.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.dicos.setItem(currow, 1, name)
currow += 1
def __init__(self, parent):
QDialog.__init__(self, parent)
# Set up the user interface from Designer.
self.ui = ui = Ui_SettingsDialog()
ui.setupUi(self)
ui.lineEdit_BrowserPath.setPlaceholderText(
"Leave this empty to use your default browser")
ui.toolButton_Browse.clicked.connect(self.browseClicked)
# load settings
settings = QSettings()
ui.lineEdit_BrowserPath.setText(
settings.value("/Qgis2threejs/browser", "", type=unicode))
enabled_plugins = QSettings().value("/Qgis2threejs/plugins",
"",
type=unicode).split(",")
# initialize plugin table widget
plugin_dir = QDir(
os.path.join(os.path.dirname(QFile.decodeName(__file__)),
"plugins"))
plugins = plugin_dir.entryList(QDir.Dirs | QDir.NoSymLinks
| QDir.NoDotAndDotDot)
tableWidget = ui.tableWidget_Plugins
tableWidget.setRowCount(len(plugins))
tableWidget.setColumnCount(1)
tableWidget.setHorizontalHeaderLabels(["Name"])
tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
headerView = tableWidget.horizontalHeader()
headerView.setResizeMode(0, QHeaderView.Stretch)
self.plugin_metadata = []
for i, name in enumerate(plugins):
parser = ConfigParser.SafeConfigParser()
with codecs.open(
os.path.join(plugin_dir.absoluteFilePath(name),
"metadata.txt"), "r", "UTF-8") as f:
parser.readfp(f)
metadata = dict(parser.items("general"))
self.plugin_metadata.append(metadata)
item = QTableWidgetItem(metadata.get("name", name))
item.setCheckState(Qt.Checked if name in
enabled_plugins else Qt.Unchecked)
tableWidget.setItem(i, 0, item)
tableWidget.selectionModel().currentRowChanged.connect(
self.pluginSelectionChanged)
def load(self, error=True):
s = QSettings( "norBIT", "norGIS-ALKIS-Erweiterung" )
s.setValue( "service", self.leSERVICE.text() )
s.setValue( "host", self.leHOST.text() )
s.setValue( "port", self.lePORT.text() )
s.setValue( "dbname", self.leDBNAME.text() )
s.setValue( "uid", self.leUID.text() )
s.setValue( "pwd", self.lePWD.text() )
modelle = s.value( "modellarten", ['DLKM','DKKM1000'] )
(db,conninfo) = self.plugin.opendb()
if db:
qry = QSqlQuery(db)
if qry.exec_( """
SELECT modell,count(*)
FROM (
SELECT unnest(modell) AS modell FROM po_points UNION ALL
SELECT unnest(modell) AS modell FROM po_lines UNION ALL
SELECT unnest(modell) AS modell FROM po_polygons UNION ALL
SELECT unnest(modell) AS modell from po_lines UNION ALL
SELECT unnest(modell) AS modell from po_labels
) AS foo
GROUP BY modell
ORDER BY count(*) DESC
""" ):
self.twModellarten.clearContents()
res = {}
while qry.next():
res[ qry.value(0) ] = qry.value(1)
self.twModellarten.setRowCount( len(res) )
i = 0
for k,n in sorted(res.iteritems(), key=operator.itemgetter(1), reverse=True):
item = QTableWidgetItem( k )
item.setCheckState( Qt.Checked if (item.text() in modelle) else Qt.Unchecked )
self.twModellarten.setItem( i, 0, item )
item = QTableWidgetItem( str(n) )
self.twModellarten.setItem( i, 1, item )
i += 1
self.twModellarten.resizeColumnsToContents()
elif error:
modelle = []
self.twModellarten.clearContents()
self.twModellarten.setDisabled( True )
else:
modelle = []
elif error:
QMessageBox.critical( None, "ALKIS", u"Datenbankverbindung schlug fehl." )
def load_table(table, headers, data, checkFirstColumn=True):
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in xrange(table.rowCount()):
table.removeRow(0)
for r, row in enumerate(data):
table.insertRow(r)
for index, colItem in enumerate(row):
item = QTableWidgetItem(colItem)
table.setItem(r, index, item)
if index == 0 and checkFirstColumn:
item.setCheckState(Qt.Unchecked)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def load_table(table, headers, data, checkFirstColumn=True):
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in xrange(table.rowCount()):
table.removeRow(0)
for r, row in enumerate(data):
table.insertRow(r)
for index, colItem in enumerate(row):
item = QTableWidgetItem(colItem)
table.setItem(r, index, item)
if index == 0 and checkFirstColumn:
item.setCheckState(Qt.Unchecked)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def do_add(self):
#print "do_add() \n"
row = self.tableWidget.rowCount()
self.tableWidget.setRowCount(row + 1)
#ckBox = QTableWidgetItem("select %d" %row)
ckBox = QTableWidgetItem("Active")
ckBox.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
ckBox.setCheckState(QtCore.Qt.Unchecked)
self.tableWidget.setItem(row, 0, ckBox)
cbBox = QtGui.QComboBox()
cbBox.addItem("dnw")
cbBox.addItem("fastboot")
self.tableWidget.setCellWidget(row, 1, cbBox)
self.tableWidget.setItem(row, 2, QTableWidgetItem(QString("0x00000000")))
self.tableWidget.setItem(row, 3, QTableWidgetItem(QString("./uboot.bin")))
def set_data(skins, table):
table.setHorizontalHeaderLabels(['Name', 'URL'])
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in xrange(table.rowCount()):
table.removeRow(0)
r = 0
for skin in skins:
table.insertRow(r)
#Column 1
item = QTableWidgetItem(skin[1])
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
table.setItem(r, 1, item)
#Column 0
item = QTableWidgetItem(skin[0])
table.setItem(r, 0, item)
item.setCheckState(Qt.Unchecked)
r += 1
def addSettingsToRow(settings, out_table):
s = settings
row = out_table.rowCount()
out_table.insertRow(row)
s = settings
# insert values
for i, value in enumerate([
s.layerName, s.startTimeAttribute, s.endTimeAttribute, s.isEnabled,
s.layerId, s.timeFormat,
str(s.offset), s.interpolationEnabled, s.idAttribute,
s.interpolationMode, not s.geometriesCount, s.accumulate
]):
item = QTableWidgetItem()
if type(value) != bool:
item.setText(value)
else:
item.setCheckState(Qt.Checked if value else Qt.Unchecked)
out_table.setItem(row, i, item)
def set_data(skins, table):
table.setHorizontalHeaderLabels(['Name', 'URL'])
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in xrange(table.rowCount()):
table.removeRow(0)
r = 0
for skin in skins:
table.insertRow(r)
#Column 1
item = QTableWidgetItem(skin[1])
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
table.setItem(r, 1, item)
#Column 0
item = QTableWidgetItem(skin[0])
table.setItem(r, 0, item)
item.setCheckState(Qt.Unchecked)
r += 1
def initWithExtents(self, axes, shape, start, stop):
tagged_shape = collections.OrderedDict(zip(axes, shape))
tagged_start = collections.OrderedDict(zip(axes, start))
tagged_stop = collections.OrderedDict(zip(axes, stop))
self._tagged_shape = tagged_shape
self.setRowCount(len(tagged_shape))
self.setVerticalHeaderLabels(tagged_shape.keys())
for row, (axis_key, extent) in enumerate(tagged_shape.items()):
# Init 'full' checkbox
checkbox_item = QTableWidgetItem("All")
if tagged_start[axis_key] is None:
checkbox_item.setCheckState(Qt.Checked)
else:
checkbox_item.setCheckState(Qt.Unchecked)
checkbox_item.setFlags(
Qt.ItemFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled))
self.setItem(row, 0, checkbox_item)
# Init min/max spinboxes
default_start = tagged_start[axis_key] or 0
default_stop = tagged_stop[axis_key] or extent
startBox = RoiSpinBox(self, 0, extent - 1, default_start)
stopBox = RoiSpinBox(self, 1, extent, default_stop)
startBox.setPartner(stopBox)
stopBox.setPartner(startBox)
startBox.setValue(default_start)
stopBox.setValue(default_stop)
startBox.setEnabled(tagged_start[axis_key] is not None)
stopBox.setEnabled(tagged_stop[axis_key] is not None)
startBox.valueChanged.connect(self._updateRoi)
stopBox.valueChanged.connect(self._updateRoi)
self.setCellWidget(row, 1, startBox)
self.setCellWidget(row, 2, stopBox)
self._boxes[axis_key] = (checkbox_item, startBox, stopBox)
def initWithExtents(self, axes, shape, start, stop):
tagged_shape = collections.OrderedDict( zip(axes, shape) )
tagged_start = collections.OrderedDict( zip(axes, start) )
tagged_stop = collections.OrderedDict( zip(axes, stop) )
self._tagged_shape = tagged_shape
self.setRowCount( len(tagged_shape) )
self.setVerticalHeaderLabels( tagged_shape.keys() )
for row, (axis_key, extent) in enumerate(tagged_shape.items()):
# Init 'full' checkbox
checkbox_item = QTableWidgetItem("All")
if tagged_start[axis_key] is None:
checkbox_item.setCheckState( Qt.Checked )
else:
checkbox_item.setCheckState( Qt.Unchecked )
checkbox_item.setFlags( Qt.ItemFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) )
self.setItem(row, 0, checkbox_item)
# Init min/max spinboxes
default_start = tagged_start[axis_key] or 0
default_stop = tagged_stop[axis_key] or extent
startBox = RoiSpinBox(self, 0, extent-1, default_start )
stopBox = RoiSpinBox(self, 1, extent, default_stop )
startBox.setPartner( stopBox )
stopBox.setPartner( startBox )
startBox.setValue( default_start )
stopBox.setValue( default_stop )
startBox.setEnabled( tagged_start[axis_key] is not None )
stopBox.setEnabled( tagged_stop[axis_key] is not None )
startBox.valueChanged.connect( self._updateRoi )
stopBox.valueChanged.connect( self._updateRoi )
self.setCellWidget( row, 1, startBox )
self.setCellWidget( row, 2, stopBox )
self._boxes[axis_key] = (checkbox_item, startBox, stopBox)
def do_additem(self, cmd, args, filename):
row = self.tableWidget.rowCount()
self.tableWidget.setRowCount(row + 1)
#ckBox = QTableWidgetItem("select %d" %row)
ckBox = QTableWidgetItem("Active")
ckBox.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
ckBox.setCheckState(QtCore.Qt.Unchecked)
self.tableWidget.setItem(row, 0, ckBox)
cbBox = QtGui.QComboBox()
cbBox.addItem("dnw")
cbBox.addItem("fastboot")
if cmd == "fastboot":
cbBox.setCurrentIndex(1)
else:
cbBox.setCurrentIndex(0)
self.tableWidget.setCellWidget(row, 1, cbBox)
self.tableWidget.setItem(row, 2, QTableWidgetItem(QString(args)))
self.tableWidget.setItem(row, 3, QTableWidgetItem(QString(filename)))
def create_widgets(self):
# main/delete/supergroup
self.set_as_main_button = QPushButton("Set As Main")
self.create_super_group_button = QPushButton("Create Super Group")
self.delete_groups_button = QPushButton("Delete Groups")
self.revert_groups_button = QPushButton("Revert Groups")
self.show_groups_button = QPushButton("Show Groups")
self.hide_groups_button = QPushButton("Hide Groups")
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
#table
self.table = QTableWidget()
self.checks = []
self.names_text = []
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
bold.setWeight(75)
anames = array(self.names)
for iname, name in enumerate(anames[self.inames]):
check = QTableWidgetItem()
check.setCheckState(False)
# TODO: create right click menu ???
name_text = QTableWidgetItem(str(name))
if iname == self.imain:
name_text.setFont(bold)
self.shown_set.add(iname)
check.setCheckState(2)
name_text.setBackground(QtGui.QColor(*self.light_grey))
elif iname in self.shown_set:
name_text.setBackground(QtGui.QColor(*self.light_grey))
self.checks.append(check)
self.names_text.append(name_text)
def create_widgets(self):
# main/delete/supergroup
self.set_as_main_button = QPushButton("Set As Main")
self.create_super_group_button = QPushButton("Create Super Group")
self.delete_groups_button = QPushButton("Delete Groups")
self.revert_groups_button = QPushButton("Revert Groups")
self.show_groups_button = QPushButton("Show Groups")
self.hide_groups_button = QPushButton("Hide Groups")
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
#table
self.table = QTableWidget()
self.checks = []
self.names_text = []
bold = QtGui.QFont()
bold.setBold(True)
bold.setItalic(True)
bold.setWeight(75)
anames = array(self.names)
for iname, name in enumerate(anames[self.inames]):
check = QTableWidgetItem()
check.setCheckState(False)
# TODO: create right click menu ???
name_text = QTableWidgetItem(str(name))
if iname == self.imain:
name_text.setFont(bold)
self.shown_set.add(iname)
check.setCheckState(2)
name_text.setBackground(QtGui.QColor(*self.light_grey))
elif iname in self.shown_set:
name_text.setBackground(QtGui.QColor(*self.light_grey))
self.checks.append(check)
self.names_text.append(name_text)
def addDictionnary(self):
fn = QFileDialog.getOpenFileName(self, self.tr("Select your dictionnary"), os.path.expanduser('~'))
if fn != "":
ufn = str(unicode(fn).encode('utf-8'))
dicname = self.autoDicName(ufn)
if dicname != None:
currow = self.dicos.rowCount()
self.dicos.setRowCount(currow + 1)
item = QTableWidgetItem(QString.fromUtf8(ufn))
item.setFlags(Qt.ItemIsUserCheckable|Qt.ItemIsEnabled|Qt.ItemIsSelectable)
item.setCheckState(Qt.Unchecked)
self.dicos.setItem(currow, 0, item)
name = QTableWidgetItem(QString.fromUtf8(dicname))
name.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.dicos.setItem(currow, 1, name)
dict_ = FileDictionnary(ufn)
dict_.thisown = False
try:
self.manager.add(dicname, dict_)
except RuntimeError:
print "Error adding new dictionnary"
def populateFieldTable(self):
if self.collectedDataDict:
importingFields = self.collectedDataDict[0].keys()
self.fieldTable.clear()
self.fieldTable.setRowCount(len(importingFields))
predefinedFields = ['EOMETRY','ODKUUID']
for row,field in enumerate(importingFields):
enabledItem = QTableWidgetItem()
enabledItem.setFlags(enabledItem.flags() | Qt.ItemIsUserCheckable)
enabledItem.setText("")
self.fieldTable.setItem(row,0,enabledItem)
ODKfieldItem = QTableWidgetItem()
ODKfieldItem.setText(field)
self.fieldTable.setItem(row,1,ODKfieldItem)
self.fieldTable.setRowHeight(row,30)
QGISfieldItem = QTableWidgetItem()
if slugify(field) in self.fieldMapping:
QGISfieldItem.setText(self.fieldMapping[slugify(field)])
enabledItem.setCheckState(Qt.Checked)
else:
QGISfieldItem.setText("")
enabledItem.setCheckState(Qt.Unchecked)
self.fieldTable.setItem(row,2,QGISfieldItem)
if field[-7:] in predefinedFields: #prevent predefined fields user editing
if field[-7:] == 'ODKUUID':
ODKfieldItem.setText('ODKUUID')
enabledItem.setCheckState(Qt.Checked)
enabledItem.setFlags(enabledItem.flags() & Qt.ItemIsEditable)
ODKfieldItem.setFlags(ODKfieldItem.flags() & Qt.ItemIsEditable)
QGISfieldItem.setFlags(QGISfieldItem.flags() & Qt.ItemIsEditable)
def onRemoveClicked(self):
if len(self.removeList) == 0:
QMessageBox.information(self, 'Remove Sentences',
'Select the Sentences to Delete')
else:
reply = QMessageBox.question(self,
'Remove Sentences',
'You want to delete the selected sentences',
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
for sentence in self.removeList:
if sentence in self.sentenceList:
self.sentenceList.remove(sentence)
## clear the contents of the Table
self.sentenceTable.clearContents()
cellList = []
## Add the new entries into the table
for sentence in self.sentenceList:
item = QTableWidgetItem(QString(sentence))
item.setFlags(Qt.ItemFlags(Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable | Qt.ItemIsEnabled))
item.setCheckState(Qt.Unchecked)
cellList.append(item)
cellList.reverse()
for index in range(0, len(self.sentenceList)):
self.sentenceTable.setItem(index, self.col, cellList.pop())
self.sentenceTable.setRowCount(len(self.sentenceList))
deleteSentences = []
for sentence in self.removeList.values():
deleteSentences.append(sentence)
rowsDeletec = data.Data().deleteSentencesFromDatabase(deleteSentences)
self.getSentencesFromDatabase()
self.removeList = {}
def __init__(self, parent):
QDialog.__init__(self, parent)
# Set up the user interface from Designer.
self.ui = ui = Ui_SettingsDialog()
ui.setupUi(self)
ui.lineEdit_BrowserPath.setPlaceholderText("Leave this empty to use your default browser")
ui.toolButton_Browse.clicked.connect(self.browseClicked)
# load settings
settings = QSettings()
ui.lineEdit_BrowserPath.setText(settings.value("/Qgis2threejs/browser", "", type=unicode))
enabled_plugins = QSettings().value("/Qgis2threejs/plugins", "", type=unicode).split(",")
# initialize plugin table widget
plugin_dir = QDir(os.path.join(os.path.dirname(QFile.decodeName(__file__)), "plugins"))
plugins = plugin_dir.entryList(QDir.Dirs | QDir.NoSymLinks | QDir.NoDotAndDotDot)
tableWidget = ui.tableWidget_Plugins
tableWidget.setRowCount(len(plugins))
tableWidget.setColumnCount(1)
tableWidget.setHorizontalHeaderLabels(["Name"])
tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
headerView = tableWidget.horizontalHeader()
headerView.setResizeMode(0, QHeaderView.Stretch)
self.plugin_metadata = []
for i, name in enumerate(plugins):
parser = ConfigParser.SafeConfigParser()
with codecs.open(os.path.join(plugin_dir.absoluteFilePath(name), "metadata.txt"), "r", "UTF-8") as f:
parser.readfp(f)
metadata = dict(parser.items("general"))
self.plugin_metadata.append(metadata)
item = QTableWidgetItem(metadata.get("name", name))
item.setCheckState(Qt.Checked if name in enabled_plugins else Qt.Unchecked)
tableWidget.setItem(i, 0, item)
tableWidget.selectionModel().currentRowChanged.connect(self.pluginSelectionChanged)
def set_data(plugins, table):
table.setHorizontalHeaderLabels(["Name", "Version", "Description"])
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in xrange(table.rowCount()):
table.removeRow(0)
r = 0
for plug in plugins:
table.insertRow(r)
# Column 2
item = QTableWidgetItem(plug[1])
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
table.setItem(r, 2, item)
# Column 1
item = QTableWidgetItem(plug[2])
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
table.setItem(r, 1, item)
# Column 0
item = QTableWidgetItem(plug[0])
table.setItem(r, 0, item)
item.setCheckState(Qt.Unchecked)
r += 1
def addNodeInIndexList(self, index):
"""
Add the node wich pointer is index.data(QT.UserRole + 1) in the
indexedItems list.
"""
# get the node from the index
node_ptr = self.selectIndexItems.model().data(index, Qt.UserRole + 1)
if not node_ptr.isValid():
return
added_node = VFS.Get().getNodeFromPointer(node_ptr.toULongLong()[0])
# add the node.this into the selected items list
new_item = QTableWidgetItem(QIcon(":/folder.png"), added_node.name())
new_item.setData(Qt.UserRole + 1, QVariant(long(added_node.this)))
self.tmp_indexed_items[long(added_node.this)] = False
new_checkbox = QTableWidgetItem(1);
new_checkbox.data(Qt.CheckStateRole);
new_checkbox.setCheckState(Qt.Unchecked);
self.indexedItems.insertRow(0)
self.indexedItems.setItem(0, 0, new_item)
self.indexedItems.setItem(0, 1, new_checkbox)
def displayRows(self, observations):
self.clearContents()
for r in range(self.rowCount() - 1, -1, -1):
self.removeRow(r)
for r, obs in enumerate(observations):
# obs is a QgsFeature, translate it to a dict
dataDict = {"type": obs["type"], "x": obs["x"], "y": obs["y"],
"observation": obs["observation"], "precision": obs["precision"]}
self.insertRow(r)
# type
item = QTableWidgetItem(obs["type"])
item.setData(Qt.UserRole, dataDict)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
self.setItem(r, 0, item)
# observation
item = QTableWidgetItem("%.4f" % obs["observation"])
item.setFlags(Qt.ItemIsEnabled)
self.setItem(r, 1, item)
# precision
item = QTableWidgetItem("%.4f" % obs["precision"])
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.setItem(r, 2, item)
self.adjustSize()
def populateFieldTable(self):
if self.collectedDataDict:
importingFields = self.collectedDataDict[0].keys()
self.fieldTable.clear()
self.fieldTable.setRowCount(len(importingFields))
predefinedFields = ['EOMETRY','UUID']
for row,field in enumerate(importingFields):
enabledItem = QTableWidgetItem()
enabledItem.setFlags(enabledItem.flags() | Qt.ItemIsUserCheckable)
enabledItem.setText("")
self.fieldTable.setItem(row,0,enabledItem)
ODKfieldItem = QTableWidgetItem()
ODKfieldItem.setText(field)
self.fieldTable.setItem(row,1,ODKfieldItem)
self.fieldTable.setRowHeight(row,30)
QGISfieldItem = QTableWidgetItem()
# try to guess field mapping
QGISfieldItem.setText("")
enabledItem.setCheckState(Qt.Unchecked)
for fieldOrigin, FieldDest in self.fieldMapping.iteritems():
if fieldOrigin in slugify(field):
QGISfieldItem.setText(FieldDest)
enabledItem.setCheckState(Qt.Checked)
break
'''
if slugify(field) in self.fieldMapping:
QGISfieldItem.setText(self.fieldMapping[slugify(field)])
enabledItem.setCheckState(Qt.Checked)
else:
QGISfieldItem.setText("")
enabledItem.setCheckState(Qt.Unchecked)
'''
self.fieldTable.setItem(row,2,QGISfieldItem)
for predef in predefinedFields:
if predef in field.upper(): #prevent predefined fields user editing
if predef == 'UUID':
ODKfieldItem.setText(field)
QGISfieldItem.setText('ODKUUID')
elif predef == 'EOMETRY':
ODKfieldItem.setText('GEOMETRY')
QGISfieldItem.setText('GEOMETRY')
enabledItem.setCheckState(Qt.Checked)
enabledItem.setFlags(enabledItem.flags() & Qt.ItemIsEditable)
ODKfieldItem.setFlags(ODKfieldItem.flags() & Qt.ItemIsEditable)
QGISfieldItem.setFlags(QGISfieldItem.flags() & Qt.ItemIsEditable)
def load(self, error=True):
s = QSettings( "norBIT", "norGIS-ALKIS-Erweiterung" )
s.setValue( "service", self.leSERVICE.text() )
s.setValue( "host", self.leHOST.text() )
s.setValue( "port", self.lePORT.text() )
s.setValue( "dbname", self.leDBNAME.text() )
s.setValue( "uid", self.leUID.text() )
s.setValue( "pwd", self.lePWD.text() )
if hasattr(qgis.gui,'QgsAuthConfigSelect'):
s.setValue( "authcfg", self.authCfgSelect.configId() )
self.twModellarten.clearContents()
self.cbxSignaturkatalog.clear()
modelle = s.value( "modellarten", ['DLKM','DKKM1000'] )
if modelle is None:
modelle = ['DLKM','DKKM1000']
(db,conninfo) = self.plugin.opendb()
if not db:
if error:
QMessageBox.critical( None, "ALKIS", u"Datenbankverbindung schlug fehl." )
return
qry = QSqlQuery(db)
if qry.exec_( """
SELECT modell,count(*)
FROM (
SELECT unnest(modell) AS modell FROM po_points UNION ALL
SELECT unnest(modell) AS modell FROM po_lines UNION ALL
SELECT unnest(modell) AS modell FROM po_polygons UNION ALL
SELECT unnest(modell) AS modell from po_lines UNION ALL
SELECT unnest(modell) AS modell from po_labels
) AS foo
GROUP BY modell
ORDER BY count(*) DESC
""" ):
res = {}
while qry.next():
res[ qry.value(0) ] = qry.value(1)
self.twModellarten.setRowCount( len(res) )
i = 0
for k,n in sorted(res.iteritems(), key=operator.itemgetter(1), reverse=True):
item = QTableWidgetItem( k )
item.setCheckState( Qt.Checked if (item.text() in modelle) else Qt.Unchecked )
self.twModellarten.setItem( i, 0, item )
item = QTableWidgetItem( str(n) )
self.twModellarten.setItem( i, 1, item )
i += 1
self.twModellarten.resizeColumnsToContents()
self.twModellarten.setEnabled( True )
else:
modelle = []
self.twModellarten.clearContents()
self.twModellarten.setDisabled( True )
if qry.exec_( "SELECT id,name FROM alkis_signaturkataloge" ):
while qry.next():
self.cbxSignaturkatalog.addItem( qry.value(1), int(qry.value(0)) )
self.cbxSignaturkatalog.setEnabled( True )
else:
self.cbxSignaturkatalog.addItem( u"Farbe", -1 )
self.cbxSignaturkatalog.setCurrentIndex( max( [ 0, self.cbxSignaturkatalog.findData( s.value( "signaturkatalog", -1 ) ) ] ) )
def saveParameters(self):
self.updateDistricts()
layers = self.iface.legendInterface().layers()
selectedLayerIndex = self.dlgparameters.cmbActiveLayer.currentIndex()
selectedLayer = layers[selectedLayerIndex]
self.activeLayer = selectedLayer
self.districts = self.dlgparameters.inpDistricts.value()
self.activedistrict = 1
self.dockwidget.lblActiveDistrict.setText("Active District: " +
str(self.activedistrict))
self.dockwidget.sliderDistricts.setMinimum(1)
self.dockwidget.sliderDistricts.setMaximum(self.districts)
self.dockwidget.sliderDistricts.setValue(1)
self.popfield = self.dlgparameters.cmbPopField.currentText()
self.distfield = self.dlgparameters.cmbDistField.currentText()
# self.dispfield1 = self.dlgparameters.cmbDispField1.currentText()
# self.dispfield2 = self.dlgparameters.cmbDispField1.currentText()
QgsMessageLog.logMessage("Popfield:" + str(self.popfield))
self.totalpop = 0
self.targetpop = 0
for feature in self.activeLayer.getFeatures():
self.totalpop = self.totalpop + feature[self.popfield]
self.targetpop = int(self.totalpop / self.districts)
self.targetpoppct = self.dlgparameters.inpTolerance.value()
targetpoprem = int((self.targetpop / 100) * self.targetpoppct)
self.targetpoplower = int(self.targetpop - targetpoprem)
self.targetpophigher = int(self.targetpop + targetpoprem + 1)
QgsMessageLog.logMessage("TargetPop:" + str(self.targetpop) + "(" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
QgsMessageLog.logMessage("Districts:" + str(self.districts))
self.dockwidget.lblMainInfo.setText("Active Layer: " +
self.activeLayer.name() +
"\nActive District Field: " +
self.distfield +
"\nTarget Population: " +
str(self.targetpop) + " (" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
self.attrdockwidget.tblPop.setRowCount(self.districts + 1)
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
2 + numDataFields, QTableWidgetItem(d.name))
self.attrdockwidget.tblPop.setColumnCount(4 + numDataFields)
for r in range(0, self.districts + 1):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
self.attrdockwidget.tblPop.setItem(r, 1, chkBoxItem)
self.attrdockwidget.tblPop.setHorizontalHeaderLabels(
['#', 'Lock', 'Population', 'To Target'])
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
if d.type == 1:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name))
else:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name + '%'))
if len(districtName) == 0:
self.initializeElectorates()
try:
self.saveParametersToFile()
QgsMessageLog.logMessage("Parameters file saved!")
except:
QgsMessageLog.logMessage("Parameters file could not be saved")
if self.dlgparameters.chkStyleMap.isChecked():
categories = []
for cat in range(0, self.districts + 1):
symbol = QgsSymbolV2.defaultSymbol(
self.activeLayer.geometryType())
layer_style = {}
layer_style['color'] = '%d, %d, %d' % (randrange(
0, 256), randrange(0, 256), randrange(0, 256))
layer_style['outline'] = '#000000'
symbol_layer = QgsSimpleFillSymbolLayerV2.create(layer_style)
# replace default symbol layer with the configured one
if symbol_layer is not None:
symbol.changeSymbolLayer(0, symbol_layer)
# create renderer object
category = QgsRendererCategoryV2(cat, symbol, str(cat))
# entry for the list of category items
categories.append(category)
renderer = QgsCategorizedSymbolRendererV2(self.distfield,
categories)
# assign the created renderer to the layer
if renderer is not None:
self.activeLayer.setRendererV2(renderer)
self.activeLayer.triggerRepaint()
self.updateFieldValues()
self.updateTable()
self.updateLockedFields()
self.updateDistricts()
def _item(self, content, is_checkable):
item = QTableWidgetItem(content)
if is_checkable:
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsSelectable)
return item
def view(self):
"""create view and import layers"""
layer = QgsMapLayerRegistry.instance().mapLayer(
self.current_layers[0] )
uri = QgsDataSourceURI(layer.source())
mtch = re.match(r'(.+)_([^_]+)_rev_(head|\d+)', uri.schema())
schema = mtch.group(1)
assert(schema)
dlg = QDialog()
layout = QVBoxLayout(dlg)
button_box = QDialogButtonBox(dlg)
button_box.setStandardButtons(
QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
button_box.accepted.connect(dlg.accept)
button_box.rejected.connect(dlg.reject)
user_msg1 = QgsMessageBar(dlg)
user_msg1.pushInfo("Select:", "one [many] for single [multiple] "
"revisions. Fetching may take time.")
pcur = versioning_base.Db( psycopg2.connect(self.pg_conn_info()) )
pcur.execute("SELECT rev, commit_msg, branch, date, author "
"FROM "+schema+".revisions")
revs = pcur.fetchall()
pcur.close()
tblw = QTableWidget( dlg )
tblw.setRowCount(len(revs))
tblw.setColumnCount(6)
tblw.setSortingEnabled(True)
tblw.setHorizontalHeaderLabels(['Select','Revision', 'Commit Message',
'Branch', 'Date', 'Author'])
tblw.verticalHeader().setVisible(False)
for i, rev in enumerate(revs):
for j, item in enumerate(rev):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
tblw.setItem(i, 0, chkBoxItem)
tblw.setItem(i, j+1, QTableWidgetItem( str(item) ))
layout.addWidget( user_msg1 )
layout.addWidget( tblw )
layout.addWidget( button_box )
dlg.resize( 650, 300 )
if not dlg.exec_() :
return
rows = set()
revision_number_list = []
for i in range(len(revs)):
if tblw.item(i,0).checkState():
print "Revision "+ str(i + 1) +" will be fetched"
revision_number_list.append(i + 1)
rows.add(tblw.item(i,0).row())
progressMessageBar = self.iface.messageBar().createMessage("Querying "
"the database for revision(s) "+str(revision_number_list))
progress = QProgressBar()
progress.setMaximum(len(rows))
progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, self.iface.messageBar().INFO)
progress.setValue(0)
for i, row in enumerate(rows):
progress.setValue(i+1)
branch = revs[row][2]
rev = revs[row][0]
versioning_base.add_revision_view(uri.connectionInfo(),
schema, branch, rev )
grp_name = branch+' revision '+str(rev)
grp_idx = self.iface.legendInterface().addGroup( grp_name )
for layer_id in reversed(self.current_layers):
layer = QgsMapLayerRegistry.instance().mapLayer(layer_id)
new_uri = QgsDataSourceURI(layer.source())
new_uri.setDataSource(schema+'_'+branch+'_rev_'+str(rev),
new_uri.table(),
new_uri.geometryColumn(),
new_uri.sql(),
new_uri.keyColumn())
display_name = QgsMapLayerRegistry.instance().mapLayer(layer_id).name()
src = new_uri.uri().replace('()','')
new_layer = self.iface.addVectorLayer( src,
display_name, 'postgres')
self.iface.legendInterface().moveLayer( new_layer, grp_idx)
self.iface.messageBar().clearWidgets()
def view(self):
"""create view and import layers"""
layer = QgsMapLayerRegistry.instance().mapLayer(self.current_layers[0])
uri = QgsDataSourceURI(layer.source())
mtch = re.match(r'(.+)_([^_]+)_rev_(head|\d+)', uri.schema())
schema = mtch.group(1)
assert (schema)
dlg = QDialog()
layout = QVBoxLayout(dlg)
button_box = QDialogButtonBox(dlg)
button_box.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
button_box.accepted.connect(dlg.accept)
button_box.rejected.connect(dlg.reject)
user_msg1 = QgsMessageBar(dlg)
user_msg1.pushInfo(
"Select:", "one [many] for single [multiple] "
"revisions. Fetching may take time.")
pcur = versioning_base.Db(psycopg2.connect(self.pg_conn_info()))
pcur.execute("SELECT rev, commit_msg, branch, date, author "
"FROM " + schema + ".revisions")
revs = pcur.fetchall()
pcur.close()
tblw = QTableWidget(dlg)
tblw.setRowCount(len(revs))
tblw.setColumnCount(6)
tblw.setSortingEnabled(True)
tblw.setHorizontalHeaderLabels([
'Select', 'Revision', 'Commit Message', 'Branch', 'Date', 'Author'
])
tblw.verticalHeader().setVisible(False)
for i, rev in enumerate(revs):
for j, item in enumerate(rev):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
tblw.setItem(i, 0, chkBoxItem)
tblw.setItem(i, j + 1, QTableWidgetItem(str(item)))
layout.addWidget(user_msg1)
layout.addWidget(tblw)
layout.addWidget(button_box)
dlg.resize(650, 300)
if not dlg.exec_():
return
rows = set()
revision_number_list = []
for i in range(len(revs)):
if tblw.item(i, 0).checkState():
print "Revision " + str(i + 1) + " will be fetched"
revision_number_list.append(i + 1)
rows.add(tblw.item(i, 0).row())
progressMessageBar = self.iface.messageBar().createMessage(
"Querying "
"the database for revision(s) " + str(revision_number_list))
progress = QProgressBar()
progress.setMaximum(len(rows))
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar,
self.iface.messageBar().INFO)
progress.setValue(0)
for i, row in enumerate(rows):
progress.setValue(i + 1)
branch = revs[row][2]
rev = revs[row][0]
versioning_base.add_revision_view(uri.connectionInfo(), schema,
branch, rev)
grp_name = branch + ' revision ' + str(rev)
grp_idx = self.iface.legendInterface().addGroup(grp_name)
for layer_id in reversed(self.current_layers):
layer = QgsMapLayerRegistry.instance().mapLayer(layer_id)
new_uri = QgsDataSourceURI(layer.source())
new_uri.setDataSource(
schema + '_' + branch + '_rev_' + str(rev),
new_uri.table(), new_uri.geometryColumn(), new_uri.sql(),
new_uri.keyColumn())
display_name = QgsMapLayerRegistry.instance().mapLayer(
layer_id).name()
src = new_uri.uri().replace('()', '')
new_layer = self.iface.addVectorLayer(src, display_name,
'postgres')
self.iface.legendInterface().moveLayer(new_layer, grp_idx)
self.iface.messageBar().clearWidgets()
def setSnapshotTable(self, data, table, eventid):
if data:
length = len(data.values()[0])
else:
print ('data is empty, exit.')
return
for i in range(1, len(data.values())):
if length != len(data.values()[i]):
QMessageBox.warning(self,
"Warning",
"Data length are not consistent.")
return
if isinstance(data, odict) and isinstance(table, QTableWidget):
table.setSortingEnabled(False)
table.clear()
nrows = len(data.values()[0])
# ('pv name label', 'dbr_type label', 'string value', 'int value', 'double value', 'status label', 'severity label',
# 'ioc time stamp label', 'ioc time stamp nano label', 'is_array', 'array_value'),
# => (pv_name, status, severity, ioc_timestamp, saved value)
# ncols = len(data) - 6
# ncols = ncols + 3 # 2 columns for live data and (live data - saved data), selected restore pv
ncols = len(data) - 3
table.setRowCount(nrows)
table.setColumnCount(ncols)
pvnames = data['PV Name']
status = data['Status']
severity = data['Severity']
ts = data['Time stamp']
ts_nano = data['Time stamp (nano)']
dbrtype = data['DBR']
s_value = data['S_value']
i_value = data['I_value']
d_value = data['D_value']
isConnected = data['isConnected']
is_array = data['isArray']
array_value = data['arrayValue']
keys = ['Name', 'Status', 'Severity', 'Time Stamp', 'Connection', 'Saved Value', 'Live Value', 'Delta', 'Not Restore']
table.setHorizontalHeaderLabels(keys)
for i in range(nrows):
item = table.item(i, 8)
if item:
item.setCheckState(False)
else:
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsUserCheckable)
table.setItem(i, 8, item)
item.setCheckState(False)
if pvnames[i]:
self.__setTableItem(table, i, 0, pvnames[i])
if status[i]:
self.__setTableItem(table, i, 1, str(status[i]))
if severity[i]:
self.__setTableItem(table, i, 2, str(severity[i]))
if ts[i]:
dt = str(datetime.datetime.fromtimestamp(ts[i]+ts_nano[i]*1.0e-9))
self.__setTableItem(table, i, 3, dt)
if is_array[i]:
self.__setTableItem(table, i, 5, self.__arrayTextFormat(array_value[i]))
self.arrayData[pvnames[i]+'_'+str(eventid)] = array_value[i]
else:
if dbrtype[i] in self.epicsDouble:
self.__setTableItem(table, i, 5, str(d_value[i]))
elif dbrtype[i] in self.epicsLong:
self.__setTableItem(table, i, 5, str(i_value[i]))
elif dbrtype[i] in self.epicsString:
self.__setTableItem(table, i, 5, str(s_value[i]))
elif dbrtype[i] in self.epicsNoAccess:
# channel are not connected.
pass
else:
print('invalid dbr type (code = %s)'%(dbrtype[i]))
if isConnected[i]:
self.__setTableItem(table, i, 4, str(bool(isConnected[i])))
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
else:
self.__setTableItem(table, i, 4, 'False')
item.setCheckState(True)
item.setSelected(True)
# disable user checkable function
item.setFlags(item.flags() ^ Qt.ItemIsUserCheckable)
for item_idx in range(9):
itemtmp = table.item(i, item_idx)
if not itemtmp:
itemtmp = QTableWidgetItem()
table.setItem(i, item_idx, itemtmp)
itemtmp.setBackground(self.brushbadpv)
table.setSortingEnabled(True)
else:
raise "Either given data is not an instance of OrderedDict or table is not an instance of QtGui.QTableWidget"
def _item(self, content, is_checkable):
item = QTableWidgetItem(str(content))
if is_checkable:
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsSelectable)
return item
