oox/source/ole/axbinarywriter.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9 #include "oox/ole/axbinarywriter.hxx"
  10
  11 #include "oox/ole/olehelper.hxx"
  12
  13 namespace oox {
  14 namespace ole {
  15
  16 // ============================================================================
  17
  18 namespace {
  19
  20 const sal_uInt32 AX_STRING_COMPRESSED       = 0x80000000;
  21
  22 } // namespace
  23
  24 // ============================================================================
  25
  26 AxAlignedOutputStream::AxAlignedOutputStream( BinaryOutputStream& rOutStrm ) :
  27     BinaryStreamBase( false ),
  28     mpOutStrm( &rOutStrm ),
  29     mnStrmPos( 0 ),
  30     mnStrmSize( rOutStrm.getRemaining() ),
  31     mnWrappedBeginPos( rOutStrm.tell() )
  32 {
  33     mbEof = mbEof || rOutStrm.isEof();
  34 }
  35
  36 sal_Int64 AxAlignedOutputStream::size() const
  37 {
  38     return mpOutStrm ? mnStrmSize : -1;
  39 }
  40
  41 sal_Int64 AxAlignedOutputStream::tell() const
  42 {
  43     return mpOutStrm ? mnStrmPos : -1;
  44 }
  45
  46 void AxAlignedOutputStream::seek( sal_Int64 nPos )
  47 {
  48     mbEof = (nPos < 0);
  49     if( !mbEof )
  50     {
  51         mpOutStrm->seek( static_cast< sal_Int32 >( mnWrappedBeginPos + nPos  ) );
  52         mnStrmPos = mpOutStrm->tell() - mnWrappedBeginPos;
  53     }
  54 }
  55
  56 void AxAlignedOutputStream::close()
  57 {
  58     mpOutStrm = 0;
  59     mbEof = true;
  60 }
  61
  62 void AxAlignedOutputStream::writeData( const StreamDataSequence& orData, size_t nAtomSize )
  63 {
  64     mpOutStrm->writeData( orData, nAtomSize );
  65     mnStrmPos = mpOutStrm->tell() - mnWrappedBeginPos;
  66 }
  67
  68 void AxAlignedOutputStream::writeMemory( const void* opMem, sal_Int32 nBytes, size_t nAtomSize )
  69 {
  70     mpOutStrm->writeMemory( opMem, nBytes, nAtomSize );
  71     mnStrmPos = mpOutStrm->tell() - mnWrappedBeginPos;
  72 }
  73
  74 void AxAlignedOutputStream::pad( sal_Int32 nBytes, size_t nAtomSize )
  75 {
  76    //PRESUMABELY we need to pad with 0's here as appropriate
  77    com::sun::star::uno::Sequence< sal_Int8 > aData( nBytes );
  78    // ok we could be padding with rubbish here, but really that shouldn't matter
  79    // set to 0(s), easier to not get fooled by 0's when looking at
  80    // binary content......
  81    memset( static_cast<void*>( aData.getArray() ), 0, nBytes );
  82    mpOutStrm->writeData( aData, nAtomSize );
  83    mnStrmPos = mpOutStrm->tell() - mnWrappedBeginPos;
  84 }
  85
  86 void AxAlignedOutputStream::align( size_t nSize )
  87 {
  88     pad( static_cast< sal_Int32 >( (nSize - (mnStrmPos % nSize)) % nSize ) );
  89 }
  90
  91 // ============================================================================
  92
  93 namespace {
  94
  95 void lclWriteString( AxAlignedOutputStream& rOutStrm, OUString& rValue, sal_uInt32 nSize, bool bArrayString )
  96 {
  97     bool bCompressed = getFlag( nSize, AX_STRING_COMPRESSED );
  98     rOutStrm.writeCompressedUnicodeArray( rValue, bCompressed || bArrayString );
  99 }
 100
 101 } // namespace
 102
 103 // ----------------------------------------------------------------------------
 104
 105 AxBinaryPropertyWriter::ComplexProperty::~ComplexProperty()
 106 {
 107 }
 108
 109 bool AxBinaryPropertyWriter::PairProperty::writeProperty( AxAlignedOutputStream& rOutStrm )
 110 {
 111     rOutStrm << mrPairData.first << mrPairData.second;
 112     return true;
 113 }
 114
 115 bool AxBinaryPropertyWriter::StringProperty::writeProperty( AxAlignedOutputStream& rOutStrm )
 116 {
 117     lclWriteString( rOutStrm, mrValue, mnSize, false );
 118     return true;
 119 }
 120
 121 // ----------------------------------------------------------------------------
 122
 123 AxBinaryPropertyWriter::AxBinaryPropertyWriter( BinaryOutputStream& rOutStrm, bool b64BitPropFlags ) :
 124     maOutStrm( rOutStrm ),
 125     mnPropFlags( 0x0 ),
 126     mbValid( true ),
 127     mb64BitPropFlags( b64BitPropFlags )
 128 {
 129     sal_uInt16 nId( 0x0200 );
 130     maOutStrm << nId;
 131     mnBlockSize = 0; // will be filled in the finalize method
 132
 133     maOutStrm << nId;
 134     mnPropFlagsStart = maOutStrm.tell();
 135
 136     if( mb64BitPropFlags )
 137         maOutStrm << mnPropFlags;
 138     else
 139         maOutStrm << sal_uInt32( mnPropFlags );
 140     mnNextProp = 1;
 141 }
 142
 143 void AxBinaryPropertyWriter::writeBoolProperty( bool orbValue, bool bReverse )
 144 {
 145     // orbValue ^ bReverse true then we want to set the bit, e.g. don't skip
 146     startNextProperty(  !( ( orbValue ^ bReverse ) >= 1 ) );
 147 }
 148
 149 void AxBinaryPropertyWriter::writePairProperty( AxPairData& orPairData )
 150 {
 151     if( startNextProperty() )
 152         maLargeProps.push_back( ComplexPropVector::value_type( new PairProperty( orPairData ) ) );
 153 }
 154
 155 void AxBinaryPropertyWriter::writeStringProperty( OUString& orValue, bool bCompressed )
 156 {
 157     sal_uInt32 nSize = orValue.getLength();
 158     if ( bCompressed )
 159         setFlag(  nSize, AX_STRING_COMPRESSED );
 160     else
 161         nSize *= 2;
 162     maOutStrm.writeAligned< sal_uInt32 >( nSize );
 163     maLargeProps.push_back( ComplexPropVector::value_type( new StringProperty( orValue, nSize ) ) );
 164     startNextProperty();
 165 }
 166
 167 bool AxBinaryPropertyWriter::finalizeExport()
 168 {
 169     // write large properties
 170     maOutStrm.align( 4 );
 171     if( !maLargeProps.empty() )
 172     {
 173         for( ComplexPropVector::iterator aIt = maLargeProps.begin(), aEnd = maLargeProps.end(); ensureValid() && (aIt != aEnd); ++aIt )
 174         {
 175             (*aIt)->writeProperty( maOutStrm );
 176             maOutStrm.align( 4 );
 177         }
 178     }
 179
 180     mnBlockSize = maOutStrm.tell() - mnPropFlagsStart;
 181
 182     // write stream properties (no stream alignment between properties!)
 183     if( !maStreamProps.empty() )
 184         for( ComplexPropVector::iterator aIt = maStreamProps.begin(), aEnd = maStreamProps.end(); ensureValid() && (aIt != aEnd); ++aIt )
 185            (*aIt)->writeProperty( maOutStrm );
 186
 187     sal_Int64 nPos = maOutStrm.tell();
 188     maOutStrm.seek( mnPropFlagsStart - sizeof( mnBlockSize ) );
 189
 190     maOutStrm << mnBlockSize;
 191
 192     if( mb64BitPropFlags )
 193         maOutStrm << mnPropFlags;
 194     else
 195         maOutStrm << sal_uInt32( mnPropFlags );
 196
 197     maOutStrm.seek( nPos );
 198     return true;
 199 }
 200
 201 bool AxBinaryPropertyWriter::ensureValid( bool bCondition )
 202 {
 203     mbValid = mbValid && bCondition && !maOutStrm.isEof();
 204     return mbValid;
 205 }
 206
 207 bool AxBinaryPropertyWriter::startNextProperty( bool bSkip )
 208 {
 209     // if we are skipping then we clear the flag
 210     setFlag( mnPropFlags, mnNextProp, !bSkip );
 211     mnNextProp <<= 1;
 212     return true;
 213 }
 214
 215 // ============================================================================
 216
 217 } // namespace exp
 218 } // namespace ole
 219
 220 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */