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 <utility>
  26 #include <vector>
  27
  28 #include <com/sun/star/uno/Reference.hxx>
  29 #include <oox/dump/dumperbase.hxx>
  30 #include <oox/helper/binaryinputstream.hxx>
  31 #include <oox/helper/storagebase.hxx>
  32 #include <rtl/textenc.h>
  33 #include <rtl/ustring.hxx>
  34 #include <sal/types.h>
  35
  36 #ifdef DBG_UTIL
  37
  38 namespace com::sun::star {
  39     namespace io { class XInputStream; }
  40 }
  41
  42 namespace oox::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 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, String aItemName, sal_uInt32 nDataSize, OUString* pItemValue = nullptr ) :
 358                                 mePropType( ePropType ), maItemName(std::move( aItemName )), 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( String aItemName, sal_uInt16 nData ) :
 367                                 maItemName(std::move( aItemName )), mnData( nData ) {}
 368     };
 369
 370     LargePropertyVector maLargeProps;
 371     std::vector< StreamProperty >
 372                         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
 552 struct VbaFormSharedData
 553 {
 554     OUStringVector                 maClassInfoProgIds;
 555     std::vector< VbaFormSiteInfo > maSiteInfos;
 556 };
 557
 558
 559 class VbaFormClassInfoObject : public AxPropertyObjectBase
 560 {
 561 public:
 562     explicit            VbaFormClassInfoObject( const InputObjectBase& rParent, VbaFormSharedData& rFormData );
 563
 564 protected:
 565     virtual void        implDumpShortProperties() override;
 566
 567 private:
 568     VbaFormSharedData&  mrFormData;
 569 };
 570
 571
 572 class VbaFormSiteObject : public AxPropertyObjectBase
 573 {
 574 public:
 575     explicit            VbaFormSiteObject( const InputObjectBase& rParent, VbaFormSharedData& rFormData );
 576
 577 protected:
 578     virtual void        implDumpShortProperties() override;
 579
 580 private:
 581     VbaFormSharedData&  mrFormData;
 582 };
 583
 584
 585 class VbaFormDesignExtObject : public AxPropertyObjectBase
 586 {
 587 public:
 588     explicit            VbaFormDesignExtObject( const InputObjectBase& rParent );
 589
 590 protected:
 591     virtual void        implDumpShortProperties() override;
 592 };
 593
 594
 595 class VbaFStreamObject : public AxPropertyObjectBase
 596 {
 597 public:
 598     explicit            VbaFStreamObject(
 599                             const ObjectBase& rParent,
 600                             const BinaryInputStreamRef& rxStrm,
 601                             const OUString& rSysFileName,
 602                             VbaFormSharedData& rFormData );
 603
 604 protected:
 605     virtual void        implDumpShortProperties() override;
 606     virtual void        implDumpExtended() override;
 607
 608 private:
 609     void                dumpClassInfos();
 610     void                dumpFormSites( sal_uInt32 nCount );
 611     void                dumpSiteData();
 612     void                dumpDesignExtender();
 613
 614 private:
 615     VbaFormSharedData&  mrFormData;
 616     sal_uInt32          mnFlags;
 617 };
 618
 619
 620 class VbaOStreamObject : public OleInputObjectBase
 621 {
 622 public:
 623     explicit            VbaOStreamObject(
 624                             const ObjectBase& rParent,
 625                             const BinaryInputStreamRef& rxStrm,
 626                             const OUString& rSysFileName,
 627                             VbaFormSharedData& rFormData );
 628
 629 protected:
 630     virtual void        implDump() override;
 631
 632 private:
 633     VbaFormSharedData&  mrFormData;
 634 };
 635
 636
 637 class VbaPageObject : public AxPropertyObjectBase
 638 {
 639 public:
 640     explicit            VbaPageObject( const InputObjectBase& rParent );
 641
 642 protected:
 643     virtual void        implDumpShortProperties() override;
 644 };
 645
 646
 647 class VbaMultiPageObject : public AxPropertyObjectBase
 648 {
 649 public:
 650     explicit            VbaMultiPageObject( const InputObjectBase& rParent );
 651
 652 protected:
 653     virtual void        implDumpShortProperties() override;
 654     virtual void        implDumpExtended() override;
 655
 656 private:
 657     sal_Int32           mnPageCount;
 658 };
 659
 660
 661 class VbaXStreamObject : public InputObjectBase
 662 {
 663 public:
 664     explicit            VbaXStreamObject(
 665                             const ObjectBase& rParent,
 666                             const BinaryInputStreamRef& rxStrm,
 667                             const OUString& rSysFileName,
 668                             VbaFormSharedData& rFormData );
 669
 670 protected:
 671     virtual void        implDump() override;
 672
 673 private:
 674     VbaFormSharedData&  mrFormData;
 675 };
 676
 677
 678 class VbaContainerStorageObject : public OleStorageObject
 679 {
 680 public:
 681     explicit            VbaContainerStorageObject(
 682                             const ObjectBase& rParent,
 683                             const StorageRef& rxStrg,
 684                             const OUString& rSysPath );
 685
 686 protected:
 687     virtual void        implDumpStream(
 688                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 689                             const OUString& rStrgPath,
 690                             const OUString& rStrmName,
 691                             const OUString& rSysFileName ) override;
 692
 693     virtual void        implDumpStorage(
 694                             const StorageRef& rxStrg,
 695                             const OUString& rStrgPath,
 696                             const OUString& rSysPath ) override;
 697
 698 private:
 699     bool                isFormStorage( std::u16string_view rStrgPath ) const;
 700
 701 private:
 702     VbaFormSharedData   maFormData;
 703 };
 704
 705
 706 struct VbaSharedData
 707 {
 708     typedef ::std::map< OUString, sal_Int32 > StreamOffsetMap;
 709
 710     StreamOffsetMap     maStrmOffsets;
 711     rtl_TextEncoding    meTextEnc;
 712
 713                         VbaSharedData();
 714
 715     bool                isModuleStream( const OUString& rStrmName ) const;
 716     sal_Int32           getStreamOffset( const OUString& rStrmName ) const;
 717 };
 718
 719
 720 class VbaDirStreamObject : public SequenceRecordObjectBase
 721 {
 722 public:
 723     explicit            VbaDirStreamObject(
 724                             const ObjectBase& rParent,
 725                             const BinaryInputStreamRef& rxStrm,
 726                             const OUString& rSysFileName,
 727                             VbaSharedData& rVbaData );
 728
 729 protected:
 730     virtual bool        implIsValid() const override;
 731     virtual bool        implReadRecordHeader( BinaryInputStream& rBaseStrm, sal_Int64& ornRecId, sal_Int64& ornRecSize ) override;
 732     virtual void        implDumpRecordBody() override;
 733
 734 private:
 735     OUString     dumpByteString( const String& rName );
 736     OUString     dumpUniString( const String& rName );
 737     OUString     dumpByteStringWithLength( const String& rName );
 738
 739 private:
 740     VbaSharedData&      mrVbaData;
 741     BinaryInputStreamRef mxInStrm;
 742     OUString     maCurrStream;
 743     sal_Int32           mnCurrOffset;
 744 };
 745
 746
 747 class VbaModuleStreamObject : public InputObjectBase
 748 {
 749 public:
 750     explicit            VbaModuleStreamObject(
 751                             const ObjectBase& rParent,
 752                             const BinaryInputStreamRef& rxStrm,
 753                             const OUString& rSysFileName,
 754                             VbaSharedData& rVbaData,
 755                             sal_Int32 nStrmOffset );
 756
 757 protected:
 758     virtual void        implDump() override;
 759
 760 private:
 761     VbaSharedData&      mrVbaData;
 762     sal_Int32           mnStrmOffset;
 763 };
 764
 765
 766 class VbaStorageObject : public OleStorageObject
 767 {
 768 public:
 769     explicit            VbaStorageObject(
 770                             const ObjectBase& rParent,
 771                             const StorageRef& rxStrg,
 772                             const OUString& rSysPath,
 773                             VbaSharedData& rVbaData );
 774
 775 protected:
 776     virtual void        implDumpStream(
 777                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 778                             const OUString& rStrgPath,
 779                             const OUString& rStrmName,
 780                             const OUString& rSysFileName ) override;
 781
 782 private:
 783     VbaSharedData&      mrVbaData;
 784 };
 785
 786
 787 class VbaFormStorageObject : public VbaContainerStorageObject
 788 {
 789 public:
 790     explicit            VbaFormStorageObject(
 791                             const ObjectBase& rParent,
 792                             const StorageRef& rxStrg,
 793                             const OUString& rSysPath,
 794                             VbaSharedData& rVbaData );
 795
 796 protected:
 797     virtual void        implDumpStream(
 798                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 799                             const OUString& rStrgPath,
 800                             const OUString& rStrmName,
 801                             const OUString& rSysFileName ) override;
 802
 803 private:
 804     VbaSharedData&      mrVbaData;
 805 };
 806
 807
 808 class VbaProjectStorageObject : public OleStorageObject
 809 {
 810 public:
 811     explicit            VbaProjectStorageObject( const ObjectBase& rParent, const StorageRef& rxStrg, const OUString& rSysPath );
 812
 813 protected:
 814     virtual void        implDumpStream(
 815                             const css::uno::Reference< css::io::XInputStream >& rxStrm,
 816                             const OUString& rStrgPath,
 817                             const OUString& rStrmName,
 818                             const OUString& rSysFileName ) override;
 819
 820     virtual void        implDumpStorage(
 821                             const StorageRef& rxStrg,
 822                             const OUString& rStrgPath,
 823                             const OUString& rSysPath ) override;
 824
 825 private:
 826     VbaSharedData       maVbaData;
 827 };
 828
 829
 830 class ActiveXStorageObject : public VbaContainerStorageObject
 831 {
 832 public:
 833     explicit            ActiveXStorageObject(
 834                             const ObjectBase& rParent,
 835                             const StorageRef& rxStrg,
 836                             const OUString& rSysPath );
 837
 838 protected:
 839     virtual void        implDumpBaseStream(
 840                             const BinaryInputStreamRef& rxStrm,
 841                             const OUString& rSysFileName ) override;
 842 };
 843
 844
 845 } // namespace oox::dump
 846
 847 #endif
 848 #endif
 849
 850 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */