mypreferencemanager.java

jxta官方例程

                }
            }
        }
        
        return prefSetInstance;
    }
    
    
    
    public PreferenceSet getPreferenceSet(String categoryName, String preferenceSetName) {
        String path = buildPath(categoryName, preferenceSetName);
        return getPreferenceSet(path);
    }
    
    private PreferenceSet getPreferenceSet(String path) {
        
        return this.prefSetTable.get(path);
        
//getClass attr
//        String className = getAttribute(path, ATTRIBUTE_CLASS);
        
  //      PreferenceSet prefSet = instantiatePreferenceSet(className);
        //inject root path
    //    prefSet.setRootPath(path);
        
      //  return prefSet;
    }
    
    
    
    
    
    public PreferenceSet getPluginPreferenceSet(String pluginPrefSetName) {
        return getPreferenceSet(buildPath(CATEGORY_PLUGINS, pluginPrefSetName));
    }
    
    public String toString() {
        return res.toString();
    }
    
    public void setPreference(String path, String value) {
    	path = addLeadingSlash(path);
        res.set(path, value);
    }
    
    public String getPreference(String name) {
        name=addLeadingSlash(name);
        return res.get(name);
    }
    
    public String getAttribute(String prefName, String attr) {
        String rtn = null;
        
        prefName = addLeadingSlash(prefName);
        if(attr.startsWith("@")) {
            rtn = prefName + SEP + attr;
        }else{
            rtn = prefName + SEP + "@" + attr;
        }
        
        return res.get(rtn);
    }

	private String addLeadingSlash(String prefName) {
		if (!prefName.startsWith("/"))
        	prefName="/"+prefName;
		return prefName;
	}
    
    public List getAttributes(String name, String attr) {
        return getPreferences(name, attr);
    }
    
    public List getPreferences(String name, String attr) {
        String rtn = name;
        name = addLeadingSlash(name);
        if(attr != null) {
            if(attr.startsWith("@")) {
                rtn = name + SEP  + attr;
            }else{
                rtn = name + SEP + "@" + attr;
            }
        }
        
        
        
        return res.getAll(rtn);
    }
    
    
    public void shutdown() {
        
        save();
        
        
        
    }

	public void save() {
		Env.savePreferences(res.toString());
	}
    
    
    /**
     * Creates a new instance of MyPreferenceManager
     */
    private MyPreferenceManager() {

       PREFSET_LEGACY = buildPath(CATEGORY_GENERAL,PREFERENCESET_LEGACY);
        
        
        LOG.setLevel(Level.DEBUG);
        try {
            
            res = new Resource(MyPreferenceManager.ROOT);
            
            try {
                //res.load(new URL("file:///home/polo/dev/prefs.xml"));
                res.load(Env.getPreferences());
            
            } catch (ResourceNotFoundException ex) {
                ex.printStackTrace();
            }
        } catch(Exception x) {
            x.printStackTrace();
        }
        
        
        prefSetTable = new LinkedHashMap<String, PreferenceSet>();
        

    }
    
    public void init() {
        scanCategoryList(); // initializes the preferencsets
    }
    
    protected List<String> getCategorys() {
        if(categoryList == null) {
            categoryList = new ArrayList<String>();
            scanCategoryList();
        }
        return categoryList;
    }
    
    private void scanCategoryList() {
        if(categoryList == null) {
            categoryList = new ArrayList<String>();
        }
        
        List l = getAttributes(ROOT + SEP + PREFERENCES + SEP + CATEGORY , ATTRIBUTE_NAME);

        Iterator itr = l.iterator();
        
        while(itr.hasNext()) {
            
            String categoryPath = buildPath((String)itr.next());
            if(!categoryList.contains(categoryPath)) {
                
                categoryList.add(categoryPath);
                
                setupPreferenceSets(categoryPath);
                
            }
        }
        
        for(Iterator<String> i = categoryList.iterator();i.hasNext();) {
            if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("category " + i.next());
            }
        }
        for(Iterator<String> i = prefSetTable.keySet().iterator();i.hasNext();) {
            if (LOG.isEnabledFor(Level.DEBUG)) {
                LOG.debug("prefset " + i.next());
            }
        }
    }
        
        
        protected HashMap<String, PreferenceSet> getPreferenceSets() {
            return prefSetTable;
        }
        
        public Hashtable<String, PreferenceSet> getPreferenceSets(String categoryPath) {
            Hashtable<String, PreferenceSet> table = new Hashtable<String, PreferenceSet>();
            for(Iterator<String> i = prefSetTable.keySet().iterator();i != null && i.hasNext();) {
                String path = i.next();
                if(path.startsWith(categoryPath)) {
                    table.put(path,prefSetTable.get(path));
                }
            }
            return table;
        } 
        
        private void setupPreferenceSets(String categoryPath) {
            String pathToPreferenceSet = categoryPath + SEP + PREFERENCE_SET;
            List l = getAttributes(pathToPreferenceSet, ATTRIBUTE_NAME);
            Iterator itr = l.iterator();
            String categoryName = getAttribute(categoryPath, ATTRIBUTE_NAME);
            while(itr.hasNext()) {
                
                String prefSetPath = buildPath(categoryName,(String)itr.next());
                if(Boolean.valueOf(getAttribute(prefSetPath, ATTRIBUTE_ENABLE)) == true) {
                    if(!prefSetTable.containsKey(prefSetPath)) { //if its not already in the list
                        String prefSetClassName = getAttribute(prefSetPath, ATTRIBUTE_CLASS);
                        PreferenceSet prefSet = instantiatePreferenceSet(prefSetClassName);
                        prefSet.setRootPath(prefSetPath);
                        prefSet.init();
                        prefSetTable.put(prefSetPath, prefSet);
                    }
                }
            }
        }
        
        public static Dimension stringToDimension(String s) {
            
            
            int w = 0;
            int h = 0;
            Dimension rtn = null;
            
            if(s != null) {
                
                String[] tmp = s.split("x");
                
                if( tmp.length == 2) {
                    
                    try {
                        
                        w = Integer.valueOf(tmp[0].trim()).intValue();
                        
                        h = Integer.valueOf(tmp[1].trim()).intValue();
                        
                    }catch(NumberFormatException nfx) {
                        nfx.printStackTrace();
                    }
                }
                rtn = new Dimension(w,h);
            }
            return rtn;
            
        }
        
        public static String dimensionToString(Dimension d) {
            
            return (d != null) ?
                String.valueOf(String.valueOf((int)d.getWidth()) +
                    " x " +
                    String.valueOf((int)d.getHeight())) : null;
        }
    }