qadevOOo/runner/convwatch/OfficePrint.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 convwatch;
  20
  21 import java.io.File;
  22 import java.util.ArrayList;
  23 import java.io.FileWriter;
  24
  25 import com.sun.star.uno.UnoRuntime;
  26 import com.sun.star.lang.XMultiServiceFactory;
  27 import com.sun.star.document.XTypeDetection;
  28 import com.sun.star.container.XNameAccess;
  29 import com.sun.star.frame.XDesktop;
  30 import com.sun.star.beans.XPropertySet;
  31 import com.sun.star.beans.PropertyValue;
  32 import com.sun.star.frame.XComponentLoader;
  33 import com.sun.star.lang.XComponent;
  34 import com.sun.star.frame.XStorable;
  35 import com.sun.star.view.XPrintable;
  36 import com.sun.star.lang.XServiceInfo;
  37 import com.sun.star.frame.XModel;
  38 import com.sun.star.uno.AnyConverter;
  39
  40 import helper.URLHelper;
  41 import helper.PropertyHelper;
  42 import helper.OSHelper;
  43 // import convwatch.FileHelper;
  44 // import convwatch.MSOfficePrint;
  45 // import convwatch.GraphicalTestArguments;
  46 // import convwatch.ConvWatchCancelException;
  47
  48 // import helper.Parameter;
  49
  50 /**
  51  * This Object is to print a given document with OpenOffice.org / StarOffice
  52  * over the normal printer driver
  53  * or over it's pdf exporter
  54  */
  55 public class OfficePrint {
  56
  57
  58 //     static long m_nStartTime;
  59 //     // static Date m_aDateCache = null;
  60 //
  61 //     /*
  62 //       simple helper functions to start/stop a timer, to know how long a process need in milliseconds
  63 //      */
  64 //     public static void startTimer()
  65 //         {
  66 //             // if (m_aDateCache == null)
  67 //             // {
  68 //             //     m_aDateCache = new Date();
  69 //             // }
  70 //             // m_nStartTime = m_aDateCache.getTime();
  71 //             m_nStartTime = System.currentTimeMillis();
  72 //         }
  73 //     public static long stopTimer()
  74 //         {
  75 //             // if (m_aDateCache == null)
  76 //             // {
  77 //             //     System.out.println("Forgotten to initialise start timer.");
  78 //             //     return 0;
  79 //             // }
  80 //             // long m_nStopTime = m_aDateCache.getTime();
  81 //             if (m_nStartTime == 0)
  82 //             {
  83 //                 System.out.println("Forgotten to initialise start timer.");
  84 //                 return 0;
  85 //             }
  86 //             long m_nStopTime = System.currentTimeMillis();
  87 //             return m_nStopTime - m_nStartTime;
  88 //         }
  89
  90
  91     private static void showProperty(PropertyValue _aValue)
  92         {
  93             String sName = _aValue.Name;
  94             String sValue;
  95             try
  96             {
  97                 sValue = AnyConverter.toString(_aValue.Value);
  98                 GlobalLogWriter.get().println("Property " + sName + ":=" + sValue);
  99             }
 100             catch (com.sun.star.lang.IllegalArgumentException e)
 101             {
 102                 // GlobalLogWriter.get().println("showProperty: can't convert a object to string.");
 103                 GlobalLogWriter.get().println("Property " + sName + ":= a Object which can't convert by AnyConverter()");
 104             }
 105         }
 106
 107     /**
 108      * shows the FilterName and MediaType from the given XComponent
 109      */
 110     static String getDocumentType( XComponent _aDoc )
 111         {
 112             XModel xModel =  UnoRuntime.queryInterface( XModel.class, _aDoc);
 113             PropertyValue[] aArgs = xModel.getArgs();
 114             for (int i=0;i<aArgs.length;i++)
 115             {
 116                 PropertyValue aValue = aArgs[i];
 117                 // System.out.print("Property: '" + aValue.Name);
 118                 // System.out.println("' := '" + aValue.Value + "'");
 119                 if (aValue.Name.equals("FilterName") ||
 120                     aValue.Name.equals("MediaType"))
 121                 {
 122                     String sNameValue = "'" + aValue.Name + "' := '" + aValue.Value + "'";
 123                     return sNameValue;
 124                 }
 125             }
 126             return "";
 127         }
 128
 129     static void showDocumentType( XComponent _aDoc )
 130         {
 131             String sNameValue = getDocumentType(_aDoc);
 132             GlobalLogWriter.get().println("  Property: '" + sNameValue);
 133         }
 134     /**
 135      * load a OpenOffice.org document from a given URL (_sInputURL)
 136      * the GraphicalTestArguments must contain a living MultiServiceFactory object
 137      * or we crash here.
 138      * Be aware, the ownership of the document gets to you, you have to close it.
 139      * @param _aGTA
 140      * @param _sInputURL
 141      * @return
 142      */
 143     public static XComponent loadFromURL(GraphicalTestArguments _aGTA,
 144                                          String _sInputURL)
 145         {
 146             XComponent aDoc = null;
 147             try
 148             {
 149                 if (_aGTA.getMultiServiceFactory() == null)
 150                 {
 151                     GlobalLogWriter.get().println("MultiServiceFactory in GraphicalTestArgument not set.");
 152                     return null;
 153                 }
 154                 Object oDsk = _aGTA.getMultiServiceFactory().createInstance("com.sun.star.frame.Desktop");
 155                 XDesktop aDesktop = UnoRuntime.queryInterface(XDesktop.class, oDsk);
 156
 157                 if (aDesktop != null)
 158                 {
 159                     GlobalLogWriter.get().println("com.sun.star.frame.Desktop created.");
 160                     // String sInputURL = aCurrentParameter.sInputURL;
 161                     // String sOutputURL = aCurrentParameter.sOutputURL;
 162                     // String sPrintFileURL = aCurrentParameter.sPrintToFileURL;
 163                     // System.out.println(_sInputURL);
 164
 165
 166                     // set here the loadComponentFromURL() properties
 167                     // at the moment only 'Hidden' is set, so no window is opened at work
 168
 169                     ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>();
 170
 171                     // check which properties should set and count it.
 172                     // if (_aGTA.isHidden())
 173                     // {
 174                     //     nPropertyCount ++;
 175                     // }
 176                     // if (_aGTA.getImportFilterName() != null && _aGTA.getImportFilterName().length() > 0)
 177                     // {
 178                     //     nPropertyCount ++;
 179                     // }
 180
 181                     // initialize the propertyvalue
 182                     // int nPropertyIndex = 0;
 183                     // aProps = new PropertyValue[ nPropertyCount ];
 184
 185                     // set all property values
 186                     if (_aGTA.isHidden())
 187                     {
 188                         PropertyValue Arg = new PropertyValue();
 189                         Arg.Name = "Hidden";
 190                         Arg.Value = Boolean.TRUE;
 191                         aPropertyList.add(Arg);
 192                         showProperty(Arg);
 193                     }
 194                     if (_aGTA.getImportFilterName() != null && _aGTA.getImportFilterName().length() > 0)
 195                     {
 196                         PropertyValue Arg = new PropertyValue();
 197                         Arg.Name = "FilterName";
 198                         Arg.Value = _aGTA.getImportFilterName();
 199                         aPropertyList.add(Arg);
 200                         showProperty(Arg);
 201                     }
 202
 203                     GlobalLogWriter.get().println(DateHelper.getDateTimeForHumanreadableLog() + " Load document");
 204                     // GlobalLogWriter.get().flush();
 205
 206                     XComponentLoader aCompLoader = UnoRuntime.queryInterface( XComponentLoader.class, aDesktop);
 207
 208                     // XComponent aDoc = null;
 209
 210                     _aGTA.getPerformance().startTime(PerformanceContainer.Load);
 211                     aDoc = aCompLoader.loadComponentFromURL(_sInputURL, "_blank", 0, PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList) );
 212                     _aGTA.getPerformance().stopTime(PerformanceContainer.Load);
 213                     if (aDoc != null)
 214                     {
 215                         GlobalLogWriter.get().println(DateHelper.getDateTimeForHumanreadableLog() + " Load document done.");
 216                         showDocumentType(aDoc);
 217                         _aGTA.setDocumentType(getDocumentType(aDoc));
 218                     }
 219                     else
 220                     {
 221                         GlobalLogWriter.get().println(" Load document failed.");
 222                         if (_aGTA.getImportFilterName() != null && _aGTA.getImportFilterName().length() > 0)
 223                         {
 224                             GlobalLogWriter.get().println(" Please check FilterName := '" + _aGTA.getImportFilterName() + "'");
 225                         }
 226                         GlobalLogWriter.get().println("");
 227                     }
 228                 }
 229                 else
 230                 {
 231                     GlobalLogWriter.get().println("com.sun.star.frame.Desktop failed.");
 232                 }
 233             }
 234             catch ( com.sun.star.uno.Exception e )
 235             {
 236                 // Some exception occures.FAILED
 237                 GlobalLogWriter.get().println("UNO Exception caught.");
 238                 GlobalLogWriter.get().println("Message: " + e.getMessage());
 239                 e.printStackTrace();
 240                 aDoc = null;
 241             }
 242             return aDoc;
 243         }
 244
 245     static boolean exportToPDF(XComponent _xComponent, String _sDestinationName)
 246         {
 247             XServiceInfo xServiceInfo =
 248                  UnoRuntime.queryInterface(
 249                     XServiceInfo.class, _xComponent
 250                     );
 251
 252             ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>();
 253             PropertyValue aFiltername = new PropertyValue();
 254             aFiltername.Name = "FilterName";
 255             aFiltername.Value = getFilterName_forPDF(xServiceInfo);
 256             aPropertyList.add(aFiltername);
 257             showProperty(aFiltername);
 258             boolean bWorked = true;
 259
 260             try
 261             {
 262                 XStorable store =
 263                      UnoRuntime.queryInterface(
 264                         XStorable.class, _xComponent
 265                         );
 266                 store.storeToURL(_sDestinationName, PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList));
 267             }
 268             catch (com.sun.star.io.IOException e)
 269             {
 270                 GlobalLogWriter.get().println("IO Exception caught.");
 271                 GlobalLogWriter.get().println("Message: " + e.getMessage());
 272                 bWorked = false;
 273             }
 274
 275             return bWorked;
 276         }
 277
 278     static String getFilterName_forPDF(XServiceInfo xServiceInfo)
 279         {
 280             String filterName = "";
 281
 282             if (xServiceInfo.supportsService("com.sun.star.text.TextDocument"))
 283             {
 284                 //writer
 285                 filterName = "writer_pdf_Export";
 286             }
 287             else if ( xServiceInfo.supportsService( "com.sun.star.sheet.SpreadsheetDocument" ) )
 288             {
 289                 //calc
 290                 filterName = "calc_pdf_Export";
 291             }
 292             else if ( xServiceInfo.supportsService( "com.sun.star.drawing.DrawingDocument" ) )
 293             {
 294                 //draw
 295                 filterName = "draw_pdf_Export";
 296             }
 297             else if ( xServiceInfo.supportsService( "com.sun.star.presentation.PresentationDocument" ) )
 298             {
 299                 //impress
 300                 filterName = "impress_pdf_Export";
 301             }
 302             else if (xServiceInfo.supportsService("com.sun.star.text.WebDocument"))
 303             {
 304                 //html document
 305                 filterName = "writer_web_pdf_Export";
 306             }
 307             else if ( xServiceInfo.supportsService("com.sun.star.text.GlobalDocument") )
 308             {
 309                 //master document
 310                 filterName = "writer_globaldocument_pdf_Export";
 311             }
 312             else if ( xServiceInfo.supportsService( "com.sun.star.formulaFormulaProperties" ) )
 313             {
 314                 //math document
 315                 filterName = "math_pdf_Export";
 316             }
 317
 318             return filterName;
 319         }
 320
 321     // -----------------------------------------------------------------------------
 322
 323     public static boolean storeAsPDF(GraphicalTestArguments _aGTA,
 324                                      String _sInputURL,
 325                                      String _sOutputURL)
 326         {
 327             boolean bBack = false;
 328             XComponent aDoc = loadFromURL(_aGTA, _sInputURL);
 329
 330             if (aDoc == null)
 331             {
 332                 GlobalLogWriter.get().println("Can't load document.");
 333                 return bBack;
 334             }
 335             bBack = storeAsPDF(_aGTA, aDoc, _sOutputURL);
 336             createInfoFile(_sOutputURL, _aGTA, "as pdf");
 337
 338             GlobalLogWriter.get().println("Close document.");
 339             aDoc.dispose();
 340             return bBack;
 341         }
 342
 343     public static boolean storeAsPDF(GraphicalTestArguments _aGTA,
 344                                      XComponent _aDoc,
 345                                      String _sOutputURL)
 346         {
 347             // try {
 348             boolean bBack = true;
 349             _aGTA.getPerformance().startTime(PerformanceContainer.StoreAsPDF);
 350             bBack = exportToPDF(_aDoc, _sOutputURL);
 351             _aGTA.getPerformance().stopTime(PerformanceContainer.StoreAsPDF);
 352
 353             if (!bBack)
 354             {
 355                 GlobalLogWriter.get().println("Can't store document as PDF.");
 356                 bBack = false;
 357             }
 358             return bBack;
 359         }
 360
 361     // -----------------------------------------------------------------------------
 362
 363     /**
 364      * print the document found in file (_sInputURL) to as postscript to file (_sPrintFileURL)
 365      * Due to the fact we use a printer to convert the file to postscript, the default printer
 366      * to create such postscript format must be installed, this is not tested here.
 367      *
 368      * @param _aGTA
 369      * @param _sInputURL
 370      * @param _sOutputURL
 371      * @param _sPrintFileURL
 372      * @return true, if print has been done.
 373      *         Be careful, true means only print returns with no errors, to be sure print is really done
 374      *         check existance of _sPrintFileURL
 375      */
 376
 377     public static boolean printToFileWithOOo(GraphicalTestArguments _aGTA,
 378                                              String _sInputURL,
 379                                              String _sOutputURL,
 380                                              String _sPrintFileURL)
 381         {
 382             // waitInSeconds(1);
 383             boolean bBack = false;
 384
 385             XComponent aDoc = loadFromURL(_aGTA, _sInputURL);
 386             if (aDoc != null)
 387             {
 388                 if ( _sInputURL.equals(_sOutputURL) )
 389                 {
 390                     // don't store document
 391                     // input and output are equal OR
 392                     GlobalLogWriter.get().println("Warning: Inputpath and Outputpath are equal. Document will not stored again.");
 393                     _aGTA.disallowStore();
 394                 }
 395                 bBack = impl_printToFileWithOOo(_aGTA, aDoc, _sOutputURL, _sPrintFileURL);
 396
 397                 GlobalLogWriter.get().println("Close document.");
 398                 aDoc.dispose();
 399             }
 400             else
 401             {
 402                 GlobalLogWriter.get().println("loadDocumentFromURL() failed with document: " + _sInputURL);
 403             }
 404             return bBack;
 405         }
 406
 407     // -----------------------------------------------------------------------------
 408     public static void createInfoFile(String _sFile, GraphicalTestArguments _aGTA)
 409         {
 410             createInfoFile(_sFile, _aGTA, "");
 411         }
 412
 413     public static void createInfoFile(String _sFile, GraphicalTestArguments _aGTA, String _sSpecial)
 414         {
 415             String sFilename;
 416             if (_sFile.startsWith("file://"))
 417             {
 418                 sFilename = FileHelper.getSystemPathFromFileURL(_sFile);
 419                 GlobalLogWriter.get().println("CreateInfoFile: '" + sFilename + "'" );
 420             }
 421             else
 422             {
 423                 sFilename = _sFile;
 424             }
 425             String sFileDir = FileHelper.getPath(sFilename);
 426             String sBasename = FileHelper.getBasename(sFilename);
 427             String sNameNoSuffix = FileHelper.getNameNoSuffix(sBasename);
 428
 429             String fs = System.getProperty("file.separator");
 430             String ls = System.getProperty("line.separator");
 431             String sInfoFilename = sFileDir + fs + sNameNoSuffix + ".info";
 432             File aInfoFile = new File(sInfoFilename);
 433
 434             String sBuildID = "";
 435
 436             try
 437             {
 438                 FileWriter out = new FileWriter(aInfoFile.toString());
 439                 out.write("# automatically created file by graphical compare" + ls);
 440                 if (_aGTA != null)
 441                 {
 442                     if (_sSpecial != null && _sSpecial.equals("msoffice"))
 443                     {
 444                         out.write("# buildid from wordloadfile" + ls);
 445                         sBuildID = _aGTA.getPerformance().getMSOfficeVersion();
 446                         out.write("buildid=" + sBuildID + ls);
 447                     }
 448                     else
 449                     {
 450                         out.write("# buildid is read out of the bootstrap file" + ls);
 451                         sBuildID = _aGTA.getBuildID();
 452                         out.write("buildid=" + sBuildID + ls);
 453                     }
 454                     // if (_sSpecial != null && _sSpecial.length() > 0)
 455                     // {
 456                     //    out.write("special=" + _sSpecial + ls);
 457                     // }
 458                     out.write(ls);
 459                     out.write("# resolution given in DPI" + ls);
 460                     out.write("resolution=" + _aGTA.getResolutionInDPI() + ls);
 461                 }
 462                 else
 463                 {
 464                     out.write("buildid=" + _sSpecial + ls);
 465                 }
 466                 // long nTime = stopTimer();
 467                 // if (nTime != 0)
 468                 // {
 469                 //     out.write("# time is given in milli seconds" + ls);
 470                 //     out.write("time=" + nTime + ls);
 471                 // }
 472
 473                 out.write(ls);
 474                 out.write("# Values out of System.getProperty(...)" + ls);
 475                 out.write("os.name=" + System.getProperty("os.name") + ls);
 476                 out.write("os.arch=" + System.getProperty("os.arch") + ls);
 477                 out.write("os.version=" + System.getProperty("os.version") + ls);
 478
 479                 if (_aGTA != null)
 480                 {
 481                     out.write(ls);
 482                     out.write("# Performance output, values are given in milli sec." + ls);
 483                     _aGTA.getPerformance().print(out);
 484                 }
 485
 486                 out.flush();
 487                 out.close();
 488             }
 489             catch (java.io.IOException e)
 490             {
 491                 GlobalLogWriter.get().println("can't create Info file.");
 492                 e.printStackTrace();
 493             }
 494
 495             String sExtension = FileHelper.getSuffix(_aGTA.getInputFile());
 496             if (sExtension.startsWith("."))
 497             {
 498                 sExtension = sExtension.substring(1);
 499             }
 500
 501             DB.writeToDB(_aGTA.getInputFile(),
 502                          sNameNoSuffix,
 503                          sExtension,
 504                          sBuildID,
 505                          _aGTA.getReferenceType(),
 506                          _aGTA.getResolutionInDPI()
 507                          );
 508         }
 509
 510
 511
 512     // -----------------------------------------------------------------------------
 513     private static boolean impl_printToFileWithOOo(GraphicalTestArguments _aGTA,
 514                                                    XComponent _aDoc,
 515                                                    String _sOutputURL,
 516                                                    String _sPrintFileURL)
 517         {
 518             boolean bBack = false;
 519             boolean bFailed = true;              // always be a pessimist,
 520             if (_aDoc == null)
 521             {
 522                 GlobalLogWriter.get().println("No document is given.");
 523                 return bBack;
 524             }
 525
 526             try
 527             {
 528                 if (_sOutputURL != null)
 529                 {
 530                     if (_aGTA.isStoreAllowed())
 531                     {
 532                         // store the document in an other directory
 533                         XStorable aStorable = UnoRuntime.queryInterface( XStorable.class, _aDoc);
 534                         if (aStorable != null)
 535                         {
 536                             PropertyValue [] szEmptyArgs = new PropertyValue [0];
 537
 538                             GlobalLogWriter.get().println(DateHelper.getDateTimeForHumanreadableLog() + " Store document.");
 539                             _aGTA.getPerformance().startTime(PerformanceContainer.Store);
 540                             aStorable.storeAsURL(_sOutputURL, szEmptyArgs);
 541                             _aGTA.getPerformance().stopTime(PerformanceContainer.Store);
 542
 543                             GlobalLogWriter.get().println(DateHelper.getDateTimeForHumanreadableLog() + " Store document done.");
 544                             TimeHelper.waitInSeconds(2, "After store as URL to:" + _sOutputURL);
 545                             GlobalLogWriter.get().println("Reload stored file test.");
 546                             XComponent aDoc = loadFromURL(_aGTA, _sOutputURL);
 547                             if (aDoc == null)
 548                             {
 549                                 GlobalLogWriter.get().println("Reload stored file test failed, can't reload file: " + _sOutputURL);
 550                             }
 551                         }
 552                     }
 553                 }
 554             }
 555             catch ( com.sun.star.uno.Exception e )
 556             {
 557                 // Some exception occures.FAILED
 558                 GlobalLogWriter.get().println("UNO Exception caught.");
 559                 GlobalLogWriter.get().println("Message: " + e.getMessage());
 560
 561                 e.printStackTrace();
 562                 bBack = false;
 563             }
 564
 565             try
 566             {
 567
 568                 // System.out.println("Document loaded.");
 569                 // Change Pagesettings to DIN A4
 570
 571                 GlobalLogWriter.get().println(DateHelper.getDateTimeForHumanreadableLog() + " Print document.");
 572                 XPrintable aPrintable =  UnoRuntime.queryInterface( XPrintable.class, _aDoc);
 573                 if (aPrintable != null)
 574                 {
 575                     // System.out.println("  Set PaperFormat to DIN A4");
 576                     // {
 577                     //     PropertyValue[] aPrinterProps = aPrintable.getPrinter();
 578                     //     System.out.println("PrinterProps size: " + String.valueOf(aPrinterProps.length));
 579                     //     int nPropIndex = 0;
 580                     //     while (!"PaperFormat".equals(aPrinterProps[nPropIndex].Name))
 581                     //     {
 582                     //         // System.out.println(aPrinterProps[nPropIndex].Name);
 583                     //         nPropIndex++;
 584                     //     }
 585                     //     aPrinterProps[nPropIndex].Value = com.sun.star.view.PaperFormat.A4;
 586                     //     aPrintable.setPrinter(aPrinterProps);
 587                     // }
 588
 589                     // configure Office to allow to execute macos
 590
 591 // TODO: We need a possiblity to set the printer name also for StarOffice/OpenOffice
 592                     if (OSHelper.isWindows())
 593                     {
 594                         if (_aGTA.getPrinterName() != null)
 595                         {
 596                             ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>();
 597                             // PropertyValue [] aPrintProps = new PropertyValue[1];
 598                             PropertyValue Arg = new PropertyValue();
 599                             Arg.Name = "Name";
 600                             Arg.Value = _aGTA.getPrinterName();
 601                             aPropertyList.add(Arg);
 602                             showProperty(Arg);
 603                             // GlobalLogWriter.get().println("Printername is not null, so set to " + _aGTA.getPrinterName());
 604                             aPrintable.setPrinter(PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList));
 605                         }
 606                     }
 607
 608                     // set property values for XPrintable.print()
 609                     // more can be found at "http://api.libreoffice.org/docs/common/ref/com/sun/star/view/PrintOptions.html"
 610
 611                     // int nProperties = 1;                    // default for 'FileName' property
 612                     // if (_aGTA.printAllPages() == false)
 613                     // {
 614                     //     // we don't want to print all pages, build Pages string by ourself
 615                     //     nProperties ++;
 616                     // }
 617                     // int nPropsCount = 0;
 618
 619                     // If we are a SpreadSheet (calc), we need to set PrintAllSheets property to 'true'
 620                     XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, _aDoc );
 621                     if ( xServiceInfo.supportsService( "com.sun.star.sheet.SpreadsheetDocument" ) )
 622                     {
 623                         XMultiServiceFactory xMSF = _aGTA.getMultiServiceFactory();
 624                         Object aSettings = xMSF.createInstance( "com.sun.star.sheet.GlobalSheetSettings" );
 625                         if (aSettings != null)
 626                         {
 627                             XPropertySet xPropSet =  UnoRuntime.queryInterface( XPropertySet.class, aSettings );
 628                             xPropSet.setPropertyValue( "PrintAllSheets", new Boolean( true ) );
 629                             GlobalLogWriter.get().println("PrintAllSheets := true");
 630                         }
 631                     }
 632
 633                     ArrayList<PropertyValue> aPrintProps = new ArrayList<PropertyValue>();
 634                     // GlobalLogWriter.get().println("Property FileName:=" + _sPrintFileURL);
 635
 636                     // PropertyValue [] aPrintProps = new PropertyValue[nProperties];
 637                     PropertyValue Arg = new PropertyValue();
 638                     Arg.Name = "FileName";
 639                     Arg.Value = _sPrintFileURL;
 640                     // aPrintProps[nPropsCount ++] = Arg;
 641                     aPrintProps.add(Arg);
 642                     showProperty(Arg);
 643
 644                     if (_aGTA.printAllPages() == false)
 645                     {
 646                         String sPages = "";
 647                         if (_aGTA.getMaxPages() > 0)
 648                         {
 649                             sPages = "1-" + String.valueOf(_aGTA.getMaxPages());
 650                         }
 651                         if (_aGTA.getOnlyPages().length() != 0)
 652                         {
 653                             if (sPages.length() != 0)
 654                             {
 655                                 sPages += ";";
 656                             }
 657                             sPages += String.valueOf(_aGTA.getOnlyPages());
 658                         }
 659
 660                         Arg = new PropertyValue();
 661                         Arg.Name = "Pages";
 662                         Arg.Value = sPages;
 663                         aPrintProps.add(Arg);
 664                         showProperty(Arg);
 665                     }
 666
 667                     // GlobalLogWriter.get().println("Start printing.");
 668
 669                     _aGTA.getPerformance().startTime(PerformanceContainer.Print);
 670                     aPrintable.print(PropertyHelper.createPropertyValueArrayFormArrayList(aPrintProps));
 671                     TimeHelper.waitInSeconds(1, "Start waiting for print ready.");
 672
 673                     GlobalLogWriter.get().println("Wait until document is printed.");
 674                     boolean isBusy = true;
 675                     int nPrintCount = 0;
 676                     while (isBusy)
 677                     {
 678                         PropertyValue[] aPrinterProps = aPrintable.getPrinter();
 679                         int nPropIndex = 0;
 680                         while (!"IsBusy".equals(aPrinterProps[nPropIndex].Name))
 681                         {
 682                             // System.out.println(aPrinterProps[nPropIndex].Name);
 683                             nPropIndex++;
 684                         }
 685                         isBusy = (aPrinterProps[nPropIndex].Value == Boolean.TRUE) ? true : false;
 686                         TimeHelper.waitInSeconds(1, "is print ready?");
 687                         nPrintCount++;
 688                         if (nPrintCount > 3600)
 689                         {
 690                             // we will never wait >1h until print is ready!
 691                             GlobalLogWriter.get().println("ERROR: Cancel print due to too long wait.");
 692                             throw new com.sun.star.uno.Exception("Convwatch exception, wait too long for printing.");
 693                         }
 694                     }
 695                     _aGTA.getPerformance().stopTime(PerformanceContainer.Print);
 696                     GlobalLogWriter.get().println(DateHelper.getDateTimeForHumanreadableLog() + " Print document done.");
 697
 698                     // Create a .info file near the printed '.ps' or '.prn' file.
 699                     createInfoFile(_sPrintFileURL, _aGTA);
 700                 }
 701                 else
 702                 {
 703                     GlobalLogWriter.get().println("Can't get XPrintable interface.");
 704                 }
 705                 bFailed = false;
 706                 bBack = true;
 707             }
 708             catch ( com.sun.star.uno.Exception e )
 709             {
 710                 // Some exception occures.FAILED
 711                 GlobalLogWriter.get().println("UNO Exception caught.");
 712                 GlobalLogWriter.get().println("Message: " + e.getMessage());
 713
 714                 e.printStackTrace();
 715                 bBack = false;
 716             }
 717
 718             if (bFailed == true)
 719             {
 720                 GlobalLogWriter.get().println("convwatch.OfficePrint: FAILED");
 721             }
 722             else
 723             {
 724                 GlobalLogWriter.get().println("convwatch.OfficePrint: OK");
 725             }
 726             return bBack;
 727         }
 728
 729
 730     /**
 731      * @param _aGTA
 732      * @param _sAbsoluteOutputPath
 733      * @param _sAbsoluteInputFile
 734      * @return true, if the reference (*.prrn file) based on given output path and given input path exist.
 735      *               If OVERWRITE_REFERENCE is set, always return false.
 736      */
 737     public static boolean isReferenceExists(GraphicalTestArguments _aGTA,
 738                                             String _sAbsoluteOutputPath,
 739                                             String _sAbsoluteInputFile)
 740         {
 741             if (! FileHelper.exists(_sAbsoluteInputFile))
 742             {
 743                 // throw new ConvWatchCancelException("Input file: " + _sAbsoluteInputFile + " does not exist.");
 744                 return false;
 745             }
 746
 747             String fs = System.getProperty("file.separator");
 748
 749             // String sInputFileURL = URLHelper.getFileURLFromSystemPath(_sAbsoluteInputFile);
 750
 751             String sInputFileBasename = FileHelper.getBasename(_sAbsoluteInputFile);
 752             // String sOutputFileURL = null;
 753             String sOutputPath;
 754             if (_sAbsoluteOutputPath != null)
 755             {
 756                 sOutputPath    = _sAbsoluteOutputPath;
 757                 // FileHelper.makeDirectories("", sOutputPath);
 758             }
 759             else
 760             {
 761                 String sInputPath = FileHelper.getPath(_sAbsoluteInputFile);
 762                 sOutputPath    = sInputPath;
 763             }
 764             // sOutputFileURL = URLHelper.getFileURLFromSystemPath(sOutputPath + fs + sInputFileBasename);
 765             // sOutputFileURL = null;
 766
 767             String sPrintFilename = FileHelper.getNameNoSuffix(sInputFileBasename);
 768             // String sPrintFileURL;
 769
 770             String sAbsolutePrintFilename = sOutputPath + fs + sPrintFilename + ".prn";
 771             if (FileHelper.exists(sAbsolutePrintFilename) && _aGTA.getOverwrite() == false)
 772             {
 773                 GlobalLogWriter.get().println("Reference already exist, don't overwrite. Set " + PropertyName.DOC_COMPARATOR_OVERWRITE_REFERENCE + "=true to force overwrite.");
 774                 return true;
 775             }
 776             return false;
 777         }
 778
 779     // -----------------------------------------------------------------------------
 780     /**
 781      * create a reference file
 782      * _sAbsoluteInputPath  contains the source file, if not exists, return with failure.
 783      * _sAbsoluteOutputPath contains the destination, where the file will store after load with StarOffice/OpenOffice.org
 784      *                      if is null, print only near the Input file path
 785      * _sPrintType ".prn" Print input file with StarOffice/OpenOffice.org and the default printer as PostScript
 786      *
 787      * @param _aGTA
 788      * @param _sAbsoluteOutputPath
 789      * @param _sAbsoluteInputFile
 790      * @return
 791      * @throws ConvWatchCancelException
 792      */
 793     public static boolean buildReference(GraphicalTestArguments _aGTA,
 794                                          String _sAbsoluteOutputPath,
 795                                          String _sAbsoluteInputFile)
 796         throws ConvWatchCancelException
 797         {
 798             if (! FileHelper.exists(_sAbsoluteInputFile))
 799             {
 800                 throw new ConvWatchCancelException("buildReference(): Input file: " + _sAbsoluteInputFile + " does not exist.");
 801             }
 802
 803             String fs = System.getProperty("file.separator");
 804
 805             String sInputFileURL = URLHelper.getFileURLFromSystemPath(_sAbsoluteInputFile);
 806
 807             String sInputFileBasename = FileHelper.getBasename(_sAbsoluteInputFile);
 808             String sOutputFileURL = null;
 809             String sOutputPath;
 810             if (_sAbsoluteOutputPath != null)
 811             {
 812                 sOutputPath    = _sAbsoluteOutputPath;
 813                 FileHelper.makeDirectories("", sOutputPath);
 814             }
 815             else
 816             {
 817                 String sInputPath = FileHelper.getPath(_sAbsoluteInputFile);
 818                 sOutputPath    = sInputPath;
 819             }
 820             // sOutputFileURL = URLHelper.getFileURLFromSystemPath(sOutputPath + fs + sInputFileBasename);
 821             sOutputFileURL = null;
 822
 823             String sPrintFilename = FileHelper.getNameNoSuffix(sInputFileBasename);
 824             String sPrintFileURL;
 825
 826             String sAbsolutePrintFilename = sOutputPath + fs + sPrintFilename + ".prn";
 827             if (FileHelper.exists(sAbsolutePrintFilename) && _aGTA.getOverwrite() == false)
 828             {
 829                 GlobalLogWriter.get().println("Reference already exist, don't overwrite. Set " + PropertyName.DOC_COMPARATOR_OVERWRITE_REFERENCE + "=true to force overwrite.");
 830                 return true;
 831             }
 832
 833             if (_aGTA.getReferenceType().toLowerCase().equals("msoffice"))
 834             {
 835                 sPrintFileURL = URLHelper.getFileURLFromSystemPath(sAbsolutePrintFilename);
 836             }
 837             else if (_aGTA.getReferenceType().toLowerCase().equals("pdf"))
 838             {
 839 //  TODO: If we rename the stored file to *.pdf, we have to be sure that we use *.pdf also as a available reference
 840                 sPrintFileURL = URLHelper.getFileURLFromSystemPath(sAbsolutePrintFilename );
 841             }
 842             else if (_aGTA.getReferenceType().toLowerCase().equals("ooo"))
 843             {
 844                 sPrintFileURL = URLHelper.getFileURLFromSystemPath(sAbsolutePrintFilename );
 845             }
 846             else
 847             {
 848                 GlobalLogWriter.get().println("OfficePrint.buildreference(): Unknown print type.");
 849                 return false;
 850             }
 851             return printToFile(_aGTA, sInputFileURL, sOutputFileURL, sPrintFileURL);
 852         }
 853
 854     public static boolean printToFile(GraphicalTestArguments _aGTA,
 855                                       String _sInputFileURL,
 856                                       String _sOutputFileURL,
 857                                       String _sPrintFileURL) throws ConvWatchCancelException
 858         {
 859             boolean bBack = false;
 860             // check if given file is a picture, then do nothing
 861             String sDocumentSuffix = FileHelper.getSuffix(_sInputFileURL);
 862             if (sDocumentSuffix.toLowerCase().endsWith(".png") ||
 863                 sDocumentSuffix.toLowerCase().endsWith(".gif") ||
 864                 sDocumentSuffix.toLowerCase().endsWith(".jpg") ||
 865                 sDocumentSuffix.toLowerCase().endsWith(".bmp"))
 866             {
 867                 return false;
 868             }
 869
 870
 871             // remember the current timer, to know how long a print process need.
 872             // startTimer();
 873
 874             if (_aGTA.getReferenceType().toLowerCase().equals("ooo"))
 875             {
 876                 bBack = printToFileWithOOo(_aGTA, _sInputFileURL, _sOutputFileURL, _sPrintFileURL);
 877             }
 878             else if (_aGTA.getReferenceType().toLowerCase().equals("pdf"))
 879             {
 880                 GlobalLogWriter.get().println("USE PDF AS EXPORT FORMAT.");
 881                 bBack = storeAsPDF(_aGTA, _sInputFileURL, _sPrintFileURL);
 882             }
 883             else if (_aGTA.getReferenceType().toLowerCase().equals("msoffice"))
 884             {
 885                 if (MSOfficePrint.isMSOfficeDocumentFormat(_sInputFileURL))
 886                 {
 887                     GlobalLogWriter.get().println("USE MSOFFICE AS EXPORT FORMAT.");
 888                     MSOfficePrint a = new MSOfficePrint();
 889                     try
 890                     {
 891                         a.printToFileWithMSOffice(_aGTA, FileHelper.getSystemPathFromFileURL(_sInputFileURL),
 892                                                   FileHelper.getSystemPathFromFileURL(_sPrintFileURL));
 893                     }
 894                     catch(ConvWatchCancelException e)
 895                     {
 896                         e.printStackTrace();
 897                         GlobalLogWriter.get().println(e.getMessage());
 898                         throw new ConvWatchCancelException("Exception caught. Problem with MSOffice printer methods.");
 899                     }
 900                     catch(java.io.IOException e)
 901                     {
 902                         GlobalLogWriter.get().println(e.getMessage());
 903                         throw new ConvWatchCancelException("IOException caught. Problem with MSOffice printer methods.");
 904                     }
 905                     bBack = true;
 906                 }
 907                 else
 908                 {
 909                     GlobalLogWriter.get().println("This document type is not recognized as MSOffice format, as default fallback StarOffice/OpenOffice.org instead is used.");
 910                     bBack = printToFileWithOOo(_aGTA, _sInputFileURL, _sOutputFileURL, _sPrintFileURL);
 911                 }
 912             }
 913             else
 914             {
 915                 // System.out.println("");
 916                 throw new ConvWatchCancelException("OfficePrint.printToFile(): Unknown print type.");
 917             }
 918             return bBack;
 919         }
 920
 921     // -----------------------------------------------------------------------------
 922     // TODO: move this away!
 923     // -----------------------------------------------------------------------------
 924     static void showType(String _sInputURL, XMultiServiceFactory _xMSF)
 925         {
 926             if (_sInputURL.length() == 0)
 927             {
 928                 return;
 929             }
 930
 931             if (_xMSF == null)
 932             {
 933                 GlobalLogWriter.get().println("MultiServiceFactory not set.");
 934                 return;
 935             }
 936             XTypeDetection aTypeDetection = null;
 937             try
 938             {
 939                 Object oObj = _xMSF.createInstance("com.sun.star.document.TypeDetection");
 940                 aTypeDetection = UnoRuntime.queryInterface(XTypeDetection.class, oObj);
 941             }
 942             catch(com.sun.star.uno.Exception e)
 943             {
 944                 GlobalLogWriter.get().println("Can't get com.sun.star.document.TypeDetection.");
 945                 return;
 946             }
 947             if (aTypeDetection != null)
 948             {
 949                 String sType = aTypeDetection.queryTypeByURL(_sInputURL);
 950                 GlobalLogWriter.get().println("Type is: " + sType);
 951             }
 952         }
 953
 954
 955     // -----------------------------------------------------------------------------
 956     public static String getInternalFilterName(String _sFilterName, XMultiServiceFactory _xMSF)
 957         {
 958             if (_sFilterName.length() == 0)
 959             {
 960                 // System.out.println("No FilterName set.");
 961                 return null;
 962             }
 963
 964             if (_xMSF == null)
 965             {
 966                 GlobalLogWriter.get().println("MultiServiceFactory not set.");
 967                 return null;
 968             }
 969             // XFilterFactory aFilterFactory = null;
 970             Object aObj = null;
 971             try
 972             {
 973                 aObj = _xMSF.createInstance("com.sun.star.document.FilterFactory");
 974             }
 975             catch(com.sun.star.uno.Exception e)
 976             {
 977                 GlobalLogWriter.get().println("Can't get com.sun.star.document.FilterFactory.");
 978                 return null;
 979             }
 980             if (aObj != null)
 981             {
 982                 XNameAccess aNameAccess = UnoRuntime.queryInterface(XNameAccess.class, aObj);
 983                 if (aNameAccess != null)
 984                 {
 985
 986                     // if (_sFilterName.toLowerCase().equals("help"))
 987                     // {
 988                     //     System.out.println("Show all possible ElementNames from current version." );
 989                     // String[] aElementNames = aNameAccess.getElementNames();
 990                     // for (int i = 0; i<aElementNames.length; i++)
 991                     // {
 992                     //     System.out.println(aElementNames[i]);
 993                     // }
 994                     //     System.out.println("Must quit.");
 995                     //     System.out.exit(1);
 996                     // }
 997
 998                     if (! aNameAccess.hasByName(_sFilterName))
 999                     {
1000                         GlobalLogWriter.get().println("FilterFactory.hasByName() says there exist no '" + _sFilterName + "'" );
1001                         return null;
1002                     }
1003
1004                     Object[] aElements = null;
1005                     try
1006                     {
1007                         aElements = (Object[]) aNameAccess.getByName(_sFilterName);
1008                         if (aElements != null)
1009                         {
1010                             String sInternalFilterName = null;
1011                             // System.out.println("getByName().length: " + String.valueOf(aElements.length));
1012                             for (int i=0;i<aElements.length; i++)
1013                             {
1014                                 PropertyValue aPropertyValue = (PropertyValue)aElements[i];
1015                                 // System.out.println("PropertyValue.Name: " + aPropertyValue.Name);
1016                                 if (aPropertyValue.Name.equals("Type"))
1017                                 {
1018                                     String sValue = (String)aPropertyValue.Value;
1019                                     // System.out.println("Type: " + sValue);
1020                                     sInternalFilterName = sValue;
1021                                 }
1022                             }
1023                             return sInternalFilterName;
1024                         }
1025                         else
1026                         {
1027                             GlobalLogWriter.get().println("There are no elements for FilterName '" + _sFilterName + "'");
1028                             return null;
1029                         }
1030                     }
1031                     catch (com.sun.star.container.NoSuchElementException e)
1032                     {
1033                         GlobalLogWriter.get().println("NoSuchElementException caught. " + e.getMessage());
1034                     }
1035                     catch (com.sun.star.lang.WrappedTargetException e)
1036                     {
1037                         GlobalLogWriter.get().println("WrappedTargetException caught. " + e.getMessage());
1038                     }
1039                 }
1040             }
1041             return null;
1042         }
1043
1044     // -----------------------------------------------------------------------------
1045
1046     static String getServiceNameFromFilterName(String _sFilterName, XMultiServiceFactory _xMSF)
1047         {
1048             if (_sFilterName.length() == 0)
1049             {
1050                 // System.out.println("No FilterName set.");
1051                 return null;
1052             }
1053
1054             if (_xMSF == null)
1055             {
1056                 GlobalLogWriter.get().println("MultiServiceFactory not set.");
1057                 return null;
1058             }
1059             // XFilterFactory aFilterFactory = null;
1060             Object aObj = null;
1061             try
1062             {
1063                 aObj = _xMSF.createInstance("com.sun.star.document.FilterFactory");
1064             }
1065             catch(com.sun.star.uno.Exception e)
1066             {
1067                 GlobalLogWriter.get().println("Can't get com.sun.star.document.FilterFactory.");
1068                 return null;
1069             }
1070             if (aObj != null)
1071             {
1072                 XNameAccess aNameAccess = UnoRuntime.queryInterface(XNameAccess.class, aObj);
1073                 if (aNameAccess != null)
1074                 {
1075                     if (! aNameAccess.hasByName(_sFilterName))
1076                     {
1077                         GlobalLogWriter.get().println("FilterFactory.hasByName() says there exist no '" + _sFilterName + "'" );
1078                         return null;
1079                     }
1080
1081                     Object[] aElements = null;
1082                     try
1083                     {
1084                         aElements = (Object[]) aNameAccess.getByName(_sFilterName);
1085                         if (aElements != null)
1086                         {
1087                             String sServiceName = null;
1088                             // System.out.println("getByName().length: " + String.valueOf(aElements.length));
1089                             for (int i=0;i<aElements.length; i++)
1090                             {
1091                                 PropertyValue aPropertyValue = (PropertyValue)aElements[i];
1092                                 if (aPropertyValue.Name.equals("DocumentService"))
1093                                 {
1094                                     String sValue = (String)aPropertyValue.Value;
1095                                     // System.out.println("DocumentService: " + sValue);
1096                                     sServiceName = sValue;
1097                                     break;
1098                                 }
1099                             }
1100                             return sServiceName;
1101                         }
1102                         else
1103                         {
1104                             GlobalLogWriter.get().println("There are no elements for FilterName '" + _sFilterName + "'");
1105                             return null;
1106                         }
1107                     }
1108                     catch (com.sun.star.container.NoSuchElementException e)
1109                     {
1110                         GlobalLogWriter.get().println("NoSuchElementException caught. " + e.getMessage());
1111                     }
1112                     catch (com.sun.star.lang.WrappedTargetException e)
1113                     {
1114                         GlobalLogWriter.get().println("WrappedTargetException caught. " + e.getMessage());
1115                     }
1116                 }
1117             }
1118             return null;
1119         }
1120     // -----------------------------------------------------------------------------
1121
1122     public static String getFileExtension(String _sInternalFilterName, XMultiServiceFactory _xMSF)
1123         {
1124             if (_sInternalFilterName.length() == 0)
1125             {
1126                 // System.out.println("No FilterName set.");
1127                 return null;
1128             }
1129
1130             if (_xMSF == null)
1131             {
1132                 GlobalLogWriter.get().println("MultiServiceFactory not set.");
1133                 return null;
1134             }
1135             XTypeDetection aTypeDetection = null;
1136             try
1137             {
1138                 Object oObj = _xMSF.createInstance("com.sun.star.document.TypeDetection");
1139                 aTypeDetection =UnoRuntime.queryInterface(XTypeDetection.class, oObj);
1140             }
1141             catch(com.sun.star.uno.Exception e)
1142             {
1143                 GlobalLogWriter.get().println("Can't get com.sun.star.document.TypeDetection.");
1144                 return null;
1145             }
1146             if (aTypeDetection != null)
1147             {
1148                 XNameAccess aNameAccess = UnoRuntime.queryInterface(XNameAccess.class, aTypeDetection);
1149                 if (aNameAccess != null)
1150                 {
1151
1152                     // System.out.println("Show ElementNames" );
1153                     // String[] aElementNames = aNameAccess.getElementNames();
1154                     // for (int i = 0; i<aElementNames.length; i++)
1155                     // {
1156                     //     System.out.println(aElementNames[i]);
1157                     // }
1158
1159                     if (! aNameAccess.hasByName(_sInternalFilterName))
1160                     {
1161                         GlobalLogWriter.get().println("TypeDetection.hasByName() says there exist no '" + _sInternalFilterName + "'" );
1162                         return null;
1163                     }
1164
1165                     Object[] aElements = null;
1166                     String[] aExtensions;
1167                     try
1168                     {
1169                         aElements = (Object[]) aNameAccess.getByName(_sInternalFilterName);
1170                         if (aElements != null)
1171                         {
1172                             String sExtension = null;
1173                             // System.out.println("getByName().length: " + String.valueOf(aElements.length));
1174                             for (int i=0;i<aElements.length; i++)
1175                             {
1176                                 PropertyValue aPropertyValue = (PropertyValue)aElements[i];
1177                                 // System.out.println("PropertyValue.Name: " + aPropertyValue.Name);
1178                                 if (aPropertyValue.Name.equals("Extensions"))
1179                                 {
1180                                     aExtensions = (String[])aPropertyValue.Value;
1181                                     GlobalLogWriter.get().println("   Possible extensions are: " + String.valueOf(aExtensions.length));
1182                                     if (aExtensions.length > 0)
1183                                     {
1184                                         for (int j=0;j<aExtensions.length;j++)
1185                                         {
1186                                             GlobalLogWriter.get().println(" " + aExtensions[j]);
1187                                         }
1188                                         sExtension = aExtensions[0];
1189                                         GlobalLogWriter.get().println("");
1190                                     }
1191                                 }
1192                             }
1193                             return sExtension;
1194                         }
1195                         else
1196                         {
1197                             GlobalLogWriter.get().println("There are no elements for FilterName '" + _sInternalFilterName + "'");
1198                             return null;
1199                         }
1200                     }
1201                     catch (com.sun.star.container.NoSuchElementException e)
1202                     {
1203                         GlobalLogWriter.get().println("NoSuchElementException caught. " + e.getMessage());
1204                     }
1205                     catch (com.sun.star.lang.WrappedTargetException e)
1206                     {
1207                         GlobalLogWriter.get().println("WrappedTargetException caught. " + e.getMessage());
1208                     }
1209 }
1210             }
1211             return null;
1212         }
1213
1214     // -----------------------------------------------------------------------------
1215     public static void convertDocument(String _sInputFile, String _sOutputPath, GraphicalTestArguments _aGTA) throws ConvWatchCancelException
1216         {
1217             XMultiServiceFactory xMSF = _aGTA.getMultiServiceFactory();
1218             if (xMSF == null)
1219             {
1220                 GlobalLogWriter.get().println("MultiServiceFactory in GraphicalTestArgument not set.");
1221                 return;
1222             }
1223
1224             String sInputURL = URLHelper.getFileURLFromSystemPath(_sInputFile);
1225             // showType(sInputURL, xMSF);
1226             XComponent aDoc = loadFromURL( _aGTA, sInputURL);
1227             if (aDoc == null)
1228             {
1229                 GlobalLogWriter.get().println("Can't load document '"+ sInputURL + "'");
1230                 return;
1231             }
1232
1233             if (_sOutputPath == null)
1234             {
1235                 GlobalLogWriter.get().println("Outputpath not set.");
1236                 return;
1237             }
1238
1239             if (! _aGTA.isStoreAllowed())
1240             {
1241                 GlobalLogWriter.get().println("It's not allowed to store, check Input/Output path.");
1242                 return;
1243             }
1244 //  TODO: Do we need to wait?
1245             TimeHelper.waitInSeconds(1, "wait after loadFromURL.");
1246
1247             XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, aDoc );
1248             // String sFilter = getFilterName_forExcel(xServiceInfo);
1249             // System.out.println("Filter is " + sFilter);
1250
1251             // store the document in an other directory
1252             XStorable xStorable = UnoRuntime.queryInterface( XStorable.class, aDoc);
1253             if (xStorable == null)
1254             {
1255                 GlobalLogWriter.get().println("com.sun.star.frame.XStorable is null");
1256                 return;
1257             }
1258
1259             String sFilterName = _aGTA.getExportFilterName();
1260
1261             // initialize PropertyArray
1262             // PropertyValue [] aStoreProps = new PropertyValue[ nPropertyCount ];
1263             // int nPropertyIndex = 0;
1264             ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>();
1265
1266             String sExtension = "";
1267
1268             if (sFilterName != null && sFilterName.length() > 0)
1269             {
1270                 String sInternalFilterName = getInternalFilterName(sFilterName, xMSF);
1271                 String sServiceName = getServiceNameFromFilterName(sFilterName, xMSF);
1272
1273                 GlobalLogWriter.get().println("Filter detection:");
1274                 // check if service name from file filter is the same as from the loaded document
1275                 boolean bServiceFailed = false;
1276                 if (sServiceName == null || sInternalFilterName == null)
1277                 {
1278                     GlobalLogWriter.get().println("Given FilterName '" + sFilterName + "' seems to be unknown.");
1279                     bServiceFailed = true;
1280                 }
1281                 if (! xServiceInfo.supportsService(sServiceName))
1282                 {
1283                     GlobalLogWriter.get().println("Service from FilterName '" + sServiceName + "' is not supported by loaded document.");
1284                     bServiceFailed = true;
1285                 }
1286                 if (bServiceFailed == true)
1287                 {
1288                     GlobalLogWriter.get().println("Please check '" + PropertyName.DOC_CONVERTER_EXPORT_FILTER_NAME + "' in the property file.");
1289                     return;
1290                 }
1291
1292                 if (sInternalFilterName != null && sInternalFilterName.length() > 0)
1293                 {
1294                     // get the FileExtension, by the filter name, if we don't get a file extension
1295                     // we assume the is also no right filter name.
1296                     sExtension = getFileExtension(sInternalFilterName, xMSF);
1297                     if (sExtension == null)
1298                     {
1299                         GlobalLogWriter.get().println("Can't found an extension for filtername, take it from the source.");
1300                     }
1301                 }
1302
1303                 PropertyValue Arg = new PropertyValue();
1304                 Arg.Name = "FilterName";
1305                 Arg.Value = sFilterName;
1306                 // aStoreProps[nPropertyIndex ++] = Arg;
1307                 aPropertyList.add(Arg);
1308                 showProperty(Arg);
1309                 GlobalLogWriter.get().println("FilterName is set to: " + sFilterName);
1310             }
1311
1312             String sOutputURL = "";
1313             try
1314             {
1315                 // create the new filename with the extension, which is ok to the file format
1316                 String sInputFileBasename = FileHelper.getBasename(_sInputFile);
1317                 // System.out.println("InputFileBasename " + sInputFileBasename);
1318                 String sInputFileNameNoSuffix = FileHelper.getNameNoSuffix(sInputFileBasename);
1319                 // System.out.println("InputFilename no suffix " + sInputFileNameNoSuffix);
1320                 String fs = System.getProperty("file.separator");
1321                 String sOutputFile = _sOutputPath;
1322                 if (! sOutputFile.endsWith(fs))
1323                 {
1324                     sOutputFile += fs;
1325                 }
1326                 if (sExtension != null && sExtension.length() > 0)
1327                 {
1328                     sOutputFile += sInputFileNameNoSuffix + "." + sExtension;
1329                 }
1330                 else
1331                 {
1332                     sOutputFile += sInputFileBasename;
1333                 }
1334
1335                 if (FileHelper.exists(sOutputFile) && _aGTA.getOverwrite() == false)
1336                 {
1337                     GlobalLogWriter.get().println("File already exist, don't overwrite. Set " + PropertyName.DOC_COMPARATOR_OVERWRITE_REFERENCE + "=true to force overwrite.");
1338                     return;
1339                 }
1340
1341                 sOutputURL = URLHelper.getFileURLFromSystemPath(sOutputFile);
1342
1343                 GlobalLogWriter.get().println("Store document as '" + sOutputURL + "'");
1344                 xStorable.storeAsURL(sOutputURL, PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList));
1345                 GlobalLogWriter.get().println("Document stored.");
1346             }
1347             catch (com.sun.star.io.IOException e)
1348             {
1349                 GlobalLogWriter.get().println("Can't store document '" + sOutputURL + "'. Message is :'" + e.getMessage() + "'");
1350             }
1351 //  TODO: Do we need to wait?
1352             TimeHelper.waitInSeconds(1, "unknown in OfficePrint.convertDocument()");
1353
1354         }
1355
1356 }
1357