def __init__(self, layer, env):
if not haveGdal:
sys.stderr.write(
_("Unable to load GDAL Python bindings.\n"
"WMS layers can not be displayed without the bindings.\n"))
self.layer = layer
wx.EvtHandler.__init__(self)
# thread for d.wms commands
self.thread = gThread()
self._startTime = None
self.downloading = False
self.renderedRegion = None
self.updateMap = True
self.fetched_data_cmd = None
self.tempMap = grass.tempfile()
self.dstSize = {}
self.dataFetched = Signal('RenderWMSMgr.dataFetched')
self.updateProgress = Signal('RenderWMSMgr.updateProgress')
self.renderingFailed = Signal('RenderWMSMgr.renderingFailed')
def __init__(self, layer, mapfile, maskfile):
if not haveGdal:
sys.stderr.write(_("Unable to load GDAL Python bindings.\n"\
"WMS layers can not be displayed without the bindings.\n"))
self.layer = layer
wx.EvtHandler.__init__(self)
# thread for d.wms commands
self.thread = CmdThread(self)
self.Bind(EVT_CMD_DONE, self.OnDataFetched)
self.downloading = False
self.renderedRegion = None
self.updateMap = True
self.fetched_data_cmd = None
self.cmdStdErr = GStderr(self)
self.mapfile = mapfile
self.maskfile = maskfile
self.tempMap = grass.tempfile()
self.dstSize = {}
self.Bind(EVT_CMD_OUTPUT, self.OnCmdOutput)
self.dataFetched = Signal('RenderWMSMgr.dataFetched')
self.updateProgress = Signal('RenderWMSMgr.updateProgress')
def __init__(self,
parent,
giface=None,
id=wx.ID_ANY,
title=_("Data catalog"),
name='catalog',
**kwargs):
"""Panel constructor """
self.showNotification = Signal('DataCatalog.showNotification')
self.changeMapset = Signal('DataCatalog.changeMapset')
self.changeLocation = Signal('DataCatalog.changeLocation')
self.parent = parent
self.baseTitle = title
wx.Panel.__init__(self, parent=parent, id=id, **kwargs)
self.SetName("DataCatalog")
Debug.msg(1, "DataCatalog.__init__()")
# toolbar
self.toolbar = DataCatalogToolbar(parent=self)
# tree with layers
self.tree = DataCatalogTree(self, giface=giface)
self.thread = gThread()
self._loaded = False
self.tree.showNotification.connect(self.showNotification)
self.tree.changeMapset.connect(self.changeMapset)
self.tree.changeLocation.connect(self.changeLocation)
# some layout
self._layout()
def __init__(self, parent, giface, Map, properties, tree=None,
id=wx.ID_ANY, lmgr=None,
style=wx.NO_FULL_REPAINT_ON_RESIZE, **kwargs):
BufferedMapWindow.__init__(self, parent=parent, giface=giface, Map=Map,
properties=properties,
style=style, **kwargs)
self.lmgr = lmgr
self.tree = tree
self.pdcVector = PseudoDC()
self.toolbar = self.parent.GetToolbar('vdigit')
self.digit = None # wxvdigit.IVDigit
self._digitizingInfo = False # digitizing with info
# Emitted when info about digitizing updated
# Parameter text is a string with information
# currently used only for coordinates of mouse cursor + segmnt and
# total feature length
self.digitizingInfo = Signal('VDigitWindow.digitizingInfo')
# Emitted when some info about digitizing is or will be availbale
self.digitizingInfoAvailable = Signal('VDigitWindow.digitizingInfo')
# Emitted when some info about digitizing is or will be availbale
# digitizingInfo signal is emmited only between digitizingInfoAvailable
# and digitizingInfoUnavailable signals
self.digitizingInfoUnavailable = Signal('VDigitWindow.digitizingInfo')
self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
self.mouseMoving.connect(self._mouseMovingToDigitizingInfo)
def __init__(self, parent, giface=None):
"""Data Catalog Tree constructor."""
super(DataCatalogTree, self).__init__(parent)
self._giface = giface
self._restricted = True
self._initVariablesCatalog()
self.beginDrag = Signal('DataCatalogTree.beginDrag')
self.endDrag = Signal('DataCatalogTree.endDrag')
self.startEdit = Signal('DataCatalogTree.startEdit')
self.endEdit = Signal('DataCatalogTree.endEdit')
self.Bind(
wx.EVT_TREE_BEGIN_DRAG, lambda evt: self._emitSignal(
evt.GetItem(), self.beginDrag, event=evt))
self.Bind(
wx.EVT_TREE_END_DRAG, lambda evt: self._emitSignal(
evt.GetItem(), self.endDrag, event=evt))
self.beginDrag.connect(self.OnBeginDrag)
self.endDrag.connect(self.OnEndDrag)
self.Bind(
wx.EVT_TREE_BEGIN_LABEL_EDIT, lambda evt: self._emitSignal(
evt.GetItem(), self.startEdit, event=evt))
self.Bind(
wx.EVT_TREE_END_LABEL_EDIT, lambda evt: self._emitSignal(
evt.GetItem(), self.endEdit, event=evt))
self.startEdit.connect(self.OnStartEditLabel)
self.endEdit.connect(self.OnEditLabel)
def __init__(self, lmgr):
"""Costructor is specific to the current implementation.
Uses Layer Manager object including its private attributes.
(It encapsulates existing Layer Manager so access to private members
is intention.)
"""
self.lmgr = lmgr
# Signal when some map is created or updated by a module.
# Used for adding/refreshing displayed layers.
# attributes: name: map name, ltype: map type,
# add: if map should be added to layer tree (questionable attribute)
self.mapCreated = Signal('LayerManagerGrassInterface.mapCreated')
# Signal for communicating current mapset has been switched
self.currentMapsetChanged = Signal('LayerManagerGrassInterface.currentMapsetChanged')
# Signal for communicating something in current grassdb has changed.
# Parameters:
# action: required, is one of 'new', 'rename', 'delete'
# element: required, can be one of 'grassdb', 'location', 'mapset', 'raster', 'vector' and 'raster_3d'
# grassdb: path to grass db, required
# location: location name, required
# mapset: mapset name, required when element is 'mapset', 'raster', 'vector' or 'raster_3d'
# map: map name, required when element is 'raster', 'vector' or 'raster_3d'
# newname: new name (of mapset, map), required with action='rename'
self.grassdbChanged = Signal('LayerManagerGrassInterface.grassdbChanged')
# Signal emitted to request updating of map
self.updateMap = Signal('LayerManagerGrassInterface.updateMap')
def __init__(self, giface, cmdfile=None, mapfile=None):
"""Map composition (stack of map layers and overlays)
:param cmdline: full path to the cmd file (defined by d.mon)
:param mapfile: full path to the map file (defined by d.mon)
"""
Map.__init__(self)
self._giface = giface
# environment settings
self.env = dict()
self.cmdfile = cmdfile
# list of layers for rendering added from cmd file
# TODO temporary solution, layer managment by different tools in GRASS should be resovled
self.ownedLayers = []
if mapfile:
self.mapfileCmd = mapfile
self.maskfileCmd = os.path.splitext(mapfile)[0] + '.pgm'
# generated file for g.pnmcomp output for rendering the map
self.mapfile = monFile['map'] + '.ppm'
# signal sent when d.out.file/d.to.rast appears in cmd file, attribute is cmd
self.saveToFile = Signal('DMonMap.saveToFile')
self.dToRast = Signal('DMonMap.dToRast')
# signal sent when d.what.rast/vect appears in cmd file, attribute is cmd
self.query = Signal('DMonMap.query')
def __init__(self, guiparent, giface):
self.data = {}
self.guiparent = guiparent
self.giface = giface
self.mapWin = giface.GetMapWindow()
self.goutput = GConsole(guiparent=guiparent)
self.vnet_data = VNETData(guiparent=guiparent, mapWin=self.mapWin)
self.results = {"analysis": None, "vect_map": None} #TODO more results
# this class instance manages all temporary vector maps created during life of VNETDialog
self.tmp_maps = VNETTmpVectMaps(parent=guiparent, mapWin=self.mapWin)
# initialization of History class used for saving and reading data from file
# it is used for browsing analysis results
self.history = VNETHistory(self.guiparent, self.vnet_data,
self.tmp_maps)
self.analyses = VNETAnalyses(self.vnet_data, self.RunAnDone,
self.goutput, self.tmp_maps)
self.snap_nodes = SnappingNodes(self.giface, self.vnet_data,
self.tmp_maps, self.mapWin)
self.ttbCreated = Signal('VNETManager.ttbCreated')
self.analysisDone = Signal('VNETManager.analysisDone')
self.pointsChanged = self.vnet_data.pointsChanged
self.parametersChanged = self.vnet_data.parametersChanged
self.snapping = self.snap_nodes.snapping
self.pointsChanged.connect(self.PointsChanged)
def __init__(self, mapWindow, timer):
"""Animation constructor
Signals:
animationFinished - emitted when animation finished
- attribute 'mode'
animationUpdateIndex - emitted during animation to update gui
- attributes 'index' and 'mode'
:param mapWindow: glWindow where rendering takes place
:param timer: timer for recording and replaying
"""
self.animationFinished = Signal("Animation.animationFinished")
self.animationUpdateIndex = Signal("Animation.animationUpdateIndex")
self.animationList = [] # view states
self.timer = timer
self.mapWindow = mapWindow
self.actions = {"record": self.Record, "play": self.Play}
self.formats = ["tif", "ppm"] # currently supported formats
self.mode = "record" # current mode (record, play, save)
self.paused = False # recording/replaying paused
self.currentFrame = 0 # index of current frame
self.fps = 24 # user settings # Frames per second
self.stopSaving = False # stop during saving images
self.animationSaved = False # current animation saved or not
def __init__(self, giface, mapWindow):
"""Constructs controller
:param giface: grass interface object
:param mapWindow: instance of BufferedMapWindow
"""
wx.EvtHandler.__init__(self)
self._giface = giface
self._mapWindow = mapWindow
# thread for running rasterization process
self._thread = gThread()
# name of raster map which is edited (also new one)
self._editedRaster = None
# name of optional background raster
self._backgroundRaster = None
# name of temporary raster used to backup original state
self._backupRasterName = None
# if we edit an old raster or a new one (important for setting color
# table)
self._editOldRaster = False
# type of output raster map (CELL, FCELL, DCELL)
self._mapType = None
# GraphicsSet for drawing areas, lines, points
self._areas = None
self._lines = None
self._points = None
# list of all GraphicsItems in the order of drawing
self._all = []
# if in state of drawing lin or area
self._drawing = False
# if running digitizing process in thread (to block drawing)
self._running = False
# color used to draw (should be moved to settings)
self._drawColor = wx.GREEN
# transparency used to draw (should be moved to settings)
self._drawTransparency = 100
# current selected drawing method
self._graphicsType = 'area'
# last edited cell value
self._currentCellValue = None
# last edited buffer value
self._currentWidthValue = None
# digit env
self._env = os.environ.copy()
self._oldMouseUse = None
self._oldCursor = None
# signal to add new raster to toolbar items
self.newRasterCreated = Signal('RDigitController:newRasterCreated')
# signal to add just used cell value in toolbar combo
self.newFeatureCreated = Signal('RDigitController:newFeatureCreated')
# signal to upload unique categories of background map into toolbar
# combo
self.uploadMapCategories = Signal(
'RDigitController:uploadMapCategories')
self.quitDigitizer = Signal('RDigitController:quitDigitizer')
self.showNotification = Signal('RDigitController:showNotification')
def __init__(self):
self._resolution = None
self.resolutionChanged = Signal('MapWindowProperties.resolutionChanged')
self._autoRender = None
self.autoRenderChanged = Signal('MapWindowProperties.autoRenderChanged')
self._showRegion = None
self.showRegionChanged = Signal('MapWindowProperties.showRegionChanged')
self._alignExtent = None
self.alignExtentChanged = Signal('MapWindowProperties.alignExtentChanged')
def __init__(self, mapframe, statusbar, sbManager, position=0):
self.progressShown = Signal('SbProgress.progressShown')
self.progressHidden = Signal('SbProgress.progressHidden')
SbItem.__init__(self, mapframe, statusbar, position)
self.name = 'progress'
self.sbManager = sbManager
# on-render gauge
self.widget = wx.Gauge(parent=self.statusbar, id=wx.ID_ANY,
range=0, style=wx.GA_HORIZONTAL)
self.Hide()
def __init__(self):
self.statisticsDict = {}
self.statisticsList = []
self.statisticsAdded = Signal("StatisticsData.statisticsAdded")
self.statisticsDeleted = Signal("StatisticsData.statisticsDeleted")
self.allStatisticsDeleted = Signal(
"StatisticsData.allStatisticsDeleted")
self.statisticsSet = Signal("StatisticsData.statisticsSet")
def __init__(self, parent, giface, menuModel, margin=False):
GPrompt.__init__(self,
parent=parent,
giface=giface,
menuModel=menuModel)
wx.stc.StyledTextCtrl.__init__(self, self.panel, id=wx.ID_ANY)
#
# styles
#
self.SetWrapMode(True)
self.SetUndoCollection(True)
#
# create command and map lists for autocompletion
#
self.AutoCompSetIgnoreCase(False)
#
# line margins
#
# TODO print number only from cmdlog
self.SetMarginWidth(1, 0)
self.SetMarginWidth(2, 0)
if margin:
self.SetMarginType(0, wx.stc.STC_MARGIN_NUMBER)
self.SetMarginWidth(0, 30)
else:
self.SetMarginWidth(0, 0)
#
# miscellaneous
#
self.SetViewWhiteSpace(False)
self.SetUseTabs(False)
self.UsePopUp(True)
self.SetSelBackground(True, "#FFFF00")
self.SetUseHorizontalScrollBar(True)
#
# bindings
#
self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
self.Bind(wx.EVT_CHAR, self.OnChar)
self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)
self.Bind(wx.stc.EVT_STC_AUTOCOMP_SELECTION, self.OnItemSelected)
self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemChanged)
if sys.platform != 'darwin': # unstable on Mac with wxPython 3
self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
# signal which requests showing of a notification
self.showNotification = Signal('GPromptSTC.showNotification')
# signal to notify selected command
self.commandSelected = Signal('GPromptSTC.commandSelected')
def __init__(self,
parent,
model,
showChoice=True,
showTip=False,
**kwargs):
self._showTip = showTip
self._showChoice = showChoice
self._model = model
self._results = [] # list of found nodes
self._resultIndex = -1
self._searchKeys = ['description', 'keywords', 'command']
self._oldValue = ''
self.moduleSelected = Signal('SearchModuleWidget.moduleSelected')
self.showSearchResult = Signal('SearchModuleWidget.showSearchResult')
self.showNotification = Signal('SearchModuleWidget.showNotification')
wx.Panel.__init__(self, parent=parent, id=wx.ID_ANY, **kwargs)
# self._box = wx.StaticBox(parent = self, id = wx.ID_ANY,
# label = " %s " % _("Find module - (press Enter for next match)"))
if sys.platform == 'win32':
self._search = wx.TextCtrl(parent=self,
id=wx.ID_ANY,
size=(-1, 25),
style=wx.TE_PROCESS_ENTER)
else:
self._search = wx.SearchCtrl(parent=self,
id=wx.ID_ANY,
size=(-1, 25),
style=wx.TE_PROCESS_ENTER)
self._search.SetDescriptiveText(_('Fulltext search'))
self._search.SetToolTipString(
_("Type to search in all modules. Press Enter for next match.")
)
self._search.Bind(wx.EVT_TEXT, self.OnSearchModule)
self._search.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
if self._showTip:
self._searchTip = StaticWrapText(parent=self,
id=wx.ID_ANY,
size=(-1, 35))
if self._showChoice:
self._searchChoice = wx.Choice(parent=self, id=wx.ID_ANY)
self._searchChoice.SetItems(
self._searchModule(keys=['command'], value=''))
self._searchChoice.Bind(wx.EVT_CHOICE, self.OnSelectModule)
self._layout()
def __init__(self, guiparent, giface, iclass_mapwin=None):
self.giface = giface
self.mapDisp = giface.GetMapDisplay()
if iclass_mapwin:
self.mapWin = iclass_mapwin
else:
self.mapWin = giface.GetMapWindow()
self.guiparent = guiparent
self.show_add_scatt_plot = False
self.core = Core()
self.cats_mgr = CategoriesManager(self, self.core)
self.render_mgr = PlotsRenderingManager(scatt_mgr=self,
cats_mgr=self.cats_mgr,
core=self.core)
self.thread = gThread()
self.plots = {}
self.plot_mode = None
self.pol_sel_mode = [False, None]
self.data_set = False
self.cursorPlotMove = Signal("ScattsManager.cursorPlotMove")
self.renderingStarted = self.render_mgr.renderingStarted
self.renderingFinished = self.render_mgr.renderingFinished
self.computingStarted = Signal("ScattsManager.computingStarted")
if iclass_mapwin:
self.digit_conn = IClassDigitConnection(self,
self.mapWin,
self.core.CatRastUpdater())
self.iclass_conn = IClassConnection(self,
iclass_mapwin.parent,
self.cats_mgr)
else:
self.digit_conn = IMapWinDigitConnection()
self.iclass_conn = IMapDispConnection(scatt_mgr=self,
cats_mgr=self.cats_mgr,
giface=self.giface)
self._initSettings()
self.modeSet = Signal("ScattsManager.mondeSet")
def __init__(self, model, parent, *args, **kw):
self._model = model
super(AbstractTreeViewMixin, self).__init__(parent=parent, *args, **kw)
self.selectionChanged = Signal('TreeView.selectionChanged')
self.itemActivated = Signal('TreeView.itemActivated')
self.contextMenu = Signal('TreeView.contextMenu')
self.Bind(wx.EVT_TREE_SEL_CHANGED, lambda evt:
self._emitSignal(evt.GetItem(), self.selectionChanged))
self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, lambda evt:
self._emitSignal(evt.GetItem(), self.itemActivated))
self.Bind(wx.EVT_TREE_ITEM_MENU, lambda evt:
self._emitSignal(evt.GetItem(), self.contextMenu))
def __init__(self, giface, cmdfile=None, mapfile=None):
"""Map composition (stack of map layers and overlays)
:param cmdline: full path to the cmd file (defined by d.mon)
:param mapfile: full path to the map file (defined by d.mon)
"""
Map.__init__(self)
self._giface = giface
# environment settings
self.env = dict()
self.cmdfile = cmdfile
# list of layers for rendering added from cmd file
# TODO temporary solution, layer management by different tools in GRASS
# should be resolved
self.ownedLayers = []
self.oldOverlays = []
if mapfile:
self.mapfileCmd = mapfile
self.maskfileCmd = os.path.splitext(mapfile)[0] + '.pgm'
# generated file for g.pnmcomp output for rendering the map
self.mapfile = monFile['map']
if os.path.splitext(self.mapfile)[1] != '.ppm':
self.mapfile += '.ppm'
# signal sent when d.out.file/d.to.rast appears in cmd file, attribute
# is cmd
self.saveToFile = Signal('DMonMap.saveToFile')
self.dToRast = Signal('DMonMap.dToRast')
# signal sent when d.what.rast/vect appears in cmd file, attribute is
# cmd
self.query = Signal('DMonMap.query')
self.renderMgr = RenderMapMgr(self)
# update legend file variable with the one d.mon uses
with open(monFile['env'], 'r') as f:
lines = f.readlines()
for line in lines:
if 'GRASS_LEGEND_FILE' in line:
legfile = line.split('=', 1)[1].strip()
self.renderMgr.UpdateRenderEnv(
{'GRASS_LEGEND_FILE': legfile})
break
def __init__(self, parent, settingsFile):
"""
Signals:
settingsChanged - called when users changes setting
- attribute 'data' with chosen setting data
settingsSaving - called when settings are saving
- attribute 'name' with chosen settings name
settingsLoaded - called when settings are loaded
- attribute 'settings' is dict with loaded settings
{nameofsetting : settingdata, ....}
:param settingsFile: path to file, where settings will be saved and loaded from
"""
self.settingsFile = settingsFile
self.settingsChanged = Signal('ManageSettingsWidget.settingsChanged')
self.settingsSaving = Signal('ManageSettingsWidget.settingsSaving')
self.settingsLoaded = Signal('ManageSettingsWidget.settingsLoaded')
wx.Panel.__init__(self, parent=parent, id=wx.ID_ANY)
self.settingsBox = wx.StaticBox(parent=self,
id=wx.ID_ANY,
label=" %s " % _("Settings"))
self.settingsChoice = wx.Choice(parent=self, id=wx.ID_ANY)
self.settingsChoice.Bind(wx.EVT_CHOICE, self.OnSettingsChanged)
self.btnSettingsSave = wx.Button(parent=self, id=wx.ID_SAVE)
self.btnSettingsSave.Bind(wx.EVT_BUTTON, self.OnSettingsSave)
self.btnSettingsSave.SetToolTipString(_("Save current settings"))
self.btnSettingsDel = wx.Button(parent=self, id=wx.ID_REMOVE)
self.btnSettingsDel.Bind(wx.EVT_BUTTON, self.OnSettingsDelete)
self.btnSettingsSave.SetToolTipString(
_("Delete currently selected settings"))
# escaping with '$' character - index in self.esc_chars
self.e_char_i = 0
self.esc_chars = ['$', ';']
self._settings = self._loadSettings(
) # -> self.settingsChoice.SetItems()
self.settingsLoaded.emit(settings=self._settings)
self.data_to_save = []
self._layout()
self.SetSizer(self.settingsSizer)
self.settingsSizer.Fit(self)
def __init__(self, scatt_mgr, core):
self.core = core
self.scatt_mgr = scatt_mgr
self.cats = {}
self.cats_ids = []
self.sel_cat_id = None
self.exportRaster = None
self.initialized = Signal('CategoriesManager.initialized')
self.setCategoryAttrs = Signal('CategoriesManager.setCategoryAttrs')
self.deletedCategory = Signal('CategoriesManager.deletedCategory')
self.addedCategory = Signal('CategoriesManager.addedCategory')
def __init__(self, scatt_mgr, cats_mgr, core):
self.scatt_mgr = scatt_mgr
self.cats_mgr = cats_mgr
self.core = core
self.scatts_dt, self.scatt_conds_dt = self.core.GetScattsData()
self.runningProcesses = 0
self.data_to_render = {}
self.render_queue = []
self.cat_ids = []
self.cat_cond_ids = []
self.renderingStarted = Signal("ScattsManager.renderingStarted")
self.renderingFinished = Signal("ScattsManager.renderingFinished")
def __init__(self, lmgr):
"""Costructor is specific to the current implementation.
Uses Layer Manager object including its private attributes.
(It encapsulates existing Layer Manager so access to private members
is intention.)
"""
self.lmgr = lmgr
# Signal when some map is created or updated by a module.
# attributes: name: map name, ltype: map type,
# add: if map should be added to layer tree (questionable attribute)
self.mapCreated = Signal('LayerManagerGrassInterface.mapCreated')
# Signal emitted to request updating of map
self.updateMap = Signal('LayerManagerGrassInterface.updateMap')
def __init__(self, app_name, parent_menu, pos, history_len=10):
self._history_len = history_len
self._parent_menu = parent_menu
self._pos = pos
self.file_requested = Signal("RecentFilesMenu.FileRequested")
self._filehistory = wx.FileHistory(maxFiles=history_len)
# Recent files path stored in GRASS GIS config dir in the
# .recent_files file in the group by application name
self._config = wx.FileConfig(
style=wx.CONFIG_USE_LOCAL_FILE,
localFilename=os.path.join(
utils.GetSettingsPath(),
self.recent_files,
),
)
self._config.SetPath(strPath=app_name)
self._filehistory.Load(self._config)
self.RemoveNonExistentFiles()
self.recent = wx.Menu()
self._filehistory.UseMenu(self.recent)
self._filehistory.AddFilesToMenu()
# Show recent files menu if count of items in menu > 0
if self._filehistory.GetCount() > 0:
self._insertMenu()
def __init__(self, parent, giface, menuModel):
self.parent = parent # GConsole
self.panel = self.parent.GetPanel()
self.promptRunCmd = Signal('GPrompt.promptRunCmd')
# probably only subclasses need this
self._menuModel = menuModel
self.mapList = self._getListOfMaps()
self.mapsetList = utils.ListOfMapsets()
# auto complete items
self.autoCompList = list()
self.autoCompFilter = None
# command description (gtask.grassTask)
self.cmdDesc = None
self._loadHistory()
if giface:
giface.currentMapsetChanged.connect(self._loadHistory)
# list of traced commands
self.commands = list()
def __init__(self, giface, mapWindow):
AnalysisControllerBase.__init__(self,
giface=giface,
mapWindow=mapWindow)
self.transectChanged = Signal('ProfileController.transectChanged')
self._graphicsType = 'line'
def __init__(self):
self._resolution = None
self.resolutionChanged = Signal(
"MapWindowProperties.resolutionChanged")
self._autoRender = None
self.autoRenderChanged = Signal(
"MapWindowProperties.autoRenderChanged")
self._showRegion = None
self.showRegionChanged = Signal(
"MapWindowProperties.showRegionChanged")
self._alignExtent = None
self.alignExtentChanged = Signal(
"MapWindowProperties.alignExtentChanged")
self._useDefinedProjection = False
self.useDefinedProjectionChanged = Signal(
"MapWindowProperties.useDefinedProjectionChanged")
def __init__(self, parent, symbolPath):
"""Panel constructor
Signal symbolSelectionChanged - symbol selected
- attribute 'name' (symbol name)
- attribute 'doubleClick' (underlying cause)
:param parent: parent (gui_core::dialog::SymbolDialog)
:param symbolPath: absolute path to symbol
"""
self.symbolSelectionChanged = Signal(
'SingleSymbolPanel.symbolSelectionChanged')
wx.Panel.__init__(self, parent, id=wx.ID_ANY, style=wx.BORDER_RAISED)
self.SetName(os.path.splitext(os.path.basename(symbolPath))[0])
self.sBmp = wx.StaticBitmap(self, wx.ID_ANY, wx.Bitmap(symbolPath))
self.selected = False
self.selectColor = wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHT)
self.deselectColor = wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW)
sizer = wx.BoxSizer()
sizer.Add(item=self.sBmp,
proportion=0,
flag=wx.ALL | wx.ALIGN_CENTER,
border=5)
self.SetBackgroundColour(self.deselectColor)
self.SetMinSize(self.GetBestSize())
self.SetSizerAndFit(sizer)
# binding to both (staticBitmap, Panel) necessary
self.sBmp.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
self.sBmp.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
def __init__(self, parent, vectmap, id=wx.ID_ANY, layer=1, column=None):
self.column = column
# set dialog title
title = _("GRASS SQL Builder (%(type)s) - <%(map)s>") % \
{ 'type' : "UPDATE", 'map' : vectmap }
modeChoices = [
_("Column to set (SET clause)"),
_("Constraint for query (WHERE clause)"),
_("Calculate column value to set")
]
SQLBuilder.__init__(self,
parent,
title,
vectmap,
id=wx.ID_ANY,
modeChoices=modeChoices,
layer=layer)
# signals
self.sqlApplied = Signal("SQLBuilder.sqlApplied")
if parent: # TODO: replace by giface
self.sqlApplied.connect(parent.Update)
def __init__(self, gisrc = None):
"""Map composition (stack of map layers and overlays)
:param gisrc: alternative gisrc (used eg. by georectifier)
"""
# region/extent settigns
self.wind = dict() # WIND settings (wind file)
self.region = dict() # region settings (g.region)
self.width = 640 # map width
self.height = 480 # map height
# list of layers
self.layers = list() # stack of available GRASS layer
self.overlays = list() # stack of available overlays
self.ovlookup = dict() # lookup dictionary for overlay items and overlays
# path to external gisrc
self.gisrc = gisrc
# generated file for g.pnmcomp output for rendering the map
self.mapfile = grass.tempfile(create = False) + '.ppm'
# setting some initial env. variables
if not self.GetWindow():
sys.stderr.write(_("Trying to recover from default region..."))
RunCommand('g.region', flags='d')
# info to report progress
self.progressInfo = None
# GRASS environment variable (for rendering)
self.default_env = {"GRASS_BACKGROUNDCOLOR" : "000000",
"GRASS_PNG_COMPRESSION" : "0",
"GRASS_TRUECOLOR" : "TRUE",
"GRASS_TRANSPARENT" : "TRUE"
}
# projection info
self.projinfo = self._projInfo()
# is some layer being downloaded?
self.downloading = False
self.layerChanged = Signal('Map.layerChanged')
self.updateProgress = Signal('Map.updateProgress')
def __init__(
self,
parent,
giface=None,
id=wx.ID_ANY,
title=_("Data catalog"),
name="catalog",
**kwargs,
):
"""Panel constructor"""
self.showNotification = Signal("DataCatalog.showNotification")
self.parent = parent
self.baseTitle = title
self.giface = giface
self._startLoadingTime = 0
wx.Panel.__init__(self, parent=parent, id=id, **kwargs)
self.SetName("DataCatalog")
Debug.msg(1, "DataCatalog.__init__()")
# toolbar
self.toolbar = DataCatalogToolbar(parent=self)
# tree with layers
self.tree = DataCatalogTree(self, giface=giface)
self.tree.showNotification.connect(self.showNotification)
# infobar for data catalog
delay = 2000
self.infoBar = InfoBar(self)
self.giface.currentMapsetChanged.connect(self.dismissInfobar)
# infobar manager for data catalog
self.infoManager = DataCatalogInfoManager(infobar=self.infoBar,
giface=self.giface)
self.tree.showImportDataInfo.connect(self.showImportDataInfo)
self.tree.loadingDone.connect(self._loadingDone)
# some layout
self._layout()
# show infobar for first-time user if applicable
if is_first_time_user():
# show data structure infobar for first-time user
wx.CallLater(delay, self.showDataStructureInfo)
# show infobar if last used mapset is not usable
if is_fallback_session():
# get reason why last used mapset is not usable
last_mapset_path = gisenv()["LAST_MAPSET_PATH"]
self.reason_id = get_reason_id_mapset_not_usable(last_mapset_path)
if self.reason_id in ("non-existent", "invalid",
"different-owner"):
# show non-standard situation info
wx.CallLater(delay, self.showFallbackSessionInfo)
elif self.reason_id == "locked":
# show info allowing to switch to locked mapset
wx.CallLater(delay, self.showLockedMapsetInfo)