| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| package graphical; |
| |
| import com.sun.star.frame.FrameSearchFlag; |
| import com.sun.star.util.XCloseable; |
| import helper.OfficeProvider; |
| import helper.OfficeWatcher; |
| import java.util.ArrayList; |
| |
| import com.sun.star.uno.UnoRuntime; |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.document.XTypeDetection; |
| import com.sun.star.container.XNameAccess; |
| import com.sun.star.frame.XDesktop; |
| import com.sun.star.beans.XPropertySet; |
| import com.sun.star.beans.PropertyValue; |
| import com.sun.star.frame.XComponentLoader; |
| import com.sun.star.lang.XComponent; |
| import com.sun.star.frame.XStorable; |
| import com.sun.star.view.XPrintable; |
| import com.sun.star.lang.XServiceInfo; |
| import com.sun.star.frame.XModel; |
| import com.sun.star.uno.AnyConverter; |
| |
| import helper.URLHelper; |
| import helper.PropertyHelper; |
| import helper.OSHelper; |
| |
| // import helper.Parameter; |
| import java.io.File; |
| |
| /** |
| * This Object is to print a given document with OpenOffice.org / StarOffice |
| * over the normal printer driver |
| * or over it's pdf exporter |
| */ |
| public class OpenOfficePostscriptCreator implements IOffice |
| { |
| private ParameterHelper m_aParameterHelper; |
| private String m_sOutputURL; |
| private String m_sBasename; |
| private String m_sDocumentName; |
| private XComponent m_aDocument; |
| |
| public OpenOfficePostscriptCreator(ParameterHelper _aParam, String _sResult) |
| { |
| m_aParameterHelper = _aParam; |
| String sOutputURL = _sResult; |
| if (! sOutputURL.startsWith("file:")) |
| { |
| sOutputURL = URLHelper.getFileURLFromSystemPath(_sResult); |
| } |
| m_sOutputURL = sOutputURL; |
| m_aDocument = null; |
| } |
| |
| |
| public void load(String _sDocumentName) throws OfficeException |
| { |
| m_sDocumentName = _sDocumentName; |
| |
| String sInputFileURL = URLHelper.getFileURLFromSystemPath(m_sDocumentName); |
| m_aDocument = loadFromURL(m_aParameterHelper, sInputFileURL); |
| if (m_aDocument == null) |
| { |
| GlobalLogWriter.println("loadDocumentFromURL() failed with document: " + sInputFileURL); |
| throw new OfficeException("load(): failed with document" + sInputFileURL); |
| } |
| |
| m_sBasename = FileHelper.getBasename(m_sDocumentName); |
| } |
| |
| public void storeAsPostscript() throws OfficeException |
| { |
| if (m_aDocument != null) |
| { |
| String sDocumentName = FileHelper.appendPath(m_sOutputURL, m_sBasename); |
| if (m_aParameterHelper.getReferenceType().toLowerCase().equals("ooo") || |
| m_aParameterHelper.getReferenceType().toLowerCase().equals("o3") || |
| m_aParameterHelper.getReferenceType().toLowerCase().equals("ps") ) |
| { |
| String sPrintURL = sDocumentName + ".ps"; |
| |
| impl_printToFileWithOOo(m_aParameterHelper, m_aDocument, sDocumentName, sPrintURL /*_sPrintFileURL*/); |
| String sBasename = FileHelper.getBasename(sPrintURL); |
| FileHelper.addBasenameToIndex(m_sOutputURL, sBasename, "OOo", "postscript", m_sDocumentName); |
| } |
| else if (m_aParameterHelper.getReferenceType().toLowerCase().equals("pdf")) |
| { |
| String sPDFURL = sDocumentName + ".pdf"; |
| storeAsPDF(m_aParameterHelper, m_aDocument, sPDFURL); |
| |
| String sBasename = FileHelper.getBasename(sPDFURL); |
| FileHelper.addBasenameToIndex(m_sOutputURL, sBasename, "pdf", "pdf-export", m_sDocumentName); |
| } |
| else |
| { |
| throw new OfficeException("unknown reference type"); |
| } |
| GlobalLogWriter.println("Close document."); |
| m_aDocument.dispose(); |
| } |
| } |
| |
| public void start() throws OfficeException |
| { |
| startOffice(); |
| } |
| |
| public void close() throws OfficeException |
| { |
| stopOffice(); |
| } |
| |
| |
| |
| |
| |
| private void showProperty(PropertyValue _aValue) |
| { |
| String sName = _aValue.Name; |
| String sValue; |
| try |
| { |
| sValue = AnyConverter.toString(_aValue.Value); |
| GlobalLogWriter.println("Property " + sName + ":=" + sValue); |
| } |
| catch (com.sun.star.lang.IllegalArgumentException e) |
| { |
| GlobalLogWriter.println("showProperty: can't convert a object to string. " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * shows the FilterName and MediaType from the given XComponent |
| */ |
| private String getDocumentType( XComponent _aDoc ) |
| { |
| XModel xModel = UnoRuntime.queryInterface( XModel.class, _aDoc); |
| PropertyValue[] aArgs = xModel.getArgs(); |
| for (int i=0;i<aArgs.length;i++) |
| { |
| PropertyValue aValue = aArgs[i]; |
| // System.out.print("Property: '" + aValue.Name); |
| // System.out.println("' := '" + aValue.Value + "'"); |
| if (aValue.Name.equals("FilterName") || |
| aValue.Name.equals("MediaType")) |
| { |
| String sNameValue = "'" + aValue.Name + "' := '" + aValue.Value + "'"; |
| return sNameValue; |
| } |
| } |
| return ""; |
| } |
| |
| private void showDocumentType( XComponent _aDoc ) |
| { |
| String sNameValue = getDocumentType(_aDoc); |
| GlobalLogWriter.println(" Property: '" + sNameValue); |
| } |
| /** |
| * load a OpenOffice.org document from a given URL (_sInputURL) |
| * the ParameterHelper must contain a living MultiServiceFactory object |
| * or we crash here. |
| * Be aware, the ownership of the document gets to you, you have to close it. |
| */ |
| private XComponent loadFromURL(ParameterHelper _aGTA, |
| String _sInputURL) |
| { |
| XComponent aDoc = null; |
| try |
| { |
| if (_aGTA.getMultiServiceFactory() == null) |
| { |
| GlobalLogWriter.println("MultiServiceFactory in GraphicalTestArgument not set."); |
| return null; |
| } |
| Object oDsk = _aGTA.getMultiServiceFactory().createInstance("com.sun.star.frame.Desktop"); |
| XDesktop aDesktop = UnoRuntime.queryInterface(XDesktop.class, oDsk); |
| |
| if (aDesktop != null) |
| { |
| GlobalLogWriter.println("com.sun.star.frame.Desktop created."); |
| // String sInputURL = aCurrentParameter.sInputURL; |
| // String sOutputURL = aCurrentParameter.sOutputURL; |
| // String sPrintFileURL = aCurrentParameter.sPrintToFileURL; |
| // System.out.println(_sInputURL); |
| |
| |
| // set here the loadComponentFromURL() properties |
| // at the moment only 'Hidden' is set, so no window is opened at work |
| |
| ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>(); |
| |
| // check which properties should set and count it. |
| // if (_aGTA.isHidden()) |
| // { |
| // nPropertyCount ++; |
| // } |
| // if (_aGTA.getImportFilterName() != null && _aGTA.getImportFilterName().length() > 0) |
| // { |
| // nPropertyCount ++; |
| // } |
| |
| // initialize the propertyvalue |
| // int nPropertyIndex = 0; |
| // aProps = new PropertyValue[ nPropertyCount ]; |
| |
| // set all property values |
| if (_aGTA.isHidden()) |
| { |
| PropertyValue Arg = new PropertyValue(); |
| Arg.Name = "Hidden"; |
| Arg.Value = Boolean.TRUE; |
| aPropertyList.add(Arg); |
| showProperty(Arg); |
| } |
| if (_aGTA.getImportFilterName() != null && _aGTA.getImportFilterName().length() > 0) |
| { |
| PropertyValue Arg = new PropertyValue(); |
| Arg.Name = "FilterName"; |
| Arg.Value = _aGTA.getImportFilterName(); |
| aPropertyList.add(Arg); |
| showProperty(Arg); |
| } |
| PropertyValue ReadOnly = new PropertyValue(); |
| ReadOnly.Name = "ReadOnly"; |
| ReadOnly.Value = Boolean.TRUE; |
| aPropertyList.add(ReadOnly); |
| showProperty(ReadOnly); |
| |
| GlobalLogWriter.println(DateHelper.getDateTimeForHumanreadableLog() + " Load document"); |
| // GlobalLogWriter.flush(); |
| |
| XComponentLoader aCompLoader = UnoRuntime.queryInterface( XComponentLoader.class, aDesktop); |
| |
| // XComponent aDoc = null; |
| |
| _aGTA.getPerformance().startTime(PerformanceContainer.Load); |
| aDoc = aCompLoader.loadComponentFromURL(_sInputURL, "_blank", FrameSearchFlag.ALL, PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList) ); |
| _aGTA.getPerformance().stopTime(PerformanceContainer.Load); |
| if (aDoc != null) |
| { |
| GlobalLogWriter.println(DateHelper.getDateTimeForHumanreadableLog() + " Load document done."); |
| showDocumentType(aDoc); |
| _aGTA.setDocumentType(getDocumentType(aDoc)); |
| // TODO: TimeHelper.waitInSeconds(20, "Wait after load document. Maybe helps due to layouting problems."); |
| } |
| else |
| { |
| GlobalLogWriter.println(" Load document failed."); |
| if (_aGTA.getImportFilterName() != null && _aGTA.getImportFilterName().length() > 0) |
| { |
| GlobalLogWriter.println(" Please check FilterName := '" + _aGTA.getImportFilterName() + "'"); |
| } |
| GlobalLogWriter.println(""); |
| } |
| } |
| else |
| { |
| GlobalLogWriter.println("com.sun.star.frame.Desktop failed."); |
| } |
| } |
| catch ( com.sun.star.uno.Exception e ) |
| { |
| // Some exception occures.FAILED |
| GlobalLogWriter.println("UNO Exception caught."); |
| GlobalLogWriter.println("Message: " + e.getMessage()); |
| e.printStackTrace(); |
| aDoc = null; |
| } |
| return aDoc; |
| } |
| |
| private boolean exportToPDF(XComponent _xComponent, String _sDestinationName) |
| { |
| XServiceInfo xServiceInfo = |
| UnoRuntime.queryInterface( |
| XServiceInfo.class, _xComponent |
| ); |
| |
| ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>(); |
| PropertyValue aFiltername = new PropertyValue(); |
| aFiltername.Name = "FilterName"; |
| aFiltername.Value = getFilterName_forPDF(xServiceInfo); |
| aPropertyList.add(aFiltername); |
| showProperty(aFiltername); |
| boolean bWorked = true; |
| |
| // TODO: TimeHelper.waitInSeconds(20, "Wait before storeToURL. Maybe helps due to layouting problems."); |
| try |
| { |
| XStorable store = |
| UnoRuntime.queryInterface( |
| XStorable.class, _xComponent |
| ); |
| store.storeToURL(_sDestinationName, PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList)); |
| } |
| catch (com.sun.star.io.IOException e) |
| { |
| GlobalLogWriter.println("IO Exception caught."); |
| GlobalLogWriter.println("Message: " + e.getMessage()); |
| bWorked = false; |
| } |
| |
| return bWorked; |
| } |
| |
| |
| private String getFilterName_forPDF(XServiceInfo xServiceInfo) |
| { |
| String filterName = ""; |
| |
| if (xServiceInfo.supportsService("com.sun.star.text.TextDocument")) |
| { |
| //writer |
| filterName = "writer_pdf_Export"; |
| } |
| else if ( xServiceInfo.supportsService( "com.sun.star.sheet.SpreadsheetDocument" ) ) |
| { |
| //calc |
| filterName = "calc_pdf_Export"; |
| } |
| else if ( xServiceInfo.supportsService( "com.sun.star.drawing.DrawingDocument" ) ) |
| { |
| //draw |
| filterName = "draw_pdf_Export"; |
| } |
| else if ( xServiceInfo.supportsService( "com.sun.star.presentation.PresentationDocument" ) ) |
| { |
| //impress |
| filterName = "impress_pdf_Export"; |
| } |
| else if (xServiceInfo.supportsService("com.sun.star.text.WebDocument")) |
| { |
| //html document |
| filterName = "writer_web_pdf_Export"; |
| } |
| else if ( xServiceInfo.supportsService("com.sun.star.text.GlobalDocument") ) |
| { |
| //master document |
| filterName = "writer_globaldocument_pdf_Export"; |
| } |
| else if ( xServiceInfo.supportsService( "com.sun.star.formulaFormulaProperties" ) ) |
| { |
| //math document |
| filterName = "math_pdf_Export"; |
| } |
| |
| return filterName; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| // public boolean storeAsPDF(ParameterHelper _aGTA, |
| // String _sInputURL, |
| // String _sOutputURL) |
| // { |
| // boolean bBack = false; |
| // XComponent aDoc = loadFromURL(_aGTA, _sInputURL); |
| // |
| // if (aDoc == null) |
| // { |
| // GlobalLogWriter.println("Can't load document."); |
| // return bBack; |
| // } |
| // bBack = storeAsPDF(_aGTA, aDoc, _sOutputURL); |
| // FileHelper.createInfoFile(_sOutputURL, _aGTA, "as pdf"); |
| // |
| // GlobalLogWriter.println("Close document."); |
| // aDoc.dispose(); |
| // return bBack; |
| // } |
| |
| public boolean storeAsPDF(ParameterHelper _aGTA, |
| XComponent _aDoc, |
| String _sOutputURL) throws OfficeException |
| { |
| // try { |
| boolean bBack = true; |
| _aGTA.getPerformance().startTime(PerformanceContainer.StoreAsPDF); |
| bBack = exportToPDF(_aDoc, _sOutputURL); |
| _aGTA.getPerformance().stopTime(PerformanceContainer.StoreAsPDF); |
| |
| if (!bBack) |
| { |
| GlobalLogWriter.println("Can't store document as PDF."); |
| // bBack = false; |
| throw new OfficeException("Can't store document as PDF"); |
| } |
| else |
| { |
| FileHelper.createInfoFile(_sOutputURL, _aGTA, "as pdf"); |
| } |
| return bBack; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| /** |
| * print the document found in file (_sInputURL) to as postscript to file (_sPrintFileURL) |
| * Due to the fact we use a printer to convert the file to postscript, the default printer |
| * to create such postscript format must be installed, this is not tested here. |
| * |
| * @return true, if print has been done. |
| * Be careful, true means only print returns with no errors, to be sure print is really done |
| * check existance of _sPrintFileURL |
| */ |
| |
| // public boolean printToFileWithOOo(ParameterHelper _aGTA, |
| // String _sInputURL, |
| // String _sOutputURL, |
| // String _sPrintFileURL) |
| // { |
| // // waitInSeconds(1); |
| // boolean bBack = false; |
| // |
| // XComponent aDoc = loadFromURL(_aGTA, _sInputURL); |
| // if (aDoc != null) |
| // { |
| // if ( _sInputURL.equals(_sOutputURL) ) |
| // { |
| // // don't store document |
| // // input and output are equal OR |
| // GlobalLogWriter.println("Warning: Inputpath and Outputpath are equal. Document will not stored again."); |
| // disallowStore(); |
| // } |
| // bBack = impl_printToFileWithOOo(_aGTA, aDoc, _sOutputURL, _sPrintFileURL); |
| // |
| // GlobalLogWriter.println("Close document."); |
| // aDoc.dispose(); |
| // } |
| // else |
| // { |
| // GlobalLogWriter.println("loadDocumentFromURL() failed with document: " + _sInputURL); |
| // } |
| // return bBack; |
| // } |
| |
| |
| |
| // ----------------------------------------------------------------------------- |
| private boolean impl_printToFileWithOOo(ParameterHelper _aGTA, |
| XComponent _aDoc, |
| String _sOutputURL, |
| String _sPrintFileURL) |
| { |
| boolean bBack = false; |
| boolean bFailed = true; // always be a pessimist, |
| if (_aDoc == null) |
| { |
| GlobalLogWriter.println("No document is given."); |
| return bBack; |
| } |
| |
| try |
| { |
| if (_sOutputURL != null) |
| { |
| if (isStoreAllowed()) |
| { |
| // store the document in an other directory |
| XStorable aStorable = UnoRuntime.queryInterface( XStorable.class, _aDoc); |
| if (aStorable != null) |
| { |
| PropertyValue [] szEmptyArgs = new PropertyValue [0]; |
| |
| GlobalLogWriter.println(DateHelper.getDateTimeForHumanreadableLog() + " Store document."); |
| _aGTA.getPerformance().startTime(PerformanceContainer.Store); |
| aStorable.storeAsURL(_sOutputURL, szEmptyArgs); |
| _aGTA.getPerformance().stopTime(PerformanceContainer.Store); |
| |
| GlobalLogWriter.println(DateHelper.getDateTimeForHumanreadableLog() + " Store document done."); |
| // TimeHelper.waitInSeconds(1, "After store as URL to:" + _sOutputURL); |
| GlobalLogWriter.println("Reload stored file test."); |
| XComponent aDoc = loadFromURL(_aGTA, _sOutputURL); |
| if (aDoc == null) |
| { |
| GlobalLogWriter.println("Reload stored file test failed, can't reload file: " + _sOutputURL); |
| } |
| else |
| { |
| XCloseable xClose = UnoRuntime.queryInterface(XCloseable.class, aDoc); |
| if (xClose != null) |
| { |
| xClose.close(true); |
| } |
| else |
| { |
| aDoc.dispose(); |
| } |
| // TimeHelper.waitInSeconds(1, "after close temp document"); |
| } |
| } |
| } |
| else |
| { |
| // make sure to create the directory in |
| String sOutputFilename = FileHelper.getSystemPathFromFileURL(_sOutputURL); |
| String sOutputPath = FileHelper.getPath(sOutputFilename); |
| File aFile = new File(sOutputPath); |
| aFile.mkdirs(); |
| } |
| } |
| } |
| catch ( com.sun.star.uno.Exception e ) |
| { |
| // Some exception occures.FAILED |
| GlobalLogWriter.println("UNO Exception caught."); |
| GlobalLogWriter.println("Message: " + e.getMessage()); |
| |
| e.printStackTrace(); |
| bBack = false; |
| } |
| |
| try |
| { |
| |
| // System.out.println("Document loaded."); |
| // Change Pagesettings to DIN A4 |
| |
| GlobalLogWriter.println(DateHelper.getDateTimeForHumanreadableLog() + " Print document."); |
| XPrintable aPrintable = UnoRuntime.queryInterface( XPrintable.class, _aDoc); |
| if (aPrintable != null) |
| { |
| // System.out.println(" Set PaperFormat to DIN A4"); |
| // { |
| // PropertyValue[] aPrinterProps = aPrintable.getPrinter(); |
| // System.out.println("PrinterProps size: " + String.valueOf(aPrinterProps.length)); |
| // int nPropIndex = 0; |
| // while (!"PaperFormat".equals(aPrinterProps[nPropIndex].Name)) |
| // { |
| // // System.out.println(aPrinterProps[nPropIndex].Name); |
| // nPropIndex++; |
| // } |
| // aPrinterProps[nPropIndex].Value = com.sun.star.view.PaperFormat.A4; |
| // aPrintable.setPrinter(aPrinterProps); |
| // } |
| |
| // configure Office to allow to execute macos |
| |
| // TODO: We need a possiblity to set the printer name also for StarOffice/OpenOffice |
| if (OSHelper.isWindows()) |
| { |
| if (_aGTA.getPrinterName() != null) |
| { |
| ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>(); |
| // PropertyValue [] aPrintProps = new PropertyValue[1]; |
| PropertyValue Arg = new PropertyValue(); |
| Arg.Name = "Name"; |
| Arg.Value = _aGTA.getPrinterName(); |
| aPropertyList.add(Arg); |
| showProperty(Arg); |
| // GlobalLogWriter.println("Printername is not null, so set to " + _aGTA.getPrinterName()); |
| aPrintable.setPrinter(PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList)); |
| } |
| } |
| |
| // set property values for XPrintable.print() |
| // more can be found at "http://api.openoffice.org/docs/common/ref/com/sun/star/view/PrintOptions.html" |
| |
| // int nProperties = 1; // default for 'FileName' property |
| // if (_aGTA.printAllPages() == false) |
| // { |
| // // we don't want to print all pages, build Pages string by ourself |
| // nProperties ++; |
| // } |
| // int nPropsCount = 0; |
| |
| // If we are a SpreadSheet (calc), we need to set PrintAllSheets property to 'true' |
| XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, _aDoc ); |
| if ( xServiceInfo.supportsService( "com.sun.star.sheet.SpreadsheetDocument" ) ) |
| { |
| XMultiServiceFactory xMSF = _aGTA.getMultiServiceFactory(); |
| Object aSettings = xMSF.createInstance( "com.sun.star.sheet.GlobalSheetSettings" ); |
| if (aSettings != null) |
| { |
| XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, aSettings ); |
| xPropSet.setPropertyValue( "PrintAllSheets", new Boolean( true ) ); |
| GlobalLogWriter.println("PrintAllSheets := true"); |
| } |
| } |
| |
| ArrayList<PropertyValue> aPrintProps = new ArrayList<PropertyValue>(); |
| // GlobalLogWriter.println("Property FileName:=" + _sPrintFileURL); |
| |
| // PropertyValue [] aPrintProps = new PropertyValue[nProperties]; |
| PropertyValue Arg = new PropertyValue(); |
| Arg.Name = "FileName"; |
| Arg.Value = _sPrintFileURL; |
| // aPrintProps[nPropsCount ++] = Arg; |
| aPrintProps.add(Arg); |
| showProperty(Arg); |
| |
| |
| // generate pages string |
| if (_aGTA.printAllPages() == false) |
| { |
| String sPages = ""; |
| if (_aGTA.getMaxPages() > 0) |
| { |
| sPages = "1-" + String.valueOf(_aGTA.getMaxPages()); |
| } |
| if (_aGTA.getOnlyPages().length() != 0) |
| { |
| if (sPages.length() != 0) |
| { |
| sPages += ";"; |
| } |
| sPages += String.valueOf(_aGTA.getOnlyPages()); |
| } |
| |
| Arg = new PropertyValue(); |
| Arg.Name = "Pages"; |
| Arg.Value = sPages; |
| aPrintProps.add(Arg); |
| showProperty(Arg); |
| } |
| |
| // GlobalLogWriter.println("Start printing."); |
| |
| _aGTA.getPerformance().startTime(PerformanceContainer.Print); |
| aPrintable.print(PropertyHelper.createPropertyValueArrayFormArrayList(aPrintProps)); |
| TimeHelper.waitInSeconds(1, "Start waiting for print ready."); |
| |
| GlobalLogWriter.println("Wait until document is printed."); |
| boolean isBusy = true; |
| int nPrintCount = 0; |
| while (isBusy) |
| { |
| PropertyValue[] aPrinterProps = aPrintable.getPrinter(); |
| int nPropIndex = 0; |
| while (!"IsBusy".equals(aPrinterProps[nPropIndex].Name)) |
| { |
| // System.out.println(aPrinterProps[nPropIndex].Name); |
| nPropIndex++; |
| } |
| isBusy = (aPrinterProps[nPropIndex].Value == Boolean.TRUE) ? true : false; |
| TimeHelper.waitInSeconds(1, "is print ready?"); |
| nPrintCount++; |
| if (nPrintCount > 3600) |
| { |
| // we will never wait >1h until print is ready! |
| GlobalLogWriter.println("ERROR: Cancel print due to too long wait."); |
| throw new com.sun.star.uno.Exception("Convwatch exception, wait too long for printing."); |
| } |
| } |
| // TODO: |
| // TimeHelper.waitInSeconds(40, "Start waiting after print ready."); |
| |
| _aGTA.getPerformance().stopTime(PerformanceContainer.Print); |
| GlobalLogWriter.println(DateHelper.getDateTimeForHumanreadableLog() + " Print document done."); |
| |
| // Create a .info file near the printed '.ps' or '.prn' file. |
| FileHelper.createInfoFile(_sPrintFileURL, _aGTA); |
| } |
| else |
| { |
| GlobalLogWriter.println("Can't get XPrintable interface."); |
| } |
| bFailed = false; |
| bBack = true; |
| } |
| catch ( com.sun.star.uno.Exception e ) |
| { |
| // Some exception occures.FAILED |
| GlobalLogWriter.println("UNO Exception caught."); |
| GlobalLogWriter.println("Message: " + e.getMessage()); |
| |
| e.printStackTrace(); |
| bBack = false; |
| } |
| |
| if (bFailed == true) |
| { |
| GlobalLogWriter.println("convwatch.OfficePrint: FAILED"); |
| } |
| else |
| { |
| GlobalLogWriter.println("convwatch.OfficePrint: OK"); |
| } |
| return bBack; |
| } |
| |
| |
| /** |
| * @param _aGTA |
| * @param _sAbsoluteOutputPath |
| * @param _sAbsoluteInputFile |
| * @return true, if the reference (*.prrn file) based on given output path and given input path exist. |
| * If OVERWRITE_REFERENCE is set, always return false. |
| */ |
| public boolean isReferenceExists(ParameterHelper _aGTA, |
| String _sAbsoluteOutputPath, |
| String _sAbsoluteInputFile) |
| { |
| if (! FileHelper.exists(_sAbsoluteInputFile)) |
| { |
| // throw new ConvWatchCancelException("Input file: " + _sAbsoluteInputFile + " does not exist."); |
| return false; |
| } |
| |
| // String fs = System.getProperty("file.separator"); |
| |
| // String sInputFileURL = URLHelper.getFileURLFromSystemPath(_sAbsoluteInputFile); |
| |
| String sInputFileBasename = FileHelper.getBasename(_sAbsoluteInputFile); |
| // String sOutputFileURL = null; |
| String sOutputPath; |
| if (_sAbsoluteOutputPath != null) |
| { |
| sOutputPath = _sAbsoluteOutputPath; |
| // FileHelper.makeDirectories("", sOutputPath); |
| } |
| else |
| { |
| String sInputPath = FileHelper.getPath(_sAbsoluteInputFile); |
| sOutputPath = sInputPath; |
| } |
| // sOutputFileURL = URLHelper.getFileURLFromSystemPath(sOutputPath + fs + sInputFileBasename); |
| // sOutputFileURL = null; |
| |
| String sPrintFilename = FileHelper.getNameNoSuffix(sInputFileBasename); |
| // String sPrintFileURL; |
| |
| String sAbsolutePrintFilename = FileHelper.appendPath(sOutputPath, sPrintFilename + ".prn"); |
| if (FileHelper.exists(sAbsolutePrintFilename) && _aGTA.getOverwrite() == false) |
| { |
| GlobalLogWriter.println("Reference already exist, don't overwrite. Set " + PropertyName.DOC_COMPARATOR_OVERWRITE_REFERENCE + "=true to force overwrite."); |
| return true; |
| } |
| return false; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| /** |
| * create a reference file |
| * _sAbsoluteInputPath contains the source file, if not exists, return with failure. |
| * _sAbsoluteOutputPath contains the destination, where the file will store after load with StarOffice/OpenOffice.org |
| * if is null, print only near the Input file path |
| * _sPrintType ".prn" Print input file with StarOffice/OpenOffice.org and the default printer as PostScript |
| * |
| * @param _aGTA |
| * @return |
| */ |
| // public static boolean buildReference(ParameterHelper _aGTA, |
| // String _sAbsoluteOutputPath, |
| // String _sAbsoluteInputFile) |
| // throws OfficeException |
| // { |
| // if (! FileHelper.exists(_sAbsoluteInputFile)) |
| // { |
| // throw new OfficeException("buildReference(): Input file: " + _sAbsoluteInputFile + " does not exist."); |
| // } |
| // |
| // String fs = System.getProperty("file.separator"); |
| // |
| // String sInputFileURL = URLHelper.getFileURLFromSystemPath(_sAbsoluteInputFile); |
| // |
| // String sInputFileBasename = FileHelper.getBasename(_sAbsoluteInputFile); |
| // String sOutputFileURL = null; |
| // String sOutputPath; |
| // if (_sAbsoluteOutputPath != null) |
| // { |
| // sOutputPath = _sAbsoluteOutputPath; |
| // FileHelper.makeDirectories("", sOutputPath); |
| // } |
| // else |
| // { |
| // String sInputPath = FileHelper.getPath(_sAbsoluteInputFile); |
| // sOutputPath = sInputPath; |
| // } |
| // // sOutputFileURL = URLHelper.getFileURLFromSystemPath(sOutputPath + fs + sInputFileBasename); |
| // sOutputFileURL = null; |
| // |
| // String sPrintFilename = FileHelper.getNameNoSuffix(sInputFileBasename); |
| // String sPrintFileURL; |
| // |
| // String sAbsolutePrintFilename = sOutputPath + fs + sPrintFilename + ".prn"; |
| // if (FileHelper.exists(sAbsolutePrintFilename) && _aGTA.getOverwrite() == false) |
| // { |
| // GlobalLogWriter.println("Reference already exist, don't overwrite. Set " + PropertyName.DOC_COMPARATOR_OVERWRITE_REFERENCE + "=true to force overwrite."); |
| // return true; |
| // } |
| // |
| // if (_aGTA.getReferenceType().toLowerCase().equals("msoffice")) |
| // { |
| // sPrintFileURL = URLHelper.getFileURLFromSystemPath(sAbsolutePrintFilename); |
| // } |
| // else if (_aGTA.getReferenceType().toLowerCase().equals("pdf")) |
| // { |
| //// TODO: If we rename the stored file to *.pdf, we have to be sure that we use *.pdf also as a available reference |
| // sPrintFileURL = URLHelper.getFileURLFromSystemPath(sAbsolutePrintFilename ); |
| // } |
| // else if (_aGTA.getReferenceType().toLowerCase().equals("ooo")) |
| // { |
| // sPrintFileURL = URLHelper.getFileURLFromSystemPath(sAbsolutePrintFilename ); |
| // } |
| // else |
| // { |
| // GlobalLogWriter.println("OfficePrint.buildreference(): Unknown print type."); |
| // return false; |
| // } |
| // return printToFile(_aGTA, sInputFileURL, sOutputFileURL, sPrintFileURL); |
| // } |
| |
| |
| |
| // TODO: Das Teil muss hier raus! |
| |
| |
| // public static boolean printToFile(ParameterHelper _aGTA, |
| // String _sInputFileURL, |
| // String _sOutputFileURL, |
| // String _sPrintFileURL) throws OfficeException |
| // { |
| // boolean bBack = false; |
| // String sPrintFileURL = null; |
| // |
| // |
| // // remember the current timer, to know how long a print process need. |
| // // startTimer(); |
| // |
| // if (_aGTA.getReferenceType().toLowerCase().equals("ooo")) |
| // { |
| // bBack = printToFileWithOOo(_aGTA, _sInputFileURL, _sOutputFileURL, _sPrintFileURL); |
| // } |
| // else if (_aGTA.getReferenceType().toLowerCase().equals("pdf")) |
| // { |
| // GlobalLogWriter.println("USE PDF AS EXPORT FORMAT."); |
| // bBack = storeAsPDF(_aGTA, _sInputFileURL, _sPrintFileURL); |
| // } |
| // else if (_aGTA.getReferenceType().toLowerCase().equals("msoffice")) |
| // { |
| // if (MSOfficePostscriptCreator.isMSOfficeDocumentFormat(_sInputFileURL)) |
| // { |
| // GlobalLogWriter.println("USE MSOFFICE AS EXPORT FORMAT."); |
| // MSOfficePostscriptCreator a = new MSOfficePostscriptCreator(); |
| // try |
| // { |
| // a.printToFileWithMSOffice(_aGTA, FileHelper.getSystemPathFromFileURL(_sInputFileURL), |
| // FileHelper.getSystemPathFromFileURL(_sPrintFileURL)); |
| // } |
| // catch(OfficeException e) |
| // { |
| // e.printStackTrace(); |
| // GlobalLogWriter.println(e.getMessage()); |
| // throw new OfficeException("Exception caught. Problem with MSOffice printer methods."); |
| // } |
| // catch(java.io.IOException e) |
| // { |
| // GlobalLogWriter.println(e.getMessage()); |
| // throw new OfficeException("IOException caught. Problem with MSOffice printer methods."); |
| // } |
| // bBack = true; |
| // } |
| // else |
| // { |
| // GlobalLogWriter.println("This document type is not recognized as MSOffice format, as default fallback StarOffice/OpenOffice.org instead is used."); |
| // bBack = printToFileWithOOo(_aGTA, _sInputFileURL, _sOutputFileURL, _sPrintFileURL); |
| // } |
| // } |
| // else |
| // { |
| // // System.out.println(""); |
| // throw new OfficeException("OfficePrint.printToFile(): Unknown print type."); |
| // } |
| // return bBack; |
| // } |
| |
| // ----------------------------------------------------------------------------- |
| // TODO: move this away! |
| // ----------------------------------------------------------------------------- |
| void showType(String _sInputURL, XMultiServiceFactory _xMSF) |
| { |
| if (_sInputURL.length() == 0) |
| { |
| return; |
| } |
| |
| if (_xMSF == null) |
| { |
| GlobalLogWriter.println("MultiServiceFactory not set."); |
| return; |
| } |
| XTypeDetection aTypeDetection = null; |
| try |
| { |
| Object oObj = _xMSF.createInstance("com.sun.star.document.TypeDetection"); |
| aTypeDetection = UnoRuntime.queryInterface(XTypeDetection.class, oObj); |
| } |
| catch(com.sun.star.uno.Exception e) |
| { |
| GlobalLogWriter.println("Can't get com.sun.star.document.TypeDetection."); |
| return; |
| } |
| if (aTypeDetection != null) |
| { |
| String sType = aTypeDetection.queryTypeByURL(_sInputURL); |
| GlobalLogWriter.println("Type is: " + sType); |
| } |
| } |
| |
| |
| // ----------------------------------------------------------------------------- |
| public String getInternalFilterName(String _sFilterName, XMultiServiceFactory _xMSF) |
| { |
| if (_sFilterName.length() == 0) |
| { |
| // System.out.println("No FilterName set."); |
| return null; |
| } |
| |
| if (_xMSF == null) |
| { |
| GlobalLogWriter.println("MultiServiceFactory not set."); |
| return null; |
| } |
| // XFilterFactory aFilterFactory = null; |
| Object aObj = null; |
| try |
| { |
| aObj = _xMSF.createInstance("com.sun.star.document.FilterFactory"); |
| } |
| catch(com.sun.star.uno.Exception e) |
| { |
| GlobalLogWriter.println("Can't get com.sun.star.document.FilterFactory."); |
| return null; |
| } |
| if (aObj != null) |
| { |
| XNameAccess aNameAccess = UnoRuntime.queryInterface(XNameAccess.class, aObj); |
| if (aNameAccess != null) |
| { |
| |
| // if (_sFilterName.toLowerCase().equals("help")) |
| // { |
| // System.out.println("Show all possible ElementNames from current version." ); |
| // String[] aElementNames = aNameAccess.getElementNames(); |
| // for (int i = 0; i<aElementNames.length; i++) |
| // { |
| // System.out.println(aElementNames[i]); |
| // } |
| // System.out.println("Must quit."); |
| // System.out.exit(1); |
| // } |
| |
| if (! aNameAccess.hasByName(_sFilterName)) |
| { |
| GlobalLogWriter.println("FilterFactory.hasByName() says there exist no '" + _sFilterName + "'" ); |
| return null; |
| } |
| |
| Object[] aElements = null; |
| String[] aExtensions; |
| try |
| { |
| aElements = (Object[]) aNameAccess.getByName(_sFilterName); |
| if (aElements != null) |
| { |
| String sInternalFilterName = null; |
| // System.out.println("getByName().length: " + String.valueOf(aElements.length)); |
| for (int i=0;i<aElements.length; i++) |
| { |
| PropertyValue aPropertyValue = (PropertyValue)aElements[i]; |
| // System.out.println("PropertyValue.Name: " + aPropertyValue.Name); |
| if (aPropertyValue.Name.equals("Type")) |
| { |
| String sValue = (String)aPropertyValue.Value; |
| // System.out.println("Type: " + sValue); |
| sInternalFilterName = sValue; |
| } |
| } |
| return sInternalFilterName; |
| } |
| else |
| { |
| GlobalLogWriter.println("There are no elements for FilterName '" + _sFilterName + "'"); |
| return null; |
| } |
| } |
| catch (com.sun.star.container.NoSuchElementException e) |
| { |
| GlobalLogWriter.println("NoSuchElementException caught. " + e.getMessage()); |
| } |
| catch (com.sun.star.lang.WrappedTargetException e) |
| { |
| GlobalLogWriter.println("WrappedTargetException caught. " + e.getMessage()); |
| } |
| } |
| } |
| return null; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| String getServiceNameFromFilterName(String _sFilterName, XMultiServiceFactory _xMSF) |
| { |
| if (_sFilterName.length() == 0) |
| { |
| // System.out.println("No FilterName set."); |
| return null; |
| } |
| |
| if (_xMSF == null) |
| { |
| GlobalLogWriter.println("MultiServiceFactory not set."); |
| return null; |
| } |
| // XFilterFactory aFilterFactory = null; |
| Object aObj = null; |
| try |
| { |
| aObj = _xMSF.createInstance("com.sun.star.document.FilterFactory"); |
| } |
| catch(com.sun.star.uno.Exception e) |
| { |
| GlobalLogWriter.println("Can't get com.sun.star.document.FilterFactory."); |
| return null; |
| } |
| if (aObj != null) |
| { |
| XNameAccess aNameAccess = UnoRuntime.queryInterface(XNameAccess.class, aObj); |
| if (aNameAccess != null) |
| { |
| if (! aNameAccess.hasByName(_sFilterName)) |
| { |
| GlobalLogWriter.println("FilterFactory.hasByName() says there exist no '" + _sFilterName + "'" ); |
| return null; |
| } |
| |
| Object[] aElements = null; |
| String[] aExtensions; |
| try |
| { |
| aElements = (Object[]) aNameAccess.getByName(_sFilterName); |
| if (aElements != null) |
| { |
| String sServiceName = null; |
| // System.out.println("getByName().length: " + String.valueOf(aElements.length)); |
| for (int i=0;i<aElements.length; i++) |
| { |
| PropertyValue aPropertyValue = (PropertyValue)aElements[i]; |
| if (aPropertyValue.Name.equals("DocumentService")) |
| { |
| String sValue = (String)aPropertyValue.Value; |
| // System.out.println("DocumentService: " + sValue); |
| sServiceName = sValue; |
| break; |
| } |
| } |
| return sServiceName; |
| } |
| else |
| { |
| GlobalLogWriter.println("There are no elements for FilterName '" + _sFilterName + "'"); |
| return null; |
| } |
| } |
| catch (com.sun.star.container.NoSuchElementException e) |
| { |
| GlobalLogWriter.println("NoSuchElementException caught. " + e.getMessage()); |
| } |
| catch (com.sun.star.lang.WrappedTargetException e) |
| { |
| GlobalLogWriter.println("WrappedTargetException caught. " + e.getMessage()); |
| } |
| } |
| } |
| return null; |
| } |
| // ----------------------------------------------------------------------------- |
| |
| public static String getFileExtension(String _sInternalFilterName, XMultiServiceFactory _xMSF) |
| { |
| if (_sInternalFilterName.length() == 0) |
| { |
| // System.out.println("No FilterName set."); |
| return null; |
| } |
| |
| if (_xMSF == null) |
| { |
| GlobalLogWriter.println("MultiServiceFactory not set."); |
| return null; |
| } |
| XTypeDetection aTypeDetection = null; |
| try |
| { |
| Object oObj = _xMSF.createInstance("com.sun.star.document.TypeDetection"); |
| aTypeDetection = UnoRuntime.queryInterface(XTypeDetection.class, oObj); |
| } |
| catch(com.sun.star.uno.Exception e) |
| { |
| GlobalLogWriter.println("Can't get com.sun.star.document.TypeDetection."); |
| return null; |
| } |
| if (aTypeDetection != null) |
| { |
| XNameAccess aNameAccess = UnoRuntime.queryInterface(XNameAccess.class, aTypeDetection); |
| if (aNameAccess != null) |
| { |
| |
| // System.out.println("Show ElementNames" ); |
| // String[] aElementNames = aNameAccess.getElementNames(); |
| // for (int i = 0; i<aElementNames.length; i++) |
| // { |
| // System.out.println(aElementNames[i]); |
| // } |
| |
| if (! aNameAccess.hasByName(_sInternalFilterName)) |
| { |
| GlobalLogWriter.println("TypeDetection.hasByName() says there exist no '" + _sInternalFilterName + "'" ); |
| return null; |
| } |
| |
| Object[] aElements = null; |
| String[] aExtensions; |
| try |
| { |
| aElements = (Object[]) aNameAccess.getByName(_sInternalFilterName); |
| if (aElements != null) |
| { |
| String sExtension = null; |
| // System.out.println("getByName().length: " + String.valueOf(aElements.length)); |
| for (int i=0;i<aElements.length; i++) |
| { |
| PropertyValue aPropertyValue = (PropertyValue)aElements[i]; |
| // System.out.println("PropertyValue.Name: " + aPropertyValue.Name); |
| if (aPropertyValue.Name.equals("Extensions")) |
| { |
| aExtensions = (String[])aPropertyValue.Value; |
| GlobalLogWriter.println(" Possible extensions are: " + String.valueOf(aExtensions.length)); |
| if (aExtensions.length > 0) |
| { |
| for (int j=0;j<aExtensions.length;j++) |
| { |
| GlobalLogWriter.println(" " + aExtensions[j]); |
| } |
| sExtension = aExtensions[0]; |
| GlobalLogWriter.println(""); |
| } |
| } |
| } |
| return sExtension; |
| } |
| else |
| { |
| GlobalLogWriter.println("There are no elements for FilterName '" + _sInternalFilterName + "'"); |
| return null; |
| } |
| } |
| catch (com.sun.star.container.NoSuchElementException e) |
| { |
| GlobalLogWriter.println("NoSuchElementException caught. " + e.getMessage()); |
| } |
| catch (com.sun.star.lang.WrappedTargetException e) |
| { |
| GlobalLogWriter.println("WrappedTargetException caught. " + e.getMessage()); |
| } |
| } |
| } |
| return null; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| public void convertDocument(String _sInputFile, String _sOutputPath, ParameterHelper _aGTA) throws OfficeException |
| { |
| XMultiServiceFactory xMSF = _aGTA.getMultiServiceFactory(); |
| if (xMSF == null) |
| { |
| GlobalLogWriter.println("MultiServiceFactory in GraphicalTestArgument not set."); |
| return; |
| } |
| |
| String sInputURL = URLHelper.getFileURLFromSystemPath(_sInputFile); |
| // showType(sInputURL, xMSF); |
| XComponent aDoc = loadFromURL( _aGTA, sInputURL); |
| if (aDoc == null) |
| { |
| GlobalLogWriter.println("Can't load document '"+ sInputURL + "'"); |
| return; |
| } |
| |
| if (_sOutputPath == null) |
| { |
| GlobalLogWriter.println("Outputpath not set."); |
| return; |
| } |
| |
| if (! isStoreAllowed()) |
| { |
| GlobalLogWriter.println("It's not allowed to store, check Input/Output path."); |
| return; |
| } |
| // TODO: Do we need to wait? |
| // TimeHelper.waitInSeconds(1, "wait after loadFromURL."); |
| |
| XServiceInfo xServiceInfo = UnoRuntime.queryInterface( XServiceInfo.class, aDoc ); |
| // String sFilter = getFilterName_forExcel(xServiceInfo); |
| // System.out.println("Filter is " + sFilter); |
| |
| // store the document in an other directory |
| XStorable xStorable = UnoRuntime.queryInterface( XStorable.class, aDoc); |
| if (xStorable == null) |
| { |
| GlobalLogWriter.println("com.sun.star.frame.XStorable is null"); |
| return; |
| } |
| |
| String sFilterName = _aGTA.getExportFilterName(); |
| |
| // check how many Properties should initialize |
| int nPropertyCount = 0; |
| // if (sFilterName != null && sFilterName.length() > 0) |
| // { |
| // nPropertyCount ++; |
| // } |
| |
| // initialize PropertyArray |
| // PropertyValue [] aStoreProps = new PropertyValue[ nPropertyCount ]; |
| // int nPropertyIndex = 0; |
| ArrayList<PropertyValue> aPropertyList = new ArrayList<PropertyValue>(); |
| |
| String sExtension = ""; |
| |
| if (sFilterName != null && sFilterName.length() > 0) |
| { |
| String sInternalFilterName = getInternalFilterName(sFilterName, xMSF); |
| String sServiceName = getServiceNameFromFilterName(sFilterName, xMSF); |
| |
| GlobalLogWriter.println("Filter detection:"); |
| // check if service name from file filter is the same as from the loaded document |
| boolean bServiceFailed = false; |
| if (sServiceName == null || sInternalFilterName == null) |
| { |
| GlobalLogWriter.println("Given FilterName '" + sFilterName + "' seems to be unknown."); |
| bServiceFailed = true; |
| } |
| if (! xServiceInfo.supportsService(sServiceName)) |
| { |
| GlobalLogWriter.println("Service from FilterName '" + sServiceName + "' is not supported by loaded document."); |
| bServiceFailed = true; |
| } |
| if (bServiceFailed == true) |
| { |
| GlobalLogWriter.println("Please check '" + PropertyName.DOC_CONVERTER_EXPORT_FILTER_NAME + "' in the property file."); |
| return; |
| } |
| |
| if (sInternalFilterName != null && sInternalFilterName.length() > 0) |
| { |
| // get the FileExtension, by the filter name, if we don't get a file extension |
| // we assume the is also no right filter name. |
| sExtension = getFileExtension(sInternalFilterName, xMSF); |
| if (sExtension == null) |
| { |
| GlobalLogWriter.println("Can't found an extension for filtername, take it from the source."); |
| } |
| } |
| |
| PropertyValue Arg = new PropertyValue(); |
| Arg.Name = "FilterName"; |
| Arg.Value = sFilterName; |
| // aStoreProps[nPropertyIndex ++] = Arg; |
| aPropertyList.add(Arg); |
| showProperty(Arg); |
| GlobalLogWriter.println("FilterName is set to: " + sFilterName); |
| } |
| |
| String sOutputURL = ""; |
| try |
| { |
| // create the new filename with the extension, which is ok to the file format |
| String sInputFileBasename = FileHelper.getBasename(_sInputFile); |
| // System.out.println("InputFileBasename " + sInputFileBasename); |
| String sInputFileNameNoSuffix = FileHelper.getNameNoSuffix(sInputFileBasename); |
| // System.out.println("InputFilename no suffix " + sInputFileNameNoSuffix); |
| String fs = System.getProperty("file.separator"); |
| String sOutputFile = _sOutputPath; |
| if (! sOutputFile.endsWith(fs)) |
| { |
| sOutputFile += fs; |
| } |
| if (sExtension != null && sExtension.length() > 0) |
| { |
| sOutputFile += sInputFileNameNoSuffix + "." + sExtension; |
| } |
| else |
| { |
| sOutputFile += sInputFileBasename; |
| } |
| |
| if (FileHelper.exists(sOutputFile) && _aGTA.getOverwrite() == false) |
| { |
| GlobalLogWriter.println("File already exist, don't overwrite. Set " + PropertyName.DOC_COMPARATOR_OVERWRITE_REFERENCE + "=true to force overwrite."); |
| return; |
| } |
| |
| sOutputURL = URLHelper.getFileURLFromSystemPath(sOutputFile); |
| |
| GlobalLogWriter.println("Store document as '" + sOutputURL + "'"); |
| xStorable.storeAsURL(sOutputURL, PropertyHelper.createPropertyValueArrayFormArrayList(aPropertyList)); |
| GlobalLogWriter.println("Document stored."); |
| } |
| catch (com.sun.star.io.IOException e) |
| { |
| GlobalLogWriter.println("Can't store document '" + sOutputURL + "'. Message is :'" + e.getMessage() + "'"); |
| } |
| // TODO: Do we need to wait? |
| // TimeHelper.waitInSeconds(1, "unknown in OfficePrint.convertDocument()"); |
| |
| } |
| |
| /** |
| * |
| * @return false, if 'NoOffice=yes' is given |
| */ |
| // private boolean shouldOfficeStart() |
| // { |
| // String sNoOffice = (String)m_aParameterHelper.getTestParameters().get( "NoOffice" ); |
| // if (sNoOffice != null) |
| // { |
| // if (sNoOffice.toLowerCase().startsWith("t") || sNoOffice.toLowerCase().startsWith("y")) |
| // { |
| // return false; |
| // } |
| // } |
| // return true; |
| // } |
| |
| OfficeProvider m_aProvider = null; |
| private void startOffice() |
| { |
| // SimpleFileSemaphore aSemaphore = new SimpleFileSemaphore(); |
| // if (shouldOfficeStart()) |
| // { |
| // if (OSHelper.isWindows()) |
| // { |
| // aSemaphore.P(aSemaphore.getSemaphoreFile()); |
| // } |
| m_aParameterHelper.getTestParameters().put(util.PropertyName.DONT_BACKUP_USERLAYER, Boolean.TRUE); |
| |
| m_aParameterHelper.getPerformance().startTime(PerformanceContainer.OfficeStart); |
| m_aProvider = new OfficeProvider(); |
| XMultiServiceFactory xMSF = (XMultiServiceFactory) m_aProvider.getManager(m_aParameterHelper.getTestParameters()); |
| m_aParameterHelper.getTestParameters().put("ServiceFactory", xMSF); |
| m_aParameterHelper.getPerformance().stopTime(PerformanceContainer.OfficeStart); |
| |
| long nStartTime = m_aParameterHelper.getPerformance().getTime(PerformanceContainer.OfficeStart); |
| // aGTA = getParameterHelper(); // get new TestArguments |
| m_aParameterHelper.getPerformance().setTime(PerformanceContainer.OfficeStart, nStartTime); |
| // } |
| |
| // Watcher Object is need in log object to give a simple way to say if a running office is alive. |
| // As long as a log comes, it pings the Watcher and says the office is alive, if not an |
| // internal counter increase and at a given point (300 seconds) the office is killed. |
| if (GlobalLogWriter.get().getWatcher() == null) |
| { |
| GlobalLogWriter.println("Set office watcher"); |
| OfficeWatcher aWatcher = (OfficeWatcher)m_aParameterHelper.getTestParameters().get("Watcher"); |
| GlobalLogWriter.get().setWatcher(aWatcher); |
| } |
| } |
| |
| private void stopOffice() |
| { |
| // Office shutdown |
| if (m_aProvider != null) |
| { |
| String sAppExecCmd = (String)m_aParameterHelper.getTestParameters().get("AppExecutionCommand"); |
| if (sAppExecCmd != null && sAppExecCmd.length() > 0) |
| { |
| m_aProvider.closeExistingOffice(m_aParameterHelper.getTestParameters(), true); |
| } |
| // if (OSHelper.isWindows()) |
| // { |
| // aSemaphore.V(aSemaphore.getSemaphoreFile()); |
| // aSemaphore.sleep(2); |
| // // wait some time maybe an other process will take the semaphore |
| // // I know, this is absolutly dirty, but the whole convwatch is dirty and need a big cleanup. |
| // } |
| } |
| } |
| |
| private boolean m_bStoreFile; |
| public void disallowStore() |
| { |
| m_bStoreFile = false; |
| } |
| public void allowStore() |
| { |
| m_bStoreFile = true; |
| } |
| public boolean isStoreAllowed() |
| { |
| return false; |
| // return m_bStoreFile; |
| } |
| |
| } |
| |
