def showMainHelp(session, **kwargs):
    try:
        if XMLConfigMainHelp:
            XMLConfigMainHelp.open(session)
    except:
        getGeneralLogger().printOut("showMainHelp-Error:\n%s" %
                                    str(format_exc()),
                                    level=ERROR_LEVEL)
    def __init__(self, xmlFilePath, xmlNodeName, objectClass, objectEditorClass = None, \
      objectSelectClass = None, supportName = None, loggerInstance = None, \
      objectSingular = "", objectSingularArticle = "", \
      objectPlural = "", objectPluralArticle = ""):
        self.lastConfigMtime = -1
        self.writeXMLNeeded = False
        self.objectOperationForbidden = False
        self.objects = {}
        self.objectClass = objectClass
        self.objectEditor = objectEditorClass
        self.objectSelect = objectSelectClass
        self.xmlNode = xmlNodeName
        self.XML_CONFIG = xmlFilePath
        self.xmlBool = {}

        self.objectSingular = objectSingular
        self.objectSingularArticle = objectSingularArticle
        self.objectPlural = objectPlural
        self.objectPluralArticle = objectPluralArticle

        self.log = loggerInstance
        if self.log == None:
            self.log = getGeneralLogger(additionalPrefix=supportName)

        # Defaults
        self.adjustBoolString("yes", "no")
 def selectionChanged():
     current = self["config"].getCurrent()
     if self["config"].current != current:
         if self["config"].current:
             self["config"].current[1].onDeselect(self.session)
         self["config"].current = current
         if current:
             current[1].onSelect(self.session)
     for x in self["config"].onSelectionChanged:
         try:
             x()
         except:
             if "log" in self:
                 self.log.printOut(
                     "overwritten-selectionChanged-Error:\n%s" %
                     (str(format_exc())),
                     level=ERROR_LEVEL)
             else:
                 getGeneralLogger().printOut(
                     "overwritten-selectionChanged-Error:\n%s" %
                     (str(format_exc())),
                     level=ERROR_LEVEL)
    def __init__(self, session, xmlConfigSupportInstance, configObject = None, \
      isUpdating = False, objectName = "", loggerInstance = None):
        try:
            self.log = loggerInstance
            if self.log == None:
                self.log = getGeneralLogger()

            Screen.__init__(self, session)

            self.objectSupport = xmlConfigSupportInstance
            if configObject == None:
                configObject = self.objectSupport.objectClass()

            self.isUpdating = isUpdating if isUpdating != None else False
            self.object = configObject
            self.objectName = objectName
            """ Summary
				set the setup_title in your inherited class 
			"""
            self.setup_title = "Config-Object Editor"
            self.onChangedEntry = []

            self.list = []
            ConfigListScreen.__init__(self,
                                      self.list,
                                      session=self.session,
                                      on_change=self.changed)

            # Override selectionChanged --> normally the config tuples have a size bigger than 2
            def selectionChanged():
                current = self["config"].getCurrent()
                if self["config"].current != current:
                    if self["config"].current:
                        self["config"].current[1].onDeselect(self.session)
                    self["config"].current = current
                    if current:
                        current[1].onSelect(self.session)
                for x in self["config"].onSelectionChanged:
                    try:
                        x()
                    except:
                        if "log" in self:
                            self.log.printOut(
                                "overwritten-selectionChanged-Error:\n%s" %
                                (str(format_exc())),
                                level=ERROR_LEVEL)
                        else:
                            getGeneralLogger().printOut(
                                "overwritten-selectionChanged-Error:\n%s" %
                                (str(format_exc())),
                                level=ERROR_LEVEL)

            self["config"].selectionChanged = selectionChanged
            # other handling
            self["config"].onSelectionChanged.append(self.selectionChanged)

            self["warning"] = StaticText()

            self["key_red"] = StaticText(_("Cancel"))
            self["key_green"] = StaticText(_("OK"))
            self["key_yellow"] = StaticText()
            self["keyYellowIcon"] = Pixmap()
            self["key_blue"] = StaticText()
            self["keyBlueIcon"] = Pixmap()

            self["help"] = StaticText()
            self["LeftIcon"] = Pixmap()
            self["RightIcon"] = Pixmap()
            self["VKeyIcon"] = Pixmap()
            self["HelpWindow"] = Pixmap()
            self["LeftIcon"].hide()
            self["RightIcon"].hide()
            self["VKeyIcon"].hide()
            self["VirtualKB"].setEnabled(False)
            self["HelpWindow"].hide()
            self["additionalIconLabel"] = StaticText()
            self["additionalIcon"] = Pixmap()
            self["additionalIcon"].hide()

            self["ColorActions"] = HelpableActionMap(
                self,
                "ColorActions",
                {
                    "red": (self.keyCancel, _("Close and forget changes")),
                    "green": (self.keySave, _("Close and save changes")),
                },
            )
            self["SetupActions"] = HelpableActionMap(
                self,
                "SetupActions",
                {
                    "cancel": (self.keyCancel, _("Close and forget changes")),
                },
            )
            self["ChannelSelectBaseActions"] = HelpableActionMap(
                self,
                "ChannelSelectBaseActions",
                {
                    "nextBouquet": (self.pageup, _("Move page up")),
                    "prevBouquet": (self.pagedown, _("Move page down")),
                },
            )

            self["HelpActions"] = ActionMap(["HelpActions"], {
                "displayHelp": self.showKeyHelp,
            })

            self.createSetup(self.object)
            self.getConfig()
            self.configureBlueButton()
            self.configureYellowButton()

            # Trigger change
            self.changed()

            self.onLayoutFinish.append(self.setCustomTitle)
        except:
            if "log" in self:
                self.log.printOut("ConfigObject-Editor-Init-Error:\n%s" %
                                  (str(format_exc())),
                                  level=ERROR_LEVEL)
            else:
                getGeneralLogger().printOut(
                    "ConfigObject-Editor-Init-Error:\n%s" %
                    (str(format_exc())),
                    level=ERROR_LEVEL)
            self.close(None)
    def __init__(self,
                 session,
                 xmlConfigSupportInstance,
                 configObjectListClass,
                 loggerInstance=None):
        try:
            Screen.__init__(self, session)
            HelpableScreen.__init__(self)

            self.log = loggerInstance
            if self.log == None:
                self.log = getGeneralLogger()

            self.objectSupport = xmlConfigSupportInstance
            self.objectSupport.objectOperationForbidden = True

            self.lastXmlDir = None
            self.changed = False

            # Button Labels
            self["key_red"] = StaticText(_("Delete"))
            self["key_green"] = StaticText(_("Save"))
            self["key_yellow"] = StaticText(_("Add"))

            # Create List of Entries, named config for summary
            self["config"] = configObjectListClass(self.objectSupport.getSortedTupleList(), \
             loggerInstance = self.log)

            self["info"] = StaticText()
            self["warning"] = StaticText()
            """ Summary
				set the setup_title in your inherited class 
			"""
            self.setup_title = "ConfigObjectOverview"
            self.onChangedEntry = []
            self["config"].onSelectionChanged.append(self.selectionChanged)

            # Define Actions
            self["OkCancelActions"] = HelpableActionMap(
                self, "OkCancelActions", {
                    "ok": (self.ok, _("Edit %s") %
                           (self.objectSupport.objectSingular)),
                    "cancel": (self.cancel, _("Close and forget changes")),
                })

            self["MenuActions"] = HelpableActionMap(
                self, "MenuActions",
                {"menu": (self.menu, _("Open Context Menu"))})

            self["ChannelSelectBaseActions"] = HelpableActionMap(
                self,
                "ChannelSelectBaseActions",
                {
                    "nextBouquet": (self.pageup, _("Move page up")),
                    "prevBouquet": (self.pagedown, _("Move page down")),
                },
            )

            self["HelpActions"] = ActionMap(["HelpActions"], {
                "displayHelp": self.showKeyHelp,
            })
            self["DirectionActions"] = HelpableActionMap(
                self, "DirectionActions", {
                    "leftUp": (self.pageup, _("Move page up")),
                    "rightUp": (self.pagedown, _("Move page down")),
                    "up": (self["config"].up, _("Move up")),
                    "down": (self.keyDown, _("Move down")),
                }, -3)

            self["ColorActions"] = HelpableActionMap(
                self, "ColorActions", {
                    "red": (self.remove, _("Remove %s") %
                            (self.objectSupport.objectSingular)),
                    "green": (self.save, _("Close and save changes")),
                    "yellow": (self.add, _("Add new Entry")),
                })
            """
				manipulate or extend this list for own entries
				use getBaseMenuCB() or extend menuCallback() to react
			"""
            self.menulist = [
                (_("Export %s-Configuration") %
                 (self.objectSupport.objectPlural),
                 self.CONST_MENU_XMLTOOL_EXPORT),
                (_("Import %s-Configuration") %
                 (self.objectSupport.objectPlural),
                 self.CONST_MENU_XMLTOOL_IMPORT),
                ("--", None),
                (_("Show Help"), self.CONST_MENU_XMLTOOL_HELP),
            ]

            self.onLayoutFinish.append(self.setCustomTitle)
            self.onClose.append(self.onCloseAction)
        except:
            if self.log:
                self.log.printOut("ConfigObjectOverview-Init-Error:\n%s" %
                                  (str(format_exc())),
                                  level=ERROR_LEVEL)
            else:
                getGeneralLogger().printOut(
                    "ConfigObjectOverview-Init-Error:\n%s" %
                    (str(format_exc())),
                    level=ERROR_LEVEL)
            self.close()
    def __init__(self, session, xmlConfigSupportInstance, availableObjects, preSelectedObjects = None, \
       windowTitle = None, filterBtnEnabled = True, showDisabled = True, loggerInstance = None):
        try:
            Screen.__init__(self, session)

            self.log = loggerInstance
            if self.log == None:
                self.log = getGeneralLogger()

            self.objectSupport = xmlConfigSupportInstance
            self.selectedObjects = {}
            if preSelectedObjects != None:
                for object in preSelectedObjects:
                    self.selectedObjects[object.key] = object
            self.availableObjects = availableObjects
            self.allSelected = False
            if len(self.selectedObjects) == len(self.availableObjects):
                self.allSelected = True
            self.showDisabled = showDisabled
            self.filterBtnEnabled = filterBtnEnabled
            if not self.filterBtnEnabled:
                self.showDisabled = True
            self.windowTitle = windowTitle

            self["key_red"] = StaticText(_("Cancel"))
            self["key_green"] = StaticText(_("OK"))
            self["key_yellow"] = StaticText()
            self["keyYellowIcon"] = Pixmap()
            self["key_blue"] = StaticText()
            self["keyBlueIcon"] = Pixmap()

            self["list"] = SelectionList(None, enableWrapAround=True)

            self["actions"] = ActionMap(
                ["OkCancelActions", "ColorActions"], {
                    "ok": self.toggleSelection,
                    "cancel": self.close,
                    "red": self.close,
                    "green": self.keyClose,
                    "yellow": self.toggleAll,
                }, -5)
            self["filteractions"] = ActionMap(["ColorActions"], {
                "blue": self.toggleFilter,
            }, -5)

            self.setSelection()
            self.setFilterButton()
            self.setAllButton()

            self.onLayoutFinish.append(self.setCustomTitle)
        except:
            if "log" in self:
                self.log.printOut("ConfigObject-Select-Init-Error:\n%s" %
                                  (str(format_exc())),
                                  level=ERROR_LEVEL)
            else:
                getGeneralLogger().printOut(
                    "ConfigObject-Select-Init-Error:\n%s" %
                    (str(format_exc())),
                    level=ERROR_LEVEL)
            self.close()
from XMLConfigTools import ERROR_LEVEL, WARN_LEVEL, DEBUG_LEVEL, getGeneralLogger
from traceback import format_exc

from . import _

XMLConfigHelpfile = None
XMLConfigMainHelp = None
try:
    from Plugins.SystemPlugins.MPHelp import registerHelp, XMLHelpReader

    XMLConfigHelpfile = resolveFilename(
        SCOPE_PLUGINS, "SystemPlugins/xmlConfigTool") + "/mphelp.xml"
    reader = XMLHelpReader(XMLConfigHelpfile)
    XMLConfigMainHelp = registerHelp(*reader)
except:
    getGeneralLogger().printOut("Help-Init-Error:\n%s" % str(format_exc()),
                                level=ERROR_LEVEL)


def showMainHelp(session, **kwargs):
    try:
        if XMLConfigMainHelp:
            XMLConfigMainHelp.open(session)
    except:
        getGeneralLogger().printOut("showMainHelp-Error:\n%s" %
                                    str(format_exc()),
                                    level=ERROR_LEVEL)


def Plugins(**kwargs):
    return [
        PluginDescriptor(name=_("XML-Config-Tool"),