/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <rtl/ref.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <sal/log.hxx>
#include <tools/datetime.hxx>
#include <comphelper/documentinfo.hxx>
#include <comphelper/namedvaluecollection.hxx>
#include <comphelper/sequence.hxx>
#include <com/sun/star/awt/XTopWindow.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/document/XDocumentEventBroadcaster.hpp>
#include <com/sun/star/document/XStorageBasedDocument.hpp>
#include <com/sun/star/frame/UnknownModuleException.hpp>
#include <com/sun/star/frame/theGlobalEventBroadcaster.hpp>
#include <com/sun/star/frame/ModuleManager.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/lang/NotInitializedException.hpp>
#include <com/sun/star/util/XCloseBroadcaster.hpp>
#include "tdoc_docmgr.hxx"
#include "tdoc_provider.hxx"
using namespace com::sun::star;
using namespace tdoc_ucp;
// OfficeDocumentsCloseListener Implementation.
// util::XCloseListener
// virtual
void SAL_CALL OfficeDocumentsManager::OfficeDocumentsCloseListener::queryClosing(
const lang::EventObject&
/*Source*/, sal_Bool /*GetsOwnership*/ )
{
}
void SAL_CALL OfficeDocumentsManager::OfficeDocumentsCloseListener::notifyClosing(
const lang::EventObject& Source )
{
if (!m_pManager)
return;
// disposed?
document::DocumentEvent aDocEvent;
aDocEvent.Source = Source.Source;
aDocEvent.EventName =
"OfficeDocumentsListener::notifyClosing";
m_pManager->documentEventOccured( aDocEvent );
}
// lang::XDocumentEventListener (base of util::XCloseListener)
// virtual
void SAL_CALL OfficeDocumentsManager::OfficeDocumentsCloseListener::disposing(
const lang::EventObject&
/*Source*/ )
{
}
// OfficeDocumentsManager Implementation.
OfficeDocumentsManager::OfficeDocumentsManager(
const uno::Reference< uno::XComponentContext > & rxContext,
ContentProvider * pDocEventListener )
: m_xContext( rxContext ),
m_xDocEvtNotifier( frame::theGlobalEventBroadcaster::get( rxContext ) ),
m_pDocEventListener( pDocEventListener ),
m_xDocCloseListener(
new OfficeDocumentsCloseListener(
this ) )
{
// Order is important (multithreaded environment)
uno::Reference< document::XDocumentEventBroadcaster >(
m_xDocEvtNotifier, uno::UNO_QUERY_THROW )->addDocumentEventListener(
this );
buildDocumentsList();
}
// virtual
OfficeDocumentsManager::~OfficeDocumentsManager()
{
//OSL_ENSURE( m_aDocs.empty(), "document list not empty!" );
// no need to assert this: Normal shutdown of LibreOffice could already trigger it, since the order
// in which objects are actually released/destroyed upon shutdown is not defined. And when we
// arrive *here*, LibreOffice *is* shutting down currently, since we're held by the TDOC provider,
// which is disposed upon shutdown.
m_xDocCloseListener->Dispose();
}
void OfficeDocumentsManager::destroy()
{
uno::Reference< document::XDocumentEventBroadcaster >(
m_xDocEvtNotifier, uno::UNO_QUERY_THROW )->removeDocumentEventListener(
this );
}
static OUString
getDocumentId(
const uno::Reference< uno::XInterface > & xDoc )
{
OUString aId;
// Try to get the UID directly from the document.
uno::Reference< beans::XPropertySet > xPropSet( xDoc, uno::UNO_QUERY );
if ( xPropSet.is() )
{
try
{
uno::Any aValue = xPropSet->getPropertyValue(u
"RuntimeUID"_ustr);
aValue >>= aId;
}
catch ( beans::UnknownPropertyException
const & )
{
// Not actually an error. Property is optional.
}
catch ( lang::WrappedTargetException
const & )
{
TOOLS_WARN_EXCEPTION(
"ucb.ucp",
"Caught WrappedTargetException!");
}
}
if ( aId.isEmpty() )
{
// fallback: generate UID from document's this pointer.
// normalize the interface pointer first. Else, calls with different
// interfaces to the same object (say, XFoo and XBar) will produce
// different IDs
uno::Reference< uno::XInterface > xNormalizedIFace( xDoc, uno::UNO_QUERY );
sal_Int64 nId =
reinterpret_cast< sal_Int64 >( xNormalizedIFace.get() );
aId = OUString::number( nId );
}
OSL_ENSURE( !aId.isEmpty(),
"getDocumentId - Empty id!" );
return aId;
}
// document::XDocumentEventListener
// virtual
void SAL_CALL OfficeDocumentsManager::documentEventOccured(
const document::DocumentEvent & Event )
{
/*
Events documentation: OOo Developer's Guide / Writing UNO Components /
Integrating Components into OpenOffice.org / Jobs
*/
if ( Event.EventName ==
"OnLoadFinished" // document loaded
|| Event.EventName ==
"OnCreate" )
// document created
{
if ( isOfficeDocument( Event.Source ) )
{
uno::Reference<frame::XModel>
const xModel(
Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xModel.is(),
"Got no frame::XModel!" );
bool found(
false);
{
std::scoped_lock aGuard( m_aMtx );
found = std::any_of(m_aDocs.begin(), m_aDocs.end(),
[&xModel](
const DocumentList::value_type& rEntry) {
return rEntry.s
econd.xModel == xModel; });
}
if (!found)
{
// no mutex to avoid deadlocks!
// need no lock to access const members, ContentProvider is safe
// new document
uno::Reference< document::XStorageBasedDocument >
xDoc( Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xDoc.is(), "Got no document::XStorageBasedDocument!" );
uno::Reference< embed::XStorage > xStorage
= xDoc->getDocumentStorage();
OSL_ENSURE( xStorage.is(), "Got no document storage!" );
rtl:: OUString aDocId = getDocumentId( Event.Source );
rtl:: OUString aTitle = comphelper::DocumentInfo::getDocumentTitle(
uno::Reference< frame::XModel >( Event.Source, uno::UNO_QUERY ) );
{
std::scoped_lock g(m_aMtx);
m_aDocs[ aDocId ] = StorageInfo( aTitle, xStorage, xModel );
}
uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster(
Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xCloseBroadcaster.is(),
"OnLoadFinished/OnCreate event: got no close broadcaster!" );
if ( xCloseBroadcaster.is() )
xCloseBroadcaster->addCloseListener(m_xDocCloseListener);
// Propagate document closure.
OSL_ENSURE( m_pDocEventListener,
"OnLoadFinished/OnCreate event: no owner for insert event propagation!" );
if ( m_pDocEventListener )
m_pDocEventListener->notifyDocumentOpened( aDocId );
}
}
}
else if ( Event.EventName == "OfficeDocumentsListener::notifyClosing" )
{
if ( isOfficeDocument( Event.Source ) )
{
// Document has been closed (unloaded)
// Official event "OnUnload" does not work here. Event
// gets fired too early. Other OnUnload listeners called after this
// listener may still need TDOC access to the document. Remove the
// document from TDOC docs list on XCloseListener::notifyClosing.
// See OfficeDocumentsManager::OfficeDocumentsListener::notifyClosing.
uno::Reference< frame::XModel >
xModel( Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xModel.is(), "Got no frame::XModel!" );
bool found(false);
OUString aDocId;
{
std::scoped_lock aGuard( m_aMtx );
auto it = std::find_if(m_aDocs.begin(), m_aDocs.end(),
[&xModel](const DocumentList::value_type& rEntry) { return rEntry.second.xModel == xModel; });
if ( it != m_aDocs.end() )
{
aDocId = (*it).first;
found = true;
m_aDocs.erase( it );
}
}
OSL_ENSURE( found,
"OnUnload event notified for unknown document!" );
if (found)
{
// Propagate document closure.
OSL_ENSURE( m_pDocEventListener,
"OnUnload event: no owner for close event propagation!" );
if (m_pDocEventListener)
{
m_pDocEventListener->notifyDocumentClosed(aDocId);
}
uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster(
Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xCloseBroadcaster.is(),
"OnUnload event: got no XCloseBroadcaster from XModel" );
if ( xCloseBroadcaster.is() )
xCloseBroadcaster->removeCloseListener(m_xDocCloseListener);
}
}
}
else if ( Event.EventName == "OnSaveDone" )
{
if ( isOfficeDocument( Event.Source ) )
{
// Storage gets exchanged while saving.
uno::Reference<document::XStorageBasedDocument> const xDoc(
Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xDoc.is(),
"Got no document::XStorageBasedDocument!" );
uno::Reference<embed::XStorage> const xStorage(
xDoc->getDocumentStorage());
OSL_ENSURE( xStorage.is(), "Got no document storage!" );
uno::Reference< frame::XModel >
xModel( Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xModel.is(), "Got no frame::XModel!" );
std::scoped_lock aGuard( m_aMtx );
DocumentList::iterator it = std::find_if(m_aDocs.begin(), m_aDocs.end(),
[&xModel](const DocumentList::value_type& rEntry) { return rEntry.second.xModel == xModel; });
OSL_ENSURE( it != m_aDocs.end(),
"OnSaveDone event notified for unknown document!" );
if ( it != m_aDocs.end() )
{
(*it).second.xStorage = xStorage;
}
}
}
else if ( Event.EventName == "OnSaveAsDone" )
{
if ( isOfficeDocument( Event.Source ) )
{
// Storage gets exchanged while saving.
uno::Reference<document::XStorageBasedDocument> const xDoc(
Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xDoc.is(),
"Got no document::XStorageBasedDocument!" );
uno::Reference<embed::XStorage> const xStorage(
xDoc->getDocumentStorage());
OSL_ENSURE( xStorage.is(), "Got no document storage!" );
uno::Reference< frame::XModel >
xModel( Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xModel.is(), "Got no frame::XModel!" );
OUString const title(comphelper::DocumentInfo::getDocumentTitle(xModel));
std::scoped_lock aGuard( m_aMtx );
DocumentList::iterator it = std::find_if(m_aDocs.begin(), m_aDocs.end(),
[&xModel](const DocumentList::value_type& rEntry) { return rEntry.second.xModel == xModel; });
OSL_ENSURE( it != m_aDocs.end(),
"OnSaveAsDone event notified for unknown document!" );
if ( it != m_aDocs.end() )
{
(*it).second.xStorage = xStorage;
// Adjust title.
(*it).second.aTitle = title;
}
}
}
else if ( Event.EventName == "OnTitleChanged"
|| Event.EventName == "OnStorageChanged" )
{
if ( isOfficeDocument( Event.Source ) )
{
// Storage gets exchanged while saving.
uno::Reference<document::XStorageBasedDocument> const xDoc(
Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xDoc.is(),
"Got no document::XStorageBasedDocument!" );
uno::Reference<embed::XStorage> const xStorage(
xDoc->getDocumentStorage());
OSL_ENSURE( xStorage.is(), "Got no document storage!" );
uno::Reference< frame::XModel >
xModel( Event.Source, uno::UNO_QUERY );
OSL_ENSURE( xModel.is(), "Got no frame::XModel!" );
OUString const aTitle(comphelper::DocumentInfo::getDocumentTitle(xModel));
OUString const aDocId(getDocumentId(Event.Source));
std::scoped_lock aGuard( m_aMtx );
DocumentList::iterator it = std::find_if(m_aDocs.begin(), m_aDocs.end(),
[&xModel](const DocumentList::value_type& rEntry) { return rEntry.second.xModel == xModel; });
if ( it != m_aDocs.end() )
{
// Adjust title.
(*it).second.aTitle = aTitle;
m_aDocs[ aDocId ] = StorageInfo( aTitle, xStorage, xModel );
}
// OSL_ENSURE( it != m_aDocs.end(),
// "TitleChanged event notified for unknown document!" );
// TODO: re-enable this assertion. It has been disabled for now, since it breaks the assertion-free smoketest,
// and the fix is more difficult than what can be done now.
// The problem is that at the moment, when you close a SFX-based document via API, it will first
// fire the notifyClosing event, which will make the OfficeDocumentsManager remove the doc from its list.
// Then, it will notify an OnTitleChanged, then an OnUnload. Documents closed via call the notifyClosing
// *after* OnUnload and all other On* events.
// In agreement with MBA, the implementation for SfxBaseModel::Close should be changed to also send notifyClosing
// as last event. When this happens, the assertion here must be enabled, again.
}
}
}
// lang::XDocumentEventListener (base of document::XDocumentEventListener)
// virtual
void SAL_CALL OfficeDocumentsManager::disposing(
const lang::EventObject& /*Source*/ )
{
}
// Non-interface.
void OfficeDocumentsManager::buildDocumentsList()
{
uno::Reference< container::XEnumeration > xEnum
= m_xDocEvtNotifier->createEnumeration();
while ( xEnum->hasMoreElements() )
{
uno::Any aValue = xEnum->nextElement();
// container::NoSuchElementException
// lang::WrappedTargetException
try
{
uno::Reference< frame::XModel > xModel;
aValue >>= xModel;
if ( xModel.is() )
{
if ( isOfficeDocument( xModel ) )
{
bool found(false);
{
std::scoped_lock aGuard( m_aMtx );
found = std::any_of(m_aDocs.begin(), m_aDocs.end(),
[&xModel](const DocumentList::value_type& rEntry) { return rEntry.second.xModel == xModel; });
}
if (!found)
{
// new document
OUString aDocId = getDocumentId( xModel );
OUString aTitle = comphelper::DocumentInfo::getDocumentTitle( xModel );
uno::Reference< document::XStorageBasedDocument >
xDoc( xModel, uno::UNO_QUERY );
OSL_ENSURE( xDoc.is(),
"Got no document::XStorageBasedDocument!" );
uno::Reference< embed::XStorage > xStorage
= xDoc->getDocumentStorage();
OSL_ENSURE( xStorage.is(), "Got no document storage!" );
{
std::scoped_lock aGuard( m_aMtx );
m_aDocs[ aDocId ]
= StorageInfo( aTitle, xStorage, xModel );
}
uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster(
xModel, uno::UNO_QUERY );
OSL_ENSURE( xCloseBroadcaster.is(),
"buildDocumentsList: got no close broadcaster!" );
if ( xCloseBroadcaster.is() )
xCloseBroadcaster->addCloseListener(m_xDocCloseListener);
}
}
}
}
catch ( lang::DisposedException const & )
{
// Note: Due to race conditions the XEnumeration can
// contain docs that have already been closed
}
catch ( lang::NotInitializedException const & )
{
// Note: Due to race conditions the XEnumeration can
// contain docs that are still uninitialized
}
}
}
uno::Reference< embed::XStorage >
OfficeDocumentsManager::queryStorage( const OUString & rDocId )
{
std::scoped_lock aGuard( m_aMtx );
DocumentList::const_iterator it = m_aDocs.find( rDocId );
if ( it == m_aDocs.end() )
return uno::Reference< embed::XStorage >();
return (*it).second.xStorage;
}
OUString OfficeDocumentsManager::queryDocumentId(
const uno::Reference< frame::XModel > & xModel )
{
return getDocumentId( xModel );
}
uno::Reference< frame::XModel >
OfficeDocumentsManager::queryDocumentModel( const OUString & rDocId )
{
std::scoped_lock aGuard( m_aMtx );
DocumentList::const_iterator it = m_aDocs.find( rDocId );
if ( it == m_aDocs.end() )
return uno::Reference< frame::XModel >();
return (*it).second.xModel;
}
uno::Sequence< OUString > OfficeDocumentsManager::queryDocuments()
{
std::scoped_lock aGuard( m_aMtx );
return comphelper::mapKeysToSequence( m_aDocs );
}
OUString
OfficeDocumentsManager::queryStorageTitle( const OUString & rDocId )
{
std::scoped_lock aGuard( m_aMtx );
DocumentList::const_iterator it = m_aDocs.find( rDocId );
if ( it == m_aDocs.end() )
return OUString();
return (*it).second.aTitle;
}
css::util::DateTime OfficeDocumentsManager::queryStreamDateModified(OUString const & uri) {
std::scoped_lock g(m_aMtx);
auto const i1 = m_aDocs.find(Uri(uri).getDocumentId());
if (i1 != m_aDocs.end()) {
auto const i2 = i1->second.streamDateModified.find(uri);
if (i2 != i1->second.streamDateModified.end()) {
return i2->second;
}
}
return {};
}
void OfficeDocumentsManager::updateStreamDateModified(OUString const & uri) {
std::scoped_lock g(m_aMtx);
auto const i = m_aDocs.find(Uri(uri).getDocumentId());
if (i == m_aDocs.end()) {
SAL_WARN("ucb.ucp.tdoc", "No document info for <" << uri << ">");
return;
}
i->second.streamDateModified[uri] = DateTime(DateTime::SYSTEM).GetUNODateTime();
}
bool OfficeDocumentsManager::isDocumentPreview(
const uno::Reference< frame::XModel3 > & xModel )
{
if ( !xModel.is() )
return false;
uno::Sequence<beans::PropertyValue> props = xModel->getArgs2( { u"Preview"_ustr } );
for (const auto & rProp : props)
if (rProp.Name == "Preview")
{
bool bIsPreview = false;
rProp.Value >>= bIsPreview;
return bIsPreview;
}
return false;
}
bool OfficeDocumentsManager::isHelpDocument(
const uno::Reference< frame::XModel > & xModel )
{
if ( !xModel.is() )
return false;
OUString sURL( xModel->getURL() );
return sURL.match( "vnd.sun.star.help://" );
}
bool OfficeDocumentsManager::isWithoutOrInTopLevelFrame(
const uno::Reference< frame::XModel > & xModel )
{
if ( !xModel.is() )
return false;
uno::Reference< frame::XController > xController
= xModel->getCurrentController();
if ( xController.is() )
{
uno::Reference< frame::XFrame > xFrame
= xController->getFrame();
if ( xFrame.is() )
{
// don't use XFrame::isTop here. This nowadays excludes
// "sub documents" such as forms embedded in database documents
uno::Reference< awt::XTopWindow > xFrameContainer(
xFrame->getContainerWindow(), uno::UNO_QUERY );
if ( !xFrameContainer.is() )
return false;
}
}
return true;
}
bool OfficeDocumentsManager::isBasicIDE(
const uno::Reference< frame::XModel > & xModel )
{
if ( !m_xModuleMgr.is() )
{
std::scoped_lock aGuard( m_aMtx );
if ( !m_xModuleMgr.is() )
{
try
{
m_xModuleMgr = frame::ModuleManager::create( m_xContext );
}
catch ( uno::Exception const & )
{
// handled below.
}
OSL_ENSURE( m_xModuleMgr .is(),
"Could not instantiate ModuleManager service!" );
}
}
if ( m_xModuleMgr.is() )
{
OUString aModule;
try
{
aModule = m_xModuleMgr->identify( xModel );
}
catch ( lang::IllegalArgumentException const & )
{
TOOLS_WARN_EXCEPTION("ucb.ucp", "");
}
catch ( frame::UnknownModuleException const & )
{
TOOLS_WARN_EXCEPTION("ucb.ucp", "");
}
if ( !aModule.isEmpty() )
{
// Filter unwanted items, that are no real documents.
if ( aModule == "com.sun.star.script.BasicIDE" )
{
return true;
}
}
}
return false;
}
bool OfficeDocumentsManager::isOfficeDocument(
const uno::Reference< uno::XInterface > & xDoc )
{
uno::Reference< frame::XModel > xModel( xDoc, uno::UNO_QUERY );
uno::Reference< document::XStorageBasedDocument >
xStorageBasedDoc( xModel, uno::UNO_QUERY );
if ( !xStorageBasedDoc.is() )
return false;
uno::Reference< frame::XModel3 > xModel3( xDoc, uno::UNO_QUERY );
assert(xModel3 && "anything implementing frame:XModel is expected to implement XModel3 as well");
if ( !isWithoutOrInTopLevelFrame( xModel ) )
return false;
if ( isDocumentPreview( xModel3 ) )
return false;
if ( isHelpDocument( xModel ) )
return false;
if ( isBasicIDE( xModel ) )
return false;
return true;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
