qadevOOo/runner/graphical/ParameterHelper.java

   1 /*
   2  * ************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  * ***********************************************************************
  28  */
  29
  30 package graphical;
  31
  32 import com.sun.star.lang.XMultiServiceFactory;
  33 import lib.TestParameters;
  34
  35 /**
  36  * This class object is more a Helper or Controller.
  37  * It stores information like:
  38  * - How to create a document (with a OpenOffice.org method, or with MS Word, or with OpenOffice.org as pdf)
  39  * - some more infos for OpenOffice.org method
  40  *   - a service factory pointer
  41  *   - if hidden mode should use
  42  *   - target name
  43  *
  44  * - printer name
  45  *
  46  * - how to handle .xml files, which in Microsoft could be Excel or Word documents
  47  *
  48  * HOWTO USE:
  49  * For OOo,
  50  *   create an ParameterHelper with a set of TestParameters
  51  *    ParameterHelper a = new ParameterHelper(params);
  52  *
  53  *  If you wish to use pdf export instead of normal printer output, set also the reference type to 'pdf'
  54  *    a.setReferenceType("pdf");
  55  *
  56  *
  57  * For MS Office:
  58  *   create a ParameterHelper and set the reference type to 'msoffice'
  59  *    ParameterHelper a = new ParameterHelper(params);
  60  *    a.setReferenceType("msoffice");
  61  *
  62  * within windows it's better to set also a printer name so it's simply possible to use for normal work the default printer
  63  * and for such tests with ConvWatch a extra printer.
  64  *    a.setPrinterName("CrossOffice Printer");
  65  *
  66  */
  67
  68 public class ParameterHelper
  69 {
  70     /*
  71      TODO:
  72      Possible reference types are currently
  73      // ooo
  74      // pdf
  75      // msoffice
  76     */
  77     private String m_sReferenceType = null;
  78
  79     // private String m_sTargetFrameName = "_blank";
  80
  81     private String m_sPrinterName = null;
  82
  83     private int m_nResolutionInDPI = 180;
  84
  85     private boolean m_bIncludeSubdirectories;
  86
  87     private String m_sInputPath = null;
  88     private String m_sOutputPath = null;
  89 //    private String m_sReferencePath = null;
  90
  91     private TestParameters m_aCurrentParams;
  92
  93     // private GlobalLogWriter m_aLog;
  94
  95     // CONSTRUCTOR
  96     private ParameterHelper(){}
  97
  98     public ParameterHelper(TestParameters param)
  99         {
 100             m_aCurrentParams = param;
 101             // m_aLog = log;
 102             // interpretReferenceType();
 103             // interpretPrinterName();
 104         }
 105
 106
 107     protected TestParameters getTestParameters()
 108         {
 109             return m_aCurrentParams;
 110         }
 111
 112         /**
 113          * return the input path, if given.
 114          * @return
 115          */
 116     public String getInputPath()
 117     {
 118         if (m_sInputPath == null)
 119         {
 120             String sInputPath = (String)getTestParameters().get( PropertyName.DOC_COMPARATOR_INPUT_PATH );
 121             if (sInputPath == null || sInputPath.length() == 0)
 122             {
 123                 GlobalLogWriter.println("Please set input path (path to documents) " + PropertyName.DOC_COMPARATOR_INPUT_PATH + "=path.");
 124             }
 125             else
 126             {
 127                 m_sInputPath = helper.StringHelper.removeQuoteIfExists(sInputPath);
 128             }
 129         }
 130         return m_sInputPath;
 131     }
 132
 133     public String getOutputPath()
 134     {
 135         if (m_sOutputPath == null)
 136         {
 137             String sOutputPath = (String)getTestParameters().get( PropertyName.DOC_COMPARATOR_OUTPUT_PATH );
 138             if (sOutputPath == null || sOutputPath.length() == 0)
 139             {
 140                 GlobalLogWriter.println("Please set output path (path where to store document results) " + PropertyName.DOC_COMPARATOR_OUTPUT_PATH + "=path.");
 141             }
 142             else
 143             {
 144                 m_sOutputPath = helper.StringHelper.removeQuoteIfExists(sOutputPath);
 145             }
 146         }
 147         return m_sOutputPath;
 148     }
 149
 150 //    public String getReferencePath()
 151 //    {
 152 //        if (m_sReferencePath == null)
 153 //        {
 154 //            String sReferencePath = (String)getTestParameters().get( PropertyName.DOC_COMPARATOR_REFERENCE_PATH );
 155 //            if (sReferencePath == null || sReferencePath.length() == 0)
 156 //            {
 157 //                GlobalLogWriter.println("Please set reference path (path to reference documents) " + PropertyName.DOC_COMPARATOR_REFERENCE_PATH + "=path.");
 158 //            }
 159 //            else
 160 //            {
 161 //                m_sReferencePath = sReferencePath;
 162 //            }
 163 //        }
 164 //        return m_sReferencePath;
 165 //    }
 166
 167
 168     public boolean isIncludeSubDirectories()
 169         {
 170             m_bIncludeSubdirectories = true;
 171             String sRECURSIVE = (String)getTestParameters().get( PropertyName.DOC_COMPARATOR_INCLUDE_SUBDIRS );
 172 // TODO: I need to get the boolean value with get("name") because, if it is not given getBool() returns
 173 //       with a default of 'false' which is not very helpful if the default should be 'true'
 174 //       maybe a getBoolean("name", true) could be a better choise.
 175             if (sRECURSIVE == null)
 176             {
 177                 sRECURSIVE = "true";
 178             }
 179             if (sRECURSIVE.toLowerCase().equals("no") ||
 180                 sRECURSIVE.toLowerCase().equals("false"))
 181             {
 182                 m_bIncludeSubdirectories = false;
 183             }
 184             return m_bIncludeSubdirectories;
 185         }
 186
 187     public String getReferenceType()
 188         {
 189             if (m_sReferenceType == null)
 190             {
 191                 // REFERENCE_TYPE ----------
 192
 193                 String sReferenceType = (String)getTestParameters().get( PropertyName.DOC_COMPARATOR_REFERENCE_TYPE );
 194                 if (sReferenceType == null || sReferenceType.length() == 0)
 195                 {
 196                     m_sReferenceType = "ps";
 197                 }
 198                 else
 199                 {
 200                     // log.println("found REFERENCE_TYPE " + sReferenceType );
 201                     m_sReferenceType = sReferenceType;
 202                 }
 203             }
 204             return m_sReferenceType;
 205         }
 206
 207         public String getPrinterName()
 208         {
 209             if (m_sPrinterName == null)
 210             {
 211                 // PRINTER_NAME ----------
 212
 213                 String sPrinterName = (String)getTestParameters().get( PropertyName.DOC_COMPARATOR_PRINTER_NAME );
 214                 if (sPrinterName == null || sPrinterName.length() == 0)
 215                 {
 216                     m_sPrinterName = "";
 217                 }
 218                 else
 219                 {
 220                     // log.println("found PRINTER_NAME " + sPrinterName );
 221                     m_sPrinterName = sPrinterName;
 222                 }
 223             }
 224             return m_sPrinterName;
 225         }
 226
 227     PerformanceContainer m_aPerformanceContainer = null;
 228     /**
 229      * helper class for performance analyser features
 230      * @return
 231      */
 232     public PerformanceContainer getPerformance()
 233         {
 234             if (m_aPerformanceContainer == null)
 235             {
 236                 m_aPerformanceContainer = new PerformanceContainer();
 237             }
 238             return m_aPerformanceContainer;
 239         }
 240
 241     /**
 242      * Helper function to get the buildid of the current used OpenOffice.org
 243      * out of the AppExecutionCommand the build ID
 244      * @return
 245      */
 246     public String getBuildID()
 247         {
 248             String sAPP = (String)m_aCurrentParams.get(util.PropertyName.APP_EXECUTION_COMMAND);
 249             // return getBuildID(sAPP);
 250 //  TODO: here we need the getBuildID(string) method
 251             String sBuildID = BuildID.getBuildID(sAPP);
 252             return sBuildID;
 253         }
 254
 255     /**
 256      * @return integer value, which contain resolution in DPI.
 257      */
 258     public int getResolutionInDPI()
 259     {
 260         return m_nResolutionInDPI;
 261     }
 262     // get methods
 263     public XMultiServiceFactory getMultiServiceFactory()
 264         {
 265             XMultiServiceFactory xMSF = (XMultiServiceFactory)m_aCurrentParams.getMSF();
 266
 267             // check if MultiServiceFactory is given
 268             if (getReferenceType().toLowerCase().equals("pdf") ||
 269                 getReferenceType().toLowerCase().equals("ps") ||
 270                 getReferenceType().toLowerCase().equals("ooo") ||
 271                 getReferenceType().toLowerCase().equals("o3") )
 272             {
 273                 if (xMSF == null)
 274                 {
 275                     GlobalLogWriter.println("ERROR! MultiServiceFactory not given.");
 276                 }
 277             }
 278             return xMSF;
 279         }
 280
 281     // Hidden = true hiddes a used OpenOffice.org, all code is executed in the background
 282     // This parameter is not used for RefType: msoffice
 283     // boolean m_bHidden = true;
 284
 285
 286     public boolean isHidden()
 287     {
 288         // HIDDEN
 289
 290         String sOfficeViewable = (String)m_aCurrentParams.get(PropertyName.OFFICE_VIEWABLE);
 291         if (sOfficeViewable != null)
 292         {
 293             if (sOfficeViewable.toLowerCase().equals("yes") ||
 294                 sOfficeViewable.toLowerCase().equals("true"))
 295             {
 296                 return false; // setViewable();
 297             }
 298             else
 299             {
 300                 return true; // setHidden();
 301             }
 302         }
 303         return true; /* default: hidden */
 304     }
 305
 306     // get/set for FilterName
 307     // get the right Filtername (internal Name) from
 308     // http://framework.openoffice.org/files/documents/25/897/filter_description.html
 309
 310     String m_sImportFilterName = "";
 311     String m_sExportFilterName = "";
 312     public void setImportFilterName(String _sImportFilterName)
 313         {
 314             m_sImportFilterName = _sImportFilterName;
 315         }
 316     public String getImportFilterName()
 317         {
 318             return m_sImportFilterName;
 319         }
 320     public void setExportFilterName(String _sExportFilterName)
 321         {
 322             m_sExportFilterName = _sExportFilterName;
 323         }
 324     public String getExportFilterName()
 325         {
 326             return m_sExportFilterName;
 327         }
 328     String m_sDocumentType = "";
 329     public void setDocumentType(String _sName)
 330         {
 331             m_sDocumentType = _sName;
 332         }
 333     public String getDocumentType()
 334         {
 335             return m_sDocumentType;
 336         }
 337
 338
 339 //    String m_sDefaultXMLFormatApplication = null;
 340 //    public String getDefaultXMLFormatApp()
 341 //    {
 342 //        if (m_sDefaultXMLFormatApplication == null)
 343 //        {
 344 //            // DEFAULT_XML_FORMAT_APP ------
 345 //
 346 //            String sDefaultXMLFormatApp = (String)m_aCurrentParams.get( PropertyName.DOC_COMPARATOR_DEFAULT_XML_FORMAT_APP );
 347 //            if (sDefaultXMLFormatApp == null || sDefaultXMLFormatApp.length() == 0)
 348 //            {
 349 //                m_sDefaultXMLFormatApplication = "word";
 350 //            }
 351 //            else
 352 //            {
 353 //                m_sDefaultXMLFormatApplication = sDefaultXMLFormatApp;
 354 //            }
 355 //        }
 356 //        return m_sDefaultXMLFormatApplication;
 357 //    }
 358
 359
 360     // Pages -------------------------------------------------------------------
 361
 362     /**
 363      * @return the number of pages to be print
 364      */
 365     public int getMaxPages()
 366     {
 367         // default is 0 (print all pages)
 368         int nMaxPages = m_aCurrentParams.getInt( PropertyName.DOC_COMPARATOR_PRINT_MAX_PAGE );
 369         return nMaxPages;
 370     }
 371
 372     /**
 373      * @return as string, which pages should be print, e.g. '1-4;6' here, page 1 to 4 and page 6.
 374      */
 375     public String getOnlyPages()
 376     {
 377         // default is null, there is no page which we want to print only.
 378         String sOnlyPage = (String)m_aCurrentParams.get(PropertyName.DOC_COMPARATOR_PRINT_ONLY_PAGE);
 379         if (sOnlyPage == null)
 380         {
 381             sOnlyPage = "";
 382         }
 383         return sOnlyPage;
 384     }
 385
 386     /**
 387      * @return true, if there should not print all pages at all, use getMaxPages() and or getOnlyPages() to get which pages to print
 388      */
 389     public boolean printAllPages()
 390         {
 391             if ( (getMaxPages() > 0) ||
 392                  (getOnlyPages().length() != 0))
 393             {
 394                 return false;
 395             }
 396             return true;
 397         }
 398
 399     public boolean getOverwrite()
 400         {
 401             boolean bOverwrite = m_aCurrentParams.getBool( PropertyName.DOC_COMPARATOR_OVERWRITE_REFERENCE);
 402             return bOverwrite;
 403         }
 404
 405     private String m_sHTMLPrefix = null;
 406     public String getHTMLPrefix()
 407     {
 408         if (m_sHTMLPrefix == null)
 409         {
 410             String sPrefix = (String)getTestParameters().get( PropertyName.DOC_COMPARATOR_HTML_OUTPUT_PREFIX );
 411             if (sPrefix == null || sPrefix.length() == 0)
 412             {
 413                 GlobalLogWriter.println("Please set html prefix " + PropertyName.DOC_COMPARATOR_HTML_OUTPUT_PREFIX + "=prefix.");
 414             }
 415             else
 416             {
 417                 m_sHTMLPrefix = sPrefix;
 418             }
 419         }
 420         return m_sHTMLPrefix;
 421     }
 422
 423     public boolean createSmallPictures()
 424         {
 425             // boolean bCreateSmallPictures = true;
 426             boolean bNoSmallPictures = m_aCurrentParams.getBool( PropertyName.NO_SMALL_PICTURES);
 427             if (bNoSmallPictures == true)
 428             {
 429                 return false;
 430             }
 431             return true;
 432         }
 433
 434 }