def autoResize(self):
desktop_w = enigma.getDesktop(0).size().width()
desktop_h = enigma.getDesktop(0).size().height()
count = len(self.list)
itemheight = self['list'].getItemHeight()
if count > 15:
count = 15
if not self['text'].text:
textsize = (520, 0)
listsize = (520, itemheight * count)
self['list'].instance.move(enigma.ePoint(0, 0))
self['list'].instance.resize(enigma.eSize(*listsize))
else:
textsize = self['text'].getSize()
if textsize[0] < textsize[1]:
textsize = (textsize[1], textsize[0] + 10)
if textsize[0] > 520:
textsize = (textsize[0], textsize[1] + itemheight)
else:
textsize = (520, textsize[1] + itemheight)
listsize = (textsize[0], itemheight * count)
self['text'].instance.resize(enigma.eSize(*textsize))
self['text'].instance.move(enigma.ePoint(10, 10))
self['list'].instance.move(enigma.ePoint(0, textsize[1]))
self['list'].instance.resize(enigma.eSize(*listsize))
wsizex = textsize[0]
wsizey = textsize[1] + listsize[1]
wsize = (wsizex, wsizey)
self.instance.resize(enigma.eSize(*wsize))
self.instance.move(enigma.ePoint((desktop_w - wsizex) / 2, (desktop_h - wsizey) / 2))
def pageUp(self): if self.total is not None: curPos = self.long_text.position() if curPos.y() < 0: self.long_text.move( ePoint( curPos.x(), curPos.y() + self.pageHeight ) ) self.split and self.right_text.move( ePoint( curPos.x(), curPos.y() + self.pageHeight ) ) self.updateScrollbar()
def move(self, x, y): if config.av.pip_mode.value == 2: self.instance.move(ePoint(370, 152)) return w = config.av.pip.value[2] if config.av.pip_mode.value == 1: x = 720 - w y = 0 config.av.pip.value[0] = x config.av.pip.value[1] = y w = config.av.pip.value[2] h = config.av.pip.value[3] if config.av.pip_mode.value == "cascade": x = MAX_X - w y = 0 elif config.av.pip_mode.value == "split": x = MAX_X / 2 y = 0 elif config.av.pip_mode.value == "byside": x = MAX_X / 2 y = MAX_Y / 4 elif config.av.pip_mode.value in "bigpig external": x = 0 y = 0 config.av.pip.save() self.instance.move(ePoint(x, y))
def updateSize(self): node = self.currentNode size = self.getSettings(node)[0] position = self.getSettings(node)[1] center = True if HD_Res: HDscale = 2; else: HDscale = 1; if splitToInt(position, 0) and splitToInt(position, 1): pos_x = splitToInt(position, 0) pos_y = splitToInt(position, 1) center = False # print "[OpenPanel] center = False" if splitToInt(size, 0) and splitToInt(size, 1): width = splitToInt(size, 0) height = splitToInt(size, 1) self.instance.resize(eSize(width, height)) self["list"].resize(eSize((width-(10*HDscale)), (height-60))) self["help"].resize(eSize((width-(10*HDscale)), 38)) self["help"].move(ePoint((5*HDscale), (height-40))) if center: pos_x = (self.Desktop_width - width) / 2 pos_y = (self.Desktop_height - height) / 2 # print "[OpenPanel] move center position" self.instance.move(ePoint(pos_x, pos_y)) else: # print "[OpenPanel] move to position: ",pos_x, pos_y self.instance.move(ePoint(pos_x, pos_y))
def applySkin(self, desktop, parent): ret = False if self.skinAttributes is not None: skin.applyAllAttributes(self.long_text, desktop, self.skinAttributes, parent.scale) widget_attribs = [ ] scrollbar_attribs = [ ] for (attrib, value) in self.skinAttributes: if "borderColor" in attrib or "borderWidth" in attrib: scrollbar_attribs.append((attrib,value)) if "transparent" in attrib or "backgroundColor" in attrib: widget_attribs.append((attrib,value)) skin.applyAllAttributes(self.instance, desktop, widget_attribs, parent.scale) skin.applyAllAttributes(self.scrollbar, desktop, scrollbar_attribs+widget_attribs, parent.scale) ret = True s = self.long_text.size() self.instance.move(self.long_text.position()) lineheight=fontRenderClass.getInstance().getLineHeight( self.long_text.getFont() ) if not lineheight: lineheight = 30 # assume a random lineheight if nothing is visible lines = (int)(s.height() / lineheight) self.pageHeight = (int)(lines * lineheight) self.instance.resize(eSize(s.width(), self.pageHeight+(int)(lineheight/6))) self.scrollbar.move(ePoint(s.width()-20,0)) self.scrollbar.resize(eSize(20,self.pageHeight+(int)(lineheight/6))) self.scrollbar.setOrientation(eSlider.orVertical); self.scrollbar.setRange(0,100) self.scrollbar.setBorderWidth(1) self.long_text.move(ePoint(0,0)) self.long_text.resize(eSize(s.width()-30, self.pageHeight*50)) self.setText(self.message) return ret
def pageDown(self): if self.total is not None: curPos = self.long_text.position() if self.total-self.pageHeight >= abs( curPos.y() - self.pageHeight ): self.long_text.move( ePoint( curPos.x(), curPos.y() - self.pageHeight ) ) self.split and self.right_text.move( ePoint( curPos.x(), curPos.y() - self.pageHeight ) ) self.updateScrollbar()
def autoResize(self):
desktop_w = enigma.getDesktop(0).size().width()
desktop_h = enigma.getDesktop(0).size().height()
count = len(self.list)
if count > 15:
count = 15
if not self["text"].text:
# move list
textsize = (520, 0)
listsize = (520, 25 * count)
self["list"].instance.move(enigma.ePoint(0, 0))
self["list"].instance.resize(enigma.eSize(*listsize))
else:
textsize = self["text"].getSize()
if textsize[0] < textsize[1]:
textsize = (textsize[1], textsize[0] + 10)
if textsize[0] > 520:
textsize = (textsize[0], textsize[1] + 25)
else:
textsize = (520, textsize[1] + 25)
listsize = (textsize[0], 25 * count)
# resize label
self["text"].instance.resize(enigma.eSize(*textsize))
self["text"].instance.move(enigma.ePoint(10, 10))
# move list
self["list"].instance.move(enigma.ePoint(0, textsize[1]))
self["list"].instance.resize(enigma.eSize(*listsize))
wsizex = textsize[0]
wsizey = textsize[1] + listsize[1]
wsize = (wsizex, wsizey)
self.instance.resize(enigma.eSize(*wsize))
# center window
self.instance.move(enigma.ePoint((desktop_w - wsizex) / 2, (desktop_h - wsizey) / 2))
def updateSize(self): center = True if HD_Res: HDscale = 2 else: HDscale = 1; if splitToInt(self.position, 0) and splitToInt(self.position, 1): pos_x = splitToInt(self.position, 0) pos_y = splitToInt(self.position, 1) center = False # print "[OpenPanel] center = False" if splitToInt(self.size, 0) and splitToInt(self.size, 1): width = splitToInt(self.size, 0) height = splitToInt(self.size, 1) self.instance.resize(eSize(width, height)) self["text"].resize(eSize((width-(10*HDscale)), (height-20))) if center: pos_x = (self.Desktop_width - width) / 2 pos_y = (self.Desktop_height - height) / 2 # print "[OpenPanel] move center position" self.instance.move(ePoint(pos_x, pos_y)) else: # print "[OpenPanel] move to position: ",pos_x, pos_y self.instance.move(ePoint(pos_x, pos_y))
def autoResize(self): orgwidth = self.instance.size().width() orgpos = self.instance.position() # textsize = self["text"].getSize() textsize = (textsize[0] + 50, textsize[1]) # [iq] count = len(self.list) if count > 10: count = 10 offset = 25 * count wsizex = textsize[0] + 60 wsizey = textsize[1] + offset if (520 > wsizex): wsizex = 520 wsize = (wsizex, wsizey) # resize self.instance.resize(enigma.eSize(*wsize)) # resize label self["text"].instance.resize(enigma.eSize(*textsize)) # move list listsize = (wsizex, 25 * count) self["list"].instance.move(enigma.ePoint(0, textsize[1])) self["list"].instance.resize(enigma.eSize(*listsize)) # center window newwidth = wsize[0] self.instance.move(enigma.ePoint((720-wsizex)/2, (576-wsizey)/(count > 7 and 2 or 3)))
def lineScroll(self): if self.long_text is not None and config.usage.scroll_label_delay.value != 'noscrolling': if self.text_height > self.page_height: curPos = self.long_text.position() if self.text_height - self.step >= abs(curPos.y() - self.step): self.long_text.move(ePoint(curPos.x(), curPos.y() - self.step)) else: self.long_text.move(ePoint(curPos.x(), self.page_height)) self.updateTimer.start(self.steptime) else: self.updateTimer.stop()
def applySkin(self, desktop, parent):
scrollbarWidth = 20
scrollbarBorderWidth = 1
ret = False
if self.skinAttributes is not None:
scrollbar_attribs = [ ]
widget_attribs = [ ]
remove_attribs = [ ]
for (attrib, value) in self.skinAttributes:
if attrib.find("borderColor") != -1 or attrib.find("borderWidth") != -1:
scrollbar_attribs.append((attrib,value))
if attrib.find("transparent") != -1 or attrib.find("backgroundColor") != -1:
widget_attribs.append((attrib,value))
if attrib.find("scrollbarSliderForegroundColor") != -1:
scrollbar_attribs.append((attrib,value))
remove_attribs.append((attrib, value))
if attrib.find("scrollbarSliderBorderColor") != -1:
scrollbar_attribs.append((attrib,value))
remove_attribs.append((attrib, value))
if attrib.find("scrollbarSliderPicture") != -1:
scrollbar_attribs.append((attrib,value))
remove_attribs.append((attrib, value))
if attrib.find("scrollbarBackgroundPicture") != -1:
scrollbar_attribs.append((attrib,value))
remove_attribs.append((attrib, value))
if attrib.find("scrollbarWidth") != -1:
scrollbarWidth = int(value)
remove_attribs.append((attrib, value))
if attrib.find("scrollbarSliderBorderWidth") != -1:
scrollbarBorderWidth = int(value)
remove_attribs.append((attrib, value))
for (attrib, value) in remove_attribs:
self.skinAttributes.remove((attrib, value))
skin.applyAllAttributes(self.long_text, desktop, self.skinAttributes, parent.scale)
skin.applyAllAttributes(self.instance, desktop, widget_attribs, parent.scale)
skin.applyAllAttributes(self.scrollbar, desktop, scrollbar_attribs+widget_attribs, parent.scale)
ret = True
s = self.long_text.size()
self.instance.move(self.long_text.position())
lineheight=fontRenderClass.getInstance().getLineHeight( self.long_text.getFont() )
if not lineheight:
lineheight = 30 # assume a random lineheight if nothing is visible
lines = (int)(s.height() / lineheight)
self.pageHeight = (int)(lines * lineheight)
self.instance.resize(eSize(s.width(), self.pageHeight+(int)(lineheight/6)))
self.scrollbar.move(ePoint(s.width() - scrollbarWidth,0))
self.scrollbar.resize(eSize(scrollbarWidth,self.pageHeight+(int)(lineheight/6)))
self.scrollbar.setOrientation(eSlider.orVertical);
self.scrollbar.setRange(0,100)
self.scrollbar.setBorderWidth(scrollbarBorderWidth)
self.long_text.move(ePoint(0,0))
self.long_text.resize(eSize(s.width()-30, self.pageHeight*16))
self.setText(self.message)
return ret
def lineScroll(self):
if self.long_text is not None:
if self.text_height > self.page_height:
curPos = self.long_text.position()
if self.text_height - self.step >= abs(curPos.y() - self.step):
self.long_text.move(ePoint(curPos.x(), curPos.y() - self.step))
else:
self.long_text.move(ePoint(curPos.x(), self.page_height))
self.updateTimer.start(self.steptime)
else:
self.updateTimer.stop()
def move(self, x, y): if config.av.pip_mode.value == 2: self.instance.move(ePoint(370, 152)) return w = config.av.pip.value[2] if config.av.pip_mode.value == 1: x = 720 - w y = 0 config.av.pip.value[0] = x config.av.pip.value[1] = y config.av.pip.save() self.instance.move(ePoint(x, y))
def __layoutFinished(self): from enigma import eSize, ePoint if getDesktop(0).size().height() == 1080: lenlist = len(self.list)*40 self["config"].instance.move(ePoint(383, 863 - lenlist)) self["config"].instance.resize(eSize(1234, lenlist)) self["introduction"].instance.resize(eSize(1234, 623 - lenlist)) else: lenlist = len(self.list)*30 self["config"].instance.move(ePoint(228, 590 - lenlist)) self["config"].instance.resize(eSize(800, lenlist)) self["introduction"].instance.resize(eSize(800, 415 - lenlist))
def setValues(self, v): i = 0 while True: barvalues = self.bars.get(i,(0,0,0)) progressbarHeight = barvalues[0] value = int(1.25 * (v[i] + 80)) currentvalue = int(value*progressbarHeight/100) oldvalue = self.pegelvalues.get(i,None) if currentvalue <= 0: hide = 1 else: hide = 0 if oldvalue: if oldvalue[0] < currentvalue: self.pegelvalues[i] = (currentvalue, time.time(),0,hide) if hide: self["top_%d" % i].hide() else: if oldvalue[3]: self["top_%d" % i].show() self["top_%d" % i].instance.move(ePoint(self["top_%d" % i].instance.position().x(), barvalues[1] - currentvalue - barvalues[2])) elif oldvalue[0] > currentvalue: d = time.time() if (d - oldvalue[1] > 0.7 and oldvalue[2] == 0) or (d - oldvalue[1] > 0.1 and oldvalue[2] == 1) or (oldvalue[2] >= 2): if oldvalue[2] > 4: currentvalue = oldvalue[0] - int(0.1 * progressbarHeight) elif oldvalue[2] > 2: currentvalue = oldvalue[0] - int(0.06 * progressbarHeight) else: currentvalue = oldvalue[0] - int(0.03 * progressbarHeight) if currentvalue <= 0: hide = 1 else: hide = 0 self.pegelvalues[i] = (currentvalue, d,oldvalue[2]+1,hide) if hide: self["top_%d" % i].hide() else: self["top_%d" % i].instance.move(ePoint(self["top_%d" % i].instance.position().x(), barvalues[1] - currentvalue - barvalues[2])) else: self.pegelvalues[i] = (currentvalue, time.time(),0,hide) else: self.pegelvalues[i] = (currentvalue, time.time(),0, hide) if hide: self["top_%d" % i].hide() else: self["top_%d" % i].instance.move(ePoint(self["top_%d" % i].instance.position().x(), barvalues[1] - currentvalue - barvalues[2])) self["progress_%d" % i].setValue(value) i += 1 if i == len(v): break
def resizeScreen(self): n = len(self["config"].getList()) y = n * self.height if fullHD: x = [112,412,67,367,580] dy = [35,25,31] else: x = [100,285,70,255,380] dy = [25,17,20] self.instance.resize(eSize(self.width, self.height*(n+1)+ dy[0])) self["key_red"].instance.move(ePoint(x[0], y + dy[1])) self["key_green"].instance.move(ePoint(x[1], y + dy[1])) self["red"].instance.move(ePoint(x[2], y + dy[2])) self["green"].instance.move(ePoint(x[3], y + dy[2])) self["blue"].instance.move(ePoint(x[4], y + dy[2]))
def changeScreensize(self, new_height, new_width = None):
if new_width is None:
new_width = sizeH
self.instance.resize(eSize(new_width, new_height))
fb = getDesktop(0).size()
new_posY = int(( fb.height() / 2 ) - ( new_height / 2 ))
x = int( ( fb.width() - sizeH ) / 2 )
self.instance.move(ePoint(x, new_posY))
self["output"].resize(eSize(self.sizeLH, new_height - 20))
self["key_red"].setText(_("Close"))
if self.what == "c":
self["key_green"].setText("")
self["key_yellow"].setText("Servers")
self["key_blue"].setText("Log")
self["output"].l.setItemHeight(20)
elif self.what == "s":
self["key_green"].setText("Clients")
self["key_yellow"].setText("")
self["key_blue"].setText("Log")
self["output"].l.setItemHeight(20)
elif self.what == "l":
self["key_green"].setText("Clients")
self["key_yellow"].setText("Servers")
self["key_blue"].setText("")
self["output"].l.setItemHeight(14)
else:
self["key_green"].setText("Clients")
self["key_yellow"].setText("Servers")
self["key_blue"].setText("Log")
def movePositionTimer(self):
if self.configRoot.position_x.value == 0 and self.configRoot.position_y.value == 0:
self.configRoot.position_x.value = (self.desktopWidth - self.screenSize_x)/2
self.configRoot.position_y.value = self.moveMinMargin
self.instance.move(ePoint(self.configRoot.position_x.value, self.configRoot.position_y.value))
self.moveTimer.start(50, 1)
def applySkin(self, desktop):
skin.applyAllAttributes(self.long_text, desktop, self.skinAttributes)
s = self.long_text.size()
self.instance.move(self.long_text.position())
lineheight = fontRenderClass.getInstance().getLineHeight(self.long_text.getFont())
lines = int(s.height() / lineheight)
self.pageHeight = int(lines * lineheight)
self.instance.resize(eSize(s.width(), self.pageHeight + int(lineheight / 6)))
self.scrollbar.move(ePoint(s.width() - 20, 0))
self.scrollbar.resize(eSize(20, self.pageHeight + int(lineheight / 6)))
self.scrollbar.setOrientation(eSlider.orVertical)
self.scrollbar.setRange(0, 100)
self.scrollbar.setBorderWidth(1)
self.long_text.move(ePoint(0, 0))
self.long_text.resize(eSize(s.width() - 30, self.pageHeight * 16))
self.setText(self.message)
def showKeypad(self): current = self["config"].getCurrent() helpwindowpos = self["HelpWindow"].getPosition() if hasattr(current[1], 'help_window'): if current[1].help_window.instance is not None: current[1].help_window.instance.show() current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
def applySkin(self, desktop, parent):
attribs = []
longtext_attribs = []
for attrib, value in self.skinAttributes:
if attrib.find('step') != -1:
self.step = int(value)
if attrib.find('steptime') != -1:
self.steptime = int(value)
if attrib.find('startdelay') != -1:
self.startdelay = int(value)
if attrib.find('font') != -1 or attrib.find('size') != -1 or attrib.find('zPosition') != -1 or attrib.find('transparent') != -1 or attrib.find('backgroundColor') != -1 or attrib.find('foregroundColor') != -1 or attrib.find('valign') != -1 or attrib.find('halign') != -1:
longtext_attribs.append((attrib, value))
if attrib != 'font' and attrib != 'valign' and attrib != 'halign' and attrib != 'foregroundColor' and attrib != 'step' and attrib != 'steptime' and attrib != 'startdelay' and attrib != 'css':
attribs.append((attrib, value))
if attrib.find('css') != -1:
from skin import cascadingStyleSheets
styles = value.split(',')
for style in styles:
for _attrib in cascadingStyleSheets[style].keys():
_value = cascadingStyleSheets[style][_attrib]
if _attrib.find('step') != -1:
self.step = int(_value)
if _attrib.find('steptime') != -1:
self.steptime = int(_value)
if _attrib.find('startdelay') != -1:
self.startdelay = int(_value)
if _attrib.find('font') != -1 or _attrib.find('size') != -1 or _attrib.find('zPosition') != -1 or _attrib.find('transparent') != -1 or _attrib.find('backgroundColor') != -1 or _attrib.find('foregroundColor') != -1 or _attrib.find('valign') != -1 or _attrib.find('halign') != -1:
longtext_attribs.append((_attrib, _value))
if _attrib != 'font' and _attrib != 'valign' and _attrib != 'halign' and _attrib != 'foregroundColor' and _attrib != 'step' and _attrib != 'steptime' and _attrib != 'startdelay':
attribs.append((_attrib, _value))
skin.applyAllAttributes(self.long_text, desktop, longtext_attribs, parent.scale)
self.long_text.move(ePoint(0, 0))
self.skinAttributes = attribs
return Renderer.applySkin(self, desktop, parent)
def movePosition(self):
if self.instance:
self.instance.move(ePoint(config.plugins.MovielistPreview.position_x.value, config.plugins.MovielistPreview.position_y.value))
size = config.plugins.MovielistPreview.size.value.split("x")
self.instance.resize(eSize(int(size[0]), int(size[1])))
self["background"].instance.resize(eSize(int(size[0]), int(size[1])))
self["preview"].instance.resize(eSize(int(size[0]), int(size[1])))
def setText(self, text):
self.message = text
if self.long_text is not None and self.pageHeight:
self.long_text.move(ePoint(0,0))
if self.split:
left = []
right = []
for line in self.message.split("\n"):
line = line.split(self.splitchar,1)
if len(line) == 1:
line.append("")
left.append(line[0])
right.append(line[1].lstrip(' '))
self.long_text.setText("\n".join(left))
self.right_text.setText("\n".join(right))
else:
self.long_text.setText(self.message)
text_height=self.long_text.calculateSize().height()
total=self.pageHeight
pages=1
while total < text_height:
total=total+self.pageHeight
pages=pages+1
if pages > 1:
self.scrollbar.show()
self.total = total
self.pages = pages
self.updateScrollbar()
else:
self.scrollbar.hide()
self.total = None
self.pages = None
def moveTimerTextRun(self): self.moveTimerText.stop() if (self.a > 8): # Als de tekst op het display meer dan 14 tekens bevat, dan gaan scrollen self.instance.move(ePoint(self.x, self.y)) self.x -=1 self.c -=1 elif (self.a > 0): # Als de niet mag scrollen en de tekst bevat meer dan 0 tekens dan tekst stil laten staan for d in self.text: # Kijk in de tekst als er spaties zijn if d == " ": self.x2 +=5 # Als er een spatie is tel 5 pixels bij de tekst op self.x2 = 2 # zet dan de begin positie van de tekst op deze berekening (midden lcd scherm) self.a = 0 self.instance.move(ePoint(self.x2, self.y)) # zet de vaste tekst hier neer self.p self.y if self.c == 1: self.changed((self.CHANGED_DEFAULT,)) self.moveTimerText.start(25)
def selectionChanged(self):
if self["config"].getCurrent():
if len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2]:
self["description"].setText(self["config"].getCurrent()[2])
if isinstance(self["config"].getCurrent()[1], ConfigText):
if self.has_key("VKeyIcon"):
self["VirtualKB"].setEnabled(True)
self["VKeyIcon"].boolean = True
if self.has_key("HelpWindow"):
if (
self["config"].getCurrent()[1].help_window
and self["config"].getCurrent()[1].help_window.instance is not None
):
helpwindowpos = self["HelpWindow"].getPosition()
from enigma import ePoint
self["config"].getCurrent()[1].help_window.instance.move(
ePoint(helpwindowpos[0], helpwindowpos[1])
)
else:
if self.has_key("VKeyIcon"):
self["VirtualKB"].setEnabled(False)
self["VKeyIcon"].boolean = False
else:
if self.has_key("VKeyIcon"):
self["VirtualKB"].setEnabled(False)
self["VKeyIcon"].boolean = False
def handleInputHelpers(self):
self["status"].setText(self["config"].getCurrent()[2])
if self["config"].getCurrent() is not None:
try:
if isinstance(self["config"].getCurrent()[1], ConfigText) or isinstance(self["config"].getCurrent()[1], ConfigPassword):
if self.has_key("VKeyIcon"):
self["VirtualKB"].setEnabled(True)
self["VKeyIcon"].boolean = True
if self.has_key("HelpWindow"):
if self["config"].getCurrent()[1].help_window.instance is not None:
helpwindowpos = self["HelpWindow"].getPosition()
from enigma import ePoint
self["config"].getCurrent()[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
else:
if self.has_key("VKeyIcon"):
self["VirtualKB"].setEnabled(False)
self["VKeyIcon"].boolean = False
except:
if self.has_key("VKeyIcon"):
self["VirtualKB"].setEnabled(False)
self["VKeyIcon"].boolean = False
else:
if self.has_key("VKeyIcon"):
self["VirtualKB"].setEnabled(False)
self["VKeyIcon"].boolean = False
def position(self, value):
if isinstance(value, tuple):
self.guiObject.move(ePoint(*value))
else:
self.guiObject.move(
parsePosition(value, self.scale, self.guiObject, self.desktop,
self.guiObject.csize()))
def moveMarker(self):
# calculate position of image
imgPosX = self.offsetCoverX + (self.coverWidth + self.disWidth) * self.dispX
imgPosY = self.offsetCoverY + (self.coverHeight + self.disHeight) * self.dispY
# calculate postion of marker for current image
x = imgPosX - (self.markerWidth - self.coverWidth)/2
y = imgPosY - (self.markerHeight - self.coverHeight)/2
#x = 30 + self.dispX * 180
#y = 130 + self.dispY * 125
self["marker"].instance.move(ePoint(x,y))
idx = self.currLine * self.numOfCol + self.dispX
self["curChannelName"].setText(self.currList[idx][1])
current = ServiceReference(self.currList[idx][0])
nowepg, nowstart, nowend, nowname, nowduration, nowdesc, percentnow = self.getEPGNowNext(current.ref,0)
nextepg, nextstart, nextend, nextname, nextduration, nextdesc, percentnext = self.getEPGNowNext(current.ref,1)
self["NowEventStart"].setText(nowstart)
self["NextEventStart"].setText(nextstart)
self["NowEventEnd"].setText(nowend)
self["NextEventEnd"].setText(nextend)
self["NowEventTitle"].setText(nowname)
self["NextEventTitle"].setText(nextname)
self["NowDuration"].setText(nowduration)
self["NextDuration"].setText(nextduration)
self["NowDescription"].setText(nowdesc)
self["NextDescription"].setText(nextdesc)
self["vzProgress"].setValue(percentnow)
if config.plugins.SparkWall.ZapMode.value == "2ok": self.zap = True
return
def moveWindow(self):
try:
if self.x_pos is None or self.y_pos is None:
self.x_pos = self.instance.position().x()
self.y_pos = self.instance.position().y()
if self.instance.size().width() + 20 >= getDesktop(0).size().width() and self.instance.size().height() + 20 >= getDesktop(0).size().height():
return
self.x_pos += self.x_dir
self.y_pos += self.y_dir
if self.x_dir > 0 and self.x_pos + self.instance.size().width() >= getDesktop(0).size().width():
self.x_dir = -self.x_dir
elif self.x_dir < 0 and self.x_pos <= 0:
self.x_dir = -self.x_dir
if self.y_dir > 0 and self.y_pos + self.instance.size().height() >= getDesktop(0).size().height():
self.y_dir = -self.y_dir
elif self.y_dir < 0 and self.y_pos <= 0:
self.y_dir = -self.y_dir
self.instance.move(ePoint(self.x_pos, self.y_pos))
except Exception:
pass
try:
self.WindowMoveTimer.start(150, True)
except Exception:
pass
def timerAdd(self):
if self.isRecording:
return
event = self.event
serviceref = self.currentService
if event is None:
return
eventid = event.getEventId()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
for timer in self.session.nav.RecordTimer.timer_list:
if timer.eit == eventid and ':'.join(timer.service_ref.ref.toString().split(':')[:11]) == refstr:
cb_func1 = lambda ret: self.removeTimer(timer)
cb_func2 = lambda ret: self.editTimer(timer)
menu = [(_('Delete timer'),
'CALLFUNC',
self.ChoiceBoxCB,
cb_func1), (_('Edit timer'),
'CALLFUNC',
self.ChoiceBoxCB,
cb_func2)]
self.ChoiceBoxDialog = self.session.instantiateDialog(ChoiceBox, title=_('Select action for timer %s:') % event.getEventName(), list=menu, keys=['green', 'blue'], skin_name='RecordTimerQuestion')
self.ChoiceBoxDialog.instance.move(ePoint(self.instance.position().x() + self['key_green'].getPosition()[0], self.instance.position().y() + self['key_green'].getPosition()[1] - self['key_green'].instance.size().height()))
self.showChoiceBoxDialog()
break
else:
newEntry = RecordTimerEntry(self.currentService, checkOldTimers=True, dirname=preferredTimerPath(), *parseEvent(self.event))
self.session.openWithCallback(self.finishedAdd, TimerEntry, newEntry)
def move(self, x, y):
config.av.pip.value[0] = x
config.av.pip.value[1] = y
config.av.pip.save()
self.instance.move(ePoint(x, y))
def selectionChanged(self):
current = self["config"].getCurrent()
helpwindowpos = self["HelpWindow"].getPosition()
if current[1].help_window.instance is not None:
current[1].help_window.instance.move(
ePoint(helpwindowpos[0], helpwindowpos[1]))
def parsePosition(s, scale, object = None, desktop = None, size = None): (x, y) = parseValuePair(s, scale, object, desktop, size) return ePoint(x, y)
def doMovePicture(self):
self.posx = random.randint(1, self.maxx)
self.posy = random.randint(1, self.maxy)
self["picture"].instance.move(ePoint(self.posx, self.posy))
self.moveLogoTimer.startLongTimer(5)
def pageUp(self): if self.total is not None: curPos = self.long_text.position() if curPos.y() < 0: self.long_text.move(ePoint(curPos.x(), curPos.y() + self.pageHeight)) self.updateScrollbar()
def move(self, x, y=None):
# we assume, that x is already an ePoint
if y is None:
self.instance.move(x)
else:
self.instance.move(ePoint(int(x), int(y)))
def __init__(self, widget1, widget2):
position = widget1.position
size1 = widget1.instance.calculateSize()
widget2.instance.move(
ePoint(position[0] + size1.width() + 10, position[1]))
def setPosition(self, x, y):
self.instance.move(ePoint(int(x), int(y)))
def pageDown(self): if self.total is not None: curPos = self.long_text.position() if self.total - self.pageHeight >= abs(curPos.y() - self.pageHeight): self.long_text.move(ePoint(curPos.x(), curPos.y() - self.pageHeight)) self.updateScrollbar()
def position(self, value): if isinstance(value, tuple): self.guiObject.move(ePoint(*value)) else: self.guiObject.move(parsePosition(value, self.scaleTuple, self.guiObject, self.desktop, self.guiObject.csize()))
def applySkin(self, desktop, screen):
def retValue(val, limit, default, Min=False):
try:
if Min:
x = min(limit, int(val))
else:
x = max(limit, int(val))
except:
x = default
return x
self.halign = valign = eLabel.alignLeft
if self.skinAttributes:
attribs = []
for (attrib, value) in self.skinAttributes:
if attrib == "font":
self.txfont = parseFont(value, ((1, 1), (1, 1)))
elif attrib == "foregroundColor":
self.fcolor = parseColor(value)
elif attrib == "backgroundColor":
self.bcolor = parseColor(value)
elif attrib == "shadowColor":
self.scolor = parseColor(value)
elif attrib == "shadowOffset":
x, y = value.split(',')
self.soffset = (int(x), int(y))
elif attrib == "valign" and value in ("top", "center",
"bottom"):
valign = {
"top": eLabel.alignTop,
"center": eLabel.alignCenter,
"bottom": eLabel.alignBottom
}[value]
self.txtflags |= {
"top": RT_VALIGN_TOP,
"center": RT_VALIGN_CENTER,
"bottom": RT_VALIGN_BOTTOM
}[value]
elif attrib == "halign" and value in ("left", "center",
"right", "block"):
self.halign = {
"left": eLabel.alignLeft,
"center": eLabel.alignCenter,
"right": eLabel.alignRight,
"block": eLabel.alignBlock
}[value]
self.txtflags |= {
"left": RT_HALIGN_LEFT,
"center": RT_HALIGN_CENTER,
"right": RT_HALIGN_RIGHT,
"block": RT_HALIGN_BLOCK
}[value]
elif attrib == "noWrap":
if value == "0":
self.txtflags |= RT_WRAP
else:
self.txtflags &= ~RT_WRAP
elif attrib == "options":
options = value.split(',')
for opt in options:
val = ''
pos = opt.find('=')
if pos != -1:
val = opt[pos + 1:].strip()
opt = opt[:pos].strip()
if opt == "wrap":
if val == "0":
self.txtflags &= ~RT_WRAP
else:
self.txtflags |= RT_WRAP
elif opt == "nowrap":
if val == "0":
self.txtflags |= RT_WRAP
else:
self.txtflags &= ~RT_WRAP
elif opt == "movetype" and val in ("none", "running",
"swimming"):
self.type = {
"none": NONE,
"running": RUNNING,
"swimming": SWIMMING
}[val]
elif opt == "direction" and val in ("left", "right",
"top", "bottom"):
self.direction = {
"left": LEFT,
"right": RIGHT,
"top": TOP,
"bottom": BOTTOM
}[val]
elif opt == "step" and val:
#retValue(val, limit, default, Min=False)
self.mStep = retValue(val, 1, self.mStep)
elif opt == "steptime" and val:
self.mStepTimeout = retValue(
val, 25, self.mStepTimeout)
elif opt == "startdelay" and val:
self.mStartDelay = retValue(
val, 0, self.mStartDelay)
elif opt == "pause" and val:
self.mLoopTimeout = retValue(
val, 0, self.mLoopTimeout)
elif opt == "oneshot" and val:
self.mOneShot = retValue(val, 0, self.mOneShot)
elif opt == "repeat" and val:
self.mRepeat = retValue(val, 0, self.mRepeat)
elif opt == "always" and val:
self.mAlways = retValue(val, 0, self.mAlways)
elif opt == "startpoint" and val:
self.mStartPoint = int(val)
else:
attribs.append((attrib, value))
self.skinAttributes = attribs
ret = Renderer.applySkin(self, desktop, screen)
#if self.type == RUNNING and self.direction in (LEFT,RIGHT):
# self.halign = eLabel.alignLeft
# self.txtflags = RT_HALIGN_LEFT | (self.txtflags & RT_WRAP)
if self.mOneShot: self.mOneShot = max(self.mStepTimeout, self.mOneShot)
if self.mLoopTimeout:
self.mLoopTimeout = max(self.mStepTimeout, self.mLoopTimeout)
self.test_label.setFont(self.txfont)
#self.test_label.setForegroundColor(self.fcolor)
#self.test_label.setBackgroundColor(self.bcolor)
#if not self.scolor is None:
# self.test_label.setShadowColor(self.scolor)
# self.test_label.setShadowOffset(ePoint(self.soffset[0], self.soffset[1]))
if not (self.txtflags & RT_WRAP):
self.test_label.setNoWrap(1)
self.test_label.setVAlign(valign)
self.test_label.setHAlign(self.halign)
self.test_label.move(ePoint(self.W, self.H))
self.test_label.resize(eSize(self.W, self.H))
#self.test_label.hide()
#self.changed((self.CHANGED_DEFAULT,))
return ret
def applySkin(self, desktop, screen):
def retValue(val, limit, default, Min=False):
try:
if Min:
x = min(limit, int(val))
else:
x = max(limit, int(val))
except:
x = default
return x
def setWrapFlag(attrib, value):
if attrib.lower() == 'wrap' and value == '0' or attrib.lower(
) == 'nowrap' and value != '0':
self.txtflags &= ~RT_WRAP
else:
self.txtflags |= RT_WRAP
self.halign = valign = eLabel.alignLeft
if self.skinAttributes:
attribs = []
for attrib, value in self.skinAttributes:
if attrib == 'font':
self.txfont = parseFont(value, ((1, 1), (1, 1)))
elif attrib == 'foregroundColor':
self.scroll_label.setForegroundColor(parseColor(value))
elif attrib in ('shadowColor', 'borderColor'):
self.scroll_label.setShadowColor(parseColor(value))
elif attrib == 'shadowOffset':
x, y = value.split(',')
self.soffset = (int(x), int(y))
self.scroll_label.setShadowOffset(ePoint(self.soffset))
elif attrib == 'borderWidth':
self.soffset = (-int(value), -int(value))
elif attrib == 'valign' and value in ('top', 'center',
'bottom'):
valign = {
'top': eLabel.alignTop,
'center': eLabel.alignCenter,
'bottom': eLabel.alignBottom
}[value]
self.txtflags |= {
'top': RT_VALIGN_TOP,
'center': RT_VALIGN_CENTER,
'bottom': RT_VALIGN_BOTTOM
}[value]
elif attrib == 'halign' and value in ('left', 'center',
'right', 'block'):
self.halign = {
'left': eLabel.alignLeft,
'center': eLabel.alignCenter,
'right': eLabel.alignRight,
'block': eLabel.alignBlock
}[value]
self.txtflags |= {
'left': RT_HALIGN_LEFT,
'center': RT_HALIGN_CENTER,
'right': RT_HALIGN_RIGHT,
'block': RT_HALIGN_BLOCK
}[value]
elif attrib == 'noWrap':
setWrapFlag(attrib, value)
elif attrib == 'options':
options = value.split(',')
for o in options:
if o.find('=') != -1:
opt, val = (x.strip() for x in o.split('=', 1))
else:
opt, val = o.strip(), ''
if opt == '':
continue
elif opt in ('wrap', 'nowrap'):
setWrapFlag(opt, val)
elif opt == 'movetype' and val in ('none', 'running',
'swimming'):
self.type = {
'none': NONE,
'running': RUNNING,
'swimming': SWIMMING
}[val]
elif opt == 'direction' and val in ('left', 'right',
'top', 'bottom'):
self.direction = {
'left': LEFT,
'right': RIGHT,
'top': TOP,
'bottom': BOTTOM
}[val]
elif opt == 'step' and val:
self.mStep = retValue(val, 1, self.mStep)
elif opt == 'steptime' and val:
self.mStepTimeout = retValue(
val, 25, self.mStepTimeout)
elif opt == 'startdelay' and val:
self.mStartDelay = retValue(
val, 0, self.mStartDelay)
elif opt == 'pause' and val:
self.mLoopTimeout = retValue(
val, 0, self.mLoopTimeout)
elif opt == 'oneshot' and val:
self.mOneShot = retValue(val, 0, self.mOneShot)
elif opt == 'repeat' and val:
self.mRepeat = retValue(val, 0, self.mRepeat)
elif opt == 'always' and val:
self.mAlways = retValue(val, 0, self.mAlways)
elif opt == 'startpoint' and val:
self.mStartPoint = int(val)
elif opt == 'pagedelay' and val:
self.mPageDelay = retValue(val, 0, self.mPageDelay)
elif opt == 'pagelength' and val:
self.mPageLength = retValue(
val, 0, self.mPageLength)
else:
attribs.append((attrib, value))
if attrib == 'backgroundColor':
self.scroll_label.setBackgroundColor(parseColor(value))
elif attrib == 'transparent':
self.scroll_label.setTransparent(int(value))
self.skinAttributes = attribs
ret = Renderer.applySkin(self, desktop, screen)
if self.mOneShot:
self.mOneShot = max(self.mStepTimeout, self.mOneShot)
if self.mLoopTimeout:
self.mLoopTimeout = max(self.mStepTimeout, self.mLoopTimeout)
if self.mPageDelay:
self.mPageDelay = max(self.mStepTimeout, self.mPageDelay)
self.scroll_label.setFont(self.txfont)
if not self.txtflags & RT_WRAP:
self.scroll_label.setNoWrap(1)
self.scroll_label.setVAlign(valign)
self.scroll_label.setHAlign(self.halign)
self.scroll_label.move(ePoint(0, 0))
self.scroll_label.resize(eSize(self.W, self.H))
if self.direction in (TOP, BOTTOM):
from enigma import fontRenderClass
flh = int(fontRenderClass.getInstance().getLineHeight(self.txfont)
or self.txfont.pointSize / 6 + self.txfont.pointSize)
self.scroll_label.setText('WQq')
if flh > self.scroll_label.calculateSize().height():
self.lineHeight = flh
self.scroll_label.setText('')
return ret
def applySkin(self, desktop, screen):
def retValue(val, limit, default, Min=False):
try:
if Min:
x = min(limit, int(val))
else:
x = max(limit, int(val))
except:
x = default
return x
def setWrapFlag(attrib, value):
if (attrib.lower() == "wrap" and value == "0") or \
(attrib.lower() == "nowrap" and value != "0"):
self.txtflags &= ~RT_WRAP
else:
self.txtflags |= RT_WRAP
self.halign = valign = eLabel.alignLeft
if self.skinAttributes:
attribs = []
for (attrib, value) in self.skinAttributes:
if attrib == "font":
self.txfont = parseFont(value, ((1, 1), (1, 1)))
elif attrib == "foregroundColor":
self.scroll_label.setForegroundColor(parseColor(value))
elif attrib in ("shadowColor",
"borderColor"): # fake for openpli-enigma2
self.scroll_label.setShadowColor(parseColor(value))
elif attrib == "shadowOffset":
x, y = value.split(',')
self.soffset = (int(x), int(y))
self.scroll_label.setShadowOffset(ePoint(self.soffset))
elif attrib == "borderWidth": # fake for openpli-enigma2
self.soffset = (-int(value), -int(value))
elif attrib == "valign" and value in ("top", "center",
"bottom"):
valign = {
"top": eLabel.alignTop,
"center": eLabel.alignCenter,
"bottom": eLabel.alignBottom
}[value]
self.txtflags |= {
"top": RT_VALIGN_TOP,
"center": RT_VALIGN_CENTER,
"bottom": RT_VALIGN_BOTTOM
}[value]
elif attrib == "halign" and value in ("left", "center",
"right", "block"):
self.halign = {
"left": eLabel.alignLeft,
"center": eLabel.alignCenter,
"right": eLabel.alignRight,
"block": eLabel.alignBlock
}[value]
self.txtflags |= {
"left": RT_HALIGN_LEFT,
"center": RT_HALIGN_CENTER,
"right": RT_HALIGN_RIGHT,
"block": RT_HALIGN_BLOCK
}[value]
elif attrib == "noWrap":
setWrapFlag(attrib, value)
elif attrib == "options":
options = value.split(',')
for o in options:
if '=' in o:
opt, val = (x.strip() for x in o.split('=', 1))
else:
opt, val = o.strip(), ""
if opt == "":
continue
elif opt in ("wrap", "nowrap"):
setWrapFlag(opt, val)
elif opt == "movetype" and val in ("none", "running",
"swimming"):
self.type = {
"none": NONE,
"running": RUNNING,
"swimming": SWIMMING
}[val]
elif opt == "direction" and val in ("left", "right",
"top", "bottom"):
self.direction = {
"left": LEFT,
"right": RIGHT,
"top": TOP,
"bottom": BOTTOM
}[val]
elif opt == "step" and val:
self.mStep = retValue(val, 1, self.mStep)
elif opt == "steptime" and val:
self.mStepTimeout = retValue(
val, 25, self.mStepTimeout)
elif opt == "startdelay" and val:
self.mStartDelay = retValue(
val, 0, self.mStartDelay)
elif opt == "pause" and val:
self.mLoopTimeout = retValue(
val, 0, self.mLoopTimeout)
elif opt == "oneshot" and val:
self.mOneShot = retValue(val, 0, self.mOneShot)
elif opt == "repeat" and val:
self.mRepeat = retValue(val, 0, self.mRepeat)
elif opt == "always" and val:
self.mAlways = retValue(val, 0, self.mAlways)
elif opt == "startpoint" and val:
self.mStartPoint = int(val)
elif opt == "pagedelay" and val:
self.mPageDelay = retValue(val, 0, self.mPageDelay)
elif opt == "pagelength" and val:
self.mPageLength = retValue(
val, 0, self.mPageLength)
else:
attribs.append((attrib, value))
if attrib == "backgroundColor":
self.scroll_label.setBackgroundColor(parseColor(value))
elif attrib == "transparent":
self.scroll_label.setTransparent(int(value))
self.skinAttributes = attribs
ret = Renderer.applySkin(self, desktop, screen)
if self.mOneShot: self.mOneShot = max(self.mStepTimeout, self.mOneShot)
if self.mLoopTimeout:
self.mLoopTimeout = max(self.mStepTimeout, self.mLoopTimeout)
if self.mPageDelay:
self.mPageDelay = max(self.mStepTimeout, self.mPageDelay)
self.scroll_label.setFont(self.txfont)
if not (self.txtflags & RT_WRAP):
self.scroll_label.setNoWrap(1)
self.scroll_label.setVAlign(valign)
self.scroll_label.setHAlign(self.halign)
self.scroll_label.move(ePoint(0, 0))
self.scroll_label.resize(eSize(self.W, self.H))
# test for auto correction text height:
if self.direction in (TOP, BOTTOM):
from enigma import fontRenderClass
flh = int(fontRenderClass.getInstance().getLineHeight(self.txfont)
or self.txfont.pointSize / 6 + self.txfont.pointSize)
self.scroll_label.setText("WQq")
if flh > self.scroll_label.calculateSize().height():
self.lineHeight = flh
self.scroll_label.setText("")
return ret
def movePosition(self):
if self.configRoot.position_x.value != 0 or self.configRoot.position_y.value != 0:
self.instance.move(
ePoint(self.configRoot.position_x.value,
self.configRoot.position_y.value))
def textOffset(self, value):
x, y = value.split(',')
self.guiObject.setTextOffset(ePoint(int(x) * self.scale[0][0] / self.scale[0][1], int(y) * self.scale[1][0] / self.scale[1][1]))
def refreshPosition(self):
#== position des PiP abfragen (kommt mit SD-Werten)
x1 = config.av.pip.value[0]
y1 = config.av.pip.value[1]
x2 = config.av.pip.value[2]
y2 = config.av.pip.value[3]
#== Abmessungen des Screens ermitteln
width = getDesktop(0).size().width()
height = getDesktop(0).size().height()
#position des PiP in Skin-Werte umrechnen
xt = x1 * width / 720
yt = y1 * height / 576
ht = y2 * height / 576
wt = x2 * width / 720
# Korrektur wenn das PiP ueber den unteren bzw. rechten Rand gehen wuerde
tmp = xt - (wt * 4) / 100
if tmp < 0:
xt = 0
else:
xt = tmp
tmp = yt - (ht * 4) / 100
if tmp < 0:
yt = 0
else:
yt = tmp
tmp = (wt * 108) / 100
if xt + tmp > width:
wt = width - xt
else:
wt = tmp
tmp = (ht * 108) / 100
if yt + tmp > height:
ht = height - yt
else:
ht = tmp
border_width = self["border_top"].instance.size().height()
x = xt - (border_width / 2) - 1
y = yt - border_width + 1
h = ht + (border_width / 2)
w = wt + (2 * border_width) - 1
border_txt_height = self["border_txt"].instance.size().height()
h_border_txt = border_txt_height + 5 # Versatz/Hoehe des Text-Rahmens
h = h + h_border_txt #Hoehe
show_txt_ontop_of_pip = False
if (y + h) > height: # wenn PiP am unteren Rand
y = y - border_txt_height + border_width
h_border_txt = h
show_txt_ontop_of_pip = True
h_border = h - 6
#== Groessen und Positionen der Screen-Elemente anpassen ====
self.instance.resize(eSize(*(w, h)))
self.instance.move(ePoint(int(x), int(y)))
self["border_top"].instance.resize(eSize(*(w, border_width)))
if show_txt_ontop_of_pip:
self["border_top"].instance.move(
ePoint(int(0), int(h_border - border_width)))
else:
self["border_top"].instance.move(ePoint(int(0), int(0)))
self["border_left"].instance.resize(eSize(*(border_width, h_border)))
self["border_right"].instance.resize(eSize(*(border_width, h_border)))
self["border_right"].instance.move(
ePoint(int(w - border_width), int(0)))
self["border_txt"].instance.resize(eSize(*(w, border_txt_height)))
self["border_txt"].instance.move(ePoint(int(0), int(h - h_border_txt)))
self["channel_txt"].instance.resize(
eSize(*(w - (2 * border_width), 29)))
self["channel_txt"].instance.move(
ePoint(int(border_width), int(h - h_border_txt + 2)))
def moveLabel(self, X, Y):
self.scroll_label.move(ePoint(X - self.soffset[0],
Y - self.soffset[1]))
