code.vuplus.com Git - vuplus_dvbapp-plugin/blob - autotimer/src/AutoTimerOverview.py

   1 # for localized messages
   2 from . import _
   3
   4 # GUI (Screens)
   5 from Screens.Screen import Screen
   6 from Screens.HelpMenu import HelpableScreen
   7 from Screens.MessageBox import MessageBox
   8 from Screens.ChoiceBox import ChoiceBox
   9 from AutoTimerEditor import AutoTimerEditor, AutoTimerChannelSelection
  10 from AutoTimerSettings import AutoTimerSettings
  11 from AutoTimerPreview import AutoTimerPreview
  12 from AutoTimerImporter import AutoTimerImportSelector
  13 from AutoTimerWizard import AutoTimerWizard
  14
  15 # GUI (Components)
  16 from AutoTimerList import AutoTimerList
  17 from Components.ActionMap import HelpableActionMap
  18 from Components.config import config
  19 from Components.Sources.StaticText import StaticText
  20
  21 class AutoTimerOverviewSummary(Screen):
  22         skin = """
  23         <screen position="0,0" size="132,64">
  24                 <widget source="parent.Title" render="Label" position="6,4" size="120,21" font="Regular;18" />
  25                 <widget source="entry" render="Label" position="6,25" size="120,21" font="Regular;16" />
  26                 <widget source="global.CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
  27                         <convert type="ClockToText">WithSeconds</convert>
  28                 </widget>
  29         </screen>"""
  30
  31         def __init__(self, session, parent):
  32                 Screen.__init__(self, session, parent = parent)
  33                 self["entry"] = StaticText("")
  34                 self.onShow.append(self.addWatcher)
  35                 self.onHide.append(self.removeWatcher)
  36
  37         def addWatcher(self):
  38                 self.parent.onChangedEntry.append(self.selectionChanged)
  39                 self.parent.selectionChanged()
  40
  41         def removeWatcher(self):
  42                 self.parent.onChangedEntry.remove(self.selectionChanged)
  43
  44         def selectionChanged(self, text):
  45                 self["entry"].text = text
  46
  47 class AutoTimerOverview(Screen, HelpableScreen):
  48         """Overview of AutoTimers"""
  49
  50         skin = """<screen name="AutoTimerOverview" position="center,center" size="460,280" title="AutoTimer Overview">
  51                         <ePixmap position="0,0" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" />
  52                         <ePixmap position="140,0" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" />
  53                         <ePixmap position="280,0" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" />
  54                         <ePixmap position="422,10" zPosition="1" size="35,25" pixmap="skin_default/buttons/key_menu.png" alphatest="on" />
  55                         <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" />
  56                         <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" />
  57                         <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" />
  58                         <widget name="entries" position="5,45" size="450,225" scrollbarMode="showOnDemand" />
  59                 </screen>"""
  60
  61         def __init__(self, session, autotimer):
  62                 Screen.__init__(self, session)
  63                 HelpableScreen.__init__(self)
  64
  65                 # Save autotimer
  66                 self.autotimer = autotimer
  67
  68                 self.changed = False
  69
  70                 # Button Labels
  71                 self["key_green"] = StaticText(_("Save"))
  72                 self["key_yellow"] = StaticText(_("Delete"))
  73                 self["key_blue"] = StaticText(_("Add"))
  74
  75                 # Create List of Timers
  76                 self["entries"] = AutoTimerList(autotimer.getSortedTupleTimerList())
  77
  78                 # Summary
  79                 self.onChangedEntry = []
  80                 self["entries"].onSelectionChanged.append(self.selectionChanged)
  81
  82                 # Define Actions
  83                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
  84                         {
  85                                 "ok": (self.ok, _("Edit selected AutoTimer")),
  86                                 "cancel": (self.cancel, _("Close and forget changes")),
  87                         }
  88                 )
  89
  90                 self["MenuActions"] = HelpableActionMap(self, "MenuActions",
  91                         {
  92                                 "menu": (self.menu, _("Open Context Menu"))
  93                         }
  94                 )
  95
  96                 self["ColorActions"] = HelpableActionMap(self, "ColorActions",
  97                         {
  98                                 "green": (self.save, _("Close and save changes")),
  99                                 "yellow": (self.remove, _("Remove selected AutoTimer")),
 100                                 "blue": (self.add, _("Add new AutoTimer")),
 101                         }
 102                 )
 103
 104                 self.onLayoutFinish.append(self.setCustomTitle)
 105
 106         def setCustomTitle(self):
 107                 self.setTitle(_("AutoTimer overview"))
 108
 109         def createSummary(self):
 110                 return AutoTimerOverviewSummary
 111
 112         def selectionChanged(self):
 113                 sel = self["entries"].getCurrent()
 114                 text = sel and sel.name or ""
 115                 for x in self.onChangedEntry:
 116                         try:
 117                                 x(text)
 118                         except Exception:
 119                                 pass
 120
 121         def add(self):
 122                 newTimer = self.autotimer.defaultTimer.clone()
 123                 newTimer.id = self.autotimer.getUniqueId()
 124
 125                 if config.plugins.autotimer.editor.value == "wizard":
 126                         self.session.openWithCallback(
 127                                 self.addCallback,
 128                                 AutoTimerWizard,
 129                                 newTimer
 130                         )
 131                 else:
 132                         self.session.openWithCallback(
 133                                 self.addCallback,
 134                                 AutoTimerEditor,
 135                                 newTimer
 136                         )
 137
 138         def editCallback(self, ret):
 139                 if ret:
 140                         self.changed = True
 141                         self.refresh()
 142
 143         def addCallback(self, ret):
 144                 if ret:
 145                         self.changed = True
 146                         self.autotimer.add(ret)
 147                         self.refresh()
 148
 149         def importCallback(self, ret):
 150                 if ret:
 151                         self.session.openWithCallback(
 152                                 self.addCallback,
 153                                 AutoTimerEditor,
 154                                 ret
 155                         )
 156
 157         def refresh(self, res = None):
 158                 # Re-assign List
 159                 cur = self["entries"].getCurrent()
 160                 self["entries"].setList(self.autotimer.getSortedTupleTimerList())
 161                 self["entries"].moveToEntry(cur)
 162
 163         def ok(self):
 164                 # Edit selected Timer
 165                 current = self["entries"].getCurrent()
 166                 if current is not None:
 167                         self.session.openWithCallback(
 168                                 self.editCallback,
 169                                 AutoTimerEditor,
 170                                 current
 171                         )
 172
 173         def remove(self):
 174                 # Remove selected Timer
 175                 cur = self["entries"].getCurrent()
 176                 if cur is not None:
 177                         self.session.openWithCallback(
 178                                 self.removeCallback,
 179                                 MessageBox,
 180                                 _("Do you really want to delete %s?") % (cur.name),
 181                         )
 182
 183         def removeCallback(self, ret):
 184                 cur = self["entries"].getCurrent()
 185                 if ret and cur:
 186                         self.autotimer.remove(cur.id)
 187                         self.refresh()
 188
 189         def cancel(self):
 190                 if self.changed:
 191                         self.session.openWithCallback(
 192                                 self.cancelConfirm,
 193                                 MessageBox,
 194                                 _("Really close without saving settings?")
 195                         )
 196                 else:
 197                         self.close(None)
 198
 199         def cancelConfirm(self, ret):
 200                 if ret:
 201                         # Invalidate config mtime to force re-read on next run
 202                         self.autotimer.configMtime = -1
 203
 204                         # Close and indicated that we canceled by returning None
 205                         self.close(None)
 206
 207         def menu(self):
 208                 list = [
 209                         (_("Preview"), "preview"),
 210                         (_("Import existing Timer"), "import"),
 211                         (_("Import from EPG"), "import_epg"),
 212                         (_("Setup"), "setup"),
 213                         (_("Edit new timer defaults"), "defaults"),
 214                 ]
 215
 216                 if config.plugins.autotimer.editor.value == "wizard":
 217                         list.append((_("Create a new timer using the classic editor"), "newplain"))
 218                 else:
 219                         list.append((_("Create a new timer using the wizard"), "newwizard"))
 220
 221                 self.session.openWithCallback(
 222                         self.menuCallback,
 223                         ChoiceBox,
 224                         list = list,
 225                 )
 226
 227         def menuCallback(self, ret):
 228                 ret = ret and ret[1]
 229                 if ret:
 230                         if ret == "preview":
 231                                 total, new, modified, timers = self.autotimer.parseEPG(simulateOnly = True)
 232                                 self.session.open(
 233                                         AutoTimerPreview,
 234                                         timers
 235                                 )
 236                         elif ret == "import":
 237                                 newTimer = self.autotimer.defaultTimer.clone()
 238                                 newTimer.id = self.autotimer.getUniqueId()
 239
 240                                 self.session.openWithCallback(
 241                                         self.importCallback,
 242                                         AutoTimerImportSelector,
 243                                         newTimer
 244                                 )
 245                         elif ret == "import_epg":
 246                                 self.session.openWithCallback(
 247                                         self.refresh,
 248                                         AutoTimerChannelSelection,
 249                                         self.autotimer
 250                                 )
 251                         elif ret == "setup":
 252                                 self.session.open(
 253                                         AutoTimerSettings
 254                                 )
 255                         elif ret == "defaults":
 256                                 self.session.open(
 257                                         AutoTimerEditor,
 258                                         self.autotimer.defaultTimer,
 259                                         editingDefaults = True
 260                                 )
 261                         elif ret == "newwizard":
 262                                 newTimer = self.autotimer.defaultTimer.clone()
 263                                 newTimer.id = self.autotimer.getUniqueId()
 264
 265                                 self.session.openWithCallback(
 266                                         self.addCallback, # XXX: we could also use importCallback... dunno what seems more natural
 267                                         AutoTimerWizard,
 268                                         newTimer
 269                                 )
 270                         elif ret == "newplain":
 271                                 newTimer = self.autotimer.defaultTimer.clone()
 272                                 newTimer.id = self.autotimer.getUniqueId()
 273
 274                                 self.session.openWithCallback(
 275                                         self.addCallback,
 276                                         AutoTimerEditor,
 277                                         newTimer
 278                                 )
 279
 280         def save(self):
 281                 # Just close here, saving will be done by cb
 282                 self.close(self.session)
 283