svx/workben/msview/msview.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  * 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
  21 #include <vector>
  22 #include <map>
  23 #include <algorithm>
  24 #include <boost/shared_ptr.hpp>
  25 #include <sot/storage.hxx>
  26 #include <svtools/svtools.hrc>
  27
  28 #include <sal/main.h>
  29 #include <vcl/event.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <vcl/wrkwin.hxx>
  32 #include <vcl/msgbox.hxx>
  33 #include <vcl/fixed.hxx>
  34 #include <vcl/edit.hxx>
  35 #include <vcl/button.hxx>
  36 #include <vcl/lstbox.hxx>
  37 #include <svtools/filectrl.hxx>
  38 #include <tools/urlobj.hxx>
  39 #include <osl/file.hxx>
  40 #include <vcl/unohelp2.hxx>
  41 #include <svtools/treelistbox.hxx>
  42 #include <svtools/svmedit.hxx>
  43 #include <sfx2/filedlghelper.hxx>
  44
  45 #include <toolkit/helper/vclunohelper.hxx>
  46
  47 #include <tools/stream.hxx>
  48 #include <tools/resmgr.hxx>
  49
  50 #include <comphelper/processfactory.hxx>
  51 #include <cppuhelper/servicefactory.hxx>
  52 #include <cppuhelper/bootstrap.hxx>
  53
  54 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  55
  56 #include <com/sun/star/awt/XWindowPeer.hpp>
  57 #include <com/sun/star/awt/XToolkit.hpp>
  58 #include <com/sun/star/awt/WindowDescriptor.hpp>
  59 #include <com/sun/star/awt/WindowAttribute.hpp>
  60 #include <svx/msdffdef.hxx>
  61
  62 #include <unotools/localfilehelper.hxx>
  63
  64 #include "xmlconfig.hxx"
  65
  66
  67 using namespace ::com::sun::star;
  68
  69
  70
  71 enum CompareStatus           { CMP_NOTYET = 0, CMP_EQUAL = 1, CMP_NOTEQUAL = 2, CMP_NOTAVAILABLE = 3 };
  72 static ColorData gColors[] = { COL_BLACK,      COL_GREEN,     COL_RED,          COL_CYAN };
  73
  74 class Atom
  75 {
  76 public:
  77     ~Atom();
  78
  79     /** imports this atom and its child atoms */
  80     static Atom* import( const DffRecordHeader& rRootRecordHeader, SvStream& rStCtrl );
  81     static Atom* import( UINT16 nRecType, SvStream& rStCtrl );
  82
  83     inline const DffRecordHeader& getHeader() const;
  84
  85     /** returns true if at least one atom with the given nRecType is found */
  86     inline bool hasChildAtom( sal_uInt16 nRecType ) const;
  87
  88     /** returns true if at least one atom with the given nRecType and nRecInstnace is found */
  89     inline bool hasChildAtom( sal_uInt16 nRecType, sal_uInt16 nRecInstance ) const;
  90
  91     /** returns the first child atom with nRecType or NULL */
  92     inline const Atom* findFirstChildAtom( sal_uInt16 nRecType ) const;
  93
  94     /** returns the next child atom after pLast with nRecType or NULL */
  95     const Atom* findNextChildAtom( sal_uInt16 nRecType, const Atom* pLast ) const;
  96
  97     /** returns the first child atom with nRecType and nRecInstance or NULL */
  98     inline const Atom* findFirstChildAtom( sal_uInt16 nRecType, sal_uInt16 nRecInstance ) const;
  99
 100     /** returns the next child atom after pLast with nRecType and nRecInstance or NULL */
 101     const Atom* findNextChildAtom( sal_uInt16 nRecType, sal_uInt16 nRecInstance, const Atom* pLast ) const;
 102
 103     /** returns the first child atom or NULL */
 104     inline const Atom* findFirstChildAtom() const;
 105
 106     /** returns the next child atom after pLast or NULL */
 107     inline const Atom* findNextChildAtom( const Atom* pLast ) const;
 108
 109     /** returns true if this atom is a container */
 110     inline bool isContainer() const;
 111
 112     /** seeks to the contents of this atom */
 113     inline bool seekToContent() const;
 114
 115     /** returns the record type */
 116     inline sal_uInt16 getType() const;
 117
 118     /** returns the record instance */
 119     inline sal_uInt16 getInstance() const;
 120
 121     /** returns the record length */
 122     inline sal_uInt32 getLength() const;
 123
 124     SvStream& getStream() const { return mrStream; }
 125
 126     bool operator==( const Atom& rAtom ) const;
 127
 128     CompareStatus getCompareStatus() const { return meStatus; }
 129
 130     void compare( Atom* pAtom );
 131     bool compareContent( Atom& rAtom );
 132
 133     Atom* getCompareAtom() const { return mpCompareAtom; }
 134     void setCompareAtom( Atom* pAtom ) { mpCompareAtom = pAtom; }
 135
 136 private:
 137     Atom( const DffRecordHeader& rRecordHeader, SvStream& rStCtrl );
 138
 139     // statics for compare
 140     static Atom* skipAtoms( Atom* pContainer, Atom* pAtom, Atom* pSkipTo );
 141     static Atom* findFirstEqualAtom( Atom* pCompare, Atom* pContainer, Atom* pSearch, int& nDistance );
 142
 143     SvStream& mrStream;
 144     DffRecordHeader maRecordHeader;
 145     Atom* mpFirstChild;
 146     Atom* mpNextAtom;
 147
 148     CompareStatus meStatus;
 149     Atom* mpCompareAtom;
 150 };
 151
 152 bool Atom::operator==( const Atom& rAtom ) const
 153 {
 154     return ( maRecordHeader.nRecType == rAtom.maRecordHeader.nRecType ) &&
 155             ( maRecordHeader.nRecVer == rAtom.maRecordHeader.nRecVer ) &&
 156            ( maRecordHeader.nRecInstance == rAtom.maRecordHeader.nRecInstance );
 157 }
 158
 159 bool Atom::compareContent( Atom& rAtom )
 160 {
 161     if( maRecordHeader.nRecLen == rAtom.maRecordHeader.nRecLen )
 162     {
 163         seekToContent();
 164         rAtom.seekToContent();
 165
 166         SvStream& rStream1 = getStream();
 167         SvStream& rStream2 = rAtom.getStream();
 168
 169         const int nBufferSize = 1024;
 170         boost::shared_ptr< char > buffer1( new char[nBufferSize] );
 171         boost::shared_ptr< char > buffer2( new char[nBufferSize] );
 172
 173         sal_uInt32 nLength = maRecordHeader.nRecLen;
 174         sal_Size nRead = 0;
 175         while( nLength )
 176         {
 177             sal_Size nRead = (nBufferSize < nLength) ? nBufferSize : nLength;
 178             nRead = rStream1.Read( (void*)buffer1.get(), nRead );
 179             if( nRead == 0 )
 180                 break;
 181             if( rStream2.Read( (void*)buffer2.get(), nRead ) != nRead )
 182                 break;
 183             if( memcmp( (void*)buffer1.get(), (void*)buffer2.get(), nRead ) != 0 )
 184                 break;
 185
 186             nLength -= nRead;
 187         }
 188
 189         return nLength == 0;
 190     }
 191
 192     return false;
 193 }
 194
 195 inline bool Atom::hasChildAtom( sal_uInt16 nRecType ) const
 196 {
 197     return findFirstChildAtom( nRecType ) != NULL;
 198 }
 199
 200 inline bool Atom::hasChildAtom( sal_uInt16 nRecType, sal_uInt16 nRecInstance ) const
 201 {
 202     return findFirstChildAtom( nRecType, nRecInstance ) != NULL;
 203 }
 204
 205 inline const Atom* Atom::findFirstChildAtom( sal_uInt16 nRecType ) const
 206 {
 207     return findNextChildAtom( nRecType, NULL );
 208 }
 209
 210 inline const DffRecordHeader& Atom::getHeader() const
 211 {
 212     return maRecordHeader;
 213 }
 214
 215 inline const Atom* Atom::findFirstChildAtom( sal_uInt16 nRecType, sal_uInt16 nRecInstance ) const
 216 {
 217     return findNextChildAtom( nRecType, nRecInstance, NULL );
 218 }
 219
 220 inline const Atom* Atom::findFirstChildAtom() const
 221 {
 222     return mpFirstChild;
 223 }
 224
 225 inline const Atom* Atom::findNextChildAtom( const Atom* pLast ) const
 226 {
 227     return pLast ? pLast->mpNextAtom : pLast;
 228 }
 229
 230 inline bool Atom::isContainer() const
 231 {
 232     return (bool)maRecordHeader.IsContainer();
 233 }
 234
 235 inline bool Atom::seekToContent() const
 236 {
 237     maRecordHeader.SeekToContent( mrStream );
 238     return mrStream.GetError() == 0;
 239 }
 240
 241 inline sal_uInt16 Atom::getType() const
 242 {
 243     return maRecordHeader.nRecType;
 244 }
 245
 246 inline sal_uInt16 Atom::getInstance() const
 247 {
 248     return maRecordHeader.nRecInstance;
 249 }
 250
 251 inline sal_uInt32 Atom::getLength() const
 252 {
 253     return maRecordHeader.nRecLen;
 254 }
 255
 256 Atom::Atom( const DffRecordHeader& rRecordHeader, SvStream& rStream )
 257 : maRecordHeader( rRecordHeader ),
 258   mrStream( rStream ),
 259   mpFirstChild( 0 ),
 260   mpNextAtom( 0 ),
 261   meStatus( CMP_NOTYET ),
 262   mpCompareAtom( 0 )
 263 {
 264     // check if we need to force this to a container
 265     if( maRecordHeader.nRecVer != DFF_PSFLAG_CONTAINER )
 266     {
 267         AtomConfig* pAtomConfig = dynamic_cast< AtomConfig* >( gAtomConfigMap[ maRecordHeader.nRecType ].get() );
 268         if( pAtomConfig && pAtomConfig->isContainer() )
 269         {
 270             maRecordHeader.nRecVer = DFF_PSFLAG_CONTAINER;
 271         }
 272     }
 273
 274     if( isContainer() )
 275     {
 276         if( seekToContent() )
 277         {
 278             DffRecordHeader aChildHeader;
 279
 280             Atom* pLastAtom = NULL;
 281
 282             while( (mrStream.GetError() == 0 ) && ( mrStream.Tell() < maRecordHeader.GetRecEndFilePos() ) )
 283             {
 284                 mrStream >> aChildHeader;
 285
 286                 if( mrStream.GetError() == 0 )
 287                 {
 288                     Atom* pAtom = new Atom( aChildHeader, mrStream );
 289
 290                     if( pLastAtom )
 291                         pLastAtom->mpNextAtom = pAtom;
 292                     if( mpFirstChild == NULL )
 293                         mpFirstChild = pAtom;
 294
 295                     pLastAtom = pAtom;
 296                 }
 297             }
 298         }
 299     }
 300
 301     maRecordHeader.SeekToEndOfRecord( mrStream );
 302 }
 303
 304 Atom::~Atom()
 305 {
 306     Atom* pChild = mpFirstChild;
 307     while( pChild )
 308     {
 309         Atom* pNextChild = pChild->mpNextAtom;
 310         delete pChild;
 311         pChild = pNextChild;
 312     }
 313 }
 314
 315 /** imports this atom and its child atoms */
 316 Atom* Atom::import( const DffRecordHeader& rRootRecordHeader, SvStream& rStCtrl )
 317 {
 318     Atom* pRootAtom = new Atom( rRootRecordHeader, rStCtrl );
 319
 320     if( rStCtrl.GetError() == 0 )
 321     {
 322         return pRootAtom;
 323     }
 324     else
 325     {
 326         delete pRootAtom;
 327         return NULL;
 328     }
 329 }
 330
 331 /** imports this atom and its child atoms */
 332 Atom* Atom::import( UINT16 nRecType, SvStream& rStCtrl )
 333 {
 334     rStCtrl.Seek( STREAM_SEEK_TO_END );
 335     sal_Size nStreamLength = rStCtrl.Tell();
 336     rStCtrl.Seek( STREAM_SEEK_TO_BEGIN );
 337
 338     DffRecordHeader aRootRecordHeader;
 339     aRootRecordHeader.nRecVer = DFF_PSFLAG_CONTAINER;
 340     aRootRecordHeader.nRecInstance = 0;
 341     aRootRecordHeader.nImpVerInst = 0;
 342     aRootRecordHeader.nRecType = nRecType;
 343     aRootRecordHeader.nRecLen = nStreamLength;
 344     aRootRecordHeader.nFilePos = 0;
 345
 346     return import( aRootRecordHeader, rStCtrl );
 347 }
 348
 349 /** returns the next child atom after pLast with nRecType or NULL */
 350 const Atom* Atom::findNextChildAtom( sal_uInt16 nRecType, const Atom* pLast ) const
 351 {
 352     Atom* pChild = pLast != NULL ? pLast->mpNextAtom : mpFirstChild;
 353     while( pChild && pChild->maRecordHeader.nRecType != nRecType )
 354     {
 355         pChild = pChild->mpNextAtom;
 356     }
 357
 358     return pChild;
 359 }
 360
 361 /** returns the next child atom after pLast with nRecType and nRecInstance or NULL */
 362 const Atom* Atom::findNextChildAtom( sal_uInt16 nRecType, sal_uInt16 nRecInstance, const Atom* pLast ) const
 363 {
 364     const Atom* pChild = pLast != NULL ? pLast->mpNextAtom : mpFirstChild;
 365     while( pChild && (pChild->maRecordHeader.nRecType != nRecType) && (pChild->maRecordHeader.nRecInstance != nRecInstance) )
 366     {
 367         pChild = findNextChildAtom( pChild );
 368     }
 369
 370     return pChild;
 371 }
 372
 373 Atom* Atom::findFirstEqualAtom( Atom* pCompare, Atom* pContainer, Atom* pSearch, int& nDistance )
 374 {
 375     nDistance = 0;
 376
 377     while( pSearch )
 378     {
 379         if( *pSearch == *pCompare )
 380             return pSearch;
 381
 382         pSearch = const_cast< Atom* >( pContainer->findNextChildAtom( pSearch ) );
 383         nDistance++;
 384     }
 385
 386     return 0;
 387 }
 388
 389 Atom* Atom::skipAtoms( Atom* pContainer, Atom* pAtom, Atom* pSkipTo )
 390 {
 391     while( pAtom && (pAtom != pSkipTo) )
 392     {
 393         pAtom->meStatus = CMP_NOTAVAILABLE;
 394         pAtom = const_cast< Atom* >( pContainer->findNextChildAtom( pAtom ) );
 395     }
 396
 397     return pAtom;
 398 }
 399
 400 void Atom::compare( Atom* pAtom )
 401 {
 402     if( pAtom )
 403     {
 404         if( meStatus == CMP_NOTYET )
 405         {
 406             mpCompareAtom = pAtom;
 407             pAtom->mpCompareAtom = this;
 408
 409             mpCompareAtom = pAtom;
 410             pAtom->mpCompareAtom = this;
 411
 412             meStatus = pAtom->meStatus = ( *this == *pAtom ) ? CMP_EQUAL : CMP_NOTEQUAL;
 413         }
 414
 415         if(meStatus == CMP_EQUAL)
 416         {
 417             if( isContainer() )
 418             {
 419                 /** returns the first child atom or NULL */
 420                 Atom* pChildAtom1 = const_cast< Atom* >( findFirstChildAtom() );
 421
 422                 if( pChildAtom1 && (pChildAtom1->meStatus == CMP_NOTYET) )
 423                 {
 424                     Atom* pChildAtom2 = const_cast< Atom* >( pAtom->findFirstChildAtom() );
 425                     while( pChildAtom1 && pChildAtom2 )
 426                     {
 427                         if( !(*pChildAtom1 == *pChildAtom2) )
 428                         {
 429                             int nDistance1;
 430                             int nDistance2;
 431
 432                             Atom* pFind1 = findFirstEqualAtom( pChildAtom1, pAtom, const_cast< Atom* >( pAtom->findNextChildAtom( pChildAtom2 )), nDistance1 );
 433                             Atom* pFind2 = findFirstEqualAtom( pChildAtom2, this, const_cast< Atom* >(findNextChildAtom( pChildAtom1 )), nDistance2 );
 434
 435                             if( pFind1 && (!pFind2 || (nDistance1 < nDistance2) ) )
 436                             {
 437                                 pChildAtom2 = skipAtoms( pAtom, pChildAtom2, pFind1 );
 438                             }
 439                             else if( pFind2 )
 440                             {
 441                                 pChildAtom1 = skipAtoms( this, pChildAtom1, pFind2 );
 442                             }
 443                             else
 444                             {
 445                                 pChildAtom1 = skipAtoms( this, pChildAtom1, 0 );
 446                                 pChildAtom2 = skipAtoms( pAtom, pChildAtom2, 0 );
 447                             }
 448                         }
 449
 450                         if( pChildAtom1 && pChildAtom2 )
 451                         {
 452                             pChildAtom1->mpCompareAtom = pChildAtom2;
 453                             pChildAtom2->mpCompareAtom = pChildAtom1;
 454
 455                             pChildAtom1->meStatus = pChildAtom2->meStatus =
 456                                 (pChildAtom1->isContainer() || pChildAtom1->compareContent( *pChildAtom2 )) ?
 457                                     CMP_EQUAL : CMP_NOTEQUAL;
 458
 459                             pChildAtom1 = const_cast< Atom* >( findNextChildAtom( pChildAtom1 ) );
 460                             pChildAtom2 = const_cast< Atom* >( pAtom->findNextChildAtom( pChildAtom2 ) );
 461                         }
 462                     }
 463                 }
 464             }
 465             else
 466             {
 467                 if( !compareContent( *pAtom ) )
 468                 {
 469                     meStatus = pAtom->meStatus = CMP_NOTEQUAL;
 470                 }
 471             }
 472         }
 473     }
 474 }
 475
 476
 477
 478
 479
 480 class AtomBoxString : public SvLBoxString
 481 {
 482 public:
 483     AtomBoxString( SvTreeListEntry* pEntry, const String& rStr )
 484         : SvLBoxString( pEntry, 0, rStr )
 485     { }
 486
 487     ~AtomBoxString() { }
 488
 489     virtual void Paint(
 490         const Point& rPos, SvLBox& rOutDev, const SvViewDataEntry* pView, const SvTreeListEntry* pEntry)
 491     {
 492         Color aOldTextColor = rOutDev.GetTextColor();
 493
 494         if( pEntry && pEntry->GetUserData() )
 495         {
 496             Atom* pAtom = static_cast<Atom*>( pEntry->GetUserData() );
 497             rOutDev.SetTextColor( Color( gColors[ pAtom->getCompareStatus() ] ) );
 498         }
 499
 500         SvLBoxString::Paint(rPos, rOutDev, pView, pEntry);
 501
 502         rOutDev.SetTextColor( aOldTextColor );
 503     }
 504 };
 505
 506
 507
 508
 509 class AtomContainerTreeListBox : public SvTreeListBox
 510 {
 511 public:
 512     AtomContainerTreeListBox( vcl::Window* pParent );
 513     ~AtomContainerTreeListBox();
 514
 515     void SetRootAtom( const Atom* pAtom );
 516
 517
 518     void            SetCollapsingHdl(const Link<>& rNewHdl){maCollapsingHdl=rNewHdl;}
 519     const Link<>&   GetCollapsingHdl() const { return maCollapsingHdl; }
 520
 521     void            SetExpandingHdl(const Link<>& rNewHdl){maExpandingHdl=rNewHdl;}
 522     const Link<>&   GetExpandingHdl() const { return maExpandingHdl; }
 523
 524     virtual BOOL    Expand( SvTreeListEntry* pParent );
 525     virtual BOOL    Collapse( SvTreeListEntry* pParent );
 526
 527     SvTreeListEntry*    findAtom( Atom* pAtom );
 528
 529     virtual void InitEntry(SvTreeListEntry*, const OUString&, const Image&, const Image&);
 530     virtual void SetTabs();
 531
 532 private:
 533     void InsertAtom( const Atom* pAtom, SvTreeListEntry* pParent = 0 );
 534     const Atom* mpRootAtom;
 535     ResMgr* mpResMgr;
 536     Image maImgFolder;
 537     Image maImgAtom;
 538     Image maImgExpanded;
 539     Image maImgCollapsed;
 540     bool mbRecursiveGuard;
 541     Link<> maCollapsingHdl;
 542     Link<> maExpandingHdl;
 543 };
 544
 545 typedef std::pair< AtomContainerTreeListBox*, SvTreeListEntry* > AtomContainerEntryPair;
 546
 547 AtomContainerTreeListBox::AtomContainerTreeListBox( vcl::Window* pParent )
 548 : SvTreeListBox( pParent, WB_HASBUTTONS|WB_HASLINES|WB_HASBUTTONSATROOT|WB_3DLOOK|WB_BORDER ),
 549     mpRootAtom( 0 ), mbRecursiveGuard( false )
 550 {
 551     mpResMgr = ResMgr::CreateResMgr( "svt" );
 552     maImgCollapsed = Image( ResId( RID_IMG_TREENODE_COLLAPSED, mpResMgr ) );
 553     maImgExpanded = Image( ResId( RID_IMG_TREENODE_EXPANDED, mpResMgr ) );
 554
 555 //  SetDefaultExpandedEntryBmp( aExpanded );
 556 //  SetDefaultCollapsedEntryBmp(aCollapsed );
 557
 558     maImgFolder = Image( ResId( IMG_SVT_FOLDER, mpResMgr ) );
 559     maImgAtom = Image( ResId( IMG_SVT_DOCTEMPLATE_DOCINFO_SMALL, mpResMgr ) );
 560 }
 561
 562 AtomContainerTreeListBox::~AtomContainerTreeListBox()
 563 {
 564 }
 565
 566 void AtomContainerTreeListBox::SetTabs()
 567 {
 568     if( IsEditingActive() )
 569         EndEditing( TRUE );
 570
 571     ClearTabList();
 572
 573     short nIndent = 0; GetIndent();
 574     long nNodeWidthPixel = maImgCollapsed.GetSizePixel().Width();
 575     long nContextWidthDIV2 = nNodeWidthPixel >> 1;
 576
 577     long nStartPos = 2 + ( nIndent + nContextWidthDIV2 );
 578     AddTab( nStartPos, SvLBoxTabFlags::DYNAMIC | SvLBoxTabFlags::ADJUST_CENTER );
 579     nStartPos += nNodeWidthPixel + 5;
 580     AddTab( nStartPos, SvLBoxTabFlags::DYNAMIC | SvLBoxTabFlags::ADJUST_CENTER | SvLBoxTabFlags::SHOW_SELECTION );
 581     nStartPos += nContextWidthDIV2 + 5;
 582     AddTab( nStartPos, SvLBoxTabFlags::DYNAMIC|SvLBoxTabFlags::ADJUST_LEFT | SvLBoxTabFlags::SHOW_SELECTION );
 583 }
 584
 585 void AtomContainerTreeListBox::InitEntry(SvTreeListEntry* pEntry, const OUString& aStr,
 586     const Image& aCollEntryBmp, const Image& aExpEntryBmp)
 587 {
 588     pEntry->AddItem( new SvLBoxContextBmp(pEntry,0, aCollEntryBmp,aExpEntryBmp, true) );
 589     pEntry->AddItem( new SvLBoxContextBmp(pEntry,0, maImgAtom, maImgAtom, true) );
 590     pEntry->AddItem( new AtomBoxString( pEntry, aStr ) );
 591 }
 592
 593 SvTreeListEntry* AtomContainerTreeListBox::findAtom( Atom* pAtom )
 594 {
 595     SvTreeListEntry* pEntry = First();
 596     while( pEntry )
 597     {
 598         if( pEntry->GetUserData() == pAtom )
 599             return pEntry;
 600
 601         pEntry = Next( pEntry );
 602     }
 603
 604     return 0;
 605 }
 606
 607 BOOL AtomContainerTreeListBox::Expand( SvTreeListEntry* pParent )
 608 {
 609     BOOL bRet = FALSE;
 610     if( !mbRecursiveGuard )
 611     {
 612         mbRecursiveGuard = true;
 613         AtomContainerEntryPair aPair( this, pParent );
 614         maExpandingHdl.Call( &aPair);
 615
 616         bRet = SvTreeListBox::Expand( pParent );
 617         mbRecursiveGuard = false;
 618     }
 619     return bRet;
 620 }
 621
 622 BOOL AtomContainerTreeListBox::Collapse( SvTreeListEntry* pParent )
 623 {
 624     BOOL bRet = FALSE;
 625     if( !mbRecursiveGuard )
 626     {
 627         mbRecursiveGuard = true;
 628         AtomContainerEntryPair aPair( this, pParent );
 629         maCollapsingHdl.Call( &aPair);
 630
 631         bRet = SvTreeListBox::Collapse( pParent );
 632         mbRecursiveGuard = false;
 633     }
 634     return bRet;
 635 }
 636
 637 void AtomContainerTreeListBox::SetRootAtom( const Atom* pAtom )
 638 {
 639     mpRootAtom = pAtom;
 640     InsertAtom( mpRootAtom );
 641 }
 642
 643 void AtomContainerTreeListBox::InsertAtom( const Atom* pAtom, SvTreeListEntry* pParent /* = 0 */ )
 644 {
 645     if( pAtom )
 646     {
 647         const DffRecordHeader& rHeader = pAtom->getHeader();
 648
 649         char buffer[1024];
 650
 651         OUString aText;
 652         AtomConfig* pAtomConfig = dynamic_cast< AtomConfig*>( gAtomConfigMap[rHeader.nRecType].get() );
 653
 654         if( pAtomConfig )
 655             aText = pAtomConfig->getName();
 656
 657         if( !aText.getLength() )
 658         {
 659             sprintf( buffer, "unknown_0x%04x", rHeader.nRecType );
 660             aText += OUString::createFromAscii( buffer );
 661         }
 662
 663         sprintf( buffer, " (I: %lu L: %lu)", (UINT32)rHeader.nRecVer, (UINT32)rHeader.nRecLen );
 664         aText += String( OUString::createFromAscii( buffer ) );
 665
 666         SvTreeListEntry* pEntry = 0;
 667         if( pAtom->isContainer() && pAtom->findFirstChildAtom() )
 668         {
 669             pEntry = InsertEntry( aText, maImgExpanded, maImgCollapsed, pParent );
 670
 671             /** returns the first child atom or NULL */
 672             const Atom* pChildAtom = pAtom->findFirstChildAtom();
 673
 674             while( pChildAtom )
 675             {
 676                 InsertAtom( pChildAtom, pEntry );
 677                 pChildAtom = pAtom->findNextChildAtom( pChildAtom );
 678             }
 679         }
 680         else
 681         {
 682             pEntry = InsertEntry( aText, pParent );
 683         }
 684
 685         if( pEntry )
 686         {
 687             pEntry->SetUserData( (void*)pAtom );
 688
 689             if( pAtom->isContainer() )
 690             {
 691                 SvLBoxContextBmp* pBoxBmp = dynamic_cast< SvLBoxContextBmp* >( pEntry->GetItem( pEntry->ItemCount() - 2 ) );
 692                 if( pBoxBmp )
 693                 {
 694                     pBoxBmp->SetBitmap1( pEntry, maImgFolder );
 695                     pBoxBmp->SetBitmap2( pEntry, maImgFolder );
 696                 }
 697             }
 698
 699 /*
 700             pEntry->ReplaceItem(
 701                 new AtomBoxString( pEntry, aText, pImage ),
 702                 pEntry->ItemCount() - 1 );
 703 */
 704         }
 705     }
 706 }
 707
 708
 709
 710 extern void load_config( const OUString& rPath );
 711
 712 class PPTDocument
 713 {
 714 public:
 715     PPTDocument( const OUString& rFilePath );
 716     ~PPTDocument();
 717
 718     Atom* getRootAtom() const;
 719
 720 private:
 721     void Load( const OUString& rFilePath );
 722
 723     Atom* mpAtom;
 724     SvStream* mpDocStream;
 725     tools::SvRef<SotStorage> maStorage;
 726 };
 727
 728 typedef boost::shared_ptr< PPTDocument > PPTDocumentPtr;
 729
 730 PPTDocument::PPTDocument(const OUString& rFilePath)
 731 : mpAtom(0), mpDocStream(0)
 732 {
 733     Load( rFilePath );
 734 }
 735
 736 PPTDocument::~PPTDocument()
 737 {
 738     delete mpAtom;
 739     delete mpDocStream;
 740 }
 741
 742 void PPTDocument::Load( const OUString& rFilePath )
 743 {
 744     maStorage = new SotStorage( rFilePath, STREAM_STD_READ );
 745     if( !maStorage->GetError() )
 746     {
 747         mpDocStream = maStorage->OpenSotStream( String( "PowerPoint Document" ), STREAM_STD_READ );
 748         if( mpDocStream )
 749         {
 750             DffRecordHeader aRecordHeader;
 751             *mpDocStream >> aRecordHeader;
 752
 753             mpAtom = Atom::import( 65530, *mpDocStream );
 754         }
 755     }
 756 }
 757
 758 Atom* PPTDocument::getRootAtom() const
 759 {
 760     return mpAtom;
 761 }
 762
 763
 764
 765 class MSViewerWorkWindow : public WorkWindow
 766 {
 767 public:
 768     MSViewerWorkWindow();
 769     ~MSViewerWorkWindow();
 770
 771     PPTDocumentPtr Load();
 772     void onView();
 773     void onCompare();
 774     void onClose();
 775
 776     void View( const PPTDocumentPtr& pDocument, int nPane );
 777     void Compare( const PPTDocumentPtr& pDocument1, const PPTDocumentPtr& pDocument2 );
 778
 779     virtual void Resize();
 780
 781 private:
 782     void Sync( AtomContainerEntryPair* pPair, int nAction );
 783
 784     AtomContainerTreeListBox*   mpListBox[2];
 785     MultiLineEdit*              mpEdit[2];
 786     PPTDocumentPtr              mpDocument[2];
 787     MenuBar*                    mpMenuBar;
 788     PopupMenu*                  mpFileMenu;
 789     bool mbSelectHdlGuard;
 790     DECL_LINK( implSelectHdl, AtomContainerTreeListBox* );
 791     DECL_LINK( implExpandingHdl, AtomContainerEntryPair* );
 792     DECL_LINK( implCollapsingHdl, AtomContainerEntryPair* );
 793     DECL_LINK( implMenuHdl, Menu* );
 794 };
 795
 796
 797
 798 void MSViewerWorkWindow::onView()
 799 {
 800     PPTDocumentPtr pDocument( Load() );
 801     if( pDocument.get() )
 802     {
 803         onClose();
 804         View( pDocument, 0 );
 805     }
 806 }
 807
 808 void MSViewerWorkWindow::onClose()
 809 {
 810 }
 811
 812 void MSViewerWorkWindow::onCompare()
 813 {
 814     PPTDocumentPtr pDocument1( Load() );
 815     if( pDocument1.get() )
 816     {
 817         PPTDocumentPtr pDocument2( Load() );
 818         if( pDocument2.get() )
 819         {
 820             onClose();
 821             Compare( pDocument1, pDocument2 );
 822         }
 823     }
 824 }
 825
 826 void MSViewerWorkWindow::Compare( const PPTDocumentPtr& pDocument1, const PPTDocumentPtr& pDocument2 )
 827 {
 828     if( pDocument1.get() && pDocument2.get() )
 829     {
 830         Atom* pAtom1 = pDocument1->getRootAtom();
 831         Atom* pAtom2 = pDocument2->getRootAtom();
 832         pAtom1->setCompareAtom( pAtom2 );
 833         pAtom2->setCompareAtom( pAtom1 );
 834     }
 835
 836     View( pDocument1, 0 );
 837     View( pDocument2, 1 );
 838 }
 839
 840 void MSViewerWorkWindow::View( const PPTDocumentPtr& pDocument, int nPane )
 841 {
 842     if( ((nPane != 0) && (nPane != 1)) || (pDocument.get() == 0) )
 843         return;
 844
 845     mpDocument[nPane] = pDocument;
 846
 847     mpListBox[nPane]->SetRootAtom( pDocument->getRootAtom() );
 848     mpListBox[nPane]->Expand( mpListBox[nPane]->GetEntry(0) );
 849     mpListBox[nPane]->Show();
 850     mpEdit[nPane]->Show();
 851     Resize();
 852 }
 853
 854
 855 PPTDocumentPtr MSViewerWorkWindow::Load()
 856 {
 857     ::sfx2::FileDialogHelper aDlg(
 858         ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, 0 );
 859     String aStrFilterType(  "*.ppt"  );
 860     aDlg.AddFilter( aStrFilterType, aStrFilterType );
 861 //  INetURLObject aFile( SvtPathOptions().GetPalettePath() );
 862 //  aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::NO_DECODE ) );
 863
 864     PPTDocumentPtr pDocument;
 865     if ( aDlg.Execute() == ERRCODE_NONE )
 866     {
 867         pDocument.reset( new PPTDocument( aDlg.GetPath() ) );
 868     }
 869
 870     return pDocument;
 871 }
 872
 873
 874
 875 MSViewerWorkWindow::MSViewerWorkWindow() :
 876     WorkWindow( 0, WB_APP | WB_STDWORK | WB_3DLOOK ),mbSelectHdlGuard(false)
 877 {
 878     Size aOutputSize( 400, 600 );
 879     SetOutputSizePixel( aOutputSize );
 880     SetText( String(  "MSViewer"  ) );
 881
 882     Size aOutSize( GetOutputSizePixel() );
 883
 884     Font aFont( String(  "Courier"  ), GetFont().GetSize() );
 885
 886     mpMenuBar = new MenuBar();
 887     mpMenuBar->InsertItem( 1, String( "~File"  ) );
 888     mpFileMenu = new PopupMenu();
 889     mpFileMenu->InsertItem( 2, String( "~View"  ) );
 890     mpFileMenu->InsertItem( 3, String( "~Compare"  ) );
 891     mpFileMenu->InsertSeparator();
 892     mpFileMenu->InsertItem( 4, String( "~Quit"  ) );
 893     mpFileMenu->SetSelectHdl( LINK( this, MSViewerWorkWindow, implMenuHdl ) );
 894
 895     mpMenuBar->SetPopupMenu( 1, mpFileMenu );
 896     SetMenuBar( mpMenuBar );
 897     int nPane;
 898     for( nPane = 0; nPane < 2; nPane++ )
 899     {
 900         mpListBox[nPane] = new AtomContainerTreeListBox( this );
 901         mpListBox[nPane]->SetSelectHdl( LINK( this, MSViewerWorkWindow, implSelectHdl ) );
 902         mpListBox[nPane]->SetExpandingHdl( LINK( this, MSViewerWorkWindow, implExpandingHdl ) );
 903         mpListBox[nPane]->SetCollapsingHdl( LINK( this, MSViewerWorkWindow, implCollapsingHdl ) );
 904
 905         mpEdit[nPane] = VclPtr<MultiLineEdit>::Create(this, WB_3DLOOK | WB_BORDER | WB_LEFT | WB_TOP | WB_READONLY | WB_HSCROLL | WB_VSCROLL );
 906         mpEdit[nPane]->SetReadOnly( TRUE );
 907         mpEdit[nPane]->SetReadOnly( TRUE );
 908         mpEdit[nPane]->SetControlFont( aFont );
 909     }
 910 }
 911
 912
 913
 914 static String GetAtomText( const Atom* pAtom )
 915 {
 916     String aText;
 917     if( pAtom )
 918     {
 919         const DffRecordHeader& rHeader = pAtom->getHeader();
 920         char buffer[512];
 921         sprintf( buffer, "Version = %lu\n\rInstance = %lu\n\rVersionInstance = %lu\n\rLength = %lu\n\r",
 922         (UINT32)rHeader.nRecVer,
 923         (UINT32)rHeader.nRecInstance,
 924         (UINT32)rHeader.nImpVerInst,
 925         (UINT32)rHeader.nRecLen );
 926         aText = OUString::createFromAscii( buffer );
 927         if( pAtom->isContainer() )
 928         {
 929
 930         }
 931         else
 932         {
 933             pAtom->seekToContent();
 934             AtomConfig* pAtomConfig = dynamic_cast< AtomConfig* >( gAtomConfigMap[pAtom->getType()].get() );
 935             if( pAtomConfig )
 936             {
 937                 sal_Size nLength = pAtom->getLength();
 938                 aText += String( pAtomConfig->format( pAtom->getStream(), nLength ) );
 939             }
 940             else
 941             {
 942                 sal_Size nLength = pAtom->getLength();
 943                 aText += String( ElementConfig::dump_hex( pAtom->getStream(), nLength ) );
 944             }
 945         }
 946     }
 947
 948     return aText;
 949 }
 950
 951 IMPL_LINK(MSViewerWorkWindow,implSelectHdl, AtomContainerTreeListBox*, pListBox )
 952 {
 953     int nPane = (pListBox == mpListBox[1]) ? 1 : 0;
 954     SvTreeListEntry* pEntry = mpListBox[nPane]->FirstSelected();
 955     if( pEntry && pEntry->GetUserData() )
 956     {
 957         Atom* pAtom = static_cast<Atom*>( pEntry->GetUserData() );
 958         mpEdit[nPane]->SetText( GetAtomText( pAtom ) );
 959
 960         if(!mbSelectHdlGuard)
 961         {
 962             mbSelectHdlGuard = true;
 963             // select other
 964             AtomContainerEntryPair aPair( pListBox, pEntry );
 965             Sync( &aPair, 2 );
 966             mbSelectHdlGuard = false;
 967         }
 968     }
 969     return 0;
 970 }
 971
 972 void MSViewerWorkWindow::Sync( AtomContainerEntryPair* pPair, int nAction )
 973 {
 974     if( mpDocument[0].get() && mpDocument[1].get() && pPair->first && pPair->second )
 975     {
 976         AtomContainerTreeListBox* pDestinationListBox = (pPair->first == mpListBox[0]) ? mpListBox[1] : mpListBox[0];
 977
 978         Atom* pAtom = static_cast<Atom*>(pPair->second->GetUserData());
 979         if( pAtom && pAtom->getCompareAtom() )
 980         {
 981             SvTreeListEntry* pEntry = pDestinationListBox->findAtom( pAtom->getCompareAtom() );
 982
 983             if(pEntry )
 984             {
 985                 if( nAction == 0 )
 986                 {
 987                     pDestinationListBox->Expand( pEntry );
 988                 }
 989                 else if( nAction == 1 )
 990                 {
 991                     pDestinationListBox->Collapse( pEntry );
 992                 }
 993                 else
 994                 {
 995                     pDestinationListBox->Select( pEntry );
 996                 }
 997             }
 998         }
 999     }
1000 }
1001
1002 IMPL_LINK(MSViewerWorkWindow, implExpandingHdl, AtomContainerEntryPair*, pPair )
1003 {
1004     SvTreeListEntry* pEntry = pPair->second;
1005     if( pEntry && pEntry->GetUserData() )
1006     {
1007         Atom* pAtom = static_cast<Atom*>( pEntry->GetUserData() );
1008         pAtom->compare( pAtom->getCompareAtom() );
1009     }
1010
1011     Sync( pPair, 0 );
1012
1013     return 0;
1014 }
1015
1016 IMPL_LINK(MSViewerWorkWindow, implCollapsingHdl, AtomContainerEntryPair*, pPair )
1017 {
1018     Sync( pPair, 1 );
1019
1020     return 0;
1021 }
1022
1023 IMPL_LINK( MSViewerWorkWindow, implMenuHdl, Menu*, pMenu )
1024 {
1025     if( pMenu )
1026     {
1027         USHORT nId = pMenu->GetCurItemId();
1028         switch( nId )
1029         {
1030         case 2: onView(); break;
1031         case 3: onCompare(); break;
1032         case 4: Application::Quit(); break;
1033         }
1034     }
1035     return 0;
1036 }
1037
1038
1039
1040 MSViewerWorkWindow::~MSViewerWorkWindow()
1041 {
1042     int nPane;
1043     for( nPane = 0; nPane < 2; nPane++ )
1044     {
1045         delete mpListBox[nPane];
1046         delete mpEdit[nPane];
1047     }
1048
1049     delete mpFileMenu;
1050     delete mpMenuBar;
1051 }
1052
1053
1054
1055 void MSViewerWorkWindow::Resize()
1056 {
1057     int nPaneCount = ((mpDocument[0].get() != 0) ? 1 : 0) + ((mpDocument[1].get() != 0) ? 1 : 0);
1058
1059     Size aOutputSize( GetOutputSizePixel() );
1060     int nHeight = aOutputSize.Height() >> 1;
1061     if( nPaneCount )
1062     {
1063         int nWidth = aOutputSize.Width();
1064         if( nPaneCount == 2 )
1065             nWidth >>= 1;
1066
1067         int nPosX = 0;
1068
1069         int nPane;
1070         for( nPane = 0; nPane < 2; nPane++ )
1071         {
1072             mpListBox[nPane]->SetPosSizePixel( nPosX,0, nWidth, nHeight );
1073             mpEdit[nPane]->SetPosSizePixel( nPosX, nHeight, nWidth, aOutputSize.Height() - nHeight );
1074             nPosX += nWidth;
1075         }
1076     }
1077 }
1078
1079
1080
1081
1082
1083     SAL_IMPLEMENT_MAIN()
1084 {
1085     if( argc > 3 )
1086         return 0;
1087
1088     uno::Reference< lang::XMultiServiceFactory > xMSF;
1089     try
1090     {
1091         uno::Reference< uno::XComponentContext > xCtx( cppu::defaultBootstrap_InitialComponentContext() );
1092         if ( !xCtx.is() )
1093         {
1094             OSL_FAIL( "Error creating initial component context!" );
1095             return -1;
1096         }
1097
1098         xMSF = uno::Reference< lang::XMultiServiceFactory >(xCtx->getServiceManager(), uno::UNO_QUERY );
1099
1100         if ( !xMSF.is() )
1101         {
1102             OSL_FAIL( "No service manager!" );
1103             return -1;
1104         }
1105     }
1106     catch ( uno::Exception const & )
1107     {
1108         OSL_FAIL( "Exception during creation of initial component context!" );
1109         return -1;
1110     }
1111     comphelper::setProcessServiceFactory( xMSF );
1112
1113     InitVCL();
1114
1115     String aConfigURL;
1116     if( ::utl::LocalFileHelper::ConvertPhysicalNameToURL( Application::GetAppFileName(), aConfigURL ) )
1117     {
1118         INetURLObject aURL( aConfigURL );
1119
1120         aURL.removeSegment();
1121         aURL.removeFinalSlash();
1122         aURL.Append( String(   "msview.xml"   ) );
1123
1124         load_config( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
1125     }
1126
1127     {
1128         MSViewerWorkWindow aMainWindow;
1129
1130         if( argc >= 2 )
1131         {
1132             const OUString aFile1( OUString::createFromAscii(argv[1]) );
1133             PPTDocumentPtr pDocument1( new PPTDocument(  aFile1 ) );
1134
1135             if( argc == 3 )
1136             {
1137                 const OUString aFile2( OUString::createFromAscii(argv[2]) );
1138
1139                 PPTDocumentPtr pDocument2;
1140                 pDocument2.reset( new PPTDocument( aFile2 ) );
1141                 aMainWindow.Compare( pDocument1, pDocument2 );
1142             }
1143             else
1144             {
1145                 aMainWindow.View( pDocument1, 0 );
1146             }
1147         }
1148
1149         aMainWindow.Show();
1150
1151         Application::Execute();
1152     }
1153
1154     DeInitVCL();
1155
1156     return 0;
1157 }
1158
1159 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */