preferenceinfo.java

打印管理程序,测试完全通过.windows开发环境.

	
	public int getAuthType() {
		return getAuthType(curIdx);
	}
	
	private int getAuthType(int idx) {
		if (idx < 0 || idx >= vcPrefInfos.size()) {
			return DEF_AUTHTYPE;
		}
		
		return ((PreferenceInfoElement)vcPrefInfos.elementAt(idx)).getAuthType();
	}
	
	public void setAuthType(int authType) {
		setAuthType(curIdx, authType);
	}
	
	private void setAuthType(int idx, int authType) {
		if (idx < 0 || idx >= vcPrefInfos.size()) {
			return;
		}
		PreferenceInfoElement	prefInfo = (PreferenceInfoElement)vcPrefInfos.elementAt(idx);
		prefInfo.setAuthType(authType);
		vcPrefInfos.setElementAt(prefInfo, idx);
	}
	
	public boolean isAllowSelectedAuthType() {
		return isAllowSelectedAuthType(curIdx);
	}
	
	private boolean isAllowSelectedAuthType(int idx) {
		if (idx < 0 || idx >= vcPrefInfos.size()) {
			return DEF_ALLOW_SELECTED_AUTH_TYPE;
		}
		
		return ((PreferenceInfoElement)vcPrefInfos.elementAt(idx)).isAllowSelectedAuthType();
	}

	public void readXml() throws ParserConfigurationException, SAXException, FileNotFoundException, IOException {
		DocumentBuilderFactory	dbfactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder			builder = dbfactory.newDocumentBuilder();
		Document				doc = builder.parse(new File(fileName));
		Element					root = doc.getDocumentElement();
		
		// 弶婜愝掕忣曬偼侾屄偺傒懳墳(暋悢屄懳墳梊掕)
		NodeList				list = root.getElementsByTagName(TAG_PREFERENCE_INFO);
		if (list.getLength() > 0) {
			PreferenceInfoElement	prefInfo = new PreferenceInfoElement();
			Element					element = (Element)list.item(0);
			
			deleteAllPreferenceInfos();
			
			NodeList	listItem;
			Element		elementItem;

			// 擣徹曽幃
			try {
				listItem = element.getElementsByTagName(KEY_AUTHTYPE);
				elementItem = (Element)listItem.item(0);
				prefInfo.setAuthType(Integer.parseInt(elementItem.getAttribute(ATTR_VALUE)));
			} catch (NullPointerException e) {
			}
			
			// 擣徹曽幃慖戰嫋壜僼儔僌
			try {
				listItem = element.getElementsByTagName(KEY_ALLOW_SELECTED_AUTHTYPE);
				elementItem = (Element)listItem.item(0);
				prefInfo.setAllowSelectedAuthType(new Boolean(elementItem.getAttribute(ATTR_VALUE)).booleanValue());
			} catch (NullPointerException e) {
			}
			
			// 儂僗僩柤
			try {
				listItem = element.getElementsByTagName(KEY_HOST);
				elementItem = (Element)listItem.item(0);
				prefInfo.setHost(elementItem.getAttribute(ATTR_VALUE));
			} catch (NullPointerException e) {
			}
			
			// 僷僗
			try {
				listItem = element.getElementsByTagName(KEY_PATH);
				elementItem = (Element)listItem.item(0);
				prefInfo.setPath(elementItem.getAttribute(ATTR_VALUE));
			} catch (NullPointerException e) {
			}
			
			// 億乕僩斣崋
			try {
				listItem = element.getElementsByTagName(KEY_PORT);
				elementItem = (Element)listItem.item(0);
				prefInfo.setPort(Integer.parseInt(elementItem.getAttribute(ATTR_VALUE)));
			} catch (NullPointerException e) {
			}
			
			// HTTPS巊梡
			try {
				listItem = element.getElementsByTagName(KEY_USEHTTPS);
				elementItem = (Element)listItem.item(0);
				prefInfo.setUseHttps(new Boolean(elementItem.getAttribute(ATTR_VALUE)).booleanValue());
			} catch (NullPointerException e) {
			}

			// 僨僶僢僌儌乕僪
			try {
				listItem = element.getElementsByTagName(KEY_DEBUG);
				elementItem = (Element)listItem.item(0);
				prefInfo.setDebug(new Boolean(elementItem.getAttribute(ATTR_VALUE)).booleanValue());
			} catch (NullPointerException e) {
			}
			
			// 僶僢僋僌儔儞僪僀儊乕僕僼傽僀儖柤
			try {
				listItem = element.getElementsByTagName(KEY_IMAGE_BACKGROUND);
				elementItem = (Element)listItem.item(0);
				prefInfo.setBackgroundImageName(elementItem.getAttribute(ATTR_VALUE));
			} catch (NullPointerException e) {
			}
			
			// 尵岅
			try {
				listItem = element.getElementsByTagName(KEY_LANGUAGE);
				elementItem = (Element)listItem.item(0);
				prefInfo.setLanguage(elementItem.getAttribute(ATTR_VALUE));
			} catch (NullPointerException e) {
			}
			
			// 梡巻僒僀僘僒億乕僩
			try {
				listItem = element.getElementsByTagName(KEY_PAPER_INFO_SUPPORT);
				elementItem = (Element)listItem.item(0);
				prefInfo.setPaperInfoSupport(new Boolean(elementItem.getAttribute(ATTR_VALUE)).booleanValue());
			} catch (NullPointerException e) {
			}
			
			// 僙僢僔儑儞僞僀儉傾僂僩抣
			try {
				listItem = element.getElementsByTagName(KEY_SESSION_TIMER_VALUE);
				elementItem = (Element)listItem.item(0);
				prefInfo.setSessionTimerValue(Integer.parseInt(elementItem.getAttribute(ATTR_VALUE)));
			} catch (NullPointerException e) {
			}
			
			// 儀儞僟乕
			try {
				listItem = element.getElementsByTagName(KEY_VENDER);
				elementItem = (Element)listItem.item(0);
				prefInfo.setVender(elementItem.getAttribute(ATTR_VALUE));
			} catch (NullPointerException e) {
			}
			
			// 僇乕僪R/W傾僪儗僗
			try {
				listItem = element.getElementsByTagName(KEY_CARD_RW_ADDR);
				elementItem = (Element)listItem.item(0);
				prefInfo.setCardRWAddr(elementItem.getAttribute(ATTR_VALUE));
			} catch (NullPointerException e) {
			}
			
			// 僼僃儕僇僇乕僪僔僗僥儉僐乕僪
			try {
				listItem = element.getElementsByTagName(KEY_FELICA_SYS_CODE);
				elementItem = (Element)listItem.item(0);
				prefInfo.setFelicaSysCode(Integer.parseInt(elementItem.getAttribute(ATTR_VALUE)));
			} catch (NullPointerException e) {
			}
			
			addPreferenceInfo(prefInfo);
		}
	}
	
	public void writeXml() throws FileNotFoundException, UnsupportedEncodingException {
		createXml();
	}
	
	private void createXml() throws FileNotFoundException, UnsupportedEncodingException {
		// 弶婜愝掕忣曬偼侾屄偺傒懳墳(暋悢屄懳墳梊掕)
		PreferenceInfoElement	prefInfo = getPreferenceInfo(curIdx);
		
		try {
			File			fs = new File(fileName);
			File			fd = new File(XML_TEMP_FILE_NAME);
			BufferedReader	br = new BufferedReader(new FileReader(fs));
			PrintWriter		pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(fd), "UTF-8"));
			
			String	line;
			try {
				while ((line = br.readLine()) != null) {
					if (line.indexOf(KEY_AUTHTYPE) >= 0) {
						pw.println(makeXmlItem(KEY_AUTHTYPE, prefInfo.getAuthType()));
					} else if (line.indexOf(KEY_ALLOW_SELECTED_AUTHTYPE) >= 0) {
						pw.println(makeXmlItem(KEY_ALLOW_SELECTED_AUTHTYPE, prefInfo.isAllowSelectedAuthType()));
					} else if (line.indexOf(KEY_HOST) >= 0) {
						pw.println(makeXmlItem(KEY_HOST, prefInfo.getHost()));
					} else if (line.indexOf(KEY_PATH) >= 0) {
						pw.println(makeXmlItem(KEY_PATH, prefInfo.getPath()));
					} else if (line.indexOf(KEY_PORT) >= 0) {
						pw.println(makeXmlItem(KEY_PORT, prefInfo.getPort()));
					} else if (line.indexOf(KEY_USEHTTPS) >= 0) {
						pw.println(makeXmlItem(KEY_USEHTTPS, prefInfo.isUseHttps()));
					} else if (line.indexOf(KEY_DEBUG) >= 0) {
						pw.println(makeXmlItem(KEY_DEBUG, prefInfo.isDebug()));
					} else if (line.indexOf(KEY_IMAGE_BACKGROUND) >= 0) {
						pw.println(makeXmlItem(KEY_IMAGE_BACKGROUND, prefInfo.getBackgroundImageName()));
					} else if (line.indexOf(KEY_LANGUAGE) >= 0) {
						pw.println(makeXmlItem(KEY_LANGUAGE, prefInfo.getLanguage()));
					} else if (line.indexOf(KEY_PAPER_INFO_SUPPORT) >= 0) {
						pw.println(makeXmlItem(KEY_PAPER_INFO_SUPPORT, prefInfo.isPaperInfoSupport()));
					} else if (line.indexOf(KEY_SESSION_TIMER_VALUE) >= 0) {
						pw.println(makeXmlItem(KEY_SESSION_TIMER_VALUE, prefInfo.getSessionTimerValue()));
					} else if (line.indexOf(KEY_VENDER) >= 0) {
						pw.println(makeXmlItem(KEY_VENDER, prefInfo.getVender()));
					} else if (line.indexOf(KEY_CARD_RW_ADDR) >= 0) {
						pw.println(makeXmlItem(KEY_CARD_RW_ADDR, prefInfo.getCardRWAddr()));
					} else if (line.indexOf(KEY_FELICA_SYS_CODE) >= 0) {
						pw.println(makeXmlItem(KEY_FELICA_SYS_CODE, prefInfo.getFelicaSysCode()));
					} else {
						pw.println(line);
					}
				}
				
				br.close();
				pw.close();
				
				// 尦僼傽僀儖傪嶍彍偟偰儕僱乕儉偡傞
				fs.delete();
				fd.renameTo(new File(fileName));
			} catch (IOException e) {
			}
		} catch (FileNotFoundException e) {
			PrintWriter	pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(fileName), "UTF-8"));

			pw.println("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
			pw.println("<" + TAG_INFO + ">");
			pw.println("\t<" + TAG_PREFERENCE_INFO + " " + ATTR_ID + "=\"" + curIdx + "\">");
			pw.println(makeXmlItem(KEY_AUTHTYPE, prefInfo.getAuthType()));
			pw.println(makeXmlItem(KEY_HOST, prefInfo.getHost()));
			pw.println(makeXmlItem(KEY_PATH, prefInfo.getPath()));
			pw.println(makeXmlItem(KEY_PORT, prefInfo.getPort()));
			pw.println(makeXmlItem(KEY_IMAGE_BACKGROUND, prefInfo.getBackgroundImageName()));
			pw.println(makeXmlItem(KEY_SESSION_TIMER_VALUE, prefInfo.getSessionTimerValue()));
			pw.println(makeXmlItem(KEY_CARD_RW_ADDR, prefInfo.getCardRWAddr()));
			pw.println(makeXmlItem(KEY_FELICA_SYS_CODE, prefInfo.getFelicaSysCode()));
			pw.println("\t</" + TAG_PREFERENCE_INFO + ">");
			pw.println("</" + TAG_INFO + ">");
			pw.close();
		}
	}
	
	private String makeXmlItem(String keyName, String value) {
		return "\t\t<" + keyName + " " + ATTR_VALUE + "=\"" + value + "\"/>";
	}
	
	private String makeXmlItem(String keyName, int value) {
		return "\t\t<" + keyName + " " + ATTR_VALUE + "=\"" + String.valueOf(value) + "\"/>";
	}
	
	private String makeXmlItem(String keyName, boolean value) {
		return "\t\t<" + keyName + " " + ATTR_VALUE + "=\"" + new Boolean(value).toString() + "\"/>";
	}
	
	private class PreferenceInfoElement {
		public final static int		IDX_MAX						= 14;
		public final static int		IDX_BACKGROUND_IMAGE		= 0;
		public final static int		IDX_DEBUG					= 1;
		public final static int		IDX_LANGUAGE				= 2;
		public final static int		IDX_PAPER_INFO_SUPPORT		= 3;
		public final static int		IDX_VENDER					= 4;
		public final static int		IDX_SESSION_TIMER_VALUE		= 5;
		public final static int		IDX_CARD_RW_ADDR			= 6;
		public final static int		IDX_FELICA_SYS_CODE			= 7;
		public final static int		IDX_HOST					= 8;
		public final static int		IDX_PORT					= 9;
		public final static int		IDX_USE_HTTPS				= 10;
		public final static int		IDX_PATH					= 11;
		public final static int		IDX_AUTHTYPE				= 12;
		public final static int		IDX_ALLOW_SELECTED_AUTHTYPE	= 13;
		
		private boolean[]				setValueFlags;
		private String					backgroundImage;
		private boolean				debug;
		private String					language;
		private boolean				paperInfoSupport;
		private String					vender;
		private int					sessionTimerValue;
		private String					cardRWAddr;
		private int					felicaSysCode;
		private String					host;
		private int					port;
		private boolean				useHttps;
		private String					path;
		private int					authType;
		private boolean				allowSelectedAuthType;
		
		public PreferenceInfoElement() {
			this.setValueFlags			= new boolean[IDX_MAX];
			for (int i = 0; i < this.setValueFlags.length; i++) {
				this.setValueFlags[i] = false;
			}
			
			this.backgroundImage		= DEF_BACKGROUND_IMAGE;
			this.debug					= DEF_DEBUG;
			this.language				= DEF_LANGUAGE;
			this.paperInfoSupport		= DEF_PAPER_INFO_SUPPORT;
			this.vender					= DEF_VENDER;
			this.sessionTimerValue		= DEF_SESSION_TIMER_VALUE;
			this.cardRWAddr				= DEF_CARD_RW_ADDR;
			this.felicaSysCode			= DEF_FELICA_SYS_CODE;
			this.host					= DEF_HOST;
			this.port					= DEF_PORT;
			this.useHttps				= DEF_USE_HTTPS;
			this.path					= DEF_PATH;
			this.authType				= DEF_AUTHTYPE;
			this.allowSelectedAuthType	= DEF_ALLOW_SELECTED_AUTH_TYPE;
		}

		public boolean[] getSetValueFlags() {
			return setValueFlags;
		}
		
		public boolean isSetValue(int idx) {
			if (idx >= 0 && idx < setValueFlags.length) {
				return setValueFlags[idx];
			}
			
			return false;
		}
		
		public String getBackgroundImageName() {
			return this.backgroundImage;
		}
		
		public void setBackgroundImageName(String backgroundImage) {
			this.setValueFlags[IDX_BACKGROUND_IMAGE] = true;
			this.backgroundImage = backgroundImage;
		}
		
		public int getClientKind() {
			String	client = System.getProperty("os.name", "");
			if (client.indexOf("Mac") >= 0) {
				return CLIENT_MAC;
			}
			
			return CLIENT_WINDOWS;
		}
		
		public void setClientKind(int clientKind) {
		}
		
		public void setDebug(boolean debug) {
			this.setValueFlags[IDX_DEBUG] = true;
			this.debug = debug;
		}
		
		public boolean isDebug() {
			return this.debug;
		}
		
		public String getLanguage() {
			return this.language;
		}
		
		public void setLanguage(String language) {
			this.setValueFlags[IDX_LANGUAGE] = true;
			if (language == null) {
				this.language = "";
			} else {
				this.language = language;
			}
		}
		
		public boolean isPaperInfoSupport() {
			return paperInfoSupport;
		}
		
		public void setPaperInfoSupport(boolean paperInfoSupport) {
			this.setValueFlags[IDX_PAPER_INFO_SUPPORT] = true;
			this.paperInfoSupport = paperInfoSupport;
		}
		
		public String getVender() {
			return vender;
		}
		
		public void setVender(String vender) {
			this.setValueFlags[IDX_VENDER] = true;
			this.vender = vender;
		}
		
		public int getSessionTimerValue() {
			return sessionTimerValue;
		}
		
		public void setSessionTimerValue(int sessionTimerValue) {
			this.setValueFlags[IDX_SESSION_TIMER_VALUE] = true;
			this.sessionTimerValue = sessionTimerValue;
		}
		
		public String getCardRWAddr() {
			return cardRWAddr;
		}
		
		public void setCardRWAddr(String cardRWAddr) {
			this.setValueFlags[IDX_CARD_RW_ADDR] = true;
			this.cardRWAddr = cardRWAddr;
		}
		
		public int getFelicaSysCode() {
			return felicaSysCode;
		}
		
		public void setFelicaSysCode(int felicaSysCode) {
			this.setValueFlags[IDX_FELICA_SYS_CODE] = true;
			this.felicaSysCode = felicaSysCode;
		}
		
		public String getHost() {
			return host;
		}
		
		public void setHost(String host) {
			this.setValueFlags[IDX_HOST] = true;
			this.host = host;
		}
		
		public int getPort() {
			return port;
		}
		
		public void setPort(int port) {
			this.setValueFlags[IDX_PORT] = true;
			this.port = port;
		}
		
		public boolean isUseHttps() {
			return useHttps;
		}
		
		public void setUseHttps(boolean useHttps) {
			this.setValueFlags[IDX_USE_HTTPS] = true;
			this.useHttps = useHttps;
		}
		
		public String getPath() {
			return path;
		}
		
		public void setPath(String path) {
			this.setValueFlags[IDX_PATH] = true;
			this.path = path;
		}
		
		public String getDocBase() {
			return (useHttps ? HTTPS_STR : HTTP_STR) + host + ":" + Integer.toString(port) + path + SERVLET_DIR_STR;
		}
		
		public int getAuthType() {
			return authType;
		}
		
		public void setAuthType(int authType) {
			this.setValueFlags[IDX_AUTHTYPE] = true;
			this.authType = authType;
		}
		
		public boolean isAllowSelectedAuthType() {
			return allowSelectedAuthType;
		}
		
		public void setAllowSelectedAuthType(boolean allowSelectedAuthType) {
			this.setValueFlags[IDX_ALLOW_SELECTED_AUTHTYPE] = true;
			this.allowSelectedAuthType = allowSelectedAuthType;
		}
		
	}
}