dbaccess/source/core/recovery/subcomponentrecovery.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 #include "subcomponentrecovery.hxx"
  21
  22 #include "sdbcoretools.hxx"
  23 #include "storagexmlstream.hxx"
  24 #include "subcomponentloader.hxx"
  25 #include "settingsimport.hxx"
  26
  27 #include <com/sun/star/embed/ElementModes.hpp>
  28 #include <com/sun/star/frame/ModuleManager.hpp>
  29 #include <com/sun/star/document/XStorageBasedDocument.hpp>
  30 #include <com/sun/star/ucb/XCommandProcessor.hpp>
  31 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  32 #include <com/sun/star/sdb/XFormDocumentsSupplier.hpp>
  33 #include <com/sun/star/sdb/XReportDocumentsSupplier.hpp>
  34 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
  35
  36 #include <comphelper/namedvaluecollection.hxx>
  37 #include <cppuhelper/implbase.hxx>
  38 #include <connectivity/dbtools.hxx>
  39 #include <tools/diagnose_ex.h>
  40 #include <xmloff/XMLSettingsExportContext.hxx>
  41 #include <xmloff/SettingsExportHelper.hxx>
  42
  43 #include <stack>
  44
  45 namespace dbaccess
  46 {
  47
  48     using css::uno::Reference;
  49     using css::uno::XInterface;
  50     using css::uno::UNO_QUERY;
  51     using css::uno::UNO_QUERY_THROW;
  52     using css::uno::UNO_SET_THROW;
  53     using css::uno::Exception;
  54     using css::uno::RuntimeException;
  55     using css::uno::Any;
  56     using css::uno::Sequence;
  57     using css::uno::XComponentContext;
  58     using css::embed::XStorage;
  59     using css::sdb::application::XDatabaseDocumentUI;
  60     using css::beans::Pair;
  61     using css::frame::ModuleManager;
  62     using css::frame::XModuleManager2;
  63     using css::lang::XComponent;
  64     using css::frame::XModel;
  65     using css::frame::XController;
  66     using css::beans::XPropertySet;
  67     using css::beans::PropertyValue;
  68     using css::document::XStorageBasedDocument;
  69     using css::ucb::XCommandProcessor;
  70     using css::container::XHierarchicalNameAccess;
  71     using css::sdb::XFormDocumentsSupplier;
  72     using css::sdb::XReportDocumentsSupplier;
  73     using css::xml::sax::SAXException;
  74     using css::xml::sax::XLocator;
  75     using css::xml::sax::XDocumentHandler;
  76     using css::xml::sax::XAttributeList;
  77
  78     namespace ElementModes = css::embed::ElementModes;
  79     namespace DatabaseObject = css::sdb::application::DatabaseObject;
  80
  81     // helper
  82     namespace
  83     {
  84         OUString lcl_getComponentStorageBaseName( const SubComponentType i_eType )
  85         {
  86             switch ( i_eType )
  87             {
  88             case FORM:
  89                 return OUString("form");
  90             case REPORT:
  91                 return OUString("report");
  92             case TABLE:
  93                 return OUString("table");
  94             case QUERY:
  95                 return OUString("query");
  96             default:
  97                 break;
  98             }
  99
 100             OSL_FAIL( "lcl_getComponentStorageBaseName: unimplemented case!" );
 101             return OUString();
 102         }
 103
 104         SubComponentType lcl_databaseObjectToSubComponentType( const sal_Int32 i_nObjectType )
 105         {
 106             switch ( i_nObjectType )
 107             {
 108             case DatabaseObject::TABLE: return TABLE;
 109             case DatabaseObject::QUERY: return QUERY;
 110             case DatabaseObject::FORM:  return FORM;
 111             case DatabaseObject::REPORT:return REPORT;
 112             default:
 113                 break;
 114             }
 115             return UNKNOWN;
 116         }
 117
 118         bool lcl_determineReadOnly( const Reference< XComponent >& i_rComponent )
 119         {
 120             Reference< XModel > xDocument( i_rComponent, UNO_QUERY );
 121             if ( !xDocument.is() )
 122             {
 123                 Reference< XController > xController( i_rComponent, UNO_QUERY_THROW );
 124                 xDocument = xController->getModel();
 125             }
 126
 127             if ( !xDocument.is() )
 128                 return false;
 129
 130             ::comphelper::NamedValueCollection aDocArgs( xDocument->getArgs() );
 131             return aDocArgs.getOrDefault( "ReadOnly", false );
 132         }
 133
 134         Reference< XCommandProcessor > lcl_getSubComponentDef_nothrow( const Reference< XDatabaseDocumentUI >& i_rAppUI,
 135             const SubComponentType i_eType, const OUString& i_rName )
 136         {
 137             Reference< XController > xController( i_rAppUI, UNO_QUERY_THROW );
 138             ENSURE_OR_RETURN( ( i_eType == FORM ) || ( i_eType == REPORT ), "lcl_getSubComponentDef_nothrow: illegal controller", nullptr );
 139
 140             Reference< XCommandProcessor > xCommandProcessor;
 141             try
 142             {
 143                 Reference< XHierarchicalNameAccess > xDefinitionContainer;
 144                 if ( i_eType == FORM )
 145                 {
 146                     Reference< XFormDocumentsSupplier > xSuppForms( xController->getModel(), UNO_QUERY_THROW );
 147                     xDefinitionContainer.set( xSuppForms->getFormDocuments(), UNO_QUERY_THROW );
 148                 }
 149                 else
 150                 {
 151                     Reference< XReportDocumentsSupplier > xSuppReports( xController->getModel(), UNO_QUERY_THROW );
 152                     xDefinitionContainer.set( xSuppReports->getReportDocuments(), UNO_QUERY_THROW );
 153                 }
 154                 xCommandProcessor.set( xDefinitionContainer->getByHierarchicalName( i_rName ), UNO_QUERY_THROW );
 155             }
 156             catch( const Exception& )
 157             {
 158                 DBG_UNHANDLED_EXCEPTION();
 159             }
 160             return xCommandProcessor;
 161         }
 162
 163         static const char sSettingsStreamName[] = "settings.xml";
 164         static const char sCurrentQueryDesignName[] = "ooo:current-query-design";
 165     }
 166
 167     // SettingsExportContext
 168     class SettingsExportContext : public ::xmloff::XMLSettingsExportContext
 169     {
 170     public:
 171         SettingsExportContext( const Reference<XComponentContext>& i_rContext, const StorageXMLOutputStream& i_rDelegator )
 172             :m_rContext( i_rContext )
 173             ,m_rDelegator( i_rDelegator )
 174             ,m_aNamespace( ::xmloff::token::GetXMLToken( ::xmloff::token::XML_NP_CONFIG ) )
 175         {
 176         }
 177
 178         virtual ~SettingsExportContext()
 179         {
 180         }
 181
 182     public:
 183         virtual void    AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName, const OUString& i_rValue ) override;
 184         virtual void    AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName, enum ::xmloff::token::XMLTokenEnum i_eValue ) override;
 185         virtual void    StartElement( enum ::xmloff::token::XMLTokenEnum i_eName ) override;
 186         virtual void    EndElement  ( const bool i_bIgnoreWhitespace ) override;
 187         virtual void    Characters( const OUString& i_rCharacters ) override;
 188
 189         virtual css::uno::Reference< css::uno::XComponentContext >
 190                         GetComponentContext() const override;
 191
 192     private:
 193         OUString impl_prefix( const ::xmloff::token::XMLTokenEnum i_eToken )
 194         {
 195             return m_aNamespace + ":" + ::xmloff::token::GetXMLToken( i_eToken );
 196         }
 197
 198     private:
 199         const Reference<XComponentContext>&   m_rContext;
 200         const StorageXMLOutputStream&           m_rDelegator;
 201         const OUString m_aNamespace;
 202     };
 203
 204     void SettingsExportContext::AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName, const OUString& i_rValue )
 205     {
 206         m_rDelegator.addAttribute( impl_prefix( i_eName ), i_rValue );
 207     }
 208
 209     void SettingsExportContext::AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName, enum ::xmloff::token::XMLTokenEnum i_eValue )
 210     {
 211         m_rDelegator.addAttribute( impl_prefix( i_eName ), ::xmloff::token::GetXMLToken( i_eValue ) );
 212     }
 213
 214     void SettingsExportContext::StartElement( enum ::xmloff::token::XMLTokenEnum i_eName )
 215     {
 216         m_rDelegator.ignorableWhitespace( " " );
 217
 218         m_rDelegator.startElement( impl_prefix( i_eName ) );
 219     }
 220
 221     void SettingsExportContext::EndElement( const bool i_bIgnoreWhitespace )
 222     {
 223         if ( i_bIgnoreWhitespace )
 224             m_rDelegator.ignorableWhitespace( " " );
 225         m_rDelegator.endElement();
 226     }
 227
 228     void SettingsExportContext::Characters( const OUString& i_rCharacters )
 229     {
 230         m_rDelegator.characters( i_rCharacters );
 231     }
 232
 233     Reference< css::uno::XComponentContext > SettingsExportContext::GetComponentContext() const
 234     {
 235         return m_rContext;
 236     }
 237
 238     // SettingsDocumentHandler
 239     typedef ::cppu::WeakImplHelper<   XDocumentHandler
 240                                   >   SettingsDocumentHandler_Base;
 241     class SettingsDocumentHandler : public SettingsDocumentHandler_Base
 242     {
 243     public:
 244         SettingsDocumentHandler()
 245         {
 246         }
 247
 248     protected:
 249         virtual ~SettingsDocumentHandler() override
 250         {
 251         }
 252
 253     public:
 254         // XDocumentHandler
 255         virtual void SAL_CALL startDocument(  ) throw (SAXException, RuntimeException, std::exception) override;
 256         virtual void SAL_CALL endDocument(  ) throw (SAXException, RuntimeException, std::exception) override;
 257         virtual void SAL_CALL startElement( const OUString& aName, const Reference< XAttributeList >& xAttribs ) throw (SAXException, RuntimeException, std::exception) override;
 258         virtual void SAL_CALL endElement( const OUString& aName ) throw (SAXException, RuntimeException, std::exception) override;
 259         virtual void SAL_CALL characters( const OUString& aChars ) throw (SAXException, RuntimeException, std::exception) override;
 260         virtual void SAL_CALL ignorableWhitespace( const OUString& aWhitespaces ) throw (SAXException, RuntimeException, std::exception) override;
 261         virtual void SAL_CALL processingInstruction( const OUString& aTarget, const OUString& aData ) throw (SAXException, RuntimeException, std::exception) override;
 262         virtual void SAL_CALL setDocumentLocator( const Reference< XLocator >& xLocator ) throw (SAXException, RuntimeException, std::exception) override;
 263
 264         const ::comphelper::NamedValueCollection&   getSettings() const { return m_aSettings; }
 265
 266     private:
 267         ::std::stack< ::rtl::Reference< SettingsImport > >  m_aStates;
 268         ::comphelper::NamedValueCollection                  m_aSettings;
 269     };
 270
 271     void SAL_CALL SettingsDocumentHandler::startDocument(  ) throw (SAXException, RuntimeException, std::exception)
 272     {
 273     }
 274
 275     void SAL_CALL SettingsDocumentHandler::endDocument(  ) throw (SAXException, RuntimeException, std::exception)
 276     {
 277     }
 278
 279     void SAL_CALL SettingsDocumentHandler::startElement( const OUString& i_Name, const Reference< XAttributeList >& i_Attribs ) throw (SAXException, RuntimeException, std::exception)
 280     {
 281         ::rtl::Reference< SettingsImport >  pNewState;
 282
 283         if ( m_aStates.empty() )
 284         {
 285             if ( i_Name == "office:settings" )
 286             {
 287                 pNewState = new OfficeSettingsImport( m_aSettings );
 288             }
 289             else
 290             {
 291                 OSL_FAIL( "SettingsDocumentHandler::startElement: invalid settings file!" );
 292                 // Yes, that's not correct. Somebody could, in theory, give us a document which starts with "foo:settings",
 293                 // where "foo" is mapped to the proper namespace URL.
 294                 // However, there's no need to bother with this. The "recovery" sub storage we're recovering from is
 295                 // not part of ODF, so we can impose any format restrictions on it ...
 296             }
 297         }
 298         else
 299         {
 300             ::rtl::Reference< SettingsImport > pCurrentState( m_aStates.top() );
 301             pNewState = pCurrentState->nextState( i_Name );
 302         }
 303
 304         ENSURE_OR_THROW( pNewState.is(), "no new state - aborting import" );
 305         pNewState->startElement( i_Attribs );
 306
 307         m_aStates.push( pNewState );
 308     }
 309
 310     void SAL_CALL SettingsDocumentHandler::endElement( const OUString& i_Name ) throw (SAXException, RuntimeException, std::exception)
 311     {
 312         ENSURE_OR_THROW( !m_aStates.empty(), "no active element" );
 313         (void)i_Name;
 314
 315         ::rtl::Reference< SettingsImport > pCurrentState( m_aStates.top() );
 316         pCurrentState->endElement();
 317         m_aStates.pop();
 318     }
 319
 320     void SAL_CALL SettingsDocumentHandler::characters( const OUString& i_Chars ) throw (SAXException, RuntimeException, std::exception)
 321     {
 322         ENSURE_OR_THROW( !m_aStates.empty(), "no active element" );
 323
 324         ::rtl::Reference< SettingsImport > pCurrentState( m_aStates.top() );
 325         pCurrentState->characters( i_Chars );
 326     }
 327
 328     void SAL_CALL SettingsDocumentHandler::ignorableWhitespace( const OUString& aWhitespaces ) throw (SAXException, RuntimeException, std::exception)
 329     {
 330         // ignore them - that's why they're called "ignorable"
 331         (void)aWhitespaces;
 332     }
 333
 334     void SAL_CALL SettingsDocumentHandler::processingInstruction( const OUString& i_Target, const OUString& i_Data ) throw (SAXException, RuntimeException, std::exception)
 335     {
 336         OSL_FAIL( "SettingsDocumentHandler::processingInstruction: unexpected ..." );
 337         (void)i_Target;
 338         (void)i_Data;
 339     }
 340
 341     void SAL_CALL SettingsDocumentHandler::setDocumentLocator( const Reference< XLocator >& i_Locator ) throw (SAXException, RuntimeException, std::exception)
 342     {
 343         (void)i_Locator;
 344     }
 345
 346     // SubComponentRecovery
 347     const OUString SubComponentRecovery::getComponentsStorageName( const SubComponentType i_eType )
 348     {
 349         switch ( i_eType )
 350         {
 351         case FORM:
 352             return OUString("forms");
 353         case REPORT:
 354             return OUString("reports");
 355         case TABLE:
 356             return OUString("tables");
 357         case QUERY:
 358             return OUString("queries");
 359         case RELATION_DESIGN:
 360             return OUString("relations");
 361         default:
 362             break;
 363         }
 364
 365         OSL_FAIL( "SubComponentRecovery::getComponentsStorageName: unimplemented case!" );
 366         return OUString();
 367     }
 368
 369     void SubComponentRecovery::saveToRecoveryStorage( const Reference< XStorage >& i_rRecoveryStorage,
 370         MapCompTypeToCompDescs& io_mapCompDescs )
 371     {
 372         if ( m_eType == UNKNOWN )
 373             // quite fatal, but has already been reported (as assertion) before
 374             return;
 375
 376         // open the sub storage for the given kind of components
 377         const OUString& rStorageName( getComponentsStorageName( m_eType ) );
 378         const Reference< XStorage > xComponentsStorage( i_rRecoveryStorage->openStorageElement(
 379             rStorageName, ElementModes::READWRITE ), UNO_QUERY_THROW );
 380
 381         // find a free sub storage name, and create Yet Another Sub Storage
 382         const OUString& rBaseName( lcl_getComponentStorageBaseName( m_eType ) );
 383         const OUString sStorName = ::dbtools::createUniqueName( xComponentsStorage.get(), rBaseName );
 384         const Reference< XStorage > xObjectStor( xComponentsStorage->openStorageElement(
 385             sStorName, ElementModes::READWRITE ), UNO_QUERY_THROW );
 386
 387         switch ( m_eType )
 388         {
 389         case FORM:
 390         case REPORT:
 391             impl_saveSubDocument_throw( xObjectStor );
 392             break;
 393
 394         case QUERY:
 395             impl_saveQueryDesign_throw( xObjectStor );
 396             break;
 397
 398         default:
 399             // TODO
 400             OSL_FAIL( "SubComponentRecoverys::saveToRecoveryStorage: unimplemented case!" );
 401             break;
 402         }
 403
 404         // commit the storage(s)
 405         tools::stor::commitStorageIfWriteable( xObjectStor );
 406         tools::stor::commitStorageIfWriteable( xComponentsStorage );
 407
 408         // remember the relationship from the component name to the storage name
 409         MapStringToCompDesc& rMapCompDescs = io_mapCompDescs[ m_eType ];
 410         OSL_ENSURE( rMapCompDescs.find( sStorName ) == rMapCompDescs.end(),
 411             "SubComponentRecoverys::saveToRecoveryStorage: object name already used!" );
 412         rMapCompDescs[ sStorName ] = m_aCompDesc;
 413     }
 414
 415     void SubComponentRecovery::impl_identifyComponent_throw()
 416     {
 417         // ask the controller
 418         Pair< sal_Int32, OUString > aComponentIdentity = m_xDocumentUI->identifySubComponent( m_xComponent );
 419         m_eType = lcl_databaseObjectToSubComponentType( aComponentIdentity.First );
 420         m_aCompDesc.sName = aComponentIdentity.Second;
 421
 422         // what the controller didn't give us is the information whether this is in edit mode or not ...
 423         Reference< XModuleManager2 > xModuleManager( ModuleManager::create(m_rContext) );
 424         const OUString sModuleIdentifier = xModuleManager->identify( m_xComponent );
 425
 426         switch ( m_eType )
 427         {
 428         case TABLE:
 429             m_aCompDesc.bForEditing = sModuleIdentifier == "com.sun.star.sdb.TableDesign";
 430             break;
 431
 432         case QUERY:
 433             m_aCompDesc.bForEditing = sModuleIdentifier == "com.sun.star.sdb.QueryDesign";
 434             break;
 435
 436         case REPORT:
 437             if ( sModuleIdentifier == "com.sun.star.report.ReportDefinition" )
 438             {
 439                 // it's an SRB report designer
 440                 m_aCompDesc.bForEditing = true;
 441                 break;
 442             }
 443             SAL_FALLTHROUGH;
 444
 445         case FORM:
 446             m_aCompDesc.bForEditing = !lcl_determineReadOnly( m_xComponent );
 447             break;
 448
 449         default:
 450             if ( sModuleIdentifier == "com.sun.star.sdb.RelationDesign" )
 451             {
 452                 m_eType = RELATION_DESIGN;
 453                 m_aCompDesc.bForEditing = true;
 454             }
 455             else
 456             {
 457                 OSL_FAIL( "SubComponentRecovery::impl_identifyComponent_throw: couldn't classify the given sub component!" );
 458             }
 459             break;
 460         }
 461
 462         SAL_WARN_IF( m_eType == UNKNOWN, "dbaccess",
 463             "SubComponentRecovery::impl_identifyComponent_throw: couldn't classify the component!" );
 464     }
 465
 466     void SubComponentRecovery::impl_saveQueryDesign_throw( const Reference< XStorage >& i_rObjectStorage )
 467     {
 468         ENSURE_OR_THROW( m_eType == QUERY, "illegal sub component type" );
 469         ENSURE_OR_THROW( i_rObjectStorage.is(), "illegal storage" );
 470
 471         // retrieve the current query design (which might differ from what we can retrieve as ActiveCommand property, since
 472         // the latter is updated only upon successful save of the design)
 473         Reference< XPropertySet > xDesignerProps( m_xComponent, UNO_QUERY_THROW );
 474         Sequence< PropertyValue > aCurrentQueryDesign;
 475         OSL_VERIFY( xDesignerProps->getPropertyValue( "CurrentQueryDesign" ) >>= aCurrentQueryDesign );
 476
 477         // write the query design
 478         StorageXMLOutputStream aDesignOutput( m_rContext, i_rObjectStorage, sSettingsStreamName );
 479         SettingsExportContext aSettingsExportContext( m_rContext, aDesignOutput );
 480
 481         const OUString sWhitespace( " " );
 482
 483         aDesignOutput.startElement( "office:settings" );
 484         aDesignOutput.ignorableWhitespace( sWhitespace );
 485
 486         XMLSettingsExportHelper aSettingsExporter( aSettingsExportContext );
 487         aSettingsExporter.exportAllSettings( aCurrentQueryDesign, sCurrentQueryDesignName );
 488
 489         aDesignOutput.ignorableWhitespace( sWhitespace );
 490         aDesignOutput.endElement();
 491         aDesignOutput.close();
 492     }
 493
 494     void SubComponentRecovery::impl_saveSubDocument_throw( const Reference< XStorage >& i_rObjectStorage )
 495     {
 496         ENSURE_OR_THROW( ( m_eType == FORM ) || ( m_eType == REPORT ), "illegal sub component type" );
 497         ENSURE_OR_THROW( i_rObjectStorage.is(), "illegal storage" );
 498
 499         // store the document into the storage
 500         Reference< XStorageBasedDocument > xStorageDocument( m_xComponent, UNO_QUERY_THROW );
 501         xStorageDocument->storeToStorage( i_rObjectStorage, Sequence< PropertyValue >() );
 502     }
 503
 504     Reference< XComponent > SubComponentRecovery::impl_recoverSubDocument_throw( const Reference< XStorage >& i_rRecoveryStorage,
 505             const OUString& i_rComponentName, const bool i_bForEditing )
 506     {
 507         Reference< XComponent > xSubComponent;
 508         Reference< XCommandProcessor > xDocDefinition;
 509
 510         ::comphelper::NamedValueCollection aLoadArgs;
 511         aLoadArgs.put( "RecoveryStorage", i_rRecoveryStorage );
 512
 513         // load/create the sub component hidden. We'll show it when the main app window is shown.
 514         aLoadArgs.put( "Hidden", true );
 515
 516         if ( !i_rComponentName.isEmpty() )
 517         {
 518             xDocDefinition = lcl_getSubComponentDef_nothrow( m_xDocumentUI, m_eType, i_rComponentName );
 519             xSubComponent.set( m_xDocumentUI->loadComponentWithArguments(
 520                     m_eType,
 521                     i_rComponentName,
 522                     i_bForEditing,
 523                     aLoadArgs.getPropertyValues()
 524                 ),
 525                 UNO_SET_THROW
 526             );
 527         }
 528         else
 529         {
 530             Reference< XComponent > xDocDefComponent;
 531             xSubComponent.set( m_xDocumentUI->createComponentWithArguments(
 532                     m_eType,
 533                     aLoadArgs.getPropertyValues(),
 534                     xDocDefComponent
 535                 ),
 536                 UNO_SET_THROW
 537             );
 538
 539             xDocDefinition.set( xDocDefComponent, UNO_QUERY );
 540             OSL_ENSURE( xDocDefinition.is(), "DatabaseDocumentRecovery::recoverSubDocuments: loaded a form/report, but don't have a document definition?!" );
 541         }
 542
 543         if ( xDocDefinition.is() )
 544         {
 545             Reference< XController > xController( m_xDocumentUI, UNO_QUERY_THROW );
 546             Reference< XInterface > xLoader( *new SubComponentLoader( xController, xDocDefinition ) );
 547             (void)xLoader;
 548         }
 549
 550         return xSubComponent;
 551     }
 552
 553     Reference< XComponent > SubComponentRecovery::impl_recoverQueryDesign_throw( const Reference< XStorage >& i_rRecoveryStorage,
 554         const OUString& i_rComponentName,  const bool i_bForEditing )
 555     {
 556         Reference< XComponent > xSubComponent;
 557
 558         // first read the settings query design settings from the storage
 559         StorageXMLInputStream aDesignInput( m_rContext, i_rRecoveryStorage, sSettingsStreamName );
 560
 561         ::rtl::Reference< SettingsDocumentHandler > pDocHandler( new SettingsDocumentHandler );
 562         aDesignInput.import( pDocHandler.get() );
 563
 564         const ::comphelper::NamedValueCollection& rSettings( pDocHandler->getSettings() );
 565         const Any& aCurrentQueryDesign = rSettings.get( sCurrentQueryDesignName );
 566 #if OSL_DEBUG_LEVEL > 0
 567         Sequence< PropertyValue > aQueryDesignLayout;
 568         OSL_VERIFY( aCurrentQueryDesign >>= aQueryDesignLayout );
 569 #endif
 570
 571         // then load the query designer
 572         ::comphelper::NamedValueCollection aLoadArgs;
 573         aLoadArgs.put( "CurrentQueryDesign", aCurrentQueryDesign );
 574         aLoadArgs.put( "Hidden", true );
 575
 576         if ( !i_rComponentName.isEmpty() )
 577         {
 578             xSubComponent.set( m_xDocumentUI->loadComponentWithArguments(
 579                     m_eType,
 580                     i_rComponentName,
 581                     i_bForEditing,
 582                     aLoadArgs.getPropertyValues()
 583                 ),
 584                 UNO_SET_THROW
 585             );
 586         }
 587         else
 588         {
 589             Reference< XComponent > xDummy;
 590             xSubComponent.set( m_xDocumentUI->createComponentWithArguments(
 591                     m_eType,
 592                     aLoadArgs.getPropertyValues(),
 593                     xDummy
 594                 ),
 595                 UNO_SET_THROW
 596             );
 597         }
 598
 599         Reference< XController > xController( m_xDocumentUI, UNO_QUERY_THROW );
 600         Reference< XInterface > xLoader( *new SubComponentLoader( xController, xSubComponent ) );
 601         (void)xLoader;
 602
 603         return xSubComponent;
 604     }
 605
 606     Reference< XComponent > SubComponentRecovery::recoverFromStorage( const Reference< XStorage >& i_rRecoveryStorage,
 607             const OUString& i_rComponentName, const bool i_bForEditing )
 608     {
 609         Reference< XComponent > xSubComponent;
 610         switch ( m_eType )
 611         {
 612         case FORM:
 613         case REPORT:
 614             xSubComponent = impl_recoverSubDocument_throw( i_rRecoveryStorage, i_rComponentName, i_bForEditing );
 615             break;
 616         case QUERY:
 617             xSubComponent = impl_recoverQueryDesign_throw( i_rRecoveryStorage, i_rComponentName, i_bForEditing );
 618             break;
 619         default:
 620             OSL_FAIL( "SubComponentRecovery::recoverFromStorage: unimplemented case!" );
 621             break;
 622         }
 623         return xSubComponent;
 624     }
 625
 626 } // namespace dbaccess
 627
 628 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */