Commits

hjs  committed caac4de

CWS-TOOLING: integrate CWS dba31j_DEV300
2009-03-11 12:24:24 +0100 iha r269311 : #i100102# report donut charts crash on load
2009-03-11 10:44:35 +0100 oj r269302 : #i100102# export meta.xml
2009-03-11 07:35:03 +0100 oj r269296 : #i99686# not used anymore
2009-03-11 07:34:27 +0100 oj r269295 : #i99686# not used anymore
2009-03-11 07:33:57 +0100 oj r269294 : #i99686# change storage usage
2009-03-10 15:21:41 +0100 mav r269275 : #i99686# test additional scenario
2009-03-10 08:37:10 +0100 mav r269239 : #i100040# calculate the name length correctly
2009-03-10 08:25:16 +0100 mav r269236 : #i99686# workaround to prevent crash while disposing the hierarchical stream
2009-03-10 07:14:05 +0100 oj r269235 : #i99686# fix usage of storage api
2009-03-10 07:13:17 +0100 oj r269234 : #i99686# fix usage of storage api
2009-03-09 13:33:26 +0100 fs r269085 : #i100012#
2009-03-09 13:11:08 +0100 fs r269081 : #i100036# don't store sub documents which have not been touched
2009-03-09 11:21:17 +0100 fs r269070 : #i100040# don't silence errors in impl_storeToStorage_throw
2009-03-09 10:28:48 +0100 oj r269065 : #i100036# throw exception when no activeConnection exists

  • Participants
  • Parent commits 4563076

Comments (0)

Files changed (16)

File dbaccess/source/core/dataaccess/databasedocument.cxx

         writeStorage( _rxTargetStorage, aWriteArgs );
 
         // commit target storage
-        OSL_VERIFY( m_pImpl->commitStorageIfWriteable_ignoreErrors( _rxTargetStorage ) );
+        OSL_VERIFY( m_pImpl->commitStorageIfWriteable( _rxTargetStorage ) );
 	}
     catch( const IOException& ) { throw; }
     catch( const RuntimeException& ) { throw; }

File dbaccess/source/ext/macromigration/migrationengine.cxx

         // -----------------
         // clean up
         // store the sub document, including removal of the (now obsolete) "Scripts" sub folder
-        bSuccess =  bSuccess
-                &&  ScriptsStorage::removeFromDocument( aSubDocument.xDocument, m_rLogger )
-                &&  lcl_commitDocumentStorage_nothrow( aSubDocument.xDocument, m_rLogger )
-                &&  lcl_storeEmbeddedDocument_nothrow( aSubDocument );
+        if ( m_rLogger.movedAnyLibrary( m_nCurrentDocumentID ) )
+        {
+            bSuccess =  bSuccess
+                    &&  ScriptsStorage::removeFromDocument( aSubDocument.xDocument, m_rLogger )
+                    &&  lcl_commitDocumentStorage_nothrow( aSubDocument.xDocument, m_rLogger )
+                    &&  lcl_storeEmbeddedDocument_nothrow( aSubDocument );
+        }
 
         // unload in any case, even if we were not successful
         bSuccess =  lcl_unloadSubDocument_nothrow( aSubDocument, m_rLogger )

File dbaccess/source/ext/macromigration/migrationlog.cxx

     }
 
 	//--------------------------------------------------------------------
+    bool MigrationLog::movedAnyLibrary( const DocumentID _nDocID )
+    {
+        DocumentLogs::const_iterator docPos = m_pData->aDocumentLogs.find( _nDocID );
+        if ( docPos == m_pData->aDocumentLogs.end() )
+        {
+            OSL_ENSURE( false, "MigrationLog::movedAnyLibrary: document is not known!" );
+            return false;
+        }
+        return !docPos->second.aMovedLibraries.empty();
+    }
+
+	//--------------------------------------------------------------------
     ::rtl::OUString MigrationLog::getCompleteLog() const
     {
         ::rtl::OUStringBuffer aBuffer;

File dbaccess/source/ext/macromigration/migrationlog.hxx

                         const ::rtl::OUString& _rOriginalLibName
                     ) const;
 
+        /** determines whether for the given document, any library needed to be (and was) moved
+        */
+        bool    movedAnyLibrary( const DocumentID );
+
         /** provides a human-readable version of the log, explaining a user what happened during
             the migration.
         */

