summaryrefslogtreecommitdiff
path: root/testgraphical
diff options
context:
space:
mode:
Diffstat (limited to 'testgraphical')
-rw-r--r--testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java718
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;
+ }
+}
+
generated by cgit (git 2.34.1) at 2024-12-26 22:13:45 +0000