def __init__(self, project, parent=None):
QDialog.__init__(self, parent)
uic.loadUi(
os.path.join(os.path.dirname(__file__),
'export_raster_formation.ui'), self)
self.__project = project
self.populateFormation()
def __init__(self, iface: QgisInterface = None, canvas: QgsMapCanvas = None,
position: int = Qt.RightDockWidgetArea):
'''
Parameters
----------
iface : QgisInterface, optional
instance of QGIS interface, defaults to the interface of the QGIS
instance in use
canvas : QgsMapCanvas, optional
the map canvas, defaults to the canvas of the interface
position : int, optional
dock widget area to add the dock widget to, defaults to attach the
widget in the right section of QGIS (Qt.RightDockWidgetArea)
'''
super().__init__()
self.iface = iface or utils.iface
self.canvas = canvas or self.iface.mapCanvas()
self.initial_position = position
self.ui = QtWidgets.QDockWidget()
# look for file ui folder if not found
ui_file = self.ui_file if os.path.exists(self.ui_file) \
else os.path.join(settings.UI_PATH, self.ui_file)
uic.loadUi(ui_file, self.ui)
#self.ui.setAllowedAreas(
#Qt.RightDockWidgetArea | Qt.LeftDockWidgetArea |
#Qt.TopDockWidgetArea | Qt.BottomDockWidgetArea
#)
self.ui.closeEvent = self.closeEvent
self.is_active = False
self.setupUi()
def __init__(self, conn_info, parent=None):
super(BoreHoleWindow, self).__init__(parent)
uic.loadUi(os.path.join(os.path.dirname(__file__), 'log_strati.ui'),
self)
self.scene = BoreHoleScene(conn_info, self)
self.graphicsView.setScene(self.scene)
self.graphicsView.installEventFilter(self.scene.scroll_filter())
def __init__(self, item, backgrounds, parent=None):
super(ProjectWidget, self).__init__(parent)
uic.loadUi(
os.path.join(os.path.dirname(__file__), "project_dialog.ui"), self)
self.__item = item
self.scaleLineEdit.setText(str([int(s) for s in item['scales']])[1:-1])
defaultBackgroundIdx = None
self.backgroundComboBox.addItem("")
for i, layer in enumerate(backgrounds):
self.backgroundComboBox.addItem(layer['name'])
checkBox = QCheckBox(layer['name'])
self.backgroundLayout.addWidget(checkBox)
for l in item['backgroundLayers']:
if (l['name'] == layer['name']) == 1:
checkBox.setChecked(True)
if l['visibility']:
defaultBackgroundIdx = i + 1
if defaultBackgroundIdx is not None:
self.backgroundComboBox.setCurrentIndex(defaultBackgroundIdx)
if 'coordinates' in item['searchProviders']:
self.coordinatesCheckBox.setChecked(True)
if 'nominatim' in item['searchProviders']:
self.nominatimCheckBox.setChecked(True)
def __init__(self, main):
super().__init__(self._icon, self._name)
self.setCheckable(True)
self.main = main
# Build the widget
self.widget = QWidget()
uic.loadUi(
os.path.join(os.path.dirname(__file__), "ui", self._widget_ui),
self.widget)
self.widget.dateTimeEdit.setDateTime(QDateTime.currentDateTime())
self.widgetAction = QWidgetAction(self)
self.widgetAction.setDefaultWidget(self.widget)
self.menu = QMenu()
self.menu.addAction(self.widgetAction)
self.setMenu(self.menu)
# Build the tool
self.tool = QgsMapToolEmitPoint(self.main.iface.mapCanvas())
self.tool.activated.connect(lambda: self.setChecked(True))
self.tool.deactivated.connect(lambda: self.setChecked(False))
self.tool.canvasClicked.connect(self.tool_clicked)
# Connect the action
self.triggered.connect(self.start_tool)
def __init__(self,
ui_file: str = None,
modal: bool = True,
parent: QWidget = None,
title: str = None):
'''
Parameters
----------
ui_file : str, optional
path to QT-Designer xml file to load UI of dialog from,
if only filename is given, the file is looked for in the standard
folder (UI_PATH), defaults to not using ui file
modal : bool, optional
set dialog to modal if True, not modal if False, defaults to modal
parent: QWidget, optional
parent widget, defaults to None
title: str, optional
replaces title of dialog if given, defaults to preset title
'''
super().__init__(parent=parent)
if ui_file:
# look for file ui folder if not found
ui_file = ui_file if os.path.exists(ui_file) \
else os.path.join(UI_PATH, ui_file)
uic.loadUi(ui_file, self)
if title:
self.setWindowTitle(title)
self.setModal(modal)
self.setupUi()
def __init__(self, iface, plugin_dir, yleiskaavaSettings,
yleiskaavaDatabase, yleiskaavaUtils):
self.iface = iface
self.yleiskaavaSettings = yleiskaavaSettings
self.yleiskaavaDatabase = yleiskaavaDatabase
self.yleiskaavaUtils = yleiskaavaUtils
self.plugin_dir = plugin_dir
self.dialogChangeFieldValuesOfGroup = uic.loadUi(
os.path.join(self.plugin_dir, 'ui',
'yleiskaava_dialog_change_field_values_of_group.ui'))
self.dialogChooseAndUpdateFieldValuesForFeatureType = uic.loadUi(
os.path.join(
self.plugin_dir, 'ui',
'yleiskaava_dialog_choose_and_update_field_values_for_feature_type.ui'
))
self.hasUserSelectedPolygonFeaturesForUpdate = False
self.hasUserSelectedSuplementaryPolygonFeaturesForUpdate = False
self.hasUserSelectedLineFeaturesForUpdate = False
self.hasUserSelectedPointFeaturesForUpdate = False
self.shownFieldNamesAndTypes = []
self.currentFeatureType = None
def __init__(self, model, iface=None):
QDialog.__init__(self)
# Set up the user interface from Designer.
ui_path = os.path.join(os.path.dirname(__file__),
'Ui_AddColumnDialog.ui')
uic.loadUi(ui_path, self)
self.mError.setStyleSheet('* { color: red; }')
try:
self.restoreGeometry(QgsSettings().value("RATAddColumn/geometry",
None, QByteArray,
QgsSettings.Plugins))
except:
pass
self.mName.textChanged.connect(self.updateDialog)
self.mStandardColumn.toggled.connect(self.updateDialog)
self.mUsage.currentIndexChanged.connect(self.updateDialog)
self.mColor.toggled.connect(self.updateDialog)
self.mDataType.addItem(data_type_name(gdal.GFT_String),
gdal.GFT_String)
self.mDataType.addItem(data_type_name(gdal.GFT_Integer),
gdal.GFT_Integer)
self.mDataType.addItem(data_type_name(gdal.GFT_Real), gdal.GFT_Real)
self.upper_headers = [h.upper() for h in model.headers]
self.model = model
self.column_info = rat_column_info()
self.mUsage.setCurrentIndex(self.mUsage.findData(gdal.GFU_Generic))
self.updateDialog()
def __init__(self, currentQgisProjectFile, parent=None):
super(ConfigDialog, self).__init__(parent)
uic.loadUi(os.path.join(os.path.dirname(__file__), "config_dialog.ui"),
self)
assert (currentQgisProjectFile
and os.path.isfile(currentQgisProjectFile))
if currentQgisProjectFile is not None and not currentQgisProjectFile.endswith(
".qgs"):
self.warningLabel.setText("the project extension is not .qgs")
s = QgsSettings()
self.urlLineEdit.setText(s.value("qwc2configurator/server/url", ""))
self.usernameLineEdit.setText(
s.value("qwc2configurator/server/username", ""))
self.passwordLineEdit.setText(
s.value("qwc2configurator/server/password", ""))
self.__config = None
self.__projectIdxInConfig = None
self.__projectConfig = None
self.__currentQgisProjectFile = os.path.abspath(currentQgisProjectFile)
self.projectsComboBox.currentIndexChanged[str].connect(
self.__projectChanged)
self.getConfigButton.clicked.connect(self.__getConfig)
def __init__(self):
QDialog.__init__(self)
# Set up the user interface from Designer.
ui_path = os.path.join(os.path.dirname(__file__), 'Ui_QuickWKT.ui')
uic.loadUi(ui_path, self)
self.exampleComboBox.addItems(list(EXAMPLES.keys()))
self.exampleComboBox.currentIndexChanged.connect(self.on_exampleComboBox_currentIndexChanged)
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
#load the ui
uic.loadUi(UI_PATH, self)
self.iface = iface
self.HelpButton.clicked.connect(self.Help)
def __init__(self):
super().__init__()
uic.loadUi(
os.path.join(os.path.dirname(__file__), "ui", "ExpressRouteWidget.ui"), self
)
self.dateTimeEdit.setDateTime(QDateTime.currentDateTime())
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.input_layer = None
self.raster_layer = None
self.raster_layer_box.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.raster_layer_box.layerChanged.connect(self.setRasterLayer)
self.raster_band_box.setEnabled(False)
self.method_box.addItem('nearest neighbor (downscaling/upscaling)')
self.method_box.addItem('bi-linear (downscaling)')
self.method_box.addItem('bi-cubic (downscaling)')
#connect by signal and slot
self.browse_button.clicked.connect(self.onBrowseButtonClicked)
self.interpolation_group.clicked.connect(self.change_interpolation)
self.HelpButton.clicked.connect(self.Help)
self.iface.currentLayerChanged.connect(self.setInputLayer)
self.setInputLayer(self.iface.activeLayer())
self.setRasterLayer(self.raster_layer_box.currentLayer())
def __init__(self, iface):
QDialog.__init__(self)
self.iface = iface
loadUi(os.path.join(os.path.dirname(__file__), "dialogo.ui"), self)
self.mi_boton.clicked.connect(self.accion)
self.accepted.connect(self.aceptado)
self.rejected.connect(self.rechazado)
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.input_layer = None
self.browse_button.clicked.connect(self.onBrowseButtonClicked)
self.iface.currentLayerChanged.connect(self.setInputLayer)
self.setInputLayer(self.iface.activeLayer())
def __init__(self, main):
super().__init__(main.iface.mainWindow())
uic.loadUi(
os.path.join(os.path.dirname(__file__), "ui", "SplashScreen.ui"),
self)
# self.setWindowFlag(Qt.WindowStaysOnTopHint)
self.buttonBox.accepted.connect(self.accept)
def __init__(self):
super().__init__()
uic.loadUi(
os.path.join(os.path.dirname(__file__), 'ui', 'ConfigDialog.ui'),
self)
self.getKeyButton.pressed.connect(self.get_key)
self.countResetButton.pressed.connect(self.reset_count)
self.buttonBox.accepted.connect(self.accept)
def __init__(self, uifile, presenter, manager, parent=None):
super().__init__(parent=parent, flags=Qt.Window)
uipath = "ui"
ui = path.join(path.dirname(__file__), f"{uipath}/{uifile}")
uic.loadUi(ui, self)
self.manager = manager
self.presenter = presenter(self)
self.messageBar = self.manager.iface.messageBar()
self.messageTitle = "Gardener plugin"
def __init__(self, main, html, *args, **kwargs):
super().__init__(*args, **kwargs)
uic.loadUi(
os.path.join(os.path.dirname(__file__), 'ui', 'HelpContent.ui'),
self)
self.main = main
self.htmlWidget.anchorClicked.connect(self.open_link)
self.htmlWidget.setText(html)
self.htmlWidget.setSearchPaths([HELP_DIR])
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent=parent, flags=flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.db_host.editingFinished.connect(self.onConnectionSettingsEdited)
self.db_name.editingFinished.connect(self.onConnectionSettingsEdited)
self.db_user.editingFinished.connect(self.onConnectionSettingsEdited)
self.db_pass.editingFinished.connect(self.onConnectionSettingsEdited)
self.browse_button.clicked.connect(self.onBrowseButtonClicked)
self.connect_button.clicked.connect(self.onConnectClicked)
def __init__(self, iface=None):
QDialog.__init__(self)
# Set up the user interface from Designer.
ui_path = os.path.join(os.path.dirname(
__file__), 'Ui_AboutDialog.ui')
uic.loadUi(ui_path, self)
try:
self.restoreGeometry(QgsSettings().value(
"RATAbout/geometry", None, QByteArray, QgsSettings.Plugins))
except:
pass
def __init__(self, parent):
super().__init__(parent)
loadUi(os.path.join(os.path.dirname(__file__), "gui_import.ui"), self)
self.accepted.connect(self.commit_session)
self.rejected.connect(self.rollback_session)
header = self.treeWidget.header()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
header.setSectionResizeMode(0, QHeaderView.Stretch)
# No required here, but this way we load before opening the dialog
get_qgep_model()
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.ecnLayerBox.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.popLayerBox.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.AreaLayerBox.setFilters(QgsMapLayerProxyModel.PolygonLayer)
# The module consists of two input options ecn/ pop. The lines below set the default that none of them are chosen in the beginning.
# The user has to choose one of them. The two bottom functions will make sure that only one of the options can be chosen.
self.mGroupBox_ecn.clicked.connect(self.check_mGroupBox_ecn)
self.mGroupBox_pop.clicked.connect(self.check_mGroupBox_pop)
self.mGroupBox_ecn.setChecked(True)
self.picker = QgsMapToolEmitPoint(self.iface.mapCanvas())
self.addButton.setEnabled(False)
self.zoomButton.setEnabled(False)
self.removeButton.setEnabled(False)
self.ExportButton.setEnabled(False)
self.groupBox.setEnabled(False)
self.ImportButton.setEnabled(False)
self.AreaLayerBox.setLayer(None)
self.ecnLayerBox.setLayer(None)
self.popLayerBox.setLayer(None)
self.removeButton.clicked.connect(self.removeRasterItems)
self.removeButton.setAutoDefault(False)
self.listWidget.currentRowChanged.connect(
self.updateRasterPropertiesGroup)
self.ecnLayerBox.layerChanged.connect(self.updateECNBox)
self.popLayerBox.layerChanged.connect(self.updatePOPBox)
self.AreaLayerBox.layerChanged.connect(self.UpdateImportButtons)
self.pickButton.clicked.connect(self.enableMapPicker)
self.pickButton.setAutoDefault(False)
self.browseButton.clicked.connect(self.onBrowseButtonClicked)
self.browseButton.setAutoDefault(False)
self.mGroupBox_ecn.setChecked(True)
self.popNaNBox.setEnabled(False)
self.popTypeBox.setEnabled(False)
self.popUnitTransBox.setEnabled(False)
self.popLayerBox.setEnabled(False)
self.label_20.setEnabled(False)
self.label.setEnabled(False)
self.label_12.setEnabled(False)
self.label_21.setEnabled(False)
self.HelpButton.clicked.connect(self.Help)
def widget(self):
"""
The editor's widget (created on the fly if needed)
"""
if not hasattr(self, "_widget"):
class BaseWidget(QWidget):
pass
self._widget = BaseWidget()
loadUi(os.path.join(os.path.dirname(__file__), self.widget_name),
self._widget)
self.init_widget()
return self._widget
def __init__(self, parent: QWidget = None):
super(MainWidget, self).__init__(parent)
# currently selected output layer
self.output = None
# stores which layers are marked as output layers
self.output_layer_ids = []
self.input = None
self.valid_bkg_key = False
self.label_field_name = None
# cache all results for a layer, (layer-id, feature-id) as keys,
# geojson features as values
self.result_cache = {}
# cache field-map settings for layers, layer-ids as keys,
# FieldMaps as values
self.field_map_cache = {}
# cache label fields, layer-ids as keys, field name as values
self.label_cache = {}
self.field_map = None
add_fields = [
ResField('n_results',
'int2',
alias='Anzahl der Ergebnisse',
prefix='gc'),
ResField('i', 'int2', alias='Ergebnisindex', prefix='gc'),
ResField('manuell_bearbeitet', 'bool', alias='Manuell bearbeitet')
]
add_fields += BKG_RESULT_FIELDS
# additional fields for storing results,
# non-optional fields are active by default, others will be set by
# user input
self.result_fields = {
f.name: (f, True if not f.optional else False)
for f in add_fields
}
self.inspect_dialog = None
self.reverse_dialog = None
self.geocoding = None
self.iface = utils.iface
self.canvas = self.iface.mapCanvas()
ui_file = self.ui_file if os.path.exists(self.ui_file) \
else os.path.join(UI_PATH, self.ui_file)
uic.loadUi(ui_file, self)
self.setAllowedAreas(Qt.RightDockWidgetArea | Qt.LeftDockWidgetArea)
self.setupUi()
self.setup_config()
def __init__(self, iface):
QDialog.__init__(self)
ui_path = os.path.join(os.path.dirname(__file__),
'BBoxPreviewWindow.ui')
uic.loadUi(ui_path, self)
self.canvas = iface.mapCanvas()
self.destinationLayer.setCurrentIndex(0)
self.destinationLayer.setFilters(
qgis.core.QgsMapLayerProxyModel.PolygonLayer)
self.showButton.clicked.connect(self.showBbox)
self.formatManager = biz.FormatManager()
for format in self.formatManager.formatClasses:
self.formatsComboBox.addItem(
self.formatManager.formatClasses[format].displayName(), format)
def __init__(self, iface):
self.iface = iface
QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = uic.loadUi(ui_file, self)
self.configFilePath = os.path.join(os.path.dirname(__file__), 'config.cfg')
self.defFlags = Qt.NoItemFlags | Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable
# Populate the PostGIS connection combo with the available connections
# Determine our current preference
s = QSettings()
selectedConnection = str(s.value("constraintchecker/postgisConnection", ''))
s.beginGroup('PostgreSQL/connections')
i = 0
for connectionName in s.childGroups():
self.postgisConnectionComboBox.addItem(connectionName)
if connectionName == selectedConnection:
# Select this preference in the combo if exists
self.postgisConnectionComboBox.setCurrentIndex(i)
i += 1
s.endGroup()
# Now read the configuration file (if it exists) into the table widget
try:
self.readConfiguration()
except:
pass
def __init__(self, model):
QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = uic.loadUi(ui_file, self)
self.resultModel = model
self.constraintTableView.setModel(self.resultModel)
self.constraintTableView.resizeColumnsToContents()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
tdir = os.path.dirname(os.path.realpath(__file__))
uif = os.path.join(tdir, "ui", "ui_rasCreateRasLayers.ui")
self.ui = uic.loadUi(uif, self)
self.rgis = parent
self.rdb = parent.rdb
self.ui.buttonBox.accepted.connect(self.acceptDialog)
self.ui.buttonBox.rejected.connect(self.reject)
self.ui.helpButton.clicked.connect(self.displayHelp)
self.ui.allChbox.toggled.connect(self.allChboxToggled)
self.tables = [
(self.ui.bankLinesChbox, heco.BankLines),
(self.ui.blockedChbox, heco.BlockedObs),
(self.ui.breaklines2DChbox, heco.BreakLines2d),
(self.ui.breakpoints2DChbox, heco.BreakPoints2d),
(self.ui.bridgesChbox, heco.Bridges),
(self.ui.flowPathChbox, heco.Flowpaths),
(self.ui.flowAreas2DChbox, heco.FlowAreas2d),
(self.ui.flowAreas2DChbox, heco.MeshPoints2d),
(self.ui.ineffectiveChbox, heco.IneffAreas),
(self.ui.inlineStructChbox, heco.InlineStructures),
(self.ui.streamChbox, heco.StreamCenterlines),
(self.ui.landuseChbox, heco.LanduseAreas),
(self.ui.lateralStructChbox, heco.LateralStructures),
(self.ui.leveeChbox, heco.LeveeAlignment),
(self.ui.leveeChbox, heco.LeveePoints),
(self.ui.storageAreasChbox, heco.StorageAreas),
(self.ui.saConnectionsChbox, heco.SAConnections),
(self.ui.xsCutLinesChbox, heco.XSCutLines)]
self.tables.sort(key=lambda x: x[1]().order)
def __init__(self, current_row, iface=None):
QDialog.__init__(self)
# Set up the user interface from Designer.
ui_path = os.path.join(os.path.dirname(__file__), 'Ui_AddRowDialog.ui')
uic.loadUi(ui_path, self)
try:
self.restoreGeometry(QgsSettings().value("RATAddRow/geometry",
None, QByteArray,
QgsSettings.Plugins))
except:
pass
self.mBefore.setText(self.mBefore.text() + str(current_row + 1))
self.mAfter.setText(self.mAfter.text() + str(current_row + 1))
def __init__(self, main, *args, **kwargs):
super().__init__(*args, **kwargs)
uic.loadUi(
os.path.join(os.path.dirname(__file__), "ui", "HelpDialog.ui"),
self)
self.closeButton.pressed.connect(self.close)
self.openBrowserButton.pressed.connect(self.open_in_browser)
self.homeButton.pressed.connect(self.reset_url)
self.main = main
self.webview = QWebView()
self.reset_url()
self.contentWidget.layout().addWidget(self.webview)
def __init__(self, iface, plugin_dir, yleiskaavaSettings,
yleiskaavaDatabase, yleiskaavaUtils):
self.iface = iface
self.yleiskaavaSettings = yleiskaavaSettings
self.yleiskaavaDatabase = yleiskaavaDatabase
self.yleiskaavaUtils = yleiskaavaUtils
self.plugin_dir = plugin_dir
self.dialogUpdateThemeOfGroup = uic.loadUi(
os.path.join(self.plugin_dir, 'ui',
'yleiskaava_dialog_update_themes_of_group.ui'))
self.themes = None
self.themeNames = None
self.currentTheme = None
self.hasUserSelectedPolygonFeaturesForUpdate = False
self.hasUserSelectedSuplementaryPolygonFeaturesForUpdate = False
self.hasUserSelectedLineFeaturesForUpdate = False
self.hasUserSelectedPointFeaturesForUpdate = False
self.hasUserCanceledCopy = False
self.progressDialog = None
self.shouldHide = False
def __init__(self, iface):
self.supportedPaperSizes = ['A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8'] # ISO A series
self.paperSizesPresent = []
self.presetScales = ['200', '500', '1 000', '1 250', '2 500', '5 000', '10 000', '25 000', '50 000', '100 000']
self.iface = iface
QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = uic.loadUi(ui_file, self)
# Set up the list of templates
s = QtCore.QSettings()
self.identifiable_only = s.value("SelectorTools/ProjectSelector/identifiableOnly", True, type=bool)
self.templateFileRoot = s.value("SelectorTools/TemplateSelector/templateRoot", '', type=str)
if len(self.templateFileRoot) == 0 or not os.path.isdir(self.templateFileRoot):
raise TemplateSelectorException('\'%s\' is not a valid template file root folder.' % self.templateFileRoot)
self.populateTemplateTypes()
self.populatePoiLayers()
self.onPoiLayerChanged()
self.onTemplateTypeChanged()
self.plugin_dir = os.path.dirname(__file__)
# Replacement map
self.ui.suitableForComboBox.addItem('<custom>')
self.user = os.environ.get('username', '[user]')
self.replaceMap = {
'author': "Compiled by {} on [%concat(day($now ),'/',month($now),'/',year($now))%]".format(self.user)
}
self.ui.autofit_btn.clicked.connect(self.autofit_map)
self.ui.suitableForComboBox.currentIndexChanged.connect(self.specify_dpi)
self.ui.suitableForComboBox.editTextChanged.connect(self.text_changed)
self.ui.poiLayerComboBox.currentIndexChanged.connect(self.onPoiLayerChanged)
def __init__(self,
zipfile: str,
output_dir: str,
no_shapes=False,
ignore_no_route_stops=False):
"""Constructor."""
super().__init__()
self.ui = uic.loadUi(
os.path.join(os.path.dirname(__file__), 'gtfs_go_loader_base.ui'),
self)
self.zipfile = zipfile
self.output_dir = output_dir
self.no_shapes = no_shapes
self.ignore_no_route_stops = ignore_no_route_stops
# vars to store Classes working in other threads.
self.downloader = None
self.extractor = None
self.ui.progressBar.setMaximum(MAX_PROGRESS_COUNT)
if os.path.exists(TEMPDIR):
shutil.rmtree(TEMPDIR)
os.makedirs(TEMPDIR, exist_ok=True)
self.start()
self.ui.pushButton.clicked.connect(self.canceled)
def update_template(self):
if self.template_subframe is not None:
self.template_subframe.setParent(None)
subframe = QFrame(self.template_frame)
self.frame_layout.addWidget(subframe, 1, 0, 1, 2)
self.template_subframe = uic.loadUi(os.path.join(
self.template().subdir(), 'wizard_form_base.ui'),
subframe)
def showAnimationOptions(self):
self.animationDialog = uic.loadUi(os.path.join(self.path, ANIMATION_WIDGET_FILE))
def selectFile():
self.animationDialog.lineEdit.setText(QFileDialog.getOpenFileName())
self.animationDialog.pushButton.clicked.connect(self.selectAnimationFolder)
self.animationDialog.buttonBox.accepted.connect(self.sendAnimationOptions)
self.animationDialog.show()
def __init__(self, iface, model):
"""Initialize the GUI control"""
QObject.__init__(self)
self.iface = iface
self.model = model
self.optionsDialog = None
self.path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'ui')
# load the form
self.dock = uic.loadUi(os.path.join(self.path, DOCK_WIDGET_FILE))
self.iface.addDockWidget(Qt.BottomDockWidgetArea, self.dock)
self.dock.pushButtonExportVideo.setEnabled(False) # only enabled if there are managed layers
self.dock.pushButtonOptions.clicked.connect(self.optionsClicked)
self.dock.pushButtonExportVideo.clicked.connect(self.exportVideoClicked)
self.dock.pushButtonToggleTime.clicked.connect(self.toggleTimeClicked)
self.dock.pushButtonArchaeology.clicked.connect(self.archaeologyClicked)
self.dock.pushButtonBack.clicked.connect(self.backClicked)
self.dock.pushButtonForward.clicked.connect(self.forwardClicked)
self.dock.pushButtonPlay.clicked.connect(self.playClicked)
self.dock.dateTimeEditCurrentTime.dateTimeChanged.connect(self.currentTimeChangedDateText)
# self.dock.horizontalTimeSlider.valueChanged.connect(self.currentTimeChangedSlider)
self.sliderTimer = QTimer(self)
self.sliderTimer.setInterval(250)
self.sliderTimer.setSingleShot(True)
self.sliderTimer.timeout.connect(self.currentTimeChangedSlider)
self.dock.horizontalTimeSlider.valueChanged.connect(self.startTimer)
self.dock.comboBoxTimeExtent.currentIndexChanged[str].connect(self.currentTimeFrameTypeChanged)
self.dock.spinBoxTimeExtent.valueChanged.connect(self.currentTimeFrameSizeChanged)
# this signal is responsible for rendering the label
self.iface.mapCanvas().renderComplete.connect(self.renderLabel)
# create shortcuts
self.focusSC = QShortcut(QKeySequence("Ctrl+Space"), self.dock)
self.focusSC.activated.connect(self.dock.horizontalTimeSlider.setFocus)
# put default values
self.dock.horizontalTimeSlider.setMinimum(conf.MIN_TIMESLIDER_DEFAULT)
self.dock.horizontalTimeSlider.setMaximum(conf.MAX_TIMESLIDER_DEFAULT)
self.dock.dateTimeEditCurrentTime.setMinimumDate(MIN_QDATE)
self.showLabel = conf.DEFAULT_SHOW_LABEL
self.exportEmpty = conf.DEFAULT_EXPORT_EMPTY
self.labelOptions = TimestampLabelConfig(self.model)
# placeholders for widgets that are added dynamically
self.bcdateSpinBox = None
# add to plugins toolbar
try:
self.action = QAction(QCoreApplication.translate("TimeManagerGuiControl", "Toggle visibility"), self.iface.mainWindow())
self.action.triggered.connect(self.toggleDock)
self.iface.addPluginToMenu(QCoreApplication.translate("TimeManagerGuiControl", "&TimeManager"), self.action)
except Exception as e:
pass # OK for testing
def initGui(self):
proj = QgsProject.instance()
proj.readProject.connect(self.loadData)
proj.writeProject.connect(self.saveData)
self.iface.newProjectCreated .connect(self.clearEdit)
pluginPath = path.dirname(path.abspath(__file__))
self.dock = uic.loadUi(path.join(pluginPath, "ui_qnote.ui"))
self.iface.addDockWidget(Qt.BottomDockWidgetArea, self.dock)
self.loadData()
def xml(self):
self.doc = QDomDocument()
element = self.doc.createElement("qgiswidgets")
self.doc.appendChild(element)
for p in glob.glob(self.ui_dir):
self.printMsg("Loading " + p)
# qgsrasterlayerpropertiesbase.ui is giving: No module named qwt_plot
try:
widget = loadUi(p)
#print dir ( ui )
self.widgetXml(element, widget)
except Exception, e:
#except IOError, e:
self.printMsg(str(e))
def __init__(self):
QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = uic.loadUi(ui_file, self)
self.settings = QtCore.QSettings()
# Populate the values
with open(DEFAULTS) as paths:
projects = paths.readline().strip().split(':', 1)[-1]
templates = paths.readline().strip().split(':', 1)[-1]
self.ui.projectsFolderLineEdit.setText(projects)
self.ui.templateRootLineEdit.setText(templates)
project_selector_enabled = self.settings.value("SelectorTools/ProjectSelector/isEnabled", True, type=bool)
identifiable_only = self.settings.value("SelectorTools/ProjectSelector/identifiableOnly", True, type=bool)
self.ui.projectSelectorEnabledCheckBox.setChecked(project_selector_enabled)
self.ui.identifiableOnly.setChecked(identifiable_only)
def __init__(self, iface):
self.iface = iface
QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = uic.loadUi(ui_file, self)
self.plugin_dir = os.path.dirname(__file__)
# import pydevd; pydevd.settrace()
# Disable OK button until we are sure we have at least one project
self.ui.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
# Set up the list of templates
self.settings = QtCore.QSettings()
self.projectFileRoot = self.settings.value('SelectorTools/ProjectSelector/projectRoot', '', type=str)
if len(self.projectFileRoot) == 0 or not os.path.isdir(self.projectFileRoot):
raise ProjectSelectorException('\'%s\' is not a valid project file root folder.' % self.projectFileRoot)
# Populate the list of project types
self.ui.projectGroupComboBox.blockSignals(True)
for entry in os.listdir(self.projectFileRoot):
entryPath = os.path.join(self.projectFileRoot, entry)
if not os.path.isdir(entryPath):
continue
# Check there's a .qgs file in this path
for subEntry in os.listdir(entryPath):
if subEntry.lower().endswith('.qgs') and os.path.isfile(os.path.join(entryPath, subEntry)):
# The folder contains at least one project, add it
self.ui.projectGroupComboBox.addItem(entry)
break
self.ui.projectGroupComboBox.blockSignals(False)
defaultGroup = self.settings.value('SelectorTools/ProjectSelector/defaultProjectGroup', '', type=str)
if len(defaultGroup) > 0:
self.ui.projectGroupComboBox.setCurrentIndex( self.ui.projectGroupComboBox.findText(defaultGroup) )
if self.ui.projectGroupComboBox.count() == 1:
self.ui.projectGroupComboBox.setCurrentIndex(0)
self.ui.projectGroupComboBox.setEnabled(False)
self.onProjectGroupChanged()
def __init__(self, iface, parent=None):
super(PostNAS_CreateFulltextindex, self).__init__(parent)
self.dialog = uic.loadUi(os.path.join(os.path.dirname(__file__), 'PostNAS_FulltextindexInProgress.ui'))
def showArchOptions(self):
self.archMenu = uic.loadUi(os.path.join(self.path, ARCH_WIDGET_FILE))
self.archMenu.buttonBox.accepted.connect(self.saveArchOptions)
self.archMenu.buttonBox.rejected.connect(self.cancelArch)
self.archMenu.show()
def showOptionsDialog(self, layerList, animationFrameLength, playBackwards=False, loopAnimation=False):
"""Show the optionsDialog and populate it with settings from timeLayerManager"""
# load the form
self.optionsDialog = uic.loadUi(os.path.join(self.path, OPTIONS_WIDGET_FILE))
# restore settings from layerList:
for layer in layerList:
settings = layer_settings.getSettingsFromLayer(layer)
layer_settings.addSettingsToRow(settings, self.optionsDialog.tableWidget)
self.optionsDialog.tableWidget.resizeColumnsToContents()
# restore animation options
self.optionsDialog.spinBoxFrameLength.setValue(animationFrameLength)
self.optionsDialog.checkBoxBackwards.setChecked(playBackwards)
self.optionsDialog.checkBoxLabel.setChecked(self.showLabel)
self.optionsDialog.checkBoxDontExportEmpty.setChecked(not self.exportEmpty)
self.optionsDialog.checkBoxLoop.setChecked(loopAnimation)
self.optionsDialog.show_label_options_button.clicked.connect(self.showLabelOptions)
self.optionsDialog.checkBoxLabel.stateChanged.connect(self.showOrHideLabelOptions)
self.optionsDialog.textBrowser.setHtml(QCoreApplication.translate('TimeManager', """\
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html>
<head>
<meta name="qrichtext" content="1"/>
<style>
li.mono {
font-family: Consolas, Courier New, Courier, monospace;
}
</style>
</head>
<body>
<h1>Time Manager</h1>
<p>Time Manager filters your layers and displays only layers and features that match the specified time frame. Time Manager supports vector layers and raster layers (including WMS-T).</p>
<p>Timestamps have to be in one of the following formats:</p>
<ul>
<li class="mono">%Y-%m-%d %H:%M:%S.%f</li>
<li class="mono">%Y-%m-%d %H:%M:%S</li>
<li class="mono">%Y-%m-%d %H:%M</li>
<li class="mono">%Y-%m-%dT%H:%M:%S</li>
<li class="mono">%Y-%m-%dT%H:%M:%SZ</li>
<li class="mono">%Y-%m-%dT%H:%M</li>
<li class="mono">%Y-%m-%dT%H:%MZ</li>
<li class="mono">%Y-%m-%d</li>
<li class="mono">%Y/%m/%d %H:%M:%S.%f</li>
<li class="mono">%Y/%m/%d %H:%M:%S</li>
<li class="mono">%Y/%m/%d %H:%M</li>
<li class="mono">%Y/%m/%d</li>
<li class="mono">%H:%M:%S</li>
<li class="mono">%H:%M:%S.%f</li>
<li class="mono">%Y.%m.%d %H:%M:%S.%f</li>
<li class="mono">%Y.%m.%d %H:%M:%S</li>
<li class="mono">%Y.%m.%d %H:%M</li>
<li class="mono">%Y.%m.%d</li>
<li class="mono">%Y%m%d%H%M%SED</li>
<li>Integer timestamp in seconds after or before the epoch (1970-1-1)</li>
</ul>
<p>The layer list contains all layers managed by Time Manager.
To add a vector layer, press [Add layer].
To add a raster layer, press [Add raster].
If you want to remove a layer from the list, select it and press [Remove layer].</p>
<p>Below the layer list, you'll find the following <b>animation options</b>:</p>
<p><b>Show frame for x milliseconds</b>...
allows you to adjust for how long a frame will be visible during the animation</p>
<p><b>Play animation backwards</b>...
if checked, the animation will run in reverse direction</p>
<p><b>Display frame start time on map</b>...
if checked, displays the start time of the visible frame in the lower right corner of the map</p>
<h2>Add Layer dialog</h2>
<p>Here, you are asked to select the layer that should be added and specify the columns containing
start and (optionally) end time.</p>
<p>The <b>offset</b> option allows you to further time the appearance of features. If you specify
an offset of -1, the features will appear one second later than they would by default.</p>
<h2>Dock widget</h2>
<p>The dock was designed to attach to the bottom of the QGIS main window. It offers the following tools:</p>
<ul>
<li><img src="images/power_on.png" alt="power"/> ... On/Off switch, allows you to turn Time Manager's functionality on/off with the click of only one button</li>
<li><span class="hidden">[Settings]</span><input type="button" value="Settings"/> ... opens the Settings dialog where you can manage your spatio-temporal layers</li>
<li><span class="hidden">[Export Video]</span><input type="button" value="Export Video"/> ... exports an image series based on current settings (This button is only enabled if there are layers registered in Time Manager "Settings")</li>
<li><b>Time frame start: <span class="hidden">[2000-01-01 00:00:00]</span></b><input type="text" value="2000-01-01 00:00:00"/> ... shows the start time of the currently active frame. Allows you to precisely specify your desired analysis time.</li>
<li><b>Time frame size: </b><input type="text" value="1"/><span class="hidden">[x]</span><select><option value="days">days</option></select> ... allow you to choose the size of the time frame</li>
<li><img src="images/back.png" alt="back"/> ... go to the previous time frame</li>
<li><img src="images/forward.png" alt="forward"/> ... go to the next time frame</li>
<li><b>Slider</b> ... shows the position of current frame relative to the whole dataset and allows you to seamlessly scroll through the dataset</li>
<li><img src="images/play.png" alt="play"/> ... start an automatic animation based on your current settings</li>
</ul>
</body>
</html>"""))
# show dialog
self.showOrHideLabelOptions()
self.optionsDialog.show()
# create raster and vector dialogs
self.vectorDialog = VectorLayerDialog(self.iface, os.path.join(self.path, ADD_VECTOR_LAYER_WIDGET_FILE),
self.optionsDialog.tableWidget)
self.rasterDialog = RasterLayerDialog(self.iface, os.path.join(self.path, ADD_RASTER_LAYER_WIDGET_FILE),
self.optionsDialog.tableWidget)
# establish connections
self.optionsDialog.pushButtonAddVector.clicked.connect(self.vectorDialog.show)
self.optionsDialog.pushButtonAddRaster.clicked.connect(self.rasterDialog.show)
self.optionsDialog.pushButtonRemove.clicked.connect(self.removeLayer)
self.optionsDialog.buttonBox.accepted.connect(self.saveOptions)
def __init__(self, iface, ui_path, out_table):
self.iface = iface
self.tempLayerIndexToId = {}
self.dialog = uic.loadUi(ui_path)
self.out_table = out_table
self.addConnections()
def __init__(self):
QDialog.__init__(self)
# Set up the user interface from Designer.
self.ui = uic.loadUi(ui_file, self)
