fix imports
[enigma2.git] / lib / python / Screens / NetworkSetup.py
index 505d508f5423f2fa27b3bac4295f7b6dfad8cc29..9514e7fd43a15e3f03e975791cdab6d5f615b44f 100644 (file)
 from Screen import Screen
 from Components.ActionMap import ActionMap
-from Components.ConfigList import ConfigList
-from Components.config import config
-from Components.config import getConfigListEntry
+from Components.ConfigList import ConfigListScreen
+from Components.config import config, getConfigListEntry
 from Components.Network import iNetwork
+from Components.Label import Label
+from Components.MenuList import MenuList
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigNothing
+from Components.PluginComponent import plugins
+from Plugins.Plugin import PluginDescriptor
 
-class NetworkSetup(Screen):
-    def __init__(self, session):
-        Screen.__init__(self, session)
-        
-        self["actions"] = ActionMap(["SetupActions"],
-        {
-            "ok": self.keySave,
-            "cancel": self.keyCancel,
-            "left": self.keyLeft,
-            "right": self.keyRight,
-            "1": self.keyNumber1,
-            "2": self.keyNumber2,
-            "3": self.keyNumber3,
-            "4": self.keyNumber4,
-            "5": self.keyNumber5,
-            "6": self.keyNumber6,
-            "7": self.keyNumber7,
-            "8": self.keyNumber8,
-            "9": self.keyNumber9,
-            "0": self.keyNumber0
-        }, -1)
-
-        self.list = []
-        self["config"] = ConfigList(self.list)
-        self.createSetup()
-        
-    def createSetup(self):
-        self.list = []
-        
-        self.list.append(getConfigListEntry("Use DHCP", config.network.dhcp))
-        if (config.network.dhcp.value == 0):
-            self.list.append(getConfigListEntry("IP Address", config.network.ip))
-            self.list.append(getConfigListEntry("Netmask", config.network.netmask))
-            self.list.append(getConfigListEntry("Gateway", config.network.gateway))
-            self.list.append(getConfigListEntry("Nameserver", config.network.dns))
-        
-        self["config"].list = self.list
-        self["config"].l.setList(self.list)
-        
-    def newConfig(self):
-        print self["config"].getCurrent()
-        if self["config"].getCurrent()[0] == "Use DHCP":
-            self.createSetup()
-
-    def keyLeft(self):
-        self["config"].handleKey(config.key["prevElement"])
-        self.newConfig()
-
-    def keyRight(self):
-        self["config"].handleKey(config.key["nextElement"])
-        self.newConfig()
-    
-    def keyNumberGlobal(self, number):
-        print "You pressed number " + str(number)
-        if (self["config"].getCurrent()[1].parent.enabled == True):
-            self["config"].handleKey(config.key[str(number)])
-        
-    def keyNumber1(self):
-        self.keyNumberGlobal(1)
-    def keyNumber2(self):
-        self.keyNumberGlobal(2)
-    def keyNumber3(self):
-        self.keyNumberGlobal(3)
-    def keyNumber4(self):
-        self.keyNumberGlobal(4)
-    def keyNumber5(self):
-        self.keyNumberGlobal(5)
-    def keyNumber6(self):
-        self.keyNumberGlobal(6)
-    def keyNumber7(self):
-        self.keyNumberGlobal(7)
-    def keyNumber8(self):
-        self.keyNumberGlobal(8)
-    def keyNumber9(self):
-        self.keyNumberGlobal(9)
-    def keyNumber0(self):
-        self.keyNumberGlobal(0)        
-
-    def keySave(self):
-        #for x in self["config"].list:
-            #x[1].save()
+
+class NetworkAdapterSelection(Screen):
+       def __init__(self, session):
+               Screen.__init__(self, session)
+               
+               self["adapterlist"] = MenuList(iNetwork.getAdapterList())
+               
+               self["actions"] = ActionMap(["OkCancelActions"],
+               {
+                       "ok": self.okbuttonClick ,
+                       "cancel": self.close
+               })
+
+       def okbuttonClick(self):
+               selection = self["adapterlist"].getCurrent()
+               print "selection:", selection
+               if selection is not None:
+                       self.session.open(AdapterSetup, selection)
+                       
+class NameserverSetup(Screen, ConfigListScreen):
+       def __init__(self, session):
+               Screen.__init__(self, session)
+               self.backupNameserverList = iNetwork.getNameserverList()[:]
+               print "backup-list:", self.backupNameserverList
+               
+               self["red"] = Label(_("Delete"))
+               self["green"] = Label(_("Add"))
+               
+               self.createConfig()
+               
+               self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
+               {
+                       "ok": self.ok,
+                       "cancel": self.cancel,
+                       "green": self.add,
+                       "red": self.remove
+               }, -2)
+
+               self.list = []
+               ConfigListScreen.__init__(self, self.list)
+               self.createSetup()
+               
+       def createConfig(self):
+               self.nameservers = iNetwork.getNameserverList()
+               self.nameserverEntries = []
+               
+               for nameserver in self.nameservers:
+                       self.nameserverEntries.append(NoSave(ConfigIP(default=nameserver)))
+                       
+       def createSetup(self):
+               self.list = []
+
+               #self.nameserverConfigEntries = []
+               for i in range(len(self.nameserverEntries)):
+                       self.list.append(getConfigListEntry(_("Nameserver %d") % (i + 1), self.nameserverEntries[i]))
+               
+               self["config"].list = self.list
+               self["config"].l.setList(self.list)
+
+       def ok(self):
+               iNetwork.clearNameservers()
+               for nameserver in self.nameserverEntries:
+                       iNetwork.addNameserver(nameserver.value)
+               iNetwork.writeNameserverConfig()
+               self.close()
+       
+       def cancel(self):
+               iNetwork.clearNameservers()
+               print "backup-list:", self.backupNameserverList
+               for nameserver in self.backupNameserverList:
+                       iNetwork.addNameserver(nameserver)
+               self.close()
+       
+       def add(self):
+               iNetwork.addNameserver([0,0,0,0])
+               self.createConfig()
+               self.createSetup()
+       
+       def remove(self):
+               print "currentIndex:", self["config"].getCurrentIndex()
+               
+               index = self["config"].getCurrentIndex()
+               if index < len(self.nameservers):
+                       iNetwork.removeNameserver(self.nameservers[index])
+                       self.createConfig()
+                       self.createSetup()
+
+               
+class AdapterSetup(Screen, ConfigListScreen):
+       def __init__(self, session, iface):
+               Screen.__init__(self, session)
+               
+               self.iface = iface
+
+               print iNetwork.getAdapterAttribute(self.iface, "dhcp")
+               self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp")))
+               self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=True))
+               self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")))
+               self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask")))
+               self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway")))
         
-        iNetwork.writeNetworkConfig()    
-        iNetwork.activateNetworkConfig()
-        self.close()
-
-    def keyCancel(self):
-        for x in self["config"].list:
-            x[1].cancel()
-        iNetwork.loadNetworkConfig()
-        self.close()
\ No newline at end of file
+               self["iface"] = Label(iNetwork.getAdapterName(self.iface))
+                       
+               self["actions"] = ActionMap(["SetupActions"],
+               {
+                       "ok": self.ok,
+                       "cancel": self.cancel,
+               }, -2)
+
+               self.list = []
+               ConfigListScreen.__init__(self, self.list)
+               self.createSetup()
+
+               self["introduction"] = Label(_("Press OK to activate the settings."))
+
+       def createSetup(self):
+               self.list = []
+
+               self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
+               self.list.append(self.dhcpEntry)
+               if not self.dhcpConfigEntry.value:
+                       self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
+                       self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
+                       self.list.append(getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry))
+                       if self.hasGatewayConfigEntry.value:
+                               self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
+               
+               self.extended = None
+               self.extendedSetup = None
+               for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
+                       callFnc = p.__call__["ifaceSupported"](self.iface)
+                       if callFnc is not None:
+                               self.extended = callFnc
+                               print p.__call__
+                               if p.__call__.has_key("configStrings"):
+                                       self.configStrings = p.__call__["configStrings"]
+                               else:
+                                       self.configStrings = None
+                               
+                               if p.__call__.has_key("menuEntryName"):
+                                       menuEntryName = p.__call__["menuEntryName"](self.iface)
+                               else:
+                                       menuEntryName = _('Extended Setup...')
+                               self.extendedSetup = getConfigListEntry(menuEntryName, NoSave(ConfigNothing()))
+                               self.list.append(self.extendedSetup)
+
+               self["config"].list = self.list
+               self["config"].l.setList(self.list)
+
+       def newConfig(self):
+               print self["config"].getCurrent()
+               if self["config"].getCurrent() == self.dhcpEntry:
+                       self.createSetup()
+
+       def keyLeft(self):
+               ConfigListScreen.keyLeft(self)
+               self.createSetup()
+
+       def keyRight(self):
+               ConfigListScreen.keyRight(self)
+               self.createSetup()
+
+       def ok(self):
+               selection = self["config"].getCurrent()
+               if selection == self.extendedSetup:
+                       self.extended(self.session, self.iface)
+               else:
+                       iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
+                       iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
+                       iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
+                       if self.hasGatewayConfigEntry.value:
+                               iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
+                       else:
+                               iNetwork.removeAdapterAttribute(self.iface, "gateway")
+                       
+                       if self.extended is not None and self.configStrings is not None:
+                               iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
+
+                       iNetwork.deactivateNetworkConfig()
+                       iNetwork.writeNetworkConfig()    
+                       iNetwork.activateNetworkConfig()
+                       self.close()
+
+       def cancel(self):
+               iNetwork.getInterfaces()
+               self.close()