some python import cleanups
[enigma2.git] / lib / python / Plugins / Extensions / CutListEditor / plugin.py
1 from Plugins.Plugin import PluginDescriptor
2
3 from Screens.Screen import Screen
4 from Screens.MessageBox import MessageBox
5 from Components.ServicePosition import ServicePositionGauge
6 from Components.ActionMap import HelpableActionMap
7 from Components.MenuList import MenuList
8 from Components.MultiContent import MultiContentEntryText
9 from Components.ServiceEventTracker import ServiceEventTracker
10 from Screens.InfoBarGenerics import InfoBarSeek, InfoBarCueSheetSupport
11 from Components.GUIComponent import GUIComponent
12 from enigma import eListboxPythonMultiContent, eListbox, gFont, iPlayableService, RT_HALIGN_RIGHT
13 from Screens.FixedMenu import FixedMenu
14 import bisect
15
16 def CutListEntry(where, what):
17         res = [ (where, what) ]
18         w = where / 90
19         ms = w % 1000
20         s = (w / 1000) % 60
21         m = (w / 60000) % 60
22         h = w / 3600000
23         if what == 0:
24                 type = "IN"
25         elif what == 1:
26                 type = "OUT"
27         elif what == 2:
28                 type = "MARK"
29         elif what == 3:
30                 type = "LAST"
31         res.append(MultiContentEntryText(size=(400, 20), text = "%dh:%02dm:%02ds:%03d" % (h, m, s, ms)))
32         res.append(MultiContentEntryText(pos=(400,0), size=(130, 20), text = type, flags = RT_HALIGN_RIGHT))
33
34         return res
35
36 class CutListContextMenu(FixedMenu):
37         RET_STARTCUT = 0
38         RET_ENDCUT = 1
39         RET_DELETECUT = 2
40         RET_MARK = 3
41         RET_DELETEMARK = 4
42         RET_REMOVEBEFORE = 5
43         RET_REMOVEAFTER = 6
44         
45         SHOW_STARTCUT = 0
46         SHOW_ENDCUT = 1
47         SHOW_DELETECUT = 2
48         
49         def __init__(self, session, state, nearmark):
50                 menu = [(_("back"), self.close)] #, (None, )]
51
52                 if state == self.SHOW_STARTCUT:
53                         menu.append((_("start cut here"), self.startCut))
54                 else:
55                         menu.append((_("start cut here"), ))
56
57                 if state == self.SHOW_ENDCUT:
58                         menu.append((_("end cut here"), self.endCut))
59                 else:
60                         menu.append((_("end cut here"), ))
61
62                 if state == self.SHOW_DELETECUT:
63                         menu.append((_("delete cut"), self.deleteCut))
64                 else:
65                         menu.append((_("delete cut"), ))
66
67                 menu.append((_("remove before this position"), self.removeBefore))
68                 menu.append((_("remove after this position"), self.removeAfter))
69
70 #               menu.append((None, ))
71
72                 if not nearmark:
73                         menu.append((_("insert mark here"), self.insertMark))
74                 else:
75                         menu.append((_("remove this mark"), self.removeMark))
76
77                 FixedMenu.__init__(self, session, _("Cut"), menu)
78                 self.skinName = "Menu"
79
80         def startCut(self):
81                 self.close(self.RET_STARTCUT)
82
83         def endCut(self):
84                 self.close(self.RET_ENDCUT)
85
86         def deleteCut(self):
87                 self.close(self.RET_DELETECUT)
88
89         def insertMark(self):
90                 self.close(self.RET_MARK)
91
92         def removeMark(self):
93                 self.close(self.RET_DELETEMARK)
94         
95         def removeBefore(self):
96                 self.close(self.RET_REMOVEBEFORE)
97
98         def removeAfter(self):
99                 self.close(self.RET_REMOVEAFTER)
100
101
102 class CutList(GUIComponent):
103         def __init__(self, list):
104                 GUIComponent.__init__(self)
105                 self.l = eListboxPythonMultiContent()
106                 self.setList(list)
107                 self.l.setFont(0, gFont("Regular", 20))
108                 self.onSelectionChanged = [ ]
109         
110         def getCurrent(self):
111                 return self.l.getCurrentSelection()
112         
113         def getCurrentIndex(self):
114                 return self.l.getCurrentSelectionIndex()
115         
116         GUI_WIDGET = eListbox
117         
118         def postWidgetCreate(self, instance):
119                 instance.setContent(self.l)
120                 instance.setItemHeight(30)
121                 instance.selectionChanged.get().append(self.selectionChanged)
122
123         def selectionChanged(self):
124                 for x in self.onSelectionChanged:
125                         x()
126         
127         def invalidateEntry(self, index):
128                 self.l.invalidateEntry(index)
129         
130         def setIndex(self, index, data):
131                 self.list[index] = data
132                 self.invalidateEntry(index)
133
134         def setList(self, list):
135                 self.list = list
136                 self.l.setList(self.list)
137         
138         def setSelection(self, index):
139                 if self.instance is not None:
140                         self.instance.moveSelectionTo(index)
141
142 class CutListEditor(Screen, InfoBarSeek, InfoBarCueSheetSupport):
143         skin = """
144                 <screen position="100,100" size="550,400" title="Test" >
145                         <widget name="Timeline" position="10,0" size="530,40" 
146                                 pointer="/usr/share/enigma2/position_pointer.png:3,5" foregroundColor="#225b7395" />
147                         <widget name="Cutlist" position="10,50" size="530,300" scrollbarMode="showOnDemand" />
148                 </screen>"""
149         def __init__(self, session, service):
150                 self.skin = CutListEditor.skin
151                 Screen.__init__(self, session)
152                 InfoBarSeek.__init__(self)
153                 InfoBarCueSheetSupport.__init__(self)
154                 self.old_service = session.nav.getCurrentlyPlayingServiceReference()
155                 session.nav.playService(service)
156                 
157                 service = session.nav.getCurrentService()
158                 cue = service and service.cueSheet()
159                 if cue is not None:
160                         # disable cutlists. we want to freely browse around in the movie
161                         print "cut lists disabled!"
162                         cue.setCutListEnable(0)
163                 
164                 self.downloadCuesheet()
165         
166                 self["Timeline"] = ServicePositionGauge(self.session.nav)
167                 self["Cutlist"] = CutList(self.getCutlist())
168                 self["Cutlist"].onSelectionChanged.append(self.selectionChanged)
169                 
170                 self["actions"] = HelpableActionMap(self, "CutListEditorActions",
171                         {
172                                 "setIn": (self.setIn, _("Make this mark an 'in' point")),
173                                 "setOut": (self.setOut, _("Make this mark an 'out' point")),
174                                 "setMark": (self.setMark, _("Make this mark just a mark")),
175                                 "addMark": (self.__addMark, _("Add a mark")),
176                                 "removeMark": (self.__removeMark, _("Remove a mark")),
177                                 "leave": (self.exit, _("Exit editor")),
178                                 "showMenu": self.showMenu,
179                         }, prio=-4)
180                 
181                 self.tutorial_seen = False
182                 
183                 self.onExecBegin.append(self.showTutorial)
184                 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
185                         {
186                                 iPlayableService.evCuesheetChanged: self.refillList
187                         })
188
189                 # to track new entries we save the last version of the cutlist
190                 self.last_cuts = [ ]
191                 self.cut_start = None
192                 
193         def showTutorial(self):
194                 if not self.tutorial_seen:
195                         self.tutorial_seen = True
196                         self.session.open(MessageBox, 
197                                 """Welcome to the Cutlist editor. It's still a bit strange to use, but anyway:
198
199 Seek to the start of the stuff you want to cut away. Press OK, select 'start cut'.
200
201 Then seek to the end, press OK, select 'end cut'. That's it.
202                                 """, MessageBox.TYPE_INFO)
203         
204         def checkSkipShowHideLock(self):
205                 pass
206         
207         def setType(self, index, type):
208                 if len(self.cut_list):
209                         self.cut_list[index] = (self.cut_list[index][0], type)
210                         self["Cutlist"].setIndex(index, CutListEntry(*self.cut_list[index]))
211         
212         def setIn(self):
213                 m = self["Cutlist"].getCurrentIndex()
214                 self.setType(m, 0)
215                 self.uploadCuesheet()
216         
217         def setOut(self):
218                 m = self["Cutlist"].getCurrentIndex()
219                 self.setType(m, 1)
220                 self.uploadCuesheet()
221
222         def setMark(self):
223                 m = self["Cutlist"].getCurrentIndex()
224                 self.setType(m, 2)
225                 self.uploadCuesheet()
226         
227         def __addMark(self):
228                 self.toggleMark(onlyadd=True, tolerance=90000) # do not allow two marks in <1s
229         
230         def __removeMark(self):
231                 m = self["Cutlist"].getCurrent()
232                 m = m and m[0]
233                 if m is not None:
234                         self.removeMark(m)
235         
236         def exit(self):
237                 self.session.nav.playService(self.old_service)
238                 self.close()
239
240         def getCutlist(self):
241                 r = [ ]
242                 for e in self.cut_list:
243                         r.append(CutListEntry(*e))
244                 return r
245
246         def selectionChanged(self):
247                 where = self["Cutlist"].getCurrent()
248                 if where is None:
249                         print "no selection"
250                         return
251                 pts = where[0][0]
252                 seek = self.getSeek()
253                 if seek is None:
254                         print "no seek"
255                         return
256                 seek.seekTo(pts)
257
258         def refillList(self):
259                 print "cue sheet changed, refilling"
260                 self.downloadCuesheet()
261                 
262                 # get the first changed entry, and select it
263                 new_list = self.getCutlist()
264                 self["Cutlist"].setList(new_list)
265                 
266                 for i in range(min(len(new_list), len(self.last_cuts))):
267                         if new_list[i] != self.last_cuts[i]:
268                                 self["Cutlist"].setSelection(i)
269                                 break
270                 self.last_cuts = new_list
271
272         def getStateForPosition(self, pos):
273                 state = 0 # in
274                 
275                 # when first point is "in", the beginning is "out"
276                 if len(self.cut_list) and self.cut_list[0][1] == 0:
277                         state = 1
278
279                 for (where, what) in self.cut_list:
280                         if where < pos:
281                                 if what == 0: # in
282                                         state = 0
283                                 elif what == 1: # out
284                                         state = 1
285                 return state
286
287         def showMenu(self):
288                 curpos = self.cueGetCurrentPosition()
289                 if curpos is None:
290                         return
291                 
292                 self.setSeekState(self.SEEK_STATE_PAUSE)
293                 
294                 self.context_position = curpos
295                 
296                 self.context_nearest_mark = self.toggleMark(onlyreturn=True)
297
298                 cur_state = self.getStateForPosition(curpos)
299                 if cur_state == 0:
300                         print "currently in 'IN'"
301                         if self.cut_start is None or self.context_position < self.cut_start:
302                                 state = CutListContextMenu.SHOW_STARTCUT
303                         else:
304                                 state = CutListContextMenu.SHOW_ENDCUT
305                 else:
306                         print "currently in 'OUT'"
307                         state = CutListContextMenu.SHOW_DELETECUT
308                 
309                 if self.context_nearest_mark is None:
310                         nearmark = False
311                 else:
312                         nearmark = True
313                 
314                 self.session.openWithCallback(self.menuCallback, CutListContextMenu, state, nearmark)
315         
316         def menuCallback(self, *result):
317                 self.setSeekState(self.SEEK_STATE_PLAY)
318                 if not len(result):
319                         return
320                 result = result[0]
321                 
322                 if result == CutListContextMenu.RET_STARTCUT:
323                         self.cut_start = self.context_position
324                 elif result == CutListContextMenu.RET_ENDCUT:
325                         # remove in/out marks between the new cut
326                         for (where, what) in self.cut_list[:]:
327                                 if self.cut_start <= where <= self.context_position and what in [0,1]:
328                                         self.cut_list.remove((where, what))
329                         
330                         bisect.insort(self.cut_list, (self.cut_start, 1))
331                         bisect.insort(self.cut_list, (self.context_position, 0))
332                         self.uploadCuesheet()
333                         self.cut_start = None
334                 elif result == CutListContextMenu.RET_DELETECUT:
335                         out_before = None
336                         in_after = None
337                         
338                         for (where, what) in self.cut_list:
339                                 if what == 1 and where < self.context_position: # out
340                                         out_before = (where, what)
341                                 elif what == 0 and where < self.context_position: # in, before out
342                                         out_before = None
343                                 elif what == 0 and where > self.context_position and in_after is None:
344                                         in_after = (where, what)
345                         
346                         if out_before is not None:
347                                 self.cut_list.remove(out_before)
348                         
349                         if in_after is not None:
350                                 self.cut_list.remove(in_after)
351                         self.uploadCuesheet()
352                 elif result == CutListContextMenu.RET_MARK:
353                         self.__addMark()
354                 elif result == CutListContextMenu.RET_DELETEMARK:
355                         self.cut_list.remove(self.context_nearest_mark)
356                         self.uploadCuesheet()
357                 elif result == CutListContextMenu.RET_REMOVEBEFORE:
358                         # remove in/out marks before current position
359                         for (where, what) in self.cut_list[:]:
360                                 if where <= self.context_position and what in [0,1]:
361                                         self.cut_list.remove((where, what))
362                         # add 'in' point
363                         bisect.insort(self.cut_list, (self.context_position, 0))
364                         self.uploadCuesheet()
365                 elif result == CutListContextMenu.RET_REMOVEAFTER:
366                         # remove in/out marks after current position
367                         for (where, what) in self.cut_list[:]:
368                                 if where >= self.context_position and what in [0,1]:
369                                         self.cut_list.remove((where, what))
370                         # add 'out' point
371                         bisect.insort(self.cut_list, (self.context_position, 1))
372                         self.uploadCuesheet()
373
374 def main(session, service, **kwargs):
375         session.open(CutListEditor, service)
376
377 def Plugins(**kwargs):
378         return PluginDescriptor(name="Cutlist Editor", description=_("Cutlist editor..."), where = PluginDescriptor.WHERE_MOVIELIST, fnc=main)