qadevOOo/runner/graphical/OpenOfficePostscriptCreator.java

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