def is_wired_setting_ok(self, info_dict):
        if info_dict["connection"]["type"] != "802-3-ethernet":
            return False
        else:
            if not self.check_conn_setting(info_dict):
                return False

            if not self.check_ip4_setting(info_dict):
                return False

            if "mac-address" in info_dict["802-3-ethernet"].keys():
                if not TypeConvert.is_valid_mac_address(
                    TypeConvert.mac_address_array2string(info_dict["802-3-ethernet"]["mac-address"])
                ):
                    print "wired invalid mac address"
                    return False

            if "cloned-mac-address" in info_dict["802-3-ethernet"].keys():
                if not TypeConvert.is_valid_mac_address(
                    TypeConvert.mac_address_array2string(info_dict["802-3-ethernet"]["mac-address"])
                ):
                    print "wired invalid clone mac address"
                    return False

            if "duplex" in info_dict["802-3-ethernet"].keys():
                if info_dict["802-3-ethernet"]["duplex"] not in ["full", "half"]:
                    print "wired invalid duplex"
                    return False
        return True

 def check_valid(self, name):
     if name == "ip4":
         return TypeConvert.is_valid_ip4(self.ip[0])
     elif name == "netmask":
         return TypeConvert.is_valid_netmask(self.ip[1])
     elif name == "gw":
         return TypeConvert.is_valid_gw(self.ip[0], self.ip[1], self.ip[2])

 def set_wep_key(self, idx, key):
     if idx == 0:
         self.prop_dict["wep-key0"] = TypeConvert.py2_dbus_string(key)
     elif idx == 1:
         self.prop_dict["wep-key1"] = TypeConvert.py2_dbus_string(key)
     elif idx == 2:
         self.prop_dict["wep-key2"] = TypeConvert.py2_dbus_string(key)
     elif idx == 3:
         self.prop_dict["wep-key3"] = TypeConvert.py2_dbus_string(key)
     else:
         print "invalid idx"

    def check_setting_finish(self):
        ###check if user complete his setting, avoid the missing property exception
        info_dict = TypeConvert.dbus2py(self.settings_dict)
        try:
            if info_dict["connection"]["type"] == "802-3-ethernet":
                return self.is_wired_setting_ok(info_dict)

            elif info_dict["connection"]["type"] == "802-11-wireless":
                return self.is_wireless_setting_ok(info_dict)

            elif info_dict["connection"]["type"] == "pppoe":
                return self.is_dsl_setting_ok(info_dict)

            elif info_dict["connection"]["type"] == "vpn":
                return self.is_vpn_setting_ok(info_dict)

            elif info_dict["connection"]["type"] == "cdma":
                return self.is_cdma_setting_ok(info_dict)

            elif info_dict["connection"]["type"] == "gsm":
                return self.is_gsm_setting_ok(info_dict)

            else:
                return False
        except:
            traceback.print_exc()

 def add_dns_search(self, dns):
     if dns in self.dns_search:
         print "already have the dns search"
     else:    
         if "dns-search" not in self.prop_dict.iterkeys():    
             self.clear_dns_search()
         self.prop_dict["dns-search"].append(TypeConvert.py2_dbus_string(dns))

 def check_complete_dns(self):
     dns = []
     for address in self.dns:
         if TypeConvert.is_valid_ip6(address):
             dns.append(address)
         else:
             return dns
     return dns

    def save_settings(self, widget, content, types):
        #value = None
        if types:
            setattr(self.ethernet, types, content)
        if self.settings_obj is None:
            return
        
        # check mac address whether is valid
        if types == "mac_address":
            mac_address = content
            cloned_mac_address = self.clone_entry.get_address()
        elif types == "cloned_mac_address":
            mac_address = self.mac_entry.get_address()
            cloned_mac_address = content
        else:
            mac_address = self.mac_entry.get_address()
            cloned_mac_address = self.clone_entry.get_address()

        if (mac_address == ":::::") or \
                (mac_address == "") or \
                (TypeConvert.is_valid_mac_address(mac_address)):
            mac_address_is_valid = True
        else:
            mac_address_is_valid = False
        if (cloned_mac_address == ":::::") or \
                (cloned_mac_address == "") or \
                (TypeConvert.is_valid_mac_address(cloned_mac_address)):
            cloned_mac_address_is_valid = True
        else:
            cloned_mac_address_is_valid = False
        if mac_address_is_valid and cloned_mac_address_is_valid:
            self.settings_obj.mac_is_valid = True
        else:
            self.settings_obj.mac_is_valid = False

        # 统一调用shared_methods.Settings的set_button
        log.debug('set_button True')
        self.settings_obj.set_button("save", True)

        """

    def check_ip4_setting(self, info_dict):
        if "ipv4" in info_dict.keys():
            if info_dict["ipv4"]["method"] == "manual":

                if not info_dict["ipv4"]["addresses"]:
                    print "ipv4 addresses not complete"
                    return False
                else:
                    [address, netmask, gateway] = TypeConvert.ip4address_net2native(info_dict["ipv4"]["addresses"][0])

                    if not TypeConvert.is_valid_ip4(address):
                        print "ipv4 invalid address"
                        return False

                    if not TypeConvert.is_valid_netmask(netmask):
                        print "ipv4 invalid netmask"
                        return False

                    if not TypeConvert.is_valid_gw(address, netmask, gateway):
                        print "ipv4 invalid gateway"
                        return False

            if "dns" in info_dict["ipv4"].keys() and len(info_dict["ipv4"]["dns"]) > 0:
                for dns in info_dict["ipv4"]["dns"]:
                    if not TypeConvert.is_valid_ip4(TypeConvert.ip4_net2native(dns)):
                        print "ipv4 invalid dns"
                        return False
        return True

    def check_setting_commit(self):
        ###delete invalid setting property before update
        for key in self.settings_dict.keys():
            for key2 in self.settings_dict[key]:
                if self.settings_dict[key][key2] == None:
                    self.settings_dict[key][key2] = ""

        info_dict = TypeConvert.dbus2py(self.settings_dict)
        try:
            if info_dict["connection"]["type"] == "802-3-ethernet":
                if not self.get_setting("802-3-ethernet").wired_valid():
                    ###or raise exception
                    return False
                self.get_setting("ipv4").adapt_ip4config_commit()

                if "ipv6" in info_dict.iterkeys():
                    self.get_setting("ipv6").adapt_ip6config_commit()

            elif info_dict["connection"]["type"] == "802-11-wireless":
                self.get_setting("802-11-wireless").adapt_wireless_commit()

                if "802-11-wireless-security" in info_dict.iterkeys():
                    self.get_setting("802-11-wireles-security").adapt_wireless_security_commit()

                self.get_setting("ipv4").adapt_ip4config_commit()

                if "ipv6" in info_dict.iterkeys():
                    self.get_setting("ipv6").adapt_ip6config_commit()

            elif info_dict["connection"]["type"] == "pppoe":
                if not self.get_setting("802-3-ethernet").wired_valid():
                    return False
                self.get_setting("ipv4").adapt_ip4config_commit()

                if "ipv6" in info_dict.iterkeys():
                    self.get_setting("ipv6").adapt_ip6config_commit()

            elif info_dict["connection"]["type"] == "vpn":
                pass

            elif info_dict["connection"]["type"] == "cdma":
                pass

            elif info_dict["connection"]["type"] == "gsm":
                pass

            else:
                print "invalid connection_type"
        except:
            pass

 def entry_changed(self, widget, content, types):
     is_valid = True
     if types == "ssid":
         setattr(self.wireless, types, content)
     else:
         from nmlib.nm_utils import TypeConvert
         if (content == "") or TypeConvert.is_valid_mac_address(content):
             setattr(self.wireless, types, content)
             #check_settings(self.connection, self.set_button)
             is_valid = self.connection.check_setting_finish()
         else:
             is_valid = False
             #Dispatcher.set_button("save", False)
     self.settings_obj.mac_is_valid = is_valid
     self.settings_obj.set_button("save", is_valid)

 def save_settings(self, widget, value, types):
     if type(value) is str:
         if (value == "") or TypeConvert.is_valid_mac_address(value):
             setattr(self.ethernet_setting, types, value)
             #if self.connection.check_setting_finish():
                 #Dispatcher.set_button("save", True)
             is_valid = self.connection.check_setting_finish()
         else:
             is_valid = False
             #Dispatcher.set_button("save", False)
         self.settings_obj.mac_is_valid = is_valid
         if not self._init:
             self.settings_obj.set_button("save", is_valid)
     else:
         setattr(self.ethernet_setting, types, value)
         if self.connection.check_setting_finish() and not self._init:
             Dispatcher.set_button("save", True)

    def set_dns_address(self, widget, content, index):
        self.dns[index] = content
        names = ["master", "slaver"]
        dns = self.check_complete_dns()
        if dns:
            is_valid = True
            self.setting.clear_dns()
            for d in dns:
                self.setting.add_dns(d)
        else:
            is_valid = False
            self.setting.clear_dns()

        if TypeConvert.is_valid_ip6(content):
            setattr(self, names[index] + "_flag", True)
        else:
            setattr(self, names[index] + "_flag", False)

        ############
        # 检查dns
        if self.settings_obj:
            self.settings_obj.ipv6_dns_is_valid = is_valid
            self.settings_obj.set_button("save", is_valid)

 def id(self):
     if "id" in self.prop_dict.iterkeys():
         return TypeConvert.dbus2py(self.prop_dict["id"])

 def autoconnect(self, new_autoconnect):
     self.prop_dict["autoconnect"] = TypeConvert.py2_dbus_boolean(new_autoconnect)

 def permissions(self, new_permissions):
     self.prop_dict["permissions"] = TypeConvert.py2_dbus_array(new_permissions)

 def zone(self, new_zone):
     self.prop_dict["zone"] = TypeConvert.py2_dbus_string(new_zone)

 def type(self, new_type):
     self.prop_dict["type"] = TypeConvert.py2_dbus_string(new_type)

 def read_only(self, new_read_only):
     self.prop_dict["read_only"] = TypeConvert.py2_dbus_boolean(new_read_only)

 def master(self, new_master):
     self.prop_dict["master"] = TypeConvert.py2_dbus_string(new_master)

 def slave_type(self, new_slave_type):
     self.prop_dict["slave-type"] = TypeConvert.py2_dbus_string(new_slave_type)