diff options
Diffstat (limited to 'sw/source/core/unocore/unocoll.cxx')
-rw-r--r-- | sw/source/core/unocore/unocoll.cxx | 1871 |
1 files changed, 1871 insertions, 0 deletions
diff --git a/sw/source/core/unocore/unocoll.cxx b/sw/source/core/unocore/unocoll.cxx new file mode 100644 index 0000000000..d0f3332421 --- /dev/null +++ b/sw/source/core/unocore/unocoll.cxx @@ -0,0 +1,1871 @@ +/* -*- 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 <config_features.h> + +#include <hintids.hxx> +#include <doc.hxx> +#include <IDocumentChartDataProviderAccess.hxx> +#include <IDocumentFieldsAccess.hxx> +#include <docary.hxx> +#include <unocoll.hxx> +#include <unosett.hxx> +#include <section.hxx> +#include <IMark.hxx> +#include <ftnidx.hxx> +#include <fmtftn.hxx> +#include <txtftn.hxx> +#include <com/sun/star/text/XTextTable.hpp> +#include <o3tl/safeint.hxx> +#include <o3tl/string_view.hxx> +#include <svtools/unoimap.hxx> +#include <svtools/unoevent.hxx> +#include <svx/SvxXTextColumns.hxx> +#include <unotbl.hxx> +#include <unostyle.hxx> +#include <unofield.hxx> +#include <unoidx.hxx> +#include <unoframe.hxx> +#include <textboxhelper.hxx> +#include <unofootnote.hxx> +#include <unolinebreak.hxx> +#include <unoport.hxx> +#include <vcl/svapp.hxx> +#include <fmtcntnt.hxx> +#include <authfld.hxx> +#include <SwXTextDefaults.hxx> +#include <unochart.hxx> +#include <comphelper/sequence.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <unosection.hxx> +#include <unoparagraph.hxx> +#include <unobookmark.hxx> +#include <unorefmark.hxx> +#include <unometa.hxx> +#include <unocontentcontrol.hxx> +#include <docsh.hxx> +#include <hints.hxx> +#include <frameformats.hxx> +#include <com/sun/star/document/XCodeNameQuery.hpp> +#include <com/sun/star/drawing/XDrawPageSupplier.hpp> +#include <com/sun/star/form/XFormsSupplier.hpp> +#include <com/sun/star/script/ModuleInfo.hpp> +#include <com/sun/star/script/ModuleType.hpp> +#include <com/sun/star/script/vba/XVBAModuleInfo.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <vbahelper/vbaaccesshelper.hxx> +#include <basic/basmgr.hxx> +#include <comphelper/processfactory.hxx> +#include <cppuhelper/implbase.hxx> +#include <sfx2/event.hxx> +#include <sal/log.hxx> +#include <tools/debug.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::document; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::text; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; + +#if HAVE_FEATURE_SCRIPTING + +namespace { + +class SwVbaCodeNameProvider : public ::cppu::WeakImplHelper< document::XCodeNameQuery > +{ + SwDocShell* mpDocShell; + OUString msThisDocumentCodeName; +public: + explicit SwVbaCodeNameProvider( SwDocShell* pDocShell ) : mpDocShell( pDocShell ) {} + // XCodeNameQuery + + OUString SAL_CALL getCodeNameForContainer( const uno::Reference< uno::XInterface >& /*xIf*/ ) override + { + // #FIXME not implemented... + return OUString(); + } + + OUString SAL_CALL getCodeNameForObject( const uno::Reference< uno::XInterface >& xIf ) override + { + // Initialise the code name + if ( msThisDocumentCodeName.isEmpty() ) + { + try + { + uno::Reference< beans::XPropertySet > xProps( mpDocShell->GetModel(), uno::UNO_QUERY_THROW ); + uno::Reference< container::XNameAccess > xLibContainer( xProps->getPropertyValue("BasicLibraries"), uno::UNO_QUERY_THROW ); + OUString sProjectName( "Standard"); + if ( !mpDocShell->GetBasicManager()->GetName().isEmpty() ) + { + sProjectName = mpDocShell->GetBasicManager()->GetName(); + } + uno::Reference< container::XNameAccess > xLib( xLibContainer->getByName( sProjectName ), uno::UNO_QUERY_THROW ); + const uno::Sequence< OUString > sModuleNames = xLib->getElementNames(); + uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY ); + + auto pModuleName = std::find_if(sModuleNames.begin(), sModuleNames.end(), [&xVBAModuleInfo](const OUString& rName) { + return xVBAModuleInfo->hasModuleInfo(rName) + && xVBAModuleInfo->getModuleInfo(rName).ModuleType == script::ModuleType::DOCUMENT; }); + if (pModuleName != sModuleNames.end()) + msThisDocumentCodeName = *pModuleName; + } + catch( uno::Exception& ) + { + } + } + OUString sCodeName; + if ( mpDocShell ) + { + // need to find the page ( and index ) for this control + uno::Reference< drawing::XDrawPageSupplier > xSupplier( mpDocShell->GetModel(), uno::UNO_QUERY_THROW ); + uno::Reference< container::XIndexAccess > xIndex( xSupplier->getDrawPage(), uno::UNO_QUERY_THROW ); + + try + { + uno::Reference< form::XFormsSupplier > xFormSupplier( xIndex, uno::UNO_QUERY_THROW ); + uno::Reference< container::XIndexAccess > xFormIndex( xFormSupplier->getForms(), uno::UNO_QUERY_THROW ); + // get the www-standard container + uno::Reference< container::XIndexAccess > xFormControls( xFormIndex->getByIndex(0), uno::UNO_QUERY_THROW ); + sal_Int32 nCntrls = xFormControls->getCount(); + for( sal_Int32 cIndex = 0; cIndex < nCntrls; ++cIndex ) + { + uno::Reference< uno::XInterface > xControl( xFormControls->getByIndex( cIndex ), uno::UNO_QUERY_THROW ); + bool bMatched = ( xControl == xIf ); + if ( bMatched ) + { + sCodeName = msThisDocumentCodeName; + break; + } + } + } + catch( uno::Exception& ) + { + } + } + // #TODO Probably should throw here ( if !bMatched ) + return sCodeName; + } +}; + +} + +typedef std::unordered_map< OUString, OUString > StringHashMap; + +namespace { + +class SwVbaProjectNameProvider : public ::cppu::WeakImplHelper< container::XNameContainer > +{ + StringHashMap mTemplateToProject; +public: + SwVbaProjectNameProvider() + { + } + virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override + { + return ( mTemplateToProject.find( aName ) != mTemplateToProject.end() ); + } + virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override + { + if ( !hasByName( aName ) ) + throw container::NoSuchElementException(); + return uno::Any( mTemplateToProject.find( aName )->second ); + } + virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override + { + return comphelper::mapKeysToSequence( mTemplateToProject ); + } + + virtual void SAL_CALL insertByName( const OUString& aName, const uno::Any& aElement ) override + { + + OUString sProjectName; + aElement >>= sProjectName; + SAL_INFO("sw.uno", "Template cache inserting template name " << aName + << " with project " << sProjectName); + mTemplateToProject[ aName ] = sProjectName; + } + + virtual void SAL_CALL removeByName( const OUString& Name ) override + { + if ( !hasByName( Name ) ) + throw container::NoSuchElementException(); + mTemplateToProject.erase( Name ); + } + virtual void SAL_CALL replaceByName( const OUString& aName, const uno::Any& aElement ) override + { + if ( !hasByName( aName ) ) + throw container::NoSuchElementException(); + insertByName( aName, aElement ); // insert will overwrite + } + // XElemenAccess + virtual css::uno::Type SAL_CALL getElementType( ) override + { + return ::cppu::UnoType<OUString>::get(); + } + virtual sal_Bool SAL_CALL hasElements( ) override + { + + return ( !mTemplateToProject.empty() ); + } + +}; + +class SwVbaObjectForCodeNameProvider : public ::cppu::WeakImplHelper< container::XNameAccess > +{ + SwDocShell* mpDocShell; +public: + explicit SwVbaObjectForCodeNameProvider( SwDocShell* pDocShell ) : mpDocShell( pDocShell ) + { + // #FIXME #TODO is the code name for ThisDocument read anywhere? + } + + virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override + { + // #FIXME #TODO we really need to be checking against the codename for + // ThisDocument + if ( aName == "ThisDocument" ) + return true; + return false; + } + + css::uno::Any SAL_CALL getByName( const OUString& aName ) override + { + if ( !hasByName( aName ) ) + throw container::NoSuchElementException(); + uno::Sequence< uno::Any > aArgs{ uno::Any(uno::Reference< uno::XInterface >()), + uno::Any(mpDocShell->GetModel()) }; + uno::Reference< uno::XInterface > xDocObj = ooo::vba::createVBAUnoAPIServiceWithArgs( mpDocShell, "ooo.vba.word.Document" , aArgs ); + SAL_INFO("sw.uno", + "Creating Object ( ooo.vba.word.Document ) 0x" << xDocObj.get()); + return uno::Any( xDocObj ); + } + virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override + { + uno::Sequence< OUString > aNames; + return aNames; + } + // XElemenAccess + virtual css::uno::Type SAL_CALL getElementType( ) override { return uno::Type(); } + virtual sal_Bool SAL_CALL hasElements( ) override { return true; } + +}; + +} + +#endif + +namespace { + +struct ProvNamesId_Type +{ + const char * pName; + SwServiceType nType; +}; + +} + +// note: this thing is indexed as an array, so do not insert/remove entries! +const ProvNamesId_Type aProvNamesId[] = +{ + { "com.sun.star.text.TextTable", SwServiceType::TypeTextTable }, + { "com.sun.star.text.TextFrame", SwServiceType::TypeTextFrame }, + { "com.sun.star.text.GraphicObject", SwServiceType::TypeGraphic }, + { "com.sun.star.text.TextEmbeddedObject", SwServiceType::TypeOLE }, + { "com.sun.star.text.Bookmark", SwServiceType::TypeBookmark }, + { "com.sun.star.text.Footnote", SwServiceType::TypeFootnote }, + { "com.sun.star.text.Endnote", SwServiceType::TypeEndnote }, + { "com.sun.star.text.DocumentIndexMark", SwServiceType::TypeIndexMark }, + { "com.sun.star.text.DocumentIndex", SwServiceType::TypeIndex }, + { "com.sun.star.text.ReferenceMark", SwServiceType::ReferenceMark }, + { "com.sun.star.style.CharacterStyle", SwServiceType::StyleCharacter }, + { "com.sun.star.style.ParagraphStyle", SwServiceType::StyleParagraph }, + { "com.sun.star.style.FrameStyle", SwServiceType::StyleFrame }, + { "com.sun.star.style.PageStyle", SwServiceType::StylePage }, + { "com.sun.star.style.NumberingStyle", SwServiceType::StyleNumbering }, + { "com.sun.star.text.ContentIndexMark", SwServiceType::ContentIndexMark }, + { "com.sun.star.text.ContentIndex", SwServiceType::ContentIndex }, + { "com.sun.star.text.UserIndexMark", SwServiceType::UserIndexMark }, + { "com.sun.star.text.UserIndex", SwServiceType::UserIndex }, + { "com.sun.star.text.TextSection", SwServiceType::TextSection }, + { "com.sun.star.text.TextField.DateTime", SwServiceType::FieldTypeDateTime }, + { "com.sun.star.text.TextField.User", SwServiceType::FieldTypeUser }, + { "com.sun.star.text.TextField.SetExpression", SwServiceType::FieldTypeSetExp }, + { "com.sun.star.text.TextField.GetExpression", SwServiceType::FieldTypeGetExp }, + { "com.sun.star.text.TextField.FileName", SwServiceType::FieldTypeFileName }, + { "com.sun.star.text.TextField.PageNumber", SwServiceType::FieldTypePageNum }, + { "com.sun.star.text.TextField.Author", SwServiceType::FieldTypeAuthor }, + { "com.sun.star.text.TextField.Chapter", SwServiceType::FieldTypeChapter }, + { "", SwServiceType::FieldTypeDummy0 }, + { "com.sun.star.text.TextField.GetReference", SwServiceType::FieldTypeGetReference }, + { "com.sun.star.text.TextField.ConditionalText", SwServiceType::FieldTypeConditionedText }, + { "com.sun.star.text.TextField.Annotation", SwServiceType::FieldTypeAnnotation }, + { "com.sun.star.text.TextField.Input", SwServiceType::FieldTypeInput }, + { "com.sun.star.text.TextField.Macro", SwServiceType::FieldTypeMacro }, + { "com.sun.star.text.TextField.DDE", SwServiceType::FieldTypeDDE }, + { "com.sun.star.text.TextField.HiddenParagraph", SwServiceType::FieldTypeHiddenPara }, + { "" /*com.sun.star.text.TextField.DocumentInfo"*/, SwServiceType::FieldTypeDocInfo }, + { "com.sun.star.text.TextField.TemplateName", SwServiceType::FieldTypeTemplateName }, + { "com.sun.star.text.TextField.ExtendedUser", SwServiceType::FieldTypeUserExt }, + { "com.sun.star.text.TextField.ReferencePageSet", SwServiceType::FieldTypeRefPageSet }, + { "com.sun.star.text.TextField.ReferencePageGet", SwServiceType::FieldTypeRefPageGet }, + { "com.sun.star.text.TextField.JumpEdit", SwServiceType::FieldTypeJumpEdit }, + { "com.sun.star.text.TextField.Script", SwServiceType::FieldTypeScript }, + { "com.sun.star.text.TextField.DatabaseNextSet", SwServiceType::FieldTypeDatabaseNextSet }, + { "com.sun.star.text.TextField.DatabaseNumberOfSet", SwServiceType::FieldTypeDatabaseNumSet }, + { "com.sun.star.text.TextField.DatabaseSetNumber", SwServiceType::FieldTypeDatabaseSetNum }, + { "com.sun.star.text.TextField.Database", SwServiceType::FieldTypeDatabase }, + { "com.sun.star.text.TextField.DatabaseName", SwServiceType::FieldTypeDatabaseName }, + { "com.sun.star.text.TextField.TableFormula", SwServiceType::FieldTypeTableFormula }, + { "com.sun.star.text.TextField.PageCount", SwServiceType::FieldTypePageCount }, + { "com.sun.star.text.TextField.ParagraphCount", SwServiceType::FieldTypeParagraphCount }, + { "com.sun.star.text.TextField.WordCount", SwServiceType::FieldTypeWordCount }, + { "com.sun.star.text.TextField.CharacterCount", SwServiceType::FieldTypeCharacterCount }, + { "com.sun.star.text.TextField.TableCount", SwServiceType::FieldTypeTableCount }, + { "com.sun.star.text.TextField.GraphicObjectCount", SwServiceType::FieldTypeGraphicObjectCount }, + { "com.sun.star.text.TextField.EmbeddedObjectCount", SwServiceType::FieldTypeEmbeddedObjectCount }, + { "com.sun.star.text.TextField.DocInfo.ChangeAuthor", SwServiceType::FieldTypeDocInfoChangeAuthor }, + { "com.sun.star.text.TextField.DocInfo.ChangeDateTime", SwServiceType::FieldTypeDocInfoChangeDateTime }, + { "com.sun.star.text.TextField.DocInfo.EditTime", SwServiceType::FieldTypeDocInfoEditTime }, + { "com.sun.star.text.TextField.DocInfo.Description", SwServiceType::FieldTypeDocInfoDescription }, + { "com.sun.star.text.TextField.DocInfo.CreateAuthor", SwServiceType::FieldTypeDocInfoCreateAuthor }, + { "com.sun.star.text.TextField.DocInfo.CreateDateTime", SwServiceType::FieldTypeDocInfoCreateDateTime }, + { "", SwServiceType::FieldTypeDummy0 }, + { "", SwServiceType::FieldTypeDummy1 }, + { "", SwServiceType::FieldTypeDummy2 }, + { "", SwServiceType::FieldTypeDummy3 }, + { "com.sun.star.text.TextField.DocInfo.Custom", SwServiceType::FieldTypeDocInfoCustom }, + { "com.sun.star.text.TextField.DocInfo.PrintAuthor", SwServiceType::FieldTypeDocInfoPrintAuthor }, + { "com.sun.star.text.TextField.DocInfo.PrintDateTime", SwServiceType::FieldTypeDocInfoPrintDateTime }, + { "com.sun.star.text.TextField.DocInfo.KeyWords", SwServiceType::FieldTypeDocInfoKeywords }, + { "com.sun.star.text.TextField.DocInfo.Subject", SwServiceType::FieldTypeDocInfoSubject }, + { "com.sun.star.text.TextField.DocInfo.Title", SwServiceType::FieldTypeDocInfoTitle }, + { "com.sun.star.text.TextField.DocInfo.Revision", SwServiceType::FieldTypeDocInfoRevision }, + { "com.sun.star.text.TextField.Bibliography", SwServiceType::FieldTypeBibliography }, + { "com.sun.star.text.TextField.CombinedCharacters", SwServiceType::FieldTypeCombinedCharacters }, + { "com.sun.star.text.TextField.DropDown", SwServiceType::FieldTypeDropdown }, + { "com.sun.star.text.textfield.MetadataField", SwServiceType::FieldTypeMetafield }, + { "", SwServiceType::FieldTypeDummy4 }, + { "", SwServiceType::FieldTypeDummy5 }, + { "", SwServiceType::FieldTypeDummy6 }, + { "", SwServiceType::FieldTypeDummy7 }, + { "com.sun.star.text.FieldMaster.User", SwServiceType::FieldMasterUser }, + { "com.sun.star.text.FieldMaster.DDE", SwServiceType::FieldMasterDDE }, + { "com.sun.star.text.FieldMaster.SetExpression", SwServiceType::FieldMasterSetExp }, + { "com.sun.star.text.FieldMaster.Database", SwServiceType::FieldMasterDatabase }, + { "com.sun.star.text.FieldMaster.Bibliography", SwServiceType::FieldMasterBibliography }, + { "", SwServiceType::FieldMasterDummy2 }, + { "", SwServiceType::FieldMasterDummy3 }, + { "", SwServiceType::FieldMasterDummy4 }, + { "", SwServiceType::FieldMasterDummy5 }, + { "com.sun.star.text.IllustrationsIndex", SwServiceType::IndexIllustrations }, + { "com.sun.star.text.ObjectIndex", SwServiceType::IndexObjects }, + { "com.sun.star.text.TableIndex", SwServiceType::IndexTables }, + { "com.sun.star.text.Bibliography", SwServiceType::IndexBibliography }, + { "com.sun.star.text.Paragraph", SwServiceType::Paragraph }, + { "com.sun.star.text.TextField.InputUser", SwServiceType::FieldTypeInputUser }, + { "com.sun.star.text.TextField.HiddenText", SwServiceType::FieldTypeHiddenText }, + { "com.sun.star.style.ConditionalParagraphStyle", SwServiceType::StyleConditionalParagraph }, + { "com.sun.star.text.NumberingRules", SwServiceType::NumberingRules }, + { "com.sun.star.text.TextColumns", SwServiceType::TextColumns }, + { "com.sun.star.text.IndexHeaderSection", SwServiceType::IndexHeaderSection }, + { "com.sun.star.text.Defaults", SwServiceType::Defaults }, + { "com.sun.star.image.ImageMapRectangleObject", SwServiceType::IMapRectangle }, + { "com.sun.star.image.ImageMapCircleObject", SwServiceType::IMapCircle }, + { "com.sun.star.image.ImageMapPolygonObject", SwServiceType::IMapPolygon }, + { "com.sun.star.text.TextGraphicObject", SwServiceType::TypeTextGraphic }, + { "com.sun.star.chart2.data.DataProvider", SwServiceType::Chart2DataProvider }, + { "com.sun.star.text.Fieldmark", SwServiceType::TypeFieldMark }, + { "com.sun.star.text.FormFieldmark", SwServiceType::TypeFormFieldMark }, + { "com.sun.star.text.InContentMetadata", SwServiceType::TypeMeta }, + { "ooo.vba.VBAObjectModuleObjectProvider", SwServiceType::VbaObjectProvider }, + { "ooo.vba.VBACodeNameProvider", SwServiceType::VbaCodeNameProvider }, + { "ooo.vba.VBAProjectNameProvider", SwServiceType::VbaProjectNameProvider }, + { "ooo.vba.VBAGlobals", SwServiceType::VbaGlobals }, + + // case-correct versions of the service names (see #i67811) + { CSS_TEXT_TEXTFIELD_DATE_TIME, SwServiceType::FieldTypeDateTime }, + { CSS_TEXT_TEXTFIELD_USER, SwServiceType::FieldTypeUser }, + { CSS_TEXT_TEXTFIELD_SET_EXPRESSION, SwServiceType::FieldTypeSetExp }, + { CSS_TEXT_TEXTFIELD_GET_EXPRESSION, SwServiceType::FieldTypeGetExp }, + { CSS_TEXT_TEXTFIELD_FILE_NAME, SwServiceType::FieldTypeFileName }, + { CSS_TEXT_TEXTFIELD_PAGE_NUMBER, SwServiceType::FieldTypePageNum }, + { CSS_TEXT_TEXTFIELD_AUTHOR, SwServiceType::FieldTypeAuthor }, + { CSS_TEXT_TEXTFIELD_CHAPTER, SwServiceType::FieldTypeChapter }, + { CSS_TEXT_TEXTFIELD_GET_REFERENCE, SwServiceType::FieldTypeGetReference }, + { CSS_TEXT_TEXTFIELD_CONDITIONAL_TEXT, SwServiceType::FieldTypeConditionedText }, + { CSS_TEXT_TEXTFIELD_ANNOTATION, SwServiceType::FieldTypeAnnotation }, + { CSS_TEXT_TEXTFIELD_INPUT, SwServiceType::FieldTypeInput }, + { CSS_TEXT_TEXTFIELD_MACRO, SwServiceType::FieldTypeMacro }, + { CSS_TEXT_TEXTFIELD_DDE, SwServiceType::FieldTypeDDE }, + { CSS_TEXT_TEXTFIELD_HIDDEN_PARAGRAPH, SwServiceType::FieldTypeHiddenPara }, + { CSS_TEXT_TEXTFIELD_TEMPLATE_NAME, SwServiceType::FieldTypeTemplateName }, + { CSS_TEXT_TEXTFIELD_EXTENDED_USER, SwServiceType::FieldTypeUserExt }, + { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_SET, SwServiceType::FieldTypeRefPageSet }, + { CSS_TEXT_TEXTFIELD_REFERENCE_PAGE_GET, SwServiceType::FieldTypeRefPageGet }, + { CSS_TEXT_TEXTFIELD_JUMP_EDIT, SwServiceType::FieldTypeJumpEdit }, + { CSS_TEXT_TEXTFIELD_SCRIPT, SwServiceType::FieldTypeScript }, + { CSS_TEXT_TEXTFIELD_DATABASE_NEXT_SET, SwServiceType::FieldTypeDatabaseNextSet }, + { CSS_TEXT_TEXTFIELD_DATABASE_NUMBER_OF_SET, SwServiceType::FieldTypeDatabaseNumSet }, + { CSS_TEXT_TEXTFIELD_DATABASE_SET_NUMBER, SwServiceType::FieldTypeDatabaseSetNum }, + { CSS_TEXT_TEXTFIELD_DATABASE, SwServiceType::FieldTypeDatabase }, + { CSS_TEXT_TEXTFIELD_DATABASE_NAME, SwServiceType::FieldTypeDatabaseName }, + { CSS_TEXT_TEXTFIELD_TABLE_FORMULA, SwServiceType::FieldTypeTableFormula }, + { CSS_TEXT_TEXTFIELD_PAGE_COUNT, SwServiceType::FieldTypePageCount }, + { CSS_TEXT_TEXTFIELD_PARAGRAPH_COUNT, SwServiceType::FieldTypeParagraphCount }, + { CSS_TEXT_TEXTFIELD_WORD_COUNT, SwServiceType::FieldTypeWordCount }, + { CSS_TEXT_TEXTFIELD_CHARACTER_COUNT, SwServiceType::FieldTypeCharacterCount }, + { CSS_TEXT_TEXTFIELD_TABLE_COUNT, SwServiceType::FieldTypeTableCount }, + { CSS_TEXT_TEXTFIELD_GRAPHIC_OBJECT_COUNT, SwServiceType::FieldTypeGraphicObjectCount }, + { CSS_TEXT_TEXTFIELD_EMBEDDED_OBJECT_COUNT, SwServiceType::FieldTypeEmbeddedObjectCount }, + { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_AUTHOR, SwServiceType::FieldTypeDocInfoChangeAuthor }, + { CSS_TEXT_TEXTFIELD_DOCINFO_CHANGE_DATE_TIME, SwServiceType::FieldTypeDocInfoChangeDateTime }, + { CSS_TEXT_TEXTFIELD_DOCINFO_EDIT_TIME, SwServiceType::FieldTypeDocInfoEditTime }, + { CSS_TEXT_TEXTFIELD_DOCINFO_DESCRIPTION, SwServiceType::FieldTypeDocInfoDescription }, + { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_AUTHOR, SwServiceType::FieldTypeDocInfoCreateAuthor }, + { CSS_TEXT_TEXTFIELD_DOCINFO_CREATE_DATE_TIME, SwServiceType::FieldTypeDocInfoCreateDateTime }, + { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_AUTHOR, SwServiceType::FieldTypeDocInfoPrintAuthor }, + { CSS_TEXT_TEXTFIELD_DOCINFO_PRINT_DATE_TIME, SwServiceType::FieldTypeDocInfoPrintDateTime }, + { CSS_TEXT_TEXTFIELD_DOCINFO_KEY_WORDS, SwServiceType::FieldTypeDocInfoKeywords }, + { CSS_TEXT_TEXTFIELD_DOCINFO_SUBJECT, SwServiceType::FieldTypeDocInfoSubject }, + { CSS_TEXT_TEXTFIELD_DOCINFO_TITLE, SwServiceType::FieldTypeDocInfoTitle }, + { CSS_TEXT_TEXTFIELD_DOCINFO_REVISION, SwServiceType::FieldTypeDocInfoRevision }, + { CSS_TEXT_TEXTFIELD_DOCINFO_CUSTOM, SwServiceType::FieldTypeDocInfoCustom }, + { CSS_TEXT_TEXTFIELD_BIBLIOGRAPHY, SwServiceType::FieldTypeBibliography }, + { CSS_TEXT_TEXTFIELD_COMBINED_CHARACTERS, SwServiceType::FieldTypeCombinedCharacters }, + { CSS_TEXT_TEXTFIELD_DROP_DOWN, SwServiceType::FieldTypeDropdown }, + { CSS_TEXT_TEXTFIELD_INPUT_USER, SwServiceType::FieldTypeInputUser }, + { CSS_TEXT_TEXTFIELD_HIDDEN_TEXT, SwServiceType::FieldTypeHiddenText }, + { CSS_TEXT_FIELDMASTER_USER, SwServiceType::FieldMasterUser }, + { CSS_TEXT_FIELDMASTER_DDE, SwServiceType::FieldMasterDDE }, + { CSS_TEXT_FIELDMASTER_SET_EXPRESSION, SwServiceType::FieldMasterSetExp }, + { CSS_TEXT_FIELDMASTER_DATABASE, SwServiceType::FieldMasterDatabase }, + { CSS_TEXT_FIELDMASTER_BIBLIOGRAPHY, SwServiceType::FieldMasterBibliography }, + { "com.sun.star.style.TableStyle", SwServiceType::StyleTable }, + { "com.sun.star.style.CellStyle", SwServiceType::StyleCell }, + { "com.sun.star.text.LineBreak", SwServiceType::LineBreak }, + { "com.sun.star.text.ContentControl", SwServiceType::ContentControl } +}; + +const SvEventDescription* sw_GetSupportedMacroItems() +{ + static const SvEventDescription aMacroDescriptionsImpl[] = + { + { SvMacroItemId::OnMouseOver, "OnMouseOver" }, + { SvMacroItemId::OnMouseOut, "OnMouseOut" }, + { SvMacroItemId::NONE, nullptr } + }; + + return aMacroDescriptionsImpl; +} + +OUString SwXServiceProvider::GetProviderName(SwServiceType nObjectType) +{ + OUString sRet; + const sal_uInt16 nEntries = SAL_N_ELEMENTS(aProvNamesId); + if(static_cast<sal_uInt16>(nObjectType) < nEntries) + sRet = OUString::createFromAscii(aProvNamesId[static_cast<sal_uInt16>(nObjectType)].pName); + return sRet; +} + +uno::Sequence<OUString> SwXServiceProvider::GetAllServiceNames() +{ + const sal_uInt16 nEntries = SAL_N_ELEMENTS(aProvNamesId); + uno::Sequence<OUString> aRet(nEntries); + OUString* pArray = aRet.getArray(); + sal_uInt16 n = 0; + for(const ProvNamesId_Type & i : aProvNamesId) + { + OUString sProv(OUString::createFromAscii(i.pName)); + if(!sProv.isEmpty()) + { + pArray[n] = sProv; + n++; + } + } + aRet.realloc(n); + return aRet; + +} + +SwServiceType SwXServiceProvider::GetProviderType(std::u16string_view rServiceName) +{ + for(const ProvNamesId_Type & i : aProvNamesId) + { + if (o3tl::equalsAscii(rServiceName, i.pName)) + return i.nType; + } + return SwServiceType::Invalid; +} + +uno::Reference<uno::XInterface> +SwXServiceProvider::MakeInstance(SwServiceType nObjectType, SwDoc & rDoc) +{ + SolarMutexGuard aGuard; + uno::Reference< uno::XInterface > xRet; + switch(nObjectType) + { + case SwServiceType::TypeTextTable: + { + xRet = getXWeak(SwXTextTable::CreateXTextTable(nullptr).get()); + } + break; + case SwServiceType::TypeTextFrame: + { + xRet = getXWeak(SwXTextFrame::CreateXTextFrame(rDoc, nullptr).get()); + } + break; + case SwServiceType::TypeGraphic : + case SwServiceType::TypeTextGraphic /* #i47503# */ : + { + xRet = getXWeak(SwXTextGraphicObject::CreateXTextGraphicObject(rDoc, nullptr).get()); + + } + break; + case SwServiceType::TypeOLE : + { + xRet = getXWeak(SwXTextEmbeddedObject::CreateXTextEmbeddedObject(rDoc, nullptr).get()); + } + break; + case SwServiceType::TypeBookmark : + { + xRet = getXWeak(SwXBookmark::CreateXBookmark(rDoc, nullptr).get()); + } + break; + case SwServiceType::TypeFieldMark : + { + xRet = getXWeak(SwXFieldmark::CreateXFieldmark(rDoc, nullptr).get()); + } + break; + case SwServiceType::TypeFormFieldMark : + { + xRet = getXWeak(SwXFieldmark::CreateXFieldmark(rDoc, nullptr, true).get()); + } + break; + case SwServiceType::VbaObjectProvider : +#if HAVE_FEATURE_SCRIPTING + { + xRet = getXWeak(new SwVbaObjectForCodeNameProvider(rDoc.GetDocShell())); + } +#endif + break; + case SwServiceType::VbaCodeNameProvider : +#if HAVE_FEATURE_SCRIPTING + { + if (rDoc.GetDocShell() && ooo::vba::isAlienWordDoc(*rDoc.GetDocShell())) + { + xRet = getXWeak(new SwVbaCodeNameProvider(rDoc.GetDocShell())); + } + } +#endif + break; + case SwServiceType::VbaProjectNameProvider : +#if HAVE_FEATURE_SCRIPTING + { + uno::Reference< container::XNameContainer > xProjProv = rDoc.GetVBATemplateToProjectCache(); + if (!xProjProv.is() && rDoc.GetDocShell() + && ooo::vba::isAlienWordDoc(*rDoc.GetDocShell())) + { + xProjProv = new SwVbaProjectNameProvider; + rDoc.SetVBATemplateToProjectCache(xProjProv); + } + xRet = xProjProv; + } +#endif + break; + case SwServiceType::VbaGlobals : +#if HAVE_FEATURE_SCRIPTING + { + uno::Any aGlobs; + BasicManager *pBasicMan = rDoc.GetDocShell()->GetBasicManager(); + if (pBasicMan && !pBasicMan->GetGlobalUNOConstant("VBAGlobals", aGlobs)) + { + uno::Sequence< uno::Any > aArgs{ uno::Any(rDoc.GetDocShell()->GetModel()) }; + aGlobs <<= ::comphelper::getProcessServiceFactory()->createInstanceWithArguments( "ooo.vba.word.Globals", aArgs ); + pBasicMan->SetGlobalUNOConstant( "VBAGlobals", aGlobs ); + } + aGlobs >>= xRet; + } +#endif + break; + + case SwServiceType::TypeFootnote : + xRet = getXWeak(SwXFootnote::CreateXFootnote(rDoc, nullptr).get()); + break; + case SwServiceType::TypeEndnote : + xRet = getXWeak(SwXFootnote::CreateXFootnote(rDoc, nullptr, true).get()); + break; + case SwServiceType::ContentIndexMark : + case SwServiceType::UserIndexMark : + case SwServiceType::TypeIndexMark: + { + TOXTypes eType = TOX_INDEX; + if(SwServiceType::ContentIndexMark== nObjectType) + eType = TOX_CONTENT; + else if(SwServiceType::UserIndexMark == nObjectType) + eType = TOX_USER; + xRet = getXWeak(SwXDocumentIndexMark::CreateXDocumentIndexMark(rDoc, nullptr, eType).get()); + } + break; + case SwServiceType::ContentIndex : + case SwServiceType::UserIndex : + case SwServiceType::TypeIndex : + case SwServiceType::IndexIllustrations: + case SwServiceType::IndexObjects : + case SwServiceType::IndexTables: + case SwServiceType::IndexBibliography : + { + TOXTypes eType = TOX_INDEX; + if(SwServiceType::ContentIndex == nObjectType) + eType = TOX_CONTENT; + else if(SwServiceType::UserIndex == nObjectType) + eType = TOX_USER; + else if(SwServiceType::IndexIllustrations == nObjectType) + { + eType = TOX_ILLUSTRATIONS; + } + else if(SwServiceType::IndexObjects == nObjectType) + { + eType = TOX_OBJECTS; + } + else if(SwServiceType::IndexBibliography == nObjectType) + { + eType = TOX_AUTHORITIES; + } + else if(SwServiceType::IndexTables == nObjectType) + { + eType = TOX_TABLES; + } + xRet = getXWeak(SwXDocumentIndex::CreateXDocumentIndex(rDoc, nullptr, eType).get()); + } + break; + case SwServiceType::IndexHeaderSection : + case SwServiceType::TextSection : + xRet = getXWeak(SwXTextSection::CreateXTextSection(nullptr, + (SwServiceType::IndexHeaderSection == nObjectType)).get()); + + break; + case SwServiceType::ReferenceMark : + xRet = getXWeak(SwXReferenceMark::CreateXReferenceMark(rDoc, nullptr).get()); + break; + case SwServiceType::StyleCharacter: + case SwServiceType::StyleParagraph: + case SwServiceType::StyleConditionalParagraph: + case SwServiceType::StyleFrame: + case SwServiceType::StylePage: + case SwServiceType::StyleNumbering: + case SwServiceType::StyleTable: + case SwServiceType::StyleCell: + { + SfxStyleFamily eFamily = SfxStyleFamily::Char; + switch(nObjectType) + { + case SwServiceType::StyleParagraph: + eFamily = SfxStyleFamily::Para; + break; + case SwServiceType::StyleConditionalParagraph: + eFamily = SfxStyleFamily::Para; + xRet = SwXStyleFamilies::CreateStyleCondParagraph(rDoc); + break; + case SwServiceType::StyleFrame: + eFamily = SfxStyleFamily::Frame; + break; + case SwServiceType::StylePage: + eFamily = SfxStyleFamily::Page; + break; + case SwServiceType::StyleNumbering: + eFamily = SfxStyleFamily::Pseudo; + break; + case SwServiceType::StyleTable: + eFamily = SfxStyleFamily::Table; + break; + case SwServiceType::StyleCell: + eFamily = SfxStyleFamily::Cell; + break; + default: break; + } + if(!xRet.is()) + xRet = SwXStyleFamilies::CreateStyle(eFamily, rDoc); + } + break; + case SwServiceType::FieldTypeDateTime: + case SwServiceType::FieldTypeUser: + case SwServiceType::FieldTypeSetExp: + case SwServiceType::FieldTypeGetExp: + case SwServiceType::FieldTypeFileName: + case SwServiceType::FieldTypePageNum: + case SwServiceType::FieldTypeAuthor: + case SwServiceType::FieldTypeChapter: + case SwServiceType::FieldTypeGetReference: + case SwServiceType::FieldTypeConditionedText: + case SwServiceType::FieldTypeInput: + case SwServiceType::FieldTypeMacro: + case SwServiceType::FieldTypeDDE: + case SwServiceType::FieldTypeHiddenPara: + case SwServiceType::FieldTypeDocInfo: + case SwServiceType::FieldTypeTemplateName: + case SwServiceType::FieldTypeUserExt: + case SwServiceType::FieldTypeRefPageSet: + case SwServiceType::FieldTypeRefPageGet: + case SwServiceType::FieldTypeJumpEdit: + case SwServiceType::FieldTypeScript: + case SwServiceType::FieldTypeDatabaseNextSet: + case SwServiceType::FieldTypeDatabaseNumSet: + case SwServiceType::FieldTypeDatabaseSetNum: + case SwServiceType::FieldTypeDatabase: + case SwServiceType::FieldTypeDatabaseName: + case SwServiceType::FieldTypePageCount: + case SwServiceType::FieldTypeParagraphCount: + case SwServiceType::FieldTypeWordCount: + case SwServiceType::FieldTypeCharacterCount: + case SwServiceType::FieldTypeTableCount: + case SwServiceType::FieldTypeGraphicObjectCount: + case SwServiceType::FieldTypeEmbeddedObjectCount: + case SwServiceType::FieldTypeDocInfoChangeAuthor: + case SwServiceType::FieldTypeDocInfoChangeDateTime: + case SwServiceType::FieldTypeDocInfoEditTime: + case SwServiceType::FieldTypeDocInfoDescription: + case SwServiceType::FieldTypeDocInfoCreateAuthor: + case SwServiceType::FieldTypeDocInfoCreateDateTime: + case SwServiceType::FieldTypeDocInfoCustom: + case SwServiceType::FieldTypeDocInfoPrintAuthor: + case SwServiceType::FieldTypeDocInfoPrintDateTime: + case SwServiceType::FieldTypeDocInfoKeywords: + case SwServiceType::FieldTypeDocInfoSubject: + case SwServiceType::FieldTypeDocInfoTitle: + case SwServiceType::FieldTypeDocInfoRevision: + case SwServiceType::FieldTypeBibliography: + case SwServiceType::FieldTypeInputUser: + case SwServiceType::FieldTypeHiddenText: + case SwServiceType::FieldTypeCombinedCharacters: + case SwServiceType::FieldTypeDropdown: + case SwServiceType::FieldTypeTableFormula: + // NOTE: the sw.SwXAutoTextEntry unoapi test depends on pDoc = 0 + xRet = getXWeak(SwXTextField::CreateXTextField(nullptr, nullptr, nObjectType).get()); + break; + case SwServiceType::FieldTypeAnnotation: + xRet = getXWeak(SwXTextField::CreateXTextField(&rDoc, nullptr, nObjectType).get()); + break; + case SwServiceType::FieldMasterUser: + case SwServiceType::FieldMasterDDE: + case SwServiceType::FieldMasterSetExp : + case SwServiceType::FieldMasterDatabase: + { + SwFieldIds nResId = SwFieldIds::Unknown; + switch(nObjectType) + { + case SwServiceType::FieldMasterUser: nResId = SwFieldIds::User; break; + case SwServiceType::FieldMasterDDE: nResId = SwFieldIds::Dde; break; + case SwServiceType::FieldMasterSetExp : nResId = SwFieldIds::SetExp; break; + case SwServiceType::FieldMasterDatabase: nResId = SwFieldIds::Database; break; + default: break; + } + xRet = getXWeak(SwXFieldMaster::CreateXFieldMaster(&rDoc, nullptr, nResId).get()); + } + break; + case SwServiceType::FieldMasterBibliography: + { + SwFieldType* pType = rDoc.getIDocumentFieldsAccess().GetFieldType(SwFieldIds::TableOfAuthorities, OUString(), true); + if(!pType) + { + SwAuthorityFieldType aType(&rDoc); + pType = rDoc.getIDocumentFieldsAccess().InsertFieldType(aType); + } + xRet = getXWeak(SwXFieldMaster::CreateXFieldMaster(&rDoc, pType).get()); + } + break; + case SwServiceType::Paragraph: + xRet = getXWeak(SwXParagraph::CreateXParagraph(rDoc, nullptr, nullptr).get()); + break; + case SwServiceType::NumberingRules: + xRet = getXWeak(new SwXNumberingRules(rDoc)); + break; + case SwServiceType::TextColumns: + xRet = SvxXTextColumns_createInstance(); + break; + case SwServiceType::Defaults: + xRet = getXWeak(new SwXTextDefaults(&rDoc)); + break; + case SwServiceType::IMapRectangle: + xRet = SvUnoImageMapRectangleObject_createInstance( sw_GetSupportedMacroItems() ); + break; + case SwServiceType::IMapCircle: + xRet = SvUnoImageMapCircleObject_createInstance( sw_GetSupportedMacroItems() ); + break; + case SwServiceType::IMapPolygon: + xRet = SvUnoImageMapPolygonObject_createInstance( sw_GetSupportedMacroItems() ); + break; + case SwServiceType::Chart2DataProvider: + // #i64497# If a chart is in a temporary document during clipboard + // paste, there should be no data provider, so that own data is used + // This should not happen during copy/paste, as this will unlink + // charts using table data. + if (rDoc.GetDocShell()->GetCreateMode() != SfxObjectCreateMode::EMBEDDED) + xRet = getXWeak(rDoc.getIDocumentChartDataProviderAccess().GetChartDataProvider( true /* create - if not yet available */ )); + else + SAL_WARN("sw.uno", + "not creating chart data provider for embedded object"); + + break; + case SwServiceType::TypeMeta: + xRet = getXWeak(SwXMeta::CreateXMeta(rDoc, false).get()); + break; + case SwServiceType::FieldTypeMetafield: + xRet = getXWeak(SwXMeta::CreateXMeta(rDoc, true).get()); + break; + case SwServiceType::LineBreak: + xRet = getXWeak(SwXLineBreak::CreateXLineBreak(nullptr).get()); + break; + case SwServiceType::ContentControl: + xRet = getXWeak(SwXContentControl::CreateXContentControl(rDoc).get()); + break; + default: + throw uno::RuntimeException(); + } + return xRet; +} + +//SMART_UNO_IMPLEMENTATION( SwXTextTables, UsrObject ); +SwXTextTables::SwXTextTables(SwDoc* pDc) : + SwUnoCollection(pDc) +{ + +} + +SwXTextTables::~SwXTextTables() +{ + +} + +sal_Int32 SwXTextTables::getCount() +{ + SolarMutexGuard aGuard; + sal_Int32 nRet = 0; + if(IsValid()) + nRet = static_cast<sal_Int32>(GetDoc().GetTableFrameFormatCount(true)); + return nRet; +} + +uno::Any SAL_CALL SwXTextTables::getByIndex(sal_Int32 nInputIndex) +{ + SolarMutexGuard aGuard; + + if (nInputIndex < 0) + throw IndexOutOfBoundsException(); + + size_t nIndex = static_cast<size_t>(nInputIndex); + for(SwTableFormat* pFormat: *GetDoc().GetTableFrameFormats()) + { + if(!pFormat->IsUsed()) + continue; + if(nIndex) + --nIndex; + else + { + uno::Reference<XTextTable> xTable = SwXTextTables::GetObject(*pFormat); + uno::Any aRet; + aRet <<= xTable; + return aRet; + } + } + throw IndexOutOfBoundsException(); +} + +uno::Any SwXTextTables::getByName(const OUString& rItemName) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + + const size_t nCount = GetDoc().GetTableFrameFormatCount(true); + uno::Reference< XTextTable > xTable; + for( size_t i = 0; i < nCount; ++i) + { + SwFrameFormat& rFormat = GetDoc().GetTableFrameFormat(i, true); + if (rItemName == rFormat.GetName()) + { + xTable = SwXTextTables::GetObject(rFormat); + aRet <<= xTable; + break; + } + } + if(!xTable.is()) + throw NoSuchElementException(); + + return aRet; +} + +uno::Sequence< OUString > SwXTextTables::getElementNames() +{ + SolarMutexGuard aGuard; + const size_t nCount = GetDoc().GetTableFrameFormatCount(true); + uno::Sequence<OUString> aSeq(static_cast<sal_Int32>(nCount)); + if(nCount) + { + OUString* pArray = aSeq.getArray(); + for( size_t i = 0; i < nCount; ++i) + { + SwFrameFormat& rFormat = GetDoc().GetTableFrameFormat(i, true); + + pArray[i] = rFormat.GetName(); + } + } + return aSeq; +} + +sal_Bool SwXTextTables::hasByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + bool bRet= false; + + const size_t nCount = GetDoc().GetTableFrameFormatCount(true); + for( size_t i = 0; i < nCount; ++i) + { + SwFrameFormat& rFormat = GetDoc().GetTableFrameFormat(i, true); + if (rName == rFormat.GetName()) + { + bRet = true; + break; + } + } + return bRet; +} + +uno::Type SAL_CALL + SwXTextTables::getElementType( ) +{ + return cppu::UnoType<XTextTable>::get(); +} + +sal_Bool SwXTextTables::hasElements() +{ + SolarMutexGuard aGuard; + return 0 != GetDoc().GetTableFrameFormatCount(true); +} + +OUString SwXTextTables::getImplementationName() +{ + return "SwXTextTables"; +} + +sal_Bool SwXTextTables::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +uno::Sequence< OUString > SwXTextTables::getSupportedServiceNames() +{ + return { "com.sun.star.text.TextTables" }; +} + +uno::Reference<text::XTextTable> SwXTextTables::GetObject(SwFrameFormat& rFormat) +{ + return SwXTextTable::CreateXTextTable(& rFormat); +} + +namespace +{ + template<FlyCntType T> struct UnoFrameWrap_traits {}; + + template<> + struct UnoFrameWrap_traits<FLYCNTTYPE_FRM> + { + static uno::Any wrapFrame(SwFrameFormat & rFrameFormat) + { + uno::Reference<text::XTextFrame> const xRet( + SwXTextFrame::CreateXTextFrame(*rFrameFormat.GetDoc(), &rFrameFormat)); + return uno::Any(xRet); + } + static bool filter(const SwNode* const pNode) { return !pNode->IsNoTextNode(); }; + }; + + template<> + struct UnoFrameWrap_traits<FLYCNTTYPE_GRF> + { + static uno::Any wrapFrame(SwFrameFormat & rFrameFormat) + { + uno::Reference<text::XTextContent> const xRet( + SwXTextGraphicObject::CreateXTextGraphicObject(*rFrameFormat.GetDoc(), &rFrameFormat)); + return uno::Any(xRet); + } + static bool filter(const SwNode* const pNode) { return pNode->IsGrfNode(); }; + }; + + template<> + struct UnoFrameWrap_traits<FLYCNTTYPE_OLE> + { + static uno::Any wrapFrame(SwFrameFormat & rFrameFormat) + { + uno::Reference<text::XTextContent> const xRet( + SwXTextEmbeddedObject::CreateXTextEmbeddedObject(*rFrameFormat.GetDoc(), &rFrameFormat)); + return uno::Any(xRet); + } + static bool filter(const SwNode* const pNode) { return pNode->IsOLENode(); }; + }; + + template<FlyCntType T> + uno::Any lcl_UnoWrapFrame(SwFrameFormat* pFormat) + { + return UnoFrameWrap_traits<T>::wrapFrame(*pFormat); + } + + // runtime adapter for lcl_UnoWrapFrame + /// @throws uno::RuntimeException + uno::Any lcl_UnoWrapFrame(SwFrameFormat* pFormat, FlyCntType eType) + { + switch(eType) + { + case FLYCNTTYPE_FRM: + return lcl_UnoWrapFrame<FLYCNTTYPE_FRM>(pFormat); + case FLYCNTTYPE_GRF: + return lcl_UnoWrapFrame<FLYCNTTYPE_GRF>(pFormat); + case FLYCNTTYPE_OLE: + return lcl_UnoWrapFrame<FLYCNTTYPE_OLE>(pFormat); + default: + throw uno::RuntimeException(); + } + } + + template<FlyCntType T> + class SwXFrameEnumeration + : public SwSimpleEnumeration_Base + { + private: + std::vector< Any > m_aFrames; + protected: + virtual ~SwXFrameEnumeration() override {}; + public: + SwXFrameEnumeration(const SwDoc& rDoc); + + //XEnumeration + virtual sal_Bool SAL_CALL hasMoreElements() override; + virtual Any SAL_CALL nextElement() override; + + //XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override; + virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + }; +} + +template<FlyCntType T> +SwXFrameEnumeration<T>::SwXFrameEnumeration(const SwDoc& rDoc) +{ + SolarMutexGuard aGuard; + for(sw::SpzFrameFormat* pFormat: *rDoc.GetSpzFrameFormats()) + { + // #i104937# + if(pFormat->Which() != RES_FLYFRMFMT || SwTextBoxHelper::isTextBox(pFormat, RES_FLYFRMFMT)) + continue; + const SwNodeIndex* pIdx = pFormat->GetContent().GetContentIdx(); + if(!pIdx || !pIdx->GetNodes().IsDocNodes()) + continue; + const SwNode* pNd = rDoc.GetNodes()[ pIdx->GetIndex() + 1 ]; + if(UnoFrameWrap_traits<T>::filter(pNd)) + m_aFrames.push_back(lcl_UnoWrapFrame<T>(pFormat)); + } +} + +template<FlyCntType T> +sal_Bool SwXFrameEnumeration<T>::hasMoreElements() +{ + SolarMutexGuard aGuard; + return !m_aFrames.empty(); +} + +template<FlyCntType T> +Any SwXFrameEnumeration<T>::nextElement() +{ + SolarMutexGuard aGuard; + if(m_aFrames.empty()) + throw NoSuchElementException(); + + Any aResult = m_aFrames.back(); + m_aFrames.pop_back(); + return aResult; +} + +template<FlyCntType T> +OUString SwXFrameEnumeration<T>::getImplementationName() +{ + return "SwXFrameEnumeration"; +} + +template<FlyCntType T> +sal_Bool SwXFrameEnumeration<T>::supportsService(const OUString& ServiceName) +{ + return cppu::supportsService(this, ServiceName); +} + +template<FlyCntType T> +Sequence< OUString > SwXFrameEnumeration<T>::getSupportedServiceNames() +{ + return { OUString("com.sun.star.container.XEnumeration") }; +} + +OUString SwXFrames::getImplementationName() +{ + return "SwXFrames"; +} + +sal_Bool SwXFrames::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence<OUString> SwXFrames::getSupportedServiceNames() +{ + return { OUString("com.sun.star.text.TextFrames") }; +} + +SwXFrames::SwXFrames(SwDoc* _pDoc, FlyCntType eSet) : + SwUnoCollection(_pDoc), + m_eType(eSet) +{} + +SwXFrames::~SwXFrames() +{} + +uno::Reference<container::XEnumeration> SwXFrames::createEnumeration() +{ + SolarMutexGuard aGuard; + switch(m_eType) + { + case FLYCNTTYPE_FRM: + return uno::Reference< container::XEnumeration >( + new SwXFrameEnumeration<FLYCNTTYPE_FRM>(GetDoc())); + case FLYCNTTYPE_GRF: + return uno::Reference< container::XEnumeration >( + new SwXFrameEnumeration<FLYCNTTYPE_GRF>(GetDoc())); + case FLYCNTTYPE_OLE: + return uno::Reference< container::XEnumeration >( + new SwXFrameEnumeration<FLYCNTTYPE_OLE>(GetDoc())); + default: + throw uno::RuntimeException(); + } +} + +sal_Int32 SwXFrames::getCount() +{ + SolarMutexGuard aGuard; + // Ignore TextBoxes for TextFrames. + return static_cast<sal_Int32>(GetDoc().GetFlyCount(m_eType, /*bIgnoreTextBoxes=*/m_eType == FLYCNTTYPE_FRM)); +} + +uno::Any SwXFrames::getByIndex(sal_Int32 nIndex) +{ + SolarMutexGuard aGuard; + if(nIndex < 0) + throw IndexOutOfBoundsException(); + // Ignore TextBoxes for TextFrames. + SwFrameFormat* pFormat = GetDoc().GetFlyNum(static_cast<size_t>(nIndex), m_eType, /*bIgnoreTextBoxes=*/m_eType == FLYCNTTYPE_FRM); + if(!pFormat) + throw IndexOutOfBoundsException(); + return lcl_UnoWrapFrame(pFormat, m_eType); +} + +uno::Any SwXFrames::getByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + const SwFrameFormat* pFormat; + switch(m_eType) + { + case FLYCNTTYPE_GRF: + pFormat = GetDoc().FindFlyByName(rName, SwNodeType::Grf); + break; + case FLYCNTTYPE_OLE: + pFormat = GetDoc().FindFlyByName(rName, SwNodeType::Ole); + break; + default: + pFormat = GetDoc().FindFlyByName(rName, SwNodeType::Text); + break; + } + if(!pFormat) + throw NoSuchElementException(); + return lcl_UnoWrapFrame(const_cast<SwFrameFormat*>(pFormat), m_eType); +} + +uno::Sequence<OUString> SwXFrames::getElementNames() +{ + SolarMutexGuard aGuard; + const Reference<XEnumeration> xEnum = createEnumeration(); + std::vector<OUString> vNames; + while(xEnum->hasMoreElements()) + { + Reference<container::XNamed> xNamed; + xEnum->nextElement() >>= xNamed; + if(xNamed.is()) + vNames.push_back(xNamed->getName()); + } + return ::comphelper::containerToSequence(vNames); +} + +sal_Bool SwXFrames::hasByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + switch(m_eType) + { + case FLYCNTTYPE_GRF: + return GetDoc().FindFlyByName(rName, SwNodeType::Grf) != nullptr; + case FLYCNTTYPE_OLE: + return GetDoc().FindFlyByName(rName, SwNodeType::Ole) != nullptr; + default: + return GetDoc().FindFlyByName(rName, SwNodeType::Text) != nullptr; + } +} + +uno::Type SAL_CALL SwXFrames::getElementType() +{ + SolarMutexGuard aGuard; + switch(m_eType) + { + case FLYCNTTYPE_FRM: + return cppu::UnoType<XTextFrame>::get(); + case FLYCNTTYPE_GRF: + return cppu::UnoType<XTextContent>::get(); + case FLYCNTTYPE_OLE: + return cppu::UnoType<XEmbeddedObjectSupplier>::get(); + default: + return uno::Type(); + } +} + +sal_Bool SwXFrames::hasElements() +{ + SolarMutexGuard aGuard; + return GetDoc().GetFlyCount(m_eType) > 0; +} + + +OUString SwXTextFrames::getImplementationName() +{ + return "SwXTextFrames"; +} + +sal_Bool SwXTextFrames::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXTextFrames::getSupportedServiceNames() +{ + return { "com.sun.star.text.TextFrames" }; +} + +SwXTextFrames::SwXTextFrames(SwDoc* _pDoc) : + SwXFrames(_pDoc, FLYCNTTYPE_FRM) +{ +} + +SwXTextFrames::~SwXTextFrames() +{ +} + +OUString SwXTextGraphicObjects::getImplementationName() +{ + return "SwXTextGraphicObjects"; +} + +sal_Bool SwXTextGraphicObjects::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXTextGraphicObjects::getSupportedServiceNames() +{ + return { "com.sun.star.text.TextGraphicObjects" }; +} + +SwXTextGraphicObjects::SwXTextGraphicObjects(SwDoc* _pDoc) : + SwXFrames(_pDoc, FLYCNTTYPE_GRF) +{ +} + +SwXTextGraphicObjects::~SwXTextGraphicObjects() +{ +} + +OUString SwXTextEmbeddedObjects::getImplementationName() +{ + return "SwXTextEmbeddedObjects"; +} + +sal_Bool SwXTextEmbeddedObjects::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXTextEmbeddedObjects::getSupportedServiceNames() +{ + return { "com.sun.star.text.TextEmbeddedObjects" }; +} + +SwXTextEmbeddedObjects::SwXTextEmbeddedObjects(SwDoc* _pDoc) : + SwXFrames(_pDoc, FLYCNTTYPE_OLE) +{ +} + +SwXTextEmbeddedObjects::~SwXTextEmbeddedObjects() +{ +} + +OUString SwXTextSections::getImplementationName() +{ + return "SwXTextSections"; +} + +sal_Bool SwXTextSections::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXTextSections::getSupportedServiceNames() +{ + return { "com.sun.star.text.TextSections" }; +} + +SwXTextSections::SwXTextSections(SwDoc* _pDoc) : + SwUnoCollection(_pDoc) +{ +} + +SwXTextSections::~SwXTextSections() +{ +} + +sal_Int32 SwXTextSections::getCount() +{ + SolarMutexGuard aGuard; + const SwSectionFormats& rSectFormats = GetDoc().GetSections(); + size_t nCount = rSectFormats.size(); + for(size_t i = nCount; i; --i) + { + if( !rSectFormats[i - 1]->IsInNodesArr()) + nCount--; + } + return nCount; +} + +uno::Any SwXTextSections::getByIndex(sal_Int32 nIndex) +{ + if (nIndex < 0) + throw IndexOutOfBoundsException(); + size_t nIndex2 = nIndex; + SolarMutexGuard aGuard; + + const SwSectionFormats& rSectFormats = GetDoc().GetSections(); + const size_t nCount = rSectFormats.size(); + for(size_t i = 0; i < nCount; ++i) + { + if( !rSectFormats[i]->IsInNodesArr()) + nIndex2++; + else if (nIndex2 == i) + return Any(GetObject(*rSectFormats[i])); + } + throw IndexOutOfBoundsException(); +} + +uno::Any SwXTextSections::getByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + + SwSectionFormats& rFormats = GetDoc().GetSections(); + uno::Reference< XTextSection > xSect; + for(size_t i = 0; i < rFormats.size(); ++i) + { + SwSectionFormat* pFormat = rFormats[i]; + if (pFormat->IsInNodesArr() + && (rName == pFormat->GetSection()->GetSectionName())) + { + xSect = GetObject(*pFormat); + aRet <<= xSect; + break; + } + } + if(!xSect.is()) + throw NoSuchElementException(); + + return aRet; +} + +uno::Sequence< OUString > SwXTextSections::getElementNames() +{ + SolarMutexGuard aGuard; + SwSectionFormats& rSectFormats = GetDoc().GetSections(); + size_t nCount = rSectFormats.size(); + for(size_t i = nCount; i; --i) + { + if( !rSectFormats[i - 1]->IsInNodesArr()) + nCount--; + } + + uno::Sequence<OUString> aSeq(nCount); + if(nCount) + { + OUString* pArray = aSeq.getArray(); + size_t nIndex = 0; + for( size_t i = 0; i < nCount; ++i, ++nIndex) + { + const SwSectionFormat* pFormat = rSectFormats[nIndex]; + while(!pFormat->IsInNodesArr()) + { + pFormat = rSectFormats[++nIndex]; + } + pArray[i] = pFormat->GetSection()->GetSectionName(); + } + } + return aSeq; +} + +sal_Bool SwXTextSections::hasByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + bool bRet = false; + if(IsValid()) + { + SwSectionFormats& rFormats = GetDoc().GetSections(); + for(size_t i = 0; i < rFormats.size(); ++i) + { + const SwSectionFormat* pFormat = rFormats[i]; + if (rName == pFormat->GetSection()->GetSectionName()) + { + bRet = true; + break; + } + } + } + else + { + // special handling for dbg_ methods + if( !rName.startsWith("dbg_")) + throw uno::RuntimeException(); + } + return bRet; +} + +uno::Type SAL_CALL SwXTextSections::getElementType() +{ + return cppu::UnoType<XTextSection>::get(); +} + +sal_Bool SwXTextSections::hasElements() +{ + SolarMutexGuard aGuard; + size_t nCount = 0; + + SwSectionFormats& rFormats = GetDoc().GetSections(); + nCount = rFormats.size(); + + return nCount > 0; +} + +uno::Reference< XTextSection > SwXTextSections::GetObject( SwSectionFormat& rFormat ) +{ + return SwXTextSection::CreateXTextSection(&rFormat); +} + +OUString SwXBookmarks::getImplementationName() +{ + return "SwXBookmarks"; +} + +sal_Bool SwXBookmarks::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXBookmarks::getSupportedServiceNames() +{ + return { "com.sun.star.text.Bookmarks" }; +} + +SwXBookmarks::SwXBookmarks(SwDoc* _pDoc) : + SwUnoCollection(_pDoc) +{ } + +SwXBookmarks::~SwXBookmarks() +{ } + +sal_Int32 SwXBookmarks::getCount() +{ + SolarMutexGuard aGuard; + + sal_Int32 count(0); + IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess(); + for (IDocumentMarkAccess::const_iterator_t ppMark = + pMarkAccess->getBookmarksBegin(); + ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark) + { + if (IDocumentMarkAccess::MarkType::BOOKMARK == + IDocumentMarkAccess::GetType(**ppMark)) + { + ++count; // only count real bookmarks + } + } + return count; +} + +uno::Any SwXBookmarks::getByIndex(sal_Int32 nIndex) +{ + SolarMutexGuard aGuard; + auto& rDoc = GetDoc(); + IDocumentMarkAccess* const pMarkAccess = rDoc.getIDocumentMarkAccess(); + if(nIndex < 0 || nIndex >= pMarkAccess->getBookmarksCount()) + throw IndexOutOfBoundsException(); + + sal_Int32 count(0); + for (IDocumentMarkAccess::const_iterator_t ppMark = + pMarkAccess->getBookmarksBegin(); + ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark) + { + if (IDocumentMarkAccess::MarkType::BOOKMARK == + IDocumentMarkAccess::GetType(**ppMark)) + { + if (count == nIndex) + { + uno::Any aRet; + const uno::Reference< text::XTextContent > xRef = + SwXBookmark::CreateXBookmark(rDoc, *ppMark); + aRet <<= xRef; + return aRet; + } + ++count; // only count real bookmarks + } + } + throw IndexOutOfBoundsException(); +} + +uno::Any SwXBookmarks::getByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + + auto& rDoc = GetDoc(); + IDocumentMarkAccess* const pMarkAccess = rDoc.getIDocumentMarkAccess(); + IDocumentMarkAccess::const_iterator_t ppBkmk = pMarkAccess->findBookmark(rName); + if(ppBkmk == pMarkAccess->getBookmarksEnd()) + throw NoSuchElementException(); + + uno::Any aRet; + const uno::Reference< text::XTextContent > xRef = + SwXBookmark::CreateXBookmark(rDoc, *ppBkmk); + aRet <<= xRef; + return aRet; +} + +uno::Sequence< OUString > SwXBookmarks::getElementNames() +{ + SolarMutexGuard aGuard; + + std::vector< OUString > ret; + IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess(); + for (IDocumentMarkAccess::const_iterator_t ppMark = + pMarkAccess->getBookmarksBegin(); + ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark) + { + if (IDocumentMarkAccess::MarkType::BOOKMARK == + IDocumentMarkAccess::GetType(**ppMark)) + { + ret.push_back((*ppMark)->GetName()); // only add real bookmarks + } + } + return comphelper::containerToSequence(ret); +} + +sal_Bool SwXBookmarks::hasByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + + IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess(); + return pMarkAccess->findBookmark(rName) != pMarkAccess->getBookmarksEnd(); +} + +uno::Type SAL_CALL SwXBookmarks::getElementType() +{ + return cppu::UnoType<XTextContent>::get(); +} + +sal_Bool SwXBookmarks::hasElements() +{ + SolarMutexGuard aGuard; + + IDocumentMarkAccess* const pMarkAccess = GetDoc().getIDocumentMarkAccess(); + for (IDocumentMarkAccess::const_iterator_t ppMark = + pMarkAccess->getBookmarksBegin(); + ppMark != pMarkAccess->getBookmarksEnd(); ++ppMark) + { + if (IDocumentMarkAccess::MarkType::BOOKMARK == + IDocumentMarkAccess::GetType(**ppMark)) + { + return true; + } + } + return false; +} + +SwXNumberingRulesCollection::SwXNumberingRulesCollection( SwDoc* _pDoc ) : + SwUnoCollection(_pDoc) +{ +} + +SwXNumberingRulesCollection::~SwXNumberingRulesCollection() +{ +} + +sal_Int32 SwXNumberingRulesCollection::getCount() +{ + SolarMutexGuard aGuard; + return GetDoc().GetNumRuleTable().size(); +} + +uno::Any SwXNumberingRulesCollection::getByIndex(sal_Int32 nIndex) +{ + if (nIndex < 0) + throw IndexOutOfBoundsException(); + + SolarMutexGuard aGuard; + + if (SwDoc& rDoc = GetDoc(); o3tl::make_unsigned(nIndex) < rDoc.GetNumRuleTable().size()) + { + uno::Reference<XIndexReplace> xRef( + new SwXNumberingRules(*rDoc.GetNumRuleTable()[nIndex], &rDoc)); + return uno::Any(xRef); + } + + throw IndexOutOfBoundsException(); +} + +uno::Type SAL_CALL SwXNumberingRulesCollection::getElementType() +{ + return cppu::UnoType<XIndexReplace>::get(); +} + +sal_Bool SwXNumberingRulesCollection::hasElements() +{ + SolarMutexGuard aGuard; + return !GetDoc().GetNumRuleTable().empty(); +} + +OUString SwXFootnotes::getImplementationName() +{ + return "SwXFootnotes"; +} + +sal_Bool SwXFootnotes::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXFootnotes::getSupportedServiceNames() +{ + return { "com.sun.star.text.Footnotes" }; +} + +SwXFootnotes::SwXFootnotes(bool bEnd, SwDoc* _pDoc) + : SwUnoCollection(_pDoc) + , m_bEndnote(bEnd) +{ +} + +SwXFootnotes::~SwXFootnotes() +{ +} + +sal_Int32 SwXFootnotes::getCount() +{ + SolarMutexGuard aGuard; + sal_Int32 nCount = 0; + auto& rIdxs = GetDoc().GetFootnoteIdxs(); + const size_t nFootnoteCnt = rIdxs.size(); + SwTextFootnote* pTextFootnote; + for( size_t n = 0; n < nFootnoteCnt; ++n ) + { + pTextFootnote = rIdxs[n]; + const SwFormatFootnote& rFootnote = pTextFootnote->GetFootnote(); + if ( rFootnote.IsEndNote() != m_bEndnote ) + continue; + nCount++; + } + return nCount; +} + +uno::Any SwXFootnotes::getByIndex(sal_Int32 nIndex) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + sal_Int32 nCount = 0; + + auto& rDoc = GetDoc(); + auto& rIdxs = rDoc.GetFootnoteIdxs(); + const size_t nFootnoteCnt = rIdxs.size(); + SwTextFootnote* pTextFootnote; + uno::Reference< XFootnote > xRef; + for( size_t n = 0; n < nFootnoteCnt; ++n ) + { + pTextFootnote = rIdxs[n]; + const SwFormatFootnote& rFootnote = pTextFootnote->GetFootnote(); + if ( rFootnote.IsEndNote() != m_bEndnote ) + continue; + + if(nCount == nIndex) + { + xRef = SwXFootnote::CreateXFootnote(rDoc, + &const_cast<SwFormatFootnote&>(rFootnote)); + aRet <<= xRef; + break; + } + nCount++; + } + if(!xRef.is()) + throw IndexOutOfBoundsException(); + + return aRet; +} + +uno::Type SAL_CALL SwXFootnotes::getElementType() +{ + return cppu::UnoType<XFootnote>::get(); +} + +sal_Bool SwXFootnotes::hasElements() +{ + SolarMutexGuard aGuard; + return !GetDoc().GetFootnoteIdxs().empty(); +} + +Reference<XFootnote> SwXFootnotes::GetObject( SwDoc& rDoc, const SwFormatFootnote& rFormat ) +{ + return SwXFootnote::CreateXFootnote(rDoc, &const_cast<SwFormatFootnote&>(rFormat)); +} + +OUString SwXReferenceMarks::getImplementationName() +{ + return "SwXReferenceMarks"; +} + +sal_Bool SwXReferenceMarks::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXReferenceMarks::getSupportedServiceNames() +{ + return { "com.sun.star.text.ReferenceMarks" }; +} + +SwXReferenceMarks::SwXReferenceMarks(SwDoc* _pDoc) : + SwUnoCollection(_pDoc) +{ +} + +SwXReferenceMarks::~SwXReferenceMarks() +{ +} + +sal_Int32 SwXReferenceMarks::getCount() +{ + SolarMutexGuard aGuard; + return GetDoc().GetRefMarks(); +} + +uno::Any SwXReferenceMarks::getByIndex(sal_Int32 nIndex) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + uno::Reference< XTextContent > xRef; + if(0 <= nIndex && nIndex < SAL_MAX_UINT16) + { + auto& rDoc = GetDoc(); + SwFormatRefMark *const pMark = const_cast<SwFormatRefMark*>( + rDoc.GetRefMark(o3tl::narrowing<sal_uInt16>(nIndex))); + if(pMark) + { + xRef = SwXReferenceMark::CreateXReferenceMark(rDoc, pMark); + aRet <<= xRef; + } + } + if(!xRef.is()) + throw IndexOutOfBoundsException(); + return aRet; +} + +uno::Any SwXReferenceMarks::getByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + + auto& rDoc = GetDoc(); + SwFormatRefMark *const pMark = + const_cast<SwFormatRefMark*>(rDoc.GetRefMark(rName)); + if(!pMark) + throw NoSuchElementException(); + + uno::Reference<XTextContent> const xRef = + SwXReferenceMark::CreateXReferenceMark(rDoc, pMark); + aRet <<= xRef; + + return aRet; +} + +uno::Sequence< OUString > SwXReferenceMarks::getElementNames() +{ + SolarMutexGuard aGuard; + uno::Sequence<OUString> aRet; + + std::vector<OUString> aStrings; + const sal_uInt16 nCount = GetDoc().GetRefMarks(&aStrings); + aRet.realloc(nCount); + OUString* pNames = aRet.getArray(); + for(sal_uInt16 i = 0; i < nCount; i++) + pNames[i] = aStrings[i]; + + return aRet; +} + +sal_Bool SwXReferenceMarks::hasByName(const OUString& rName) +{ + SolarMutexGuard aGuard; + return nullptr != GetDoc().GetRefMark( rName); +} + +uno::Type SAL_CALL SwXReferenceMarks::getElementType() +{ + return cppu::UnoType<XTextContent>::get(); +} + +sal_Bool SwXReferenceMarks::hasElements() +{ + SolarMutexGuard aGuard; + return 0 != GetDoc().GetRefMarks(); +} + +SwDoc& SwUnoCollection::GetDoc() const +{ + DBG_TESTSOLARMUTEX(); + if (!m_pDoc) + throw uno::RuntimeException(); + return *m_pDoc; +} + +void SwUnoCollection::Invalidate() +{ + SolarMutexGuard aGuard; + m_pDoc = nullptr; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |