diff options
Diffstat (limited to 'wizards/com/sun/star/wizards/common/FileAccess.java')
| -rw-r--r-- | wizards/com/sun/star/wizards/common/FileAccess.java | 1200 |
1 files changed, 1200 insertions, 0 deletions
diff --git a/wizards/com/sun/star/wizards/common/FileAccess.java b/wizards/com/sun/star/wizards/common/FileAccess.java new file mode 100644 index 000000000000..6278d7e71a97 --- /dev/null +++ b/wizards/com/sun/star/wizards/common/FileAccess.java @@ -0,0 +1,1200 @@ +/************************************************************************* + * + * 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. + * + ************************************************************************/ +package com.sun.star.wizards.common; + +import com.sun.star.beans.XPropertySet; +import com.sun.star.lang.Locale; +import com.sun.star.uno.Exception; +import com.sun.star.util.XMacroExpander; +// import com.sun.star.wizards.common.NoValidPathException; +import java.io.File; +import java.util.ArrayList; +import java.util.Vector; + +import com.sun.star.awt.VclWindowPeerAttribute; +import com.sun.star.io.XActiveDataSink; +import com.sun.star.io.XInputStream; +// import com.sun.star.io.XStream; +import com.sun.star.io.XTextInputStream; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.ucb.*; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.util.DateTime; +import com.sun.star.beans.PropertyValue; +import com.sun.star.document.XDocumentProperties; + +/** + * This class delivers static convenience methods + * to use with ucb SimpleFileAccess service. + * You can also instanciate the class, to encapsulate + * some functionality of SimpleFileAccess. The instance + * keeps a reference to an XSimpleFileAccess and an + * XFileIdentifierConverter, saves the permanent + * overhead of quering for those interfaces, and delivers + * conveneince methods for using them. + * These Convenince methods include mainly Exception-handling. + */ +public class FileAccess +{ + + /** + * + * @param xMSF + * @param sPath + * @param sAddPath + */ + public static void addOfficePath(XMultiServiceFactory xMSF, String sPath, String sAddPath) + { + XSimpleFileAccess xSimpleFileAccess = null; + String ResultPath = getOfficePath(xMSF, sPath, xSimpleFileAccess); + // As there are several conventions about the look of Url (e.g. with " " or with "%20") you cannot make a + // simple String comparison to find out, if a path is already in "ResultPath" + String[] PathList = JavaTools.ArrayoutofString(ResultPath, ";"); + int MaxIndex = PathList.length - 1; + String CompCurPath; + // sAddPath.replace(null, (char) 47); + String CompAddPath = JavaTools.replaceSubString(sAddPath, "", "/"); + String CurPath; + for (int i = 0; i <= MaxIndex; i++) + { + CurPath = JavaTools.convertfromURLNotation(PathList[i]); + CompCurPath = JavaTools.replaceSubString(CurPath, "", "/"); + if (CompCurPath.equals(CompAddPath)) + { + return; + } + } + ResultPath += ";" + sAddPath; + return; + } + + public static String deleteLastSlashfromUrl(String _sPath) + { + if (_sPath.endsWith("/")) + { + return _sPath.substring(0, _sPath.length() - 1); + } + else + { + return _sPath; + } + } + + /** + * Further information on arguments value see in OO Developer Guide, + * chapter 6.2.7 + * @param xMSF + * @param sPath + * @param xSimpleFileAccess + * @return the respective path of the office application. A probable following "/" at the end is trimmed. + */ + public static String getOfficePath(XMultiServiceFactory xMSF, String sPath, XSimpleFileAccess xSimpleFileAccess) + { + try + { + String ResultPath = ""; + XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.util.PathSettings"); + ResultPath = com.sun.star.uno.AnyConverter.toString(Helper.getUnoPropertyValue(xInterface, sPath)); + ResultPath = deleteLastSlashfromUrl(ResultPath); + return ResultPath; + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + return ""; + } + } + + /** + * Further information on arguments value see in OO Developer Guide, + * chapter 6.2.7 + * @param xMSF + * @param sPath + * @param sType use "share" or "user". Set to "" if not needed eg for the WorkPath; + * In the return Officepath a possible slash at the end is cut off + * @param sSearchDir + * @return + * @throws NoValidPathException + */ + public static String getOfficePath(XMultiServiceFactory xMSF, String sPath, String sType, String sSearchDir) throws NoValidPathException + { + //This method currently only works with sPath="Template" + + String ResultPath = ""; + + String Template_writable = ""; + String[] Template_internal; + String[] Template_user; + + boolean bexists = false; + try + { + XInterface xPathInterface = (XInterface) xMSF.createInstance("com.sun.star.util.PathSettings"); + XPropertySet xPropertySet = (XPropertySet) com.sun.star.uno.UnoRuntime.queryInterface(XPropertySet.class, xPathInterface); + String WritePath = ""; + String[] ReadPaths = null; + XInterface xUcbInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, xUcbInterface); + + Template_writable = (String) xPropertySet.getPropertyValue(sPath + "_writable"); + Template_internal = (String[]) xPropertySet.getPropertyValue(sPath + "_internal"); + Template_user = (String[]) xPropertySet.getPropertyValue(sPath + "_user"); + int iNumEntries = Template_user.length + Template_internal.length + 1; + ReadPaths = new String[iNumEntries]; + int t = 0; + for (int i = 0; i < Template_internal.length; i++) + { + ReadPaths[t] = Template_internal[i]; + t++; + } + for (int i = 0; i < Template_user.length; i++) + { + ReadPaths[t] = Template_user[i]; + t++; + } + ReadPaths[t] = Template_writable; + WritePath = Template_writable; + + if (sType.equalsIgnoreCase("user")) + { + ResultPath = WritePath; + bexists = true; + } + else + { + //find right path using the search sub path + for (int i = 0; i < ReadPaths.length; i++) + { + String tmpPath = ReadPaths[i] + sSearchDir; + if (xSimpleFileAccess.exists(tmpPath)) + { + ResultPath = ReadPaths[i]; + bexists = true; + break; + } + } + } + ResultPath = deleteLastSlashfromUrl(ResultPath); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + ResultPath = ""; + } + if (bexists == false) + { + throw new NoValidPathException(xMSF, ""); + } + return ResultPath; + } + + public static ArrayList<String> getOfficePaths(XMultiServiceFactory xMSF, String _sPath, String sType, String sSearchDir) throws NoValidPathException + { + //This method currently only works with sPath="Template" + + // String ResultPath = ""; + ArrayList<String> aPathList = new ArrayList<String>(); + String Template_writable = ""; + String[] Template_internal; + String[] Template_user; + + // String [] ReadPaths = null; + + // boolean bexists = false; + try + { + XInterface xPathInterface = (XInterface) xMSF.createInstance("com.sun.star.util.PathSettings"); + XPropertySet xPropertySet = (XPropertySet) com.sun.star.uno.UnoRuntime.queryInterface(XPropertySet.class, xPathInterface); + // String WritePath = ""; + // XInterface xUcbInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + // XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, xUcbInterface); + + Template_writable = (String) xPropertySet.getPropertyValue(_sPath + "_writable"); + Template_internal = (String[]) xPropertySet.getPropertyValue(_sPath + "_internal"); + Template_user = (String[]) xPropertySet.getPropertyValue(_sPath + "_user"); + + // int iNumEntries = Template_user.length + Template_internal.length + 1; + for (int i = 0; i < Template_internal.length; i++) + { + String sPath = Template_internal[i]; + if (sPath.startsWith("vnd.")) + { + String sPathToExpand = sPath.substring("vnd.sun.star.Expand:".length()); + + XMacroExpander xExpander = Helper.getMacroExpander(xMSF); + sPath = xExpander.expandMacros(sPathToExpand); + } + + // if there exists a language in the directory, we try to add the right language + sPath = checkIfLanguagePathExists(xMSF, sPath); + + aPathList.add(sPath); + } + for (int i = 0; i < Template_user.length; i++) + { + aPathList.add(Template_user[i]); + } + aPathList.add(Template_writable); + // WritePath = Template_writable; + +// if (sType.equalsIgnoreCase("user")) +// { +// ResultPath = WritePath; +// bexists = true; +// } + + // There was a bug here, because we have to search through the whole list of paths +// else +// { +// //find right path using the search sub path +// for (int i = 0; i<ReadPaths.length; i++) +// { +// String tmpPath = ReadPaths[i]+sSearchDir; +// if (xSimpleFileAccess.exists(tmpPath)) +// { +// ResultPath = ReadPaths[i]; +// bexists = true; +// break; +// } +// } +// } +// ResultPath = deleteLastSlashfromUrl(ResultPath); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + // ResultPath = ""; + } +// if (bexists == false) +// { +// throw new NoValidPathException(xMSF, ""); +// } +// return ResultPath; + return aPathList; + } + + private static String checkIfLanguagePathExists(XMultiServiceFactory _xMSF, String _sPath) + { + try + { + Object defaults = _xMSF.createInstance("com.sun.star.text.Defaults"); + Locale aLocale = (Locale) Helper.getUnoStructValue(defaults, "CharLocale"); + if (aLocale == null) + { + java.util.Locale.getDefault(); + aLocale = new com.sun.star.lang.Locale(); + aLocale.Country = java.util.Locale.getDefault().getCountry(); + aLocale.Language = java.util.Locale.getDefault().getLanguage(); + aLocale.Variant = java.util.Locale.getDefault().getVariant(); + } + + String sLanguage = aLocale.Language; + String sCountry = aLocale.Country; + String sVariant = aLocale.Variant; + + // de-DE-Bayrisch + StringBuffer aLocaleAll = new StringBuffer(); + aLocaleAll.append(sLanguage).append('-').append(sCountry).append('-').append(sVariant); + String sPath = _sPath + "/" + aLocaleAll.toString(); + + XInterface xInterface = (XInterface) _xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, xInterface); + if (xSimpleFileAccess.exists(sPath)) + { + return sPath; + } + + // de-DE + StringBuffer aLocaleLang_Country = new StringBuffer(); + aLocaleLang_Country.append(sLanguage).append('-').append(sCountry); + sPath = _sPath + "/" + aLocaleLang_Country.toString(); + + if (xSimpleFileAccess.exists(sPath)) + { + return sPath; + } + + // de + StringBuffer aLocaleLang = new StringBuffer(); + aLocaleLang.append(sLanguage); + sPath = _sPath + "/" + aLocaleLang.toString(); + + if (xSimpleFileAccess.exists(sPath)) + { + return sPath; + } + + // the absolute default is en-US or en + sPath = _sPath + "/en-US"; + if (xSimpleFileAccess.exists(sPath)) + { + return sPath; + } + + sPath = _sPath + "/en"; + if (xSimpleFileAccess.exists(sPath)) + { + return sPath; + } + + // java.util.Locale jl = new java.util.Locale( + // l.Language , l.Country, l.Variant ); + } + catch (com.sun.star.uno.Exception e) + { + } + + return _sPath; + } + + /* + public static String getOfficePath(XMultiServiceFactory xMSF, String sPath, String sType) throws NoValidPathException { + String ResultPath = ""; + Object oPathSettings; + int iPathCount; + String[] PathList; + boolean bexists = false; + try { + XInterface xUcbInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, xUcbInterface); + ResultPath = getOfficePath(xMSF, sPath, xSimpleFileAccess); + PathList = JavaTools.ArrayoutofString(ResultPath, ";"); + if (!sType.equals("")) { + ResultPath = ""; + String CurPath = ""; + String EndString = "/" + sType; + int EndLength = EndString.length(); + sType = "/" + sType + "/"; + int MaxIndex = PathList.length - 1; + int iPos; + for (int i = 0; i <= MaxIndex; i++) { + CurPath = PathList[i]; + iPos = CurPath.length() - EndLength; + if ((CurPath.indexOf(sType) > 0) || (CurPath.indexOf(EndString) == iPos)) { + ResultPath = deleteLastSlashfromUrl(CurPath); + if (xSimpleFileAccess.exists(ResultPath)) + break; + } + } + } else + ResultPath = PathList[0]; + if (ResultPath.equals("") == false) + bexists = xSimpleFileAccess.exists(ResultPath); + } catch (Exception exception) { + exception.printStackTrace(System.out); + ResultPath = ""; + } + if (bexists == false) + throw new NoValidPathException(xMSF); + return ResultPath; + } + **/ + public static void combinePaths(XMultiServiceFactory xMSF, ArrayList _aFirstPath, String _sSecondPath) throws NoValidPathException + { + for (int i = 0; i < _aFirstPath.size(); ++i) + { + String sOnePath = (String) _aFirstPath.get(i); + sOnePath = addPath(sOnePath, _sSecondPath); + if (isPathValid(xMSF, sOnePath)) + { + _aFirstPath.add(i, sOnePath); + _aFirstPath.remove(i + 1); + } + else + { + _aFirstPath.remove(i); + --i; + } + } + } + + public static boolean isPathValid(XMultiServiceFactory xMSF, String _sPath) + { + boolean bExists = false; + try + { + XInterface xUcbInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, xUcbInterface); + bExists = xSimpleFileAccess.exists(_sPath); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + return bExists; + } + + public static String combinePaths(XMultiServiceFactory xMSF, String _sFirstPath, String _sSecondPath) throws NoValidPathException + { + boolean bexists = false; + String ReturnPath = ""; + try + { + XInterface xUcbInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, xUcbInterface); + ReturnPath = _sFirstPath + _sSecondPath; + bexists = xSimpleFileAccess.exists(ReturnPath); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + return ""; + } + if (bexists == false) + { + throw new NoValidPathException(xMSF, ""); + } + return ReturnPath; + } + + public static boolean createSubDirectory(XMultiServiceFactory xMSF, XSimpleFileAccess xSimpleFileAccess, String Path) + { + String sNoDirCreation = ""; + try + { + Resource oResource = new Resource(xMSF, "ImportWizard", "imp"); + if (oResource != null) + { + sNoDirCreation = oResource.getResText(1050); + String sMsgDirNotThere = oResource.getResText(1051); + String sQueryForNewCreation = oResource.getResText(1052); + String OSPath = JavaTools.convertfromURLNotation(Path); + String sQueryMessage = JavaTools.replaceSubString(sMsgDirNotThere, OSPath, "%1"); + sQueryMessage = sQueryMessage + (char) 13 + sQueryForNewCreation; + int icreate = SystemDialog.showMessageBox(xMSF, "QueryBox", VclWindowPeerAttribute.YES_NO, sQueryMessage); + if (icreate == 2) + { + xSimpleFileAccess.createFolder(Path); + return true; + } + } + return false; + } + catch (com.sun.star.ucb.CommandAbortedException exception) + { + String sMsgNoDir = JavaTools.replaceSubString(sNoDirCreation, Path, "%1"); + SystemDialog.showMessageBox(xMSF, "ErrorBox", VclWindowPeerAttribute.OK, sMsgNoDir); + return false; + } + catch (com.sun.star.uno.Exception unoexception) + { + String sMsgNoDir = JavaTools.replaceSubString(sNoDirCreation, Path, "%1"); + SystemDialog.showMessageBox(xMSF, "ErrorBox", VclWindowPeerAttribute.OK, sMsgNoDir); + return false; + } + } + + // checks if the root of a path exists. if the parameter xWindowPeer is not null then also the directory is + // created when it does not exists and the user + public static boolean PathisValid(XMultiServiceFactory xMSF, String Path, String sMsgFilePathInvalid, boolean baskbeforeOverwrite) + { + try + { + String SubDir; + String SubDirPath = ""; + int SubLen; + int NewLen; + int RestLen; + boolean bexists; + boolean bSubDirexists = true; + String LowerCasePath; + String NewPath = Path; + XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, xInterface); + if (baskbeforeOverwrite) + { + if (xSimpleFileAccess.exists(Path)) + { + Resource oResource = new Resource(xMSF, "ImportWizard", "imp"); + String sFileexists = oResource.getResText(1053); + String NewString = JavaTools.convertfromURLNotation(Path); + sFileexists = JavaTools.replaceSubString(sFileexists, NewString, "<1>"); + sFileexists = JavaTools.replaceSubString(sFileexists, String.valueOf((char) 13), "<CR>"); + int iLeave = SystemDialog.showMessageBox(xMSF, "QueryBox", VclWindowPeerAttribute.YES_NO, sFileexists); + if (iLeave == 3) + { + return false; + } + } + } + String[] DirArray = JavaTools.ArrayoutofString(Path, "/"); + int MaxIndex = DirArray.length - 1; + if (MaxIndex > 0) + { + for (int i = MaxIndex; i >= 0; i--) + { + SubDir = DirArray[i]; + SubLen = SubDir.length(); + NewLen = NewPath.length(); + RestLen = NewLen - SubLen; + if (RestLen > 0) + { + NewPath = NewPath.substring(0, NewLen - SubLen - 1); + if (i == MaxIndex) + { + SubDirPath = NewPath; + } + bexists = xSimpleFileAccess.exists(NewPath); + if (bexists) + { + LowerCasePath = NewPath.toLowerCase(); + bexists = (((LowerCasePath.equals("file:///")) || (LowerCasePath.equals("file://")) || (LowerCasePath.equals("file:/")) || (LowerCasePath.equals("file:"))) == false); + } + if (bexists) + { + if (bSubDirexists == false) + { + boolean bSubDiriscreated = createSubDirectory(xMSF, xSimpleFileAccess, SubDirPath); + return bSubDiriscreated; + } + return true; + } + else + { + bSubDirexists = false; + } + } + } + } + SystemDialog.showMessageBox(xMSF, "ErrorBox", VclWindowPeerAttribute.OK, sMsgFilePathInvalid); + return false; + } + catch (com.sun.star.uno.Exception exception) + { + exception.printStackTrace(System.out); + SystemDialog.showMessageBox(xMSF, "ErrorBox", VclWindowPeerAttribute.OK, sMsgFilePathInvalid); + return false; + } + } + + /** + * searches a directory for files which start with a certain + * prefix, and returns their URLs and document-titles. + * @param xMSF + * @param FilterName the prefix of the filename. a "-" is added to the prefix ! + * @param FolderName the folder (URL) to look for files... + * @return an array with two array members. The first one, with document titles, + * the second with the corresponding URLs. + * @deprecated please use the getFolderTitles() with ArrayList + */ + public static String[][] getFolderTitles(com.sun.star.lang.XMultiServiceFactory xMSF, String FilterName, String FolderName) + { + String[][] LocLayoutFiles = new String[2][]; //{"",""}{""}; + try + { + java.util.Vector<String> TitleVector = null; + java.util.Vector<String> NameVector = null; + + XInterface xDocInterface = (XInterface) xMSF.createInstance("com.sun.star.document.DocumentProperties"); + XDocumentProperties xDocProps = (XDocumentProperties) UnoRuntime.queryInterface(XDocumentProperties.class, xDocInterface); + + XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + com.sun.star.ucb.XSimpleFileAccess xSimpleFileAccess = (com.sun.star.ucb.XSimpleFileAccess) UnoRuntime.queryInterface(com.sun.star.ucb.XSimpleFileAccess.class, xInterface); + + String[] nameList = xSimpleFileAccess.getFolderContents(FolderName, false); + + TitleVector = new java.util.Vector<String>(/*nameList.length*/); + NameVector = new java.util.Vector<String>(nameList.length); + + FilterName = FilterName == null || FilterName.equals("") ? null : FilterName + "-"; + + String fileName = ""; + PropertyValue[] noArgs = { }; + for (int i = 0; i < nameList.length; i++) + { + fileName = getFilename(nameList[i]); + + if (FilterName == null || fileName.startsWith(FilterName)) + { + xDocProps.loadFromMedium(nameList[i], noArgs); + NameVector.addElement(nameList[i]); + TitleVector.addElement(xDocProps.getTitle()); + } + } + String[] LocNameList = new String[NameVector.size()]; + String[] LocTitleList = new String[TitleVector.size()]; + + NameVector.copyInto(LocNameList); + TitleVector.copyInto(LocTitleList); + LocLayoutFiles[1] = LocNameList; + LocLayoutFiles[0] = LocTitleList; + + JavaTools.bubblesortList(LocLayoutFiles); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + return LocLayoutFiles; + } + + /** + * We search in all given path for a given file + * @param _sPath + * @param _sPath2 + * @return + */ + public static String addPath(String _sPath, String _sPath2) + { + String sNewPath; + if (!_sPath.endsWith("/")) + { + _sPath += "/"; + } + if (_sPath2.startsWith("/")) + { + _sPath2 = _sPath2.substring(1); + } + sNewPath = _sPath + _sPath2; + return sNewPath; + } + + public static String getPathFromList(XMultiServiceFactory xMSF, ArrayList _aList, String _sFile) + { + String sFoundFile = ""; + try + { + XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + com.sun.star.ucb.XSimpleFileAccess xSimpleFileAccess = (com.sun.star.ucb.XSimpleFileAccess) UnoRuntime.queryInterface(com.sun.star.ucb.XSimpleFileAccess.class, xInterface); + + for (int i = 0; i < _aList.size(); i++) + { + String sPath = (String) _aList.get(i); + sPath = addPath(sPath, _sFile); + if (xSimpleFileAccess.exists(sPath)) + { + sFoundFile = sPath; + } + } + } + catch (com.sun.star.uno.Exception e) + { + } + return sFoundFile; + } + + /** + * + * @param xMSF + * @param _sStartFilterName + * @param FolderNames + * @return + * @throws com.sun.star.wizards.common.NoValidPathException + */ + public static String[][] getFolderTitles(com.sun.star.lang.XMultiServiceFactory xMSF, String _sStartFilterName, ArrayList FolderNames) + throws NoValidPathException + { + return getFolderTitles(xMSF, _sStartFilterName, FolderNames, ""); + } + + private static String getTitle(XMultiServiceFactory xMSF, String _sFile) + { + String sTitle = ""; + try + { + XInterface xDocInterface = (XInterface) xMSF.createInstance("com.sun.star.document.DocumentProperties"); + XDocumentProperties xDocProps = (XDocumentProperties) UnoRuntime.queryInterface(XDocumentProperties.class, xDocInterface); + PropertyValue[] noArgs = { }; + xDocProps.loadFromMedium(_sFile, noArgs); + sTitle = xDocProps.getTitle(); + } + catch (Exception e) + { + } + return sTitle; + } + + public static String[][] getFolderTitles(com.sun.star.lang.XMultiServiceFactory xMSF, String _sStartFilterName, ArrayList FolderName, String _sEndFilterName) + throws NoValidPathException + { + String[][] LocLayoutFiles = new String[2][]; //{"",""}{""}; + if (FolderName.size() == 0) + { + throw new NoValidPathException(null, "Path not given."); + } + ArrayList<String> TitleVector = new ArrayList<String>(); + ArrayList<String> URLVector = new ArrayList<String>(); + + com.sun.star.ucb.XSimpleFileAccess xSimpleFileAccess = null; + try + { + XInterface xInterface = (XInterface) xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + xSimpleFileAccess = (com.sun.star.ucb.XSimpleFileAccess) UnoRuntime.queryInterface(com.sun.star.ucb.XSimpleFileAccess.class, xInterface); + } + catch (com.sun.star.uno.Exception e) + { + e.printStackTrace(); + throw new NoValidPathException(null, "Internal error."); + } + + for (int j = 0; j < FolderName.size(); j++) + { + String sFolderName = (String) FolderName.get(j); + + try + { + String[] nameList = xSimpleFileAccess.getFolderContents(sFolderName, false); + _sStartFilterName = _sStartFilterName == null || _sStartFilterName.equals("") ? null : _sStartFilterName + "-"; + + String fileName = ""; + for (int i = 0; i < nameList.length; i++) + { + fileName = getFilename(nameList[i]); + String sTitle; + + if (_sStartFilterName == null || fileName.startsWith(_sStartFilterName)) + { + if (_sEndFilterName.equals("")) + { + sTitle = getTitle(xMSF, nameList[i]); + } + else if (fileName.endsWith(_sEndFilterName)) + { + fileName = fileName.replaceAll(_sEndFilterName + "$", ""); + sTitle = fileName; + } + else + { + // no or wrong (start|end) filter + continue; + } + URLVector.add(nameList[i]); + TitleVector.add(sTitle); + } + } + } + catch (com.sun.star.ucb.CommandAbortedException exception) + { + exception.printStackTrace(System.out); + } + catch (com.sun.star.uno.Exception e) + { + } + } + + String[] LocNameList = new String[URLVector.size()]; + String[] LocTitleList = new String[TitleVector.size()]; + + // LLA: we have to check if this works + URLVector.toArray(LocNameList); + TitleVector.toArray(LocTitleList); + + LocLayoutFiles[1] = LocNameList; + LocLayoutFiles[0] = LocTitleList; + + JavaTools.bubblesortList(LocLayoutFiles); + + return LocLayoutFiles; + } + public XSimpleFileAccess2 fileAccess; + public XFileIdentifierConverter filenameConverter; + + public FileAccess(XMultiServiceFactory xmsf) throws com.sun.star.uno.Exception + { + //get a simple file access... + Object fa = xmsf.createInstance("com.sun.star.ucb.SimpleFileAccess"); + fileAccess = (XSimpleFileAccess2) UnoRuntime.queryInterface(XSimpleFileAccess2.class, fa); + //get the file identifier converter + Object fcv = xmsf.createInstance("com.sun.star.ucb.FileContentProvider"); + filenameConverter = (XFileIdentifierConverter) UnoRuntime.queryInterface(XFileIdentifierConverter.class, fcv); + } + + public String getURL(String parentPath, String childPath) + { + String parent = filenameConverter.getSystemPathFromFileURL(parentPath); + File f = new File(parent, childPath); + String r = filenameConverter.getFileURLFromSystemPath(parentPath, f.getAbsolutePath()); + return r; + } + + public String getURL(String path) + { + File f = new File(path); + String r = filenameConverter.getFileURLFromSystemPath( + path, f.getAbsolutePath()); + return r; + } + + public String getPath(String parentURL, String childURL) + { + return filenameConverter.getSystemPathFromFileURL(parentURL + (((childURL == null || childURL.equals("")) ? "" : "/" + childURL))); + } + + /** + * @author rpiterman + * @param filename + * @return the extension of the given filename. + */ + public static String getExtension(String filename) + { + int p = filename.indexOf("."); + if (p == -1) + { + return ""; + } + else + { + do + { + filename = filename.substring(p + 1); + } + while ((p = filename.indexOf(".")) > -1); + } + return filename; + } + + /** + * @author rpiterman + * @param s + * @return + */ + public boolean mkdir(String s) + { + try + { + fileAccess.createFolder(s); + return true; + } + catch (CommandAbortedException cax) + { + cax.printStackTrace(); + } + catch (com.sun.star.uno.Exception ex) + { + ex.printStackTrace(); + } + return false; + } + + /** + * @author rpiterman + * @param filename + * @param def what to return in case of an exception + * @return true if the given file exists or not. + * if an exception accures, returns the def value. + */ + public boolean exists(String filename, boolean def) + { + try + { + return fileAccess.exists(filename); + } + catch (CommandAbortedException e) + { + } + catch (Exception e) + { + } + + return def; + } + + /** + * @author rpiterman + * @param filename + * @return + */ + public boolean isDirectory(String filename) + { + try + { + return fileAccess.isFolder(filename); + } + catch (CommandAbortedException e) + { + } + catch (Exception e) + { + } + + return false; + } + + /** + * lists the files in a given directory + * @author rpiterman + * @param dir + * @param includeFolders + * @return + */ + public String[] listFiles(String dir, boolean includeFolders) + { + try + { + return fileAccess.getFolderContents(dir, includeFolders); + } + catch (CommandAbortedException e) + { + } + catch (Exception e) + { + } + + return new String[0]; + } + + /** + * @author rpiterman + * @param file + * @return + */ + public boolean delete(String file) + { + try + { + fileAccess.kill(file); + return true; + } + catch (CommandAbortedException e) + { + e.printStackTrace(System.out); + } + catch (Exception e) + { + e.printStackTrace(System.out); + } + + return false; + } + + /** + * @author rpiterman + * @param path + * @return + */ + public static String getFilename(String path) + { + return getFilename(path, "/"); + } + + /** + * return the filename out of a system-dependent path + * @param path + * @return + */ + public static String getPathFilename(String path) + { + return getFilename(path, File.separator); + } + + /** + * @author rpiterman + * @param path + * @param pathSeparator + * @return + */ + public static String getFilename(String path, String pathSeparator) + { + String[] s = JavaTools.ArrayoutofString(path, pathSeparator); + return s[s.length - 1]; + } + + public static String getBasename(String path, String pathSeparator) + { + String filename = getFilename(path, pathSeparator); + String sExtension = getExtension(filename); + String basename = filename.substring(0, filename.length() - (sExtension.length() + 1)); + return basename; + } + + /** + * @author rpiterman + * @param source + * @param target + * @return + */ + public boolean copy(String source, String target) + { + try + { + fileAccess.copy(source, target); + return true; + } + catch (CommandAbortedException e) + { + } + catch (Exception e) + { + } + + return false; + } + + public DateTime getLastModified(String url) + { + try + { + return fileAccess.getDateTimeModified(url); + } + catch (CommandAbortedException e) + { + } + catch (Exception e) + { + } + return null; + } + + /** + * + * @param url + * @return the parent dir of the given url. + * if the path points to file, gives the directory in which the file is. + */ + public static String getParentDir(String url) + { + if (url.endsWith("/")) + { + return getParentDir(url.substring(0, url.length() - 1)); + } + int pos = -1; + int lastPos = 0; + while ((pos = url.indexOf("/", pos + 1)) > -1) + { + lastPos = pos; + } + return url.substring(0, lastPos); + } + + public String createNewDir(String parentDir, String name) + { + String s = getNewFile(parentDir, name, ""); + if (mkdir(s)) + { + return s; + } + else + { + return null; + } + } + + public String getNewFile(String parentDir, String name, String extension) + { + + int i = 0; + String url; + do + { + String filename = filename(name, extension, i++); + String u = getURL(parentDir, filename); + url = u; + } + while (exists(url, true)); + + return url; + } + + private static String filename(String name, String ext, int i) + { + return name + (i == 0 ? "" : String.valueOf(i)) + (ext.equals("") ? "" : "." + ext); + } + + public int getSize(String url) + { + try + { + return fileAccess.getSize(url); + } + catch (Exception ex) + { + return -1; + } + } + + public static String connectURLs(String urlFolder, String urlFilename) + { + return urlFolder + (urlFolder.endsWith("/") ? "" : "/") + + (urlFilename.startsWith("/") ? urlFilename.substring(1) : urlFilename); + } + + public static String[] getDataFromTextFile(XMultiServiceFactory _xMSF, String _filepath) + { + String[] sFileData = null; + try + { + Vector<String> oDataVector = new Vector<String>(); + Object oSimpleFileAccess = _xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"); + XSimpleFileAccess xSimpleFileAccess = (XSimpleFileAccess) com.sun.star.uno.UnoRuntime.queryInterface(XSimpleFileAccess.class, oSimpleFileAccess); + if (xSimpleFileAccess.exists(_filepath)) + { + XInputStream xInputStream = xSimpleFileAccess.openFileRead(_filepath); + Object oTextInputStream = _xMSF.createInstance("com.sun.star.io.TextInputStream"); + XTextInputStream xTextInputStream = (XTextInputStream) UnoRuntime.queryInterface(XTextInputStream.class, oTextInputStream); + XActiveDataSink xActiveDataSink = (XActiveDataSink) UnoRuntime.queryInterface(XActiveDataSink.class, oTextInputStream); + xActiveDataSink.setInputStream(xInputStream); + while (!xTextInputStream.isEOF()) + { + oDataVector.addElement( xTextInputStream.readLine()); + } + xTextInputStream.closeInput(); + sFileData = new String[oDataVector.size()]; + oDataVector.toArray(sFileData); + + } + } + catch (Exception e) + { + e.printStackTrace(System.out); + } + return sFileData; + } + + /** + * shortens a filename to a user displayable representation. + * @param path + * @param maxLength + * @return + */ + public static String getShortFilename(String path, int maxLength) + { + int firstPart = 0; + + if (path.length() > maxLength) + { + if (path.startsWith("/")) + { // unix + int nextSlash = path.indexOf("/", 1) + 1; + firstPart = Math.min(nextSlash, (maxLength - 3) / 2); + } + else + { //windows + firstPart = Math.min(10, (maxLength - 3) / 2); + } + + String s1 = path.substring(0, firstPart); + String s2 = path.substring(path.length() - (maxLength - (3 + firstPart))); + + return s1 + "..." + s2; + } + else + { + return path; + } + } +} |