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]))