File package/qa/storages/StorageUnitTest.java

 								"ExecuteTest14",
 								"ExecuteTest15",
 								"ExecuteTest16",
+								"ExecuteTest17",
 								"ExecuteRegressionTest_114358",
 								"ExecuteRegressionTest_i29169",
 								"ExecuteRegressionTest_i30400",
 		assure( "Test16 failed!", aTest.test() );
 	}
 
+	public void ExecuteTest17()
+	{
+		StorageTest aTest = new Test17( m_xMSF, m_xStorageFactory, log );
+		assure( "Test17 failed!", aTest.test() );
+	}
+
 
 	public void ExecuteRegressionTest_114358()
 	{

File package/qa/storages/Test17.java

+package complex.storages;
+
+import com.sun.star.uno.XInterface;
+import com.sun.star.lang.XMultiServiceFactory;
+import com.sun.star.lang.XSingleServiceFactory;
+
+import com.sun.star.bridge.XUnoUrlResolver;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XInterface;
+import com.sun.star.io.XStream;
+import com.sun.star.io.XInputStream;
+
+import com.sun.star.embed.*;
+
+import share.LogWriter;
+import complex.storages.TestHelper;
+import complex.storages.StorageTest;
+
+public class Test17 implements StorageTest {
+
+	XMultiServiceFactory m_xMSF;
+	XSingleServiceFactory m_xStorageFactory;
+	TestHelper m_aTestHelper;
+
+	public Test17( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter )
+	{
+		m_xMSF = xMSF;
+		m_xStorageFactory = xStorageFactory;
+		m_aTestHelper = new TestHelper( aLogWriter, "Test17: " );
+	}
+
+    public boolean test()
+	{
+		try
+		{
+			XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF );
+			if ( xTempFileStream == null )
+				return false;
+		
+			// create storage based on the temporary stream
+			Object pArgs[] = new Object[2];
+			pArgs[0] = (Object) xTempFileStream;
+			pArgs[1] = new Integer( ElementModes.WRITE );
+
+			Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
+			XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
+			if ( xTempStorage == null )
+			{
+				m_aTestHelper.Error( "Can't create temporary storage representation!" );
+				return false;
+			}
+
+		
+			byte pBytes1[] = { 1, 1, 1, 1, 1 };
+            String pNames[] = { "SubStream1", "SubStream2", "SubStream3", "SubStream4", "SubStream5", "SubStream6", "SubStream7" };
+
+            for ( int nInd = 0; nInd < pNames.length; nInd++ )
+            {
+			    // open a new substorage
+			    XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage,
+																	    "SubStorage1",
+																	    ElementModes.WRITE );
+			    if ( xTempSubStorage == null )
+			    {
+				    m_aTestHelper.Error( "Can't create substorage!" );
+				    return false;
+			    }
+	
+			    // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
+			    if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, pNames[nInd], "MediaType1", true, pBytes1 ) )
+				    return false;
+
+                // commit substorage first
+                if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
+                    return false;
+
+                // dispose used storage to free resources
+                if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
+                    return false;
+            }
+
+			// commit the root storage so the contents must be stored now
+			if ( !m_aTestHelper.commitStorage( xTempStorage ) )
+				return false;
+
+			// dispose used storage to free resources
+			if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
+				return false;
+
+
+			// ================================================
+			// now check all the written information
+			// ================================================
+
+			// close the output part of the temporary stream
+			// the output part must present since we already wrote to the stream
+			if ( !m_aTestHelper.closeOutput( xTempFileStream ) )
+				return false;
+
+			XInputStream xTempInStream = m_aTestHelper.getInputStream( xTempFileStream );
+			if ( xTempInStream == null )
+				return false;
+
+		
+			// open input stream
+			// since no mode is provided the result storage must be opened readonly
+			Object pOneArg[] = new Object[1];
+			pOneArg[0] = (Object) xTempInStream;
+
+			Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pOneArg );
+			XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage );
+			if ( xResultStorage == null )
+			{
+				m_aTestHelper.Error( "Can't open storage based on input stream!" );
+				return false;
+			}
+
+			// open existing substorage
+			XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage,
+																		"SubStorage1",
+																		ElementModes.READ );
+			if ( xResultSubStorage == null )
+			{
+				m_aTestHelper.Error( "Can't open existing substorage!" );
+				return false;
+			}
+	
+            for ( int nInd = 0; nInd < pNames.length; nInd++ )
+			    if ( !m_aTestHelper.checkStream( xResultSubStorage, pNames[nInd], "MediaType1", true, pBytes1 ) )
+				    return false;
+
+			return true;
+		}
+		catch( Exception e )
+		{
+			m_aTestHelper.Error( "Exception: " + e );
+			return false;
+		}
+    } 
+
+}
+

File package/qa/storages/makefile.mk

 				Test14.java\
 				Test15.java\
 				Test16.java\
+				Test17.java\
 				RegressionTest_114358.java\
 				RegressionTest_i29169.java\
 				RegressionTest_i30400.java\

File package/source/xstor/owriteablestream.cxx

 		throw ( uno::RuntimeException )
 {
 	// should be an internal method since it can be called only from parent storage
-
-	::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
-
-	if ( !m_pImpl )
-		throw lang::DisposedException();
-
-	if ( m_xOutStream.is() )
-		CloseOutput_Impl();
-
-	if ( m_xInStream.is() )
-	{
-		m_xInStream->closeInput();
-		m_xInStream = uno::Reference< io::XInputStream >();
-	}
+    {
+        ::osl::MutexGuard aGuard( m_pData->m_rSharedMutexRef->GetMutex() );
+
+        if ( !m_pImpl )
+            throw lang::DisposedException();
+
+        if ( m_xOutStream.is() )
+            CloseOutput_Impl();
+
+        if ( m_xInStream.is() )
+        {
+            m_xInStream->closeInput();
+            m_xInStream = uno::Reference< io::XInputStream >();
+        }
+
+        m_pImpl->m_pAntiImpl = NULL;
+
+        if ( !m_bInitOnDemand )
+        {
+            try
+            {
+                if ( !m_bTransacted )
+                {
+                    m_pImpl->Commit();
+                }
+                else
+                {
+                    // throw away all the changes
+                    m_pImpl->Revert();
+                }
+            }
+            catch( uno::Exception& )
+            {
+                uno::Any aCaught( ::cppu::getCaughtException() );
+                throw lang::WrappedTargetRuntimeException(
+                                                ::rtl::OUString::createFromAscii( "Can not commit/revert the storage!\n" ),
+                                                uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
+                                                                                    uno::UNO_QUERY ),
+                                                aCaught );
+            }
+        }
+
+        m_pImpl = NULL;
+    }
+
+    // the listener might try to get rid of parent storage, and the storage would delete this object;
+    // for now the listener is just notified at the end of the method to workaround the problem
+    // in future a more elegant way should be found
 
    	lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
 	m_pData->m_aListenersContainer.disposeAndClear( aSource );
-
-	m_pImpl->m_pAntiImpl = NULL;
-
-	if ( !m_bInitOnDemand )
-	{
-		try
-		{
-			if ( !m_bTransacted )
-			{
-				m_pImpl->Commit();
-			}
-			else
-			{
-				// throw away all the changes
-				m_pImpl->Revert();
-			}
-		}
-		catch( uno::Exception& )
-		{
-   			uno::Any aCaught( ::cppu::getCaughtException() );
-			throw lang::WrappedTargetRuntimeException(
-											::rtl::OUString::createFromAscii( "Can not commit/revert the storage!\n" ),
-											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
-																				uno::UNO_QUERY ),
-											aCaught );
-		}
-	}
-
-	m_pImpl = NULL;
 }
 
 //-----------------------------------------------

File package/source/zippackage/ZipPackageFolder.cxx

 		// it is an empty subfolder, use workaround to store it
 		ZipEntry* pTempEntry = new ZipEntry();
 		ZipPackageFolder::copyZipEntry ( *pTempEntry, aEntry );
-		pTempEntry->nNameLen = (sal_Int16)rPath.getLength();
+		pTempEntry->nNameLen = (sal_Int16)( ::rtl::OUStringToOString( rPath, RTL_TEXTENCODING_UTF8 ).getLength() );
 		pTempEntry->nExtraLen = -1;
 		pTempEntry->sName = rPath;
 
 
 			ZipPackageFolder::copyZipEntry ( *pTempEntry, pStream->aEntry );
 			pTempEntry->sName = rPath + rShortName;
-			pTempEntry->nNameLen = (sal_Int16)( pTempEntry->sName.getLength() );
+			pTempEntry->nNameLen = (sal_Int16)( ::rtl::OUStringToOString( pTempEntry->sName, RTL_TEXTENCODING_UTF8 ).getLength() );
 
 			sal_Bool bToBeEncrypted = pStream->IsToBeEncrypted() && (bHaveEncryptionKey || pStream->HasOwnKey());
 			sal_Bool bToBeCompressed = bToBeEncrypted ? sal_True : pStream->IsToBeCompressed();

File reportbuilder/java/com/sun/star/report/StorageRepository.java

     {
         this.input = input;
         this.output = output;
+
     }
 
     public StorageRepository(final XStorage storage, final boolean isOutput)
         }
         try
         {
-            final XStream stream = (XStream) UnoRuntime.queryInterface(XStream.class, output.openStreamElement(name, ElementModes.WRITE | ElementModes.TRUNCATE));
+            final XStream stream = output.openStreamElement(name, ElementModes.WRITE | ElementModes.TRUNCATE);
             stream.getInputStream().closeInput();
             if (mimeType != null)
             {

File reportbuilder/java/com/sun/star/report/pentaho/output/ImageProducer.java

                 final byte b = keyData[i];
                 hashValue = b + hashValue * 23;
             }
-            this.hashCode = new Integer(hashValue);
+            this.hashCode = Integer.valueOf(hashValue);
             return hashValue;
         }
     }
     private final InputRepository inputRepository;
     private final OutputRepository outputRepository;
     private final ImageService imageService;
