diff options
Diffstat (limited to '')
| -rw-r--r-- | sdext/source/presenter/PresenterTheme.cxx | 1060 |
1 files changed, 1060 insertions, 0 deletions
diff --git a/sdext/source/presenter/PresenterTheme.cxx b/sdext/source/presenter/PresenterTheme.cxx new file mode 100644 index 000000000..c84747d0f --- /dev/null +++ b/sdext/source/presenter/PresenterTheme.cxx @@ -0,0 +1,1060 @@ +/* -*- 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 "PresenterTheme.hxx" +#include "PresenterBitmapContainer.hxx" +#include "PresenterCanvasHelper.hxx" +#include "PresenterConfigurationAccess.hxx" +#include <com/sun/star/drawing/XPresenterHelper.hpp> +#include <com/sun/star/rendering/PanoseWeight.hpp> +#include <osl/diagnose.h> +#include <map> +#include <numeric> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::std; + +namespace sdext::presenter { + +namespace { + +class BorderSize +{ +public: + const static sal_Int32 mnInvalidValue = -10000; + + BorderSize() : mnLeft(mnInvalidValue), + mnTop(mnInvalidValue), + mnRight(mnInvalidValue), + mnBottom(mnInvalidValue) {} + + sal_Int32 mnLeft; + sal_Int32 mnTop; + sal_Int32 mnRight; + sal_Int32 mnBottom; + + vector<sal_Int32> ToVector() + { + return + { + mnLeft == mnInvalidValue ? 0 : mnLeft, + mnTop == mnInvalidValue ? 0 : mnTop, + mnRight == mnInvalidValue ? 0 : mnRight, + mnBottom == mnInvalidValue ? 0 : mnBottom + }; + }; + + void Merge (const BorderSize& rBorderSize) + { + if (mnLeft == mnInvalidValue) + mnLeft = rBorderSize.mnLeft; + if (mnTop == mnInvalidValue) + mnTop = rBorderSize.mnTop; + if (mnRight == mnInvalidValue) + mnRight = rBorderSize.mnRight; + if (mnBottom == mnInvalidValue) + mnBottom = rBorderSize.mnBottom; + } +}; + +/** Reading a theme from the configurations is done in various classes. The + ReadContext gives access to frequently used objects and functions to make + the configuration handling easier. +*/ +class ReadContext +{ +public: + Reference<XComponentContext> mxComponentContext; + Reference<rendering::XCanvas> mxCanvas; + Reference<drawing::XPresenterHelper> mxPresenterHelper; + + ReadContext ( + const Reference<XComponentContext>& rxContext, + const Reference<rendering::XCanvas>& rxCanvas); + + /** Read data describing a font from the node that can be reached from + the given root via the given path. + @param rsFontPath + May be empty. + */ + static PresenterTheme::SharedFontDescriptor ReadFont ( + const css::uno::Reference<css::container::XHierarchicalNameAccess>& rxTheme, + const PresenterTheme::SharedFontDescriptor& rpDefault); + static PresenterTheme::SharedFontDescriptor ReadFont ( + const Reference<beans::XPropertySet>& rxFontProperties, + const PresenterTheme::SharedFontDescriptor& rpDefault); + + std::shared_ptr<PresenterTheme::Theme> ReadTheme ( + PresenterConfigurationAccess& rConfiguration, + const OUString& rsThemeName); + + static BorderSize ReadBorderSize (const Reference<container::XNameAccess>& rxNode); + +private: + static Any GetByName ( + const Reference<container::XNameAccess>& rxNode, + const OUString& rsName); +}; + +/** A PaneStyle describes how a pane is rendered. +*/ +class PaneStyle +{ +public: + PaneStyle(); + + SharedBitmapDescriptor GetBitmap (const OUString& sBitmapName) const; + + OUString msStyleName; + std::shared_ptr<PaneStyle> mpParentStyle; + PresenterTheme::SharedFontDescriptor mpFont; + BorderSize maInnerBorderSize; + BorderSize maOuterBorderSize; + std::shared_ptr<PresenterBitmapContainer> mpBitmaps; + + PresenterTheme::SharedFontDescriptor GetFont() const; +}; + +typedef std::shared_ptr<PaneStyle> SharedPaneStyle; + +class PaneStyleContainer +{ +private: + ::std::vector<SharedPaneStyle> mStyles; + +public: + void Read ( + const ReadContext& rReadContext, + const Reference<container::XHierarchicalNameAccess>& rThemeRoot); + + SharedPaneStyle GetPaneStyle (const OUString& rsStyleName) const; + +private: + void ProcessPaneStyle ( + ReadContext const & rReadContext, + const ::std::vector<css::uno::Any>& rValues); +}; + +/** A ViewStyle describes how a view is displayed. +*/ +class ViewStyle +{ +public: + ViewStyle(); + + SharedBitmapDescriptor GetBitmap (std::u16string_view sBitmapName) const; + + PresenterTheme::SharedFontDescriptor GetFont() const; + + OUString msStyleName; + std::shared_ptr<ViewStyle> mpParentStyle; + PresenterTheme::SharedFontDescriptor mpFont; + SharedBitmapDescriptor mpBackground; +}; + +typedef std::shared_ptr<ViewStyle> SharedViewStyle; + +class ViewStyleContainer +{ +private: + ::std::vector<SharedViewStyle> mStyles; + +public: + void Read ( + const ReadContext& rReadContext, + const Reference<container::XHierarchicalNameAccess>& rThemeRoot); + + SharedViewStyle GetViewStyle (const OUString& rsStyleName) const; + +private: + void ProcessViewStyle( + ReadContext const & rReadContext, + const Reference<beans::XPropertySet>& rxProperties); +}; + +class StyleAssociationContainer +{ +public: + void Read ( + const Reference<container::XHierarchicalNameAccess>& rThemeRoot); + + OUString GetStyleName (const OUString& rsResourceName) const; + +private: + typedef map<OUString, OUString> StyleAssociations; + StyleAssociations maStyleAssociations; + + void ProcessStyleAssociation( + const ::std::vector<css::uno::Any>& rValues); +}; + +} // end of anonymous namespace + +class PresenterTheme::Theme +{ +public: + Theme ( + const Reference<container::XHierarchicalNameAccess>& rThemeRoot, + const OUString& rsNodeName); + + void Read ( + PresenterConfigurationAccess& rConfiguration, + ReadContext& rReadContext); + + OUString msConfigurationNodeName; + std::shared_ptr<Theme> mpParentTheme; + SharedBitmapDescriptor mpBackground; + PaneStyleContainer maPaneStyles; + ViewStyleContainer maViewStyles; + StyleAssociationContainer maStyleAssociations; + Reference<container::XHierarchicalNameAccess> mxThemeRoot; + std::shared_ptr<PresenterBitmapContainer> mpIconContainer; + typedef map<OUString,SharedFontDescriptor> FontContainer; + FontContainer maFontContainer; + + SharedPaneStyle GetPaneStyle (const OUString& rsStyleName) const; + SharedViewStyle GetViewStyle (const OUString& rsStyleName) const; + +private: + void ProcessFont( + const OUString& rsKey, + const Reference<beans::XPropertySet>& rxProperties); +}; + +//===== PresenterTheme ======================================================== + +PresenterTheme::PresenterTheme ( + const css::uno::Reference<css::uno::XComponentContext>& rxContext, + const css::uno::Reference<css::rendering::XCanvas>& rxCanvas) + : mxContext(rxContext), + mxCanvas(rxCanvas) +{ + mpTheme = ReadTheme(); +} + +PresenterTheme::~PresenterTheme() +{ +} + +std::shared_ptr<PresenterTheme::Theme> PresenterTheme::ReadTheme() +{ + ReadContext aReadContext(mxContext, mxCanvas); + + PresenterConfigurationAccess aConfiguration ( + mxContext, + "/org.openoffice.Office.PresenterScreen/", + PresenterConfigurationAccess::READ_ONLY); + + return aReadContext.ReadTheme(aConfiguration, OUString()); +} + +bool PresenterTheme::HasCanvas() const +{ + return mxCanvas.is(); +} + +void PresenterTheme::ProvideCanvas (const Reference<rendering::XCanvas>& rxCanvas) +{ + if ( ! mxCanvas.is() && rxCanvas.is()) + { + mxCanvas = rxCanvas; + ReadTheme(); + } +} + +OUString PresenterTheme::GetStyleName (const OUString& rsResourceURL) const +{ + OUString sStyleName; + std::shared_ptr<Theme> pTheme (mpTheme); + while (sStyleName.isEmpty() && pTheme != nullptr) + { + sStyleName = pTheme->maStyleAssociations.GetStyleName(rsResourceURL); + pTheme = pTheme->mpParentTheme; + } + return sStyleName; +} + +::std::vector<sal_Int32> PresenterTheme::GetBorderSize ( + const OUString& rsStyleName, + const bool bOuter) const +{ + OSL_ASSERT(mpTheme != nullptr); + + SharedPaneStyle pPaneStyle (mpTheme->GetPaneStyle(rsStyleName)); + if (pPaneStyle) + if (bOuter) + return pPaneStyle->maOuterBorderSize.ToVector(); + else + return pPaneStyle->maInnerBorderSize.ToVector(); + else + { + return ::std::vector<sal_Int32>(4,0); + } +} + +PresenterTheme::SharedFontDescriptor PresenterTheme::ReadFont ( + const Reference<container::XHierarchicalNameAccess>& rxNode, + const PresenterTheme::SharedFontDescriptor& rpDefault) +{ + return ReadContext::ReadFont(rxNode, rpDefault); +} + +bool PresenterTheme::ConvertToColor ( + const Any& rColorSequence, + sal_uInt32& rColor) +{ + Sequence<sal_Int8> aByteSequence; + if (rColorSequence >>= aByteSequence) + { + rColor = std::accumulate(std::cbegin(aByteSequence), std::cend(aByteSequence), sal_uInt32(0), + [](const sal_uInt32 nRes, const sal_uInt8 nByte) { return (nRes << 8) | nByte; }); + return true; + } + else + return false; +} + +std::shared_ptr<PresenterConfigurationAccess> PresenterTheme::GetNodeForViewStyle ( + const OUString& rsStyleName) const +{ + if (mpTheme == nullptr) + return std::shared_ptr<PresenterConfigurationAccess>(); + + // Open configuration for writing. + auto pConfiguration = std::make_shared<PresenterConfigurationAccess>( + mxContext, + "/org.openoffice.Office.PresenterScreen/", + PresenterConfigurationAccess::READ_WRITE); + + // Get configuration node for the view style container of the current + // theme. + if (pConfiguration->GoToChild( OUString( + "Presenter/Themes/" + mpTheme->msConfigurationNodeName + "/ViewStyles"))) + { + pConfiguration->GoToChild( + [&rsStyleName] (OUString const&, uno::Reference<beans::XPropertySet> const& xProps) + { + return PresenterConfigurationAccess::IsStringPropertyEqual( + rsStyleName, "StyleName", xProps); + }); + } + return pConfiguration; +} + +SharedBitmapDescriptor PresenterTheme::GetBitmap ( + const OUString& rsStyleName, + const OUString& rsBitmapName) const +{ + if (mpTheme != nullptr) + { + if (rsStyleName.isEmpty()) + { + if (rsBitmapName == "Background") + { + std::shared_ptr<Theme> pTheme (mpTheme); + while (pTheme != nullptr && !pTheme->mpBackground) + pTheme = pTheme->mpParentTheme; + if (pTheme != nullptr) + return pTheme->mpBackground; + else + return SharedBitmapDescriptor(); + } + } + else + { + SharedPaneStyle pPaneStyle (mpTheme->GetPaneStyle(rsStyleName)); + if (pPaneStyle) + { + SharedBitmapDescriptor pBitmap (pPaneStyle->GetBitmap(rsBitmapName)); + if (pBitmap) + return pBitmap; + } + + SharedViewStyle pViewStyle (mpTheme->GetViewStyle(rsStyleName)); + if (pViewStyle) + { + SharedBitmapDescriptor pBitmap (pViewStyle->GetBitmap(rsBitmapName)); + if (pBitmap) + return pBitmap; + } + } + } + + return SharedBitmapDescriptor(); +} + +SharedBitmapDescriptor PresenterTheme::GetBitmap ( + const OUString& rsBitmapName) const +{ + if (mpTheme != nullptr) + { + if (rsBitmapName == "Background") + { + std::shared_ptr<Theme> pTheme (mpTheme); + while (pTheme != nullptr && !pTheme->mpBackground) + pTheme = pTheme->mpParentTheme; + if (pTheme != nullptr) + return pTheme->mpBackground; + else + return SharedBitmapDescriptor(); + } + else + { + if (mpTheme->mpIconContainer != nullptr) + return mpTheme->mpIconContainer->GetBitmap(rsBitmapName); + } + } + + return SharedBitmapDescriptor(); +} + +std::shared_ptr<PresenterBitmapContainer> PresenterTheme::GetBitmapContainer() const +{ + if (mpTheme != nullptr) + return mpTheme->mpIconContainer; + else + return std::shared_ptr<PresenterBitmapContainer>(); +} + +PresenterTheme::SharedFontDescriptor PresenterTheme::GetFont ( + const OUString& rsStyleName) const +{ + if (mpTheme != nullptr) + { + SharedPaneStyle pPaneStyle (mpTheme->GetPaneStyle(rsStyleName)); + if (pPaneStyle) + return pPaneStyle->GetFont(); + + SharedViewStyle pViewStyle (mpTheme->GetViewStyle(rsStyleName)); + if (pViewStyle) + return pViewStyle->GetFont(); + + std::shared_ptr<Theme> pTheme (mpTheme); + while (pTheme != nullptr) + { + Theme::FontContainer::const_iterator iFont (pTheme->maFontContainer.find(rsStyleName)); + if (iFont != pTheme->maFontContainer.end()) + return iFont->second; + + pTheme = pTheme->mpParentTheme; + } + } + + return SharedFontDescriptor(); +} + +//===== FontDescriptor ======================================================== + +PresenterTheme::FontDescriptor::FontDescriptor ( + const std::shared_ptr<FontDescriptor>& rpDescriptor) + : mnSize(12), + mnColor(0x00000000), + msAnchor(OUString("Left")), + mnXOffset(0), + mnYOffset(0) +{ + if (rpDescriptor != nullptr) + { + msFamilyName = rpDescriptor->msFamilyName; + msStyleName = rpDescriptor->msStyleName; + mnSize = rpDescriptor->mnSize; + mnColor = rpDescriptor->mnColor; + msAnchor = rpDescriptor->msAnchor; + mnXOffset = rpDescriptor->mnXOffset; + mnYOffset = rpDescriptor->mnYOffset; + } +} + +bool PresenterTheme::FontDescriptor::PrepareFont ( + const Reference<rendering::XCanvas>& rxCanvas) +{ + if (mxFont.is()) + return true; + + if ( ! rxCanvas.is()) + return false; + + const double nCellSize (GetCellSizeForDesignSize(rxCanvas, mnSize)); + mxFont = CreateFont(rxCanvas, nCellSize); + + return mxFont.is(); +} + +Reference<rendering::XCanvasFont> PresenterTheme::FontDescriptor::CreateFont ( + const Reference<rendering::XCanvas>& rxCanvas, + const double nCellSize) const +{ + rendering::FontRequest aFontRequest; + aFontRequest.FontDescription.FamilyName = msFamilyName; + if (msFamilyName.isEmpty()) + aFontRequest.FontDescription.FamilyName = "Tahoma"; + aFontRequest.FontDescription.StyleName = msStyleName; + aFontRequest.CellSize = nCellSize; + + // Make an attempt at translating the style name(s)into a corresponding + // font description. + if (msStyleName == "Bold") + aFontRequest.FontDescription.FontDescription.Weight = rendering::PanoseWeight::HEAVY; + + return rxCanvas->createFont( + aFontRequest, + Sequence<beans::PropertyValue>(), + geometry::Matrix2D(1,0,0,1)); +} + +double PresenterTheme::FontDescriptor::GetCellSizeForDesignSize ( + const Reference<rendering::XCanvas>& rxCanvas, + const double nDesignSize) const +{ + // Use the given design size as initial value in calculating the cell + // size. + double nCellSize (nDesignSize); + + if ( ! rxCanvas.is()) + { + // We need the canvas to do the conversion. Return the design size, + // it is the our best guess in this circumstance. + return nDesignSize; + } + + Reference<rendering::XCanvasFont> xFont (CreateFont(rxCanvas, nCellSize)); + if ( ! xFont.is()) + return nDesignSize; + + geometry::RealRectangle2D aBox (PresenterCanvasHelper::GetTextBoundingBox (xFont, "X")); + + const double nAscent (-aBox.Y1); + //tdf#112408 + if (nAscent == 0) + return nDesignSize; + const double nDescent (aBox.Y2); + const double nScale = (nAscent+nDescent) / nAscent; + return nDesignSize * nScale; +} + +//===== Theme ================================================================= + +PresenterTheme::Theme::Theme ( + const Reference<container::XHierarchicalNameAccess>& rxThemeRoot, + const OUString& rsNodeName) + : msConfigurationNodeName(rsNodeName), + maPaneStyles(), + maViewStyles(), + maStyleAssociations(), + mxThemeRoot(rxThemeRoot) +{ +} + +void PresenterTheme::Theme::Read ( + PresenterConfigurationAccess& rConfiguration, + ReadContext& rReadContext) +{ + // Parent theme name. + OUString sParentThemeName; + if ((PresenterConfigurationAccess::GetConfigurationNode(mxThemeRoot, "ParentTheme") + >>= sParentThemeName) + && !sParentThemeName.isEmpty()) + { + mpParentTheme = rReadContext.ReadTheme(rConfiguration, sParentThemeName); + } + + // Background. + mpBackground = PresenterBitmapContainer::LoadBitmap( + mxThemeRoot, + "Background", + rReadContext.mxPresenterHelper, + rReadContext.mxCanvas, + SharedBitmapDescriptor()); + + // Style associations. + maStyleAssociations.Read(mxThemeRoot); + + // Pane styles. + maPaneStyles.Read(rReadContext, mxThemeRoot); + + // View styles. + maViewStyles.Read(rReadContext, mxThemeRoot); + + // Read bitmaps. + mpIconContainer = std::make_shared<PresenterBitmapContainer>( + Reference<container::XNameAccess>( + PresenterConfigurationAccess::GetConfigurationNode(mxThemeRoot, "Bitmaps"), UNO_QUERY), + mpParentTheme != nullptr ? mpParentTheme->mpIconContainer + : std::shared_ptr<PresenterBitmapContainer>(), + rReadContext.mxComponentContext, rReadContext.mxCanvas); + + // Read fonts. + Reference<container::XNameAccess> xFontNode( + PresenterConfigurationAccess::GetConfigurationNode(mxThemeRoot, "Fonts"), + UNO_QUERY); + PresenterConfigurationAccess::ForAll( + xFontNode, + [this] (OUString const& rKey, uno::Reference<beans::XPropertySet> const& xProps) + { + return this->ProcessFont(rKey, xProps); + }); +} + +SharedPaneStyle PresenterTheme::Theme::GetPaneStyle (const OUString& rsStyleName) const +{ + SharedPaneStyle pPaneStyle (maPaneStyles.GetPaneStyle(rsStyleName)); + if (pPaneStyle) + return pPaneStyle; + else if (mpParentTheme != nullptr) + return mpParentTheme->GetPaneStyle(rsStyleName); + else + return SharedPaneStyle(); +} + +SharedViewStyle PresenterTheme::Theme::GetViewStyle (const OUString& rsStyleName) const +{ + SharedViewStyle pViewStyle (maViewStyles.GetViewStyle(rsStyleName)); + if (pViewStyle) + return pViewStyle; + else if (mpParentTheme != nullptr) + return mpParentTheme->GetViewStyle(rsStyleName); + else + return SharedViewStyle(); +} + +void PresenterTheme::Theme::ProcessFont( + const OUString& rsKey, + const Reference<beans::XPropertySet>& rxProperties) +{ + maFontContainer[rsKey] = ReadContext::ReadFont(rxProperties, SharedFontDescriptor()); +} + +namespace { + +//===== ReadContext =========================================================== + +ReadContext::ReadContext ( + const css::uno::Reference<css::uno::XComponentContext>& rxContext, + const Reference<rendering::XCanvas>& rxCanvas) + : mxComponentContext(rxContext), + mxCanvas(rxCanvas) +{ + Reference<lang::XMultiComponentFactory> xFactory (rxContext->getServiceManager()); + if (xFactory.is()) + { + mxPresenterHelper.set( + xFactory->createInstanceWithContext( + "com.sun.star.comp.Draw.PresenterHelper", + rxContext), + UNO_QUERY_THROW); + } +} + +PresenterTheme::SharedFontDescriptor ReadContext::ReadFont ( + const Reference<container::XHierarchicalNameAccess>& rxNode, + const PresenterTheme::SharedFontDescriptor& rpDefault) +{ + if ( ! rxNode.is()) + return PresenterTheme::SharedFontDescriptor(); + + try + { + Reference<container::XHierarchicalNameAccess> xFont ( + PresenterConfigurationAccess::GetConfigurationNode( + rxNode, + /*rsFontPath*/""), + UNO_QUERY_THROW); + + Reference<beans::XPropertySet> xProperties (xFont, UNO_QUERY_THROW); + return ReadFont(xProperties, rpDefault); + } + catch (Exception&) + { + OSL_ASSERT(false); + } + + return PresenterTheme::SharedFontDescriptor(); +} + +PresenterTheme::SharedFontDescriptor ReadContext::ReadFont ( + const Reference<beans::XPropertySet>& rxProperties, + const PresenterTheme::SharedFontDescriptor& rpDefault) +{ + auto pDescriptor = std::make_shared<PresenterTheme::FontDescriptor>(rpDefault); + + PresenterConfigurationAccess::GetProperty(rxProperties, "FamilyName") >>= pDescriptor->msFamilyName; + PresenterConfigurationAccess::GetProperty(rxProperties, "Style") >>= pDescriptor->msStyleName; + PresenterConfigurationAccess::GetProperty(rxProperties, "Size") >>= pDescriptor->mnSize; + PresenterTheme::ConvertToColor( + PresenterConfigurationAccess::GetProperty(rxProperties, "Color"), + pDescriptor->mnColor); + PresenterConfigurationAccess::GetProperty(rxProperties, "Anchor") >>= pDescriptor->msAnchor; + PresenterConfigurationAccess::GetProperty(rxProperties, "XOffset") >>= pDescriptor->mnXOffset; + PresenterConfigurationAccess::GetProperty(rxProperties, "YOffset") >>= pDescriptor->mnYOffset; + + return pDescriptor; +} + +Any ReadContext::GetByName ( + const Reference<container::XNameAccess>& rxNode, + const OUString& rsName) +{ + OSL_ASSERT(rxNode.is()); + if (rxNode->hasByName(rsName)) + return rxNode->getByName(rsName); + else + return Any(); +} + +std::shared_ptr<PresenterTheme::Theme> ReadContext::ReadTheme ( + PresenterConfigurationAccess& rConfiguration, + const OUString& rsThemeName) +{ + std::shared_ptr<PresenterTheme::Theme> pTheme; + + OUString sCurrentThemeName (rsThemeName); + if (sCurrentThemeName.isEmpty()) + { + // No theme name given. Look up the CurrentTheme property. + rConfiguration.GetConfigurationNode("Presenter/CurrentTheme") >>= sCurrentThemeName; + if (sCurrentThemeName.isEmpty()) + { + // Still no name. Use "DefaultTheme". + sCurrentThemeName = "DefaultTheme"; + } + } + + Reference<container::XNameAccess> xThemes ( + rConfiguration.GetConfigurationNode("Presenter/Themes"), + UNO_QUERY); + if (xThemes.is()) + { + // Iterate over all themes and search the one with the given name. + const Sequence<OUString> aKeys (xThemes->getElementNames()); + for (const OUString& rsKey : aKeys) + { + Reference<container::XHierarchicalNameAccess> xTheme ( + xThemes->getByName(rsKey), UNO_QUERY); + if (xTheme.is()) + { + OUString sThemeName; + PresenterConfigurationAccess::GetConfigurationNode(xTheme, "ThemeName") + >>= sThemeName; + if (sThemeName == sCurrentThemeName) + { + pTheme = std::make_shared<PresenterTheme::Theme>(xTheme,rsKey); + break; + } + } + } + } + + if (pTheme != nullptr) + { + pTheme->Read(rConfiguration, *this); + } + + return pTheme; +} + +BorderSize ReadContext::ReadBorderSize (const Reference<container::XNameAccess>& rxNode) +{ + BorderSize aBorderSize; + + if (rxNode.is()) + { + GetByName(rxNode, "Left") >>= aBorderSize.mnLeft; + GetByName(rxNode, "Top") >>= aBorderSize.mnTop; + GetByName(rxNode, "Right") >>= aBorderSize.mnRight; + GetByName(rxNode, "Bottom") >>= aBorderSize.mnBottom; + } + + return aBorderSize; +} + +//===== PaneStyleContainer ==================================================== + +void PaneStyleContainer::Read ( + const ReadContext& rReadContext, + const Reference<container::XHierarchicalNameAccess>& rxThemeRoot) +{ + Reference<container::XNameAccess> xPaneStyleList ( + PresenterConfigurationAccess::GetConfigurationNode( + rxThemeRoot, + "PaneStyles"), + UNO_QUERY); + if (!xPaneStyleList.is()) + return; + + ::std::vector<OUString> aProperties; + aProperties.reserve(6); + aProperties.emplace_back("StyleName"); + aProperties.emplace_back("ParentStyle"); + aProperties.emplace_back("TitleFont"); + aProperties.emplace_back("InnerBorderSize"); + aProperties.emplace_back("OuterBorderSize"); + aProperties.emplace_back("BorderBitmapList"); + PresenterConfigurationAccess::ForAll( + xPaneStyleList, + aProperties, + [this, &rReadContext] (std::vector<uno::Any> const& rValues) + { + return this->ProcessPaneStyle(rReadContext, rValues); + }); +} + +void PaneStyleContainer::ProcessPaneStyle( + ReadContext const & rReadContext, + const ::std::vector<Any>& rValues) +{ + if (rValues.size() != 6) + return; + + auto pStyle = std::make_shared<PaneStyle>(); + + rValues[0] >>= pStyle->msStyleName; + + OUString sParentStyleName; + if (rValues[1] >>= sParentStyleName) + { + // Find parent style. + auto iStyle = std::find_if(mStyles.begin(), mStyles.end(), + [&sParentStyleName](const SharedPaneStyle& rxStyle) { return rxStyle->msStyleName == sParentStyleName; }); + if (iStyle != mStyles.end()) + pStyle->mpParentStyle = *iStyle; + } + + Reference<container::XHierarchicalNameAccess> xFontNode (rValues[2], UNO_QUERY); + pStyle->mpFont = ReadContext::ReadFont( + xFontNode, PresenterTheme::SharedFontDescriptor()); + + Reference<container::XNameAccess> xInnerBorderSizeNode (rValues[3], UNO_QUERY); + pStyle->maInnerBorderSize = ReadContext::ReadBorderSize(xInnerBorderSizeNode); + Reference<container::XNameAccess> xOuterBorderSizeNode (rValues[4], UNO_QUERY); + pStyle->maOuterBorderSize = ReadContext::ReadBorderSize(xOuterBorderSizeNode); + + if (pStyle->mpParentStyle != nullptr) + { + pStyle->maInnerBorderSize.Merge(pStyle->mpParentStyle->maInnerBorderSize); + pStyle->maOuterBorderSize.Merge(pStyle->mpParentStyle->maOuterBorderSize); + } + + if (rReadContext.mxCanvas.is()) + { + Reference<container::XNameAccess> xBitmapsNode (rValues[5], UNO_QUERY); + pStyle->mpBitmaps = std::make_shared<PresenterBitmapContainer>( + xBitmapsNode, + pStyle->mpParentStyle != nullptr ? pStyle->mpParentStyle->mpBitmaps + : std::shared_ptr<PresenterBitmapContainer>(), + rReadContext.mxComponentContext, rReadContext.mxCanvas, + rReadContext.mxPresenterHelper); + } + + mStyles.push_back(pStyle); +} + +SharedPaneStyle PaneStyleContainer::GetPaneStyle (const OUString& rsStyleName) const +{ + auto iStyle = std::find_if(mStyles.begin(), mStyles.end(), + [&rsStyleName](const SharedPaneStyle& rxStyle) { return rxStyle->msStyleName == rsStyleName; }); + if (iStyle != mStyles.end()) + return *iStyle; + return SharedPaneStyle(); +} + +//===== PaneStyle ============================================================= + +PaneStyle::PaneStyle() +{ +} + +SharedBitmapDescriptor PaneStyle::GetBitmap (const OUString& rsBitmapName) const +{ + if (mpBitmaps != nullptr) + { + SharedBitmapDescriptor pBitmap = mpBitmaps->GetBitmap(rsBitmapName); + if (pBitmap) + return pBitmap; + } + + if (mpParentStyle != nullptr) + return mpParentStyle->GetBitmap(rsBitmapName); + else + return SharedBitmapDescriptor(); +} + +PresenterTheme::SharedFontDescriptor PaneStyle::GetFont() const +{ + if (mpFont) + return mpFont; + else if (mpParentStyle != nullptr) + return mpParentStyle->GetFont(); + else + return PresenterTheme::SharedFontDescriptor(); +} + +//===== ViewStyleContainer ==================================================== + +void ViewStyleContainer::Read ( + const ReadContext& rReadContext, + const Reference<container::XHierarchicalNameAccess>& rxThemeRoot) +{ + Reference<container::XNameAccess> xViewStyleList ( + PresenterConfigurationAccess::GetConfigurationNode( + rxThemeRoot, + "ViewStyles"), + UNO_QUERY); + if (xViewStyleList.is()) + { + PresenterConfigurationAccess::ForAll( + xViewStyleList, + [this, &rReadContext] (OUString const&, uno::Reference<beans::XPropertySet> const& xProps) + { + return this->ProcessViewStyle(rReadContext, xProps); + }); + } +} + +void ViewStyleContainer::ProcessViewStyle( + ReadContext const & rReadContext, + const Reference<beans::XPropertySet>& rxProperties) +{ + auto pStyle = std::make_shared<ViewStyle>(); + + PresenterConfigurationAccess::GetProperty(rxProperties, "StyleName") + >>= pStyle->msStyleName; + + OUString sParentStyleName; + if (PresenterConfigurationAccess::GetProperty(rxProperties, "ParentStyle") + >>= sParentStyleName) + { + // Find parent style. + auto iStyle = std::find_if(mStyles.begin(), mStyles.end(), + [&sParentStyleName](const SharedViewStyle& rxStyle) { return rxStyle->msStyleName == sParentStyleName; }); + if (iStyle != mStyles.end()) + { + pStyle->mpParentStyle = *iStyle; + pStyle->mpFont = (*iStyle)->mpFont; + pStyle->mpBackground = (*iStyle)->mpBackground; + } + } + + Reference<container::XHierarchicalNameAccess> xFontNode ( + PresenterConfigurationAccess::GetProperty(rxProperties, "Font"), UNO_QUERY); + PresenterTheme::SharedFontDescriptor pFont ( + ReadContext::ReadFont(xFontNode, PresenterTheme::SharedFontDescriptor())); + if (pFont) + pStyle->mpFont = pFont; + + Reference<container::XHierarchicalNameAccess> xBackgroundNode ( + PresenterConfigurationAccess::GetProperty(rxProperties, "Background"), + UNO_QUERY); + SharedBitmapDescriptor pBackground (PresenterBitmapContainer::LoadBitmap( + xBackgroundNode, + OUString(), + rReadContext.mxPresenterHelper, + rReadContext.mxCanvas, + SharedBitmapDescriptor())); + if (pBackground && pBackground->GetNormalBitmap().is()) + pStyle->mpBackground = pBackground; + + mStyles.push_back(pStyle); +} + +SharedViewStyle ViewStyleContainer::GetViewStyle (const OUString& rsStyleName) const +{ + auto iStyle = std::find_if(mStyles.begin(), mStyles.end(), + [&rsStyleName](const SharedViewStyle& rxStyle) { return rxStyle->msStyleName == rsStyleName; }); + if (iStyle != mStyles.end()) + return *iStyle; + return SharedViewStyle(); +} + +//===== ViewStyle ============================================================= + +ViewStyle::ViewStyle() +{ +} + +SharedBitmapDescriptor ViewStyle::GetBitmap (std::u16string_view rsBitmapName) const +{ + if (rsBitmapName == u"Background") + return mpBackground; + else + return SharedBitmapDescriptor(); +} + +PresenterTheme::SharedFontDescriptor ViewStyle::GetFont() const +{ + if (mpFont) + return mpFont; + else if (mpParentStyle != nullptr) + return mpParentStyle->GetFont(); + else + return PresenterTheme::SharedFontDescriptor(); +} + +//===== StyleAssociationContainer ============================================= + +void StyleAssociationContainer::Read ( + const Reference<container::XHierarchicalNameAccess>& rxThemeRoot) +{ + Reference<container::XNameAccess> xStyleAssociationList ( + PresenterConfigurationAccess::GetConfigurationNode( + rxThemeRoot, + "StyleAssociations"), + UNO_QUERY); + if (!xStyleAssociationList.is()) + return; + + ::std::vector<OUString> aProperties { "ResourceURL", "StyleName" }; + PresenterConfigurationAccess::ForAll( + xStyleAssociationList, + aProperties, + [this] (std::vector<uno::Any> const& rValues) + { + return this->ProcessStyleAssociation(rValues); + }); +} + +OUString StyleAssociationContainer::GetStyleName (const OUString& rsResourceName) const +{ + StyleAssociations::const_iterator iAssociation (maStyleAssociations.find(rsResourceName)); + if (iAssociation != maStyleAssociations.end()) + return iAssociation->second; + else + return OUString(); +} + +void StyleAssociationContainer::ProcessStyleAssociation( + const ::std::vector<Any>& rValues) +{ + if (rValues.size() != 2) + return; + + OUString sResourceURL; + OUString sStyleName; + if ((rValues[0] >>= sResourceURL) + && (rValues[1] >>= sStyleName)) + { + maStyleAssociations[sResourceURL] = sStyleName; + } +} + +} // end of anonymous namespace + +} // end of namespace ::sdext::presenter + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |