qadevOOo/runner/graphical/FileHelper.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package graphical;
  20
  21 import java.io.File;
  22 import java.io.FileFilter;
  23 import java.io.FileInputStream;
  24 import java.io.FileOutputStream;
  25 import java.io.InputStream;
  26 import java.io.OutputStream;
  27 import java.util.StringTokenizer;
  28 import helper.OSHelper;
  29
  30 import java.io.PrintStream;
  31 import javax.swing.JOptionPane;
  32
  33 public class FileHelper
  34 {
  35     public FileHelper()
  36         {
  37             // fs = System.getProperty("file.separator");
  38
  39
  40             String sOSName = System.getProperty("os.name");
  41             String sOSArch = System.getProperty("os.arch");
  42             String sOSVersion = System.getProperty("os.version");
  43
  44             GlobalLogWriter.println(sOSName);
  45             GlobalLogWriter.println(sOSArch);
  46             GlobalLogWriter.println(sOSVersion);
  47
  48         }
  49
  50     public static void MessageBox(String _sStr)
  51         {
  52             String sVersion = System.getProperty("java.version");
  53             String sOSName  = System.getProperty("os.name");
  54             JOptionPane.showMessageDialog( null, _sStr, sVersion + " " + sOSName + " Hello World Debugger", JOptionPane.INFORMATION_MESSAGE );
  55         }
  56
  57     public static boolean exists(String _sFile)
  58         {
  59             if (_sFile == null)
  60             {
  61                 return false;
  62             }
  63
  64             File aFile = new File(_sFile);
  65             if (aFile.exists())
  66             {
  67                 return true;
  68             }
  69             // This is just nice for DEBUG behaviour
  70             // due to the fact this is absolutly context dependency no one should use it.
  71             // else
  72             // {
  73             //     System.out.println("FileHelper:exists() tell this path doesn't exists. Check it. path is:" );
  74             //     System.out.println( _sFile );
  75             //     System.out.println( aFile.getAbsolutePath() );
  76             //     MessageBox("Der JavaProzess wartet auf eine interaktion ihrerseits.");
  77             //
  78             //     File aFile2 = new File(_sFile);
  79             //     if (aFile2.exists())
  80             //     {
  81             //         System.out.println("Thanks, file exists." );
  82             //         return true;
  83             //     }
  84             // }
  85             return false;
  86         }
  87
  88     public static boolean isDir(String _sDir)
  89         {
  90             if (_sDir == null)
  91             {
  92                 return false;
  93             }
  94             try
  95             {
  96                 File aFile = new File(_sDir);
  97                 if (aFile.exists() && aFile.isDirectory())
  98                 {
  99                     return true;
 100                 }
 101             }
 102             catch (NullPointerException e)
 103             {
 104                 GlobalLogWriter.println("Exception caught. FileHelper.isDir('" + _sDir + "')");
 105                 e.printStackTrace();
 106             }
 107             return false;
 108         }
 109
 110     public static String getBasename(String _sFilename)
 111         {
 112             if (_sFilename == null)
 113             {
 114                 return "";
 115             }
 116             // String fs = System.getProperty("file.separator");
 117
 118             int nIdx = _sFilename.lastIndexOf("\\");
 119             if (nIdx == -1)
 120             {
 121                 nIdx = _sFilename.lastIndexOf("/");
 122             }
 123             if (nIdx > 0)
 124             {
 125                 return _sFilename.substring(nIdx + 1);
 126             }
 127             return _sFilename;
 128         }
 129
 130     public static String getNameNoSuffix(String _sFilename)
 131         {
 132             if (_sFilename == null)
 133             {
 134                 return "";
 135             }
 136             int nIdx = _sFilename.lastIndexOf(".");
 137             if (nIdx > 0)
 138             {
 139                 return _sFilename.substring(0, nIdx);
 140             }
 141             return _sFilename;
 142         }
 143
 144     public static String getSuffix(String _sFilename)
 145         {
 146             if (_sFilename == null)
 147             {
 148                 return "";
 149             }
 150             int nIdx = _sFilename.lastIndexOf(".");
 151             if (nIdx > 0)
 152             {
 153                 return _sFilename.substring(nIdx );
 154             }
 155             return "";
 156         }
 157
 158     public static String getPath(String _sFilename)
 159         {
 160             if (_sFilename == null)
 161             {
 162                 return "";
 163             }
 164             // String fs = System.getProperty("file.separator");
 165
 166             int nIdx = _sFilename.lastIndexOf("\\");
 167             if (nIdx == -1)
 168             {
 169                 nIdx = _sFilename.lastIndexOf("/");
 170             }
 171             if (nIdx > 0)
 172             {
 173                 return _sFilename.substring(0, nIdx);
 174             }
 175             return "";
 176         }
 177
 178 /*
 179     static ArrayList files = new ArrayList();
 180     public static Object[] traverse( String afileDirectory )
 181         {
 182
 183             File fileDirectory = new File(afileDirectory);
 184             // Testing, if the file is a directory, and if so, it throws an exception
 185             if ( !fileDirectory.isDirectory() )
 186             {
 187                 throw new IllegalArgumentException( "not a directory: " + fileDirectory.getName() );
 188             }
 189
 190             // Getting all files and directories in the current directory
 191             File[] entries = fileDirectory.listFiles();
 192
 193             // Iterating for each file and directory
 194             for ( int i = 0; i < entries.length; ++i )
 195             {
 196                 // adding file to List
 197                 try
 198                 {
 199                     // Composing the URL by replacing all backslashs
 200                     String stringUrl = "file:///"
 201                         + entries[ i ].getAbsolutePath().replace( '\\', '/' );
 202                     files.add(stringUrl);
 203                 }
 204                 catch( Exception exception )
 205                 {
 206                     exception.printStackTrace();
 207                 }
 208             }
 209             return files.toArray();
 210         }
 211 */
 212
 213     // makeDirectories("", "/tmp/a/b");
 214     // creates all directories /tmp/a/b
 215     //
 216     public static void makeDirectories(String first, String path)
 217         {
 218             makeDirectories(first, path, "0777");
 219         }
 220
 221     public static void makeDirectories(String first, String path, String _sMode)
 222         {
 223             String fs = System.getProperty("file.separator");
 224             if (path.startsWith(fs + fs)) // starts with UNC Path
 225             {
 226                 int n = path.indexOf(fs, 2);
 227                 n = path.indexOf(fs, n + 1);
 228                 first = path.substring(0, n);
 229                 path = path.substring(n + 1);
 230             }
 231
 232             String already_done = null;
 233             StringTokenizer path_tokenizer = new StringTokenizer(path,fs,false);
 234             already_done = first;
 235             while (path_tokenizer.hasMoreTokens())
 236             {
 237                 String part = path_tokenizer.nextToken();
 238                 File new_dir = new File(already_done + File.separatorChar + part);
 239                 already_done = new_dir.toString();
 240                 // System.out.println(already_done);
 241                 //create the directory
 242                 new_dir.mkdirs();
 243                 if (OSHelper.isUnix() &&
 244                     _sMode.length() > 0)
 245                 {
 246                     try
 247                     {
 248                         chmod(new_dir, _sMode);
 249                     }
 250                     catch (java.io.IOException e)
 251                     {
 252                         GlobalLogWriter.println("Exception caught. FileHelper.makeDirectories('" + new_dir.getAbsolutePath() + "')");
 253                     }
 254                 }
 255             }
 256             // return;
 257         }
 258
 259     public static void chmod(File file, String mode) throws java.io.IOException
 260         {
 261             Runtime.getRuntime().exec
 262                 (new String[]
 263                     {"chmod", mode, file.getAbsolutePath()});
 264         }
 265
 266     public static String removeFirstDirectorysAndBasenameFrom(String _sName, String _sRemovePath)
 267         {
 268             // pre: _sName: /a/b/c/d/e/f.g _sRemovePath /a/b/c
 269             // result: d/e
 270             String fs = System.getProperty("file.separator");
 271
 272             String sBasename = FileHelper.getBasename(_sName);
 273             String sSubDirs = "";
 274             if (_sName.startsWith(_sRemovePath))
 275             {
 276                 // if _sName starts with _sRemovePath
 277                 int nRemovePathIndex = _sRemovePath.length();
 278                 if (! _sRemovePath.endsWith(fs))
 279                 {
 280                     // add 1 if we not ends with file separator
 281                     nRemovePathIndex ++;
 282                 }
 283                 int nBasenameIndex = _sName.length() - sBasename.length() - 1;
 284                 if (nRemovePathIndex < nBasenameIndex)
 285                 {
 286                     sSubDirs = _sName.substring(nRemovePathIndex, nBasenameIndex);
 287                 }
 288             }
 289             else
 290             {
 291                 // special case, the _sRemovePath is not part of _sName
 292                 sSubDirs = FileHelper.getPath(_sName);
 293                 if (sSubDirs.startsWith(fs))
 294                 {
 295                     // remove leading file separator
 296                     sSubDirs = sSubDirs.substring(1);
 297                 }
 298             }
 299
 300             return sSubDirs;
 301         }
 302
 303     public static void test_removeFirstDirectorysAndBasenameFrom()
 304         {
 305             removeFirstDirectorysAndBasenameFrom("/a/b/c/d/e/f.g", "/a/b/c");
 306             removeFirstDirectorysAndBasenameFrom("/a/b/c/d/e/f.g", "/a/b/c/");
 307             removeFirstDirectorysAndBasenameFrom("/a/b/c/d/e/f.g", "/b/c");
 308         }
 309
 310
 311     public static String getSystemPathFromFileURL( String _sFileURL )
 312     {
 313         String sSystemFile = null;
 314
 315         if(_sFileURL.startsWith("file:///"))
 316         {
 317             if (OSHelper.isWindows())
 318             {
 319                 sSystemFile = _sFileURL.substring(8);
 320             }
 321             else
 322             {
 323                 sSystemFile = _sFileURL.substring(7);
 324             }
 325         }
 326         else if (_sFileURL.startsWith("file://"))
 327         {
 328             sSystemFile = _sFileURL.substring(5);
 329         }
 330         String fs = System.getProperty("file.separator");
 331         if (! fs.equals("/"))
 332         {
 333             sSystemFile = sSystemFile.replace ('/', fs.toCharArray ()[0]);
 334         }
 335 // FEATURE FOR UNC NEED!!!
 336         return sSystemFile;
 337     }
 338
 339     private static boolean m_bDebugTextShown = false;
 340     public static boolean isDebugEnabled()
 341         {
 342             boolean bDebug = false;
 343             String sTmpPath = util.utils.getUsersTempDir();
 344             //util.utils.getUsersTempDir();
 345             String fs = System.getProperty("file.separator");
 346             String sName = sTmpPath + fs + "DOC_COMPARATOR_DEBUG";
 347             File aFile = new File(sName);
 348             if (aFile.exists())
 349             {
 350                 if (m_bDebugTextShown == false)
 351                 {
 352                     GlobalLogWriter.println("Found file: " + sName);
 353                     GlobalLogWriter.println("Activate debug mode.");
 354                     GlobalLogWriter.println("If debug mode is no longer necessary, remove the above file.");
 355                     m_bDebugTextShown = true;
 356                 }
 357                 bDebug = true;
 358             }
 359             return bDebug;
 360         }
 361
 362     private static void copyStream(InputStream _aIn, OutputStream _aOut) throws java.io.IOException
 363     {
 364         byte[] aBuffer = new byte[0xFFFF];
 365         for (int len; (len = _aIn.read(aBuffer)) != -1; )
 366         {
 367             _aOut.write(aBuffer, 0, len);
 368         }
 369     }
 370
 371     public static void copy(String _sSource, String _sDestination)
 372         {
 373             FileInputStream aFIS = null;
 374             FileOutputStream aFOS = null;
 375
 376             try
 377             {
 378                 aFIS = new FileInputStream(_sSource);
 379                 aFOS = new FileOutputStream(_sDestination);
 380                 copyStream(aFIS, aFOS);
 381             }
 382             catch (java.io.IOException e)
 383             {
 384                 System.out.println("Error: caught Exception: " + e.getMessage());
 385             }
 386             finally
 387             {
 388                 if (aFIS != null)
 389                 {
 390                     try
 391                     {
 392                         aFIS.close();
 393                     }
 394                     catch (java.io.IOException e)
 395                     {
 396                         System.out.println("Error: caught Exception: " + e.getMessage());
 397                     }
 398                 }
 399                 if (aFOS != null)
 400                 {
 401                     try
 402                     {
 403                         aFOS.close();
 404                     }
 405                     catch (java.io.IOException e)
 406                     {
 407                         System.out.println("Error: caught Exception: " + e.getMessage());
 408                     }
 409                 }
 410             }
 411
 412 //            try
 413 //            {
 414 //                File inputFile = new File(_sSource);
 415 //                File outputFile = new File(_sDestination);
 416 //
 417 //                java.io.FileReader in = new java.io.FileReader(inputFile);
 418 //                java.io.FileWriter out = new java.io.FileWriter(outputFile);
 419 //                int c;
 420 //
 421 //                while ((c = in.read()) != -1)
 422 //                {
 423 //                    out.write(c);
 424 //                }
 425 //
 426 //                in.close();
 427 //                out.close();
 428 //            }
 429 //            catch (java.io.IOException e)
 430 //            {
 431 //                GlobalLogWriter.get().println("Exception caught. FileHelper.copy('" + _sSource + ", " + _sDestination + "')");
 432 //                GlobalLogWriter.get().println("Message: " + e.getMessage());
 433 //            }
 434         }
 435
 436
 437     /**
 438      * Within the directory run through, it's possible to say which file extension types should not
 439      * consider like '*.prn' because it's not a document.
 440      *
 441      * @return a FileFilter function
 442      */
 443     public static FileFilter getFileFilter()
 444         {
 445             FileFilter aFileFilter = new FileFilter()
 446                 {
 447                     public boolean accept( File pathname )
 448                         {
 449                             // leave out files which started by '~$' these are Microsoft Office temp files
 450                             if (pathname.getName().startsWith("~$"))
 451                             {
 452                                 return false;
 453                             }
 454                             // leave out files starts with '.~lock.' these are OpenOffice.org lock files
 455                             if (pathname.getName().startsWith(".~lock."))
 456                             {
 457                                 return false;
 458                             }
 459                             // leave out files ends with '#' these could be temp files
 460                             if (pathname.getName().endsWith("#"))
 461                             {
 462                                 return false;
 463                             }
 464                             if (pathname.getName().endsWith(".prn"))
 465                             {
 466                                 return false;
 467                             }
 468                             if (pathname.getName().endsWith(".ps"))
 469                             {
 470                                 return false;
 471                             }
 472                             // This type of document no one would like to load.
 473                             if (pathname.getName().endsWith(".zip"))
 474                             {
 475                                 return false;
 476                             }
 477                             // just a hack
 478                             if (pathname.getName().endsWith("_"))
 479                             {
 480                                 return false;
 481                             }
 482                             return true;
 483                         }
 484                 };
 485             return aFileFilter;
 486         }
 487     /**
 488      * Within the directory run through, it's possible to say which file extension types should not
 489      * consider like '*.prn' because it's not a document.
 490      *
 491      * @return a FileFilter function
 492      */
 493     public static FileFilter getFileFilterPSorPDF()
 494         {
 495             FileFilter aFileFilter = new FileFilter()
 496                 {
 497                     public boolean accept( File pathname )
 498                         {
 499                             if (pathname.getName().endsWith(".ps"))
 500                             {
 501                                 return true;
 502                             }
 503                             if (pathname.getName().endsWith(".pdf"))
 504                             {
 505                                 return true;
 506                             }
 507                             return false;
 508                         }
 509                 };
 510             return aFileFilter;
 511         }
 512     /**
 513      * Within the directory run through, it's possible to say which file extension types should not
 514      * consider like '*.prn' because it's not a document.
 515      *
 516      * @return a FileFilter function
 517      */
 518     public static FileFilter getFileFilterJPEG()
 519         {
 520             FileFilter aFileFilter = new FileFilter()
 521                 {
 522                     public boolean accept( File pathname )
 523                         {
 524                             if (pathname.getName().toLowerCase().endsWith(".jpg"))
 525                             {
 526                                 return true;
 527                             }
 528                             if (pathname.getName().toLowerCase().endsWith(".jpeg"))
 529                             {
 530                                 return true;
 531                             }
 532                             return false;
 533                         }
 534                 };
 535             return aFileFilter;
 536         }
 537     /**
 538      * Within the directory run through, it's possible to say which file extension types should not
 539      * consider like '*.ini' because it's not a document.
 540      *
 541      * @return a FileFilter function
 542      */
 543     public static FileFilter getFileFilterINI()
 544         {
 545             FileFilter aFileFilter = new FileFilter()
 546                 {
 547                     public boolean accept( File pathname )
 548                         {
 549                             String sPathname = pathname.getName().toLowerCase();
 550                             if (sPathname.endsWith("index.ini"))
 551                             {
 552                                 // don't consider the index.ini file
 553                                 return false;
 554                             }
 555                             if (sPathname.endsWith(".ini"))
 556                             {
 557                                 return true;
 558                             }
 559                             return false;
 560                         }
 561                 };
 562             return aFileFilter;
 563         }
 564
 565         public static String appendPath(String _sPath, String _sRelativePathToAdd)
 566         {
 567             String sNewPath = _sPath;
 568             String fs = System.getProperty("file.separator");
 569             if (_sPath.startsWith("file:"))
 570             {
 571                 fs = "/";                                  // we use a file URL so only '/' is allowed.
 572             }
 573             if (! (sNewPath.endsWith("/") || sNewPath.endsWith("\\") ) )
 574             {
 575                 sNewPath += fs;
 576             }
 577             sNewPath += _sRelativePathToAdd;
 578             return sNewPath;
 579         }
 580
 581     // -----------------------------------------------------------------------------
 582     public static void createInfoFile(String _sFile, ParameterHelper _aGTA)
 583         {
 584             createInfoFile(_sFile, _aGTA, "");
 585         }
 586
 587     public static void createInfoFile(String _sFile, ParameterHelper _aGTA, String _sSpecial)
 588         {
 589             String sFilename;
 590             if (_sFile.startsWith("file://"))
 591             {
 592                 sFilename = FileHelper.getSystemPathFromFileURL(_sFile);
 593                 GlobalLogWriter.println("CreateInfoFile: '" + sFilename + "'" );
 594             }
 595             else
 596             {
 597                 sFilename = _sFile;
 598             }
 599             String sFileDir = FileHelper.getPath(sFilename);
 600             String sBasename = FileHelper.getBasename(sFilename);
 601             String sNameNoSuffix = FileHelper.getNameNoSuffix(sBasename);
 602
 603             String sIniFile = FileHelper.appendPath(sFileDir, sBasename + ".ini");
 604             IniFile aIniFile = new IniFile(sIniFile);
 605
 606             // OLD INFO FILE
 607
 608             System.getProperty("line.separator");
 609             String sInfoFilename = FileHelper.appendPath(sFileDir, sNameNoSuffix + ".info");
 610             File aInfoFile = new File(sInfoFilename);
 611
 612             String sBuildID = "";
 613
 614             try
 615             {
 616                 FileOutputStream out2 = new FileOutputStream(aInfoFile.toString());
 617                 PrintStream out = new PrintStream(out2);
 618
 619                 out.println("# automatically created file by graphical compare");
 620                 if (_aGTA != null)
 621                 {
 622                     if (_sSpecial != null && _sSpecial.equals("msoffice"))
 623                     {
 624                         out.println("# buildid from wordloadfile");
 625                         sBuildID = _aGTA.getPerformance().getMSOfficeVersion();
 626                         out.println("buildid=" + sBuildID);
 627                     }
 628                     else
 629                     {
 630                         out.println("# buildid is read out of the bootstrap file");
 631                         sBuildID = _aGTA.getBuildID();
 632                         out.println("buildid=" + sBuildID);
 633                     }
 634                     aIniFile.insertValue("global", "buildid", sBuildID);
 635
 636                     // if (_sSpecial != null && _sSpecial.length() > 0)
 637                     // {
 638                     //    out.write("special=" + _sSpecial + ls);
 639                     // }
 640                     out.println();
 641                     out.println("# resolution given in DPI");
 642                     out.println("resolution=" + _aGTA.getResolutionInDPI());
 643                     aIniFile.insertValue("global", "resolution", _aGTA.getResolutionInDPI());
 644                 }
 645                 else
 646                 {
 647                     out.println("buildid=" + _sSpecial);
 648                     aIniFile.insertValue("global", "buildid", _sSpecial);
 649                 }
 650
 651                 // long nTime = stopTimer();
 652                 // if (nTime != 0)
 653                 // {
 654                 //     out.write("# time is given in milli seconds" + ls);
 655                 //     out.write("time=" + nTime + ls);
 656                 // }
 657
 658                 out.println();
 659                 out.println("# Values out of System.getProperty(...)");
 660                 out.println("os.name=" + System.getProperty("os.name"));
 661                 out.println("os.arch=" + System.getProperty("os.arch"));
 662                 out.println("os.version=" + System.getProperty("os.version"));
 663
 664                 aIniFile.insertValue("global", "os.name", System.getProperty("os.name"));
 665                 aIniFile.insertValue("global", "os.arch", System.getProperty("os.arch"));
 666                 aIniFile.insertValue("global", "os.version", System.getProperty("os.version"));
 667
 668                 if (_aGTA != null)
 669                 {
 670                     out.println();
 671                     out.println("# Performance output, values are given in milli sec.");
 672                     _aGTA.getPerformance().print(out);
 673                     _aGTA.getPerformance().print(aIniFile, "global");
 674                 }
 675
 676                 out.flush();
 677                 out.close();
 678                 out2.close();
 679             }
 680             catch (java.io.IOException e)
 681             {
 682                 GlobalLogWriter.println("can't create Info file.");
 683                 e.printStackTrace();
 684             }
 685             aIniFile.close();
 686
 687 //            String sExtension = FileHelper.getSuffix(_aGTA.getInputFile());
 688 //            if (sExtension.startsWith("."))
 689 //            {
 690 //                sExtension = sExtension.substring(1);
 691 //            }
 692 //
 693 //            DB.writeToDB(_aGTA.getInputFile(),
 694 //                         sNameNoSuffix,
 695 //                         sExtension,
 696 //                         sBuildID,
 697 //                         _aGTA.getReferenceType(),
 698 //                         _aGTA.getResolutionInDPI()
 699 //                         );
 700         }
 701
 702         public static void addBasenameToFile(String _sIndexFilename, String _sBasename, String _sCreator, String _sType, String _sSource)
 703         {
 704             // String sOutputDir = FileHelper.getPath(_sOutputFilename);
 705             String sPath;
 706             if (_sIndexFilename.startsWith("file:"))
 707             {
 708                 sPath = FileHelper.getSystemPathFromFileURL(_sIndexFilename);
 709             }
 710             else
 711             {
 712                 sPath = _sIndexFilename;
 713             }
 714             String sIndexFilename = sPath; // FileHelper.appendPath(sPath, _sFilename);
 715             IniFile aIniFile = new IniFile(sIndexFilename);
 716             aIniFile.insertValue(_sBasename, "creator", _sCreator);
 717             aIniFile.insertValue(_sBasename, "type", _sType);
 718             aIniFile.insertValue(_sBasename, "source", _sSource);
 719             aIniFile.close();
 720 //            File aFile = new File(sIndexFilename);
 721 //            try
 722 //            {
 723 //                RandomAccessFile aRandomAccess = new RandomAccessFile(aFile, "rw");
 724 //                // String sBasename = FileHelper.getBasename(_sOutputFilename);
 725 //                aRandomAccess.seek(aRandomAccess.length()); // jump to the end.
 726 //// TODO: seems to be wrong, there exist no writeLine() with 'return' ending?
 727 //                aRandomAccess.writeUTF(_sBasename);
 728 //                aRandomAccess.close();
 729 //            }
 730 //            catch (java.io.FileNotFoundException e)
 731 //            {
 732 //            }
 733 //            catch (java.io.IOException e)
 734 //            {
 735 //            }
 736         }
 737
 738         public static void addBasenameToPostscript(String _sOutputFilename)
 739         {
 740             String sIndexFilename = FileHelper.appendPath(_sOutputFilename, "postscript.ini");
 741             // String sPath = FileHelper.getPath(sIndexFilename);
 742             String sBasename = FileHelper.getBasename(_sOutputFilename);
 743             addBasenameToFile(sIndexFilename, sBasename, "", "", "");
 744         }
 745         public static void addBasenameToIndex(String _sOutputFilename, String _sBasename, String _sCreator, String _sType, String _sSource)
 746         {
 747             String sIndexFilename = FileHelper.appendPath(_sOutputFilename, "index.ini");
 748             // String sPath = FileHelper.getPath(sIndexFilename);
 749             // String sBasename = FileHelper.getBasename(_sOutputFilename);
 750             addBasenameToFile(sIndexFilename, _sBasename, _sCreator, _sType, _sSource);
 751         }
 752
 753 }
 754