-    private final DefaultNameGenerator nameGenerator;
 
     public ImageProducer(final InputRepository inputRepository,
             final OutputRepository outputRepository,
         this.outputRepository = outputRepository;
         this.imageService = imageService;
         this.imageCache = new HashMap();
-        this.nameGenerator = new DefaultNameGenerator(outputRepository);
     }
 
     /**
 
             // copy the image into the local output-storage
             // todo: Implement data-fingerprinting so that we can detect the mime-type
-            final String name = nameGenerator.generateName("Pictures/image", mimeType);
-            final OutputStream outputStream = outputRepository.createOutputStream(name, mimeType);
+            final OutputRepository storage = outputRepository.openOutputRepository("Pictures", null);
+            final DefaultNameGenerator nameGenerator = new DefaultNameGenerator(storage);
+            final String name = nameGenerator.generateName("image", mimeType);
+            final OutputStream outputStream = storage.createOutputStream(name, mimeType);
             final ByteArrayInputStream bin = new ByteArrayInputStream(data);
 
             try
             } finally
             {
                 outputStream.close();
+                storage.closeOutputRepository();
             }
 
             final CSSNumericValue widthVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.getWidth() / 100.0);
             final CSSNumericValue heightVal = CSSNumericValue.createValue(CSSNumericType.MM, dims.getHeight() / 100.0);
-            final OfficeImage officeImage = new OfficeImage(name, widthVal, heightVal);
+            final OfficeImage officeImage = new OfficeImage("Pictures/" + name, widthVal, heightVal);
             imageCache.put(imageKey, officeImage);
             return officeImage;
         }
         }
 
         // copy the image into the local output-storage
-        final String name = nameGenerator.generateName("Pictures/image", mimeType);
-        final OutputStream outputStream = outputRepository.createOutputStream(name, mimeType);
+        final OutputRepository storage = outputRepository.openOutputRepository("Pictures", null);
+        final DefaultNameGenerator nameGenerator = new DefaultNameGenerator(storage);
+        final String name = nameGenerator.generateName("image", mimeType);
+        final OutputStream outputStream = storage.createOutputStream(name, mimeType);
         final ByteArrayInputStream bin = new ByteArrayInputStream(data);
 
         try
         } finally
         {
             outputStream.close();
+            storage.closeOutputRepository();
         }
-        return name;
+        return "Pictures/" + name;
     }
 }

File reportbuilder/java/com/sun/star/report/pentaho/output/chart/ChartRawReportTarget.java

 import com.sun.star.report.pentaho.PentahoReportEngineMetaData;
 import com.sun.star.report.pentaho.output.OfficeDocumentReportTarget;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 import org.jfree.layouting.util.AttributeMap;
 import org.jfree.report.DataFlags;
 import org.jfree.report.DataSourceException;
 import org.jfree.report.ReportProcessingException;
 import org.jfree.report.flow.ReportJob;
+import org.jfree.report.flow.ReportStructureRoot;
 import org.jfree.report.flow.ReportTargetUtil;
+import org.pentaho.reporting.libraries.base.util.IOUtils;
 import org.pentaho.reporting.libraries.resourceloader.ResourceKey;
 import org.pentaho.reporting.libraries.resourceloader.ResourceManager;
 import org.pentaho.reporting.libraries.xmlns.common.AttributeList;
         }
         super.processText(text);
     }
+    public void endReport(final ReportStructureRoot report)
+            throws DataSourceException, ReportProcessingException
+    {
+        super.endReport(report);
+        try
+        {
+            // now copy the meta.xml
+            if (getInputRepository().isReadable("meta.xml"))
+            {
+                final InputStream inputStream = getInputRepository().createInputStream("meta.xml");
+                try
+                {
+                    final OutputStream outputMetaStream = getOutputRepository().createOutputStream("meta.xml", "text/xml");
+                    IOUtils.getInstance().copyStreams(inputStream, outputMetaStream);
+                    outputMetaStream.close();
+                } finally
+                {
+                    inputStream.close();
+                }
+            }
+        }
+        catch (IOException ioe)
+        {
+            throw new ReportProcessingException("Failed to write settings document");
+        }
+    }
 }

File reportbuilder/util/description.xml

     xmlns:d="http://openoffice.org/extensions/description/2006" 
     xmlns:xlink="http://www.w3.org/1999/xlink">
   <display-name>
-    <name lang="en-US">Sun Report Builder</name>
+    <name lang="en-US">Sun Report Builder</name>
     <!-- <name lang="en-US">Sun(TM) Report Builder</name> -->
   </display-name>
   <registration>

File reportdesign/source/filter/xml/xmlExportDocumentHandler.cxx

         throw uno::Exception();
 
     m_xDatabaseDataProvider.set(m_xModel->getDataProvider(),uno::UNO_QUERY);
-    if ( !m_xDatabaseDataProvider.is() )
+	if ( !m_xDatabaseDataProvider.is() || !m_xDatabaseDataProvider->getActiveConnection().is() )
         throw uno::Exception();
     
     uno::Reference< reflection::XProxyFactory >	xProxyFactory( m_xContext->getServiceManager()->createInstanceWithContext(

File svtools/source/edit/editsyntaxhighlighter.cxx

 	{
 		for (long aPara =nStartPara; aPara>=0;--aPara)
 		{
+            if ( aStartPos == 0 )
+                continue;
+
 			String aLine( GetTextEngine()->GetText( aPara ) );
-			for (USHORT i = ((unsigned long)aPara==nStartPara) ? aStartPos-1 : (USHORT)(GetTextEngine()->GetTextLen()-1); i>0; --i)
+			for (USHORT i = ((unsigned long)aPara==nStartPara) ? aStartPos-1 : (USHORT)(aLine.Len()-1); i>0; --i)
 			{	
 				if (aLine.GetChar(i)==aChar)
 				{

File xmloff/source/chart/SchXMLTools.cxx

 {
     bool bResult = false;
     ::rtl::OUString aGenerator( lcl_getGeneratorFromModel(xChartModel) );
+    //if there is a meta stream at the chart object it was not written with an older OpenOffice version < 2.3
     if( !aGenerator.getLength() )
     {
-        //if there is no meta stream at the chart object it was not written with a newer OpenOffice version >= 2.3
-
-        //so it is sufficient to check now whether it was written by an OpenOffice version at all
-        //->check the meta information at the parent document
+        //if there is no meta stream at the chart object we need to check the version from the parent document
+        //and we need to check whether the document was created with OpenOffice.org at all
         uno::Reference< container::XChild > xChild( xChartModel, uno::UNO_QUERY );
         if( xChild.is() )
         {
             ::rtl::OUString aParentGenerator( lcl_getGeneratorFromModel( uno::Reference< frame::XModel >( xChild->getParent(), uno::UNO_QUERY) ) );
             if( aParentGenerator.indexOf( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("OpenOffice.org_project") ) ) != -1 )
-                bResult= true;
+            {
+                sal_Int32 nBuilId = lcl_getBuildIDFromGenerator( aParentGenerator );
+                if( nBuilId<=9161 ) //9161 is build id of OpenOffice.org 2.2.1
+                    bResult= true;
+            }
             else if(
                    ( aParentGenerator.indexOf( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("OpenOffice.org 1") ) ) == 0 )
                 || ( aParentGenerator.indexOf( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("StarOffice 6") ) ) == 0 )