class LabControl(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
# self.ui=uic.loadUi("mainwindow.ui",self)
self.DelayStageDock = QDockWidget("DelayStage", self)
self.DelayStageDock.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.DelayStageDock.setWidget(DelayStageWidget(self))
self.DelayStageDock.widget().setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.addDockWidget(Qt.TopDockWidgetArea, self.DelayStageDock)
self.DelayStageDock.widget().delaystage.throwMessage.connect(self.getMessage)
def on_actionDelayStage_triggered(self):
self.close()
def getMessage(self, text, level):
print (text)
class LabControl(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
#self.ui=uic.loadUi("mainwindow.ui",self)
self.DelayStageDock=QDockWidget("DelayStage",self)
self.DelayStageDock.setSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed)
self.DelayStageDock.setWidget(DelayStageWidget(self))
self.DelayStageDock.widget().setSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed)
self.addDockWidget(Qt.TopDockWidgetArea,self.DelayStageDock)
self.DelayStageDock.widget().delaystage.throwMessage.connect(self.getMessage)
def on_actionDelayStage_triggered(self):
self.close()
def getMessage(self,text,level):
print(text)
class PluginManualIntegrator(MSPlugin):
def __init__(self, model, view, parent=None):
MSPlugin.__init__(self, model, view, parent)
#self.connect(self.view.mdiArea, SIGNAL('subWindowActivated(QMdiSubWindow*)'), self.updateCurrentWindow)
self.guiWidget = []
self.view.mdiArea.subWindowActivated.connect(self.updateCurrentWindow)
self.x1val = 0
self.dock = QDockWidget("Manual Integrator")
self.guiWidget.append(self.dock)
self.window = self.view.mdiArea.activeSubWindow(
) if self.view.mdiArea.activeSubWindow() else None
if self.window is not None:
#self.connect(self.window.widget().pw,
# SIGNAL(self.window.widget().pw.sigMouseReleased),
# self.pluginAlgorithm)
self.window.widget().pw.plotItem.vb.sigClick.connect(
self.pluginAlgorithm)
self.label = QLabel('Inactive') if not self.window else QLabel(
'Active')
self.dock.setWidget(self.label)
self._guiUpdate()
def _guiUpdate(self):
self.view.addDockWidget(
0x1, self.dock
) #showInformationMessage('test', "Hello From Integrator Plugin")
def _buildConnections(self):
pass
def updateCurrentWindow(self, win):
if win is None: return
#print "update current window", win
self.window = win
#self.connect(self.window.widget().pw,
# SIGNAL(self.window.widget().pw.sigMouseReleased),
# self.pluginAlgorithm)
self.window.widget().pw.plotItem.vb.sigClick.connect(
self.pluginAlgorithm)
self.dock.setWidget(Widget(self.dock))
def pluginAlgorithm(self, e):
"""
receive the event off release MouseEvent
"""
if not self.x1val:
self.x1val = e.x()
self.dock.widget().x1.setText(str(self.x1val))
self.dock.widget().x2.setText('')
self.dock.widget().result.setText('')
return
x2 = e.x()
self.dock.widget().x2.setText(str(x2))
chrom = self.window.widget().data[0] #take the first one
res = chrom.integrationBtw(self.x1val, x2)
self.dock.widget().result.setText(",success:".join(
[str(res[2]), str(res[3])]))
self.x1val = 0
#self.reinitialize()
def reinitialize(self):
self.x1val = 0
self.dock.widget().x2.setText('')
self.dock.widget().x1.setText('')
def unload(self):
for e in self.guiWidget:
e.setParent(None)
del e
self.view.update()
class ComposerWrapper(QObject):
"""
Embeds custom STDM tools in a QgsComposer instance for managing map-based
STDM document templates.
"""
dataSourceSelected = pyqtSignal(str)
def __init__(self, composerView, iface):
QObject.__init__(self, composerView)
self._compView = composerView
self._stdmTB = self.mainWindow().addToolBar("STDM")
self._selectMoveAction = None
self._iface = iface
#Container for custom editor widgets
self._widgetMappings = {}
#Hide default dock widgets
if not self.itemDock() is None:
self.itemDock().hide()
if not self.atlasDock() is None:
self.atlasDock().hide()
if not self.generalDock() is None:
self.generalDock().hide()
#Create dock widget for configuring STDM data source
self._stdmDataSourceDock = QDockWidget(
QApplication.translate("ComposerWrapper","STDM Data Source"),
self.mainWindow())
self._stdmDataSourceDock.setObjectName("STDMDataSourceDock")
self._stdmDataSourceDock.setMinimumWidth(300)
self._stdmDataSourceDock.setFeatures(QDockWidget.DockWidgetMovable|QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,
self._stdmDataSourceDock)
self._dataSourceWidget = ComposerDataSourceSelector()
self._stdmDataSourceDock.setWidget(self._dataSourceWidget)
self._stdmDataSourceDock.show()
#Re-insert dock widgets
if not self.generalDock() is None:
self.generalDock().show()
if not self.itemDock() is None:
self.itemDock().show()
#Create dock widget for configuring STDM item properties
self._stdmItemPropDock = QDockWidget(
QApplication.translate("ComposerWrapper","STDM item properties"),
self.mainWindow())
self._stdmItemPropDock.setObjectName("STDMItemDock")
self._stdmItemPropDock.setMinimumWidth(300)
self._stdmItemPropDock.setFeatures(QDockWidget.DockWidgetMovable|QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,self._stdmItemPropDock)
self._stdmItemPropDock.show()
#Re-arrange dock widgets and push up STDM data source dock widget
if not self.generalDock() is None:
self.mainWindow().splitDockWidget(self._stdmDataSourceDock,
self.generalDock(),Qt.Vertical)
if not self.itemDock() is None:
self.mainWindow().splitDockWidget(self._stdmDataSourceDock,
self.itemDock(),Qt.Vertical)
if not self.generalDock() is None:
self.mainWindow().tabifyDockWidget(self.generalDock(),
self.itemDock())
if not self.itemDock() is None:
self.mainWindow().splitDockWidget(self.itemDock(),
self._stdmItemPropDock,
Qt.Vertical)
#Set focus on composition properties window
if not self.generalDock() is None:
self.generalDock().activateWindow()
self.generalDock().raise_()
#Connect signals
self.composition().itemRemoved.connect(self._onItemRemoved)
self._dataSourceWidget.cboDataSource.currentIndexChanged[str].connect(
self.propagateDataSourceSelection
)
self.composerView().selectedItemChanged.connect(self._onItemSelected)
#Current template document file
self._currDocFile = None
def _removeActions(self):
"""
Remove inapplicable actions and their corresponding toolbars and menus.
"""
removeActions = ["mActionSaveProject","mActionNewComposer","mActionDuplicateComposer"]
composerToolbar = self.composerMainToolBar()
if composerToolbar != None:
saveProjectAction = None
for itemAction in composerToolbar.actions():
if itemAction.objectName() == "mActionSaveProject":
saveProjectAction = itemAction
break
if saveProjectAction != None:
composerMenu = saveProjectAction.menu()
def configure(self):
#Create instances of custom STDM composer item configurations
for ciConfig in ComposerItemConfig.itemConfigurations:
ciConfigObj = ciConfig(self)
def addWidgetMapping(self,uniqueIdentifier,widget):
"""
Add custom STDM editor widget based on the unique identifier of the composer item
"""
self._widgetMappings[uniqueIdentifier] = widget
def widgetMappings(self):
"""
Returns a dictionary containing uuid values of composer items linked to STDM widgets.
"""
return self._widgetMappings
def clearWidgetMappings(self):
"""
Resets the widget mappings collection.
"""
self._widgetMappings = {}
def mainWindow(self):
"""
Returns the QMainWindow used by the composer view.
"""
return self._compView.composerWindow()
def stdmToolBar(self):
"""
Returns the instance of the STDM toolbar added to the QgsComposer.
"""
return self._stdmTB
def composerView(self):
"""
Returns the composer view.
"""
return self._compView
def composition(self):
"""
Returns the QgsComposition instance used in the composer view.
"""
return self._compView.composition()
def composerItemToolBar(self):
"""
Returns the toolbar containing actions for adding composer items.
"""
return self.mainWindow().findChild(QToolBar,"mItemToolbar")
def composerMainToolBar(self):
"""
Returns the toolbar containing actions for managing templates.
"""
return self.mainWindow().findChild(QToolBar,"mComposerToolbar")
def selectMoveAction(self):
"""
Returns the QAction for selecting or moving composer items.
"""
if self.composerItemToolBar() != None:
if self._selectMoveAction == None:
for itemAction in self.composerItemToolBar().actions():
if itemAction.objectName() == "mActionSelectMoveItem":
self._selectMoveAction = itemAction
break
return self._selectMoveAction
def checkedItemAction(self):
"""
Returns the currently selected composer item action.
"""
if self.selectMoveAction() != None:
return self.selectMoveAction().actionGroup().checkedAction()
return None
def itemDock(self):
"""
Get the 'Item Properties' dock widget.
"""
return self.mainWindow().findChild(QDockWidget,"ItemDock")
def atlasDock(self):
"""
Get the 'Atlas generation' dock widget.
"""
return self.mainWindow().findChild(QDockWidget,"AtlasDock")
def generalDock(self):
"""
Get the 'Composition' dock widget.
"""
return self.mainWindow().findChild(QDockWidget,"CompositionDock")
def stdmDataSourceDock(self):
"""
Returns the STDM data source dock widget.
"""
return self._stdmDataSourceDock
def stdmItemDock(self):
"""
Returns the STDM item dock widget.
"""
return self._stdmItemPropDock
def documentFile(self):
"""
Returns the QFile instance associated with the current document. 'None' will be returned for
new, unsaved documents.
"""
return self._currDocFile
def setDocumentFile(self,docFile):
"""
Sets the document file.
"""
if not isinstance(docFile,QFile):
return
self._currDocFile = docFile
def selectedDataSource(self):
"""
Returns the name of the data source specified by the user.
"""
return self._stdmDataSourceDock.widget().cboDataSource.currentText()
def selectedDataSourceCategory(self):
"""
Returns the category (view or table) that the data source belongs to.
"""
if self.stdmDataSourceDock().widget() != None:
return self.stdmDataSourceDock().widget().category()
return ""
def propagateDataSourceSelection(self, dataSourceName):
"""
Propagates the signal when a user select a data source. Listening objects can hook on to it.
"""
self.dataSourceSelected.emit(dataSourceName)
def composer_items(self):
"""
:return: Returns a list of custom composer items.
:rtype: list
"""
return [self.composition().getComposerItemById(uuid) for uuid in self._widgetMappings.keys()
if not self.composition().getComposerItemById(uuid) is None]
def _clear_composition(self):
"""
Removes composer items which, otherwise, are causing QGIS to crash
when loading a subsequent document template.
"""
items = self.composition().items()
for c_item in items:
if isinstance(c_item, QgsComposerItem) and not isinstance(c_item, QgsPaperItem):
if c_item.uuid() in self._widgetMappings:
#Remove corresponding widget as well as reference in the collection
del self._widgetMappings[c_item.uuid()]
self.composition().removeItem(c_item)
self.composition().itemRemoved.emit(c_item)
del c_item
self.composition().undoStack().clear()
self.composition().itemsModel().clear()
def create_new_document_designer(self, file_path):
"""
Creates a new document designer and loads the document template
defined in file path.
:param file_path: Path to document template
:type file_path: str
"""
document_designer = self._iface.createNewComposer("STDM Document Designer")
#Embed STDM customizations
cw = ComposerWrapper(document_designer, self._iface)
cw.configure()
#Load template
cw.loadTemplate(file_path)
def loadTemplate(self, filePath):
"""
Loads a document template into the view and updates the necessary STDM-related composer items.
"""
if not QFile.exists(filePath):
QMessageBox.critical(self.composerView(),
QApplication.translate("OpenTemplateConfig",
"Open Template Error"),
QApplication.translate("OpenTemplateConfig",
"The specified template does not exist."))
return
templateFile = QFile(filePath)
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(self.composerView(),
QApplication.translate("ComposerWrapper",
"Open Operation Error"),
"{0}\n{1}".format(QApplication.translate(
"ComposerWrapper",
"Cannot read template file."),
templateFile.errorString()
))
return
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
table_config_collection = TableConfigurationCollection.create(templateDoc)
'''
First load vector layers for the table definitions in the config
collection before loading rhe composition from file.
'''
load_table_layers(table_config_collection)
#Load items into the composition and configure STDM data controls
self.composition().loadFromTemplate(templateDoc)
self.clearWidgetMappings()
#Load data controls
composerDS = ComposerDataSource.create(templateDoc)
#Set title by appending template name
title = QApplication.translate("STDMPlugin", "STDM Document Designer")
composer_el = templateDoc.documentElement()
if not composer_el is None:
template_name = ""
if composer_el.hasAttribute("title"):
template_name = composer_el.attribute("title", "")
elif composer_el.hasAttribute("_title"):
template_name = composer_el.attribute("_title", "")
if template_name:
win_title = u"{0} - {1}".format(title, template_name)
self.mainWindow().setWindowTitle(template_name)
self._configure_data_controls(composerDS)
#Load symbol editors
spatialFieldsConfig = SpatialFieldsConfiguration.create(templateDoc)
self._configureSpatialSymbolEditor(spatialFieldsConfig)
#Load photo editors
photo_config_collection = PhotoConfigurationCollection.create(templateDoc)
self._configure_photo_editors(photo_config_collection)
#Load table editors
self._configure_table_editors(table_config_collection)
#Load chart property editors
chart_config_collection = ChartConfigurationCollection.create(templateDoc)
self._configure_chart_editors(chart_config_collection)
self._sync_ids_with_uuids()
def saveTemplate(self):
"""
Creates and saves a new document template.
"""
#Validate if the user has specified the data source
if not self.selectedDataSource():
QMessageBox.critical(self.composerView(),
QApplication.translate("ComposerWrapper","Error"),
QApplication.translate("ComposerWrapper","Please specify the "
"data source name for the document composition."))
return
#If it is a new unsaved document template then prompt for the document name.
docFile = self.documentFile()
if docFile is None:
docName,ok = QInputDialog.getText(self.composerView(),
QApplication.translate("ComposerWrapper","Template Name"),
QApplication.translate("ComposerWrapper","Please enter the template name below"),
)
if ok and docName:
templateDir = self._composerTemplatesPath()
if templateDir is None:
QMessageBox.critical(self.composerView(),
QApplication.translate("ComposerWrapper","Error"),
QApplication.translate("ComposerWrapper",
"Directory for document templates cannot not be found."))
return
absPath = templateDir + "/" + docName + ".sdt"
#Check if there is an existing document with the same name
caseInsenDic = CaseInsensitiveDict(documentTemplates())
if docName in caseInsenDic:
result = QMessageBox.warning(self.composerView(),
QApplication.translate("ComposerWrapper",
"Existing Template"),
u"'{0}' {1}.\nDo you want to replace the "
"existing template?".format(docName,
QApplication.translate("ComposerWrapper",
"already exists")),
QMessageBox.Yes|QMessageBox.No)
if result == QMessageBox.Yes:
#Delete the existing template
delFile = QFile(absPath)
remStatus = delFile.remove()
if not remStatus:
QMessageBox.critical(self.composerView(),
QApplication.translate("ComposerWrapper",
"Delete Error"),
"'{0}' {1}.".format(docName,
QApplication.translate("ComposerWrapper",
"template could not be removed by the system,"
" please remove it manually from the document templates directory.")))
return
else:
return
docFile= QFile(absPath)
else:
return
docFileInfo = QFileInfo(docFile)
if not docFile.open(QIODevice.WriteOnly):
QMessageBox.critical(self.composerView(),
QApplication.translate("ComposerWrapper",
"Save Operation Error"),
"{0}\n{1}".format(QApplication.translate("ComposerWrapper",
"Could not save template file."),
docFile.errorString()
))
return
templateDoc = QDomDocument()
template_name = docFileInfo.completeBaseName()
self._writeXML(templateDoc, template_name)
if docFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(self.composerView(),
QApplication.translate("ComposerWrapper","Save Error"),
QApplication.translate("ComposerWrapper","Could not save template file."))
return
else:
self.mainWindow().setWindowTitle(template_name)
docFile.close()
def _writeXML(self, xml_doc, doc_name):
"""
Write the template configuration into the XML document.
"""
#Write default composer configuration
composer_element = xml_doc.createElement("Composer")
composer_element.setAttribute("title", doc_name)
composer_element.setAttribute("visible", 1)
xml_doc.appendChild(composer_element)
self.composition().writeXML(composer_element, xml_doc)
#Write STDM data field configurations
dataSourceElement = ComposerDataSource.domElement(self, xml_doc)
composer_element.appendChild(dataSourceElement)
#Write spatial field configurations
spatialColumnsElement = SpatialFieldsConfiguration.domElement(self, xml_doc)
dataSourceElement.appendChild(spatialColumnsElement)
#Write photo configuration
tables_element = PhotoConfigurationCollection.dom_element(self, xml_doc)
dataSourceElement.appendChild(tables_element)
#Write table configuration
tables_element = TableConfigurationCollection.dom_element(self, xml_doc)
dataSourceElement.appendChild(tables_element)
#Write chart configuration
charts_element = ChartConfigurationCollection.dom_element(self, xml_doc)
dataSourceElement.appendChild(charts_element)
def _configure_data_controls(self, composer_data_source):
"""
Configure the data source and data field controls based on the composer data
source configuration.
"""
if not self.stdmDataSourceDock().widget() is None:
#Set data source
dataSourceWidget = self.stdmDataSourceDock().widget()
dataSourceWidget.setCategory(composer_data_source.category())
dataSourceWidget.setSelectedSource(composer_data_source.name())
#Set data field controls
for composerId in composer_data_source.dataFieldMappings().reverse:
#Use composer item id since the uuid is stripped off
composerItem = self.composition().getComposerItemById(composerId)
if not composerItem is None:
compFieldSelector = ComposerFieldSelector(self, composerItem, self.composerView())
compFieldSelector.selectFieldName(composer_data_source.dataFieldName(composerId))
#Add widget to the collection but now use the current uuid of the composition item
self.addWidgetMapping(composerItem.uuid(), compFieldSelector)
def _configureSpatialSymbolEditor(self,spatial_field_config):
"""
Configure symbol editor controls.
"""
if not self.stdmDataSourceDock().widget() is None:
for item_id, spFieldsMappings in spatial_field_config.spatialFieldsMapping().iteritems():
mapItem = self.composition().getComposerItemById(item_id)
if not mapItem is None:
composerSymbolEditor = ComposerSymbolEditor(self, self.composerView())
composerSymbolEditor.add_spatial_field_mappings(spFieldsMappings)
#Add widget to the collection but now use the current uuid of the composer map
self.addWidgetMapping(mapItem.uuid(), composerSymbolEditor)
def _configure_photo_editors(self, photo_config_collection):
"""
Creates widgets for editing photo data sources.
:param photo_config_collection: PhotoConfigurationCollection instance.
:type photo_config_collection: PhotoConfigurationCollection
"""
if self.stdmDataSourceDock().widget() is None:
return
for item_id, photo_config in photo_config_collection.mapping().iteritems():
pic_item = self.composition().getComposerItemById(item_id)
if not pic_item is None:
photo_editor = ComposerPhotoDataSourceEditor(self, self.composerView())
photo_editor.set_configuration(photo_config)
self.addWidgetMapping(pic_item.uuid(), photo_editor)
def _configure_chart_editors(self, chart_config_collection):
"""
Creates widgets for editing chart properties.
:param chart_config_collection: ChartConfigurationCollection instance.
:type chart_config_collection: ChartConfigurationCollection
"""
if self.stdmDataSourceDock().widget() is None:
return
for item_id, chart_config in chart_config_collection.mapping().iteritems():
chart_item = self.composition().getComposerItemById(item_id)
if not chart_item is None:
chart_editor = ComposerChartConfigEditor(self, self.composerView())
chart_editor.set_configuration(chart_config)
self.addWidgetMapping(chart_item.uuid(), chart_editor)
def _configure_table_editors(self, table_config_collection):
"""
Creates widgets for editing table data sources.
:param table_config_collection: TableConfigurationCollection instance.
:type table_config_collection: TableConfigurationCollection
"""
if self.stdmDataSourceDock().widget() is None:
return
for item_id, table_config in table_config_collection.mapping().iteritems():
table_item = self.composition().getComposerItemById(item_id)
if not table_item is None:
table_editor = ComposerTableDataSourceEditor(self, table_item, self.composerView())
table_editor.set_configuration(table_config)
self.addWidgetMapping(table_item.uuid(), table_editor)
def _sync_ids_with_uuids(self):
"""
Matches IDs of custom STDM items with the corresponding UUIDs. This
is applied when loading existing templates so that the saved
document contains a matching pair of ID and UUID for each composer
item.
"""
items = self._widgetMappings.keys()
for item_uuid in self._widgetMappings.keys():
item = self.composition().getComposerItemByUuid(item_uuid)
if not item is None:
item.setId(item_uuid)
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]
def _onItemRemoved(self,item):
"""
Slot raised when a composer item is removed from the scene.
"""
"""
Code will not work since a QObject instance is returned instead of a QgsComposerItem
if item.uuid() in self._widgetMappings:
del self._widgetMappings[item.uuid()]
"""
pass
def _onItemSelected(self, item):
"""
Slot raised when a composer item is selected. Load the corresponding field selector
if the selection is an STDM data field label.
QComposerLabel is returned as a QObject in the slot argument hence, we have resorted to
capturing the current selected items in the composition.
"""
selectedItems = self.composition().selectedComposerItems()
if len(selectedItems) == 0:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) == 1:
composer_item = selectedItems[0]
if composer_item.uuid() in self._widgetMappings:
stdmWidget = self._widgetMappings[composer_item.uuid()]
if stdmWidget == self._stdmItemPropDock.widget():
return
else:
self._stdmItemPropDock.setWidget(stdmWidget)
#Playing it safe in applying the formatting for the editor controls where applicable
itemFormatter = None
if isinstance(composer_item, QgsComposerArrow):
itemFormatter = LineFormatter()
elif isinstance(composer_item, QgsComposerLabel):
itemFormatter = DataLabelFormatter()
elif isinstance(composer_item, QgsComposerMap):
itemFormatter = MapFormatter()
elif isinstance(composer_item, QgsComposerPicture):
"""
Use widget attribute to distinguish type i.e.
whether it is a photo, graph etc.
"""
editor_widget = self._widgetMappings[composer_item.uuid()]
if isinstance(editor_widget, ComposerPhotoDataSourceEditor):
itemFormatter = PhotoFormatter()
elif isinstance(editor_widget, ComposerChartConfigEditor):
itemFormatter = ChartFormatter()
elif isinstance(composer_item, QgsComposerAttributeTable):
itemFormatter = TableFormatter()
if not itemFormatter is None:
itemFormatter.apply(composer_item, self, True)
else:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) > 1:
self._stdmItemPropDock.setWidget(None)
class ComposerWrapper(QObject):
"""
Embeds custom STDM tools in a QgsComposer instance for managing map-based
STDM document templates.
"""
dataSourceSelected = pyqtSignal(str)
def __init__(self, composerView, iface):
QObject.__init__(self, composerView)
self._compView = composerView
self._stdmTB = self.mainWindow().addToolBar("STDM Document Designer")
self._selectMoveAction = None
self._iface = iface
#Container for custom editor widgets
self._widgetMappings = {}
#Hide default dock widgets
if self.itemDock() is not None:
self.itemDock().hide()
if self.atlasDock() is not None:
self.atlasDock().hide()
if self.generalDock() is not None:
self.generalDock().hide()
# Remove default toolbars
self._remove_composer_toolbar('mAtlasToolbar')
self._remove_composer_toolbar('mComposerToolbar')
#Create dock widget for configuring STDM data source
self._stdmDataSourceDock = QDockWidget(
QApplication.translate("ComposerWrapper", "STDM Data Source"),
self.mainWindow())
self._stdmDataSourceDock.setObjectName("STDMDataSourceDock")
self._stdmDataSourceDock.setMinimumWidth(300)
self._stdmDataSourceDock.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,
self._stdmDataSourceDock)
self._dataSourceWidget = ComposerDataSourceSelector()
self._stdmDataSourceDock.setWidget(self._dataSourceWidget)
self._stdmDataSourceDock.show()
#Re-insert dock widgets
if self.generalDock() is not None:
self.generalDock().show()
if self.itemDock() is not None:
self.itemDock().show()
#Create dock widget for configuring STDM item properties
self._stdmItemPropDock = QDockWidget(
QApplication.translate("ComposerWrapper", "STDM item properties"),
self.mainWindow())
self._stdmItemPropDock.setObjectName("STDMItemDock")
self._stdmItemPropDock.setMinimumWidth(300)
self._stdmItemPropDock.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,
self._stdmItemPropDock)
self._stdmItemPropDock.show()
#Re-arrange dock widgets and push up STDM data source dock widget
if self.generalDock() is not None:
self.mainWindow().splitDockWidget(self._stdmDataSourceDock,
self.generalDock(), Qt.Vertical)
if self.itemDock() is not None:
self.mainWindow().splitDockWidget(self._stdmDataSourceDock,
self.itemDock(), Qt.Vertical)
if self.generalDock() is not None:
self.mainWindow().tabifyDockWidget(self.generalDock(),
self.itemDock())
if self.itemDock() is not None:
self.mainWindow().splitDockWidget(self.itemDock(),
self._stdmItemPropDock,
Qt.Vertical)
#Set focus on composition properties window
if self.generalDock() is not None:
self.generalDock().activateWindow()
self.generalDock().raise_()
#Connect signals
self.composition().itemRemoved.connect(self._onItemRemoved)
self._dataSourceWidget.cboDataSource.currentIndexChanged.connect(
self.propagateDataSourceSelection)
self.composerView().selectedItemChanged.connect(self._onItemSelected)
#Current template document file
self._currDocFile = None
#Copy of template document file
self._copy_template_file = None
self._selected_item_uuid = unicode()
self._current_ref_table_index = -1
@property
def copy_template_file(self):
return self._copy_template_file
@copy_template_file.setter
def copy_template_file(self, value):
self._copy_template_file = value
@property
def selected_item_uuid(self):
return self._selected_item_uuid
@selected_item_uuid.setter
def selected_item_uuid(self, uuid):
self._selected_item_uuid = uuid
@property
def current_ref_table_index(self):
return self._current_ref_table_index
@current_ref_table_index.setter
def current_ref_table_index(self, value):
self._current_ref_table_index = value
def _remove_composer_toolbar(self, object_name):
"""
Removes toolbars from composer window.
:param object_name: The object name of the toolbar
:type object_name: String
:return: None
:rtype: NoneType
"""
composers = self._iface.activeComposers()
for i in range(len(composers)):
comp = composers[i].composerWindow()
widgets = comp.findChildren(QToolBar, object_name)
for widget in widgets:
comp.removeToolBar(widget)
def _removeActions(self):
"""
Remove inapplicable actions and their corresponding toolbars and menus.
"""
removeActions = [
"mActionSaveProject", "mActionNewComposer",
"mActionDuplicateComposer"
]
composerToolbar = self.composerMainToolBar()
if composerToolbar != None:
saveProjectAction = None
for itemAction in composerToolbar.actions():
if itemAction.objectName() == "mActionSaveProject":
saveProjectAction = itemAction
break
if saveProjectAction != None:
composerMenu = saveProjectAction.menu()
def configure(self):
#Create instances of custom STDM composer item configurations
for ciConfig in ComposerItemConfig.itemConfigurations:
ciConfig(self)
def addWidgetMapping(self, uniqueIdentifier, widget):
"""
Add custom STDM editor widget based on the unique identifier of the composer item
"""
self._widgetMappings[uniqueIdentifier] = widget
def widgetMappings(self):
"""
Returns a dictionary containing uuid values of composer items linked to STDM widgets.
"""
return self._widgetMappings
def clearWidgetMappings(self):
"""
Resets the widget mappings collection.
"""
self._widgetMappings = {}
def mainWindow(self):
"""
Returns the QMainWindow used by the composer view.
"""
return self._compView.composerWindow()
def stdmToolBar(self):
"""
Returns the instance of the STDM toolbar added to the QgsComposer.
"""
return self._stdmTB
def composerView(self):
"""
Returns the composer view.
"""
return self._compView
def composition(self):
"""
Returns the QgsComposition instance used in the composer view.
"""
return self._compView.composition()
def composerItemToolBar(self):
"""
Returns the toolbar containing actions for adding composer items.
"""
return self.mainWindow().findChild(QToolBar, "mItemToolbar")
def composerMainToolBar(self):
"""
Returns the toolbar containing actions for managing templates.
"""
return self.mainWindow().findChild(QToolBar, "mComposerToolbar")
def selectMoveAction(self):
"""
Returns the QAction for selecting or moving composer items.
"""
if self.composerItemToolBar() != None:
if self._selectMoveAction == None:
for itemAction in self.composerItemToolBar().actions():
if itemAction.objectName() == "mActionSelectMoveItem":
self._selectMoveAction = itemAction
break
return self._selectMoveAction
def checkedItemAction(self):
"""
Returns the currently selected composer item action.
"""
if self.selectMoveAction() != None:
return self.selectMoveAction().actionGroup().checkedAction()
return None
def itemDock(self):
"""
Get the 'Item Properties' dock widget.
"""
return self.mainWindow().findChild(QDockWidget, "ItemDock")
def atlasDock(self):
"""
Get the 'Atlas generation' dock widget.
"""
return self.mainWindow().findChild(QDockWidget, "AtlasDock")
def generalDock(self):
"""
Get the 'Composition' dock widget.
"""
return self.mainWindow().findChild(QDockWidget, "CompositionDock")
def stdmDataSourceDock(self):
"""
Returns the STDM data source dock widget.
"""
return self._stdmDataSourceDock
def stdmItemDock(self):
"""
Returns the STDM item dock widget.
"""
return self._stdmItemPropDock
def documentFile(self):
"""
Returns the QFile instance associated with the current document. 'None' will be returned for
new, unsaved documents.
"""
return self._currDocFile
def setDocumentFile(self, docFile):
"""
Sets the document file.
"""
if not isinstance(docFile, QFile):
return
self._currDocFile = docFile
def selectedDataSource(self):
"""
Returns the name of the data source specified by the user.
"""
row = self._stdmDataSourceDock.widget().cboDataSource.currentIndex()
table_name = self._stdmDataSourceDock.widget().cboDataSource.itemData(
row)
return table_name
def selected_referenced_table(self):
"""
:return: Returns the name of currently specified referenced table name.
:rtype: str
"""
return self._stdmDataSourceDock.widget().referenced_table_name()
def selectedDataSourceCategory(self):
"""
Returns the category (view or table) that the data source belongs to.
"""
if not self.stdmDataSourceDock().widget() is None:
return self.stdmDataSourceDock().widget().category()
return ""
def propagateDataSourceSelection(self, index):
"""
Propagates the signal when a user select a data source. Listening objects can hook on to it.
"""
data_source_name = self._stdmDataSourceDock.widget(
).cboDataSource.itemData(index)
self.dataSourceSelected.emit(data_source_name)
def composer_items(self):
"""
:return: Returns a list of custom composer items.
:rtype: list
"""
return [
self.composition().getComposerItemById(uuid)
for uuid in self._widgetMappings.keys()
if not self.composition().getComposerItemById(uuid) is None
]
def _clear_composition(self):
"""
Removes composer items which, otherwise, are causing QGIS to crash
when loading a subsequent document template.
"""
items = self.composition().items()
for c_item in items:
if isinstance(c_item, QgsComposerItem) and not isinstance(
c_item, QgsPaperItem):
if c_item.uuid() in self._widgetMappings:
#Remove corresponding widget as well as reference in the collection
del self._widgetMappings[c_item.uuid()]
self.composition().removeItem(c_item)
self.composition().itemRemoved.emit(c_item)
del c_item
self.composition().undoStack().clear()
self.composition().itemsModel().clear()
def create_new_document_designer(self, file_path):
"""
Creates a new document designer and loads the document template
defined in file path.
:param file_path: Path to document template
:type file_path: str
"""
if len(self.composerView().items()) == 3:
self.composerView().composerWindow().close()
document_designer = self._iface.createNewComposer(
"STDM Document Designer")
#Embed STDM customizations
cw = ComposerWrapper(document_designer, self._iface)
cw.configure()
#Load template
cw.loadTemplate(file_path)
def loadTemplate(self, filePath):
"""
Loads a document template into the view and updates the necessary STDM-related composer items.
"""
if not QFile.exists(filePath):
QMessageBox.critical(
self.composerView(),
QApplication.translate("OpenTemplateConfig",
"Open Template Error"),
QApplication.translate(
"OpenTemplateConfig",
"The specified template does not exist."))
return
copy_file = filePath.replace('sdt', 'cpy')
# remove existing copy file
if QFile.exists(copy_file):
copy_template = QFile(copy_file)
copy_template.remove()
orig_template_file = QFile(filePath)
self.setDocumentFile(orig_template_file)
# make a copy of the original
orig_template_file.copy(copy_file)
#templateFile = QFile(filePath)
# work with copy
templateFile = QFile(copy_file)
self.copy_template_file = templateFile
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper",
"Open Operation Error"),
"{0}\n{1}".format(
QApplication.translate("ComposerWrapper",
"Cannot read template file."),
templateFile.errorString()))
return
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
table_config_collection = TableConfigurationCollection.create(
templateDoc)
'''
First load vector layers for the table definitions in the config
collection before loading the composition from file.
'''
load_table_layers(table_config_collection)
self.clearWidgetMappings()
#Load items into the composition and configure STDM data controls
self.composition().loadFromTemplate(templateDoc)
#Load data controls
composerDS = ComposerDataSource.create(templateDoc)
#Set title by appending template name
title = QApplication.translate("STDMPlugin",
"STDM Document Designer")
composer_el = templateDoc.documentElement()
if not composer_el is None:
template_name = ""
if composer_el.hasAttribute("title"):
template_name = composer_el.attribute("title", "")
elif composer_el.hasAttribute("_title"):
template_name = composer_el.attribute("_title", "")
if template_name:
win_title = u"{0} - {1}".format(title, template_name)
self.mainWindow().setWindowTitle(template_name)
self._configure_data_controls(composerDS)
#Load symbol editors
spatialFieldsConfig = SpatialFieldsConfiguration.create(
templateDoc)
self._configureSpatialSymbolEditor(spatialFieldsConfig)
#Load photo editors
photo_config_collection = PhotoConfigurationCollection.create(
templateDoc)
self._configure_photo_editors(photo_config_collection)
# Load table editors
self._configure_table_editors(table_config_collection)
items = self.composerView().items()
items = []
#Load chart property editors
chart_config_collection = ChartConfigurationCollection.create(
templateDoc)
self._configure_chart_editors(chart_config_collection)
# Load QR code property editors
qrc_config_collection = QRCodeConfigurationCollection.create(
templateDoc)
self._configure_qr_code_editors(qrc_config_collection)
self._sync_ids_with_uuids()
def saveTemplate(self):
"""
Creates and saves a new document template.
"""
# Validate if the user has specified the data source
if not self.selectedDataSource():
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper", "Please specify the "
"data source name for the document composition."))
return
# Assert if the referenced table name has been set
if not self.selected_referenced_table():
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper", "Please specify the "
"referenced table name for the selected data source."))
return
# If it is a new unsaved document template then prompt for the document name.
docFile = self.documentFile()
if docFile is None:
docName, ok = QInputDialog.getText(
self.composerView(),
QApplication.translate("ComposerWrapper", "Template Name"),
QApplication.translate("ComposerWrapper",
"Please enter the template name below"),
)
if not ok:
return
if ok and not docName:
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate("ComposerWrapper",
"Please enter a template name!"))
self.saveTemplate()
if ok and docName:
templateDir = self._composerTemplatesPath()
if templateDir is None:
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper", "Error"),
QApplication.translate(
"ComposerWrapper",
"Directory for document templates cannot not be found."
))
return
absPath = templateDir + "/" + docName + ".sdt"
#Check if there is an existing document with the same name
caseInsenDic = CaseInsensitiveDict(documentTemplates())
if docName in caseInsenDic:
result = QMessageBox.warning(
self.composerView(),
QApplication.translate("ComposerWrapper",
"Existing Template"),
u"'{0}' {1}.\nDo you want to replace the "
"existing template?".format(
docName,
QApplication.translate("ComposerWrapper",
"already exists")),
QMessageBox.Yes | QMessageBox.No)
if result == QMessageBox.Yes:
#Delete the existing template
delFile = QFile(absPath)
remStatus = delFile.remove()
if not remStatus:
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper",
"Delete Error"),
"'{0}' {1}.".format(
docName,
QApplication.translate(
"ComposerWrapper",
"template could not be removed by the system,"
" please remove it manually from the document templates directory."
)))
return
else:
return
docFile = QFile(absPath)
else:
return
docFileInfo = QFileInfo(docFile)
if not docFile.open(QIODevice.WriteOnly):
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper",
"Save Operation Error"),
"{0}\n{1}".format(
QApplication.translate("ComposerWrapper",
"Could not save template file."),
docFile.errorString()))
return
templateDoc = QDomDocument()
template_name = docFileInfo.completeBaseName()
# Catch exception raised when writing items' elements
try:
self._writeXML(templateDoc, template_name)
except Exception as exc:
msg = unicode(exc)
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper", "Save Error"), msg)
docFile.close()
docFile.remove()
return
if docFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(
self.composerView(),
QApplication.translate("ComposerWrapper", "Save Error"),
QApplication.translate("ComposerWrapper",
"Could not save template file."))
return
else:
self.mainWindow().setWindowTitle(template_name)
self.setDocumentFile(docFile)
docFile.close()
if self.copy_template_file:
self.copy_template_file.close()
def _writeXML(self, xml_doc, doc_name):
"""
Write the template configuration into the XML document.
"""
#Write default composer configuration
composer_element = xml_doc.createElement("Composer")
composer_element.setAttribute("title", doc_name)
composer_element.setAttribute("visible", 1)
xml_doc.appendChild(composer_element)
self.composition().writeXML(composer_element, xml_doc)
#Write STDM data field configurations
dataSourceElement = ComposerDataSource.domElement(self, xml_doc)
composer_element.appendChild(dataSourceElement)
#Write spatial field configurations
spatialColumnsElement = SpatialFieldsConfiguration.domElement(
self, xml_doc)
dataSourceElement.appendChild(spatialColumnsElement)
#Write photo configuration
photos_element = PhotoConfigurationCollection.dom_element(
self, xml_doc)
dataSourceElement.appendChild(photos_element)
#Write table configuration
tables_element = TableConfigurationCollection.dom_element(
self, xml_doc)
dataSourceElement.appendChild(tables_element)
#Write chart configuration
charts_element = ChartConfigurationCollection.dom_element(
self, xml_doc)
dataSourceElement.appendChild(charts_element)
# Write QRCode configuration
qr_codes_element = QRCodeConfigurationCollection.dom_element(
self, xml_doc)
dataSourceElement.appendChild(qr_codes_element)
def _configure_data_controls(self, composer_data_source):
"""
Configure the data source and data field controls based on the composer data
source configuration.
"""
if not self.stdmDataSourceDock().widget() is None:
#Set data source
dataSourceWidget = self.stdmDataSourceDock().widget()
dataSourceWidget.setCategory(composer_data_source.category())
dataSourceWidget.setSelectedSource(composer_data_source.name())
dataSourceWidget.set_referenced_table(
composer_data_source.referenced_table_name)
#Set data field controls
for composerId in composer_data_source.dataFieldMappings().reverse:
#Use composer item id since the uuid is stripped off
composerItem = self.composition().getComposerItemById(
composerId)
if not composerItem is None:
compFieldSelector = ComposerFieldSelector(
self, composerItem, self.composerView())
compFieldSelector.selectFieldName(
composer_data_source.dataFieldName(composerId))
#Add widget to the collection but now use the current uuid of the composition item
self.addWidgetMapping(composerItem.uuid(),
compFieldSelector)
def _configureSpatialSymbolEditor(self, spatial_field_config):
"""
Configure symbol editor controls.
"""
if not self.stdmDataSourceDock().widget() is None:
for item_id, spFieldsMappings in spatial_field_config.spatialFieldsMapping(
).iteritems():
mapItem = self.composition().getComposerItemById(item_id)
if not mapItem is None:
composerSymbolEditor = ComposerSymbolEditor(
self, self.composerView())
composerSymbolEditor.add_spatial_field_mappings(
spFieldsMappings)
#Add widget to the collection but now use the current uuid of the composer map
self.addWidgetMapping(mapItem.uuid(), composerSymbolEditor)
def _configure_photo_editors(self, photo_config_collection):
"""
Creates widgets for editing photo data sources.
:param photo_config_collection: PhotoConfigurationCollection instance.
:type photo_config_collection: PhotoConfigurationCollection
"""
if self.stdmDataSourceDock().widget() is None:
return
for item_id, photo_config in photo_config_collection.mapping(
).iteritems():
pic_item = self.composition().getComposerItemById(item_id)
if not pic_item is None:
photo_editor = ComposerPhotoDataSourceEditor(
self, self.composerView())
photo_editor.set_configuration(photo_config)
self.addWidgetMapping(pic_item.uuid(), photo_editor)
def _configure_chart_editors(self, chart_config_collection):
"""
Creates widgets for editing chart properties.
:param chart_config_collection: ChartConfigurationCollection instance.
:type chart_config_collection: ChartConfigurationCollection
"""
if self.stdmDataSourceDock().widget() is None:
return
for item_id, chart_config in chart_config_collection.mapping(
).iteritems():
chart_item = self.composition().getComposerItemById(item_id)
if not chart_item is None:
chart_editor = ComposerChartConfigEditor(
self, self.composerView())
chart_editor.set_configuration(chart_config)
self.addWidgetMapping(chart_item.uuid(), chart_editor)
def _configure_table_editors(self, table_config_collection):
"""
Creates widgets for editing table data sources.
:param table_config_collection: TableConfigurationCollection instance.
:type table_config_collection: TableConfigurationCollection
"""
if self.stdmDataSourceDock().widget() is None:
return
for item_id, table_config in table_config_collection.mapping(
).iteritems():
table_item = self.composition().getComposerItemById(item_id)
if table_item is not None:
table_editor = ComposerTableDataSourceEditor(
self, table_item, self.composerView())
table_editor.set_configuration(table_config)
table_editor.ref_table.cbo_ref_table.currentIndexChanged[
str].connect(table_editor.set_table_vector_layer)
self.addWidgetMapping(table_item.uuid(), table_editor)
def _configure_qr_code_editors(self, qr_code_config_collection):
"""
Creates widgets for editing QR code properties.
:param qr_code_config_collection: QRCodeConfigurationCollection instance.
:type qr_code_config_collection: QRCodeConfigurationCollection
"""
if self.stdmDataSourceDock().widget() is None:
return
for item_id, qrc_config in qr_code_config_collection.mapping(
).iteritems():
qrc_item = self.composition().getComposerItemById(item_id)
if not qrc_item is None:
qrc_editor_cls = qr_code_config_collection.editor_type
qrc_editor = qrc_editor_cls(self, self.composerView())
qrc_editor.set_configuration(qrc_config)
self.addWidgetMapping(qrc_item.uuid(), qrc_editor)
def _sync_ids_with_uuids(self):
"""
Matches IDs of custom STDM items with the corresponding UUIDs. This
is applied when loading existing templates so that the saved
document contains a matching pair of ID and UUID for each composer
item.
"""
items = self._widgetMappings.keys()
for item_uuid in self._widgetMappings.keys():
item = self.composition().getComposerItemByUuid(item_uuid)
if not item is None:
item.setId(item_uuid)
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]
def _onItemRemoved(self, item):
"""
Slot raised when a composer item is removed from the scene.
"""
"""
Code will not work since a QObject instance is returned instead of a QgsComposerItem
if item.uuid() in self._widgetMappings:
del self._widgetMappings[item.uuid()]
"""
pass
def _onItemSelected(self, item):
"""
Slot raised when a composer item is selected. Load the corresponding field selector
if the selection is an STDM data field label.
QComposerLabel is returned as a QObject in the slot argument hence, we have resorted to
capturing the current selected items in the composition.
"""
selectedItems = self.composition().selectedComposerItems()
if len(selectedItems) == 0:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) == 1:
composer_item = selectedItems[0]
if composer_item.uuid() in self._widgetMappings:
stdmWidget = self._widgetMappings[composer_item.uuid()]
self.selected_item_uuid = composer_item.uuid()
if stdmWidget == self._stdmItemPropDock.widget():
return
else:
self._stdmItemPropDock.setWidget(stdmWidget)
#Playing it safe in applying the formatting for the editor controls where applicable
itemFormatter = None
if isinstance(stdmWidget, ComposerTableDataSourceEditor):
itemFormatter = TableFormatter()
if isinstance(composer_item, QgsComposerArrow):
itemFormatter = LineFormatter()
elif isinstance(composer_item, QgsComposerLabel):
itemFormatter = DataLabelFormatter()
elif isinstance(composer_item, QgsComposerMap):
itemFormatter = MapFormatter()
elif isinstance(composer_item, QgsComposerPicture):
"""
Use widget attribute to distinguish type i.e.
whether it is a photo, graph etc.
"""
editor_widget = self._widgetMappings[composer_item.uuid()]
if isinstance(editor_widget,
ComposerPhotoDataSourceEditor):
itemFormatter = PhotoFormatter()
elif isinstance(editor_widget, ComposerChartConfigEditor):
itemFormatter = ChartFormatter()
elif isinstance(editor_widget,
QRCodeConfigurationCollection.editor_type):
itemFormatter = QRCodeFormatter()
elif isinstance(composer_item, QgsComposerAttributeTableV2):
itemFormatter = TableFormatter()
if itemFormatter is not None:
itemFormatter.apply(composer_item, self, True)
else:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) > 1:
self._stdmItemPropDock.setWidget(None)
class Plugin(QObject):
def __init__(self, iface):
QObject.__init__(self)
self.__iface = iface
self.__shortcuts = []
self.__current_section = QComboBox()
self.__current_section.setMinimumWidth(150)
self.__current_graph = QComboBox()
self.__current_graph.setMinimumWidth(150)
self.__toolbar = None
self.__axis_layer = None
self.__menu = None
self.__log_strati = None
def initGui(self):
for keyseq, slot in (
(Qt.CTRL + Qt.ALT + Qt.Key_K, self.__create_group),
(Qt.CTRL + Qt.ALT + Qt.Key_S, self.__select_next_group),
(Qt.CTRL + Qt.ALT + Qt.Key_N, self.__next_section),
(Qt.CTRL + Qt.ALT + Qt.Key_B, self.__previous_section)
):
short = QShortcut(QKeySequence(keyseq), self.__iface.mainWindow())
short.setContext(Qt.ApplicationShortcut)
short.activated.connect(slot)
self.__shortcuts.append(short)
self.__menu = QMenu("Albion")
self.__menu.aboutToShow.connect(self.__create_menu_entries)
self.__iface.mainWindow().menuBar().addMenu(self.__menu)
self.__toolbar = QToolBar('Albion')
self.__iface.addToolBar(self.__toolbar)
self.__toolbar.addAction(icon('log_strati.svg'), 'stratigraphic log').triggered.connect(self.__log_strati_clicked)
self.__toolbar.addWidget(self.__current_graph)
self.__current_graph.currentIndexChanged[unicode].connect(self.__current_graph_changed)
self.__toolbar.addWidget(self.__current_section)
self.__current_section.currentIndexChanged[unicode].connect(self.__current_section_changed)
self.__toolbar.addAction(icon('previous_line.svg'), 'previous section (Ctrl+Alt+b)').triggered.connect(self.__previous_section)
self.__toolbar.addAction(icon('next_line.svg'), 'next section (Ctrl+Alt+n)').triggered.connect(self.__next_section)
self.__toolbar.addAction(icon('line_from_selected.svg'), 'create temporary section').triggered.connect(self.__section_from_selection)
self.__viewer3d = QDockWidget('3D')
self.__viewer3d.setWidget(Viewer3d())
self.__iface.addDockWidget(Qt.LeftDockWidgetArea, self.__viewer3d)
self.__iface.mainWindow().tabifyDockWidget(
self.__iface.mainWindow().findChild(QDockWidget, "Layers"),
self.__viewer3d)
self.__viewer3d_ctrl = QToolBar('3D controls')
self.__viewer3d_ctrl.addWidget(ViewerControls(self.__viewer3d.widget()))
self.__iface.addToolBar(self.__viewer3d_ctrl)
QgsProject.instance().readProject.connect(self.__qgis__project__loaded)
self.__qgis__project__loaded() # case of reload
def unload(self):
for s in self.__shortcuts:
s.setParent(None)
self.__toolbar and self.__toolbar.setParent(None)
self.__menu and self.__menu.setParent(None)
self.__viewer3d and self.__viewer3d.setParent(None)
self.__viewer3d_ctrl and self.__viewer3d_ctrl.setParent(None)
def __add_menu_entry(self, name, callback, enabled=True, help_str=''):
act = self.__menu.addAction(name)
if callback is not None:
act.triggered.connect(callback)
act.setEnabled(enabled)
act.setToolTip(help_str)
else:
act.setEnabled(False)
act.setToolTip("NOT INMPLEMENTED "+help_str)
return act
def __create_menu_entries(self):
self.__menu.clear()
self.__add_menu_entry('New &Project', self.__new_project)
self.__add_menu_entry('Import Project', self.__import_project)
self.__add_menu_entry('Upgrade Project', self.__upgrade_project)
self.__menu.addSeparator()
self.__add_menu_entry('&Import Data', self.__import_data,
self.project is not None,
"Import data from directory. The data files are in ")
self.__menu.addSeparator()
self.__add_menu_entry('Create cells', self.__create_cells,
self.project is not None and self.project.has_collar,
"Create Delaunay triangulation of collar layer.")
self.__add_menu_entry('Refresh all edges', self.__refresh_all_edge,
self.project is not None and self.project.has_cell,
"Refresh materialized view of all cell edges used by graph possible edges.")
self.__menu.addSeparator()
#self.__add_menu_entry(u'Create section views 0° and 90°', self.__create_section_view_0_90,
# False and self.project is not None and self.project.has_hole,
# "Create section views (i.e. cut directions) to work West-East and South-North for this project")
#self.__add_menu_entry(u'Create section views -45° and 45°', None,
# False and self.project is not None and self.project.has_hole,
# "Create section views (i.e. cut directions) to work SE-NW and SW-NE for this project")
#
#self.__menu.addSeparator()
self.__add_menu_entry('Create sections', self.__create_sections,
self.project is not None and self.project.has_group_cell,
"Once cell groups have been defined, create section lines.")
self.__menu.addSeparator()
self.__add_menu_entry('Compute &Mineralization', self.__compute_mineralization,
self.project is not None and self.project.has_radiometry,
"")
self.__menu.addSeparator()
self.__add_menu_entry('New &Graph', self.__new_graph,
self.project is not None,
"Create a new grap.h")
self.__add_menu_entry('Delete Graph', self.__delete_graph,
self.project is not None)
self.__menu.addSeparator()
self.__add_menu_entry('Create volumes', self.__create_volumes,
self.project is not None and bool(self.__current_graph.currentText()),
"Create volumes associated with current graph.")
self.__menu.addSeparator()
self.__add_menu_entry('Create terminations', self.__create_terminations,
self.project is not None and bool(self.__current_graph.currentText()),
"Create terminations associated with current graph.")
self.__menu.addSeparator()
self.__add_menu_entry('Toggle axis', self.__toggle_axis)
self.__menu.addSeparator()
self.__add_menu_entry('Export Project', self.__export_project,
self.project is not None)
self.__add_menu_entry('Export Sections', None,
self.project is not None and self.project.has_section,
"Export triangulated section in .obj or .dxf format")
self.__add_menu_entry('Export Volume', self.__export_volume,
self.project is not None and bool(self.__current_graph.currentText()),
"Export volume of current graph in .obj or .dxf format")
self.__menu.addSeparator()
self.__menu.addAction('Help').triggered.connect(self.open_help)
def __current_graph_changed(self, graph_id):
if self.project is None:
return
self.__viewer3d.widget().set_graph(graph_id)
def __getattr__(self, name):
if name == "project":
project_name = QgsProject.instance().readEntry("albion", "project_name", "")[0]
return Project(project_name) if project_name else None
else:
raise AttributeError(name)
def __refresh_all_edge(self):
if self.project is None:
return
self.project.refresh_all_edge()
def __create_terminations(self):
if self.project is None:
return
self.project.create_terminations(self.__current_graph.currentText())
self.__viewer3d.widget().refresh_data()
self.__refresh_layers('section')
def __create_volumes(self):
if self.project is None:
return
self.project.create_volumes(self.__current_graph.currentText())
self.__viewer3d.widget().refresh_data()
def __next_section(self):
if self.project is None:
return
self.project.next_section(self.__current_section.currentText())
self.__refresh_layers('section')
self.__viewer3d.widget().scene.update('section')
self.__viewer3d.widget().update()
def __previous_section(self):
if self.project is None:
return
self.project.previous_section(self.__current_section.currentText())
self.__refresh_layers('section')
self.__viewer3d.widget().scene.update('section')
self.__viewer3d.widget().update()
def __refresh_layers(self, name=None):
for layer in self.__iface.mapCanvas().layers():
if name is None or layer.name().find(name) != -1:
layer.triggerRepaint()
def __current_section_changed(self, section_id):
layers = QgsMapLayerRegistry.instance().mapLayersByName(u"group_cell")
if len(layers):
layers[0].setSubsetString("section_id='{}'".format(section_id))
self.__refresh_layers('section')
def __select_next_group(self):
if self.project and self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"cell":
self.__iface.activeLayer().removeSelection()
self.__iface.activeLayer().selectByExpression(
"id in ({})".format(",".join(project.next_group_ids())))
def __create_group(self):
if self.project and self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"cell":
if self.__iface.activeLayer().selectedFeatureCount():
section = self.__current_section.currentText()
self.project.create_group(section,
[f['id'] for f in self.__iface.activeLayer().selectedFeatures()])
self.__iface.activeLayer().removeSelection()
self.__refresh_layers('group_cell')
def __qgis__project__loaded(self):
if self.project is None:
return
self.__current_graph.clear()
self.__current_section.clear()
self.__current_section.addItems(self.project.sections())
self.__current_graph.addItems(self.project.graphs())
layers = QgsMapLayerRegistry.instance().mapLayersByName('section.anchor')
if len(layers):
layers[0].editingStopped.connect(self.__update_section_list)
self.__viewer3d.widget().resetScene(self.project)
def __update_section_list(self):
self.__current_section.clear()
self.__current_section.addItems(self.project.sections())
def __upgrade_project(self):
project_name, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Database name", "Database name:", QLineEdit.Normal, '')
if not ok:
return
Project(project_name).update()
def __new_project(self):
# @todo open dialog to configure project name and srid
fil = QFileDialog.getSaveFileName(None,
u"New project name (no space, plain ascii)",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"QGIS poject file (*.qgs)")
if not fil:
return
fil = fil if len(fil)>4 and fil[-4:]=='.qgs' else fil+'.qgs'
fil = fil.replace(' ','_')
try:
fil.decode('ascii')
except UnicodeDecodeError:
self.__iface.messageBar().pushError('Albion:', "project name may only contain asci character (no accent)")
return
srid, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Project SRID", "Project SRID EPSG:", QLineEdit.Normal, '32632')
if not ok:
return
srid = int(srid)
project_name = str(os.path.split(fil)[1][:-4])
if Project.exists(project_name):
if QMessageBox.Yes != QMessageBox(QMessageBox.Information,
"Delete existing DB", "Database {} exits, to you want to delete it ?".format(project_name),
QMessageBox.Yes|QMessageBox.No).exec_():
return
Project.delete(project_name)
self.__iface.messageBar().pushInfo('Albion:', "creating project...")
Project.create(project_name, srid)
# load template
open(fil, 'w').write(
open(resource('template_project.qgs')).read().replace('template_project', project_name))
self.__iface.newProject()
QgsProject.instance().setFileName(fil)
QgsProject.instance().read()
QgsProject.instance().writeEntry("albion", "project_name", project_name)
QgsProject.instance().writeEntry("albion", "srid", srid)
QgsProject.instance().write()
self.__qgis__project__loaded()
def __import_data(self):
if self.project is None:
return
if not QgsProject.instance().readEntry("albion", "conn_info", "")[0]:
return
dir_ = QFileDialog.getExistingDirectory(None,
u"Data directory",
QgsProject.instance().readEntry("albion", "last_dir", "")[0])
if not dir_:
return
QgsProject.instance().writeEntry("albion", "last_dir", dir_),
progressMessageBar = self.__iface.messageBar().createMessage("Loading {}...".format(dir_))
progress = QProgressBar()
progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.__iface.messageBar().pushWidget(progressMessageBar, self.__iface.messageBar().INFO)
self.project.import_data(dir_, ProgressBar(progress))
self.project.triangulate()
self.project.create_section_view_0_90(4)
self.__iface.messageBar().clearWidgets()
collar = QgsMapLayerRegistry.instance().mapLayersByName('collar')[0]
collar.reload()
collar.updateExtents()
self.__iface.setActiveLayer(collar)
QApplication.instance().processEvents()
while self.__iface.mapCanvas().isDrawing():
QApplication.instance().processEvents()
self.__iface.zoomToActiveLayer()
self.__iface.actionSaveProject().trigger()
self.__viewer3d.widget().resetScene(self.project)
self.__current_section.clear()
self.__current_section.addItems(self.project.sections())
def __new_graph(self):
if self.project is None:
return
graph, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Graph", "Graph name:", QLineEdit.Normal, 'test_graph')
if not ok:
return
parent, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Parent Graph", "Parent Graph name:", QLineEdit.Normal, '')
if not ok:
return
self.project.new_graph(graph, parent)
self.__current_graph.addItem(graph)
self.__current_graph.setCurrentIndex(self.__current_graph.findText(graph))
def __delete_graph(self):
if self.project is None:
return
graph, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Graph", "Graph name:", QLineEdit.Normal, self.__current_graph.currentText())
if not ok:
return
self.__current_graph.removeItem(self.__current_graph.findText(graph))
def __toggle_axis(self):
if self.__axis_layer:
pass
QgsMapLayerRegistry.instance().removeMapLayer(self.__axis_layer.id())
self.__axis_layer = None
else:
self.__axis_layer = AxisLayer(self.__iface.mapCanvas().mapSettings().destinationCrs())
QgsMapLayerRegistry.instance().addMapLayer(self.__axis_layer)
self.__refresh_layers()
def __create_cells(self):
if self.project is None:
return
self.project.triangulate()
self.__refresh_layers('cells')
def __create_sections(self):
if self.project is None:
return
self.project.create_sections()
def __compute_mineralization(self):
MineralizationDialog(self.project).exec_()
def __export_volume(self):
if self.project is None:
return
fil = QFileDialog.getSaveFileName(None,
u"Export volume for current graph",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"File formats (*.dxf *.obj)")
if not fil:
return
QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)),
if fil[-4:] == '.obj':
self.project.export_obj(self.__current_graph.currentText(), fil)
elif fil[-4:] == '.dxf':
self.project.export_dxf(self.__current_graph.currentText(), fil)
else:
self.__iface.messageBar().pushWarning('Albion', 'unsupported extension for volume export')
def __import_project(self):
fil = QFileDialog.getOpenFileName(None,
u"Import project from file",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"File formats (*.zip)")
if not fil:
return
QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)),
if fil[-4:] != '.zip':
self.__iface.messageBar().pushWarning('Albion', 'unsupported extension for import')
project_name = os.path.split(fil)[1][:-4]
dir_ = tempfile.gettempdir()
with zipfile.ZipFile(fil, "r") as z:
z.extractall(dir_)
dump = find_in_dir(dir_, '.dump')
prj = find_in_dir(dir_, '.qgs')
self.__iface.messageBar().pushInfo('Albion', 'loading {} from {}'.format(project_name, dump))
if Project.exists(project_name):
if QMessageBox.Yes != QMessageBox(QMessageBox.Information,
"Delete existing DB", "Database {} exits, to you want to delete it ?".format(project_name),
QMessageBox.Yes|QMessageBox.No).exec_():
return
Project.delete(project_name)
project = Project.import_(project_name, dump)
QgsProject.instance().read(QFileInfo(prj))
def __export_project(self):
if self.project is None:
return
fil = QFileDialog.getSaveFileName(None,
u"Export project",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"Data files(*.zip)")
if not fil:
return
QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)),
if os.path.exists(fil):
os.remove(fil)
with zipfile.ZipFile(fil, 'w') as project:
dump = tempfile.mkstemp()[1]
self.project.export(dump)
project.write(dump, self.project.name+'.dump')
project.write(QgsProject.instance().fileName(), os.path.split(QgsProject.instance().fileName())[1])
def __create_section_view_0_90(self):
if self.project is None:
return
self.project.create_section_view_0_90()
def __log_strati_clicked(self):
#@todo switch behavior when in section view -> ortho
self.__click_tool = QgsMapToolEmitPoint(self.__iface.mapCanvas())
self.__iface.mapCanvas().setMapTool(self.__click_tool)
self.__click_tool.canvasClicked.connect(self.__map_log_clicked)
def __map_log_clicked(self, point, button):
self.__click_tool.setParent(None)
self.__click_tool = None
if self.project is None:
self.__log_strati and self.__log_strati.setParent(None)
self.__log_strati = None
return
if self.__log_strati is None:
self.__log_strati = QDockWidget('Stratigraphic Log')
self.__log_strati.setWidget(BoreHoleWindow(self.project))
self.__iface.addDockWidget(Qt.LeftDockWidgetArea, self.__log_strati)
self.__iface.mainWindow().tabifyDockWidget(
self.__iface.mainWindow().findChild(QDockWidget, "Layers"),
self.__log_strati)
res = self.project.closest_hole_id(point.x(), point.y())
if res:
self.__log_strati.widget().scene.set_current_id(res)
self.__log_strati.show()
self.__log_strati.raise_()
def __section_from_selection(self):
if self.project is None:
return
if self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"collar" \
and self.__iface.activeLayer().selectedFeatures():
collar = self.__iface.activeLayer()
selection = collar.selectedFeatures()
if len(selection) < 2:
return
def align(l):
assert len(l) >= 2
res = numpy.array(l[:2])
for p in l[2:]:
u, v = res[0] - res[1], p - res[1]
if numpy.dot(u,v) < 0:
res[1] = p
elif numpy.dot(u, u) < numpy.dot(v,v):
res[0] = p
# align with ref direction
sqrt2 = math.sqrt(2.)/2
l = l[numpy.argsort(numpy.dot(l-res[0], res[1]-res[0]))]
d = numpy.array(l[-1] - l[0])
dr = numpy.array([(0,1),(sqrt2, sqrt2),(1,0), (sqrt2, -sqrt2)])
i = numpy.argmax(numpy.abs(dr.dot(d)))
return l if (dr.dot(d))[i] > 0 else l[::-1]
line = LineString(align(numpy.array([f.geometry().asPoint() for f in selection])))
collar.removeSelection()
self.project.set_section_geom(self.__current_section.currentText(), line)
self.__refresh_layers('section')
self.__viewer3d.widget().scene.update('section')
self.__viewer3d.widget().update()
def open_help(self):
QDesktopServices.openUrl(QUrl.fromLocalFile(os.path.join(os.path.dirname(__file__), 'doc', 'build', 'html', 'index.html')))
class MainWindow(KXmlGuiWindow):
"Class which displays the main Danbooru Client window."
def __init__(self, *args):
"Initialize a new main window."
super(MainWindow, self).__init__(*args)
self.cache = KPixmapCache("danbooru")
self.preferences = preferences.Preferences()
self.api = None
self.__ratings = None
self.__step = 0
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
self.statusbar = self.statusBar()
self.progress = QProgressBar()
self.thumbnailarea = None
self.tag_dock = None
self.pool_dock = None
self.first_fetch_widget = None
self.progress.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
# FIXME: Hackish, but how to make it small otherwise?
self.progress.setMinimumSize(100, 1)
self.statusbar.addPermanentWidget(self.progress)
self.progress.hide()
self.setup_welcome_widget()
self.setup_actions()
def reload_config(self):
"""Reload configuration after a change"""
urls = self.preferences.boards_list
if self.first_fetch_widget is not None:
self.first_fetch_widget.setup_urls(urls)
if self.thumbnailarea is not None:
max_thumbnail = self.preferences.thumbnail_no
max_rating = self.preferences.max_allowed_rating
self.thumbnailarea.fetchwidget.limit = max_thumbnail
self.thumbnailarea.fetchwidget.rating = max_rating
self.thumbnailarea.fetchwidget.update_values()
self.thumbnailarea.connectwidget.setup_urls(urls)
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
def setup_welcome_widget(self):
"""Load the welcome widget at startup."""
widget = QWidget()
layout = QVBoxLayout()
welcome = QLabel(parent=self)
pix = QPixmap(KStandardDirs.locate("appdata", "logo.png"))
welcome.setPixmap(pix)
welcome.setAlignment(Qt.AlignCenter)
self.first_fetch_widget = connectwidget.ConnectWidget(
self.preferences.boards_list, self)
self.statusbar.addPermanentWidget(self.first_fetch_widget, 300)
self.first_fetch_widget.connectionEstablished.connect(
self.handle_connection)
self.first_fetch_widget.rejected.connect(self.first_fetch_widget.hide)
self.first_fetch_widget.hide()
self.first_fetch_widget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Fixed)
layout.addWidget(self.first_fetch_widget)
layout.addWidget(welcome)
widget.setLayout(layout)
self.setCentralWidget(widget)
def setup_tooltips(self):
"""Set tooltips for the actions."""
self.connect_action.setToolTip(i18n("Connect to a Danbooru board"))
self.fetch_action.setToolTip(
i18n("Fetch thumbnails from a Danbooru board"))
self.batch_download_action.setToolTip(i18n("Batch download images"))
def create_actions(self):
"""Create actions for the main window."""
self.connect_action = KAction(KIcon("document-open-remote"),
i18n("Connect"), self)
self.fetch_action = KAction(KIcon("download"), i18n("Download"), self)
self.clean_action = KAction(KIcon("trash-empty"),
i18n("Clear thumbnail cache"), self)
self.batch_download_action = KAction(KIcon("download"),
i18n("Batch download"), self)
self.pool_toggle_action = KToggleAction(KIcon("image-x-generic"),
i18n("Pools"), self)
self.tag_display_action = KDualAction(i18n("Show tags"),
i18n("Hide tags"), self)
self.tag_display_action.setIconForStates(KIcon("image-x-generic"))
self.tag_display_action.setEnabled(False)
# Shortcuts
connect_default = KAction.ShortcutTypes(KAction.DefaultShortcut)
connect_active = KAction.ShortcutTypes(KAction.ActiveShortcut)
self.connect_action.setShortcut(KStandardShortcut.open())
self.fetch_action.setShortcut(KStandardShortcut.find())
self.fetch_action.setEnabled(False)
self.batch_download_action.setEnabled(False)
self.pool_toggle_action.setEnabled(False)
def setup_action_collection(self):
"""Set up the action collection by adding the actions."""
action_collection = self.actionCollection()
# Addition to the action collection
action_collection.addAction("connect", self.connect_action)
action_collection.addAction("fetch", self.fetch_action)
action_collection.addAction("clean", self.clean_action)
action_collection.addAction("batchDownload",
self.batch_download_action)
action_collection.addAction("poolDownload", self.pool_toggle_action)
action_collection.addAction("tagDisplay", self.tag_display_action)
KStandardAction.quit(self.close, action_collection)
KStandardAction.preferences(self.show_preferences, action_collection)
action_collection.removeAction(
action_collection.action("help_contents"))
action_collection.actionHovered.connect(self.setup_action_tooltip)
def setup_actions(self):
"""Set up the relevant actions, tooltips, and load the RC file."""
self.create_actions()
self.setup_tooltips()
self.setup_action_collection()
# Connect signals
self.connect_action.triggered.connect(self.connect)
self.fetch_action.triggered.connect(self.get_posts)
self.clean_action.triggered.connect(self.clean_cache)
self.batch_download_action.triggered.connect(self.batch_download)
self.pool_toggle_action.toggled.connect(self.pool_toggle)
self.tag_display_action.activeChanged.connect(self.tag_display)
window_options = self.StandardWindowOption(self.ToolBar | self.Keys
| self.Create | self.Save
| self.StatusBar)
setupGUI_args = [
QSize(500, 400),
self.StandardWindowOption(window_options)
]
#Check first in standard locations for danbooruui.rc
rc_file = KStandardDirs.locate("appdata", "danbooruui.rc")
if rc_file.isEmpty():
setupGUI_args.append(os.path.join(sys.path[0], "danbooruui.rc"))
else:
setupGUI_args.append(rc_file)
self.setupGUI(*setupGUI_args)
def setup_action_tooltip(self, action):
"Show statusbar help when actions are hovered."
if action.isEnabled():
self.statusBar().showMessage(action.toolTip(), 2000)
def setup_connections(self):
"""Set up connections for post and tag retrieval."""
if self.api is None:
return
self.api.postRetrieved.connect(self.update_progress)
self.api.postDownloadFinished.connect(self.download_finished)
self.api.tagRetrieved.connect(self.tag_dock.widget().add_tags)
self.tag_dock.widget().itemDoubleClicked.connect(
self.fetch_tagged_items)
def show_preferences(self):
"Show the preferences dialog."
if KConfigDialog.showDialog("Preferences dialog"):
return
else:
dialog = preferences.PreferencesDialog(self, "Preferences dialog",
self.preferences)
dialog.show()
dialog.settingsChanged.connect(self.reload_config)
def connect(self, ok):
"Connect to a Danbooru board."
if self.thumbnailarea is None:
self.first_fetch_widget.show()
else:
self.thumbnailarea.connectwidget.show()
def restore(self):
self.statusbar.removeWidget(self.connect_widget)
def handle_connection(self, connection):
self.api = None
self.api = connection
self.api.cache = self.cache
if self.pool_dock is not None:
self.pool_dock.hide()
self.pool_dock.widget().clear()
self.pool_toggle_action.setChecked(False)
if self.thumbnailarea is not None:
#TODO: Investigate usability
self.clear(clear_pool=True)
self.thumbnailarea.clear()
self.thumbnailarea.api_data = self.api
self.setup_connections()
else:
self.first_fetch_widget.connectionEstablished.disconnect()
self.first_fetch_widget.rejected.disconnect()
self.statusbar.removeWidget(self.first_fetch_widget)
self.setup_area()
self.api.cache = self.cache
self.statusBar().showMessage(i18n("Connected to %s" % self.api.url),
3000)
self.fetch_action.setEnabled(True)
# Set up pool widget
pool_widget = poolwidget.DanbooruPoolWidget(self.api)
self.pool_dock = QDockWidget("Pools", self)
self.pool_dock.setObjectName("PoolDock")
self.pool_dock.setAllowedAreas(Qt.BottomDockWidgetArea)
self.pool_dock.setWidget(pool_widget)
#self.pool_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.BottomDockWidgetArea, self.pool_dock)
self.pool_dock.widget().poolDownloadRequested.connect(
self.pool_prepare)
self.pool_dock.hide()
self.pool_toggle_action.setEnabled(True)
self.clear() # Needed to show properly the stuff after connecting
self.api.get_post_list(tags="",
limit=self.thumbnailarea.post_limit,
rating=self.preferences.max_allowed_rating,
blacklist=list(self.preferences.tag_blacklist))
self.api.get_tag_list(name="",
blacklist=list(self.preferences.tag_blacklist),
limit=20)
def get_posts(self, ok):
"Get posts from the connected Danbooru board."
if not self.api:
return
self.thumbnailarea.fetchwidget.show()
def handle_fetching(self, tags, max_rating, limit):
"""Slot connected to the dataSent signal of the fetch widget.
The widgets are set up if they don't exist, and the API is queried
to do the actual downloading of tags and
"""
self.clear()
self.thumbnailarea.fetchwidget.hide()
if self.tag_dock is not None:
self.tag_dock.widget().clear()
self.thumbnailarea.post_limit = limit
blacklist = list(self.preferences.tag_blacklist)
self.api.get_post_list(tags=tags,
limit=limit,
rating=max_rating,
blacklist=blacklist)
tags = [item for item in tags if item]
if not tags:
# No related tags, fetch the most recent 20
tags = ""
self.api.get_tag_list(name=tags, blacklist=blacklist, limit=20)
else:
self.api.get_related_tags(tags=tags, blacklist=blacklist)
def fetch_tagged_items(self, item):
"""Fetch items found in the tag list widget."""
tag_name = unicode(item.text())
self.clear()
blacklist = self.preferences.tag_blacklist
limit = self.preferences.thumbnail_no
rating = self.preferences.max_allowed_rating
self.api.get_post_list(page=1,
tags=[tag_name],
blacklist=blacklist,
limit=limit,
rating=rating)
self.api.get_related_tags(tags=[tag_name], blacklist=blacklist)
def pool_toggle(self, checked):
"Toggle the presence/absence of the pool dock."
if not self.api:
return
if not checked:
self.pool_dock.hide()
else:
self.pool_dock.show()
def pool_prepare(self, pool_id):
"""Prepare the central area for pool image loading."""
if self.thumbnailarea is None:
self.setup_area()
else:
self.clear(clear_pool=False)
self.api.get_pool(pool_id,
blacklist=self.preferences.tag_blacklist,
rating=self.preferences.max_allowed_rating)
def batch_download(self, ok):
"Download images in batch."
selected_items = self.thumbnailarea.selected_images()
if not selected_items:
return
start_url = KUrl("kfiledialog:///danbooru")
caption = i18n("Select a directory to save the images to")
directory = KFileDialog.getExistingDirectoryUrl(
start_url, self, caption)
if directory.isEmpty():
return
for item in selected_items:
file_url = item.url_label.url()
tags = item.data.tags
# Make a local copy to append paths as addPath works in-place
destination = KUrl(directory)
file_name = KUrl(file_url).fileName()
destination.addPath(file_name)
job = KIO.file_copy(KUrl(file_url), destination, -1)
job.setProperty("tags", QVariant(tags))
job.result.connect(self.batch_download_slot)
def setup_area(self):
"Set up the central widget to display thumbnails."
self.thumbnailarea = thumbnailarea.DanbooruTabWidget(
self.api, self.preferences, self.preferences.thumbnail_no, self)
self.setCentralWidget(self.thumbnailarea)
self.thumbnailarea.connectwidget.connectionEstablished.connect(
self.handle_connection, type=Qt.UniqueConnection)
self.thumbnailarea.connectwidget.rejected.connect(
self.thumbnailarea.connectwidget.hide, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.dataSent.connect(
self.handle_fetching, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.rejected.connect(
self.thumbnailarea.fetchwidget.hide, type=Qt.UniqueConnection)
# Set up tag widget
blacklist = self.preferences.tag_blacklist
tag_widget = tagwidget.DanbooruTagWidget(blacklist, self)
self.tag_display_action.setActive(True)
self.tag_display_action.setEnabled(True)
self.tag_dock = QDockWidget("Similar tags", self)
self.tag_dock.setObjectName("TagDock")
self.tag_dock.setAllowedAreas(Qt.RightDockWidgetArea)
self.tag_dock.setWidget(tag_widget)
#self.tag_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.RightDockWidgetArea, self.tag_dock)
self.tag_dock.hide()
# Container signal-slot connections
self.setup_connections()
def download_finished(self):
"""Slot called when all the data has been completed. Clears the progress
bar and resets it to 0."""
if not self.batch_download_action.isEnabled():
self.batch_download_action.setEnabled(True)
self.__step = 0
self.progress.hide()
def update_progress(self):
"Update the progress bar."
if not self.progress.isVisible():
self.progress.show()
self.__step += 1
self.progress.setValue(self.__step)
def clear(self, clear_pool=True):
"Clear the central widget."
if self.thumbnailarea is None:
return
self.thumbnailarea.clear()
self.tag_dock.widget().clear()
if clear_pool:
self.pool_dock.widget().clear()
self.batch_download_action.setEnabled(False)
def clean_cache(self):
"Purge the thumbnail cache."
self.cache.discard()
self.statusBar().showMessage(i18n("Thumbnail cache cleared."))
def batch_download_slot(self, job):
"""Slot called when doing batch download, for each file retrieved.
If Nepomuk tagging is enabled, each file is tagged using the item's
respective tags.
"""
if job.error():
job.ui().showErrorMessage()
else:
if self.preferences.nepomuk_enabled:
tags = job.property("tags").toPyObject()
#danbooru2nepomuk.tag_danbooru_item(job.destUrl().path(),
# tags)
def tag_display(self, state):
"""Display or hide the tag dock."""
if self.tag_dock is None:
self.tag_display_action.setActive(False)
return
if state:
self.tag_dock.show()
else:
self.tag_dock.hide()
class ConflictWindow(QMainWindow):
mergeCompleted = pyqtSignal()
def __init__(self, layer, type='conflict', parent=None):
QMainWindow.__init__(self)
self.iface = parent.iface
self.layer = layer
self.parent = parent
self.layer_list = parent.layer_list
settings = QSettings()
self.tools = PgVersionTools(self)
# Restore Window Settings
settings = QSettings()
try:
self.restoreGeometry(
pybytearray(settings.value("/pgVersion/geometry")))
self.restoreState(
pybytearray(settings.value("/pgVersion/windowState")))
except:
pass
settings = QSettings()
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(
settings.value("/qgis/enable_anti_aliasing", True, type=bool))
self.canvas.useImageToRender(
settings.value("/qgis/use_qimage_to_render", True, type=bool))
action = pyint(settings.value("/qgis/wheel_action", 0))
zoomFactor = pyint(settings.value("/qgis/zoom_factor", 2))
self.canvas.setWheelAction(QgsMapCanvas.WheelAction(action),
zoomFactor)
QgsMapLayerRegistry.instance().addMapLayer(layer)
self.canvas.setExtent(layer.extent())
self.canvas.setLayerSet([QgsMapCanvasLayer(layer)])
self.canvas.zoomToFullExtent()
self.setCentralWidget(self.canvas)
actionZoomIn = QAction(
QIcon(":/plugins/pgversion/icons/mActionZoomIn.png"),
pystring("Zoom in"), self)
actionZoomOut = QAction(
QIcon(":/plugins/pgversion/icons/mActionZoomOut.png"),
pystring("Zoom out"), self)
actionZoomFull = QAction(
QIcon(":/plugins/pgversion/icons/mActionZoomFullExtent.png"),
pystring("Fullextent"), self)
actionPan = QAction(QIcon(":/plugins/pgversion/icons/mActionPan.png"),
pystring("Pan"), self)
actionZoomIn.setCheckable(True)
actionZoomOut.setCheckable(True)
actionPan.setCheckable(True)
actionZoomIn.triggered.connect(self.zoomIn)
actionZoomOut.triggered.connect(self.zoomOut)
actionZoomFull.triggered.connect(self.zoomFull)
actionPan.triggered.connect(self.pan)
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.addAction(actionPan)
self.toolbar.addAction(actionZoomIn)
self.toolbar.addAction(actionZoomOut)
self.toolbar.addAction(actionZoomFull)
self.dockWidget = QDockWidget()
self.dockWidget.setWidget(QTableWidget())
self.addDockWidget(Qt.BottomDockWidgetArea, self.dockWidget)
self.tabView = self.dockWidget.widget()
# create the map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(actionPan)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
self.toolZoomIn.setAction(actionZoomIn)
self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
self.toolZoomOut.setAction(actionZoomOut)
self.pan()
self.conflictLayerList = []
if type == 'conflict':
self.cmbMerge = QComboBox()
self.cmbMerge.addItems(self.tools.confRecords(self.layer))
self.btnMerge = QPushButton()
self.cmbMerge.currentIndexChanged.connect(self.toggleBtnMerge)
self.btnMerge.setText(self.tr('solve conflict'))
self.toolbar.addWidget(self.cmbMerge)
self.toolbar.addWidget(self.btnMerge)
self.manageConflicts()
self.btnMerge.clicked.connect(self.runMerge)
self.tabView.itemSelectionChanged.connect(self.showConfObject)
self.rBand = QgsRubberBand(self.canvas, False)
def toggleBtnMerge(self):
# if not self.btnMerge.isEnabled():
# self.btnMerge.setEnabled(False)
# else:
# self.btnMerge.setEnabled(True)
return
def toggleBtnCommit(self):
# if not self.btnMerge.isEnabled():
# self.btnMerge.setEnabled(False)
# else:
# self.btnMerge.setEnabled(True)
return
def zoomIn(self):
self.canvas.setMapTool(self.toolZoomIn)
def zoomOut(self):
self.canvas.setMapTool(self.toolZoomOut)
def zoomFull(self):
self.canvas.zoomToFullExtent()
def pan(self):
self.canvas.setMapTool(self.toolPan)
def closeEvent(self, e):
""" save window state """
# settings = QSettings()
# settings.setValue("/pgVersion/windowState", pybytearray(self.saveState()))
# settings.setValue("/pgVersion/geometry", pybytearray(self.saveGeometry()))
QgsMapLayerRegistry.instance().removeMapLayer(
self.tools.conflictLayer(self.layer).id())
self.close()
def showDiffs(self):
pass
def showConfObject(self):
myProject = self.tabView.item(self.tabView.currentRow(), 0).text()
myId = self.tabView.item(self.tabView.currentRow(), 3).text()
confLayer = self.tools.conflictLayer(self.layer)
self.conflictLayerList.append(confLayer)
self.rBand.reset()
self.rBand.setColor(QColor(0, 0, 255))
self.rBand.setWidth(5)
if confLayer.isValid():
iter = confLayer.getFeatures()
for feature in iter:
geom = feature.geometry()
attrs = feature.attributes()
if str(attrs[0]) == myId and attrs[len(attrs) -
5] == myProject:
self.rBand.addGeometry(geom, None)
return
def manageConflicts(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
vLayer = self.tools.conflictLayer(self.layer)
if vLayer == None:
return
vLayerList = [vLayer, self.layer]
QgsMapLayerRegistry.instance().addMapLayers(vLayerList, False)
self.vLayerId = vLayer.id()
self.canvas.setExtent(vLayer.extent())
self.canvas.refresh()
vLayer.triggerRepaint()
tabData = self.tools.tableRecords(self.layer)
if tabData <> None:
self.tools.createGridView(self.tabView, tabData[0], tabData[1],
100, 10)
else:
QApplication.restoreOverrideCursor()
self.mergeCompleted.emit()
QApplication.restoreOverrideCursor()
def runMerge(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
currentLayer = self.layer
object = self.cmbMerge.currentText()
if currentLayer == None:
QMessageBox.information(
None, self.tr('Notice'),
self.tr('Please select a versioned layer for committing'))
return
else:
myDb = self.tools.layerDB('Merge', currentLayer)
mySchema = self.tools.layerSchema(currentLayer)
myTable = self.tools.layerTable(currentLayer).replace(
"_version", "")
objectArray = object.split(" - ")
if len(objectArray) == 1:
return
elif 'Commit all' in objectArray[0]:
projectName = objectArray[1].strip()
sql = "select objectkey from versions.pgvscheck('%s.%s') \
where myuser = '******' or conflict_user = '******' \
order by objectkey" % (mySchema, myTable, projectName,
projectName)
result = myDb.read(sql)
for i in range(len(result['OBJECTKEY'])):
sql = "select versions.pgvsmerge('%s.%s',%s,'%s')" % (
mySchema, myTable, result['OBJECTKEY'][i], projectName)
myDb.run(sql)
else:
projectName = objectArray[1].strip()
sql = "select versions.pgvsmerge('%s.%s',%s,'%s')" % (
mySchema, myTable, objectArray[0], projectName)
myDb.run(sql)
self.canvas.refresh()
self.layer.triggerRepaint()
self.cmbMerge.clear()
QApplication.restoreOverrideCursor()
if self.tools.confRecords(self.layer) == None:
self.tabView.clear()
self.tools.setModified(self.parent.layer_list)
self.close()
else:
self.cmbMerge.addItems(self.tools.confRecords(self.layer))
tabData = self.tools.tableRecords(self.layer)
self.tools.createGridView(self.tabView, tabData[0], tabData[1],
100, 10)
self.manageConflicts()
def loadLayer(self, layer):
provider = layer.dataProvider()
uri = provider.dataSourceUri()
mySchema = self.tools.layerSchema(layer)
myHost = self.tools.layerHost(layer)
myDatabase = self.tools.layerDB(layer)
myPassword = self.tools.layerPassword(layer)
myPort = self.tools.layerPort(layer)
myUsername = self.tools.layerUsername(layer)
myGeometryColumn = self.tools.layerGeomCol(layer)
myTable = myTable.replace("_version", "")
myUri = QgsDataSourceURI()
myUri.setConnection(myHost, myPort, myDatabase, myUsername, myPassword)
myUri.setDataSource(mySchema, myTable, myGeometryColumn)
myLayer = QgsVectorLayer(myUri.uri(), "", "postgres")
QgsMapLayerRegistry.instance().addMapLayer(myLayer, False)
# self.canvas.setExtent(myLayer.extent())
self.canvas.setLayerSet([QgsMapCanvasLayer(myLayer)])
self.canvas.refresh()
class ComposerWrapper(QObject):
"""
Embeds custom STDM tools in a QgsComposer instance for managing map-based
STDM document templates.
"""
dataSourceSelected = pyqtSignal(str)
def __init__(self,composerView):
QObject.__init__(self,composerView)
self._compView = composerView
self._stdmTB = self.mainWindow().addToolBar("STDM")
self._selectMoveAction = None
#Container for custom editor widgets
self._widgetMappings = {}
#Create dock widget for configuring STDM data source
self._stdmDataSourceDock = QDockWidget(QApplication.translate("ComposerWrapper","STDM Data Source"),self.mainWindow())
self._stdmDataSourceDock.setObjectName("STDMDataSourceDock")
self._stdmDataSourceDock.setMinimumWidth(300)
self._stdmDataSourceDock.setFeatures(QDockWidget.DockWidgetMovable|QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,self._stdmDataSourceDock)
dataSourceWidget = ComposerDataSourceSelector()
self._stdmDataSourceDock.setWidget(dataSourceWidget)
self._stdmDataSourceDock.show()
#Create dock widget for configuring STDM item properties
self._stdmItemPropDock = QDockWidget(QApplication.translate("ComposerWrapper","STDM data properties"),self.mainWindow())
self._stdmItemPropDock.setObjectName("STDMItemDock")
self._stdmItemPropDock.setMinimumWidth(300)
self._stdmItemPropDock.setFeatures(QDockWidget.DockWidgetMovable|QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,self._stdmItemPropDock)
self._stdmItemPropDock.show()
if self.itemDock() != None:
self.mainWindow().tabifyDockWidget(self.itemDock(),self._stdmItemPropDock)
if self.atlasDock() != None:
self.atlasDock().hide()
if self.generalDock() != None:
self.generalDock().raise_()
#Connect signals
self.composition().itemRemoved.connect(self._onItemRemoved)
dataSourceWidget.cboDataSource.currentIndexChanged[str].connect(self.propagateDataSourceSelection)
self.composerView().selectedItemChanged.connect(self._onItemSelected)
#Current template document file
self._currDocFile = None
def _removeActions(self):
"""
Remove inapplicable actions and their corresponding toolbars and menus.
"""
removeActions = ["mActionSaveProject","mActionNewComposer","mActionDuplicateComposer"]
composerToolbar = self.composerMainToolBar()
if composerToolbar != None:
saveProjectAction = None
for itemAction in composerToolbar.actions():
if itemAction.objectName() == "mActionSaveProject":
saveProjectAction = itemAction
break
if saveProjectAction != None:
composerMenu = saveProjectAction.menu()
def configure(self):
#Create instances of custom STDM composer item configurations
for ciConfig in ComposerItemConfig.itemConfigurations:
ciConfigObj = ciConfig(self)
def addWidgetMapping(self,uniqueIdentifier,widget):
"""
Add custom STDM editor widget based on the unique identifier of the composer item
"""
self._widgetMappings[uniqueIdentifier] = widget
def widgetMappings(self):
"""
Returns a dictionary containing uuid values of composer items linked to STDM widgets.
"""
return self._widgetMappings
def clearWidgetMappings(self):
"""
Resets the widget mappings collection.
"""
self._widgetMappings = {}
def mainWindow(self):
"""
Returns the QMainWindow used by the composer view.
"""
return self._compView.composerWindow()
def stdmToolBar(self):
"""
Returns the instance of the STDM toolbar added to the QgsComposer.
"""
return self._stdmTB
def composerView(self):
"""
Returns the composer view.
"""
return self._compView
def composition(self):
"""
Returns the QgsComposition instance used in the composer view.
"""
return self._compView.composition()
def composerItemToolBar(self):
"""
Returns the toolbar containing actions for adding composer items.
"""
return self.mainWindow().findChild(QToolBar,"mItemToolbar")
def composerMainToolBar(self):
"""
Returns the toolbar containing actions for managing templates.
"""
return self.mainWindow().findChild(QToolBar,"mComposerToolbar")
def selectMoveAction(self):
"""
Returns the QAction for selecting or moving composer items.
"""
if self.composerItemToolBar() != None:
if self._selectMoveAction == None:
for itemAction in self.composerItemToolBar().actions():
if itemAction.objectName() == "mActionSelectMoveItem":
self._selectMoveAction = itemAction
break
return self._selectMoveAction
def checkedItemAction(self):
"""
Returns the currently selected composer item action.
"""
if self.selectMoveAction() != None:
return self.selectMoveAction().actionGroup().checkedAction()
return None
def itemDock(self):
"""
Get the 'Item Properties' dock widget.
"""
return self.mainWindow().findChild(QDockWidget,"ItemDock")
def atlasDock(self):
"""
Get the 'Atlas generation' dock widget.
"""
return self.mainWindow().findChild(QDockWidget,"AtlasDock")
def generalDock(self):
"""
Get the 'Composition' dock widget.
"""
return self.mainWindow().findChild(QDockWidget,"CompositionDock")
def stdmDataSourceDock(self):
"""
Returns the STDM data source dock widget.
"""
return self._stdmDataSourceDock
def stdmItemDock(self):
"""
Returns the STDM item dock widget.
"""
return self._stdmItemPropDock
def documentFile(self):
"""
Returns the QFile instance associated with the current document. 'None' will be returned for
new, unsaved documents.
"""
return self._currDocFile
def setDocumentFile(self,docFile):
"""
Sets the document file.
"""
if not isinstance(docFile,QFile):
return
self._currDocFile = docFile
def selectedDataSource(self):
"""
Returns the name of the data source specified by the user.
"""
return self._stdmDataSourceDock.widget().cboDataSource.currentText()
def selectedDataSourceCategory(self):
"""
Returns the category (view or table) that the data source belongs to.
"""
if self.stdmDataSourceDock().widget() != None:
return self.stdmDataSourceDock().widget().category()
return ""
def propagateDataSourceSelection(self,dataSourceName):
"""
Propagates the signal when a user select a data source. Listening objects can hook on to it.
"""
self.dataSourceSelected.emit(dataSourceName)
def loadTemplate(self,filePath):
"""
Loads a document template into the view and updates the necessary STDM-related controls.
"""
if not QFile.exists(filePath):
QMessageBox.critical(self.composerView(), QApplication.translate("OpenTemplateConfig","Open Template Error"), \
QApplication.translate("OpenTemplateConfig","The specified template does not exist."))
return
templateFile = QFile(filePath)
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Open Operation Error"), \
"{0}\n{1}".format(QApplication.translate("ComposerWrapper","Cannot read template file."), \
templateFile.errorString()
))
return
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
#Load items into the composition and configure STDM data controls
self.composition().loadFromTemplate(templateDoc)
self.clearWidgetMappings()
#Load data controls
composerDS = ComposerDataSource.create(templateDoc)
self._configureDataControls(composerDS)
#Load symbol editors
spatialFieldsConfig = SpatialFieldsConfiguration.create(templateDoc)
self._configureSpatialSymbolEditor(spatialFieldsConfig)
def saveTemplate(self):
"""
Creates and saves a new document template.
"""
#Validate if the user has specified the data source
if self.selectedDataSource() == "":
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \
QApplication.translate("ComposerWrapper","Please specify the " \
"data source name for the document composition."))
return
#If it is a new unsaved document template then prompt for the document name.
docFile = self.documentFile()
if docFile == None:
docName,ok = QInputDialog.getText(self.composerView(), \
QApplication.translate("ComposerWrapper","Template Name"), \
QApplication.translate("ComposerWrapper","Please enter the template name below"), \
)
if ok and docName != "":
templateDir = self._composerTemplatesPath()
if templateDir == None:
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \
QApplication.translate("ComposerWrapper","Directory for document templates could not be found."))
return
absPath = templateDir + "/" + docName + ".sdt"
docFile= QFile(absPath)
else:
return
docFileInfo = QFileInfo(docFile)
if not docFile.open(QIODevice.WriteOnly):
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Operation Error"), \
"{0}\n{1}".format(QApplication.translate("ComposerWrapper","Could not save template file."), \
docFile.errorString()
))
return
templateDoc = QDomDocument()
self._writeXML(templateDoc,docFileInfo.completeBaseName())
if docFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Error"), \
QApplication.translate("ComposerWrapper","Could not save template file."))
return
docFile.close()
self.setDocumentFile(docFile)
def _writeXML(self,xmlDoc,docName):
"""
Write the template configuration into the XML document.
"""
#Write default composer configuration
composerElement = xmlDoc.createElement("Composer")
composerElement.setAttribute("title",docName)
composerElement.setAttribute("visible",1)
xmlDoc.appendChild(composerElement)
self.composition().writeXML(composerElement,xmlDoc)
#Write STDM data field configurations
dataSourceElement = ComposerDataSource.domElement(self, xmlDoc)
composerElement.appendChild(dataSourceElement)
#Write spatial field configurations
spatialColumnsElement = SpatialFieldsConfiguration.domElement(self, xmlDoc)
dataSourceElement.appendChild(spatialColumnsElement)
def _configureDataControls(self,composerDataSource):
"""
Configure the data source and data field controls based on the composer data
source configuration.
"""
if self.stdmDataSourceDock().widget() != None:
#Set data source
dataSourceWidget = self.stdmDataSourceDock().widget()
dataSourceWidget.setCategory(composerDataSource.category())
dataSourceWidget.setSelectedSource(composerDataSource.name())
#Set data field controls
for composerId in composerDataSource.dataFieldMappings().reverse:
#Use composer item id since the uuid is stripped off
composerItem = self.composition().getComposerItemById(composerId)
if composerItem != None:
compFieldSelector = ComposerFieldSelector(self,composerItem,self.composerView())
compFieldSelector.selectFieldName(composerDataSource.dataFieldName(composerId))
#Add widget to the collection but now use the current uuid of the composition item
self.addWidgetMapping(composerItem.uuid(),compFieldSelector)
def _configureSpatialSymbolEditor(self,spatialFieldConfig):
"""
Configure symbol editor controls.
"""
if self.stdmDataSourceDock().widget() != None:
for itemId,spFieldsMappings in spatialFieldConfig.spatialFieldsMapping().iteritems():
mapItem = self.composition().getComposerItemById(itemId)
if mapItem != None:
composerSymbolEditor = ComposerSymbolEditor(self,self.composerView())
composerSymbolEditor.addSpatialFieldMappings(spFieldsMappings)
#Add widget to the collection but now use the current uuid of the composer map
self.addWidgetMapping(mapItem.uuid(),composerSymbolEditor)
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]
def _onItemRemoved(self,item):
"""
Slot raised when a composer item is removed from the scene.
"""
"""
Code will not work since a QObject instance is returned instead of a QgsComposerItem
if item.uuid() in self._widgetMappings:
del self._widgetMappings[item.uuid()]
"""
pass
def _onItemSelected(self,item):
"""
Slot raised when a composer item is selected. Load the corresponding field selector
if the selection is an STDM data field label.
QComposerLabel is returned as a QObject in the slot argument hence, we have resorted to
capturing the currently selected items in the composition.
"""
selectedItems = self.composition().selectedComposerItems()
if len(selectedItems) == 0:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) == 1:
composerItem = selectedItems[0]
if composerItem.uuid() in self._widgetMappings:
stdmWidget = self._widgetMappings[composerItem.uuid()]
if stdmWidget == self._stdmItemPropDock.widget():
return
else:
self._stdmItemPropDock.setWidget(stdmWidget)
#Playing it safe in applying the formatting for the editor controls where applicable
itemFormatter = None
if isinstance(composerItem,QgsComposerArrow):
itemFormatter = LineFormatter()
elif isinstance(composerItem,QgsComposerLabel):
itemFormatter = DataLabelFormatter()
elif isinstance(composerItem,QgsComposerMap):
itemFormatter = MapFormatter()
if itemFormatter != None:
itemFormatter.apply(composerItem,self,True)
else:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) > 1:
self._stdmItemPropDock.setWidget(None)
class MainWindow(KXmlGuiWindow):
"Class which displays the main Danbooru Client window."
def __init__(self, *args):
"Initialize a new main window."
super(MainWindow, self).__init__(*args)
self.cache = KPixmapCache("danbooru")
self.preferences = preferences.Preferences()
self.api = None
self.__ratings = None
self.__step = 0
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
self.statusbar = self.statusBar()
self.progress = QProgressBar()
self.thumbnailarea = None
self.tag_dock = None
self.pool_dock = None
self.first_fetch_widget = None
self.progress.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
# FIXME: Hackish, but how to make it small otherwise?
self.progress.setMinimumSize(100, 1)
self.statusbar.addPermanentWidget(self.progress)
self.progress.hide()
self.setup_welcome_widget()
self.setup_actions()
def reload_config(self):
"""Reload configuration after a change"""
urls = self.preferences.boards_list
if self.first_fetch_widget is not None:
self.first_fetch_widget.setup_urls(urls)
if self.thumbnailarea is not None:
max_thumbnail = self.preferences.thumbnail_no
max_rating = self.preferences.max_allowed_rating
self.thumbnailarea.fetchwidget.limit = max_thumbnail
self.thumbnailarea.fetchwidget.rating = max_rating
self.thumbnailarea.fetchwidget.update_values()
self.thumbnailarea.connectwidget.setup_urls(urls)
self.url_list = self.preferences.boards_list
self.max_retrieve = self.preferences.thumbnail_no
def setup_welcome_widget(self):
"""Load the welcome widget at startup."""
widget = QWidget()
layout = QVBoxLayout()
welcome = QLabel(parent=self)
pix = QPixmap(KStandardDirs.locate("appdata","logo.png"))
welcome.setPixmap(pix)
welcome.setAlignment(Qt.AlignCenter)
self.first_fetch_widget = connectwidget.ConnectWidget(
self.preferences.boards_list, self)
self.statusbar.addPermanentWidget(self.first_fetch_widget, 300)
self.first_fetch_widget.connectionEstablished.connect(
self.handle_connection)
self.first_fetch_widget.rejected.connect(
self.first_fetch_widget.hide)
self.first_fetch_widget.hide()
self.first_fetch_widget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
layout.addWidget(self.first_fetch_widget)
layout.addWidget(welcome)
widget.setLayout(layout)
self.setCentralWidget(widget)
def setup_tooltips(self):
"""Set tooltips for the actions."""
self.connect_action.setToolTip(i18n("Connect to a Danbooru board"))
self.fetch_action.setToolTip(
i18n("Fetch thumbnails from a Danbooru board")
)
self.batch_download_action.setToolTip(i18n("Batch download images"))
def create_actions(self):
"""Create actions for the main window."""
self.connect_action = KAction(KIcon("document-open-remote"),
i18n("Connect"), self)
self.fetch_action = KAction(KIcon("download"), i18n("Download"),
self)
self.clean_action = KAction(KIcon("trash-empty"),
i18n("Clear thumbnail cache"),
self)
self.batch_download_action = KAction(KIcon("download"),
i18n("Batch download"), self)
self.pool_toggle_action = KToggleAction(KIcon("image-x-generic"),
i18n("Pools"), self)
self.tag_display_action = KDualAction(i18n("Show tags"),
i18n("Hide tags"),
self)
self.tag_display_action.setIconForStates(KIcon("image-x-generic"))
self.tag_display_action.setEnabled(False)
# Shortcuts
connect_default = KAction.ShortcutTypes(KAction.DefaultShortcut)
connect_active = KAction.ShortcutTypes(KAction.ActiveShortcut)
self.connect_action.setShortcut(KStandardShortcut.open())
self.fetch_action.setShortcut(KStandardShortcut.find())
self.fetch_action.setEnabled(False)
self.batch_download_action.setEnabled(False)
self.pool_toggle_action.setEnabled(False)
def setup_action_collection(self):
"""Set up the action collection by adding the actions."""
action_collection = self.actionCollection()
# Addition to the action collection
action_collection.addAction("connect", self.connect_action)
action_collection.addAction("fetch", self.fetch_action)
action_collection.addAction("clean", self.clean_action)
action_collection.addAction("batchDownload", self.batch_download_action)
action_collection.addAction("poolDownload", self.pool_toggle_action)
action_collection.addAction("tagDisplay", self.tag_display_action)
KStandardAction.quit (self.close, action_collection)
KStandardAction.preferences(self.show_preferences,
action_collection)
action_collection.removeAction(
action_collection.action("help_contents"))
action_collection.actionHovered.connect(self.setup_action_tooltip)
def setup_actions(self):
"""Set up the relevant actions, tooltips, and load the RC file."""
self.create_actions()
self.setup_tooltips()
self.setup_action_collection()
# Connect signals
self.connect_action.triggered.connect(self.connect)
self.fetch_action.triggered.connect(self.get_posts)
self.clean_action.triggered.connect(self.clean_cache)
self.batch_download_action.triggered.connect(self.batch_download)
self.pool_toggle_action.toggled.connect(self.pool_toggle)
self.tag_display_action.activeChanged.connect(self.tag_display)
window_options = self.StandardWindowOption(self.ToolBar| self.Keys |
self.Create | self.Save |
self.StatusBar)
setupGUI_args = [
QSize(500, 400), self.StandardWindowOption(window_options)
]
#Check first in standard locations for danbooruui.rc
rc_file = KStandardDirs.locate("appdata", "danbooruui.rc")
if rc_file.isEmpty():
setupGUI_args.append(os.path.join(sys.path [0],
"danbooruui.rc"))
else:
setupGUI_args.append(rc_file)
self.setupGUI(*setupGUI_args)
def setup_action_tooltip(self, action):
"Show statusbar help when actions are hovered."
if action.isEnabled():
self.statusBar().showMessage(action.toolTip(), 2000)
def setup_connections(self):
"""Set up connections for post and tag retrieval."""
if self.api is None:
return
self.api.postRetrieved.connect(self.update_progress)
self.api.postDownloadFinished.connect(self.download_finished)
self.api.tagRetrieved.connect(self.tag_dock.widget().add_tags)
self.tag_dock.widget().itemDoubleClicked.connect(
self.fetch_tagged_items)
def show_preferences(self):
"Show the preferences dialog."
if KConfigDialog.showDialog("Preferences dialog"):
return
else:
dialog = preferences.PreferencesDialog(self, "Preferences dialog",
self.preferences)
dialog.show()
dialog.settingsChanged.connect(self.reload_config)
def connect(self, ok):
"Connect to a Danbooru board."
if self.thumbnailarea is None:
self.first_fetch_widget.show()
else:
self.thumbnailarea.connectwidget.show()
def restore(self):
self.statusbar.removeWidget(self.connect_widget)
def handle_connection(self, connection):
self.api = None
self.api = connection
self.api.cache = self.cache
if self.pool_dock is not None:
self.pool_dock.hide()
self.pool_dock.widget().clear()
self.pool_toggle_action.setChecked(False)
if self.thumbnailarea is not None:
#TODO: Investigate usability
self.clear(clear_pool=True)
self.thumbnailarea.clear()
self.thumbnailarea.api_data = self.api
self.setup_connections()
else:
self.first_fetch_widget.connectionEstablished.disconnect()
self.first_fetch_widget.rejected.disconnect()
self.statusbar.removeWidget(self.first_fetch_widget)
self.setup_area()
self.api.cache = self.cache
self.statusBar().showMessage(i18n("Connected to %s" % self.api.url),
3000)
self.fetch_action.setEnabled(True)
# Set up pool widget
pool_widget = poolwidget.DanbooruPoolWidget(self.api)
self.pool_dock = QDockWidget("Pools", self)
self.pool_dock.setObjectName("PoolDock")
self.pool_dock.setAllowedAreas(Qt.BottomDockWidgetArea)
self.pool_dock.setWidget(pool_widget)
#self.pool_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.BottomDockWidgetArea, self.pool_dock)
self.pool_dock.widget().poolDownloadRequested.connect(
self.pool_prepare)
self.pool_dock.hide()
self.pool_toggle_action.setEnabled(True)
self.clear() # Needed to show properly the stuff after connecting
self.api.get_post_list(tags="", limit=self.thumbnailarea.post_limit,
rating=self.preferences.max_allowed_rating,
blacklist=list(self.preferences.tag_blacklist))
self.api.get_tag_list(name="",blacklist=list(self.preferences.tag_blacklist),
limit=20)
def get_posts(self, ok):
"Get posts from the connected Danbooru board."
if not self.api:
return
self.thumbnailarea.fetchwidget.show()
def handle_fetching(self, tags, max_rating, limit):
"""Slot connected to the dataSent signal of the fetch widget.
The widgets are set up if they don't exist, and the API is queried
to do the actual downloading of tags and
"""
self.clear()
self.thumbnailarea.fetchwidget.hide()
if self.tag_dock is not None:
self.tag_dock.widget().clear()
self.thumbnailarea.post_limit = limit
blacklist= list(self.preferences.tag_blacklist)
self.api.get_post_list(tags=tags, limit=limit,
rating=max_rating,
blacklist=blacklist)
tags = [item for item in tags if item]
if not tags:
# No related tags, fetch the most recent 20
tags = ""
self.api.get_tag_list(name=tags,blacklist=blacklist,
limit=20)
else:
self.api.get_related_tags(tags=tags, blacklist=blacklist)
def fetch_tagged_items(self, item):
"""Fetch items found in the tag list widget."""
tag_name = unicode(item.text())
self.clear()
blacklist = self.preferences.tag_blacklist
limit = self.preferences.thumbnail_no
rating = self.preferences.max_allowed_rating
self.api.get_post_list(page=1, tags=[tag_name],
blacklist=blacklist,
limit=limit,
rating=rating)
self.api.get_related_tags(tags=[tag_name], blacklist=blacklist)
def pool_toggle(self, checked):
"Toggle the presence/absence of the pool dock."
if not self.api:
return
if not checked:
self.pool_dock.hide()
else:
self.pool_dock.show()
def pool_prepare(self, pool_id):
"""Prepare the central area for pool image loading."""
if self.thumbnailarea is None:
self.setup_area()
else:
self.clear(clear_pool=False)
self.api.get_pool(pool_id, blacklist=self.preferences.tag_blacklist,
rating=self.preferences.max_allowed_rating)
def batch_download(self, ok):
"Download images in batch."
selected_items = self.thumbnailarea.selected_images()
if not selected_items:
return
start_url = KUrl("kfiledialog:///danbooru")
caption = i18n("Select a directory to save the images to")
directory = KFileDialog.getExistingDirectoryUrl(start_url, self,
caption)
if directory.isEmpty():
return
for item in selected_items:
file_url = item.url_label.url()
tags = item.data.tags
# Make a local copy to append paths as addPath works in-place
destination = KUrl(directory)
file_name = KUrl(file_url).fileName()
destination.addPath(file_name)
job = KIO.file_copy(KUrl(file_url), destination, -1)
job.setProperty("tags", QVariant(tags))
job.result.connect(self.batch_download_slot)
def setup_area(self):
"Set up the central widget to display thumbnails."
self.thumbnailarea = thumbnailarea.DanbooruTabWidget(self.api,
self.preferences, self.preferences.thumbnail_no, self)
self.setCentralWidget(self.thumbnailarea)
self.thumbnailarea.connectwidget.connectionEstablished.connect(
self.handle_connection, type=Qt.UniqueConnection)
self.thumbnailarea.connectwidget.rejected.connect(
self.thumbnailarea.connectwidget.hide, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.dataSent.connect(
self.handle_fetching, type=Qt.UniqueConnection)
self.thumbnailarea.fetchwidget.rejected.connect(
self.thumbnailarea.fetchwidget.hide, type=Qt.UniqueConnection)
# Set up tag widget
blacklist = self.preferences.tag_blacklist
tag_widget = tagwidget.DanbooruTagWidget(blacklist, self)
self.tag_display_action.setActive(True)
self.tag_display_action.setEnabled(True)
self.tag_dock = QDockWidget("Similar tags", self)
self.tag_dock.setObjectName("TagDock")
self.tag_dock.setAllowedAreas(Qt.RightDockWidgetArea)
self.tag_dock.setWidget(tag_widget)
#self.tag_dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
self.addDockWidget(Qt.RightDockWidgetArea, self.tag_dock)
self.tag_dock.hide()
# Container signal-slot connections
self.setup_connections()
def download_finished(self):
"""Slot called when all the data has been completed. Clears the progress
bar and resets it to 0."""
if not self.batch_download_action.isEnabled():
self.batch_download_action.setEnabled(True)
self.__step = 0
self.progress.hide()
def update_progress(self):
"Update the progress bar."
if not self.progress.isVisible():
self.progress.show()
self.__step += 1
self.progress.setValue(self.__step)
def clear(self, clear_pool=True):
"Clear the central widget."
if self.thumbnailarea is None:
return
self.thumbnailarea.clear()
self.tag_dock.widget().clear()
if clear_pool:
self.pool_dock.widget().clear()
self.batch_download_action.setEnabled(False)
def clean_cache(self):
"Purge the thumbnail cache."
self.cache.discard()
self.statusBar().showMessage(i18n("Thumbnail cache cleared."))
def batch_download_slot(self, job):
"""Slot called when doing batch download, for each file retrieved.
If Nepomuk tagging is enabled, each file is tagged using the item's
respective tags.
"""
if job.error():
job.ui().showErrorMessage()
else:
if self.preferences.nepomuk_enabled:
tags = job.property("tags").toPyObject()
#danbooru2nepomuk.tag_danbooru_item(job.destUrl().path(),
# tags)
def tag_display(self, state):
"""Display or hide the tag dock."""
if self.tag_dock is None:
self.tag_display_action.setActive(False)
return
if state:
self.tag_dock.show()
else:
self.tag_dock.hide()
class PluginManualIntegrator(MSPlugin):
def __init__(self, model, view, parent=None):
MSPlugin.__init__(self, model, view, parent)
#self.connect(self.view.mdiArea, SIGNAL('subWindowActivated(QMdiSubWindow*)'), self.updateCurrentWindow)
self.guiWidget=[]
self.view.mdiArea.subWindowActivated.connect(self.updateCurrentWindow)
self.x1val=0
self.dock=QDockWidget("Manual Integrator")
self.guiWidget.append(self.dock)
self.window=self.view.mdiArea.activeSubWindow() if self.view.mdiArea.activeSubWindow() else None
if self.window is not None:
#self.connect(self.window.widget().pw,
# SIGNAL(self.window.widget().pw.sigMouseReleased),
# self.pluginAlgorithm)
self.window.widget().pw.plotItem.vb.sigClick.connect(self.pluginAlgorithm)
self.label=QLabel('Inactive') if not self.window else QLabel('Active')
self.dock.setWidget(self.label)
self._guiUpdate()
def _guiUpdate(self):
self.view.addDockWidget(0x1, self.dock)#showInformationMessage('test', "Hello From Integrator Plugin")
def _buildConnections(self):pass
def updateCurrentWindow(self, win):
if win is None:return
#print "update current window", win
self.window=win
#self.connect(self.window.widget().pw,
# SIGNAL(self.window.widget().pw.sigMouseReleased),
# self.pluginAlgorithm)
self.window.widget().pw.plotItem.vb.sigClick.connect(self.pluginAlgorithm)
self.dock.setWidget(Widget(self.dock))
def pluginAlgorithm(self, e):
"""
receive the event off release MouseEvent
"""
if not self.x1val:
self.x1val=e.x()
self.dock.widget().x1.setText(str(self.x1val))
self.dock.widget().x2.setText('')
self.dock.widget().result.setText('')
return
x2=e.x()
self.dock.widget().x2.setText(str(x2))
chrom=self.window.widget().data[0] #take the first one
res=chrom.integrationBtw(self.x1val, x2)
self.dock.widget().result.setText(",success:".join([str(res[2]), str(res[3])]))
self.x1val=0
#self.reinitialize()
def reinitialize(self):
self.x1val=0
self.dock.widget().x2.setText('')
self.dock.widget().x1.setText('')
def unload(self):
for e in self.guiWidget:
e.setParent(None)
del e
self.view.update()
class ComposerWrapper(QObject):
"""
Embeds custom STDM tools in a QgsComposer instance for managing map-based
STDM document templates.
"""
dataSourceSelected = pyqtSignal(str)
def __init__(self, composerView):
QObject.__init__(self, composerView)
self._compView = composerView
self._stdmTB = self.mainWindow().addToolBar("STDM")
self._selectMoveAction = None
#Container for custom editor widgets
self._widgetMappings = {}
#Create dock widget for configuring STDM data source
self._stdmDataSourceDock = QDockWidget(
QApplication.translate("ComposerWrapper", "STDM Data Source"),
self.mainWindow())
self._stdmDataSourceDock.setObjectName("STDMDataSourceDock")
self._stdmDataSourceDock.setMinimumWidth(300)
self._stdmDataSourceDock.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,
self._stdmDataSourceDock)
dataSourceWidget = ComposerDataSourceSelector()
self._stdmDataSourceDock.setWidget(dataSourceWidget)
self._stdmDataSourceDock.show()
#Create dock widget for configuring STDM item properties
self._stdmItemPropDock = QDockWidget(
QApplication.translate("ComposerWrapper", "STDM data properties"),
self.mainWindow())
self._stdmItemPropDock.setObjectName("STDMItemDock")
self._stdmItemPropDock.setMinimumWidth(300)
self._stdmItemPropDock.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetClosable)
self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,
self._stdmItemPropDock)
self._stdmItemPropDock.show()
if self.itemDock() != None:
self.mainWindow().tabifyDockWidget(self.itemDock(),
self._stdmItemPropDock)
if self.atlasDock() != None:
self.atlasDock().hide()
if self.generalDock() != None:
self.generalDock().raise_()
#Connect signals
self.composition().itemRemoved.connect(self._onItemRemoved)
dataSourceWidget.cboDataSource.currentIndexChanged[str].connect(
self.propagateDataSourceSelection)
self.composerView().selectedItemChanged.connect(self._onItemSelected)
#Current template document file
self._currDocFile = None
def _removeActions(self):
"""
Remove inapplicable actions and their corresponding toolbars and menus.
"""
removeActions = [
"mActionSaveProject", "mActionNewComposer",
"mActionDuplicateComposer"
]
composerToolbar = self.composerMainToolBar()
if composerToolbar != None:
saveProjectAction = None
for itemAction in composerToolbar.actions():
if itemAction.objectName() == "mActionSaveProject":
saveProjectAction = itemAction
break
if saveProjectAction != None:
composerMenu = saveProjectAction.menu()
def configure(self):
#Create instances of custom STDM composer item configurations
for ciConfig in ComposerItemConfig.itemConfigurations:
ciConfigObj = ciConfig(self)
def addWidgetMapping(self, uniqueIdentifier, widget):
"""
Add custom STDM editor widget based on the unique identifier of the composer item
"""
self._widgetMappings[uniqueIdentifier] = widget
def widgetMappings(self):
"""
Returns a dictionary containing uuid values of composer items linked to STDM widgets.
"""
return self._widgetMappings
def clearWidgetMappings(self):
"""
Resets the widget mappings collection.
"""
self._widgetMappings = {}
def mainWindow(self):
"""
Returns the QMainWindow used by the composer view.
"""
return self._compView.composerWindow()
def stdmToolBar(self):
"""
Returns the instance of the STDM toolbar added to the QgsComposer.
"""
return self._stdmTB
def composerView(self):
"""
Returns the composer view.
"""
return self._compView
def composition(self):
"""
Returns the QgsComposition instance used in the composer view.
"""
return self._compView.composition()
def composerItemToolBar(self):
"""
Returns the toolbar containing actions for adding composer items.
"""
return self.mainWindow().findChild(QToolBar, "mItemToolbar")
def composerMainToolBar(self):
"""
Returns the toolbar containing actions for managing templates.
"""
return self.mainWindow().findChild(QToolBar, "mComposerToolbar")
def selectMoveAction(self):
"""
Returns the QAction for selecting or moving composer items.
"""
if self.composerItemToolBar() != None:
if self._selectMoveAction == None:
for itemAction in self.composerItemToolBar().actions():
if itemAction.objectName() == "mActionSelectMoveItem":
self._selectMoveAction = itemAction
break
return self._selectMoveAction
def checkedItemAction(self):
"""
Returns the currently selected composer item action.
"""
if self.selectMoveAction() != None:
return self.selectMoveAction().actionGroup().checkedAction()
return None
def itemDock(self):
"""
Get the 'Item Properties' dock widget.
"""
return self.mainWindow().findChild(QDockWidget, "ItemDock")
def atlasDock(self):
"""
Get the 'Atlas generation' dock widget.
"""
return self.mainWindow().findChild(QDockWidget, "AtlasDock")
def generalDock(self):
"""
Get the 'Composition' dock widget.
"""
return self.mainWindow().findChild(QDockWidget, "CompositionDock")
def stdmDataSourceDock(self):
"""
Returns the STDM data source dock widget.
"""
return self._stdmDataSourceDock
def stdmItemDock(self):
"""
Returns the STDM item dock widget.
"""
return self._stdmItemPropDock
def documentFile(self):
"""
Returns the QFile instance associated with the current document. 'None' will be returned for
new, unsaved documents.
"""
return self._currDocFile
def setDocumentFile(self, docFile):
"""
Sets the document file.
"""
if not isinstance(docFile, QFile):
return
self._currDocFile = docFile
def selectedDataSource(self):
"""
Returns the name of the data source specified by the user.
"""
return self._stdmDataSourceDock.widget().cboDataSource.currentText()
def selectedDataSourceCategory(self):
"""
Returns the category (view or table) that the data source belongs to.
"""
if self.stdmDataSourceDock().widget() != None:
return self.stdmDataSourceDock().widget().category()
return ""
def propagateDataSourceSelection(self, dataSourceName):
"""
Propagates the signal when a user select a data source. Listening objects can hook on to it.
"""
self.dataSourceSelected.emit(dataSourceName)
def loadTemplate(self, filePath):
"""
Loads a document template into the view and updates the necessary STDM-related controls.
"""
if not QFile.exists(filePath):
QMessageBox.critical(self.composerView(), QApplication.translate("OpenTemplateConfig","Open Template Error"), \
QApplication.translate("OpenTemplateConfig","The specified template does not exist."))
return
templateFile = QFile(filePath)
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Open Operation Error"), \
"{0}\n{1}".format(QApplication.translate("ComposerWrapper","Cannot read template file."), \
templateFile.errorString()
))
return
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
#Load items into the composition and configure STDM data controls
self.composition().loadFromTemplate(templateDoc)
self.clearWidgetMappings()
#Load data controls
composerDS = ComposerDataSource.create(templateDoc)
self._configureDataControls(composerDS)
#Load symbol editors
spatialFieldsConfig = SpatialFieldsConfiguration.create(
templateDoc)
self._configureSpatialSymbolEditor(spatialFieldsConfig)
def saveTemplate(self):
"""
Creates and saves a new document template.
"""
#Validate if the user has specified the data source
if self.selectedDataSource() == "":
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \
QApplication.translate("ComposerWrapper","Please specify the " \
"data source name for the document composition."))
return
#If it is a new unsaved document template then prompt for the document name.
docFile = self.documentFile()
if docFile == None:
docName,ok = QInputDialog.getText(self.composerView(), \
QApplication.translate("ComposerWrapper","Template Name"), \
QApplication.translate("ComposerWrapper","Please enter the template name below"), \
)
if ok and docName != "":
templateDir = self._composerTemplatesPath()
if templateDir == None:
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \
QApplication.translate("ComposerWrapper","Directory for document templates could not be found."))
return
absPath = templateDir + "/" + docName + ".sdt"
docFile = QFile(absPath)
else:
return
docFileInfo = QFileInfo(docFile)
if not docFile.open(QIODevice.WriteOnly):
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Operation Error"), \
"{0}\n{1}".format(QApplication.translate("ComposerWrapper","Could not save template file."), \
docFile.errorString()
))
return
templateDoc = QDomDocument()
self._writeXML(templateDoc, docFileInfo.completeBaseName())
if docFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Error"), \
QApplication.translate("ComposerWrapper","Could not save template file."))
return
docFile.close()
self.setDocumentFile(docFile)
def _writeXML(self, xmlDoc, docName):
"""
Write the template configuration into the XML document.
"""
#Write default composer configuration
composerElement = xmlDoc.createElement("Composer")
composerElement.setAttribute("title", docName)
composerElement.setAttribute("visible", 1)
xmlDoc.appendChild(composerElement)
self.composition().writeXML(composerElement, xmlDoc)
#Write STDM data field configurations
dataSourceElement = ComposerDataSource.domElement(self, xmlDoc)
composerElement.appendChild(dataSourceElement)
#Write spatial field configurations
spatialColumnsElement = SpatialFieldsConfiguration.domElement(
self, xmlDoc)
dataSourceElement.appendChild(spatialColumnsElement)
def _configureDataControls(self, composerDataSource):
"""
Configure the data source and data field controls based on the composer data
source configuration.
"""
if self.stdmDataSourceDock().widget() != None:
#Set data source
dataSourceWidget = self.stdmDataSourceDock().widget()
dataSourceWidget.setCategory(composerDataSource.category())
dataSourceWidget.setSelectedSource(composerDataSource.name())
#Set data field controls
for composerId in composerDataSource.dataFieldMappings().reverse:
#Use composer item id since the uuid is stripped off
composerItem = self.composition().getComposerItemById(
composerId)
if composerItem != None:
compFieldSelector = ComposerFieldSelector(
self, composerItem, self.composerView())
compFieldSelector.selectFieldName(
composerDataSource.dataFieldName(composerId))
#Add widget to the collection but now use the current uuid of the composition item
self.addWidgetMapping(composerItem.uuid(),
compFieldSelector)
def _configureSpatialSymbolEditor(self, spatialFieldConfig):
"""
Configure symbol editor controls.
"""
if self.stdmDataSourceDock().widget() != None:
for itemId, spFieldsMappings in spatialFieldConfig.spatialFieldsMapping(
).iteritems():
mapItem = self.composition().getComposerItemById(itemId)
if mapItem != None:
composerSymbolEditor = ComposerSymbolEditor(
self, self.composerView())
composerSymbolEditor.addSpatialFieldMappings(
spFieldsMappings)
#Add widget to the collection but now use the current uuid of the composer map
self.addWidgetMapping(mapItem.uuid(), composerSymbolEditor)
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]
def _onItemRemoved(self, item):
"""
Slot raised when a composer item is removed from the scene.
"""
"""
Code will not work since a QObject instance is returned instead of a QgsComposerItem
if item.uuid() in self._widgetMappings:
del self._widgetMappings[item.uuid()]
"""
pass
def _onItemSelected(self, item):
"""
Slot raised when a composer item is selected. Load the corresponding field selector
if the selection is an STDM data field label.
QComposerLabel is returned as a QObject in the slot argument hence, we have resorted to
capturing the currently selected items in the composition.
"""
selectedItems = self.composition().selectedComposerItems()
if len(selectedItems) == 0:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) == 1:
composerItem = selectedItems[0]
if composerItem.uuid() in self._widgetMappings:
stdmWidget = self._widgetMappings[composerItem.uuid()]
if stdmWidget == self._stdmItemPropDock.widget():
return
else:
self._stdmItemPropDock.setWidget(stdmWidget)
#Playing it safe in applying the formatting for the editor controls where applicable
itemFormatter = None
if isinstance(composerItem, QgsComposerArrow):
itemFormatter = LineFormatter()
elif isinstance(composerItem, QgsComposerLabel):
itemFormatter = DataLabelFormatter()
elif isinstance(composerItem, QgsComposerMap):
itemFormatter = MapFormatter()
if itemFormatter != None:
itemFormatter.apply(composerItem, self, True)
else:
self._stdmItemPropDock.setWidget(None)
elif len(selectedItems) > 1:
self._stdmItemPropDock.setWidget(None)
