VideoEnhancement/plugin.py: small skin fix so all options fit into the configlistscreen
[openblackhole/openblackhole-enigma2.git] / lib / python / Plugins / SystemPlugins / VideoEnhancement / plugin.py
1 from Plugins.Plugin import PluginDescriptor
2 from Components.ConfigList import ConfigListScreen
3 from Components.config import getConfigListEntry, config, ConfigNothing, ConfigSelection
4 from Components.ActionMap import ActionMap
5 from Components.Sources.StaticText import StaticText
6 from Screens.Screen import Screen
7 from Screens.MessageBox import MessageBox
8 import VideoEnhancement
9 from os import path as os_path
10
11 class VideoEnhancementSetup(Screen, ConfigListScreen):
12
13         skin = """
14                 <screen name="VideoEnhancementSetup" position="center,center" size="560,440" title="VideoEnhancementSetup">
15                         <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
16                         <ePixmap pixmap="skin_default/buttons/green.png" position="140,0" size="140,40" alphatest="on" />
17                         <ePixmap pixmap="skin_default/buttons/yellow.png" position="280,0" size="140,40" alphatest="on" />
18                         <ePixmap pixmap="skin_default/buttons/blue.png" position="420,0" size="140,40" alphatest="on" />
19                         <widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" />
20                         <widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
21                         <widget source="key_yellow" render="Label" position="280,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" transparent="1" />
22                         <widget source="key_blue" render="Label" position="420,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" transparent="1" />
23                         <widget name="config" position="5,50" size="550,350" scrollbarMode="showOnDemand" />
24                         <ePixmap pixmap="skin_default/div-h.png" position="0,400" zPosition="1" size="560,2" />
25                         <widget source="introduction" render="Label" position="5,410" size="550,30" zPosition="10" font="Regular;21" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
26                 </screen>"""
27
28         def __init__(self, session):
29                 Screen.__init__(self, session)
30
31                 self.session = session
32                 self.onChangedEntry = [ ]
33                 self.setup_title = "Videoenhancement"
34
35                 self.list = [ ]
36                 self.xtdlist = [ ]
37                 ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry)
38
39                 self["actions"] = ActionMap(["SetupActions", "ColorActions"],
40                         {
41                                 "cancel": self.keyCancel,
42                                 "save": self.apply,
43                                 "yellow": self.keyYellow,
44                                 "blue": self.keyBlue,
45                         }, -2)
46
47                 self["key_red"] = StaticText(_("Cancel"))
48                 self["key_green"] = StaticText(_("OK"))
49                 self["key_yellow"] = StaticText(_("Last config"))
50                 self["key_blue"] = StaticText(_("Default"))
51                 self["introduction"] = StaticText()
52
53                 self.createSetup()
54                 self.rememberOldSettings()
55                 self.onLayoutFinish.append(self.layoutFinished)
56
57         def layoutFinished(self):
58                 self.setTitle(_("Video enhancement setup"))
59
60         def rememberOldSettings(self):
61                 self.oldContrast = config.pep.contrast.value
62                 self.oldSaturation = config.pep.saturation.value
63                 self.oldHue = config.pep.hue.value
64                 self.oldBrightness = config.pep.brightness.value
65                 self.oldBlock_noise = config.pep.block_noise_reduction.value
66                 self.oldMosquito_noise = config.pep.mosquito_noise_reduction.value
67                 self.oldDigital_contour = config.pep.digital_contour_removal.value
68                 self.oldScaler_sharpness = config.av.scaler_sharpness.value
69                 self.oldSplit = config.pep.split.value
70                 self.oldSharpness = config.pep.sharpness.value
71                 self.oldAuto_flesh = config.pep.auto_flesh.value
72                 self.oldGreen_boost = config.pep.green_boost.value
73                 self.oldBlue_boost = config.pep.blue_boost.value
74                 self.oldDynamic_contrast = config.pep.dynamic_contrast.value
75
76         def addToConfigList(self, description, configEntry, add_to_xtdlist=False):
77                 if isinstance(configEntry, ConfigNothing):
78                         return None
79                 entry = getConfigListEntry(description, configEntry)
80                 self.list.append(entry);
81                 if add_to_xtdlist:
82                         self.xtdlist.append(entry)
83                 return entry
84
85         def createSetup(self):
86                 self.list = []
87                 self.xtdlist = []
88                 addToConfigList = self.addToConfigList
89                 self.contrastEntry = addToConfigList(_("Contrast"), config.pep.contrast)
90                 self.saturationEntry = addToConfigList(_("Saturation"), config.pep.saturation)
91                 self.hueEntry = addToConfigList(_("Hue"), config.pep.hue)
92                 self.brightnessEntry = addToConfigList(_("Brightness"), config.pep.brightness)
93                 self.scaler_sharpnessEntry = addToConfigList(_("Scaler sharpness"), config.av.scaler_sharpness)
94                 self.splitEntry = addToConfigList(_("Split preview mode"), config.pep.split, True)
95                 add_to_xtdlist = self.splitEntry is not None
96                 self.sharpnessEntry = addToConfigList(_("Sharpness"), config.pep.sharpness, add_to_xtdlist)
97                 self.auto_fleshEntry = addToConfigList(_("Auto flesh"), config.pep.auto_flesh, add_to_xtdlist)
98                 self.green_boostEntry = addToConfigList(_("Green boost"), config.pep.green_boost, add_to_xtdlist)
99                 self.blue_boostEntry = addToConfigList(_("Blue boost"), config.pep.blue_boost, add_to_xtdlist)
100                 self.dynamic_contrastEntry = addToConfigList(_("Dynamic contrast"), config.pep.dynamic_contrast, add_to_xtdlist)
101                 self.block_noise_reductionEntry = addToConfigList(_("Block noise reduction"), config.pep.block_noise_reduction, add_to_xtdlist)
102                 self.mosquito_noise_reductionEntry = addToConfigList(_("Mosquito noise reduction"), config.pep.mosquito_noise_reduction, add_to_xtdlist)
103                 self.digital_contour_removalEntry = addToConfigList(_("Digital contour removal"), config.pep.digital_contour_removal, add_to_xtdlist)
104
105                 self["config"].list = self.list
106                 self["config"].l.setSeperation(300)
107                 self["config"].l.setList(self.list)
108                 if not self.selectionChanged in self["config"].onSelectionChanged:
109                         self["config"].onSelectionChanged.append(self.selectionChanged)
110                 self.selectionChanged()
111
112         def selectionChanged(self):
113                 self["introduction"].setText(_("Current value: ") + self.getCurrentValue())
114
115         def PreviewClosed(self):
116                 self["config"].invalidate(self["config"].getCurrent())
117                 self.createSetup()
118
119         def keyLeft(self):
120                 current = self["config"].getCurrent()
121                 if current == self.splitEntry:
122                         ConfigListScreen.keyLeft(self)
123                 elif current != self.splitEntry and current in self.xtdlist:
124                         self.previewlist = [
125                                 current,
126                                 self.splitEntry
127                         ]
128                         maxvalue = current[1].max
129                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist, oldSplitMode = config.pep.split.value, maxValue = maxvalue)
130                 else:
131                         self.previewlist = [
132                                 current
133                         ]
134                         maxvalue = current[1].max
135                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist, oldSplitMode = None, maxValue = maxvalue)
136
137         def keyRight(self):
138                 current = self["config"].getCurrent()
139                 if current == self.splitEntry:
140                         ConfigListScreen.keyRight(self)
141                 elif current != self.splitEntry and current in self.xtdlist:
142                         self.previewlist = [
143                                 current,
144                                 self.splitEntry
145                         ]
146                         maxvalue = current[1].max
147                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist, oldSplitMode = config.pep.split.value, maxValue = maxvalue )
148                 else:
149                         self.previewlist = [
150                                 current
151                         ]
152                         maxvalue = current[1].max
153                         self.session.openWithCallback(self.PreviewClosed, VideoEnhancementPreview, configEntry = self.previewlist, oldSplitMode = None, maxValue = maxvalue)
154
155         def confirm(self, confirmed):
156                 if not confirmed:
157                         print "not confirmed"
158                 else:
159                         if self.splitEntry is not None:
160                                 config.pep.split.setValue('off')
161                         self.keySave()
162
163         def apply(self):
164                 self.session.openWithCallback(self.confirm, MessageBox, _("Use this video enhancement settings?"), MessageBox.TYPE_YESNO, timeout = 20, default = False)
165
166         def cancelConfirm(self, result):
167                 if not result:
168                         return
169                 self.keyYellowConfirm(True)
170                 self.close()
171
172         def keyCancel(self):
173                 if self["config"].isChanged():
174                         self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
175                 else:
176                         self.close()
177
178         def keyYellowConfirm(self, confirmed):
179                 if not confirmed:
180                         print "not confirmed"
181                 else:
182                         if self.contrastEntry is not None:
183                                 config.pep.contrast.setValue(self.oldContrast)
184                         if self.saturationEntry is not None:
185                                 config.pep.saturation.setValue(self.oldSaturation)
186                         if self.hueEntry is not None:
187                                 config.pep.hue.setValue(self.oldHue)
188                         if self.brightnessEntry is not None:
189                                 config.pep.brightness.setValue(self.oldBrightness)
190                         if self.block_noise_reductionEntry is not None:
191                                 config.pep.block_noise_reduction.setValue(self.oldBlock_noise)
192                         if self.mosquito_noise_reductionEntry is not None:
193                                 config.pep.mosquito_noise_reduction.setValue(self.oldMosquito_noise)
194                         if self.digital_contour_removalEntry is not None:
195                                 config.pep.digital_contour_removal.setValue(self.oldDigital_contour)
196                         if self.scaler_sharpnessEntry is not None:
197                                 config.av.scaler_sharpness.setValue(self.oldScaler_sharpness)
198                         if self.splitEntry is not None:
199                                 config.pep.split.setValue('off')
200                         if self.sharpnessEntry is not None:
201                                 config.pep.sharpness.setValue(self.oldSharpness)
202                         if self.auto_fleshEntry is not None:
203                                 config.pep.auto_flesh.setValue(self.oldAuto_flesh)
204                         if self.green_boostEntry is not None:
205                                 config.pep.green_boost.setValue(self.oldGreen_boost)
206                         if self.blue_boostEntry is not None:
207                                 config.pep.blue_boost.setValue(self.oldBlue_boost)
208                         if self.dynamic_contrastEntry is not None:
209                                 config.pep.dynamic_contrast.setValue(self.oldDynamic_contrast)
210                         self.keySave()
211
212         def keyYellow(self):
213                 self.session.openWithCallback(self.keyYellowConfirm, MessageBox, _("Reset video enhancement settings to your last configuration?"), MessageBox.TYPE_YESNO, timeout = 20, default = False)
214
215         def keyBlueConfirm(self, confirmed):
216                 if not confirmed:
217                         print "not confirmed"
218                 else:
219                         if self.contrastEntry is not None:
220                                 config.pep.contrast.setValue(128)
221                         if self.saturationEntry is not None:
222                                 config.pep.saturation.setValue(128)
223                         if self.hueEntry is not None:
224                                 config.pep.hue.setValue(128)
225                         if self.brightnessEntry is not None:
226                                 config.pep.brightness.setValue(128)
227                         if self.block_noise_reductionEntry is not None:
228                                 config.pep.block_noise_reduction.setValue(0)
229                         if self.mosquito_noise_reductionEntry is not None:
230                                 config.pep.mosquito_noise_reduction.setValue(0)
231                         if self.digital_contour_removalEntry is not None:
232                                 config.pep.digital_contour_removal.setValue(0)
233                         if self.scaler_sharpnessEntry is not None:
234                                 config.av.scaler_sharpness.setValue(13)
235                         if self.splitEntry is not None:
236                                 config.pep.split.setValue('off')
237                         if self.sharpnessEntry is not None:
238                                 config.pep.sharpness.setValue(0)
239                         if self.auto_fleshEntry is not None:
240                                 config.pep.auto_flesh.setValue(0)
241                         if self.green_boostEntry is not None:
242                                 config.pep.green_boost.setValue(0)
243                         if self.blue_boostEntry is not None:
244                                 config.pep.blue_boost.setValue(0)
245                         if self.dynamic_contrastEntry is not None:
246                                 config.pep.dynamic_contrast.setValue(0)
247                         self.keySave()
248
249         def keyBlue(self):
250                 self.session.openWithCallback(self.keyBlueConfirm, MessageBox, _("Reset video enhancement settings to system defaults?"), MessageBox.TYPE_YESNO, timeout = 20, default = False)
251
252         # for summary:
253         def changedEntry(self):
254                 for x in self.onChangedEntry:
255                         x()
256                 self.selectionChanged()
257
258         def getCurrentEntry(self):
259                 return self["config"].getCurrent()[0]
260
261         def getCurrentValue(self):
262                 return str(self["config"].getCurrent()[1].getText())
263
264         def createSummary(self):
265                 from Screens.Setup import SetupSummary
266                 return SetupSummary
267
268
269 class VideoEnhancementPreview(Screen, ConfigListScreen):
270
271         skin = """
272                 <screen name="VideoEnhancementPreview" position="center,360" size="560,170" title="VideoEnhancementPreview">
273                         <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
274                         <ePixmap pixmap="skin_default/buttons/green.png" position="140,0" size="140,40" alphatest="on" />
275                         <widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" />
276                         <widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
277                         <widget name="config" position="5,50" size="550,80" scrollbarMode="showOnDemand" />
278                         <ePixmap pixmap="skin_default/div-h.png" position="0,130" zPosition="1" size="560,2" />
279                         <widget source="introduction" render="Label" position="0,140" size="550,25" zPosition="10" font="Regular;21" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
280                 </screen>"""
281
282         def __init__(self, session, configEntry = None, oldSplitMode = None, maxValue = None):
283                 Screen.__init__(self, session)
284
285                 self.onChangedEntry = [ ]
286                 self.setup_title = "Videoenhancement"
287                 self.oldSplitMode = oldSplitMode
288                 self.maxValue = maxValue
289                 self.configStepsEntry = None
290                 self.isStepSlider = None
291
292                 self.list = [ ]
293                 self.configEntry = configEntry
294                 ConfigListScreen.__init__(self, self.list, session = session, on_change = self.changedEntry)
295
296                 self["actions"] = ActionMap(["SetupActions"],
297                         {
298                                 "cancel": self.keyCancel,
299                                 "save": self.keySave,
300                         }, -2)
301
302                 self["key_red"] = StaticText(_("Cancel"))
303                 self["key_green"] = StaticText(_("OK"))
304                 self["introduction"] = StaticText()
305
306                 self.createSetup()
307                 self.onLayoutFinish.append(self.layoutFinished)
308
309         def layoutFinished(self):
310                 self.setTitle(_("Video enhancement preview"))
311
312         def createSetup(self):
313                 self.list = [ ]
314                 if self.maxValue == 256:
315                         self.configStepsEntry = getConfigListEntry(_("Change step size"), config.pep.configsteps)
316
317                 if self.configEntry is not None:
318                         self.list = self.configEntry
319                 if self.maxValue == 256:
320                         self.list.append(self.configStepsEntry)
321
322                 self["config"].list = self.list
323                 self["config"].l.setSeperation(300)
324                 self["config"].l.setList(self.list)
325                 if not self.selectionChanged in self["config"].onSelectionChanged:
326                         self["config"].onSelectionChanged.append(self.selectionChanged)
327                 self.selectionChanged()
328
329         def selectionChanged(self):
330                 self["introduction"].setText(_("Current value: ") + self.getCurrentValue())
331                 try:
332                         max_avail=self["config"].getCurrent()[1].max
333                         if max_avail == 256:
334                                 self.isStepSlider = True
335                         else:
336                                 self.isStepSlider = False
337                 except AttributeError:
338                         print "no max value"
339
340         def keyLeft(self):
341                 if self.isStepSlider is True:
342                         self["config"].getCurrent()[1].increment = config.pep.configsteps.value
343                 ConfigListScreen.keyLeft(self)
344
345         def keyRight(self):
346                 if self.isStepSlider is True:
347                         self["config"].getCurrent()[1].increment = config.pep.configsteps.value
348                 ConfigListScreen.keyRight(self)
349
350         def keySave(self):
351                 if self.oldSplitMode is not None:
352                         currentSplitMode = config.pep.split.value
353                         if self.oldSplitMode == 'off' and currentSplitMode != 'off':
354                                 config.pep.split.setValue('off')
355                         else:
356                                 pass
357                 self.close()
358
359         def keyCancel(self):
360                 for x in self["config"].list:
361                         x[1].cancel()
362                 if self.oldSplitMode is not None:
363                         currentSplitMode = config.pep.split.value
364                         if self.oldSplitMode == 'off' and currentSplitMode != 'off':
365                                 config.pep.split.setValue('off')
366                         else:
367                                 pass
368                 self.close()
369
370         # for summary:
371         def changedEntry(self):
372                 for x in self.onChangedEntry:
373                         x()
374                 self.selectionChanged()
375
376         def getCurrentEntry(self):
377                 return self["config"].getCurrent()[0]
378
379         def getCurrentValue(self):
380                 return str(self["config"].getCurrent()[1].getText())
381
382         def createSummary(self):
383                 from Screens.Setup import SetupSummary
384                 return SetupSummary
385
386 def videoEnhancementSetupMain(session, **kwargs):
387         session.open(VideoEnhancementSetup)
388
389 def startSetup(menuid):
390         if menuid != "system":
391                 return [ ]
392         return [(_("Video enhancement settings") , videoEnhancementSetupMain, "videoenhancement_setup", 41)]
393
394 def Plugins(**kwargs):
395         list = []
396         if config.usage.setup_level.index >= 2 and os_path.exists("/proc/stb/vmpeg/0/pep_apply"):
397                 list.append(PluginDescriptor(name=_("Videoenhancement Setup"), description=_("Advanced Video Enhancement Setup"), where = PluginDescriptor.WHERE_MENU, fnc=startSetup))
398         return list