def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
self.tt = 0
self.connected = False
self.set('speed', None)
self.set('metersPerSecSpeed', None)
self.set('bearing', None)
self.set('elevation', None)
self.status = "Unknown"
self._enabled = False
self.provider = None
self.startSignal = Signal()
self.stopSignal = Signal()
self.positionUpdate = Signal()
# check if the device handles location by itself
if not self.modrana.dmod.handles_location:
method = self.modrana.dmod.location_type
if method == "qt_mobility":
self.log.info("using Qt Mobility")
from . import qt_mobility
self.provider = qt_mobility.QtMobility(self)
elif method == "gpsd": # GPSD
self.log.info("using GPSD")
from . import gps_daemon
self.provider = gps_daemon.GPSD(self)
# watch if debugging needs to be enabled
self.modrana.watch("gpsDebugEnabled", self._debugCB, runNow=True)
def __init__(self, view):
#
QtModule.QGraphicsScene.__init__(self)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.startNodeConnector = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsObject, QtCore.QPointF )
self.traceNodeConnector = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsObject, QtCore.QPointF )
self.endNodeConnector = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsObject, QtCore.QPointF )
self.startNodeLink = Signal(
) #( QtModule.QGraphicsObject ) # QtModule.QGraphicsItem
self.traceNodeLink = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsObject, QtCore.QPointF )
self.endNodeLink = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsObject, QtCore.QPointF )
self.onGfxNodeRemoved = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsObject )
self.onGfxLinkRemoved = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsObject )
self.nodeUpdated = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsItem )
self.gfxNodeParamChanged = Signal(
) #QtCore.pyqtSignal ( QtModule.QGraphicsItem, QtCore.QObject )
#
self.view = view
self.connectSignals()
def __init__(self):
self._objs = {}
self._objs_lock = threading.RLock()
self._global_index = 0
self._errors = {}
self._main_thread = threading.currentThread()
# signals
self.thread_status_changed = Signal()
self.thread_progress_changed = Signal()
self.thread_removed = Signal()
def __init__(self):
self._objs = {}
self._objs_lock = threading.RLock()
self._globalIndex = 0
self._errors = {}
self._main_thread = threading.currentThread()
# signals
self.threadStatusChanged = Signal()
self.threadProgressChanged = Signal()
self.threadRemoved = Signal()
def __init__(self, rendererPreset):
#
QtModule.QDialog.__init__(self)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.presetChanged = Signal()
self.savePreset = Signal()
#
self.rendererPreset = rendererPreset
self.labelsReady = False
self.buildGui()
def __init__(self,
parent,
gfxNode=None,
isInput=True,
showConnected=False):
#
QtModule.QWidget.__init__(self, parent)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.sectionResized = Signal()
#
self.nodeParamView = parent
self.gfxNode = gfxNode
self.isInput = isInput
self.showConnected = showConnected
self.labelWidth = UI.CHECK_WIDTH + UI.LABEL_WIDTH + 6 + 20
self.stackedWidget = None
self.nodeParamList = None
self.buildGui()
self.updateGui()
self.connectSignals()
def __init__(self, parent):
#
QtModule.QGraphicsView.__init__(self, parent)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.mouseDoubleClickSignal = Signal()
#
self.state = 'idle'
self.panStartPos = None
self.pixmap = None
# set scene
scene = QtModule.QGraphicsScene(self)
scene.setSceneRect(0, 0, 256, 256)
#scene.setItemIndexMethod ( QtGui.QGraphicsScene.NoIndex )
self.setScene(scene)
# qt graphics stuff
#self.setCacheMode ( QtGui.QGraphicsView.CacheBackground )
self.setRenderHint(QtGui.QPainter.Antialiasing)
self.setTransformationAnchor(QtModule.QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QtModule.QGraphicsView.AnchorViewCenter)
self.setDragMode(QtModule.QGraphicsView.RubberBandDrag)
self.setMouseTracking(False)
self.BgBrush = QtGui.QBrush(QtGui.QColor(128, 128, 128))
def __init__(self, db, data):
super(MessageStream, self).__init__(db, data)
self._messages = []
self._input_group = None
self._filter_group = None
if self.data.input_group:
self._input_group = InputGroup(self.db, self.data.input_group)
else: # create a new input group
self._input_group = InputGroup.new(self.db)
self.data.input_group = self._input_group.data
if self.data.filter_group:
self._filter_group = group.FilterGroup(self.db,
self.data.filter_group)
else: # create a new filter group
self._filter_group = group.FilterGroup.new(self.db)
self.data.filter_group = self._filter_group.data
# get initial messages
initial_messages = self.inputs.messages
self._messages = self.filters.filter_messages(initial_messages)
self.refresh_done = Signal()
def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
self._go_to_initial_state()
# how long the last routing lookup took in seconds
self._route_lookup_duration = 0
self._once = True
self._entry = None
# tracks the state of the onscreen routing menu
self._osd_menu_state = None
self.set('startPos', None)
self.set('endPos', None)
self._directions_filter_rules = []
self._directions_filter_rules_loaded = False
self._addressLookupLock = threading.Lock()
self._startLookup = False
self._destinationLookup = False
# offline routing provider
self._offline_routing_provider = None
# signals
self.routing_done = Signal()
def __init__(self, parent):
#
QtModule.QWidget.__init__(self, parent)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.selectionChangedSignal = Signal()
self.addItem = Signal()
self.removeItem = Signal()
self.renameItem = Signal()
#
self.saved_text = ''
self.approvedNewName = ''
self.buildGui()
def __init__(self, parent):
#
QtModule.QWidget.__init__(self, parent)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.changeParamName = Signal()
self.changeParamLabel = Signal()
self.changeParamIsShader = Signal()
self.changeParamType = Signal()
self.changeParamDetail = Signal()
self.changeParamProvider = Signal()
self.changeParamSubtype = Signal()
self.changeParamRange = Signal()
self.changeParamValue = Signal()
self.changeParamDefValue = Signal()
#
self.param = None
self.param_default = None
self.paramWidgets = {
'string': StringWidget,
'image': StringWidget,
'rib': StringWidget,
'surface': StringWidget,
'displacement': StringWidget,
'light': StringWidget,
'volume': StringWidget,
'float': FloatWidget,
'int': IntWidget,
'color': ColorWidget,
'normal': NormalWidget,
'transform': PointWidget,
'point': PointWidget,
'vector': VectorWidget,
'matrix': MatrixWidget,
'text': TextWidget,
'control': ControlWidget,
'shader': StringWidget,
'geom': StringWidget
}
self.buildGui()
def __init__(self, db, data):
super(StreamManager, self).__init__(db, data)
self._lock = RLock()
self._streams_loaded = False
self._stream_list = []
self._stream_dict = {}
self.stream_list_changed = Signal()
account_module.account_manager.account_added.connect(
self._new_account_added_cb)
def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
# initial colors
self.navigationBoxBackground = (0, 0, 1, 0.3) # very transparent blue
self.navigationBoxText = (1, 1, 1, 1) # non-transparent white
self._tbt_worker_lock = RLock()
self._tbt_worker_enabled = False
self._go_to_initial_state()
self._automatic_reroute_counter = 0 # counts consecutive automatic reroutes
self._last_automatic_reroute_timestamp = time.time()
# reroute even though the route was not yet reached (for special cases)
self._override_route_reached = False
# signals
self.navigation_started = Signal()
self.navigation_stopped = Signal()
self.destination_reached = Signal()
self.rerouting_triggered = Signal()
self.current_step_changed = Signal()
def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
self._layers = {}
self._groups = {}
self._tree = {}
# TODO: actually support runtime layer reconfiguration
# and use this signal
self.layersChanged = Signal()
# parse the config file
self._parseConfig()
def buildGui(self):
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.clicked = Signal()
self.ui = Ui_ColorWidget_field()
self.ui.setupUi(self)
def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
self.notificationText = ""
self.timeout = 5000
self.position = 'middle'
self.expirationTimestamp = time.time()
self.draw = False
self.redrawn = None
self.wipOverlayEnabled = Signal()
self._showWorkInProgressOverlay = False
self.workStartTimestamp = None
self._wipOverlayText = ""
# this indicates if the notification about
# background processing should be shown
self._tasks = {}
self._tasksLock = threading.RLock()
## for WiP overlay testing
#self._tasks = {
# "foo" : ("foo", None),
# "bar" : ("bar", None),
# "baz" : ("baz", None)
#}
# key is an unique task name (unique for each instance of a task)
# and value is a (status, progress) tuple
self.tasksChanged = Signal()
# connect thread manager signals to task status changes
threadMgr.threadStatusChanged.connect(self.setTaskStatus)
threadMgr.threadProgressChanged.connect(self.setTaskProgress)
threadMgr.threadRemoved.connect(self.removeTask)
# also with GTK GUI, assure screen is redrawn properly
# when WiP overlay changes
if gs.GUIString == "GTK":
self.wipOverlayEnabled.connect(self._doRefresh)
self.tasksChanged.connect(self._doRefresh)
# we handle notification only with the GTK GUI and when the device module does not
# support showing them
if not self.modrana.dmod.hasNotificationSupport():
self.modrana.notificationTriggered.connect(self._startCustomNotificationCB)
def __init__(self, parent):
#
QtModule.QWidget.__init__(self, parent)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.setActiveNodeList = Signal()
self.addNode = Signal()
#
self.nodesLib = ''
self.nodesDir = ''
# This is always the same
self.ui = Ui_nodeList()
self.ui.setupUi(self)
self.ui.treeView.setDragEnabled(True)
#self.ui.treeView.setRootIsDecorated( True )
self.connectSignals()
self.updateGui()
def __init__(self):
#
QtModule.QWidget.__init__(self)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.nodeParamChangedSignal = Signal()
self.nodeLabelChangedSignal = Signal()
#
self.gfxNode = None
self.inputParamListTab = None
self.outputParamListTab = None
self.showConnected = False
self.buildGui()
self.updateGui()
self.connectSignals()
def __init__(self, main_db):
super(AccountManager, self).__init__()
self._accounts = {}
self._main_db = main_db
self.account_added = Signal()
# load stored accounts (if any)
account_data = self._main_db.filter(TwitterAccountData, {})
for data in account_data:
self._accounts[data.username] = TwitterAccount(main_db, data)
def buildGui(self):
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.clicked = Signal()
#
if self.param.isArray():
self.ui = Ui_ColorWidget_array()
else:
self.ui = Ui_ColorWidget_field()
self.ui.setupUi(self)
def __init__(self, name=None):
if name is None:
self._name = _getBatchPoolName()
else:
self._name = name
self._batch = set()
self._doneCount = 0
self._running = False
self._shutdown = False
self._mutex = threading.RLock()
self._loaderName = None
self._pool = None
self.batchDone = Signal()
def __init__(self, parent, value=None, idx=None):
#
QtModule.QWidget.__init__(self, parent)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.clicked = Signal()
#
#print ( '>>> ColorField.init' )
self.value = value
self.idx = idx
self.buildGui()
def __init__(self, parent, editNode=None):
#
QtModule.QWidget.__init__(self, parent)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.changeNodeLabel = Signal()
#
self.editNode = editNode
#self.debugPrint()
self.buildGui()
self.setNode(editNode)
def __init__(self, param, gfxNode, ignoreSubtype=False):
#
QtModule.QWidget.__init__(self)
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.nodeParamRemoved = Signal()
#
self.param = param
self.gfxNode = gfxNode
self.ignoreSubtype = ignoreSubtype # if widget is used in NodeEditor, then ignoreSubtype = True
self.buildGeneralGui()
self.buildGui()
self.ui.updateGui(self.param.value)
def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
self.images = [{}, {}] # the first dict contains normal image data, the second contains special tiles
self.imagesLock = threading.RLock()
# we need to limit the size of the tile cache to avoid a memory leak
memoryTileCacheSize = int(self.get("memoryTileCacheSize", constants.DEFAULT_MEMORY_TILE_CACHE_SIZE))
self.log.info("in memory tile cache size: %d", memoryTileCacheSize)
self.maxImagesInMemory = memoryTileCacheSize
self.imagesTrimmingAmount = constants.DEFAULT_MEMORY_TILE_CACHE_TRIM_SIZE
# how many tiles to remove once the maximum is reached
# so that trim does not run always run after adding a tile
# TODO: analyse memory usage,
# set appropriate value,
# platform dependent value,
# user configurable
self.tileSide = 256 # by default, the tiles are squares, side=256
self.scalingInfo = (1, 15, 256)
self.downloadRequestTimeout = 30 # in seconds
specialTiles = [
('tileDownloading', 'themes/default/tile_downloading.png'),
('tileDownloadFailed', 'themes/default/tile_download_failed.png'),
('tileLoading', 'themes/default/tile_loading.png'),
('tileWaitingForDownloadSlot', 'themes/default/tile_waiting_for_download_slot.png'),
('tileNetworkError', 'themes/default/tile_network_error.png')
]
self.mapViewModule = None
self._mapLayersModule = None
# cache the map folder path
self.mapFolderPath = self.modrana.paths.map_folder_path
self.log.info("map folder path: %s" % self.mapFolderPath)
self._storeTiles = None
self.connPools = {} # connection pool dictionary
self.cacheImageSurfaces = False # only GTK GUI used this
self._filterTile = self._nop
self._tileDownloaded = Signal()
self._dlRequestQueue = Queue()
self._downloader = None
def __init__(self, xml_param=None, isRibParam=False):
#
super(NodeParam, self).__init__()
#
# Define signals for PyQt5
#
if usePySide or usePyQt5:
#
self.paramChangedSignal = Signal()
self.id = None
self.name = None
self.label = None
self.type = None
self.help = None # short description
self.default = None
self.value = None
self.shaderParam = False
self.isRibParam = isRibParam
self.display = True
self.enabled = True
self.removable = False
# extra parameter description
self.detail = '' # variable, uniform
self.provider = '' # primitive, connection, constant, variable, expression
# ui decorative parameters
self.subtype = ''
self.range = ''
self.space = None # actual for color, point, vector, normal, matrix
self.spaceDef = None # default value space
self.arraySize = None # otherwise, it should be a list of values ( or empty list )
self.defaultArray = []
self.valueArray = []
#self.spaceArray = []
#self.spaceDefArray = []
if xml_param != None: self.parseFromXML(xml_param)
def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
self.loggingEnabled = False
self.loggingPaused = False
self.loggingStartTimestamp = 0
self.lastUpdateTimestamp = None
self.lastCoords = None
self.logName = None #name of the current log
self.logFilename = None #name of the current log
self.logPath = None #path to the current log
self.currentLogGPX = None
self.currentTempLog = []
# primary and secondary AOWay objects for
# persistent log storage during logging
self.log1 = None
self.log2 = None
# timer ids
self.updateLogTimerId = None
self.saveLogTimerId = None
# signals
self.tracklogUpdated = Signal()
# statistics
self.maxSpeed = 0
self.avg1 = 0
self.avg2 = 0
self.avgSpeed = 0
self.distance = 0
self.toolsMenuDone = False
self.category = 'logs'
# trace
self.traceColor = 'blue'
self.lastTracePoint = None
self.traceIndex = 0
self.pxpyIndex = deque()
self.lastX = 0
self.lastY = 0
def __init__ ( self, xml_node = None, nodenet = None ) :
#
QtCore.QObject.__init__ ( self )
#
# Define signals for PyQt5
#
if usePySide or usePyQt5 :
#
self.nodeUpdated = Signal () # QtCore.pyqtSignal ( [QtCore.QObject] )
self.nodeParamsUpdated = Signal () #QtCore.pyqtSignal ( [QtCore.QObject] )
#
self.id = None
self.name = None
self.label = None
self.type = None
self.version = None
self.format = None
self.parent = None
self.dirty = False
self.author = None
self.help = None
self.icon = None
self.master = None
self.code = None # Node code (RSL, RIB, ... )
self.control_code = None # python code executed before node computation
self.computed_code = None # code collected after compute on all connected nodes
self.event_code = {}
#self.event_code [ 'ParamLabelRenamed' ] = None
#self.event_code [ 'ParamAdded' ] = None
#self.event_code [ 'ParamRemoved' ] = None
self.display = True
self.computedInputParams = None
self.computedOutputParams = None
self.computedLocalParams = None
self.computedIncludes = None
self.computedLocals = None
self.computedCode = None
#self.previewCode = None
self.inputParams = []
self.outputParams = []
self.internals = []
self.includes = []
self.inputLinks = {}
self.outputLinks = {}
self.childs = set()
self.nodenet = nodenet
# position from GfxNode
self.offset = ( 0, 0 )
if xml_node != None :
self.parseFromXML ( xml_node )
def __init__(self):
singleton.modrana = self
self.timing = []
self.addCustomTime("modRana start", startTimestamp)
self.addCustomTime("imports done", importsDoneTimestamp)
# constants & variable initialization
self.dmod = None # device specific module
self.gui = None
self.GUIString = ""
self.optLoadingOK = None
self.d = {} # persistent dictionary of data
self.m = {} # dictionary of loaded modules
self.watches = {} # List of data change watches
self.maxWatchId = 0
self.initInfo = {
'modrana': self,
'device': None, # TODO: do this directly
'name': ""
}
# signals
self.notificationTriggered = Signal()
self.shutdown_signal = Signal()
self.mapRotationAngle = 0 # in radians
self.notMovingSpeed = 1 # in m/s
# per mode options
# NOTE: this variable is automatically saved by the
# options module
self.keyModifiers = {}
# initialize threading
threads.initThreading()
# start timing modRana launch
self.addTime("GUI creation")
# add the startup handling core module
self.startup = startup.Startup(self)
self.args = self.startup.getArgs()
# handle any early tasks specified from CLI
self.startup.handleEarlyTasks()
# early CLI tasks might need a "silent" modRana
# so the startup announcement is here
log.info(" == modRana Starting == ")
# load the version string (needs to be done here
# as PWD might change after the paths module is
# imported, for example when running
# with the Qt 5 GUI)
paths.load_version_string()
version = paths.VERSION_STRING
if version is None:
version = "unknown version"
log.info(" %s" % version)
log.info(" Python %s" % platform.python_version())
os_release = self._get_os_release()
if os_release:
log.info(" %s", os_release)
# load the device module now as it might override
# the default profile directory, so it needs to be
# before ve init the core paths module
self._load_device_module()
# initialize the paths handling core module
self.paths = paths.Paths(self)
# add the configs handling core module
self.configs = configs.Configs(configs_dir=self.paths.profile_path)
# load persistent options
self.optLoadingOK = self._load_options()
self._options_loaded()
# check if upgrade took place
if self.optLoadingOK:
savedVersionString = self.get('modRanaVersionString', "")
versionStringFromFile = paths.VERSION_STRING
if savedVersionString != versionStringFromFile:
log.info("possible upgrade detected")
self._post_upgrade_check()
# save current version string
self.set('modRanaVersionString', paths.VERSION_STRING)
# load all configuration files
self.configs.load_all()
# start loading other modules
# handle tasks that require the device
# module but not GUI
self.startup.handle_non_gui_tasks()
# then the GUI module
self._load_gui_module()
# and all other modules
self._load_modules()
# startup done, log some statistics
self._startup_done()
def __init__(self, *args, **kwargs):
RanaModule.__init__(self, *args, **kwargs)
self.internetConnectivityChanged = Signal()
