AutoPoller.py: fix missing import
[vuplus_dvbapp-plugin] / autotimer / src / AutoTimerOverview.py
index a2907e8..dd3ea29 100644 (file)
@@ -1,36 +1,66 @@
+# for localized messages
+from . import _
+
 # GUI (Screens)
 from Screens.Screen import Screen
+from Screens.HelpMenu import HelpableScreen
 from Screens.MessageBox import MessageBox
 from Screens.ChoiceBox import ChoiceBox
-from AutoTimerEditor import AutoTimerEditor
-from AutoTimerConfiguration import AutoTimerConfiguration
+from AutoTimerEditor import AutoTimerEditor, AutoTimerChannelSelection
+from AutoTimerSettings import AutoTimerSettings
 from AutoTimerPreview import AutoTimerPreview
 from AutoTimerImporter import AutoTimerImportSelector
+from AutoTimerWizard import AutoTimerWizard
 
 # GUI (Components)
 from AutoTimerList import AutoTimerList
-from Components.ActionMap import ActionMap
-from Components.Button import Button
+from Components.ActionMap import HelpableActionMap
+from Components.config import config
+from Components.Sources.StaticText import StaticText
+
+class AutoTimerOverviewSummary(Screen):
+       skin = """
+       <screen position="0,0" size="132,64">
+               <widget source="parent.Title" render="Label" position="6,4" size="120,21" font="Regular;18" />
+               <widget source="entry" render="Label" position="6,25" size="120,21" font="Regular;16" />
+               <widget source="global.CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
+                       <convert type="ClockToText">WithSeconds</convert>
+               </widget>
+       </screen>"""
+
+       def __init__(self, session, parent):
+               Screen.__init__(self, session, parent = parent)
+               self["entry"] = StaticText("")
+               self.onShow.append(self.addWatcher)
+               self.onHide.append(self.removeWatcher)
+
+       def addWatcher(self):
+               self.parent.onChangedEntry.append(self.selectionChanged)
+               self.parent.selectionChanged()
 
-# Plugin
-from AutoTimerComponent import AutoTimerComponent
+       def removeWatcher(self):
+               self.parent.onChangedEntry.remove(self.selectionChanged)
 
-class AutoTimerOverview(Screen):
+       def selectionChanged(self, text):
+               self["entry"].text = text
+
+class AutoTimerOverview(Screen, HelpableScreen):
        """Overview of AutoTimers"""
 
-       skin = """<screen name="AutoTimerOverview" position="140,148" size="460,265" title="AutoTimer Overview">
-                       <widget name="entries" position="5,5" size="450,200" scrollbarMode="showOnDemand" />
-                       <ePixmap position="0,220" zPosition="1" size="140,40" pixmap="skin_default/key-green.png" transparent="1" alphatest="on" />
-                       <ePixmap position="140,220" zPosition="1" size="140,40" pixmap="skin_default/key-yellow.png" transparent="1" alphatest="on" />
-                       <ePixmap position="280,220" zPosition="1" size="140,40" pixmap="skin_default/key-blue.png" transparent="1" alphatest="on" />
-                       <ePixmap position="422,230" zPosition="1" size="36,20" pixmap="key_menu-fs8.png" transparent="1" alphatest="on" />
-                       <widget name="key_green" position="0,220" zPosition="2" size="140,40" halign="center" valign="center" font="Regular;21" transparent="1" shadowColor="black" shadowOffset="-1,-1" />
-                       <widget name="key_yellow" position="140,220" zPosition="2" size="140,40" halign="center" valign="center" font="Regular;21" transparent="1" shadowColor="black" shadowOffset="-1,-1" />
-                       <widget name="key_blue" position="280,220" zPosition="2" size="140,40" halign="center" valign="center" font="Regular;21" transparent="1" shadowColor="black" shadowOffset="-1,-1" />
+       skin = """<screen name="AutoTimerOverview" position="center,center" size="460,280" title="AutoTimer Overview">
+                       <ePixmap position="0,0" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" />
+                       <ePixmap position="140,0" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" />
+                       <ePixmap position="280,0" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" />
+                       <ePixmap position="422,10" zPosition="1" size="35,25" pixmap="skin_default/buttons/key_menu.png" alphatest="on" />
+                       <widget source="key_green" render="Label" position="0,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
+                       <widget source="key_yellow" render="Label" position="140,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
+                       <widget source="key_blue" render="Label" position="280,0" zPosition="1" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
+                       <widget name="entries" position="5,45" size="450,225" scrollbarMode="showOnDemand" />
                </screen>"""
 
        def __init__(self, session, autotimer):
                Screen.__init__(self, session)
+               HelpableScreen.__init__(self)
 
                # Save autotimer
                self.autotimer = autotimer
@@ -38,37 +68,72 @@ class AutoTimerOverview(Screen):
                self.changed = False
 
                # Button Labels
-               self["key_green"] = Button(_("Save"))
-               self["key_yellow"] = Button(_("Delete"))
-               self["key_blue"] = Button(_("Add"))
+               self["key_green"] = StaticText(_("Save"))
+               self["key_yellow"] = StaticText(_("Delete"))
+               self["key_blue"] = StaticText(_("Add"))
 
                # Create List of Timers
-               self["entries"] = AutoTimerList(self.autotimer.getTupleTimerList())
+               self["entries"] = AutoTimerList(autotimer.getSortedTupleTimerList())
+
+               # Summary
+               self.onChangedEntry = []
+               self["entries"].onSelectionChanged.append(self.selectionChanged)
 
                # Define Actions
-               self["actions"] = ActionMap(["OkCancelActions", "MenuActions", "ColorActions"],
+               self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+                       {
+                               "ok": (self.ok, _("Edit selected AutoTimer")),
+                               "cancel": (self.cancel, _("Close and forget changes")),
+                       }
+               )
+
+               self["MenuActions"] = HelpableActionMap(self, "MenuActions",
+                       {
+                               "menu": (self.menu, _("Open Context Menu"))
+                       }
+               )
+
+               self["ColorActions"] = HelpableActionMap(self, "ColorActions",
                        {
-                               "ok": self.ok,
-                               "cancel": self.cancel,
-                               "green": self.save,
-                               "yellow": self.remove,
-                               "blue": self.add,
-                               "menu": self.menu
+                               "green": (self.save, _("Close and save changes")),
+                               "yellow": (self.remove, _("Remove selected AutoTimer")),
+                               "blue": (self.add, _("Add new AutoTimer")),
                        }
                )
 
+               self.onLayoutFinish.append(self.setCustomTitle)
+
+       def setCustomTitle(self):
+               self.setTitle(_("AutoTimer overview"))
+
+       def createSummary(self):
+               return AutoTimerOverviewSummary
+
+       def selectionChanged(self):
+               sel = self["entries"].getCurrent()
+               text = sel and sel.name or ""
+               for x in self.onChangedEntry:
+                       try:
+                               x(text)
+                       except Exception:
+                               pass
+
        def add(self):
-               self.session.openWithCallback(
-                       self.addCallback,
-                       AutoTimerEditor,
-                       # TODO: implement setting a default?
-                       AutoTimerComponent(
-                               self.autotimer.getUniqueId(),   # Id
-                               "",                                                             # Name
-                               "",                                                             # Match
-                               True                                                    # Enabled                               
+               newTimer = self.autotimer.defaultTimer.clone()
+               newTimer.id = self.autotimer.getUniqueId()
+
+               if config.plugins.autotimer.editor.value == "wizard":
+                       self.session.openWithCallback(
+                               self.addCallback,
+                               AutoTimerWizard,
+                               newTimer
+                       )
+               else:
+                       self.session.openWithCallback(
+                               self.addCallback,
+                               AutoTimerEditor,
+                               newTimer
                        )
-               )
 
        def editCallback(self, ret):
                if ret:
@@ -81,9 +146,19 @@ class AutoTimerOverview(Screen):
                        self.autotimer.add(ret)
                        self.refresh()
 
+       def importCallback(self, ret):
+               if ret:
+                       self.session.openWithCallback(
+                               self.addCallback,
+                               AutoTimerEditor,
+                               ret
+                       )
+
        def refresh(self, res = None):
                # Re-assign List
-               self["entries"].setList(self.autotimer.getTupleTimerList())
+               cur = self["entries"].getCurrent()
+               self["entries"].setList(self.autotimer.getSortedTupleTimerList())
+               self["entries"].moveToEntry(cur)
 
        def ok(self):
                # Edit selected Timer
@@ -92,7 +167,7 @@ class AutoTimerOverview(Screen):
                        self.session.openWithCallback(
                                self.editCallback,
                                AutoTimerEditor,
-                               current[0]
+                               current
                        )
 
        def remove(self):
@@ -102,18 +177,22 @@ class AutoTimerOverview(Screen):
                        self.session.openWithCallback(
                                self.removeCallback,
                                MessageBox,
-                               _("Do you really want to delete %s?") % (cur[0].name),
+                               _("Do you really want to delete %s?") % (cur.name),
                        )
 
        def removeCallback(self, ret):
                cur = self["entries"].getCurrent()
                if ret and cur:
-                       self.autotimer.remove(cur[0].id)
+                       self.autotimer.remove(cur.id)
                        self.refresh()
 
        def cancel(self):
                if self.changed:
-                       self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
+                       self.session.openWithCallback(
+                               self.cancelConfirm,
+                               MessageBox,
+                               _("Really close without saving settings?")
+                       )
                else:
                        self.close(None)
 
@@ -126,40 +205,79 @@ class AutoTimerOverview(Screen):
                        self.close(None)
 
        def menu(self):
+               list = [
+                       (_("Preview"), "preview"),
+                       (_("Import existing Timer"), "import"),
+                       (_("Import from EPG"), "import_epg"),
+                       (_("Setup"), "setup"),
+                       (_("Edit new timer defaults"), "defaults"),
+               ]
+
+               if config.plugins.autotimer.editor.value == "wizard":
+                       list.append((_("Create a new timer using the classic editor"), "newplain"))
+               else:
+                       list.append((_("Create a new timer using the wizard"), "newwizard"))
+
                self.session.openWithCallback(
                        self.menuCallback,
                        ChoiceBox,
-                       list = [
-                               (_("Preview"), "preview"),
-                               (_("Import"), "import"),
-                               (_("Setup"), "setup"),
-                       ],
+                       list = list,
                )
 
        def menuCallback(self, ret):
+               ret = ret and ret[1]
                if ret:
-                       if ret[1] == "preview":
-                               total, new, modified, timers = self.autotimer.parseEPG(simulateOnly = True)
+                       if ret == "preview":
+                               total, new, modified, timers, conflicts = self.autotimer.parseEPG(simulateOnly = True)
                                self.session.open(
                                        AutoTimerPreview,
                                        timers
                                )
-                       elif ret[1] == "import":
+                       elif ret == "import":
+                               newTimer = self.autotimer.defaultTimer.clone()
+                               newTimer.id = self.autotimer.getUniqueId()
+
                                self.session.openWithCallback(
-                                       self.addCallback,
+                                       self.importCallback,
                                        AutoTimerImportSelector,
-                                       AutoTimerComponent(
-                                               self.autotimer.getUniqueId(),   # Id
-                                               "",                                                             # Name
-                                               "",                                                             # Match
-                                               True                                                    # Enabled                               
-                                       )
+                                       newTimer
+                               )
+                       elif ret == "import_epg":
+                               self.session.openWithCallback(
+                                       self.refresh,
+                                       AutoTimerChannelSelection,
+                                       self.autotimer
                                )
-                       elif ret[1] == "setup":
+                       elif ret == "setup":
                                self.session.open(
-                                       AutoTimerConfiguration
+                                       AutoTimerSettings
+                               )
+                       elif ret == "defaults":
+                               self.session.open(
+                                       AutoTimerEditor,
+                                       self.autotimer.defaultTimer,
+                                       editingDefaults = True
+                               )
+                       elif ret == "newwizard":
+                               newTimer = self.autotimer.defaultTimer.clone()
+                               newTimer.id = self.autotimer.getUniqueId()
+
+                               self.session.openWithCallback(
+                                       self.addCallback, # XXX: we could also use importCallback... dunno what seems more natural
+                                       AutoTimerWizard,
+                                       newTimer
+                               )
+                       elif ret == "newplain":
+                               newTimer = self.autotimer.defaultTimer.clone()
+                               newTimer.id = self.autotimer.getUniqueId()
+
+                               self.session.openWithCallback(
+                                       self.addCallback,
+                                       AutoTimerEditor,
+                                       newTimer
                                )
 
        def save(self):
                # Just close here, saving will be done by cb
                self.close(self.session)
+