include/oox/dump/oledumper.hxx

   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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_OOX_DUMP_OLEDUMPER_HXX
  21 #define INCLUDED_OOX_DUMP_OLEDUMPER_HXX
  22
  23 #include <map>
  24 #include <memory>
  25 #include <vector>
  26
  27 #include <com/sun/star/uno/Reference.hxx>
  28 #include <oox/dump/dumperbase.hxx>
  29 #include <oox/helper/binaryinputstream.hxx>
  30 #include <oox/helper/storagebase.hxx>
  31 #include <rtl/textenc.h>
  32 #include <rtl/ustring.hxx>
  33 #include <sal/types.h>
  34
  35 #if OOX_INCLUDE_DUMPER
  36
  37 namespace com { namespace sun { namespace star {
  38     namespace io { class XInputStream; }
  39 } } }
  40
  41 namespace oox {
  42 namespace dump {
  43
  44
  45 class OleInputObjectBase : public InputObjectBase
  46 {
  47 protected:
  48     OleInputObjectBase() {}
  49
  50     OUString     dumpAnsiString32( const String& rName );
  51     OUString     dumpUniString32( const String& rName );
  52
  53     sal_Int32    dumpStdClipboardFormat( const String& rName );
  54     OUString     dumpAnsiString32OrStdClip( const String& rName );
  55     OUString     dumpUniString32OrStdClip( const String& rName );
  56
  57     void                writeOleColorItem( const String& rName, sal_uInt32 nColor );
  58     sal_uInt32          dumpOleColor( const String& rName );
  59 };
  60
  61
  62 class StdFontObject : public OleInputObjectBase
  63 {
  64 public:
  65     explicit            StdFontObject( const InputObjectBase& rParent );
  66
  67 protected:
  68     virtual void        implDump() override;
  69 };
  70
  71
  72 class StdPicObject : public OleInputObjectBase
  73 {
  74 public:
  75     explicit            StdPicObject( const InputObjectBase& rParent );
  76
  77 protected:
  78     virtual void        implDump() override;
  79 };
  80
  81
  82 class OleStreamObject : public OleInputObjectBase
  83 {
  84 public:
  85     explicit            OleStreamObject( const ObjectBase& rParent, const BinaryInputStreamRef& rxStrm, const OUString& rSysFileName );
  86 };
  87
  88
  89 class OleCompObjObject : public OleStreamObject
  90 {
  91 public:
  92     explicit            OleCompObjObject( const ObjectBase& rParent, const BinaryInputStreamRef& rxStrm, const OUString& rSysFileName );
  93
  94 protected:
  95     virtual void        implDump() override;
  96 };
  97
  98
  99 class OlePropertyStreamObject : public InputObjectBase
 100 {
 101 public:
 102     explicit            OlePropertyStreamObject( const ObjectBase& rParent, const BinaryInputStreamRef& rxStrm, const OUString& rSysFileName );
 103
 104 protected:
 105     virtual void        implDump() override;
 106
 107 private:
 108     void                dumpSection( const OUString& rGuid, sal_uInt32 nStartPos );
 109
 110     void                dumpProperty( sal_Int32 nPropId, sal_uInt32 nStartPos );
 111     void                dumpCodePageProperty( sal_uInt32 nStartPos );
 112     void                dumpDictionaryProperty( sal_uInt32 nStartPos );
 113
 114     sal_uInt16          dumpPropertyContents( sal_Int32 nPropId );
 115     void                dumpPropertyValue( sal_Int32 nPropId, sal_uInt16 nBaseType );
 116     void                dumpPropertyVector( sal_Int32 nPropId, sal_uInt16 nBaseType );
 117
 118     sal_uInt16          dumpPropertyType();
 119     void                dumpBlob( sal_Int32 nPropId, const String& rName );
 120     OUString            dumpString8( const String& rName );
 121     OUString            dumpCharArray8( const String& rName, sal_Int32 nLen );
 122     OUString            dumpString16( const String& rName );
 123     OUString            dumpCharArray16( const String& rName, sal_Int32 nLen );
 124     bool                dumpTypedProperty( const String& rName, sal_uInt16 nExpectedType );
 125     void                dumpHlinks( sal_Int32 nSize );
 126
 127     bool                startElement( sal_uInt32 nStartPos );
 128     void                writeSectionHeader( const OUString& rGuid, sal_uInt32 nStartPos );
 129     void                writePropertyHeader( sal_Int32 nPropId, sal_uInt32 nStartPos );
 130
 131 private:
 132     NameListRef         mxPropIds;
 133     rtl_TextEncoding    meTextEnc;
 134     bool                mbIsUnicode;
 135 };
 136
 137
 138 class OleStorageObject : public StorageObjectBase
 139 {
 140 public:
 141     explicit            OleStorageObject( const ObjectBase& rParent, const StorageRef& rxStrg, const OUString& rSysPath );
 142
 143 protected:
 144     OleStorageObject() {}
 145
 146     using               StorageObjectBase::construct;
 147
 148     virtual void        implDumpStream(
 149                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 150                             const OUString& rStrgPath,
 151                             const OUString& rStrmName,
 152                             const OUString& rSysFileName ) override;
 153 };
 154
 155
 156 class ComCtlObjectBase : public OleInputObjectBase
 157 {
 158 protected:
 159     explicit            ComCtlObjectBase(
 160                             const InputObjectBase& rParent,
 161                             sal_uInt32 nDataId5, sal_uInt32 nDataId6, sal_uInt16 nVersion,
 162                             bool bCommonPart, bool bComplexPart );
 163
 164     virtual void        implDump() override;
 165     virtual void        implDumpProperties() = 0;
 166     virtual void        implDumpCommonExtra( sal_Int64 nEndPos );
 167     virtual void        implDumpCommonTrailing();
 168
 169 private:
 170     bool                dumpComCtlHeader( sal_uInt32 nExpId, sal_uInt16 nExpMajor = SAL_MAX_UINT16, sal_uInt16 nExpMinor = SAL_MAX_UINT16 );
 171     bool                dumpComCtlSize();
 172     bool                dumpComCtlData( sal_uInt32& ornCommonPartSize );
 173     bool                dumpComCtlCommon( sal_uInt32 nPartSize );
 174     bool                dumpComCtlComplex();
 175
 176 protected:
 177     sal_uInt32          mnDataId5;
 178     sal_uInt32          mnDataId6;
 179     sal_uInt16          mnVersion;
 180     bool                mbCommonPart;
 181     bool                mbComplexPart;
 182 };
 183
 184
 185 class ComCtlScrollBarObject : public ComCtlObjectBase
 186 {
 187 public:
 188     explicit            ComCtlScrollBarObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 189
 190 protected:
 191     virtual void        implDumpProperties() override;
 192 };
 193
 194
 195 class ComCtlProgressBarObject : public ComCtlObjectBase
 196 {
 197 public:
 198     explicit            ComCtlProgressBarObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 199
 200 protected:
 201     virtual void        implDumpProperties() override;
 202 };
 203
 204
 205 class ComCtlSliderObject : public ComCtlObjectBase
 206 {
 207 public:
 208     explicit            ComCtlSliderObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 209
 210 protected:
 211     virtual void        implDumpProperties() override;
 212 };
 213
 214
 215 class ComCtlUpDownObject : public ComCtlObjectBase
 216 {
 217 public:
 218     explicit            ComCtlUpDownObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 219
 220 protected:
 221     virtual void        implDumpProperties() override;
 222 };
 223
 224
 225 class ComCtlImageListObject : public ComCtlObjectBase
 226 {
 227 public:
 228     explicit            ComCtlImageListObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 229
 230 protected:
 231     virtual void        implDumpProperties() override;
 232     virtual void        implDumpCommonExtra( sal_Int64 nEndPos ) override;
 233     virtual void        implDumpCommonTrailing() override;
 234 };
 235
 236
 237 class ComCtlTabStripObject : public ComCtlObjectBase
 238 {
 239 public:
 240     explicit            ComCtlTabStripObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 241
 242 protected:
 243     virtual void        implDumpProperties() override;
 244     virtual void        implDumpCommonExtra( sal_Int64 nEndPos ) override;
 245 };
 246
 247
 248 class ComCtlTreeViewObject : public ComCtlObjectBase
 249 {
 250 public:
 251     explicit            ComCtlTreeViewObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 252
 253 protected:
 254     virtual void        implDumpProperties() override;
 255     virtual void        implDumpCommonExtra( sal_Int64 nEndPos ) override;
 256
 257 private:
 258     sal_uInt32          mnStringFlags;
 259 };
 260
 261
 262 class ComCtlStatusBarObject : public ComCtlObjectBase
 263 {
 264 public:
 265     explicit            ComCtlStatusBarObject( const InputObjectBase& rParent, sal_uInt16 nVersion );
 266
 267 protected:
 268     virtual void        implDumpProperties() override;
 269     virtual void        implDumpCommonExtra( sal_Int64 nEndPos ) override;
 270     virtual void        implDumpCommonTrailing() override;
 271 };
 272
 273
 274 class AxPropertyObjectBase : public OleInputObjectBase
 275 {
 276 protected:
 277     AxPropertyObjectBase() {}
 278
 279     using               OleInputObjectBase::construct;
 280     void                construct(
 281                             const ObjectBase& rParent,
 282                             const BinaryInputStreamRef& rxStrm,
 283                             const OUString& rSysFileName,
 284                             const String& rPropNameList,
 285                             bool b64BitPropFlags = false );
 286     void                construct(
 287                             const InputObjectBase& rParent,
 288                             const String& rPropNameList,
 289                             bool b64BitPropFlags = false );
 290
 291     virtual bool        implIsValid() const override;
 292     virtual void        implDump() override;
 293
 294     virtual void        implDumpShortProperties();
 295     virtual void        implDumpExtended();
 296
 297     bool                ensureValid( bool bCondition = true );
 298
 299     template< typename Type >
 300     void                alignInput();
 301
 302     void                setAlignAnchor();
 303     bool                startNextProperty();
 304     OUString     getPropertyName() const;
 305
 306     template< typename Type >
 307     Type                dumpDecProperty( Type nDefault, const NameListWrapper& rListWrp = NO_LIST );
 308     template< typename Type >
 309     Type                dumpHexProperty( Type nDefault, const NameListWrapper& rListWrp = NO_LIST );
 310
 311     bool         dumpBoolProperty() { return startNextProperty(); }
 312     sal_Int32    dumpHmmProperty() { return dumpDecProperty< sal_Int32 >( 0, "CONV-HMM-TO-CM" ); }
 313     sal_uInt8    dumpMousePtrProperty() { return dumpDecProperty< sal_uInt8 >( 0, "OLE-MOUSEPTR" ); }
 314     template< typename Type >
 315     Type         dumpBorderStyleProperty( Type nDefault ) { return dumpDecProperty< Type >( nDefault, "AX-BORDERSTYLE" ); }
 316     template< typename Type >
 317     Type         dumpSpecialEffectProperty( Type nDefault ) { return dumpDecProperty< Type >( nDefault, "AX-SPECIALEFFECT" ); }
 318     sal_uInt32   dumpEnabledProperty() { return dumpDecProperty< sal_uInt32 >( 1, "AX-ENABLED" ); }
 319     sal_Int32    dumpOrientationProperty() { return dumpDecProperty< sal_Int32 >( -1, "AX-ORIENTATION" ); }
 320     sal_Int32    dumpDelayProperty() { return dumpDecProperty< sal_Int32 >( 50, "AX-CONV-MS" ); }
 321     sal_uInt32   dumpImagePosProperty() { return dumpHexProperty< sal_uInt32 >( 0x00070001, "AX-IMAGEPOS" ); }
 322     sal_uInt8    dumpImageSizeModeProperty() { return dumpDecProperty< sal_uInt8 >( 0, "AX-IMAGESIZEMODE" ); }
 323     sal_uInt8    dumpImageAlignProperty() { return dumpDecProperty< sal_uInt8 >( 2, "AX-IMAGEALIGN" ); }
 324
 325     sal_uInt32          dumpFlagsProperty( sal_uInt32 nDefault, const sal_Char* pcNameList = "AX-FLAGS" );
 326     sal_uInt32          dumpColorProperty( sal_uInt32 nDefault );
 327     sal_Unicode         dumpUnicodeProperty();
 328     void                dumpUnknownProperty();
 329
 330     void                dumpPosProperty();
 331     void                dumpSizeProperty();
 332     void                dumpGuidProperty( OUString* pValue = nullptr );
 333     void                dumpStringProperty( OUString* pValue = nullptr );
 334     void                dumpStringArrayProperty();
 335     void                dumpStreamProperty();
 336
 337     void                dumpEmbeddedFont();
 338     void                dumpToPosition( sal_Int64 nPos );
 339
 340 private:
 341     void                constructAxPropObj( const String& rPropNameList, bool b64BitPropFlags );
 342
 343     void                dumpVersion();
 344     OUString            dumpString( const String& rName, sal_uInt32 nSize, bool bArray );
 345     void                dumpShortProperties();
 346     void                dumpLargeProperties();
 347
 348 private:
 349     struct LargeProperty
 350     {
 351         enum LargePropertyType { PROPTYPE_POS, PROPTYPE_SIZE, PROPTYPE_GUID, PROPTYPE_STRING, PROPTYPE_STRINGARRAY };
 352
 353         LargePropertyType   mePropType;
 354         OUString     maItemName;
 355         sal_uInt32          mnDataSize;
 356         OUString*    mpItemValue;
 357         explicit     LargeProperty( LargePropertyType ePropType, const String& rItemName, sal_uInt32 nDataSize, OUString* pItemValue = nullptr ) :
 358                                 mePropType( ePropType ), maItemName( rItemName ), mnDataSize( nDataSize ), mpItemValue( pItemValue ) {}
 359     };
 360     typedef ::std::vector< LargeProperty > LargePropertyVector;
 361
 362     struct StreamProperty
 363     {
 364         OUString     maItemName;
 365         sal_uInt16          mnData;
 366         explicit     StreamProperty( const String& rItemName, sal_uInt16 nData ) :
 367                                 maItemName( rItemName ), mnData( nData ) {}
 368     };
 369     typedef ::std::vector< StreamProperty > StreamPropertyVector;
 370
 371     LargePropertyVector maLargeProps;
 372     StreamPropertyVector maStreamProps;
 373     NameListRef         mxPropNames;
 374     sal_Int64           mnPropertiesStart;
 375     sal_Int64           mnPropertiesEnd;
 376     sal_Int64           mnPropFlags;
 377     sal_Int64           mnCurrProp;
 378     bool                mb64BitPropFlags;
 379     bool                mbValid;
 380 };
 381
 382
 383 template< typename Type >
 384 void AxPropertyObjectBase::alignInput()
 385 {
 386     mxStrm->skip( (sizeof( Type ) - ((mxStrm->tell() - mnPropertiesStart) % sizeof( Type ))) % sizeof( Type ) );
 387 }
 388
 389 template< typename Type >
 390 Type AxPropertyObjectBase::dumpDecProperty( Type nDefault, const NameListWrapper& rListWrp )
 391 {
 392     if( startNextProperty() )
 393     {
 394         alignInput< Type >();
 395         return dumpDec< Type >( getPropertyName(), rListWrp );
 396     }
 397     return nDefault;
 398 }
 399
 400 template< typename Type >
 401 Type AxPropertyObjectBase::dumpHexProperty( Type nDefault, const NameListWrapper& rListWrp )
 402 {
 403     if( startNextProperty() )
 404     {
 405         alignInput< Type >();
 406         return dumpHex< Type >( getPropertyName(), rListWrp );
 407     }
 408     return nDefault;
 409 }
 410
 411
 412 class AxCFontNewObject : public AxPropertyObjectBase
 413 {
 414 public:
 415     explicit            AxCFontNewObject( const InputObjectBase& rParent );
 416
 417 protected:
 418     virtual void        implDumpShortProperties() override;
 419 };
 420
 421
 422 class AxColumnInfoObject : public AxPropertyObjectBase
 423 {
 424 public:
 425     explicit            AxColumnInfoObject( const InputObjectBase& rParent );
 426
 427 protected:
 428     virtual void        implDumpShortProperties() override;
 429 };
 430
 431
 432 class AxCommandButtonObject : public AxPropertyObjectBase
 433 {
 434 public:
 435     explicit            AxCommandButtonObject( const InputObjectBase& rParent );
 436
 437 protected:
 438     virtual void        implDumpShortProperties() override;
 439     virtual void        implDumpExtended() override;
 440 };
 441
 442
 443 class AxMorphControlObject : public AxPropertyObjectBase
 444 {
 445 public:
 446     explicit            AxMorphControlObject( const InputObjectBase& rParent );
 447
 448 protected:
 449     virtual void        implDumpShortProperties() override;
 450     virtual void        implDumpExtended() override;
 451
 452 private:
 453     void                dumpColumnInfos();
 454
 455 private:
 456     sal_uInt16          mnColInfoCount;
 457     sal_uInt8           mnCtrlType;
 458 };
 459
 460
 461 class AxLabelObject : public AxPropertyObjectBase
 462 {
 463 public:
 464     explicit            AxLabelObject( const InputObjectBase& rParent );
 465
 466 protected:
 467     virtual void        implDumpShortProperties() override;
 468     virtual void        implDumpExtended() override;
 469 };
 470
 471
 472 class AxImageObject : public AxPropertyObjectBase
 473 {
 474 public:
 475     explicit            AxImageObject( const InputObjectBase& rParent );
 476
 477 protected:
 478     virtual void        implDumpShortProperties() override;
 479 };
 480
 481
 482 class AxScrollBarObject : public AxPropertyObjectBase
 483 {
 484 public:
 485     explicit            AxScrollBarObject( const InputObjectBase& rParent );
 486
 487 protected:
 488     virtual void        implDumpShortProperties() override;
 489 };
 490
 491
 492 class AxSpinButtonObject : public AxPropertyObjectBase
 493 {
 494 public:
 495     explicit            AxSpinButtonObject( const InputObjectBase& rParent );
 496
 497 protected:
 498     virtual void        implDumpShortProperties() override;
 499 };
 500
 501
 502 class AxTabStripObject : public AxPropertyObjectBase
 503 {
 504 public:
 505     explicit            AxTabStripObject( const InputObjectBase& rParent );
 506
 507 protected:
 508     virtual void        implDumpShortProperties() override;
 509     virtual void        implDumpExtended() override;
 510
 511 private:
 512     sal_Int32           mnTabFlagCount;
 513 };
 514
 515
 516 class FormControlStreamObject : public OleInputObjectBase
 517 {
 518 public:
 519     explicit            FormControlStreamObject(
 520                             const ObjectBase& rParent,
 521                             const BinaryInputStreamRef& rxStrm,
 522                             const OUString& rSysFileName,
 523                             const OUString* pProgId = nullptr );
 524     explicit            FormControlStreamObject(
 525                             const OutputObjectBase& rParent,
 526                             const BinaryInputStreamRef& rxStrm,
 527                             const OUString* pProgId = nullptr );
 528
 529 protected:
 530     virtual void        implDump() override;
 531
 532 private:
 533     void                constructFormCtrlStrmObj( const OUString* pProgId );
 534
 535 private:
 536     OUString     maProgId;
 537     bool                mbReadGuid;
 538 };
 539
 540
 541 struct VbaFormSiteInfo
 542 {
 543     OUString     maProgId;
 544     sal_Int32           mnId;
 545     sal_uInt32          mnLength;
 546     bool                mbInStream;
 547
 548     VbaFormSiteInfo() : mnId( 0 ), mnLength( 0 ), mbInStream( false ) {}
 549 };
 550
 551 typedef ::std::vector< VbaFormSiteInfo > VbaFormSiteInfoVector;
 552
 553
 554 struct VbaFormSharedData
 555 {
 556     OUStringVector      maClassInfoProgIds;
 557     VbaFormSiteInfoVector maSiteInfos;
 558 };
 559
 560
 561 class VbaFormClassInfoObject : public AxPropertyObjectBase
 562 {
 563 public:
 564     explicit            VbaFormClassInfoObject( const InputObjectBase& rParent, VbaFormSharedData& rFormData );
 565
 566 protected:
 567     virtual void        implDumpShortProperties() override;
 568
 569 private:
 570     VbaFormSharedData&  mrFormData;
 571 };
 572
 573
 574 class VbaFormSiteObject : public AxPropertyObjectBase
 575 {
 576 public:
 577     explicit            VbaFormSiteObject( const InputObjectBase& rParent, VbaFormSharedData& rFormData );
 578
 579 protected:
 580     virtual void        implDumpShortProperties() override;
 581
 582 private:
 583     VbaFormSharedData&  mrFormData;
 584 };
 585
 586
 587 class VbaFormDesignExtObject : public AxPropertyObjectBase
 588 {
 589 public:
 590     explicit            VbaFormDesignExtObject( const InputObjectBase& rParent );
 591
 592 protected:
 593     virtual void        implDumpShortProperties() override;
 594 };
 595
 596
 597 class VbaFStreamObject : public AxPropertyObjectBase
 598 {
 599 public:
 600     explicit            VbaFStreamObject(
 601                             const ObjectBase& rParent,
 602                             const BinaryInputStreamRef& rxStrm,
 603                             const OUString& rSysFileName,
 604                             VbaFormSharedData& rFormData );
 605
 606 protected:
 607     virtual void        implDumpShortProperties() override;
 608     virtual void        implDumpExtended() override;
 609
 610 private:
 611     void                dumpClassInfos();
 612     void                dumpFormSites( sal_uInt32 nCount );
 613     void                dumpSiteData();
 614     void                dumpDesignExtender();
 615
 616 private:
 617     VbaFormSharedData&  mrFormData;
 618     sal_uInt32          mnFlags;
 619 };
 620
 621
 622 class VbaOStreamObject : public OleInputObjectBase
 623 {
 624 public:
 625     explicit            VbaOStreamObject(
 626                             const ObjectBase& rParent,
 627                             const BinaryInputStreamRef& rxStrm,
 628                             const OUString& rSysFileName,
 629                             VbaFormSharedData& rFormData );
 630
 631 protected:
 632     virtual void        implDump() override;
 633
 634 private:
 635     VbaFormSharedData&  mrFormData;
 636 };
 637
 638
 639 class VbaPageObject : public AxPropertyObjectBase
 640 {
 641 public:
 642     explicit            VbaPageObject( const InputObjectBase& rParent );
 643
 644 protected:
 645     virtual void        implDumpShortProperties() override;
 646 };
 647
 648
 649 class VbaMultiPageObject : public AxPropertyObjectBase
 650 {
 651 public:
 652     explicit            VbaMultiPageObject( const InputObjectBase& rParent );
 653
 654 protected:
 655     virtual void        implDumpShortProperties() override;
 656     virtual void        implDumpExtended() override;
 657
 658 private:
 659     sal_Int32           mnPageCount;
 660 };
 661
 662
 663 class VbaXStreamObject : public InputObjectBase
 664 {
 665 public:
 666     explicit            VbaXStreamObject(
 667                             const ObjectBase& rParent,
 668                             const BinaryInputStreamRef& rxStrm,
 669                             const OUString& rSysFileName,
 670                             VbaFormSharedData& rFormData );
 671
 672 protected:
 673     virtual void        implDump() override;
 674
 675 private:
 676     VbaFormSharedData&  mrFormData;
 677 };
 678
 679
 680 class VbaContainerStorageObject : public OleStorageObject
 681 {
 682 public:
 683     explicit            VbaContainerStorageObject(
 684                             const ObjectBase& rParent,
 685                             const StorageRef& rxStrg,
 686                             const OUString& rSysPath );
 687
 688 protected:
 689     virtual void        implDumpStream(
 690                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 691                             const OUString& rStrgPath,
 692                             const OUString& rStrmName,
 693                             const OUString& rSysFileName ) override;
 694
 695     virtual void        implDumpStorage(
 696                             const StorageRef& rxStrg,
 697                             const OUString& rStrgPath,
 698                             const OUString& rSysPath ) override;
 699
 700 private:
 701     bool                isFormStorage( const OUString& rStrgPath ) const;
 702
 703 private:
 704     VbaFormSharedData   maFormData;
 705 };
 706
 707
 708 struct VbaSharedData
 709 {
 710     typedef ::std::map< OUString, sal_Int32 > StreamOffsetMap;
 711
 712     StreamOffsetMap     maStrmOffsets;
 713     rtl_TextEncoding    meTextEnc;
 714
 715                         VbaSharedData();
 716
 717     bool                isModuleStream( const OUString& rStrmName ) const;
 718     sal_Int32           getStreamOffset( const OUString& rStrmName ) const;
 719 };
 720
 721
 722 class VbaDirStreamObject : public SequenceRecordObjectBase
 723 {
 724 public:
 725     explicit            VbaDirStreamObject(
 726                             const ObjectBase& rParent,
 727                             const BinaryInputStreamRef& rxStrm,
 728                             const OUString& rSysFileName,
 729                             VbaSharedData& rVbaData );
 730
 731 protected:
 732     virtual bool        implIsValid() const override;
 733     virtual bool        implReadRecordHeader( BinaryInputStream& rBaseStrm, sal_Int64& ornRecId, sal_Int64& ornRecSize ) override;
 734     virtual void        implDumpRecordBody() override;
 735
 736 private:
 737     OUString     dumpByteString( const String& rName );
 738     OUString     dumpUniString( const String& rName );
 739     OUString     dumpByteStringWithLength( const String& rName );
 740
 741 private:
 742     VbaSharedData&      mrVbaData;
 743     BinaryInputStreamRef mxInStrm;
 744     OUString     maCurrStream;
 745     sal_Int32           mnCurrOffset;
 746 };
 747
 748
 749 class VbaModuleStreamObject : public InputObjectBase
 750 {
 751 public:
 752     explicit            VbaModuleStreamObject(
 753                             const ObjectBase& rParent,
 754                             const BinaryInputStreamRef& rxStrm,
 755                             const OUString& rSysFileName,
 756                             VbaSharedData& rVbaData,
 757                             sal_Int32 nStrmOffset );
 758
 759 protected:
 760     virtual void        implDump() override;
 761
 762 private:
 763     VbaSharedData&      mrVbaData;
 764     sal_Int32           mnStrmOffset;
 765 };
 766
 767
 768 class VbaStorageObject : public OleStorageObject
 769 {
 770 public:
 771     explicit            VbaStorageObject(
 772                             const ObjectBase& rParent,
 773                             const StorageRef& rxStrg,
 774                             const OUString& rSysPath,
 775                             VbaSharedData& rVbaData );
 776
 777 protected:
 778     virtual void        implDumpStream(
 779                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 780                             const OUString& rStrgPath,
 781                             const OUString& rStrmName,
 782                             const OUString& rSysFileName ) override;
 783
 784 private:
 785     VbaSharedData&      mrVbaData;
 786 };
 787
 788
 789 class VbaFormStorageObject : public VbaContainerStorageObject
 790 {
 791 public:
 792     explicit            VbaFormStorageObject(
 793                             const ObjectBase& rParent,
 794                             const StorageRef& rxStrg,
 795                             const OUString& rSysPath,
 796                             VbaSharedData& rVbaData );
 797
 798 protected:
 799     virtual void        implDumpStream(
 800                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 801                             const OUString& rStrgPath,
 802                             const OUString& rStrmName,
 803                             const OUString& rSysFileName ) override;
 804
 805 private:
 806     VbaSharedData&      mrVbaData;
 807 };
 808
 809
 810 class VbaProjectStorageObject : public OleStorageObject
 811 {
 812 public:
 813     explicit            VbaProjectStorageObject( const ObjectBase& rParent, const StorageRef& rxStrg, const OUString& rSysPath );
 814
 815 protected:
 816     virtual void        implDumpStream(
 817                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 818                             const OUString& rStrgPath,
 819                             const OUString& rStrmName,
 820                             const OUString& rSysFileName ) override;
 821
 822     virtual void        implDumpStorage(
 823                             const StorageRef& rxStrg,
 824                             const OUString& rStrgPath,
 825                             const OUString& rSysPath ) override;
 826
 827 private:
 828     VbaSharedData       maVbaData;
 829 };
 830
 831
 832 class ActiveXStorageObject : public VbaContainerStorageObject
 833 {
 834 public:
 835     explicit            ActiveXStorageObject(
 836                             const ObjectBase& rParent,
 837                             const StorageRef& rxStrg,
 838                             const OUString& rSysPath );
 839
 840 protected:
 841     virtual void        implDumpBaseStream(
 842                             const BinaryInputStreamRef& rxStrm,
 843                             const OUString& rSysFileName ) override;
 844 };
 845
 846
 847 } // namespace dump
 848 } // namespace oox
 849
 850 #endif
 851 #endif
 852
 853 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */