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