qadevOOo/runner/convwatch/ReportDesignerTest.java

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