qadevOOo/runner/convwatch/ReportDesignerTest.java

   1 /*
   2  ************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2008 by Sun Microsystems, Inc.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * $RCSfile: ReportDesignerTest.java,v $
  11  * $Revision: 1.4.8.1 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 package convwatch;
  33
  34 import java.io.File;
  35 import java.util.ArrayList;
  36
  37 import com.sun.star.beans.PropertyValue;
  38 import com.sun.star.beans.XPropertySet;
  39 import com.sun.star.container.XNameAccess;
  40 import com.sun.star.frame.XComponentLoader;
  41 import com.sun.star.frame.XDesktop;
  42 import com.sun.star.frame.XModel;
  43 import com.sun.star.frame.XStorable;
  44 import com.sun.star.lang.XComponent;
  45 import com.sun.star.lang.XMultiServiceFactory;
  46 import com.sun.star.sdb.XDocumentDataSource;
  47 import com.sun.star.sdb.XOfficeDatabaseDocument;
  48 import com.sun.star.sdb.XReportDocumentsSupplier;
  49 import com.sun.star.sdb.application.XDatabaseDocumentUI;
  50 import com.sun.star.uno.UnoRuntime;
  51 import com.sun.star.uno.XInterface;
  52 import com.sun.star.util.XCloseable;
  53 import com.sun.star.lang.XServiceInfo;
  54
  55 // import util.BasicMacroTools;
  56 // import util.DesktopTools;
  57 // import util.dbg;
  58 import complexlib.ComplexTestCase;
  59 import helper.OfficeProvider;
  60 import helper.URLHelper;
  61 import helper.OfficeWatcher;
  62
  63 // import convwatch.DB;
  64
  65 // import java.util.Date;
  66 // import java.text.SimpleDateFormat;
  67 // import java.text.ParsePosition;
  68 // import java.sql.Time;
  69 //
  70 // import java.io.BufferedReader;
  71 // import java.io.File;
  72 // import java.io.FileReader;
  73 // import java.io.IOException;
  74 // import java.io.FilenameFilter;
  75 //
  76 // import java.util.Vector;
  77 //
  78 // import helper.AppProvider;
  79 // import java.text.DecimalFormat;
  80 // import util.DynamicClassLoader;
  81 // import java.util.StringTokenizer;
  82
  83
  84
  85
  86 class PropertySetHelper
  87 {
  88     XPropertySet m_xPropertySet;
  89     public PropertySetHelper(Object _aObj)
  90         {
  91             m_xPropertySet = (XPropertySet)UnoRuntime.queryInterface(XPropertySet.class, _aObj);
  92         }
  93
  94     /**
  95        get a property and don't convert it
  96        @param _sName the string name of the property
  97        @return the object value of the property without any conversion
  98     */
  99     public Object getPropertyValueAsObject(String _sName)
 100         {
 101             Object aObject = null;
 102
 103             if (m_xPropertySet != null)
 104             {
 105                 try
 106                 {
 107                     aObject = m_xPropertySet.getPropertyValue(_sName);
 108                 }
 109                 catch (com.sun.star.beans.UnknownPropertyException e)
 110                 {
 111                     System.out.println("ERROR: UnknownPropertyException caught. '" + _sName + "'");
 112                     System.out.println("Message: " + e.getMessage());
 113                 }
 114                 catch (com.sun.star.lang.WrappedTargetException e)
 115                 {
 116                     System.out.println("ERROR: WrappedTargetException caught.");
 117                     System.out.println("Message: " + e.getMessage());
 118                 }
 119             }
 120             return aObject;
 121         }
 122 }
 123
 124 class PropertyHelper
 125 {
 126     /**
 127        Create a PropertyValue[] from a ArrayList
 128        @param _aArrayList
 129        @return a PropertyValue[]
 130     */
 131     public static PropertyValue[] createPropertyValueArrayFormArrayList(ArrayList _aPropertyList)
 132         {
 133             // copy the whole PropertyValue List to an PropertyValue Array
 134             PropertyValue[] aSaveProperties = null;
 135
 136             if (_aPropertyList == null)
 137             {
 138                 aSaveProperties = new PropertyValue[0];
 139             }
 140             else
 141             {
 142                 if (_aPropertyList.size() > 0)
 143                 {
 144                     aSaveProperties = new PropertyValue[_aPropertyList.size()];
 145                     for (int i = 0;i<_aPropertyList.size(); i++)
 146                     {
 147                         aSaveProperties[i] = (PropertyValue) _aPropertyList.get(i);
 148                     }
 149                 }
 150                 else
 151                 {
 152                     aSaveProperties = new PropertyValue[0];
 153                 }
 154             }
 155             return aSaveProperties;
 156         }
 157 }
 158
 159 public class ReportDesignerTest extends ComplexTestCase {
 160
 161     String mTestDocumentPath;
 162
 163     /**
 164      * This method returns a list of Strings, each string must be a function name in this class.
 165      * @return
 166      */
 167     public String[] getTestMethodNames()
 168         {
 169             return new String[] {"ReportDesignTest"}; // MAIN
 170         }
 171
 172     private void checkIfOfficeExists(String _sOfficePathWithTrash)
 173         {
 174             String sOfficePath = "";
 175             int nIndex = _sOfficePathWithTrash.indexOf("soffice.exe");
 176             if (nIndex > 0)
 177             {
 178                 sOfficePath = _sOfficePathWithTrash.substring(0, nIndex + 11);
 179             }
 180             else
 181             {
 182                 nIndex = _sOfficePathWithTrash.indexOf("soffice");
 183                 if (nIndex > 0)
 184                 {
 185                     sOfficePath = _sOfficePathWithTrash.substring(0, nIndex + 7);
 186                 }
 187             }
 188
 189             // if (sOfficePath.startsWith("\"") ||
 190             //     sOfficePath.startsWith("'"))
 191             // {
 192             //     sOfficePath = sOfficePath.substring(1);
 193             // }
 194             sOfficePath = helper.StringHelper.removeQuoteIfExists(sOfficePath);
 195
 196             log.println(sOfficePath);
 197             File sOffice = new File(sOfficePath);
 198             if (! sOffice.exists())
 199             {
 200                 log.println("ERROR: There exists no office installation at given path: '" + sOfficePath + "'");
 201                 System.exit(0);
 202             }
 203         }
 204
 205
 206     private static XDesktop m_xDesktop = null;
 207     public static XDesktop getXDesktop()
 208         {
 209
 210             if (m_xDesktop == null)
 211             {
 212                 try
 213                 {
 214                     XInterface xInterface = (XInterface) m_xXMultiServiceFactory.createInstance( "com.sun.star.frame.Desktop" );
 215                     m_xDesktop = (XDesktop) UnoRuntime.queryInterface(XDesktop.class, xInterface);
 216                 }
 217                 catch (com.sun.star.uno.Exception e)
 218                 {
 219                     log.println("ERROR: uno.Exception caught");
 220                     log.println("Message: " + e.getMessage());
 221                 }
 222             }
 223             return m_xDesktop;
 224         }
 225
 226     private void showElements(XNameAccess _xNameAccess)
 227         {
 228             if (_xNameAccess != null)
 229             {
 230                 String[] sElementNames = _xNameAccess.getElementNames();
 231                 for(int i=0;i<sElementNames.length; i++)
 232                 {
 233                     System.out.println("Value: [" + i + "] := " + sElementNames[i]);
 234                 }
 235             }
 236             else
 237             {
 238                 System.out.println("Warning: Given object is null.");
 239             }
 240         }
 241
 242
 243     private OfficeProvider m_aProvider = null;
 244     private static XMultiServiceFactory m_xXMultiServiceFactory = null;
 245     private void startOffice()
 246         {
 247             // int tempTime = param.getInt("SingleTimeOut");
 248             param.put("TimeOut", new Integer(300000));
 249             System.out.println("TimeOut: " + param.getInt("TimeOut"));
 250             System.out.println("ThreadTimeOut: " + param.getInt("ThreadTimeOut"));
 251
 252             // OfficeProvider aProvider = null;
 253             m_aProvider = new OfficeProvider();
 254             m_xXMultiServiceFactory = (XMultiServiceFactory) m_aProvider.getManager(param);
 255             param.put("ServiceFactory", m_xXMultiServiceFactory);
 256         }
 257
 258     private void stopOffice()
 259         {
 260             if (m_aProvider != null)
 261             {
 262                 m_aProvider.closeExistingOffice(param, true);
 263                 m_aProvider = null;
 264             }
 265             TimeHelper.waitInSeconds(2, "Give close Office some time.");
 266         }
 267
 268     private String m_sMailAddress = null;
 269     private String m_sParentDistinct = null;
 270
 271     // private String m_sUPDMinor;
 272     // private String m_sCWS_WORK_STAMP;
 273
 274     private static String m_sSourceVersion;
 275     private static String m_sDestinationVersion;
 276     private static String m_sSourceName;
 277     private static String m_sDestinationName;
 278
 279     private static final int WRITER = 1;
 280     private static final int CALC = 2;
 281
 282     /**
 283      * This is the main test Function of current ReportDesignerTest
 284      */
 285     public void ReportDesignTest()
 286         {
 287             convwatch.GlobalLogWriter.set(log);
 288
 289             GlobalLogWriter.get().println("Set office watcher");
 290             OfficeWatcher aWatcher = (OfficeWatcher)param.get("Watcher");
 291             GlobalLogWriter.get().setWatcher(aWatcher);
 292
 293             try
 294             {
 295
 296                 // -------------------- preconditions, try to find an office --------------------
 297
 298                 String sAppExecutionCommand = (String) param.get("AppExecutionCommand");
 299                 log.println("sAppExecutionCommand='" + sAppExecutionCommand + "'");
 300
 301                 String sUser = System.getProperty("user.name");
 302                 log.println("user.name='" + sUser + "'");
 303
 304                 // String sVCSID = System.getProperty("VCSID");
 305                 // log.println("VCSID='" + sVCSID + "'");
 306                 // m_sMailAddress = sVCSID + "@openoffice.org";
 307                 m_sMailAddress = System.getProperty("MailAddress");
 308                 log.println("Assumed mail address: " + m_sMailAddress);
 309
 310                 m_sParentDistinct = System.getProperty("ParentDistinct");
 311
 312                 m_sSourceVersion = System.getProperty("SourceVersion");
 313                 m_sSourceName = System.getProperty("SourceName");
 314                 m_sDestinationVersion = System.getProperty("DestinationVersion");
 315                 m_sDestinationName = System.getProperty("DestinationName");
 316                 // createDBEntry();
 317                 // log.println("Current CWS: " + m_sCWS_WORK_STAMP);
 318                 // log.println("Current MWS: " + m_sUPDMinor);
 319
 320                 if (m_sSourceVersion == null)
 321                 {
 322                     System.out.println("Error, Sourceversion is null.");
 323                     System.exit(1);
 324                 }
 325
 326                 sAppExecutionCommand = sAppExecutionCommand.replaceAll( "\\$\\{USERNAME\\}", sUser);
 327                 log.println("sAppExecutionCommand='" + sAppExecutionCommand + "'");
 328
 329                 // an other way to replace strings
 330                 // sAppExecutionCommand = utils.replaceAll13(sAppExecutionCommand, "${USERNAME}", sUser);
 331
 332                 checkIfOfficeExists(sAppExecutionCommand);
 333                 param.put("AppExecutionCommand", new String(sAppExecutionCommand));
 334
 335                 // System.exit(1);
 336
 337                 // --------------------------- Start the given Office ---------------------------
 338
 339                 startOffice();
 340
 341                 // ------------------------------ Start a test run ------------------------------
 342
 343                 // String sCurrentDirectory = System.getProperty("user.dir");
 344                 // log.println("Current Dir: " + sCurrentDirectory);
 345                 String sDocument = (String) param.get(convwatch.PropertyName.DOC_COMPARATOR_INPUT_PATH);
 346                 sDocument = helper.StringHelper.removeQuoteIfExists( sDocument );
 347                 startTestForFile(sDocument);
 348                 // if (sDocument.toLowerCase().indexOf("writer") >= 0)
 349                 // {
 350                 //     startTestForFile(sDocument, WRITER);
 351                 // }
 352                 // else if (sDocument.toLowerCase().indexOf("calc") >= 0)
 353                 // {
 354                 //     startTestForFile(sDocument, CALC);
 355                 // }
 356                 // else
 357                 // {
 358                 //     assure("Can't identify the document no 'writer' nor 'calc' in it's name given.", false);
 359                 // }
 360             }
 361             catch (AssureException e)
 362             {
 363                 stopOffice();
 364                 throw new AssureException(e.getMessage());
 365             }
 366
 367             // ------------------------------ Office shutdown ------------------------------
 368             stopOffice();
 369         }
 370
 371 // -----------------------------------------------------------------------------
 372     private void startTestForFile(String _sDocument /*, int _nType*/)
 373         {
 374             File aFile = new File(_sDocument);
 375             assure("Test File '" + _sDocument + "' doesn't exist.", aFile.exists());
 376
 377             String sFileURL = URLHelper.getFileURLFromSystemPath(_sDocument);
 378             log.println("File URL: " + sFileURL);
 379
 380             XComponent xDocComponent = loadComponent(sFileURL, getXDesktop(), null);
 381             log.println("Load done");
 382 //      context = createUnoService("com.sun.star.sdb.DatabaseContext")
 383 //     oDataBase = context.getByName("hh")
 384 //     oDBDoc = oDataBase.DatabaseDocument
 385 //
 386 //      dim args(1) as new com.sun.star.beans.PropertyValue
 387 //      args(0).Name = "ActiveConnection"
 388 //      args(0).Value = oDBDoc.getCurrentController().getPropertyValue("ActiveConnection")
 389 //      reportContainer = oDBDoc.getReportDocuments()
 390 //     report = reportContainer.loadComponentFromURL("Report40","",0,args)
 391
 392             try
 393             {
 394                 XInterface x = (XInterface)m_xXMultiServiceFactory.createInstance("com.sun.star.sdb.DatabaseContext");
 395                 assure("can't create instance of com.sun.star.sdb.DatabaseContext", x != null);
 396                 log.println("createInstance com.sun.star.sdb.DatabaseContext done");
 397
 398                 XNameAccess xNameAccess = (XNameAccess) UnoRuntime.queryInterface(XNameAccess.class, x);
 399                 showElements(xNameAccess);
 400                 Object aObj = xNameAccess.getByName(sFileURL);
 401 //                    log.println("1");
 402
 403                     // PropertySetHelper aHelper = new PropertySetHelper(aObj);
 404                 XDocumentDataSource xDataSource = (XDocumentDataSource)UnoRuntime.queryInterface(XDocumentDataSource.class, aObj);
 405 //                    Object aDatabaseDocmuent = aHelper.getPropertyValueAsObject("DatabaseDocument");
 406                 XOfficeDatabaseDocument xOfficeDBDoc = xDataSource.getDatabaseDocument();
 407
 408                 // XOfficeDatabaseDocument xOfficeDBDoc = (XOfficeDatabaseDocument)UnoRuntime.queryInterface(XOfficeDatabaseDocument.class, aDatabaseDocument);
 409                 assure("can't access DatabaseDocument", xOfficeDBDoc != null);
 410 //                    log.println("2");
 411
 412                 XModel xDBSource = (XModel)UnoRuntime.queryInterface(XModel.class, xOfficeDBDoc);
 413                 Object aController = xDBSource.getCurrentController();
 414                 assure("Controller of xOfficeDatabaseDocument is empty!", aController != null);
 415 //                     log.println("3");
 416
 417                 XDatabaseDocumentUI aDBDocUI = (XDatabaseDocumentUI)UnoRuntime.queryInterface(XDatabaseDocumentUI.class, aController);
 418                 aDBDocUI.connect();
 419 //                     if (aDBDocUI.isConnected())
 420 //                     {
 421 //                         System.out.println("true");
 422 //                     }
 423 //                     else
 424 //                     {
 425 //                         System.out.println("false");
 426 //                     }
 427 //                     log.println("4");
 428
 429                 // aHelper = new PropertySetHelper(aController);
 430
 431                 // Object aActiveConnectionObj = aHelper.getPropertyValueAsObject("ActiveConnection");
 432                 Object aActiveConnectionObj = aDBDocUI.getActiveConnection();
 433                 assure("ActiveConnection is empty", aActiveConnectionObj != null);
 434 //                     log.println("5");
 435
 436                 XReportDocumentsSupplier xSupplier = (XReportDocumentsSupplier)UnoRuntime.queryInterface(XReportDocumentsSupplier.class, xOfficeDBDoc);
 437                 xNameAccess = xSupplier.getReportDocuments();
 438                 assure("xOfficeDatabaseDocument returns no Report Document", xNameAccess != null);
 439 //                     log.println("5");
 440
 441                 showElements(xNameAccess);
 442
 443                 ArrayList aPropertyList = new ArrayList();
 444
 445                 PropertyValue aActiveConnection = new PropertyValue();
 446                 aActiveConnection.Name = "ActiveConnection";
 447                 aActiveConnection.Value = aActiveConnectionObj;
 448                 aPropertyList.add(aActiveConnection);
 449
 450                 loadAndStoreReports(xNameAccess, aPropertyList /*, _nType*/ );
 451                 createDBEntry(/*_nType*/);
 452             }
 453             catch(com.sun.star.uno.Exception e)
 454             {
 455                 log.println("ERROR: Exception caught");
 456                 log.println("Message: " + e.getMessage());
 457             }
 458
 459             // String mTestDocumentPath = (String) param.get("TestDocumentPath");
 460             // System.out.println("mTestDocumentPath: '" + mTestDocumentPath + "'");
 461             // // workaround for issue using deprecated "DOCPTH" prop
 462             // System.setProperty("DOCPTH", mTestDocumentPath);
 463
 464             // Close the document
 465             closeComponent(xDocComponent);
 466         }
 467
 468     private String getDocumentPoolName(/*int _nType*/)
 469         {
 470             return "AutogenReportDesignTest";
 471             // return getFileFormat(_nType);
 472         }
 473
 474 // -----------------------------------------------------------------------------
 475     private void createDBEntry(/*int _nType*/)
 476         {
 477             // try to connect the database
 478             String sDBConnection = (String)param.get( convwatch.PropertyName.DB_CONNECTION_STRING );
 479             log.println("DBConnection: " + sDBConnection);
 480             DB.init(sDBConnection);
 481
 482             // String sFixRefSubDirectory = "ReportDesign_qa_complex_" + getFileFormat(_nType);
 483             String sFixRefSubDirectory = "ReportDesignFixRef";
 484
 485             String sSourceVersion = m_sSourceVersion;
 486             // String sSourceVersion = sFixRefSubDirectory;
 487             String sSourceName = m_sSourceName;
 488             // String sSourceCreatorType = "fixref";
 489             String sSourceCreatorType = "";
 490             String sDestinationVersion = m_sDestinationVersion;
 491             // if (sDestinationVersion.length() == 0)
 492             // {
 493             //     sDestinationVersion = m_sUPDMinor;
 494             // }
 495             String sDestinationName = m_sDestinationName;
 496             String sDestinationCreatorType = "";
 497             String sDocumentPoolDir = getOutputPath(/*_nType*/);
 498             String sDocumentPoolName = getDocumentPoolName(/*_nType*/);
 499             String sSpecial = "";
 500
 501             DB.insertinto_documentcompare(sSourceVersion, sSourceName, sSourceCreatorType,
 502                                           m_sDestinationVersion, sDestinationName, sDestinationCreatorType,
 503                                           sDocumentPoolDir, sDocumentPoolName, m_sMailAddress,
 504                                           sSpecial, m_sParentDistinct);
 505             TimeHelper.waitInSeconds(1, "wait for DB.");
 506             // DB.test();
 507             // System.exit(1);
 508         }
 509
 510     private void loadAndStoreReports(XNameAccess _xNameAccess, ArrayList _aPropertyList /*, int _nType*/ )
 511         {
 512             if (_xNameAccess != null)
 513             {
 514                 String[] sElementNames = _xNameAccess.getElementNames();
 515                 for(int i=0;i<sElementNames.length; i++)
 516                 {
 517                     String sReportName = sElementNames[i];
 518                     XComponent xDoc = loadComponent(sReportName, _xNameAccess, _aPropertyList);
 519                     // print? or store?
 520                     storeComponent(sReportName, xDoc /*, _nType*/);
 521                     closeComponent(xDoc);
 522                 }
 523             }
 524         }
 525
 526     private String getFormatExtension(Object _xComponent /* int _nType*/ )
 527          {
 528              String sExtension;
 529              XServiceInfo xServiceInfo = (XServiceInfo) UnoRuntime.queryInterface( XServiceInfo.class, _xComponent );
 530              if ( xServiceInfo.supportsService( "com.sun.star.sheet.SpreadsheetDocument" ) )
 531              {
 532                  // calc
 533                  sExtension = ".ods";
 534              }
 535              else if (xServiceInfo.supportsService("com.sun.star.text.TextDocument"))
 536              {
 537                  //writer
 538                  sExtension = ".odt";
 539              }
 540              else
 541              {
 542                  sExtension = ".UNKNOWN";
 543              }
 544              return sExtension;
 545          }
 546
 547     //         switch(_nType)
 548     //         {
 549     //         case WRITER:
 550     //             sExtension = ".odt";
 551     //             break;
 552     //         case CALC:
 553     //             sExtension = ".ods";
 554     //             break;
 555     //         default:
 556     //             sExtension = ".UNKNOWN";
 557     //         }
 558     //         return sExtension;
 559     //     }
 560     // private String getFileFormat(int _nType)
 561     //     {
 562     //         String sFileType;
 563     //         switch(_nType)
 564     //         {
 565     //         case WRITER:
 566     //             sFileType = "writer8";
 567     //             break;
 568     //         case CALC:
 569     //             sFileType = "calc8";
 570     //             break;
 571     //         default:
 572     //             sFileType = "UNKNOWN";
 573     //         }
 574     //         return sFileType;
 575     //     }
 576
 577     private String m_sOutputPath = null;
 578
 579     private String getOutputPath(/*int _nType*/)
 580         {
 581             if (m_sOutputPath == null)
 582             {
 583                 String sOutputPath = (String)param.get( convwatch.PropertyName.DOC_COMPARATOR_OUTPUT_PATH );
 584                 sOutputPath = helper.StringHelper.removeQuoteIfExists(sOutputPath);
 585
 586                 if (!sOutputPath.endsWith("/") ||         // construct the output file name
 587                     !sOutputPath.endsWith("\\"))
 588                 {
 589                     sOutputPath += System.getProperty("file.separator");
 590                 }
 591                 // sOutputPath += "tmp_123";
 592                 sOutputPath += DateHelper.getDateTimeForFilename();
 593                 sOutputPath += System.getProperty("file.separator");
 594
 595                 // sOutputPath += getFileFormat(_nType);
 596                 // sOutputPath += System.getProperty("file.separator");
 597
 598                 File aOutputFile = new File(sOutputPath); // create the directory of the given output path
 599                 aOutputFile.mkdirs();
 600                 m_sOutputPath = sOutputPath;
 601             }
 602             return m_sOutputPath;
 603         }
 604
 605     /*
 606       store given _xComponent under the given Name in DOC_COMPARATOR_INPUTPATH
 607      */
 608     private void storeComponent(String _sName, Object _xComponent /*, int _nType*/ )
 609         {
 610             String sOutputPath = getOutputPath(/*_nType*/);
 611
 612             // add DocumentPoolName
 613             sOutputPath += getDocumentPoolName(/*_nType*/);
 614             sOutputPath += System.getProperty("file.separator");
 615
 616             File aOutputFile = new File(sOutputPath); // create the directory of the given output path
 617             aOutputFile.mkdirs();
 618
 619             sOutputPath += _sName;
 620             sOutputPath += getFormatExtension(_xComponent /*_nType*/);
 621
 622             String sOutputURL = URLHelper.getFileURLFromSystemPath(sOutputPath);
 623
 624             ArrayList aPropertyList = new ArrayList(); // set some properties for storeAsURL
 625
 626             // PropertyValue aFileFormat = new PropertyValue();
 627             // aFileFormat.Name = "FilterName";
 628             // aFileFormat.Value = getFileFormat(_nType);
 629             // aPropertyList.add(aFileFormat);
 630
 631             PropertyValue aOverwrite = new PropertyValue(); // always overwrite already exist files
 632             aOverwrite.Name = "Overwrite";
 633             aOverwrite.Value = Boolean.TRUE;
 634             aPropertyList.add(aOverwrite);
 635
 636             // store the document in an other directory
 637             XStorable aStorable = (XStorable) UnoRuntime.queryInterface( XStorable.class, _xComponent);
 638             if (aStorable != null)
 639             {
 640                 log.println("store document as URL: '" + sOutputURL + "'");
 641                 try
 642                 {
 643                     aStorable.storeAsURL(sOutputURL, PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList));
 644                 }
 645                 catch (com.sun.star.io.IOException e)
 646                 {
 647                     log.println("ERROR: Exception caught");
 648                     log.println("Can't write document URL: '" + sOutputURL + "'");
 649                     log.println("Message: " + e.getMessage());
 650                 }
 651             }
 652         }
 653
 654     private XComponent loadComponent(String _sName, Object _xComponent, ArrayList _aPropertyList)
 655         {
 656             XComponent xDocComponent = null;
 657             XComponentLoader xComponentLoader = (XComponentLoader) UnoRuntime.queryInterface( XComponentLoader.class, _xComponent );
 658
 659             try
 660             {
 661                 PropertyValue[] aLoadProperties = PropertyHelper.createPropertyValueArrayFormArrayList(_aPropertyList);
 662                 log.println("Load component: '" + _sName + "'");
 663                 xDocComponent = xComponentLoader.loadComponentFromURL(_sName, "_blank", 0, aLoadProperties);
 664                 log.println("Load component: '" + _sName + "' done");
 665             }
 666             catch (com.sun.star.io.IOException e)
 667             {
 668                 log.println("ERROR: Exception caught");
 669                 log.println("Can't load document '" + _sName + "'");
 670                 log.println("Message: " + e.getMessage());
 671             }
 672             catch (com.sun.star.lang.IllegalArgumentException e)
 673             {
 674                 log.println("ERROR: Exception caught");
 675                 log.println("Illegal Arguments given to loadComponentFromURL.");
 676                 log.println("Message: " + e.getMessage());
 677             }
 678             return xDocComponent;
 679         }
 680
 681     private void closeComponent(XComponent _xDoc)
 682         {
 683             // Close the document
 684             XCloseable xCloseable = (XCloseable) UnoRuntime.queryInterface(XCloseable.class, _xDoc);
 685             try
 686             {
 687                 xCloseable.close(true);
 688             }
 689             catch (com.sun.star.util.CloseVetoException e)
 690             {
 691                 log.println("ERROR: CloseVetoException caught");
 692                 log.println("CloseVetoException occured Can't close document.");
 693                 log.println("Message: " + e.getMessage());
 694             }
 695         }
 696
 697 }