def processAlgorithm(self, progress):
"""Here is where the processing itself takes place."""
# The first thing to do is retrieve the values of the parameters
# entered by the user
inputFilename = self.getParameterValue(self.INPUT_LAYER)
output = self.getOutputValue(self.OUTPUT_LAYER)
# Input layers vales are always a string with its location.
# That string can be converted into a QGIS object (a
# QgsVectorLayer in this case) using the
# processing.getObjectFromUri() method.
vectorLayer = dataobjects.getObjectFromUri(inputFilename)
# And now we can process
# First we create the output layer. The output value entered by
# the user is a string containing a filename, so we can use it
# directly
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
provider = vectorLayer.dataProvider()
writer = QgsVectorFileWriter(output, systemEncoding,
provider.fields(),
provider.geometryType(), provider.crs())
# Now we take the features from input layer and add them to the
# output. Method features() returns an iterator, considering the
# selection that might exist in layer and the configuration that
# indicates should algorithm use only selected features or all
# of them
features = vector.features(vectorLayer)
for f in features:
writer.addFeature(f)
def getVectorWriter(self, fields, geomType, crs, options=None):
"""Returns a suitable writer to which features can be added as
a result of the algorithm. Use this to transparently handle
output values instead of creating your own method.
Executing this method might modify the object, adding additional
information to it, so the writer can be later accessed and
processed within QGIS. It should be called just once, since a
new call might result in previous data being replaced, thus
rendering a previously obtained writer useless.
@param fields a list of QgsField
@param geomType a suitable geometry type, as it would be passed
to a QgsVectorFileWriter constructor
@param crs the crs of the layer to create
@return writer instance of the vector writer class
"""
if self.encoding is None:
settings = QSettings()
self.encoding = settings.value('/Processing/encoding', 'System', str)
w = VectorWriter(self.value, self.encoding, fields, geomType,
crs, options)
self.memoryLayer = w.memLayer
return w
def processAlgorithm(self, progress):
connection = self.getParameterValue(self.DATABASE)
settings = QSettings()
mySettings = '/PostgreSQL/connections/' + connection
try:
database = settings.value(mySettings + '/database')
username = settings.value(mySettings + '/username')
host = settings.value(mySettings + '/host')
port = settings.value(mySettings + '/port', type=int)
password = settings.value(mySettings + '/password')
except Exception as e:
raise GeoAlgorithmExecutionException(
self.tr('Wrong database connection name: %s' % connection))
try:
self.db = postgis_utils.GeoDB(host=host, port=port,
dbname=database, user=username, passwd=password)
except postgis_utils.DbError as e:
raise GeoAlgorithmExecutionException(
self.tr("Couldn't connect to database:\n%s" % e.message))
sql = self.getParameterValue(self.SQL).replace('\n', ' ')
try:
self.db._exec_sql_and_commit(unicode(sql))
except postgis_utils.DbError as e:
raise GeoAlgorithmExecutionException(
self.tr('Error executing SQL:\n%s' % e.message))
def main(argv):
app = QApplication(sys.argv)
app.setWindowIcon(QIcon(QPixmap(":/logo_small")))
app.setOrganizationName('Hardcoded Software')
app.setApplicationName('moneyGuru')
settings = QSettings()
LOGGING_LEVEL = logging.DEBUG if adjust_after_deserialization(settings.value('DebugMode')) else logging.WARNING
setupQtLogging(level=LOGGING_LEVEL)
logging.debug('started in debug mode')
if ISLINUX:
stylesheetFile = QFile(':/stylesheet_lnx')
else:
stylesheetFile = QFile(':/stylesheet_win')
stylesheetFile.open(QFile.ReadOnly)
textStream = QTextStream(stylesheetFile)
style = textStream.readAll()
stylesheetFile.close()
app.setStyleSheet(style)
lang = settings.value('Language')
locale_folder = op.join(BASE_PATH, 'locale')
hscommon.trans.install_gettext_trans_under_qt(locale_folder, lang)
# Many strings are translated at import time, so this is why we only import after the translator
# has been installed
from qt.app import MoneyGuru
app.setApplicationVersion(MoneyGuru.VERSION)
mgapp = MoneyGuru()
install_excepthook()
exec_result = app.exec_()
del mgapp
# Since PyQt 4.7.2, I had crashes on exit, and from reading the mailing list, it seems to be
# caused by some weird crap about C++ instance being deleted with python instance still living.
# The worst part is that Phil seems to say this is expected behavior. So, whatever, this
# gc.collect() below is required to avoid a crash.
gc.collect()
return exec_result
def __init__(self):
QDockWidget.__init__(self, None)
self.setupUi(self)
self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.modeComboBox.clear()
self.modeComboBox.addItems(["Simplified interface", "Advanced interface"])
settings = QSettings()
if not settings.contains(self.USE_CATEGORIES):
settings.setValue(self.USE_CATEGORIES, True)
useCategories = settings.value(self.USE_CATEGORIES, type=bool)
if useCategories:
self.modeComboBox.setCurrentIndex(0)
else:
self.modeComboBox.setCurrentIndex(1)
self.modeComboBox.currentIndexChanged.connect(self.modeHasChanged)
self.searchBox.textChanged.connect(self.textChanged)
self.algorithmTree.customContextMenuRequested.connect(self.showPopupMenu)
self.algorithmTree.doubleClicked.connect(self.executeAlgorithm)
if hasattr(self.searchBox, "setPlaceholderText"):
self.searchBox.setPlaceholderText(self.tr("Search..."))
self.fillTree()
def __init__(self, parent=None, scan_on_startup=False):
QMainWindow.__init__(self, parent)
self.resize(800, 500)
self._widget = MainWidget(self, scan_on_startup=scan_on_startup)
self.setCentralWidget(self._widget)
settings = QSettings()
self.restoreGeometry(settings.value('geometry', b'', QByteArray))
self.setWindowTitle('Marche')
menu = self.menuBar()
menuFile = menu.addMenu('File')
menuFile.addAction(self._widget.actionAdd_host)
menuFile.addAction(self._widget.actionScan_network)
menuFile.addSeparator()
menuFile.addAction(self._widget.actionLoad_session)
menuFile.addAction(self._widget.actionSave_session_as)
menuFile.addSeparator()
menuFile.addAction(self._widget.actionExit)
self._widget.actionExit.triggered.connect(self.close)
menuEdit = menu.addMenu('Edit')
menuEdit.addAction(self._widget.actionPreferences)
menuJobs = menu.addMenu('Jobs')
menuJobs.addAction(self._widget.actionReload)
menuHelp = menu.addMenu('Help')
menuHelp.addAction(self._widget.actionAbout)
menuHelp.addAction(self._widget.actionAbout_Qt)
self.statusBar().showMessage('Welcome!', 1000)
def __on_click_on_delete(self):
settings = QSettings()
recent_projects = settings.value("recentProjects").toMap()
if self.__project in recent_projects:
del recent_projects[self.__project]
settings.setValue("recentProjects", recent_projects)
self.emit(SIGNAL("deleteMe(QListWidgetItem)"), self.__itemRelated)
def closeEvent(self, event):
settings = QSettings()
settings.setValue(u'/Windows/PlaceMarker/geometry', self.saveGeometry())
settings.setValue(u'PlaceMarker/CurrentClass', self.comboBoxClass.currentIndex())
QtGui.QDialog.closeEvent(self, event)
self.button_box.button(QDialogButtonBox.Apply).setEnabled(False)
self.lineEditPosition.setText(u'')
def toggleAutoRefresh(self, checked):
if checked:
self.repaintTimer.start(REFRESH_RATE)
else:
self.repaintTimer.stop()
settings = QSettings()
settings.setValue(u'PlaceMarker/AutoRefreshLayer', checked)
def __init__(self, parent = None):
QObject.__init__(self, parent)
self.jinja = Environment(loader = FileSystemLoader("data/templates"), autoescape = True)
self.jinja.filters["likes"] = filter_likes
self.jinja.filters["twitterise"] = filter_twitterise
self.jinja.filters["timesince"] = filter_timesince
self.mapper = Mapper()
self.mapper.connect("/", controller = "LolViews", action = "feed")
self.mapper.connect("/login", controller = "LolViews", action = "login")
self.mapper.connect("/user/:user", controller = "LolViews", action = "feed")
self.notes = NotificationServer()
from PyQt4.QtCore import QSettings
settings = QSettings()
if settings.contains("session"):
from cPickle import loads
self.session = loads(str(settings.value("session").toString()))
else:
self.session = Session()
self.ff = FriendFeedAPI(self.session)
self.deferredResponses = set()
def __quicktipOnce(self):
filename = os.path.join(settings.widget_settings_dir(),
"user-session-state.ini")
namespace = ("user-message-history/{0.__module__}.{0.__qualname__}"
.format(type(self)))
session_hist = QSettings(filename, QSettings.IniFormat)
session_hist.beginGroup(namespace)
messages = self.UserAdviceMessages
def _ispending(msg):
return not session_hist.value(
"{}/confirmed".format(msg.persistent_id),
defaultValue=False, type=bool)
messages = [msg for msg in messages if _ispending(msg)]
if not messages:
return
message = messages[self.__msgchoice % len(messages)]
self.__msgchoice += 1
self.__showMessage(message)
def _userconfirmed():
session_hist = QSettings(filename, QSettings.IniFormat)
session_hist.beginGroup(namespace)
session_hist.setValue(
"{}/confirmed".format(message.persistent_id), True)
session_hist.sync()
self.__msgwidget.accepted.connect(_userconfirmed)
class Preferences(PrefsBA):
prefsSaved = pyqtSignal()
def __init__(self, parent, autoload=0):
self.parent = parent
PrefsBA.__init__(self, parent)
self.settings = QSettings()
if autoload:
self.load()
def load(self):
for preference in self.settings.childKeys():
try:
setting = self.settings.value(preference)
if preference == "Font":
self.parent.setfont(setting.toPyObject())
if preference == "Match Font":
self.parent.setMatchFont(setting.toPyObject())
if preference == "Email Server":
self.emailServerEdit.setText(setting.toPyObject())
if preference == "Recent Files Count":
self.recentFilesSpinBox.setValue(int(setting.toPyObject()))
except Exception, e:
print "Loading of configuration key", preference, "failed."
self.settings.remove(preference)
def chooseOutputFile(self):
# get last used dir
settings = QSettings()
lastUsedDir = settings.value(self.lastUsedVectorDirSettingsKey, ".")
# get selected filter
selectedFilter = self.cboFileFormat.itemData(self.cboFileFormat.currentIndex())
# ask for a filename
filename = QFileDialog.getSaveFileName(self, self.tr("Choose where to save the file"), lastUsedDir,
selectedFilter)
if filename == "":
return
filterString = qgis.core.QgsVectorFileWriter.filterForDriver(selectedFilter)
ext = filterString[filterString.find('.'):]
ext = ext[:ext.find(' ')]
if not filename.lower().endswith(ext):
filename += ext
# store the last used dir
settings.setValue(self.lastUsedVectorDirSettingsKey, QFileInfo(filename).filePath())
self.editOutputFile.setText(filename)
def define_user_analysis_extent(self, extent, crs):
"""Slot called when user has defined a custom analysis extent.
.. versionadded: 2.2.0
:param extent: Extent of the user's preferred analysis area.
:type extent: QgsRectangle
:param crs: Coordinate reference system for user defined analysis
extent.
:type crs: QgsCoordinateReferenceSystem
"""
self.hide_user_analysis_extent()
try:
extent = self.validate_rectangle(extent)
self.user_extent = extent
self.user_extent_crs = crs
except InvalidGeometryError:
# keep existing user extent without updating it
raise InvalidGeometryError
# Persist this extent for the next session
settings = QSettings()
user_extent = [
self.user_extent.xMinimum(),
self.user_extent.yMinimum(),
self.user_extent.xMaximum(),
self.user_extent.yMaximum()]
extent_string = ', '.join(('%f' % x) for x in user_extent)
settings.setValue('inasafe/analysis_extent', extent_string)
settings.setValue('inasafe/analysis_extent_crs', crs.authid())
self.show_user_analysis_extent()
def __init__(self, parent=None, title=None, description=None,
working_directory=None, workspace_units=None):
settings = QSettings()
self.__working_directory = (
working_directory or
settings.value("output/default-working-directory",
os.path.expanduser("~/Oasys"), type=str))
if not os.path.exists(self.__working_directory):
os.makedirs(self.__working_directory, exist_ok=True)
#QSettings().setValue("output/default-units", 1)
self.__workspace_units = (
workspace_units or
settings.value("output/default-units", 1, type=int))
super().__init__(parent, title=title, description=description)
# Replace the signal manager from.
self.signal_manager.setParent(None)
self.signal_manager.deleteLater()
sip.delete(self.signal_manager)
sip.delete(self.widget_manager)
self.set_loop_flags(Scheme.AllowLoops)
self.signal_manager = OASYSSignalManager(self)
self.widget_manager = OASYSWidgetManager()
self.widget_manager.set_scheme(self)
def __init__(self, parent, network_analyzer, url=None):
QWidget.__init__(self, parent)
self.webView = QWebView()
self.webView.setPage(QgepWebPage(self.webView))
self.networkAnalyzer = network_analyzer
settings = QSettings()
layout = QVBoxLayout(self)
if url is None:
url = settings.value("/QGEP/SvgProfilePath", u'qrc:///plugins/qgepplugin/svgprofile/index.html')
developermode = settings.value("/QGEP/DeveloperMode", False, type=bool)
if developermode is True:
self.webView.page().settings().setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
else:
self.webView.setContextMenuPolicy(Qt.NoContextMenu)
self.webView.load(QUrl(url))
self.frame = self.webView.page().mainFrame()
self.frame.javaScriptWindowObjectCleared.connect(self.initJs)
layout.addWidget(self.webView)
def browseDb_clicked(self, database_type):
"""
Method run dialog for select database in widget with changes.
According to pushButton name will fill in relevant lineEdit.
:type database_type: str
"""
title = u'Vyber databázi'
settings = QSettings()
lastUsedDir = str(settings.value('/UI/' + "lastVectorFileFilter" + "Dir", "."))
if database_type == 'mainDb':
self.__databases[database_type] = QFileDialog.getOpenFileName(self, title, lastUsedDir, u'Datábaze (*.db)')
if not self.__databases[database_type]:
return
self.le_mainDb.setText(self.__databases[database_type])
elif database_type == 'amendmentDb':
self.__databases[database_type] = QFileDialog.getOpenFileName(self, title, lastUsedDir, u'Datábaze (*.db)')
if not self.__databases[database_type]:
return
self.le_amendmentDb.setText(self.__databases[database_type])
elif database_type == 'exportDb':
title = u'Zadej jméno výstupní databáze'
self.__databases[database_type] = QFileDialog.getSaveFileName(self, u"Jméno výstupní databáze",
".db", u"Databáze (*.db)")
if not self.__databases[database_type]:
return
self.le_exportDb.setText(self.__databases[database_type])
if len(self.__databases) == 3:
self.pb_applyChanges.setEnabled(True)
def dropEvent(self, event):
if event.mimeData().hasFormat('text/uri-list'):
paths = [str(u.toLocalFile().toUtf8()) for u in event.mimeData().urls()]
fileName = paths[0] #If we drop many files, only the first one will be take into acount
index = self.indexAt(event.pos())
row, col = index.row(), index.column()
settings = QSettings()
if col == UploadListView.COL_VIDEO:
if(VideoTools.isVideofile(fileName)):
settings.setValue("mainwindow/workingDirectory", QVariant(fileName))
video = VideoFile(fileName)
self.model().emit(SIGNAL("layoutAboutToBeChanged()"))
self.model().addVideos(row, [video])
subtitle = Subtitle.AutoDetectSubtitle(video.getFilePath())
if subtitle:
sub = SubtitleFile(False,subtitle)
self.model().addSubs(row, [sub])
thread.start_new_thread(self.uploadModel.ObtainUploadInfo, ())
self.resizeRowsToContents()
self.model().emit(SIGNAL("layoutChanged()"))
else: #if it's the column in SUBTITLES
print fileName
if(Subtitle.isSubtitle(fileName)):
settings.setValue("mainwindow/workingDirectory", QVariant(fileName))
sub = SubtitleFile(False, fileName)
self.model().emit(SIGNAL("layoutAboutToBeChanged()"))
self.model().addSubs(row, [sub])
self.resizeRowsToContents()
self.model().emit(SIGNAL("layoutChanged()"))
thread.start_new_thread(self.uploadModel.ObtainUploadInfo, ())
def execute(self):
settings = QSettings()
lastDir = settings.value('Processing/lastModelsDir', '')
filename = QFileDialog.getOpenFileName(self.toolbox,
self.tr('Open model', 'AddModelFromFileAction'), lastDir,
self.tr('Processing model files (*.model *.MODEL)', 'AddModelFromFileAction'))
if filename:
try:
settings.setValue('Processing/lastModelsDir',
QFileInfo(fileName).absoluteDir().absolutePath())
ModelerAlgorithm.fromFile(filename)
except WrongModelException:
QMessageBox.warning(
self.toolbox,
self.tr('Error reading model', 'AddModelFromFileAction'),
self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
return
except:
QMessageBox.warning(self.toolbox,
self.tr('Error reading model', 'AddModelFromFileAction'),
self.tr('Cannot read file', 'AddModelFromFileAction'))
destFilename = os.path.join(ModelerUtils.modelsFolder(), os.path.basename(filename))
shutil.copyfile(filename,destFilename)
self.toolbox.updateProvider('model')
def get_db_tables(self):
"""Retrieve all tables from the selected database."""
self.dlg.cmb_geo.clear()
db_name = self.dlg.cmb_db.currentText()
con_name = self.dlg.cmb_con.currentText()
con_str = "{db}/connections/{con}/".format(db=db_name, con=con_name)
qs = QSettings()
db_host = qs.value(con_str + "host")
db_port = qs.value(con_str + "port")
db_name = qs.value(con_str + "database")
con_usr = qs.value(con_str + "username")
con_pwd = qs.value(con_str + "password")
uri = QgsDataSourceURI()
uri.setConnection(db_host, db_port, db_name, con_usr, con_pwd)
post_c = pg_con.PostGisDBConnector(uri)
tbl_list = []
for table in post_c.getTables():
if table[3] or table[1] == 'spatial_ref_sys':
pass
else:
tbl_list.append(table[1])
if len(tbl_list) == 0:
QMessageBox.warning(None,
'Layer and Tables',
"""There are no tables to geo-code in this database.""")
else:
self.dlg.cmb_geo.addItems(tbl_list)
def run(self):
"""Run method that performs all the real work"""
# get all available Databases and their connections.
db_default = ['PostgreSQL', 'SpatialLite']
db_con_dict = {}
qs = QSettings()
for k in qs.allKeys():
qsk = k.split('/')
if qsk[0] in db_default and qsk[0] not in db_con_dict.keys():
db_con_dict.update({qsk[0]: qsk[2]})
self.dlg.cmb_db.clear()
self.dlg.cmb_db.addItems(db_con_dict.keys())
self.get_connections()
self.get_db_tables()
# list tables to select geonames
tables = self.iface.legendInterface().layers()
layers_list = []
for layer in tables:
layers_list.append(layer.name())
self.dlg.cmb_lay.clear()
self.dlg.cmb_lay.addItems(layers_list)
# list field names of initial table
self.get_field_names()
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
pass
def showEvent(self, event):
# Show Event
QWidget.showEvent(self, event)
# Avoid recalculate the panel sizes if they are already loaded
if self._splitterArea.count() == 2:
return
# Rearrange widgets on Window
self._splitterArea.insertWidget(0, self._splitterMain)
qsettings = QSettings()
# Lists of sizes as list of QVariant- heightList = [QVariant, QVariant]
heightList = list(qsettings.value("window/central/mainSize", [(self.height() / 3) * 2, self.height() / 3]))
widthList = list(qsettings.value("window/central/areaSize", [(self.width() / 6) * 5, self.width() / 6]))
self._splitterMainSizes = [int(heightList[0]), int(heightList[1])]
self._splitterAreaSizes = [int(widthList[0]), int(widthList[1])]
if not event.spontaneous():
self.change_misc_visibility()
if bin(settings.UI_LAYOUT)[-1] == "1":
self.splitter_central_rotate()
if bin(settings.UI_LAYOUT >> 1)[-1] == "1":
self.splitter_misc_rotate()
if bin(settings.UI_LAYOUT >> 2)[-1] == "1":
self.splitter_central_orientation()
# Set the sizes to splitters
self._splitterMain.setSizes(self._splitterMainSizes)
self._splitterArea.setSizes(self._splitterAreaSizes)
def __init__(self, parent=None):
'''
Constructor
'''
super(GuidanceDock, self).__init__(parent)
self.setupUi(self)
self.compass = CompassWidget()
self.compass.setMinimumHeight(80)
self.verticalLayout.addWidget(self.compass)
self.verticalLayout.setStretch(5, 8)
self.distArea = QgsDistanceArea()
self.distArea.setEllipsoid(u'WGS84')
self.distArea.setEllipsoidalMode(True)
self.distArea.setSourceCrs(3452L)
self.fontSize = 11
self.source = None
self.target = None
self.srcPos = [None, 0.0]
self.trgPos = [None, 0.0]
self.srcHeading = 0.0
self.trgHeading = 0.0
s = QSettings()
self.format = s.value('PosiView/Guidance/Format', defaultValue=1, type=int)
self.showUtc = s.value('PosiView/Misc/ShowUtcClock', defaultValue=False, type=bool)
self.timer = 0
self.setUtcClock()
def save_state(self):
""" Store current state of GUI to configuration file.
.. versionadded: 3.3
"""
settings = QSettings()
settings.setValue('directory', self.output_directory.text())
def __init__(self):
""" Initializer.
"""
format = self.IniFormat if isWin else self.NativeFormat
scope = self.UserScope
QSettings.__init__(self, format, scope, self.keys.org, self.keys.app)
def __init__(self, iface):
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(QFile.decodeName(__file__))
# initialize locale
settings = QSettings()
locale = settings.value("locale/userLocale", "")[0:2]
localePath = os.path.join(self.plugin_dir, 'i18n', '{0}.qm'.format(locale))
if os.path.exists(localePath):
self.translator = QTranslator()
self.translator.load(localePath)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
self.pluginName = self.tr("TileLayerPlugin")
self.downloadTimeout = int(settings.value("/TileLayerPlugin/timeout", 30, type=int))
self.navigationMessagesEnabled = int(settings.value("/TileLayerPlugin/naviMsg", Qt.Checked, type=int))
self.crs3857 = None
self.layers = {}
# register plugin layer type
self.tileLayerType = TileLayerType(self)
QgsPluginLayerRegistry.instance().addPluginLayerType(self.tileLayerType)
# connect signal-slot
QgsMapLayerRegistry.instance().layerRemoved.connect(self.layerRemoved)
def showFileSelectionDialog(self):
settings = QSettings()
text = unicode(self.text.text())
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif settings.contains('/Processing/LastInputPath'):
path = unicode(settings.value('/Processing/LastInputPath'))
else:
path = ''
ret = QFileDialog.getOpenFileNames(self, self.tr('Open file'), path,
self.tr('All files(*.*);;') + self.param.getFileFilter())
if ret:
files = list(ret)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(unicode(files[0])))
for i, filename in enumerate(files):
files[i] = dataobjects.getRasterSublayer(filename, self.param)
if len(files) == 1:
self.text.setText(files[0])
else:
if isinstance(self.param, ParameterMultipleInput):
self.text.setText(';'.join(unicode(f) for f in files))
else:
rowdif = len(files) - (self.table.rowCount() - self.row)
for i in range(rowdif):
self.panel.addRow()
for i, f in enumerate(files):
self.table.cellWidget(i + self.row,
self.col).setText(f)
def defaultJob(document, preview):
"""Returns a default job for the document."""
filename, mode, includepath = documentinfo.info(document).jobinfo(True)
includepath.extend(documentinfo.info(document).includepath())
i = info(document)
j = job.Job()
command = [i.command]
s = QSettings()
s.beginGroup("lilypond_settings")
if s.value("delete_intermediate_files", True) not in (False, "false"):
command.append('-ddelete-intermediate-files')
else:
command.append('-dno-delete-intermediate-files')
command.append('-dpoint-and-click' if preview else '-dno-point-and-click')
command.append('--pdf')
command.extend('-I' + path for path in includepath)
j.directory = os.path.dirname(filename)
command.append(filename)
j.command = command
if s.value("no_translation", False) in (True, "true"):
j.environment['LANG'] = 'C'
j.setTitle("{0} {1} [{2}]".format(
os.path.basename(i.command), i.versionString(), document.documentName()))
return j
def find_most_old_open(self):
recent_project_list = QSettings().value("recentProjects", {})
listFounder = []
for recent_project_path, content in list(recent_project_list.items()):
listFounder.append((recent_project_path, int(content["lastopen"].toString("yyyyMMddHHmmzzz"))))
listFounder = sorted(listFounder, key=lambda date: listFounder[1], reverse=True) # sort by date last used
return listFounder[0][0]
def __init__(self, rules, flux):
QDialog.__init__(self)
self.rules = rules
self.flux = flux
self.setModal(True)
self.ui = Ui_ExpertivityDialog()
self.ui.setupUi(self)
R = len(rules)
self.ui.tableWidget.setColumnCount(R)
self.ui.tableWidget.setRowCount(R)
ruleNames = [rule.name[:3] for rule in self.rules]
self.ui.tableWidget.setHorizontalHeaderLabels(ruleNames)
self.ui.tableWidget.setVerticalHeaderLabels(ruleNames)
for i in range(R):
self.ui.tableWidget.setColumnWidth(i, 50)
s = QSettings()
s.beginGroup('Expertivity')
for i in range(R):
s.beginGroup('Row%d' % i)
for j in range(R):
if j != i:
self.ui.tableWidget.setItem(i, j, QTableWidgetItem(str(s.value('Column%d' % j, 0, float))))
s.endGroup()
s.endGroup()
self.ui.tableWidget.itemChanged.connect(self.recalculateExpertivity)
self.recalculateExpertivity();
def initGui(self):
settings = QSettings()
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
# Add toolbar
self.menu = QMenu()
self.menu.setTitle(
QCoreApplication.translate("CADDigitize", "&CADDigitize"))
self.caddigitize_help = QAction(
QCoreApplication.translate("CADDigitize", "Help"),
self.iface.mainWindow())
self.caddigitize_settings = QAction(
QCoreApplication.translate("CADDigitize", "Settings"),
self.iface.mainWindow())
self.menu.addActions(
[self.caddigitize_help, self.caddigitize_settings])
menu_bar = self.iface.mainWindow().menuBar()
actions = menu_bar.actions()
lastAction = actions[len(actions) - 1]
menu_bar.insertMenu(lastAction, self.menu)
self.caddigitize_help.triggered.connect(self.doHelp)
self.caddigitize_settings.triggered.connect(self.doSettings)
# Add button
self.toolBar = self.iface.addToolBar("CADDigitize")
self.toolBar.setObjectName("CADDigitize")
self.optionsToolBar = self.iface.addToolBar("CADDigitize Options")
self.optionsToolBar.setObjectName("CADDigitize Options")
self.circleToolButton = QToolButton(self.toolBar)
self.rectToolButton = QToolButton(self.toolBar)
self.ellipseToolButton = QToolButton(self.toolBar)
self.arcToolButton = QToolButton(self.toolBar)
self.rpolygonToolButton = QToolButton(self.toolBar)
self.circleToolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.rectToolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.ellipseToolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.arcToolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.rpolygonToolButton.setPopupMode(QToolButton.MenuButtonPopup)
###
# Circles
###
# Add actions
self.circleBy2Points = QAction(
QIcon(":/plugins/CADDigitize/icons/circleBy2Points.png"),
"Circle by 2 points", self.iface.mainWindow())
self.circleBy3Points = QAction(
QIcon(":/plugins/CADDigitize/icons/circleBy3Points.png"),
"Circle by 3 points", self.iface.mainWindow())
self.circleByCenterRadius = QAction(
QIcon(":/plugins/CADDigitize/icons/circleByCenterRadius.png"),
"Circle by center and radius", self.iface.mainWindow())
self.circleByCenterPoint = QAction(
QIcon(":/plugins/CADDigitize/icons/circleByCenterPoint.png"),
"Circle by center and a point", self.iface.mainWindow())
self.circleToolButton.addActions([
self.circleBy2Points, self.circleBy3Points,
self.circleByCenterRadius, self.circleByCenterPoint
])
self.circleToolButton.setDefaultAction(self.circleBy2Points)
self.toolBar.addWidget(self.circleToolButton)
self.circleBy2Points.setCheckable(True)
self.circleBy2Points.setEnabled(False)
self.circleBy3Points.setCheckable(True)
self.circleBy3Points.setEnabled(False)
self.circleByCenterRadius.setCheckable(True)
self.circleByCenterRadius.setEnabled(False)
self.circleByCenterPoint.setCheckable(True)
self.circleByCenterPoint.setEnabled(False)
self.toolBar.addSeparator()
###
# Rectangles
###
self.rectBy3Points = QAction(
QIcon(":/plugins/CADDigitize/icons/rectBy3Points.png"),
"Rectangle by 3 points", self.iface.mainWindow())
self.rectByExtent = QAction(
QIcon(":/plugins/CADDigitize/icons/rectByExtent.png"),
"Rectangle by extent", self.iface.mainWindow())
self.rectFromCenter = QAction(
QIcon(":/plugins/CADDigitize/icons/rectFromCenter.png"),
"Rectangle from center", self.iface.mainWindow())
self.squareFromCenter = QAction(
QIcon(":/plugins/CADDigitize/icons/squareFromCenter.png"),
"Square from center", self.iface.mainWindow())
self.rectToolButton.addActions([
self.rectBy3Points, self.rectByExtent, self.rectFromCenter,
self.squareFromCenter
])
self.rectToolButton.setDefaultAction(self.rectBy3Points)
self.toolBar.addWidget(self.rectToolButton)
self.rectBy3Points.setEnabled(False)
self.rectBy3Points.setCheckable(True)
self.rectByExtent.setEnabled(False)
self.rectByExtent.setCheckable(True)
self.rectFromCenter.setEnabled(False)
self.rectFromCenter.setCheckable(True)
self.squareFromCenter.setEnabled(False)
self.squareFromCenter.setCheckable(True)
self.toolBar.addSeparator()
###
# Ellipses
###
# Add actions
self.ellipseByCenter2Points = QAction(
QIcon(":/plugins/CADDigitize/icons/ellipseByCenter2Points.png"),
"Ellipse by center and 2 points", self.iface.mainWindow())
self.ellipseByCenter3Points = QAction(
QIcon(":/plugins/CADDigitize/icons/ellipseByCenter3Points.png"),
"Ellipse by center and 3 points", self.iface.mainWindow())
self.ellipseBy4Points = QAction(
QIcon(":/plugins/CADDigitize/icons/ellipseBy4Points.png"),
"Ellipse by 4 points", self.iface.mainWindow())
self.ellipseByFociPoint = QAction(
QIcon(":/plugins/CADDigitize/icons/ellipseByFociPoint.png"),
"Ellipse by foci and a point", self.iface.mainWindow())
self.ellipseFromCenter = QAction(
QIcon(":/plugins/CADDigitize/icons/ellipseFromCenter.png"),
"Ellipse from center", self.iface.mainWindow())
self.ellipseByExtent = QAction(
QIcon(":/plugins/CADDigitize/icons/ellipseByExtent.png"),
"Ellipse by extent", self.iface.mainWindow())
self.ellipseToolButton.addActions([
self.ellipseByCenter2Points, self.ellipseByFociPoint,
self.ellipseFromCenter, self.ellipseByExtent
])
self.ellipseToolButton.setDefaultAction(self.ellipseByCenter2Points)
self.toolBar.addWidget(self.ellipseToolButton)
self.ellipseByCenter2Points.setCheckable(True)
self.ellipseByCenter2Points.setEnabled(False)
self.ellipseByCenter3Points.setCheckable(True)
self.ellipseByCenter3Points.setEnabled(False)
self.ellipseBy4Points.setCheckable(True)
self.ellipseBy4Points.setEnabled(False)
self.ellipseByFociPoint.setCheckable(True)
self.ellipseByFociPoint.setEnabled(False)
self.ellipseFromCenter.setCheckable(True)
self.ellipseFromCenter.setEnabled(False)
self.ellipseByExtent.setCheckable(True)
self.ellipseByExtent.setEnabled(False)
self.toolBar.addSeparator()
###
# Arcs
###
# Add actions
self.arcByCenter2Points = QAction(
QIcon(":/plugins/CADDigitize/icons/arcByCenter2Points.png"),
"Arc by center and 2 points", self.iface.mainWindow())
self.arcBy3Points = QAction(
QIcon(":/plugins/CADDigitize/icons/arcBy3Points.png"),
"Arc by 3 points", self.iface.mainWindow())
self.arcByCenterPointAngle = QAction(
QIcon(":/plugins/CADDigitize/icons/arcByCenterPointAngle.png"),
"Arc by center, point and angle", self.iface.mainWindow())
self.arcToolButton.addActions([
self.arcByCenter2Points, self.arcBy3Points,
self.arcByCenterPointAngle
])
self.arcToolButton.setDefaultAction(self.arcByCenter2Points)
self.toolBar.addWidget(self.arcToolButton)
self.arcByCenter2Points.setCheckable(True)
self.arcByCenter2Points.setEnabled(False)
self.arcBy3Points.setCheckable(True)
self.arcBy3Points.setEnabled(False)
self.arcByCenterPointAngle.setCheckable(True)
self.arcByCenterPointAngle.setEnabled(False)
self.toolBar.addSeparator()
###
# Regular Polygon
###
self.rpolygonByCenterPoint = QAction(
QIcon(":/plugins/CADDigitize/icons/rpolygonByCenterPoint.png"),
"Regular polygon by center and point", self.iface.mainWindow())
self.rpolygonBy2Corners = QAction(
QIcon(":/plugins/CADDigitize/icons/rpolygonBy2Corners.png"),
"Regular polygon by 2 corners", self.iface.mainWindow())
self.rpolygonToolButton.addActions(
[self.rpolygonByCenterPoint, self.rpolygonBy2Corners])
self.rpolygonToolButton.setDefaultAction(self.rpolygonByCenterPoint)
self.toolBar.addWidget(self.rpolygonToolButton)
self.rpolygonByCenterPoint.setCheckable(True)
self.rpolygonByCenterPoint.setEnabled(False)
self.rpolygonBy2Corners.setCheckable(True)
self.rpolygonBy2Corners.setEnabled(False)
self.toolBar.addSeparator()
### Conect
QObject.connect(self.circleBy2Points, SIGNAL("activated()"),
self.circleBy2PointsDigit)
QObject.connect(self.circleBy3Points, SIGNAL("activated()"),
self.circleBy3PointsDigit)
QObject.connect(self.circleByCenterRadius, SIGNAL("activated()"),
self.circleByCenterRadiusDigit)
QObject.connect(self.circleByCenterPoint, SIGNAL("activated()"),
self.circleByCenterPointDigit)
QObject.connect(self.rectBy3Points, SIGNAL("activated()"),
self.rectBy3PointsDigit)
QObject.connect(self.rectByExtent, SIGNAL("activated()"),
self.rectByExtentDigit)
QObject.connect(self.rectFromCenter, SIGNAL("activated()"),
self.rectFromCenterDigit)
QObject.connect(self.squareFromCenter, SIGNAL("activated()"),
self.squareFromCenterDigit)
QObject.connect(self.ellipseByCenter2Points, SIGNAL("activated()"),
self.ellipseByCenter2PointsDigit)
QObject.connect(self.ellipseByCenter3Points, SIGNAL("activated()"),
self.ellipseByCenter3PointsDigit)
QObject.connect(self.ellipseBy4Points, SIGNAL("activated()"),
self.ellipseBy4PointsDigit)
QObject.connect(self.ellipseByFociPoint, SIGNAL("activated()"),
self.ellipseByFociPointDigit)
QObject.connect(self.ellipseFromCenter, SIGNAL("activated()"),
self.ellipseFromCenterDigit)
QObject.connect(self.ellipseByExtent, SIGNAL("activated()"),
self.ellipseByExtentDigit)
QObject.connect(self.arcByCenter2Points, SIGNAL("activated()"),
self.arcByCenter2PointsDigit)
QObject.connect(self.arcBy3Points, SIGNAL("activated()"),
self.arcBy3PointsDigit)
QObject.connect(self.arcByCenterPointAngle, SIGNAL("activated()"),
self.arcByCenterPointAngleDigit)
QObject.connect(self.rpolygonByCenterPoint, SIGNAL("activated()"),
self.rpolygonByCenterPointDigit)
QObject.connect(self.rpolygonBy2Corners, SIGNAL("activated()"),
self.rpolygonBy2CornersDigit)
QObject.connect(self.iface,
SIGNAL("currentLayerChanged(QgsMapLayer*)"),
self.toggle)
QObject.connect(self.canvas, SIGNAL("mapToolSet(QgsMapTool*)"),
self.deactivate)
# Get the tools
self.circleBy2Points_tool = CircleBy2PointsTool(self.canvas)
self.circleBy3Points_tool = CircleBy3PointsTool(self.canvas)
self.circleByCenterRadius_tool = CircleByCenterRadiusTool(self.canvas)
self.circleByCenterPoint_tool = CircleByCenterPointTool(self.canvas)
self.rectBy3Points_tool = RectBy3PointsTool(self.canvas)
self.rectByExtent_tool = RectByExtentTool(self.canvas)
self.rectFromCenter_tool = RectFromCenterTool(self.canvas)
self.squareFromCenter_tool = SquareFromCenterTool(self.canvas)
self.ellipseByCenter2Points_tool = EllipseByCenter2PointsTool(
self.canvas)
self.ellipseByCenter3Points_tool = EllipseByCenter3PointsTool(
self.canvas)
self.ellipseBy4Points_tool = EllipseBy4PointsTool(self.canvas)
self.ellipseByFociPoint_tool = EllipseByFociPointTool(self.canvas)
self.ellipseByExtent_tool = EllipseByExtentTool(self.canvas)
self.ellipseFromCenter_tool = EllipseFromCenterTool(self.canvas)
self.arcByCenter2Points_tool = ArcByCenter2PointsTool(self.canvas)
self.arcBy3Points_tool = ArcBy3PointsTool(self.canvas)
self.arcByCenterPointAngle_tool = ArcByCenterPointAngleTool(
self.canvas)
self.rpolygonByCenterPoint_tool = RPolygonByCenterPointTool(
self.canvas)
self.rpolygonBy2Corners_tool = RPolygon2CornersTool(self.canvas)
def __init__(self, iface, parent=None, extent=None, crs=None):
"""Constructor for the dialog.
:param iface: A Quantum GIS QGisAppInterface instance.
:type iface: QGisAppInterface
:param parent: Parent widget of this dialog
:type parent: QWidget
:param extent: Extent of the user's preferred analysis area.
:type extent: QgsRectangle
:param crs: Coordinate reference system for user defined analysis
extent.
:type crs: QgsCoordinateReferenceSystem
"""
QDialog.__init__(self, parent)
self.setupUi(self)
self.iface = iface
self.parent = parent
self.canvas = iface.mapCanvas()
self.previous_map_tool = None
# Prepare the map tool
self.tool = RectangleMapTool(self.canvas)
self.previous_map_tool = self.canvas.mapTool()
if extent is None and crs is None:
# Use the current map canvas extents as a starting point
self.tool.set_rectangle(self.canvas.extent())
else:
# Ensure supplied extent is in current canvas crs
transform = QgsCoordinateTransform(
crs,
self.canvas.mapRenderer().destinationCrs())
transformed_extent = transform.transformBoundingBox(extent)
self.tool.set_rectangle(transformed_extent)
self._populate_coordinates()
# Observe inputs for changes
self.x_minimum.valueChanged.connect(self._coordinates_changed)
self.y_minimum.valueChanged.connect(self._coordinates_changed)
self.x_maximum.valueChanged.connect(self._coordinates_changed)
self.y_maximum.valueChanged.connect(self._coordinates_changed)
# Draw the rubberband
self._coordinates_changed()
# Wire up button events
self.capture_button.clicked.connect(self.start_capture)
# Handle cancel
cancel_button = self.button_box.button(QtGui.QDialogButtonBox.Cancel)
cancel_button.clicked.connect(self.reject)
# Make sure to reshow this dialog when rectangle is captured
self.tool.rectangle_created.connect(self.stop_capture)
# Setup ok button
self.ok_button = self.button_box.button(QtGui.QDialogButtonBox.Ok)
self.ok_button.clicked.connect(self.accept)
# Set up context help
self.help_button = self.button_box.button(QtGui.QDialogButtonBox.Help)
# Allow toggling the help button
self.help_button.setCheckable(True)
self.help_button.toggled.connect(self.help_toggled)
self.main_stacked_widget.setCurrentIndex(1)
# Reset / Clear button
clear_button = self.button_box.button(QtGui.QDialogButtonBox.Reset)
clear_button.setText(self.tr('Clear'))
clear_button.clicked.connect(self.clear)
# Populate the bookmarks list and connect the combobox
self._populate_bookmarks_list()
self.bookmarks_list.currentIndexChanged.connect(
self.bookmarks_index_changed)
# Reinstate the last used radio button
settings = QSettings()
mode = settings.value('inasafe/analysis_extents_mode',
'HazardExposureView')
if mode == 'HazardExposureView':
self.hazard_exposure_view_extent.setChecked(True)
elif mode == 'HazardExposure':
self.hazard_exposure_only.setChecked(True)
elif mode == 'HazardExposureBookmark':
self.hazard_exposure_bookmark.setChecked(True)
elif mode == 'HazardExposureBoundingBox':
self.hazard_exposure_user_extent.setChecked(True)
show_warnings = settings.value('inasafe/show_extent_warnings',
True,
type=bool)
if show_warnings:
self.show_warnings.setChecked(True)
else:
self.show_warnings.setChecked(False)
show_confirmations = settings.value(
'inasafe/show_extent_confirmations', True, type=bool)
if show_confirmations:
self.show_confirmations.setChecked(True)
else:
self.show_confirmations.setChecked(False)
def setUp(self):
"""Fixture run before all tests"""
self.qsetting = QSettings('InaSAFETest')
self.qsetting.clear()
class TestOptionsDialog(unittest.TestCase):
"""Test Options Dialog"""
def setUp(self):
"""Fixture run before all tests"""
self.qsetting = QSettings('InaSAFETest')
self.qsetting.clear()
def tearDown(self):
"""Fixture run after each test."""
# Make sure it's empty
self.qsetting.clear()
def test_setup_dialog(self):
"""Test Setup Options Dialog."""
dialog = OptionsDialog(
parent=PARENT, iface=IFACE, qsetting='InaSAFETest')
self.assertIsNotNone(dialog)
# Check default values
self.assertEqual(
dialog.cbxVisibleLayersOnly.isChecked(),
inasafe_default_settings['visibleLayersOnlyFlag'])
self.assertEqual(
dialog.cbxSetLayerNameFromTitle.isChecked(),
inasafe_default_settings['set_layer_from_title_flag'])
self.assertEqual(
dialog.cbxZoomToImpact.isChecked(),
inasafe_default_settings['setZoomToImpactFlag'])
self.assertEqual(
dialog.cbxHideExposure.isChecked(),
inasafe_default_settings['setHideExposureFlag'])
self.assertEqual(
dialog.cbxUseSelectedFeaturesOnly.isChecked(),
inasafe_default_settings['useSelectedFeaturesOnly'])
self.assertEqual(
dialog.leKeywordCachePath.text(),
inasafe_default_settings['keywordCachePath'])
self.assertEqual(
dialog.template_warning_checkbox.isChecked(),
inasafe_default_settings['template_warning_verbose'])
self.assertEqual(
dialog.organisation_on_dock_checkbox.isChecked(),
inasafe_default_settings['showOrganisationLogoInDockFlag'])
self.assertEqual(
dialog.cbxDevMode.isChecked(),
inasafe_default_settings['developer_mode'])
self.assertEqual(
dialog.leNorthArrowPath.text(), default_north_arrow_path())
self.assertEqual(
dialog.leOrganisationLogoPath.text(), supporters_logo_path())
self.assertEqual(dialog.leReportTemplatePath.text(), '')
self.assertEqual(dialog.txtDisclaimer.toPlainText(), disclaimer())
self.assertEqual(
dialog.leUserDirectoryPath.text(), temp_dir('impacts'))
self.assertEqual(
dialog.iso19115_organization_le.text(),
inasafe_default_settings['ISO19115_ORGANIZATION'])
self.assertEqual(
dialog.iso19115_url_le.text(),
inasafe_default_settings['ISO19115_URL'])
self.assertEqual(
dialog.iso19115_email_le.text(),
inasafe_default_settings['ISO19115_EMAIL'])
self.assertEqual(
dialog.iso19115_license_le.text(),
inasafe_default_settings['ISO19115_LICENSE'])
def test_update_settings(self):
"""Test update InaSAFE Option works."""
# Create new option dialog
dialog = OptionsDialog(
parent=PARENT, iface=IFACE, qsetting='InaSAFETest')
# Update some state
new_state = not inasafe_default_settings['visibleLayersOnlyFlag']
dialog.cbxVisibleLayersOnly.setChecked(new_state)
new_organization = 'Super Organization'
dialog.iso19115_organization_le.setText(new_organization)
# Accept the dialog
dialog.accept()
# Check the value in QSettings
# Next two lines a hack because windows qsettings returns a string
# rather than a bool...TS
value = self.qsetting.value('inasafe/visibleLayersOnlyFlag')
if value == u'false':
value = False
if value == u'true':
value = True
self.assertEquals(
new_state, value)
self.assertEqual(
new_organization,
self.qsetting.value('inasafe/ISO19115_ORGANIZATION'))
# Open the options dialog
dialog = OptionsDialog(
iface=IFACE, parent=PARENT, qsetting='InaSAFETest')
# Check the state of the dialog after save the settings
self.assertEqual(new_state, dialog.cbxVisibleLayersOnly.isChecked())
self.assertEqual(
new_organization, dialog.iso19115_organization_le.text())
def _on_click_on_delete(self, path):
settings = QSettings(resources.SETTINGS_PATH, QSettings.IniFormat)
recent_projects = settings.value("recentProjects")
if path in recent_projects:
del recent_projects[path]
settings.setValue("recentProjects", recent_projects)
def __init__(self, field_group=None, parent=None, iface=None):
"""Constructor."""
# Init from parent class
QWidget.__init__(self, parent)
# Attributes
self.layer = None
self.metadata = {}
self.parent = parent
self.iface = iface
self.field_group = field_group
self.setting = QSettings() # TODO(IS): Make dynamic
# Main container
self.main_layout = QVBoxLayout()
# Inner layout
self.header_layout = QHBoxLayout()
self.content_layout = QHBoxLayout()
self.footer_layout = QHBoxLayout()
# Header
self.header_label = QLabel()
self.header_label.setWordWrap(True)
# Content
self.field_layout = QVBoxLayout()
self.parameter_layout = QHBoxLayout()
self.field_description = QLabel(tr('List of fields'))
self.field_list = QListWidget()
self.field_list.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.field_list.setDragDropMode(QAbstractItemView.DragDrop)
self.field_list.setDefaultDropAction(Qt.MoveAction)
self.field_list.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Expanding)
# noinspection PyUnresolvedReferences
self.field_list.itemSelectionChanged.connect(self.update_footer)
# Footer
self.footer_label = QLabel()
# Parameters
self.extra_parameters = [(GroupSelectParameter,
GroupSelectParameterWidget)]
self.parameters = []
self.parameter_container = None
# Adding to layout
self.header_layout.addWidget(self.header_label)
self.field_layout.addWidget(self.field_description)
self.field_layout.addWidget(self.field_list)
self.field_layout.setSizeConstraint(QLayout.SetMaximumSize)
self.content_layout.addLayout(self.field_layout)
self.content_layout.addLayout(self.parameter_layout)
self.footer_layout.addWidget(self.footer_label)
self.main_layout.addLayout(self.header_layout)
self.main_layout.addLayout(self.content_layout)
self.main_layout.addLayout(self.footer_layout)
self.setLayout(self.main_layout)
def settings(self):
return QSettings("myrdp", "settings")
def segmentsettingsCircle(self):
settings = QSettings()
settings.setValue("/CADDigitize/circle/segments", self.spinBox.value())
def angleDirectionArc(self):
settings = QSettings()
if self.ArcAngleDirectionCombo.currentText() == "ClockWise":
settings.setValue("/CADDigitize/arc/direction", "ClockWise")
else:
settings.setValue("/CADDigitize/arc/direction", "CounterClockWise")
def segmentsettingsEllipse(self):
settings = QSettings()
settings.setValue("/CADDigitize/ellipse/segments",
self.spinBox.value())
def arcOptions(self):
settings = QSettings()
self.optionsToolBar.clear()
self.arc_featurePitch = settings.value("/CADDigitize/arc/pitch",
2,
type=float)
self.arc_featureAngle = settings.value("/CADDigitize/arc/angle",
1,
type=int)
self.arc_method = settings.value("/CADDigitize/arc/method", "pitch")
self.arc_angleDirection = settings.value("/CADDigitize/arc/direction",
"ClockWise")
mc = self.canvas
layer = mc.currentLayer()
if layer.geometryType() == 2:
self.arc_polygonCreation = settings.value(
"/CADDigitize/arc/polygon", "pie")
self.ArcPolygonCombo = QComboBox(self.iface.mainWindow())
self.ArcPolygonCombo.addItems(["pie", "chord"])
self.ArcPolygonComboAction = self.optionsToolBar.addWidget(
self.ArcPolygonCombo)
if self.arc_polygonCreation == "pie":
self.ArcPolygonCombo.setCurrentIndex(0)
else:
self.ArcPolygonCombo.setCurrentIndex(1)
QObject.connect(self.ArcPolygonCombo,
SIGNAL("currentIndexChanged(int)"),
self.polygonArc)
self.ArcFeatureSpin = QDoubleSpinBox(self.iface.mainWindow())
self.ArcAngleDirectionCombo = QComboBox(self.iface.mainWindow())
self.ArcAngleDirectionCombo.addItems(["ClockWise", "CounterClockWise"])
self.ArcAngleDirectionComboAction = self.optionsToolBar.addWidget(
self.ArcAngleDirectionCombo)
self.ArcFeatureCombo = QComboBox(self.iface.mainWindow())
self.ArcFeatureCombo.addItems(["pitch", "angle"])
self.ArcFeatureComboAction = self.optionsToolBar.addWidget(
self.ArcFeatureCombo)
if self.arc_method == "pitch":
self.ArcFeatureCombo.setCurrentIndex(0)
self.ArcFeatureSpin.setMinimum(1)
self.ArcFeatureSpin.setMaximum(1000)
self.ArcFeatureSpin.setDecimals(1)
self.ArcFeatureSpin.setValue(self.arc_featurePitch)
self.ArcFeatureSpinAction = self.optionsToolBar.addWidget(
self.ArcFeatureSpin)
self.ArcFeatureSpin.setToolTip("Pitch")
self.ArcFeatureSpinAction.setEnabled(True)
else:
self.ArcFeatureCombo.setCurrentIndex(1)
self.ArcFeatureSpin.setMinimum(1)
self.ArcFeatureSpin.setMaximum(3600)
self.ArcFeatureSpin.setDecimals(0)
self.ArcFeatureSpin.setValue(self.arc_featureAngle)
self.ArcFeatureSpinAction = self.optionsToolBar.addWidget(
self.ArcFeatureSpin)
self.ArcFeatureSpin.setToolTip("Angle")
self.ArcFeatureSpinAction.setEnabled(True)
if self.arc_angleDirection == "ClockWise":
self.ArcAngleDirectionCombo.setCurrentIndex(0)
else:
self.ArcAngleDirectionCombo.setCurrentIndex(1)
QObject.connect(self.ArcFeatureSpin, SIGNAL("valueChanged(double)"),
self.segmentsettingsArc)
QObject.connect(self.ArcFeatureCombo,
SIGNAL("currentIndexChanged(int)"), self.featureArc)
QObject.connect(self.ArcAngleDirectionCombo,
SIGNAL("currentIndexChanged(int)"),
self.angleDirectionArc)
def segmentsettingsRPolygon(self):
settings = QSettings()
settings.setValue("/CADDigitize/rpolygon/nbedges",
self.spinBox.value())
def getConsoleCommands(self):
connection = self.DB_CONNECTIONS[self.getParameterValue(self.DATABASE)]
settings = QSettings()
mySettings = '/PostgreSQL/connections/' + connection
dbname = settings.value(mySettings + '/database')
user = settings.value(mySettings + '/username')
host = settings.value(mySettings + '/host')
port = settings.value(mySettings + '/port')
password = settings.value(mySettings + '/password')
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
ssrs = unicode(self.getParameterValue(self.S_SRS))
tsrs = unicode(self.getParameterValue(self.T_SRS))
asrs = unicode(self.getParameterValue(self.A_SRS))
schema = unicode(self.getParameterValue(self.SCHEMA))
table = unicode(self.getParameterValue(self.TABLE))
pk = unicode(self.getParameterValue(self.PK))
pkstring = "-lco FID=" + pk
primary_key = self.getParameterValue(self.PRIMARY_KEY)
geocolumn = unicode(self.getParameterValue(self.GEOCOLUMN))
geocolumnstring = "-lco GEOMETRY_NAME=" + geocolumn
dim = self.DIMLIST[self.getParameterValue(self.DIM)]
dimstring = "-lco DIM=" + dim
simplify = unicode(self.getParameterValue(self.SIMPLIFY))
segmentize = unicode(self.getParameterValue(self.SEGMENTIZE))
spat = self.getParameterValue(self.SPAT)
clip = self.getParameterValue(self.CLIP)
where = unicode(self.getParameterValue(self.WHERE))
wherestring = '-where "' + where + '"'
gt = unicode(self.getParameterValue(self.GT))
overwrite = self.getParameterValue(self.OVERWRITE)
append = self.getParameterValue(self.APPEND)
addfields = self.getParameterValue(self.ADDFIELDS)
launder = self.getParameterValue(self.LAUNDER)
launderstring = "-lco LAUNDER=NO"
index = self.getParameterValue(self.INDEX)
indexstring = "-lco SPATIAL_INDEX=OFF"
skipfailures = self.getParameterValue(self.SKIPFAILURES)
promotetomulti = self.getParameterValue(self.PROMOTETOMULTI)
precision = self.getParameterValue(self.PRECISION)
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-progress')
arguments.append('--config PG_USE_COPY YES')
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append('PG:"host=' + host)
arguments.append('port=' + port)
if len(dbname) > 0:
arguments.append('dbname=' + dbname)
if len(password) > 0:
arguments.append('password='******'active_schema=' + schema)
else:
arguments.append('active_schema=public')
arguments.append('user='******'"')
arguments.append(dimstring)
arguments.append(ogrLayer)
arguments.append(ogrLayerName(inLayer))
if index:
arguments.append(indexstring)
if launder:
arguments.append(launderstring)
if append:
arguments.append('-append')
if addfields:
arguments.append('-addfields')
if overwrite:
arguments.append('-overwrite')
if len(self.GEOMTYPE[self.getParameterValue(self.GTYPE)]) > 0:
arguments.append('-nlt')
arguments.append(self.GEOMTYPE[self.getParameterValue(self.GTYPE)])
if len(geocolumn) > 0:
arguments.append(geocolumnstring)
if len(pk) > 0:
arguments.append(pkstring)
elif primary_key is not None:
arguments.append("-lco FID=" + primary_key)
if len(table) > 0:
arguments.append('-nln')
arguments.append(table)
if len(ssrs) > 0:
arguments.append('-s_srs')
arguments.append(ssrs)
if len(tsrs) > 0:
arguments.append('-t_srs')
arguments.append(tsrs)
if len(asrs) > 0:
arguments.append('-a_srs')
arguments.append(asrs)
if len(spat) > 0:
regionCoords = spat.split(',')
arguments.append('-spat')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
if clip:
arguments.append('-clipsrc spat_extent')
if skipfailures:
arguments.append('-skipfailures')
if where:
arguments.append(wherestring)
if len(simplify) > 0:
arguments.append('-simplify')
arguments.append(simplify)
if len(segmentize) > 0:
arguments.append('-segmentize')
arguments.append(segmentize)
if len(gt) > 0:
arguments.append('-gt')
arguments.append(gt)
if promotetomulti:
arguments.append('-nlt PROMOTE_TO_MULTI')
if precision is False:
arguments.append('-lco PRECISION=NO')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def polygonArc(self):
settings = QSettings()
if self.ArcPolygonCombo.currentText() == "pie":
settings.setValue("/CADDigitize/arc/polygon", "pie")
else:
settings.setValue("/CADDigitize/arc/polygon", "chord")
class Generator():
def __init__(self, notebookPath):
self.notebookPath = notebookPath
self.notepath = os.path.join(notebookPath, "notes").replace(os.sep, '/')
self.sitepath = os.path.join(notebookPath, "_site").replace(os.sep, '/')
self.htmlpath = os.path.join(notebookPath, "_site/notes").replace(os.sep, '/')
self.configfile = os.path.join(self.notebookPath, "notebook.conf").replace(os.sep, '/')
self.qsettings = QSettings(self.configfile, QSettings.NativeFormat)
self.extName = ['.md', '.mkd', '.markdown']
if os.path.exists(self.configfile):
extensions = readListFromSettings(self.qsettings,
"extensions")
defExt = self.qsettings.value("fileExt")
extCfg = readDictFromSettings(self.qsettings, "extensionsConfig")
if defExt in self.extName:
self.extName.remove(defExt)
self.extName.insert(0, defExt)
self.exts = extensions
self.md = markdown.Markdown(extensions, extension_configs=extCfg)
else:
print("ERROR: Not a valid mikidown notebook folder")
sys.exit(1)
def generate(self):
# clear sitepath
self.count = 0
if os.path.exists(self.sitepath):
for file_object in os.listdir(self.sitepath):
file_object_path = os.path.join(self.sitepath, file_object)
if os.path.isfile(file_object_path):
os.unlink(file_object_path)
else:
shutil.rmtree(file_object_path)
QDir().mkpath(self.htmlpath)
self.initTree(self.notepath, "")
# copy css and attachments folder
cssSrcPath = os.path.join(self.notebookPath, "css")
cssDstPath = os.path.join(self.sitepath, "css")
attachSrcPath = os.path.join(self.notebookPath, "attachments")
attachDstPath = os.path.join(self.sitepath, "attachments")
shutil.copytree(cssSrcPath, cssDstPath)
if os.path.exists(attachSrcPath):
shutil.copytree(attachSrcPath, attachDstPath)
print('Finished: Processed', self.count, 'notes.')
def regenerate(self):
def recursiveAddPath(filePath):
""" recursively add files and directories to watcher """
watcher.addPath(filePath)
fileList = QDir(filePath).entryInfoList(QDir.Dirs | QDir.Files | QDir.NoDotAndDotDot)
for f in fileList:
recursiveAddPath(f.absoluteFilePath())
def directoryChanged(filePath):
watchedFiles = watcher.directories() + watcher.files()
fileList = QDir(filePath).entryInfoList(QDir.Dirs | QDir.Files | QDir.NoDotAndDotDot)
for f in fileList:
if f.absoluteFilePath() not in watchedFiles:
watcher.addPath(f.absoluteFilePath())
self.generate()
# QFileSystemWatcher won't work without a QApplication!
app = QApplication(sys.argv)
watcher = QFileSystemWatcher()
recursiveAddPath(self.notepath)
# add/remove file triggers this
watcher.directoryChanged.connect(directoryChanged)
# edit file triggers this
watcher.fileChanged.connect(self.generate)
sys.exit(app.exec_())
def preview(self, port=3131):
processWatcher = Thread(target=self.regenerate)
processWatcher.start()
self.generate()
from http.server import HTTPServer, SimpleHTTPRequestHandler
HandlerClass = SimpleHTTPRequestHandler
HandlerClass.protocol_version = "HTTP/1.1"
ServerClass = HTTPServer
server_address = ('', port)
httpd = ServerClass(server_address, HandlerClass)
sa = httpd.socket.getsockname()
os.chdir(self.sitepath)
print("Serving HTTP on", sa[0], "port", sa[1], "...")
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
processWatcher.terminate()
httpd.server_close()
sys.exit(0)
def initTree(self, notepath, parent):
if parent == "":
# site wide index page
htmlfile = os.path.join(self.sitepath, "index.html")
else:
# append subpages to page
htmlfile = os.path.join(self.htmlpath, parent + ".html")
html = QFile(htmlfile)
html.open(QIODevice.Append)
savestream = QTextStream(html)
noteDir = QDir(notepath)
notesList = noteDir.entryInfoList(['*.md', '*.mkd', '*.markdown'],
QDir.NoFilter,
QDir.Name|QDir.IgnoreCase)
nl = [note.completeBaseName() for note in notesList]
noduplicate = list(set(nl))
noduplicate.sort(key=str.lower)
htmlDir = os.path.join(self.htmlpath, parent)
if len(noduplicate) > 0 and not QDir(htmlDir).exists():
QDir().mkdir(htmlDir)
for name in noduplicate:
path = notepath + '/' + name
filename = os.path.join(parent, name)
for ext in self.extName:
notefile = os.path.join(self.notepath, filename + ext)
if QFile.exists(notefile):
break
htmlfile = os.path.join(self.htmlpath, filename + ".html")
#print(notefile, htmlfile)
self.convert(notefile, htmlfile, os.path.join(parent,name))
self.initTree(path, os.path.join(parent,name))
# append subpages to page
savestream << '<li><a href="/notes/' + filename + '.html">' + name + '</a></li>'
html.close()
def convert(self, notefile, htmlfile, page):
self.count += 1
note = QFile(notefile)
note.open(QIODevice.ReadOnly)
html = QFile(htmlfile)
html.open(QIODevice.WriteOnly)
savestream = QTextStream(html)
savestream << '<html><head>' \
'<meta charset="utf-8">' \
'<link rel="stylesheet" href="/css/notebook.css" type="text/css" />' \
'</head>'
savestream << "<header>" + self.breadcrumb(page) + "</header>"
# Note content
if 'asciimathml' in self.exts:
savestream << JSCRIPT_TPL.format(self.qsettings.value('mathJax'))
savestream << self.md.reset().convert(QTextStream(note).readAll())
savestream << "</html>"
note.close()
html.close()
def breadcrumb(self, page):
""" Generate breadcrumb from page hierarchy.
e.g. page github/mikidown will be shown as:
<a>github</a> / <a>mikidown</a>
"""
parts = page.split('/')
crumb = '<a href="/">Index</a>'
for i in range(len(parts)):
crumb += ' / '
crumb += '<a href="/notes/' + '/'.join(parts[0:i+1]) + '.html">' + parts[i] + '</a>'
return crumb
def dbConnectionNames(self):
settings = QSettings()
settings.beginGroup('/PostgreSQL/connections/')
return settings.childGroups()
def setNetworkTimeout(value=60000):
global _networkTimeout
_networkTimeout = QSettings().value("Qgis/networkAndProxy/networkTimeout")
QSettings().setValue("Qgis/networkAndProxy/networkTimeout", value)
def get_qgis_app():
""" Start one QGIS application to test against.
:returns: Handle to QGIS app, canvas, iface and parent. If there are any
errors the tuple members will be returned as None.
:rtype: (QgsApplication, CANVAS, IFACE, PARENT)
If QGIS is already running the handle to that app will be returned.
"""
global QGIS_APP, PARENT, IFACE, CANVAS # pylint: disable=W0603
if iface:
from qgis.core import QgsApplication
QGIS_APP = QgsApplication
CANVAS = iface.mapCanvas()
PARENT = iface.mainWindow()
IFACE = iface
return QGIS_APP, CANVAS, IFACE, PARENT
try:
from qgis.core import QgsApplication
from qgis.gui import QgsMapCanvas # pylint: disable=no-name-in-module
# noinspection PyPackageRequirements
from PyQt4 import QtGui, QtCore # pylint: disable=W0621
# noinspection PyPackageRequirements
from PyQt4.QtCore import QCoreApplication, QSettings
from safe.test.qgis_interface import QgisInterface
except ImportError:
return None, None, None, None
if QGIS_APP is None:
gui_flag = True # All test will run qgis in gui mode
# AG: For testing purposes, we use our own configuration file instead
# of using the QGIS apps conf of the host
# noinspection PyCallByClass,PyArgumentList
QCoreApplication.setOrganizationName('QGIS')
# noinspection PyCallByClass,PyArgumentList
QCoreApplication.setOrganizationDomain('qgis.org')
# noinspection PyCallByClass,PyArgumentList
QCoreApplication.setApplicationName('QGIS2InaSAFETesting')
# noinspection PyPep8Naming
if 'argv' in dir(sys):
QGIS_APP = QgsApplication(sys.argv, gui_flag)
else:
QGIS_APP = QgsApplication([], gui_flag)
# Make sure QGIS_PREFIX_PATH is set in your env if needed!
QGIS_APP.initQgis()
s = QGIS_APP.showSettings()
LOGGER.debug(s)
# Save some settings
settings = QSettings()
settings.setValue('locale/overrideFlag', True)
settings.setValue('locale/userLocale', 'en_US')
# We disabled message bars for now for extent selector as
# we don't have a main window to show them in TS - version 3.2
settings.setValue('inasafe/show_extent_confirmations', False)
settings.setValue('inasafe/show_extent_warnings', False)
settings.setValue('inasafe/showRubberBands', True)
settings.setValue('inasafe/analysis_extents_mode', HAZARD_EXPOSURE)
if PARENT is None:
# noinspection PyPep8Naming
PARENT = QtGui.QWidget()
if CANVAS is None:
# noinspection PyPep8Naming
CANVAS = QgsMapCanvas(PARENT)
CANVAS.resize(QtCore.QSize(400, 400))
if IFACE is None:
# QgisInterface is a stub implementation of the QGIS plugin interface
# noinspection PyPep8Naming
IFACE = QgisInterface(CANVAS)
return QGIS_APP, CANVAS, IFACE, PARENT
sys.path.extend(
[os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir))])
# DO NOT REMOVE THIS
# noinspection PyUnresolvedReferences
import qgis # pylint: disable=unused-import
from PyQt4.QtCore import (QLocale, QTranslator, QCoreApplication, QSettings)
# Setup internationalisation for the plugin.
#
# See if QGIS wants to override the system locale
# and then see if we can get a valid translation file
# for whatever locale is effectively being used.
override_flag = QSettings().value('locale/overrideFlag', True, type=bool)
if override_flag:
locale_name = QSettings().value('locale/userLocale', 'en_US', type=str)
else:
locale_name = QLocale.system().name()
# NOTES: we split the locale name because we need the first two
# character i.e. 'id', 'af, etc
locale_name = str(locale_name).split('_')[0]
# Also set the system locale to the user overridden local
# so that the inasafe library functions gettext will work
# .. see:: :py:func:`common.utilities`
os.environ['LANG'] = str(locale_name)
root = os.path.abspath(os.path.join(os.path.dirname(__file__)))
def resetNetworkTimeout():
QSettings().setValue("Qgis/networkAndProxy/networkTimeout",
_networkTimeout)
def saveApplicationSettings(self):
settings = QSettings()
settings.setValue("MainWindow/Size", self.size())
settings.setValue("MainWindow/Position", self.pos())
settings.setValue("MainWindow/State", self.saveState())
settings.setValue("MainWindow/ViewsLocked", self.ui.actionLocked.isChecked())
if self.labeltool.getCurrentFilename() is not None:
filename = self.labeltool.getCurrentFilename()
else:
filename = None
settings.setValue("LastFile", filename)
def selectRootDirectory(self):
filename = QFileDialog.getExistingDirectory(
self.dlg, "Select base directory ", self.dlg.rncRootLabel.text())
self.dlg.rncRootLabel.setText(filename)
QSettings().setValue('RNCLoader/rnc_root', filename)
self.scanCharts(filename)
def save_state(self):
""" Store current state of GUI to configuration file """
settings = QSettings()
settings.setValue('directory', self.output_directory.text())
class WelcomeTab(QWidget, Ui_WelcomeTab):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.retranslate(all=False)
self.settings = QSettings()
show = self.settings.value('showWelcome', 2).toInt()[0]
self.checkBox.setCheckState(Qt.CheckState(show))
def dontShow(self, state):
self.settings.setValue('showWelcome', state)
def changeEvent(self, event):
"""For dynamic translation support.
"""
if QEvent.LanguageChange == event.type():
self.retranslate()
else:
QWidget.changeEvent(self, event)
def retranslate(self, all=True):
"""For dynamic translation.
"""
if all:
self.retranslateUi(self)
# In order to make the job a little bit easier for translators
# we should avoid the (ultra verbose) Qt Designer generated
# html. If you are going to edit the following html, it might
# be more convenient to edit the ``welcome.html`` file in the
# resource folder, and copy paste in here afterwards.
self.textBrowser.setHtml(
QApplication.translate(
'WelcomeTab', """
<html>
<head>
<style type="text/css">
body { padding: 5px; margin: 5px; font-family: sans-serif; }
h1, h2 { color: #61a7e0; }
a { color: #306ebd; }
p { font-size: 10pt; }
</style>
</head>
<body>
<h1>Welcome to Luma</h1>
<p><strong><em>Luma is LDAP management made easy</em></strong></p>
<p><em>Luma</em> provides useful LDAP administration and management
functionality, through a number of plugins.</p>
<h2>Getting started</h2>
<p>The first thing you need to do is to edit the <em>serverlist</em>: Select
(<b>Edit</b> → <b>Server List</b>) from the menubar or use the keyboard
shortcut (<b>CTRL</b>+<b>SHIFT</b>+<b>S</b> on Linux/Windwos, <b>CMD</b>+<b>SHIFT</b>+<b>S</b> on Mac Os X).</p>
<p>After you have added one or more servers, you must activate the plugins you
want to use: Select (<b>Edit</b> → <b>Settings</b>) from the
menubar to open the <em>Settings dialog</em>, and select the <b>Plugins</b> tab.</p>
<p>If you need additional help on how to use the application and/or a spesific
plugin, please refer to the online
<a href="http://folk.ntnu.no/einaru/luma/doc/userguide.html">User guide</a>.</p>
<p>If you cannot find a plugin that suits your needs or you have ideas for a
great Luma plugin, please feel free to
<a href="http://luma.sf.net/">contact us</a> or even
<a href="http://folk.ntnu.no/einaru/luma/doc/HACKING.html">contribute one your self</a>.</p>
<h2>Problems and bugs</h2>
<p>Application errors and various debug information can be seen in the Logger
Window: Select (<b>View</b> → <b>Logger Window</b>) from the menubar or
use the keyboard shortcut (<b>CTRL</b>+<b>L</b> on Linux/Windows, <b>CMD</b>+<b>L</b> on Mac Os X).</p>
<p>If you encounter errors or bugs in the application, please take your time
to fill in a bugreport on our
<a href="http://sourceforge.net/tracker/?group_id=89105">bugtracker</a>.</p>
<h2>Contact</h2>
<p>You can find contact information in the About Luma dialog: Select
(<b>Help</b> → <b>About Luma</b>) or use the keyboard shortcut
(<b>F12</b>), and on the <a href="http://luma.sf.net/">Luma website</a>.</p>
<p style="font-size: 8pt; color: #306ebd; padding-top: 25px">
<em>Copyright © 2003 - 2011 Wido Depping and the Luma devel team</em></p>
</body>
</html>
"""))
def _saveSettings(self):
settings = QSettings("Statoil", "ErtGui")
settings.setValue("geometry", self.saveGeometry())
settings.setValue("windowState", self.saveState())
def __init__(self,
destination,
encoding,
fields,
geometryType,
crs,
options=None):
self.destination = destination
self.isNotFileBased = False
self.layer = None
self.writer = None
if encoding is None:
settings = QSettings()
encoding = settings.value('/Processing/encoding',
'System',
type=str)
if self.destination.startswith(self.MEMORY_LAYER_PREFIX):
self.isNotFileBased = True
uri = GEOM_TYPE_MAP[geometryType] + "?uuid=" + unicode(
uuid.uuid4())
if crs.isValid():
uri += '&crs=' + crs.authid()
fieldsdesc = []
for f in fields:
qgsfield = _toQgsField(f)
fieldsdesc.append(
'field=%s:%s' %
(qgsfield.name(),
TYPE_MAP_MEMORY_LAYER.get(qgsfield.type(), "string")))
if fieldsdesc:
uri += '&' + '&'.join(fieldsdesc)
self.layer = QgsVectorLayer(uri, self.destination, 'memory')
self.writer = self.layer.dataProvider()
elif self.destination.startswith(self.POSTGIS_LAYER_PREFIX):
self.isNotFileBased = True
uri = QgsDataSourceURI(
self.destination[len(self.POSTGIS_LAYER_PREFIX):])
connInfo = uri.connectionInfo()
(success, user,
passwd) = QgsCredentials.instance().get(connInfo, None, None)
if success:
QgsCredentials.instance().put(connInfo, user, passwd)
else:
raise GeoAlgorithmExecutionException(
"Couldn't connect to database")
print uri.uri()
try:
db = postgis_utils.GeoDB(host=uri.host(),
port=int(uri.port()),
dbname=uri.database(),
user=user,
passwd=passwd)
except postgis_utils.DbError as e:
raise GeoAlgorithmExecutionException(
"Couldn't connect to database:\n%s" % e.message)
def _runSQL(sql):
try:
db._exec_sql_and_commit(unicode(sql))
except postgis_utils.DbError as e:
raise GeoAlgorithmExecutionException(
'Error creating output PostGIS table:\n%s' % e.message)
fields = [_toQgsField(f) for f in fields]
fieldsdesc = ",".join(
'%s %s' %
(f.name(), TYPE_MAP_POSTGIS_LAYER.get(f.type(), "VARCHAR"))
for f in fields)
_runSQL("CREATE TABLE %s.%s (%s)" %
(uri.schema(), uri.table().lower(), fieldsdesc))
_runSQL(
"SELECT AddGeometryColumn('{schema}', '{table}', 'the_geom', {srid}, '{typmod}', 2)"
.format(table=uri.table().lower(),
schema=uri.schema(),
srid=crs.authid().split(":")[-1],
typmod=GEOM_TYPE_MAP[geometryType].upper()))
self.layer = QgsVectorLayer(uri.uri(), uri.table(), "postgres")
self.writer = self.layer.dataProvider()
elif self.destination.startswith(self.SPATIALITE_LAYER_PREFIX):
self.isNotFileBased = True
uri = QgsDataSourceURI(
self.destination[len(self.SPATIALITE_LAYER_PREFIX):])
print uri.uri()
try:
db = spatialite_utils.GeoDB(uri=uri)
except spatialite_utils.DbError as e:
raise GeoAlgorithmExecutionException(
"Couldn't connect to database:\n%s" % e.message)
def _runSQL(sql):
try:
db._exec_sql_and_commit(unicode(sql))
except spatialite_utils.DbError as e:
raise GeoAlgorithmExecutionException(
'Error creating output Spatialite table:\n%s' %
e.message)
fields = [_toQgsField(f) for f in fields]
fieldsdesc = ",".join(
'%s %s' %
(f.name(), TYPE_MAP_SPATIALITE_LAYER.get(f.type(), "VARCHAR"))
for f in fields)
_runSQL("DROP TABLE IF EXISTS %s" % uri.table().lower())
_runSQL("CREATE TABLE %s (%s)" % (uri.table().lower(), fieldsdesc))
_runSQL(
"SELECT AddGeometryColumn('{table}', 'the_geom', {srid}, '{typmod}', 2)"
.format(table=uri.table().lower(),
srid=crs.authid().split(":")[-1],
typmod=GEOM_TYPE_MAP[geometryType].upper()))
self.layer = QgsVectorLayer(uri.uri(), uri.table(), "spatialite")
self.writer = self.layer.dataProvider()
else:
formats = QgsVectorFileWriter.supportedFiltersAndFormats()
OGRCodes = {}
for (key, value) in formats.items():
extension = unicode(key)
extension = extension[extension.find('*.') + 2:]
extension = extension[:extension.find(' ')]
OGRCodes[extension] = value
extension = self.destination[self.destination.rfind('.') + 1:]
if extension not in OGRCodes:
extension = 'shp'
self.destination = self.destination + '.shp'
qgsfields = QgsFields()
for field in fields:
qgsfields.append(_toQgsField(field))
self.writer = QgsVectorFileWriter(self.destination, encoding,
qgsfields, geometryType, crs,
OGRCodes[extension])
def get_workinglayer_on_opening(iface):
settings = QSettings()
last_folder = settings.value("terre_image_last_folder")
if last_folder:
path = last_folder
else:
path = QDir.currentPath()
file_opened = QFileDialog.getOpenFileName(None, "Selectionner un fichier raster", path)
settings.setValue("terre_image_last_folder", os.path.dirname(file_opened))
settings.sync()
if file_opened:
# try:
# str(file_opened)
# except UnicodeEncodeError:
# QMessageBox.warning( None , "Erreur", u'L\'image que vous essayez d\'ouvrir contient un ou des caractères spéciaux. \
# La version actuelle du plugin ne gère pas ce type de fichiers. \
# Veuillez renommer le fichier et ou les répertoires le contenant.', QMessageBox.Ok )
# return None, None
# else:
# if file_opened.find(" ") != -1:
# QMessageBox.warning( None , "Attention", u'L\'image que vous essayez d\'ouvrir contient un ou plusieurs espaces. Les traitements sur cette image provoqueront une erreur.'.encode('utf8'), QMessageBox.Ok )
if file_opened.endswith(".qgs"):
# open new qgis project
pass
else:
raster_layer = manage_QGIS.get_raster_layer(file_opened, os.path.splitext(os.path.basename(file_opened))[0])
if not os.name == "posix":
terre_image_run_process.set_OTB_PATH()
type_image = terre_image_processing.get_sensor_id(file_opened)
logger.debug("type_image " + str(type_image))
layer = WorkingLayer(file_opened, raster_layer)
layer.set_type(type_image)
# self.layer = self.canvas.currentLayer()
if layer:
# self.define_bands(self.layer)
# manage_bands()
# self.red, self.green, self.blue, self.pir, self.mir = manage_bands().get_values()
red, green, blue, pir, mir, type_satellite = manage_bands(type_image, layer.get_band_number()).get_values()
if red != -1 or green != -1 or blue != -1 or pir != -1 or mir != -1:
all_set = True
bands = {'red': red, 'green': green, 'blue': blue, 'pir': pir, 'mir': mir}
for i in range(1, layer.get_band_number() + 1):
if i not in bands.values():
all_set = False
if all_set:
layer.set_bands(bands)
if layer.type is None:
layer.set_type(type_satellite)
logger.debug(str(red) + " " + str(green) + " " + str(blue) + " " + str(pir) + " " + str(mir))
cst = TerreImageConstant()
cst.index_group = cst.iface.legendInterface().addGroup("Terre Image", True, None)
manage_QGIS.add_qgis_raser_layer(raster_layer, iface.mapCanvas(), bands)
OTBApplications.compute_overviews(file_opened)
return layer, bands
else:
QMessageBox.warning(None, "Erreur",
u'Il y a un problème dans la définition des bandes spectrales.',
QMessageBox.Ok)
return None, None
else:
return None, None
else:
return None, None
def _fetchSettings(self):
settings = QSettings("Statoil", "ErtGui")
self.restoreGeometry(settings.value("geometry").toByteArray())
self.restoreState(settings.value("windowState").toByteArray())
def acceptedAction(self):
try:
number = int(self.dlg.interval.text())
except Exception:
QMessageBox.about(None, 'Error','Interval can only be a number')
return None
s = QSettings()
if self.dlg.enableAutoSave.isChecked():
s.setValue("autoSaver/enabled","true")
if self.dlg.enableAlternate.isChecked():
s.setValue("autoSaver/alternateBak","true")
else:
s.setValue("autoSaver/alternateBak","false")
if self.dlg.enableSaveLayers.isChecked():
s.setValue("autoSaver/saveLayerInEditMode","true")
else:
s.setValue("autoSaver/saveLayerInEditMode","false")
if self.dlg.enableSaveLayersBuffer.isChecked():
s.setValue("autoSaver/saveLayerBuffer","true")
else:
s.setValue("autoSaver/saveLayerBuffer","false")
s.setValue("autoSaver/interval",self.dlg.interval.text())
self.startAutosave(self.dlg.interval.text())
else:
s.setValue("autoSaver/enabled","false")
if self.dlg.enableAlternate.isChecked():
s.setValue("autoSaver/alternateBak","true")
else:
s.setValue("autoSaver/alternateBak","false")
if self.dlg.enableSaveLayers.isChecked():
s.setValue("autoSaver/saveLayerInEditMode","true")
else:
s.setValue("autoSaver/saveLayerInEditMode","false")
if self.dlg.enableSaveLayersBuffer.isChecked():
s.setValue("autoSaver/saveLayerBuffer","true")
else:
s.setValue("autoSaver/saveLayerBuffer","false")
s.setValue("autoSaver/interval",self.dlg.interval.text())
self.stopAutosave()
self.dlg.hide()
def initGui(self):
# Import Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/database.png")
self.import_action = QAction(icon, u"Importer des données", self.iface.mainWindow())
QObject.connect(self.import_action, SIGNAL("triggered()"), self.open_import_dialog)
# Search Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/search.png")
self.search_action = QAction(icon, u"Outils de recherche", self.iface.mainWindow())
QObject.connect(self.search_action, SIGNAL("triggered()"), self.toggle_search_dialog)
if not self.cadastre_search_dialog:
dialog = cadastre_search_dialog(self.iface)
self.cadastre_search_dialog = dialog
# Load Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/output.png")
self.load_action = QAction(icon, u"Charger des données", self.iface.mainWindow())
QObject.connect(self.load_action, SIGNAL("triggered()"), self.open_load_dialog)
# Composer Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/mActionSaveAsPDF.png")
self.export_action = QAction(icon, u"Exporter la vue", self.iface.mainWindow())
QObject.connect(self.export_action, SIGNAL("triggered()"), self.export_view)
# Options Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/config.png")
self.option_action = QAction(icon, u"Configurer le plugin", self.iface.mainWindow())
QObject.connect(self.option_action, SIGNAL("triggered()"), self.open_option_dialog)
# About Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/about.png")
self.about_action = QAction(icon, u"À propos", self.iface.mainWindow())
QObject.connect(self.about_action, SIGNAL("triggered()"), self.open_about_dialog)
# Help Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/about.png")
self.help_action = QAction(icon, u"Aide", self.iface.mainWindow())
QObject.connect(self.help_action, SIGNAL("triggered()"), self.open_help)
# version Submenu
icon = QIcon(os.path.dirname(__file__) + "/icons/about.png")
self.version_action = QAction(icon, u"Notes de version", self.iface.mainWindow())
QObject.connect(self.version_action, SIGNAL("triggered()"), self.open_message_dialog)
# Add Cadastre to Extension menu
self.iface.addPluginToMenu(u"&Cadastre", self.import_action)
self.iface.addPluginToMenu(u"&Cadastre", self.load_action)
self.iface.addPluginToMenu(u"&Cadastre", self.search_action)
self.iface.addPluginToMenu(u"&Cadastre", self.export_action)
self.iface.addPluginToMenu(u"&Cadastre", self.option_action)
self.iface.addPluginToMenu(u"&Cadastre", self.about_action)
self.iface.addPluginToMenu(u"&Cadastre", self.version_action)
self.iface.addPluginToMenu(u"&Cadastre", self.help_action)
# Add cadastre toolbar
self.toolbar = self.iface.addToolBar(u'&Cadastre');
# open import dialog
self.openImportAction = QAction(
QIcon(os.path.dirname(__file__) +"/icons/database.png"),
u"Importer des données",
self.iface.mainWindow()
)
self.openImportAction.triggered.connect(self.open_import_dialog)
self.toolbar.addAction(self.openImportAction)
self.toolbar.setObjectName("cadastreToolbar");
# open load dialog
self.openLoadAction = QAction(
QIcon(os.path.dirname(__file__) +"/icons/output.png"),
u"Charger des données",
self.iface.mainWindow()
)
self.openLoadAction.triggered.connect(self.open_load_dialog)
self.toolbar.addAction(self.openLoadAction)
# open search dialog
self.openSearchAction = QAction(
QIcon(os.path.dirname(__file__) +"/icons/search.png"),
u"Outils de recherche",
self.iface.mainWindow()
)
self.openSearchAction.triggered.connect(self.toggle_search_dialog)
#~ self.openSearchAction.setCheckable(True)
self.toolbar.addAction(self.openSearchAction)
# export composer
self.runExportAction = QAction(
QIcon(os.path.dirname(__file__) +"/icons/mActionSaveAsPDF.png"),
u"Exporter la vue",
self.iface.mainWindow()
)
self.runExportAction.triggered.connect(self.export_view)
self.toolbar.addAction(self.runExportAction)
# open Option dialog
self.openOptionAction = QAction(
QIcon(os.path.dirname(__file__) +"/icons/config.png"),
u"Configurer le plugin",
self.iface.mainWindow()
)
self.openOptionAction.triggered.connect(self.open_option_dialog)
self.toolbar.addAction(self.openOptionAction)
# open About dialog
self.openAboutAction = QAction(
QIcon(os.path.dirname(__file__) +"/icons/about.png"),
u"À propos",
self.iface.mainWindow()
)
self.openAboutAction.triggered.connect(self.open_about_dialog)
self.toolbar.addAction(self.openAboutAction)
# Create action for "Parcelle information"
self.identifyParcelleAction = QAction(
QIcon(os.path.dirname(__file__) +"/icons/toolbar/get-parcelle-info.png"),
"Infos parcelle",
self.iface.mainWindow()
)
self.identifyParcelleAction.setCheckable(True)
self.identifyParcelleAction.triggered.connect( self.setIndentifyParcelleTool )
self.toolbar.addAction( self.identifyParcelleAction )
self.setActionsExclusive()
# Display About window on first use
s = QSettings()
firstUse = s.value("cadastre/isFirstUse" , 1, type=int)
if firstUse == 1:
s.setValue("cadastre/isFirstUse", 0)
self.open_about_dialog()
# Display some messages depending on version number
mConfig = ConfigParser.ConfigParser()
metadataFile = os.path.dirname(__file__) + "/metadata.txt"
mConfig.read( metadataFile )
self.mConfig = mConfig
myVersion = mConfig.get('general', 'version').replace('.', '_')
myVersionMsg = s.value("cadastre/version_%s" % myVersion , 1, type=int)
if myVersionMsg == 1:
s.setValue("cadastre/version_%s" % myVersion , 0)
self.open_message_dialog()
# Project load or create : refresh search and identify tool
self.iface.projectRead.connect(self.onProjectRead)
self.iface.newProjectCreated.connect(self.onNewProjectCreated)
# Delete layers from table when deleted from registry
lr = QgsMapLayerRegistry.instance()
lr.layersRemoved.connect( self.checkIdentifyParcelleTool )
