/*************************************************************************
*
 *  OpenOffice.org - a multi-platform office productivity suite
 *
 *  $RCSfile: FileAccess.java,v $
 *
 *  $Revision: 1.11 $
 *
 *  last change: $Author: obo $ $Date: 2006-07-13 12:13:13 $
 *
 *  The Contents of this file are made available subject to
 *  the terms of GNU Lesser General Public License Version 2.1.
 *
 *
 *    GNU Lesser General Public License Version 2.1
 *    =============================================
 *    Copyright 2005 by Sun Microsystems, Inc.
 *    901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License version 2.1, as published by the Free Software Foundation.
 *
 *    This library 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 for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *    MA  02111-1307  USA
 *
 ************************************************************************/package com.sun.star.wizards.common;
import com.sun.star.beans.XPropertySet;
import java.io.File;
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;

/**
 * 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, ";");
        boolean badd = false;
        int MaxIndex = PathList.length - 1;
        int iPos;
        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 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
    */

    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 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 String combinePaths(XMultiServiceFactory xMSF, String FirstPath, String SecondPath) 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 = FirstPath + SecondPath;
            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.
     */
    public static String[][] getFolderTitles(com.sun.star.lang.XMultiServiceFactory xMSF, String FilterName, String FolderName) {
        String[][] LocLayoutFiles = new String[2][]; //{"",""}{""};
        try {
            java.util.Vector TitleVector = null;
            java.util.Vector NameVector = null;

            XInterface xDocInterface = (XInterface) xMSF.createInstance("com.sun.star.document.StandaloneDocumentInfo");
            com.sun.star.document.XStandaloneDocumentInfo xDocInfo = (com.sun.star.document.XStandaloneDocumentInfo) UnoRuntime.queryInterface(com.sun.star.document.XStandaloneDocumentInfo.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(nameList.length);
            NameVector = new java.util.Vector(nameList.length);

            FilterName = FilterName == null || FilterName.equals("") ? null : FilterName + "-";

            String fileName = "";
            for (int i = 0; i < nameList.length; i++) {
                fileName = getFilename( nameList[i] );

                if (FilterName == null || fileName.startsWith(FilterName)) {

                    xDocInfo.loadFromURL(nameList[i]);
                    NameVector.addElement(nameList[i]);
                    TitleVector.addElement(com.sun.star.uno.AnyConverter.toString(Helper.getUnoPropertyValue(xDocInterface, "Title")));

                }
            }
            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;
    }

    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
     * @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;
    }

    /**
     *
     * @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 oDataVector = new Vector();
            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((String) 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;
    }
}
