class PictureWrapper(QtCore.QObject):
def __init__(self, picture):
QtCore.QObject.__init__(self)
self._picture = picture
def _key(self):
return str(self._picture.key)
def _small(self):
return str(self._picture.small)
def _big(self):
return str(self._picture.big)
def _original(self):
return str(self._picture.original)
def _detail(self):
return str(self._picture.detail)
changed = QtCore.Signal()
key = QtCore.Property(unicode, _key, notify=changed)
small = QtCore.Property(unicode, _small, notify=changed)
big = QtCore.Property(unicode, _big, notify=changed)
original = QtCore.Property(unicode, _original, notify=changed)
detail = QtCore.Property(unicode, _detail, notify=changed)
class MenuItem(QtCore.QObject):
def __init__(self, label, typeItem, listMenuItem):
self._label = label
self._type = typeItem
self._listMenuItem = listMenuItem
def getLabel(self):
return self._label
def getType(self):
return self._type
def getListMenuItem(self):
return self._listMenuItem
def setLabel(self, label):
self._label = label
def setType(self, itemTypeObject):
self._type = itemTypeObject
def setListMenuItem(self, listMenuItem):
self._listMenuItem = listMenuItem
changed = QtCore.Signal()
label = QtCore.Property(unicode, getLabel, setLabel, notify=changed)
itemType = QtCore.Property(QtCore.QObject,
getType,
setType,
notify=changed)
listMenuItem = QtCore.Property(QtCore.QObject,
getListMenuItem,
setListMenuItem,
notify=changed)
class FilechooserItem(QtCore.QObject):
def __init__(self, _caption, _path, _directory):
QtCore.QObject.__init__(self)
if isinstance(_caption, str):
_caption = _caption.decode('utf-8')
if isinstance(_path, str):
_path = _path.decode('utf-8')
self._caption = _caption
self._path = _path
self._directory = _directory
changed = QtCore.Signal()
def _get_caption(self):
return self._caption
def _get_path(self):
return self._path
def _get_directory(self):
return self._directory
caption = QtCore.Property(unicode, _get_caption, notify=changed)
path = QtCore.Property(unicode, _get_path, notify=changed)
directory = QtCore.Property(bool, _get_directory, notify=changed)
class SpecialWrapper(QtCore.QObject):
def __init__(self, special):
QtCore.QObject.__init__(self)
self._special = special
def _description(self):
return self._special.description
def _name(self):
return self._special.name
def _small(self):
return self._special.image["small"]
def _detail(self):
return self._special.detail
def _big(self):
return self._special.image["big"]
changed = QtCore.Signal()
small = QtCore.Property(unicode, _small, notify=changed)
name = QtCore.Property(unicode, _name, notify=changed)
description = QtCore.Property(unicode, _description, notify=changed)
detail = QtCore.Property(unicode, _detail, notify=changed)
big = QtCore.Property(unicode, _big, notify=changed)
class ListItem(QtCore.QObject):
def __init__(self, data, children=None):
if not children: children = []
QtCore.QObject.__init__(self)
self._data = data
self._children = children
changed = QtCore.Signal()
childrenChanged = QtCore.Signal()
def _getData(self):
return self._data
def _getChildCount(self):
return len(self._children)
@QtCore.Slot(int, result=QtCore.QObject)
def _getChild(self, index):
try:
return self._children[index]
except IndexError:
# index out of bounds
return None
data = QtCore.Property(QtCore.QObject, _getData, notify=changed)
childrenCount = QtCore.Property(QtCore.QObject,
_getChildCount,
notify=childrenChanged)
class PlaylistItem(QtCore.QObject):
def __init__(self, _id, _caption, _bookmark, _position):
QtCore.QObject.__init__(self)
if isinstance(_caption, str):
_caption = _caption.decode('utf-8')
self._caption = _caption
self._id = _id
self._bookmark = _bookmark
self._position = _position
changed = QtCore.Signal()
def _get_id(self):
return self._id
def _get_caption(self):
return self._caption
def _get_bookmark(self):
return self._bookmark
def _get_position(self):
return self._position
item_id = QtCore.Property(str, _get_id, notify=changed)
caption = QtCore.Property(unicode, _get_caption, notify=changed)
bookmark_id = QtCore.Property(str, _get_bookmark, notify=changed)
position = QtCore.Property(str, _get_position, notify=changed)
class DepartureListModel(BaseListModel):
_station = None
_fetching = False
changed = QtCore.Signal()
roles = {
'title': lambda i: i.title,
'subtitle': lambda i: i.subtitle,
'destination': lambda i: i.get_destination(),
'status': lambda i: i.get_status(),
'time': lambda i: i.get_time()
}
def _empty_items(self):
self.beginResetModel()
self._station._station.departures = None
self.items = []
self.endResetModel()
def _get_station(self):
return self._station
def _set_station(self, value):
self._station = value
self.fetch_departures()
station = QtCore.Property(StationWrapper,
_get_station,
_set_station,
notify=changed)
def _fetch_departures(self):
self.fetching = True
self._empty_items()
try:
departures = self._station._station.get_departures()
self.beginResetModel()
self.items = [DepartureWrapper(d) for d in departures]
self.endResetModel()
except:
raise
finally:
self.fetching = False
def _get_fetching(self):
return self._fetching
def _set_fetching(self, value):
self._fetching = value
self.changed.emit()
def fetch_departures(self):
if not self._fetching:
thread = threading.Thread(target=self._fetch_departures)
thread.start()
fetching = QtCore.Property(bool,
_get_fetching,
_set_fetching,
notify=changed)
class FamTreeWrapper(QtCore.QObject):
"""
A QObject wrapper
"""
def __init__(self, thing, dbman):
QtCore.QObject.__init__(self)
self.__dbman = dbman
self.__name = thing[CLIDbManager.IND_NAME]
self.__path = thing[CLIDbManager.IND_PATH]
self.__path_namefile = thing[CLIDbManager.IND_PATH_NAMEFILE]
self.__last_access = thing[CLIDbManager.IND_TVAL_STR]
self.__use_icon = thing[CLIDbManager.IND_USE_ICON_BOOL]
self.__icon = thing[CLIDbManager.IND_STOCK_ID]
changed = QtCore.Signal()
changed_name = QtCore.Signal()
def _name(self): return self.__name
def _path(self): return self.__path
def _last_access(self): return self.__last_access
def _use_icon(self): return self.__use_icon
def _icon(self): return self.__icon
def _set_name(self, name):
self.__name = name
self.__dbman.rename_database(self.__path_namefile, name)
self.changed_name.emit()
name = QtCore.Property(UNITYPE, _name, _set_name, notify=changed_name)
path = QtCore.Property(UNITYPE, _path, notify=changed)
last_access = QtCore.Property(UNITYPE, _last_access, notify=changed)
use_icon = QtCore.Property(bool, _use_icon, notify=changed)
icon = QtCore.Property(UNITYPE, _icon, notify=changed)
class OCPConnection(QtCore.QObject):
def __init__(self, *argv):
QtCore.QObject.__init__(self)
self.__logger = logging.getLogger("OCP")
self.__node = Node(self.__logger.getChild("Node"))
self.__api = API(self.__node, self.__logger.getChild("API"))
self.__network = Network(self.__api, self.__logger.getChild("Network"))
# Qt Property/Signal API used from the UI
# ********************************************************************************************
def nodeGetter(self):
return self.__node
node = QtCore.Property(QtCore.QObject, nodeGetter, constant=True)
def apiGetter(self):
return self.__api
api = QtCore.Property(QtCore.QObject, apiGetter, constant=True)
def networkGetter(self):
return self.__network
network = QtCore.Property(QtCore.QObject, networkGetter, constant=True)
class PythonObject(QtCore.QObject):
def __init__(self):
QtCore.QObject.__init__(self, None)
self._called = ""
self._arg1 = None
self._arg2 = None
def setCalled(self, v):
self._called = v
def setArg1(self, v):
self._arg1 = v
def setArg2(self, v):
self._arg2 = v
def getCalled(self):
return self._called
def getArg1(self):
return self._arg1
def getArg2(self):
return self._arg2
called = QtCore.Property(str, getCalled, setCalled)
arg1 = QtCore.Property(int, getArg1, setArg1)
arg2 = QtCore.Property('QVariant', getArg2, setArg2)
class DepartureWrapper(QtCore.QObject):
def __init__(self, departure, *args, **kwargs):
super(DepartureWrapper, self).__init__(*args, **kwargs)
self._departure = departure
def get_destination(self):
return self._departure.destination
def get_line(self):
return self._departure.line
def get_status(self):
return self._departure.status
def get_time(self):
return self._departure.time.strftime('%H:%M')
def get_title(self):
return '%(time)s to %(destination)s' % (
{
'time': self.get_time(),
'destination': self.get_destination()
})
def get_subtitle(self):
return self._departure.description
title = QtCore.Property(unicode, get_title)
subtitle = QtCore.Property(unicode, get_subtitle)
class EyeballWidget(QtGui.QWidget):
def __init__(self, parent):
super().__init__(parent)
self.resize(720, 720)
self._opacity = 1.0
self._scale = 1.0
self._angle = 0
self._ok = False
self.eyePixmaps = {
True:
QtGui.QPixmap.fromImage(QtGui.QImage('assets/eyes-good.png')),
False: QtGui.QPixmap.fromImage(QtGui.QImage('assets/eyes-bad.png'))
}
def getOpacity(self):
return self._opacity
def setOpacity(self, opacity):
self._opacity = opacity
def getScale(self):
return self._scale
def setScale(self, scale):
self._scale = scale
self.repaint()
def getAngle(self):
return self._angle
def setAngle(self, angle):
self._angle = angle
self.repaint()
def getOk(self):
return self._ok
def setOk(self, ok):
self._ok = ok
self.repaint()
def paintEvent(self, event):
super().paintEvent(event)
painter = QtGui.QPainter(self)
painter.setRenderHint(painter.RenderHint.SmoothPixmapTransform)
painter.setOpacity(self._opacity)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self._angle)
painter.scale(self._scale, self._scale)
painter.drawPixmap(-90, -90, self.eyePixmaps[self._ok])
painter.translate(-self.width() / 2, -self.height() / 2)
opacity = QtCore.Property(float, getOpacity, setOpacity)
scale = QtCore.Property(float, getScale, setScale)
angle = QtCore.Property(float, getAngle, setAngle)
ok = QtCore.Property(bool, getOk, setOk)
class DoubleWrapper(ParamWrapper):
"""
Gui class, which maps a ParamDouble.
"""
def __init__(self, param):
ParamWrapper.__init__(self, param)
#################### getters ####################
@QtCore.Slot(result=float)
def getDefaultValue(self):
return self._param.getDefaultValue()
def getValue(self):
return self._param.getValue()
@QtCore.Slot(result=float)
def getOldValue(self):
return self._param.getOldValue()
def getMaximum(self):
return self._param.getMaximum()
def getMinimum(self):
return self._param.getMinimum()
def getHasChanged(self):
return self._param.getHasChanged()
#################### setters ####################
def setValue(self, value):
self._param.setValue(value)
def setHasChanged(self, changed):
self._param.setHasChanged(changed)
@QtCore.Slot(float)
def pushValue(self, value):
self._param.pushValue(value)
@QtCore.Signal
def changed(self):
pass
################################################## DATA EXPOSED TO QML ##################################################
value = QtCore.Property(float, getValue, setValue, notify=changed)
maximum = QtCore.Property(float, getMaximum, constant=True)
minimum = QtCore.Property(float, getMinimum, constant=True)
hasChanged = QtCore.Property(bool, getHasChanged, setHasChanged, notify=changed)
class ModRana(QtCore.QObject):
"""
core modRana functionality
"""
def __init__(self, modrana, gui):
QtCore.QObject.__init__(self)
self.modrana = modrana
self.gui = gui
self.modrana.watch("mode", self._modeChangedCB)
self.modrana.watch("theme", self._themeChangedCB)
self._theme = Theme(gui)
# mode
def _getMode(self):
return self.modrana.get('mode', "car")
def _setMode(self, mode):
self.modrana.set('mode', mode)
modeChanged = Signal()
def _modeChangedCB(self, *args):
"""notify when the mode key changes in options"""
self.modeChanged.emit()
# theme
def _getThemeId(self):
return self.modrana.get('theme', "default")
def _setThemeId(self, newTheme):
return self.modrana.set('theme', newTheme)
def _getTheme(self):
return self._theme
themeChanged = Signal()
def _themeChangedCB(self, *args):
"""notify when the mode key changes in options"""
self.themeChanged.emit()
# properties
mode = QtCore.Property(str, _getMode, _setMode, notify=modeChanged)
theme_id = QtCore.Property(str,
_getThemeId,
_setThemeId,
notify=themeChanged)
theme = QtCore.Property(QtCore.QObject, _getTheme, notify=themeChanged)
class ChoiceWrapper(ParamWrapper):
"""
Gui class, which maps a ParamChoice.
"""
def __init__(self, param):
ParamWrapper.__init__(self, param)
self._listValue = QObjectListModel()
for value in self._param.getListValue():
self._listValue.append(value)
#################### getters ####################
@QtCore.Slot(result=str)
def getDefaultValue(self):
return self._param.getDefaultValue()
def getListValue(self):
return self._listValue
def getValue(self):
return self._param.getValue()
def getHasChanged(self):
return self._param.getHasChanged()
#################### setters ####################
def setValue(self, value):
self._param.setValue(value)
def setHasChanged(self, changed):
self._param.setHasChanged(changed)
@QtCore.Slot(str)
def pushValue(self, value):
self._param.pushValue(value)
@QtCore.Signal
def changed(self):
pass
################################################## DATA EXPOSED TO QML ##################################################
listValue = QtCore.Property(QtCore.QObject, getListValue, constant=True)
value = QtCore.Property(str, getValue, setValue, notify=changed)
hasChanged = QtCore.Property(bool,
getHasChanged,
setHasChanged,
notify=changed)
class Stats(QtCore.QObject):
"""make stats available to QML and integrable as a property"""
def __init__(self, stats):
QtCore.QObject.__init__(self)
self.stats = stats
@QtCore.Slot(bool)
def setOn(self, ON):
self.mieru.stats.setOn(ON)
@QtCore.Slot()
def reset(self):
self.stats.resetStats()
@QtCore.Slot(result=str)
def getStatsText(self):
pass
def _get_statsText(self):
text = newlines2brs(
re.sub('\n', '<br>', self.stats.getStatsText(headline=False)))
return text
def _set_statsText(self, statsText):
"""if this method is called, it should trigger the
usual property changed notification
NOTE: as the Info page is loaded from file each time
it is opened, the stats text is updated on startup and
thus this method doesn't need to be called"""
self.on_statsText.emit()
def _get_enabled(self):
return self.stats.isOn()
def _set_enabled(self, value):
self.stats.setOn(value)
self.on_enabled.emit()
on_statsText = QtCore.Signal()
on_enabled = QtCore.Signal()
statsText = QtCore.Property(str,
_get_statsText,
_set_statsText,
notify=on_statsText)
enabled = QtCore.Property(bool,
_get_enabled,
_set_enabled,
notify=on_enabled)
class PropertyWrapper(QtCore.QObject):
def __init__(self, myproperty):
QtCore.QObject.__init__(self)
self._myproperty = myproperty
def _key(self):
return self._myproperty.key
def _value(self):
return self._myproperty.value
changed = QtCore.Signal()
key = QtCore.Property(unicode, _key, notify=changed)
value = QtCore.Property(unicode, _value, notify=changed)
class TargetWrapper(QtCore.QObject):
def __init__(self, target):
QtCore.QObject.__init__(self)
self._target = target
def _name(self):
return str(self._target)
def _desc(self):
return self._target.desc
changed = QtCore.Signal()
name = QtCore.Property(unicode, _name, notify=changed)
desc = QtCore.Property(unicode, _desc, notify=changed)
class StringWrapper(ParamWrapper):
"""
Gui class, which maps a ParamString.
"""
def __init__(self, param):
ParamWrapper.__init__(self, param)
#################### getters ####################
@QtCore.Slot(result=unicode)
def getDefaultValue(self):
self.setHasChanged(False)
return self._param.getDefaultValue()
def getValue(self):
return self._param.getValue()
def getStringType(self):
return self._param.getStringType()
def getHasChanged(self):
return self._param.getHasChanged()
#################### setters ####################
def setValue(self, value):
self._param.setValue(value)
def setHasChanged(self, changed):
self._param.setHasChanged(changed)
@QtCore.Slot(str)
def pushValue(self, value):
self._param.pushValue(value)
@QtCore.Signal
def changed(self):
pass
################################################## DATA EXPOSED TO QML ##################################################
value = QtCore.Property(str, getValue, setValue, notify=changed)
stringType = QtCore.Property(str, getStringType, constant=True)
hasChanged = QtCore.Property(bool,
getHasChanged,
setHasChanged,
notify=changed)
class TargetWidget(QtGui.QWidget):
def __init__(self, parent):
super().__init__(parent)
self.resize(64, 64)
self._scale = 1
def getScale(self):
return self._scale
def setScale(self, scale):
self._scale = scale
self.repaint()
def paintEvent(self, event):
super().paintEvent(event)
painter = QtGui.QPainter(self)
painter.setPen(QtGui.QColor(0, 0, 0))
painter.setBrush(QtGui.QColor(128, 128, 128))
painter.setRenderHint(painter.RenderHint.Antialiasing)
size = self.width() * self.scale
painter.drawEllipse((self.width() - size) / 2 + 1,
(self.height() - size) / 2 + 1, size - 2, size - 2)
colors = [QtGui.QColor(0, 0, 0), QtGui.QColor(255, 255, 255)]
for color in colors:
size = size / 3.5
painter.setBrush(color)
painter.drawEllipse((self.width() - size) / 2 + 1,
(self.height() - size) / 2 + 1, size - 2,
size - 2)
scale = QtCore.Property(float, getScale, setScale)
class Object(QtCore.QObject):
def __init__(self, **kwargs):
QtCore.QObject.__init__(self)
for key, val in class_def:
self.__dict__['_' + key] = kwargs.get(key, val())
def __repr__(self):
values = ('%s=%r' % (key, self.__dict__['_'+key]) \
for key, value in class_def)
return '<%s (%s)>' % (kwargs.get('name',
'QObject'), ', '.join(values))
for key, value in class_def:
nfy = locals()['_nfy_' + key] = QtCore.Signal()
def _get(key):
def f(self):
return self.__dict__['_' + key]
return f
def _set(key):
def f(self, value):
self.__dict__['_' + key] = value
self.__dict__['_nfy_' + key].emit()
return f
set = locals()['_set_' + key] = _set(key)
get = locals()['_get_' + key] = _get(key)
locals()[key] = QtCore.Property(value, get, set, notify=nfy)
class UserImageWapper(QtCore.QObject):
"""docstring for UserImageWapper"""
def __init__(self, image):
QtCore.QObject.__init__(self)
self._image = image
def _url(self):
return self._image.url
def _index(self):
return self._image.index
changed = QtCore.Signal()
url = QtCore.Property(unicode, _url, notify=changed)
index = QtCore.Property(unicode, _index, notify=changed)
class Listener(QtCore.QObject):
def __init__(self):
QtCore.QObject.__init__(self)
self._initial = True
self._rotation = 0.
def get_rotation(self):
return self._rotation
def set_rotation(self, rotation):
if self._initial:
self._rotation = rotation
self._initial = False
else:
# Smooth the accelermeter input changes
self._rotation *= .8
self._rotation += .2 * rotation
self.on_rotation.emit()
on_rotation = QtCore.Signal()
rotation = QtCore.Property(float, get_rotation, set_rotation, \
notify=on_rotation)
@QtCore.Slot()
def on_reading_changed(self):
accel = self.sender()
# Scale the x axis reading to keep the image roughly steady
self.rotation = accel.reading().x() * 7
class NestedWrapper(AutoQObject):
"""NestedWrapped enables to include additional
QObject based object instances inside this QObject
The objects are accessed by a simple ListModel based API:
count - this property county the children of this object
get(index) - get child with the given index
"""
def __init__(self, classDef, className, children=None):
if not children: children = []
AutoQObject.__init__(self, classDef, className)
self._children = children
childrenChanged = QtCore.Signal()
def _get(self):
return self._data
def _getCount(self):
return len(self._children)
@QtCore.Slot(int, result=QtCore.QObject)
def get(self, index):
try:
return self._children[index]
except IndexError:
# index out of bounds
return None
childrenCount = QtCore.Property(int, _getCount, notify=childrenChanged)
class ParamWrapper(QtCore.QObject):
"""
Define the common methods and fields for paramWrappers.
"""
def __init__(self, param):
QtCore.QObject.__init__(self)
# the buttle param
self._param = param
# link buttle param to the paramWrapper
self._param.paramChanged.connect(self.emitParamChanged)
#################### getters ####################
def getParam(self):
return self._param
def getParamType(self):
return self._param.getParamType()
def getName(self):
return self._param.getName()
def getText(self):
return self._param.getText()
def isSecret(self):
return self._param.isSecret()
# ################################################## DATA EXPOSED TO QML ##################################################
def emitParamChanged(self):
self.changed.emit()
@QtCore.Signal
def otherParamOfTheNodeChanged(self):
pass
def emitOtherParamOfTheNodeChanged(self):
self.otherParamOfTheNodeChanged.emit()
paramType = QtCore.Property(unicode, getParamType, constant=True)
text = QtCore.Property(unicode, getText, constant=True)
isSecret = QtCore.Property(bool,
isSecret,
notify=otherParamOfTheNodeChanged)
class RGBWrapper(ParamWrapper):
"""
Gui class, which maps a ParamRGB.
"""
def __init__(self, param):
ParamWrapper.__init__(self, param)
#################### getters ####################
def getDefaultR(self):
return self._param.getDefaultR()
def getDefaultG(self):
return self._param.getDefaultG()
def getDefaultB(self):
return self._param.getDefaultB()
def getValueR(self):
return self._param.getValueR()
def getValueG(self):
return self._param.getValueG()
def getValueB(self):
return self._param.getValueB()
#################### setters ####################
def setValueR(self, value):
self._param.setValueR(value)
def setValueG(self, value):
self._param.setValueG(value)
def setValueB(self, value):
self._param.setValueB(value)
@QtCore.Signal
def changed(self):
pass
################################################## DATA EXPOSED TO QML ##################################################
r = QtCore.Property(float, getValueR, setValueR, notify=changed)
g = QtCore.Property(float, getValueG, setValueG, notify=changed)
b = QtCore.Property(float, getValueB, setValueB, notify=changed)
class Screen(QtCore.QObject):
"""implement m-declarative-screen"""
def __init__(self):
QtCore.QObject.__init__(self)
self.width = 854
self.height = 480
def _width(self):
return self.width
def _height(self):
return self.height
wChanged = QtCore.Signal()
hChanged = QtCore.Signal()
displayWidth = QtCore.Property(int, _width, notify=wChanged)
displayHeight = QtCore.Property(int, _height, notify=hChanged)
class NaService(QtCore.QObject):
def __init__(self, tab, reverse):
QtCore.QObject.__init__(self)
self.tab = tab
self.isReverse = reverse
@QtCore.Slot(str)
def fieldSelected(self, fields_json):
fields = json.loads(fields_json)
sc = []
for i in range(0, len(fields)):
for f in fields[i]:
(nomtable, nomcol) = f.split('__')
tableItem = self.tab.findTableItemByNameOrAlias(nomtable)
columnItem = self.tab.findColumnItem(tableItem.id, nomcol)
sc.append((tableItem, columnItem, {
'func': '',
'newname': '',
'group': '',
'order': None
}))
self.tab.selectedColumns = sc
#self.tab.setDirty(True)
self.tab.executeQuery()
@QtCore.Slot()
def reverse(self):
tablesName, datasets = self.tab.getNaDataset(not self.isReverse)
self.tab.naView.render(tablesName, datasets, not self.isReverse)
def readPP(self):
return self.ppval
def setPP(self, val):
self.ppval = val
def readReverse(self):
return self.isReverse
def setReverse(self, val):
self.isReverse = val
dataset = QtCore.Property(str, readPP, setPP)
isReverseVal = QtCore.Property(bool, readReverse, setReverse)
class MapTiles(QtCore.QObject):
storageTypeChanged = QtCore.Signal()
def __init__(self, gui):
QtCore.QObject.__init__(self)
self.gui = gui
# assign watch to the "tileStorageType" key
# so that the property would correctly reflect the
# changed value
#self.gui.modrana.watch("tileStorageType",
# lambda x: x.storageTypeChanged.emit())
self.gui.modrana.watch("tileStorageType", self._storageTypeCB)
# we use a lambda for the callback, so we don't have a define
# a separate callback handler
def _storageTypeCB(self, *args, **kwargs):
self.storageTypeChanged.emit()
@QtCore.Slot(result=int)
def tileserverPort(self):
port = self.gui._getTileserverPort()
if port:
return port
else: # None,0 == 0 in QML
return 0
@QtCore.Slot(str, int, int, int, result=bool)
def loadTile(self, layerId, z, x, y):
"""
load a given tile from storage and/or from the network
True - tile already in storage or in memory
False - tile download in progress, retry in a while
"""
# print(layerId, z, x, y)
if self.gui._mapTiles.tileInMemory(layerId, z, x, y):
# print("available in memory")
return True
elif self.gui._mapTiles.tileInStorage(layerId, z, x, y):
# print("available in storage")
return True
else: # not in memory or storage
# add a tile download request
self.gui._mapTiles.addTileDownloadRequest(layerId, z, x, y)
# print("downloading, try later")
return False
def _getStorageType(self):
self.gui.modrana.get("tileStorageType",
self.gui.modrana.dmod.defaultTileStorageType)
def _setStorageType(self, value):
self.gui.modrana.set("tileStorageType", value)
storageType = QtCore.Property(six.text_type,
_getStorageType,
_setStorageType,
notify=storageTypeChanged)
class ClipWrapper(QtCore.QObject):
"""
Class ClipWrapper defined by :
- _nodeName : the name of the node to wich belongs the clip.
- _clipName : the name of this clip.
"""
def __init__(self, clipName, nodeName, view):
super(ClipWrapper, self).__init__(view)
self._nodeName = nodeName
self._clipName = clipName
def getNodeName(self):
return self._nodeName
def getClipName(self):
return self._clipName
name = QtCore.Property(unicode, getClipName, constant=True)
nodeName = QtCore.Property(unicode, getNodeName, constant=True)
