qadevOOo/runner/graphical/FileHelper.java

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