diff options
author | Lars Langhans <lla@openoffice.org> | 2010-05-10 14:25:29 +0200 |
---|---|---|
committer | Lars Langhans <lla@openoffice.org> | 2010-05-10 14:25:29 +0200 |
commit | ddbd50bf72185948d2a376ab2e0f7dd682a59cce (patch) | |
tree | 1dd87626db15bca7bd9c18f6cf03762cafce6281 /testgraphical | |
parent | gfxcmp02: #159601# add graphical compare test (diff) | |
download | core-ddbd50bf72185948d2a376ab2e0f7dd682a59cce.tar.gz core-ddbd50bf72185948d2a376ab2e0f7dd682a59cce.zip |
gfxcmp02: #159601# add graphical compare test
Diffstat (limited to 'testgraphical')
-rw-r--r-- | testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java | 718 |
1 files changed, 718 insertions, 0 deletions
diff --git a/testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java b/testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java new file mode 100644 index 000000000000..2b49ffa760a0 --- /dev/null +++ b/testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java @@ -0,0 +1,718 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +import java.io.File; +import java.io.RandomAccessFile; +import java.util.ArrayList; +import java.util.Enumeration; + + +/** + * Simple implementation of a inifile manager + */ +class GlobalLogWriter +{ + public static void println(String _s) + { + System.out.println(_s); + } +} + +/** + Helper class to give a simple API to read/write windows like ini files +*/ + +/* public */ // is only need, if we need this class outside package convwatch +public class IniFile implements Enumeration +{ + + /** + * internal representation of the ini file content. + * Problem, if ini file changed why other write something difference, we don't realise this. + */ + private String m_sFilename; + // private File m_aFile; + private ArrayList<String> m_aList; + boolean m_bListContainUnsavedChanges = false; + private int m_aEnumerationPos = 0; + + /** + open a ini file by it's name + @param _sFilename string a filename, if the file doesn't exist, a new empty ini file will create. + write back to disk only if there are really changes. + */ + public IniFile(String _sFilename) + { + m_sFilename = _sFilename; + // m_aFile = new File(_sFilename); + m_aList = loadLines(); + m_aEnumerationPos = findNextSection(0); + } + + /** + open a ini file by it's name + @param _aFile a java.io.File object, if the file doesn't exist, a new empty ini file will create. + write back to disk only if there are really changes. + */ + public IniFile(File _aFile) + { + m_sFilename = _aFile.getAbsolutePath(); + m_aList = loadLines(); + m_aEnumerationPos = findNextSection(0); + } + + public void insertFirstComment(String[] _aList) + { + if (m_aList.size() == 0) + { + // can only insert if there is nothing else already in the ini file + for (int i = 0; i < _aList.length; i++) + { + m_aList.add(_aList[i]); + } + } + } + + private ArrayList<String> loadLines() + { + ArrayList<String> aLines = new ArrayList<String>(); + File aFile = new File(m_sFilename); + if (!aFile.exists()) + { + // GlobalLogWriter.println("couldn't find file '" + m_sFilename + "', will be created."); + // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, ""); + // m_bListContainUnsavedChanges = false; + return aLines; + } + RandomAccessFile aReader = null; + // BufferedReader aReader; + try + { + aReader = new RandomAccessFile(aFile, "r"); + String aLine = ""; + while (aLine != null) + { + aLine = aReader.readLine(); + if (aLine != null && aLine.length() > 0) + { + aLines.add(aLine); + } + } + } + catch (java.io.FileNotFoundException fne) + { + GlobalLogWriter.println("couldn't open file " + m_sFilename); + GlobalLogWriter.println("Message: " + fne.getMessage()); + // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, ""); + } + catch (java.io.IOException ie) + { + GlobalLogWriter.println("Exception occurs while reading from file " + m_sFilename); + GlobalLogWriter.println("Message: " + ie.getMessage()); + // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage()); + } + try + { + aReader.close(); + } + catch (java.io.IOException ie) + { + GlobalLogWriter.println("Couldn't close file " + m_sFilename); + GlobalLogWriter.println("Message: " + ie.getMessage()); + // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage()); + } + return aLines; + } + + /** + * @return true, if the ini file contain some readable data + */ + public boolean is() + { + return m_aList.size() > 1 ? true : false; + } + + /** + * Check if a given Section and Key exists in the ini file + * @param _sSectionName + * @param _sKey + * @return true if the given Section, Key exists, now you can get the value + */ + public boolean hasValue(String _sSectionName, String _sKey) + { + int n = findKey(_sSectionName, _sKey); + if (n > 0) + { + return true; + } + return false; + } + // ----------------------------------------------------------------------------- + + private boolean isRemark(String _sLine) + { + if (((_sLine.length() < 2)) || + (_sLine.startsWith("#")) || + (_sLine.startsWith(";"))) + { + return true; + } + return false; + } + + private String getItem(int i) + { + return m_aList.get(i); + } + + private String buildSectionName(String _sSectionName) + { + String sFindSection = "[" + _sSectionName + "]"; + return sFindSection; + } + + private String sectionToString(String _sSectionName) + { + String sKeyName = _sSectionName; + if (sKeyName.startsWith("[") && + sKeyName.endsWith("]")) + { + sKeyName = sKeyName.substring(1, sKeyName.length() - 1); + } + return sKeyName; + } + + private String toLowerIfNeed(String _sName) + { + return _sName.toLowerCase(); + } + + // return the number where this section starts + private int findSection(String _sSection) + { + String sFindSection = toLowerIfNeed(buildSectionName(_sSection)); + // ----------- find _sSection --------------- + int i; + for (i = 0; i < m_aList.size(); i++) + { + String sLine = toLowerIfNeed(getItem(i).trim()); + if (isRemark(sLine)) + { + continue; + } + if (sFindSection.equals("[]")) + { + // special case, empty Section. + return i - 1; + } + if (sLine.startsWith(sFindSection)) + { + return i; + } + } + return -1; + } + + /** + * Checks if a given section exists in the ini file + * @param _sSection + * @return true if the given _sSection was found + */ + public boolean hasSection(String _sSection) + { + int i = findSection(_sSection); + if (i == -1) + { + return false; + } + return true; + } + + // return the line number, where the key is found. + private int findKey(String _sSection, String _sKey) + { + int i = findSection(_sSection); + if (i == -1) + { + // Section not found, therefore the value can't exist + return -1; + } + return findKeyFromKnownSection(i, _sKey); + } + + // i must be the index in the list, where the well known section starts + private int findKeyFromKnownSection(int _nSectionIndex, String _sKey) + { + _sKey = toLowerIfNeed(_sKey); + for (int j = _nSectionIndex + 1; j < m_aList.size(); j++) + { + String sLine = getItem(j).trim(); + + if (isRemark(sLine)) + { + continue; + } + if (sLine.startsWith("[") /* && sLine.endsWith("]") */) + { + // TODO: due to the fact we would like to insert an empty line before new sections + // TODO: we should check if we are in an empty line and if, go back one line. + + // found end. + break; + } + + int nEqual = sLine.indexOf("="); + if (nEqual >= 0) + { + String sKey = toLowerIfNeed(sLine.substring(0, nEqual).trim()); + if (sKey.equals(_sKey)) + { + return j; + } + } + } + return -1; + } + + // i must be the index in the list, where the well known section starts + private int findLastKnownKeyIndex(int _nSectionIndex, String _sKey) + { + _sKey = toLowerIfNeed(_sKey); + int i = _nSectionIndex + 1; + for (int j = i; j < m_aList.size(); j++) + { + String sLine = getItem(j).trim(); + + if (isRemark(sLine)) + { + continue; + } + + if (sLine.startsWith("[") /* && sLine.endsWith("]") */) + { + // found end. + return j; + } + + int nEqual = sLine.indexOf("="); + if (nEqual >= 0) + { + String sKey = toLowerIfNeed(sLine.substring(0, nEqual).trim()); + if (sKey.equals(_sKey)) + { + return j; + } + } + } + return i; + } + + private String getValue(int _nIndex) + { + String sLine = getItem(_nIndex).trim(); + if (isRemark(sLine)) + { + return ""; + } + int nEqual = sLine.indexOf("="); + if (nEqual >= 0) + { + String sKey = sLine.substring(0, nEqual).trim(); + String sValue = sLine.substring(nEqual + 1).trim(); + return sValue; + } + return ""; + } + + /** + @param _sSection string + @param _sKey string + @return the value found in the inifile which is given by the section and key parameter + */ + // private int m_nCurrentPosition; + // private String m_sOldKey; + public String getValue(String _sSection, String _sKey) + { + String sValue = ""; + int m_nCurrentPosition = findKey(_sSection, _sKey); + if (m_nCurrentPosition == -1) + { + // Section not found, therefore the value can't exist + return ""; + } + + // m_sOldKey = _sKey; + sValue = getValue(m_nCurrentPosition); + + return sValue; + } + +// private String getNextValue() +// { +// if (m_nCurrentPosition >= 0) +// { +// ++m_nCurrentPosition; +// String sValue = getValue(m_nCurrentPosition); +// return sValue; +// } +// return ""; +// } + /** + * Returns the value at Section, Key converted to an integer + * Check with hasValue(Section, Key) to check before you get into trouble. + * @param _sSection + * @param _sKey + * @param _nDefault if there is a problem, key not found... this value will return + * @return + */ + public int getIntValue(String _sSection, String _sKey, int _nDefault) + { + String sValue = getValue(_sSection, _sKey); + int nValue = _nDefault; + if (sValue.length() > 0) + { + try + { + nValue = Integer.valueOf(sValue).intValue(); + } + catch (java.lang.NumberFormatException e) + { + GlobalLogWriter.println("IniFile.getIntValue(): Caught a number format exception, return the default value."); + } + } + return nValue; + } + +/** + * close a open inifile. + * If there are changes, all changes will store back to disk. + */ + public void close() + { + store(); + } + + /** + write back the ini file to the disk, only if there exist changes + * @deprecated use close() instead! + */ + + // TODO: make private + private void store() + { + if (m_bListContainUnsavedChanges == false) + { + // nothing has changed, so no need to store + return; + } + + File aFile = new File(m_sFilename); + if (aFile.exists()) + { + // System.out.println("couldn't find file " + m_sFilename); + // TODO: little bit unsafe here, first rename, after write is complete, delete the old. + aFile.delete(); + if (aFile.exists()) + { + GlobalLogWriter.println("Couldn't delete the file " + m_sFilename); + return; + // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, "Couldn't delete the file " + m_sFilename); + } + } + // if (! aFile.canWrite()) + // { + // System.out.println("Couldn't write to file " + m_sFilename); + // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ""); + // } + try + { + RandomAccessFile aWriter = new RandomAccessFile(aFile, "rw"); + for (int i = 0; i < m_aList.size(); i++) + { + String sLine = getItem(i); + if (sLine.startsWith("[")) + { + // write an extra empty line before next section. + aWriter.writeByte((int) '\n'); + } + aWriter.writeBytes(sLine); + aWriter.writeByte((int) '\n'); + } + aWriter.close(); + } + catch (java.io.FileNotFoundException fne) + { + GlobalLogWriter.println("couldn't open file for writing " + m_sFilename); + GlobalLogWriter.println("Message: " + fne.getMessage()); + // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, ""); + } + catch (java.io.IOException ie) + { + GlobalLogWriter.println("Exception occurs while writing to file " + m_sFilename); + GlobalLogWriter.println("Message: " + ie.getMessage()); + // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage()); + } + } + + public void insertValue(String _sSection, String _sKey, int _nValue) + { + insertValue(_sSection, _sKey, String.valueOf(_nValue)); + } + + public void insertValue(String _sSection, String _sKey, long _nValue) + { + insertValue(_sSection, _sKey, String.valueOf(_nValue)); + } + + /** + insert a value + there are 3 cases + 1. section doesn't exist, goto end and insert a new section, insert a new key value pair + 2. section exist but key not, search section, search key, if key is -1 get last known key position and insert new key value pair there + 3. section exist and key exist, remove the old key and insert the key value pair at the same position + * @param _sSection + * @param _sKey + * @param _sValue + */ + public void insertValue(String _sSection, String _sKey, String _sValue) + { + int i = findSection(_sSection); + if (i == -1) + { + // case 1: section doesn't exist + String sFindSection = buildSectionName(_sSection); + + // TODO: before create a new Section, insert a empty line + m_aList.add(sFindSection); + if (_sKey.length() > 0) + { + String sKeyValuePair = _sKey + "=" + _sValue; + m_aList.add(sKeyValuePair); + } + m_bListContainUnsavedChanges = true; + return; + } + int j = findKeyFromKnownSection(i, _sKey); + if (j == -1) + { + // case 2: section exist, but not the key + j = findLastKnownKeyIndex(i, _sKey); + if (_sKey.length() > 0) + { + String sKeyValuePair = _sKey + "=" + _sValue; + m_aList.add(j, sKeyValuePair); + m_bListContainUnsavedChanges = true; + } + return; + } + else + { + // case 3: section exist, and also the key + String sKeyValuePair = _sKey + "=" + _sValue; + m_aList.set(j, sKeyValuePair); + m_bListContainUnsavedChanges = true; + } + } + // ----------------------------------------------------------------------------- + // String replaceEvaluatedValue(String _sSection, String _sValue) + // { + // String sValue = _sValue; + // int nIndex = 0; + // while (( nIndex = sValue.indexOf("$(", nIndex)) >= 0) + // { + // int nNextIndex = sValue.indexOf(")", nIndex); + // if (nNextIndex >= 0) + // { + // String sKey = sValue.substring(nIndex + 2, nNextIndex); + // String sNewValue = getValue(_sSection, sKey); + // if (sNewValue != null && sNewValue.length() > 0) + // { + // String sRegexpKey = "\\$\\(" + sKey + "\\)"; + // sValue = sValue.replaceAll(sRegexpKey, sNewValue); + // } + // nIndex = nNextIndex; + // } + // else + // { + // nIndex += 2; + // } + // } + // return sValue; + // } + // ----------------------------------------------------------------------------- + + // public String getLocalEvaluatedValue(String _sSection, String _sKey) + // { + // String sValue = getValue(_sSection, _sKey); + // sValue = replaceEvaluatedValue(_sSection, sValue); + // return sValue; + // } + + // ----------------------------------------------------------------------------- + + // this is a special behaviour. + // public String getGlobalLocalEvaluatedValue(String _sSection, String _sKey) + // { + // String sGlobalValue = getKey("global", _sKey); + // String sLocalValue = getKey(_sSection, _sKey); + // if (sLocalValue.length() == 0) + // { + // sGlobalValue = replaceEvaluatedKey(_sSection, sGlobalValue); + // sGlobalValue = replaceEvaluatedKey("global", sGlobalValue); + // return sGlobalValue; + // } + // sLocalValue = replaceEvaluatedKey(_sSection, sLocalValue); + // sLocalValue = replaceEvaluatedKey("global", sLocalValue); + // + // return sLocalValue; + // } + public void removeSection(String _sSectionToRemove) + { + // first, search for the name + int i = findSection(_sSectionToRemove); + if (i == -1) + { + // Section to remove not found, do nothing. + return; + } + // second, find the next section + int j = findNextSection(i + 1); + if (j == -1) + { + // if we are at the end, use size() as second section + j = m_aList.size(); + } + // remove all between first and second section + for (int k = i; k < j; k++) + { + m_aList.remove(i); + } + // mark the list as changed + m_bListContainUnsavedChanges = true; + } + + /** + * some tests for this class + */ +// public static void main(String[] args) +// { +// String sTempFile = System.getProperty("java.io.tmpdir"); +// sTempFile += "inifile"; +// +// +// IniFile aIniFile = new IniFile(sTempFile); +// String sValue = aIniFile.getValue("Section", "Key"); +// // insert a new value to a already exist section +// aIniFile.insertValue("Section", "Key2", "a new value in a existing section"); +// // replace a value +// aIniFile.insertValue("Section", "Key", "replaced value"); +// // create a new value +// aIniFile.insertValue("New Section", "Key", "a new key value pair"); +// aIniFile.insertValue("New Section", "Key2", "a new second key value pair"); +// +// String sValue2 = aIniFile.getValue("Section2", "Key"); +// +// aIniFile.removeSection("Section"); +// aIniFile.removeSection("New Section"); +// +// aIniFile.close(); +// } + + /** + * Enumeration Interface + * @return true, if there are more Key values + */ + public boolean hasMoreElements() + { + if (m_aEnumerationPos >= 0 && + m_aEnumerationPos < m_aList.size()) + { + return true; + } + return false; + } + + /** + * Find the next line, which starts with '[' + * @param i start position + * @return the line where '[' found or -1 + */ + private int findNextSection(int i) + { + if (i >= 0) + { + while (i < m_aList.size()) + { + String sLine = m_aList.get(i); + if (sLine.startsWith("[")) + { + return i; + } + i++; + } + } + return -1; + } + + /** + * Enumeration Interface + * @return a key without the enveloped '[' ']' + */ + public Object nextElement() + { + int nLineWithSection = findNextSection(m_aEnumerationPos); + if (nLineWithSection != -1) + { + String sSection = m_aList.get(nLineWithSection); + m_aEnumerationPos = findNextSection(nLineWithSection + 1); + sSection = sectionToString(sSection); + return sSection; + } + else + { + m_aEnumerationPos = m_aList.size(); + } + return null; + } + + /** + * Helper to count the occurence of Sections + * @return returns the count of '^['.*']$' Elements + */ + public int getElementCount() + { + int nCount = 0; + int nPosition = 0; + while ((nPosition = findNextSection(nPosition)) != -1) + { + nCount++; + nPosition++; + } + return nCount; + } +} + |