diff options
Diffstat (limited to 'svx/source/sdr')
114 files changed, 24248 insertions, 0 deletions
diff --git a/svx/source/sdr/animation/animationstate.cxx b/svx/source/sdr/animation/animationstate.cxx new file mode 100644 index 000000000..2c23b91b7 --- /dev/null +++ b/svx/source/sdr/animation/animationstate.cxx @@ -0,0 +1,135 @@ +/* -*- 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 <svx/sdr/animation/animationstate.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/animation/objectanimator.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <drawinglayer/primitive2d/animatedprimitive2d.hxx> +#include <drawinglayer/animation/animationtiming.hxx> +#include <comphelper/lok.hxx> + + +namespace sdr::animation +{ + double PrimitiveAnimation::getSmallestNextTime(double fCurrentTime) + { + double fRetval(0.0); + + if(!maAnimatedPrimitives.empty()) + { + const sal_Int32 nCount(maAnimatedPrimitives.size()); + + for(sal_Int32 a(0); a < nCount; a++) + { + const drawinglayer::primitive2d::Primitive2DReference xRef(maAnimatedPrimitives[a]); + const drawinglayer::primitive2d::AnimatedSwitchPrimitive2D* pCandidate = dynamic_cast< const drawinglayer::primitive2d::AnimatedSwitchPrimitive2D* >(xRef.get()); + OSL_ENSURE(pCandidate, "PrimitiveAnimation::getSmallestNextTime: wrong primitive in animated list (!)"); + + if(pCandidate) + { + const drawinglayer::animation::AnimationEntry& rAnimEntry = pCandidate->getAnimationEntry(); + const double fNextTime(rAnimEntry.getNextEventTime(fCurrentTime)); + + if(!::basegfx::fTools::equalZero(fNextTime)) + { + if(::basegfx::fTools::equalZero(fRetval)) + { + fRetval = fNextTime; + } + else if(::basegfx::fTools::less(fNextTime, fRetval)) + { + fRetval = fNextTime; + } + } + } + } + } + + return fRetval; + } + + void PrimitiveAnimation::prepareNextEvent() + { + const double fCurrentTime(mrVOContact.GetObjectContact().getPrimitiveAnimator().GetTime()); + const double fNextTime(getSmallestNextTime(fCurrentTime)); + + // getSmallestNextTime will be zero when animation ended. If not zero, a next step + // exists + if(!::basegfx::fTools::equalZero(fNextTime)) + { + // next time point exists, use it + sal_uInt32 nNextTime; + + if(fNextTime >= double(0xffffff00)) + { + // take care for very late points in time, e.g. when a text animation stops + // in a defined AnimationEntryFixed with endless (0xffffffff) duration + nNextTime = GetTime() + (1000 * 60 * 60); // one hour, works with vcl timers, 0xffffff00 was too much... + } + else + { + nNextTime = static_cast<sal_uInt32>(fNextTime); + } + + // ensure step forward in integer timing, the floating step difference maybe smaller than 1.0. Use + // at least 25ms for next step + const sal_uInt32 nMinimumStepTime(static_cast<sal_uInt32>(fCurrentTime) + 25); + + if(nNextTime <= nMinimumStepTime) + { + nNextTime = nMinimumStepTime; + } + + // set time and reactivate by re-adding to the scheduler + SetTime(nNextTime); + mrVOContact.GetObjectContact().getPrimitiveAnimator().InsertEvent(*this); + } + } + + PrimitiveAnimation::PrimitiveAnimation(sdr::contact::ViewObjectContact& rVOContact, const drawinglayer::primitive2d::Primitive2DContainer& rAnimatedPrimitives) + : Event(), + mrVOContact(rVOContact), + maAnimatedPrimitives(rAnimatedPrimitives) + { + if (!comphelper::LibreOfficeKit::isActive()) + // setup initially + prepareNextEvent(); + } + + PrimitiveAnimation::~PrimitiveAnimation() + { + // ensure that Event member is removed from PrimitiveAnimator + mrVOContact.GetObjectContact().getPrimitiveAnimator().RemoveEvent(this); + } + + // execute event, from base class Event + void PrimitiveAnimation::Trigger(sal_uInt32 /*nTime*/) + { + // schedule a repaint of associated object + mrVOContact.ActionChanged(); + + if (!comphelper::LibreOfficeKit::isActive()) + // re-setup + prepareNextEvent(); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/animation/objectanimator.cxx b/svx/source/sdr/animation/objectanimator.cxx new file mode 100644 index 000000000..454376f8e --- /dev/null +++ b/svx/source/sdr/animation/objectanimator.cxx @@ -0,0 +1,36 @@ +/* -*- 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 <svx/sdr/animation/objectanimator.hxx> + + +namespace sdr::animation +{ + primitiveAnimator::primitiveAnimator() + : Scheduler() + { + } + + primitiveAnimator::~primitiveAnimator() + { + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/animation/scheduler.cxx b/svx/source/sdr/animation/scheduler.cxx new file mode 100644 index 000000000..21a28fe72 --- /dev/null +++ b/svx/source/sdr/animation/scheduler.cxx @@ -0,0 +1,172 @@ +/* -*- 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 <svx/sdr/animation/scheduler.hxx> + +#include <algorithm> +#include <vector> + + +// event class + +namespace sdr::animation +{ + Event::Event() : mnTime(0) + { + } + + Event::~Event() + { + } + + + void Event::SetTime(sal_uInt32 nNew) + { + if(mnTime != nNew) + { + mnTime = nNew; + } + } + + Scheduler::Scheduler() + : mnTime(0), + mnDeltaTime(0), + mbIsPaused(false) + { + SetPriority(TaskPriority::POST_PAINT); + } + + Scheduler::~Scheduler() + { + Stop(); + } + + void Scheduler::Invoke() + { + // stop timer and add time + Stop(); + mnTime += mnDeltaTime; + + // execute events + triggerEvents(); + + // re-start or stop timer according to event list + checkTimeout(); + } + + void Scheduler::triggerEvents() + { + if (mvEvents.empty()) + return; + + // copy events which need to be executed to a vector. Remove them from + // the scheduler + ::std::vector< Event* > aToBeExecutedList; + + while(!mvEvents.empty() && mvEvents.front()->GetTime() <= mnTime) + { + Event* pNextEvent = mvEvents.front(); + mvEvents.erase(mvEvents.begin()); + aToBeExecutedList.push_back(pNextEvent); + } + + // execute events from the vector + for(auto& rpCandidate : aToBeExecutedList) + { + // trigger event. This may re-insert the event to the scheduler again + rpCandidate->Trigger(mnTime); + } + } + + void Scheduler::checkTimeout() + { + // re-start or stop timer according to event list + if(!IsPaused() && !mvEvents.empty()) + { + mnDeltaTime = mvEvents.front()->GetTime() - mnTime; + + if(0 != mnDeltaTime) + { + SetTimeout(mnDeltaTime); + Start(); + } + } + else + { + Stop(); + } + } + + + // #i38135# + void Scheduler::SetTime(sal_uInt32 nTime) + { + // reset time + Stop(); + mnTime = nTime; + + if (mvEvents.empty()) + return; + + // reset event time points + for (auto & rEvent : mvEvents) + { + rEvent->SetTime(nTime); + } + + if(!IsPaused()) + { + // without delta time, init events by triggering them. This will invalidate + // painted objects and add them to the scheduler again + mnDeltaTime = 0; + triggerEvents(); + checkTimeout(); + } + } + + void Scheduler::InsertEvent(Event& rNew) + { + // insert maintaining time ordering + auto it = std::find_if(mvEvents.begin(), mvEvents.end(), + [&rNew](const Event* pEvent) { return rNew.GetTime() < pEvent->GetTime(); }); + mvEvents.insert(it, &rNew); + checkTimeout(); + } + + void Scheduler::RemoveEvent(Event* pOld) + { + if(!mvEvents.empty()) + { + mvEvents.erase(std::remove(mvEvents.begin(), mvEvents.end(), pOld), mvEvents.end()); + checkTimeout(); + } + } + + void Scheduler::SetPaused(bool bNew) + { + if(bNew != mbIsPaused) + { + mbIsPaused = bNew; + checkTimeout(); + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdrallfillattributeshelper.cxx b/svx/source/sdr/attribute/sdrallfillattributeshelper.cxx new file mode 100644 index 000000000..57945facb --- /dev/null +++ b/svx/source/sdr/attribute/sdrallfillattributeshelper.cxx @@ -0,0 +1,257 @@ +/* -*- 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 <svx/sdr/attribute/sdrallfillattributeshelper.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/attribute/fillhatchattribute.hxx> +#include <drawinglayer/attribute/sdrfillgraphicattribute.hxx> +#include <vcl/graph.hxx> + +////////////////////////////////////////////////////////////////////////////// + +namespace drawinglayer::attribute +{ + void SdrAllFillAttributesHelper::createPrimitive2DSequence( + const basegfx::B2DRange& rPaintRange, + const basegfx::B2DRange& rDefineRange) + { + // reset and remember new target range for object geometry + maLastPaintRange = rPaintRange; + maLastDefineRange = rDefineRange; + + if(isUsed()) + { + maPrimitives.resize(1); + maPrimitives[0] = drawinglayer::primitive2d::createPolyPolygonFillPrimitive( + basegfx::B2DPolyPolygon( + basegfx::utils::createPolygonFromRect( + maLastPaintRange)), + maLastDefineRange, + maFillAttribute ? *maFillAttribute : drawinglayer::attribute::SdrFillAttribute(), + maFillGradientAttribute ? *maFillGradientAttribute : drawinglayer::attribute::FillGradientAttribute()); + } + } + + SdrAllFillAttributesHelper::SdrAllFillAttributesHelper(const Color& rColor) + : maLastPaintRange(), + maLastDefineRange(), + maFillAttribute(), + maFillGradientAttribute(), + maPrimitives() + { + maFillAttribute = + std::make_shared<drawinglayer::attribute::SdrFillAttribute>( + 0.0, + rColor.GetRGBColor().getBColor(), + drawinglayer::attribute::FillGradientAttribute(), + drawinglayer::attribute::FillHatchAttribute(), + drawinglayer::attribute::SdrFillGraphicAttribute()); + } + + SdrAllFillAttributesHelper::SdrAllFillAttributesHelper(const SfxItemSet& rSet) + : maLastPaintRange(), + maLastDefineRange(), + maFillAttribute( + std::make_shared<drawinglayer::attribute::SdrFillAttribute>( + drawinglayer::primitive2d::createNewSdrFillAttribute(rSet))), + maFillGradientAttribute( + std::make_shared<drawinglayer::attribute::FillGradientAttribute>( + drawinglayer::primitive2d::createNewTransparenceGradientAttribute(rSet))), + maPrimitives() + { + } + + SdrAllFillAttributesHelper::~SdrAllFillAttributesHelper() + { + } + + bool SdrAllFillAttributesHelper::isUsed() const + { + // only depends on fill, FillGradientAttribute alone defines no fill + return maFillAttribute && !maFillAttribute->isDefault(); + } + + bool SdrAllFillAttributesHelper::isTransparent() const + { + if(hasSdrFillAttribute() && 0.0 != maFillAttribute->getTransparence()) + { + return true; + } + + if(maFillGradientAttribute && !maFillGradientAttribute->isDefault()) + { + return true; + } + + if(hasSdrFillAttribute()) + { + const Graphic& rGraphic = getFillAttribute().getFillGraphic().getFillGraphic(); + + return rGraphic.IsSupportedGraphic() && rGraphic.IsTransparent(); + } + + return false; + } + + const drawinglayer::attribute::SdrFillAttribute& SdrAllFillAttributesHelper::getFillAttribute() const + { + if(!maFillAttribute) + { + const_cast< SdrAllFillAttributesHelper* >(this)->maFillAttribute = + std::make_shared<drawinglayer::attribute::SdrFillAttribute>(); + } + + return *maFillAttribute; + } + + const drawinglayer::attribute::FillGradientAttribute& SdrAllFillAttributesHelper::getFillGradientAttribute() const + { + if(!maFillGradientAttribute) + { + const_cast< SdrAllFillAttributesHelper* >(this)->maFillGradientAttribute = + std::make_shared<drawinglayer::attribute::FillGradientAttribute>(); + } + + return *maFillGradientAttribute; + } + + const drawinglayer::primitive2d::Primitive2DContainer& SdrAllFillAttributesHelper::getPrimitive2DSequence( + const basegfx::B2DRange& rPaintRange, + const basegfx::B2DRange& rDefineRange) const + { + if(!maPrimitives.empty() && (maLastPaintRange != rPaintRange || maLastDefineRange != rDefineRange)) + { + const_cast< SdrAllFillAttributesHelper* >(this)->maPrimitives.clear(); + } + + if(maPrimitives.empty()) + { + const_cast< SdrAllFillAttributesHelper* >(this)->createPrimitive2DSequence(rPaintRange, rDefineRange); + } + + return maPrimitives; + } + + basegfx::BColor SdrAllFillAttributesHelper::getAverageColor(const basegfx::BColor& rFallback) const + { + basegfx::BColor aRetval(rFallback); + + if(maFillAttribute && !maFillAttribute->isDefault()) + { + const drawinglayer::attribute::FillGradientAttribute& rFillGradientAttribute = maFillAttribute->getGradient(); + const drawinglayer::attribute::FillHatchAttribute& rFillHatchAttribute = maFillAttribute->getHatch(); + const drawinglayer::attribute::SdrFillGraphicAttribute& rSdrFillGraphicAttribute = maFillAttribute->getFillGraphic(); + const drawinglayer::attribute::FillGradientAttribute& rFillTransparenceGradientAttribute = getFillGradientAttribute(); + double fTransparence(maFillAttribute->getTransparence()); + + if(!rFillTransparenceGradientAttribute.isDefault()) + { + const double fTransA = rFillTransparenceGradientAttribute.getStartColor().luminance(); + const double fTransB = rFillTransparenceGradientAttribute.getEndColor().luminance(); + + fTransparence = (fTransA + fTransB) * 0.5; + } + + if(!rFillGradientAttribute.isDefault()) + { + // gradient fill + const basegfx::BColor& rStart = rFillGradientAttribute.getStartColor(); + const basegfx::BColor& rEnd = rFillGradientAttribute.getEndColor(); + + aRetval = basegfx::interpolate(rStart, rEnd, 0.5); + } + else if(!rFillHatchAttribute.isDefault()) + { + // hatch fill + const basegfx::BColor& rColor = rFillHatchAttribute.getColor(); + + if(rFillHatchAttribute.isFillBackground()) + { + const basegfx::BColor& rBackgroundColor = maFillAttribute->getColor(); + + // mix colors 50%/50% + aRetval = basegfx::interpolate(rColor, rBackgroundColor, 0.5); + } + else + { + // mix color with fallback color + aRetval = basegfx::interpolate(rColor, rFallback, 0.5); + } + } + else if(!rSdrFillGraphicAttribute.isDefault()) + { + // graphic fill + + // not used yet by purpose (see SwPageFrm::GetDrawBackgrdColor()), + // use fallback (already set) + } + else + { + // color fill + aRetval = maFillAttribute->getColor(); + } + + if(!basegfx::fTools::equalZero(fTransparence)) + { + // blend into transparency + aRetval = basegfx::interpolate(aRetval, rFallback, fTransparence); + } + } + + return aRetval.clamp(); + } + + bool SdrAllFillAttributesHelper::needCompleteRepaint() const + { + if(!isUsed() || !hasSdrFillAttribute()) + { + // not used or no fill + return false; + } + + const drawinglayer::attribute::SdrFillAttribute& rSdrFillAttribute = getFillAttribute(); + + if(!rSdrFillAttribute.getHatch().isDefault()) + { + // hatch is always top-left aligned, needs no full refreshes + return false; + } + + if(!rSdrFillAttribute.getGradient().isDefault()) + { + // gradients always scale with the object + return true; + } + + if(!rSdrFillAttribute.getFillGraphic().isDefault()) + { + // some graphic constellations may not need this, but since most do + // (stretch to fill, all but top-left aligned, ...) claim to do by default + return true; + } + + // color fill + return false; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdreffectstextattribute.cxx b/svx/source/sdr/attribute/sdreffectstextattribute.cxx new file mode 100644 index 000000000..acf9a2ee5 --- /dev/null +++ b/svx/source/sdr/attribute/sdreffectstextattribute.cxx @@ -0,0 +1,78 @@ +/* -*- 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 <sdr/attribute/sdreffectstextattribute.hxx> + + +namespace drawinglayer::attribute +{ + SdrEffectsTextAttribute::SdrEffectsTextAttribute( + const SdrShadowAttribute& rShadow, + const SdrTextAttribute& rTextAttribute, + const SdrGlowAttribute& rGlow, + sal_Int32 nSoftEdgeRadius) + : maShadow(rShadow), + maTextAttribute(rTextAttribute), + maGlow(rGlow), + mnSoftEdgeRadius(nSoftEdgeRadius) + { + } + + SdrEffectsTextAttribute::SdrEffectsTextAttribute() + : maShadow(), + maTextAttribute() + { + } + + SdrEffectsTextAttribute::SdrEffectsTextAttribute(const SdrEffectsTextAttribute& rCandidate) + : maShadow(rCandidate.getShadow()), + maTextAttribute(rCandidate.getText()), + maGlow(rCandidate.maGlow), + mnSoftEdgeRadius(rCandidate.mnSoftEdgeRadius) + { + } + + SdrEffectsTextAttribute& SdrEffectsTextAttribute::operator=(const SdrEffectsTextAttribute& rCandidate) + { + maShadow = rCandidate.getShadow(); + maTextAttribute = rCandidate.getText(); + maGlow = rCandidate.maGlow; + mnSoftEdgeRadius = rCandidate.mnSoftEdgeRadius; + + return *this; + } + + bool SdrEffectsTextAttribute::isDefault() const + { + return (getShadow().isDefault() + && getText().isDefault() && maGlow.isDefault() && getSoftEdgeRadius() == 0); + } + + bool SdrEffectsTextAttribute::operator==(const SdrEffectsTextAttribute& rCandidate) const + { + return (getShadow() == rCandidate.getShadow() + && getText() == rCandidate.getText() + && getGlow() == rCandidate.getGlow() + && getSoftEdgeRadius() == rCandidate.getSoftEdgeRadius()); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdrfilltextattribute.cxx b/svx/source/sdr/attribute/sdrfilltextattribute.cxx new file mode 100644 index 000000000..4cad7e636 --- /dev/null +++ b/svx/source/sdr/attribute/sdrfilltextattribute.cxx @@ -0,0 +1,68 @@ +/* -*- 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 <sdr/attribute/sdrfilltextattribute.hxx> + + +namespace drawinglayer::attribute +{ + SdrFillTextAttribute::SdrFillTextAttribute( + const SdrFillAttribute& rFill, + const FillGradientAttribute& rFillFloatTransGradient, + const SdrTextAttribute& rTextAttribute) + : maFill(rFill), + maFillFloatTransGradient(rFillFloatTransGradient), + maTextAttribute(rTextAttribute) + { + } + + SdrFillTextAttribute::SdrFillTextAttribute() + : maFill(), + maFillFloatTransGradient(), + maTextAttribute() + { + } + + SdrFillTextAttribute::SdrFillTextAttribute(const SdrFillTextAttribute& rCandidate) + : maFill(rCandidate.getFill()), + maFillFloatTransGradient(rCandidate.getFillFloatTransGradient()), + maTextAttribute(rCandidate.getText()) + { + } + + SdrFillTextAttribute& SdrFillTextAttribute::operator=(const SdrFillTextAttribute& rCandidate) + { + maFill = rCandidate.getFill(); + maFillFloatTransGradient = rCandidate.getFillFloatTransGradient(); + maTextAttribute = rCandidate.getText(); + + return *this; + } + + bool SdrFillTextAttribute::operator==(const SdrFillTextAttribute& rCandidate) const + { + return(getFill() == rCandidate.getFill() + && getFillFloatTransGradient() == rCandidate.getFillFloatTransGradient() + && getText() == rCandidate.getText()); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdrformtextattribute.cxx b/svx/source/sdr/attribute/sdrformtextattribute.cxx new file mode 100644 index 000000000..77962bdb7 --- /dev/null +++ b/svx/source/sdr/attribute/sdrformtextattribute.cxx @@ -0,0 +1,375 @@ +/* -*- 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 <sdr/attribute/sdrformtextattribute.hxx> +#include <basegfx/vector/b2enums.hxx> +#include <svl/itemset.hxx> +#include <svx/sdprcitm.hxx> +#include <svx/svddef.hxx> +#include <svx/xftdiit.hxx> +#include <svx/xftstit.hxx> +#include <svx/xftshxy.hxx> +#include <xftshtit.hxx> +#include <svx/xtextit0.hxx> +#include <svx/xftadit.hxx> +#include <svx/xftshit.hxx> +#include <svx/xftshcit.hxx> +#include <svx/xftmrit.hxx> +#include <svx/xftouit.hxx> +#include <svx/xlntrit.hxx> +#include <svx/xlnclit.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlinjoit.hxx> +#include <svx/xlncapit.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xdash.hxx> +#include <svx/xlndsit.hxx> +#include <drawinglayer/attribute/lineattribute.hxx> +#include <drawinglayer/attribute/strokeattribute.hxx> +#include <sdr/attribute/sdrformtextoutlineattribute.hxx> +#include <com/sun/star/drawing/LineCap.hpp> +#include <com/sun/star/drawing/LineStyle.hpp> +#include <rtl/instance.hxx> + + +// helper to get line, stroke and transparence attributes from SfxItemSet + +namespace +{ + basegfx::B2DLineJoin impGetB2DLineJoin(css::drawing::LineJoint eLineJoint) + { + switch(eLineJoint) + { + case css::drawing::LineJoint_BEVEL : + { + return basegfx::B2DLineJoin::Bevel; + } + case css::drawing::LineJoint_MIDDLE : + case css::drawing::LineJoint_MITER : + { + return basegfx::B2DLineJoin::Miter; + } + case css::drawing::LineJoint_ROUND : + { + return basegfx::B2DLineJoin::Round; + } + default : // css::drawing::LineJoint_NONE + { + return basegfx::B2DLineJoin::NONE; // XLINEJOINT_NONE + } + } + } + + sal_uInt8 impGetStrokeTransparence(bool bShadow, const SfxItemSet& rSet) + { + sal_uInt8 nRetval; + + if(bShadow) + { + nRetval = static_cast<sal_uInt8>((rSet.Get(SDRATTR_SHADOWTRANSPARENCE).GetValue() * 255) / 100); + } + else + { + nRetval = static_cast<sal_uInt8>((rSet.Get(XATTR_LINETRANSPARENCE).GetValue() * 255) / 100); + } + + return nRetval; + } + + drawinglayer::attribute::LineAttribute impGetLineAttribute(bool bShadow, const SfxItemSet& rSet) + { + basegfx::BColor aColorAttribute; + + if(bShadow) + { + const Color aShadowColor(rSet.Get(SDRATTR_SHADOWCOLOR).GetColorValue()); + aColorAttribute = aShadowColor.getBColor(); + } + else + { + const Color aLineColor(rSet.Get(XATTR_LINECOLOR).GetColorValue()); + aColorAttribute = aLineColor.getBColor(); + } + + const sal_uInt32 nLineWidth = rSet.Get(XATTR_LINEWIDTH).GetValue(); + const css::drawing::LineJoint eLineJoint = rSet.Get(XATTR_LINEJOINT).GetValue(); + const css::drawing::LineCap eLineCap = rSet.Get(XATTR_LINECAP).GetValue(); + + return drawinglayer::attribute::LineAttribute( + aColorAttribute, + static_cast<double>(nLineWidth), + impGetB2DLineJoin(eLineJoint), + eLineCap); + } + + drawinglayer::attribute::StrokeAttribute impGetStrokeAttribute(const SfxItemSet& rSet) + { + const css::drawing::LineStyle eLineStyle = rSet.Get(XATTR_LINESTYLE).GetValue(); + double fFullDotDashLen(0.0); + ::std::vector< double > aDotDashArray; + + if(css::drawing::LineStyle_DASH == eLineStyle) + { + const XDash& rDash = rSet.Get(XATTR_LINEDASH).GetDashValue(); + + if(rDash.GetDots() || rDash.GetDashes()) + { + const sal_uInt32 nLineWidth = rSet.Get(XATTR_LINEWIDTH).GetValue(); + fFullDotDashLen = rDash.CreateDotDashArray(aDotDashArray, static_cast<double>(nLineWidth)); + } + } + + return drawinglayer::attribute::StrokeAttribute(aDotDashArray, fFullDotDashLen); + } +} // end of anonymous namespace + + +namespace drawinglayer::attribute +{ + class ImpSdrFormTextAttribute + { + public: + // FormText (FontWork) Attributes + sal_Int32 mnFormTextDistance; // distance from line in upright direction + sal_Int32 mnFormTextStart; // shift from polygon start + sal_Int32 mnFormTextShdwXVal; // shadow distance or 10th degrees + sal_Int32 mnFormTextShdwYVal; // shadow distance or scaling + sal_uInt16 mnFormTextShdwTransp; // shadow transparence + XFormTextStyle meFormTextStyle; // on/off and char orientation + XFormTextAdjust meFormTextAdjust; // adjustment (left/right/center) and scale + XFormTextShadow meFormTextShadow; // shadow mode + Color maFormTextShdwColor; // shadow color + + // outline attributes; used when getFormTextOutline() is true and (for + // shadow) when getFormTextShadow() != XFormTextShadow::NONE + SdrFormTextOutlineAttribute maOutline; + SdrFormTextOutlineAttribute maShadowOutline; + + bool mbFormTextMirror : 1; // change orientation + bool mbFormTextOutline : 1; // show contour of objects + + explicit ImpSdrFormTextAttribute(const SfxItemSet& rSet) + : mnFormTextDistance(rSet.Get(XATTR_FORMTXTDISTANCE).GetValue()), + mnFormTextStart(rSet.Get(XATTR_FORMTXTSTART).GetValue()), + mnFormTextShdwXVal(rSet.Get(XATTR_FORMTXTSHDWXVAL).GetValue()), + mnFormTextShdwYVal(rSet.Get(XATTR_FORMTXTSHDWYVAL).GetValue()), + mnFormTextShdwTransp(rSet.Get(XATTR_FORMTXTSHDWTRANSP).GetValue()), + meFormTextStyle(rSet.Get(XATTR_FORMTXTSTYLE).GetValue()), + meFormTextAdjust(rSet.Get(XATTR_FORMTXTADJUST).GetValue()), + meFormTextShadow(rSet.Get(XATTR_FORMTXTSHADOW).GetValue()), + maFormTextShdwColor(rSet.Get(XATTR_FORMTXTSHDWCOLOR).GetColorValue()), + maOutline(), + maShadowOutline(), + mbFormTextMirror(rSet.Get(XATTR_FORMTXTMIRROR).GetValue()), + mbFormTextOutline(rSet.Get(XATTR_FORMTXTOUTLINE).GetValue()) + { + if(getFormTextOutline()) + { + const StrokeAttribute aStrokeAttribute(impGetStrokeAttribute(rSet)); + + // also need to prepare attributes for outlines + { + const LineAttribute aLineAttribute(impGetLineAttribute(false, rSet)); + const sal_uInt8 nTransparence(impGetStrokeTransparence(false, rSet)); + + maOutline = SdrFormTextOutlineAttribute( + aLineAttribute, aStrokeAttribute, nTransparence); + } + + if(XFormTextShadow::NONE != getFormTextShadow()) + { + // also need to prepare attributes for shadow outlines + const LineAttribute aLineAttribute(impGetLineAttribute(true, rSet)); + const sal_uInt8 nTransparence(impGetStrokeTransparence(true, rSet)); + + maShadowOutline = SdrFormTextOutlineAttribute( + aLineAttribute, aStrokeAttribute, nTransparence); + } + } + } + + ImpSdrFormTextAttribute() + : mnFormTextDistance(0), + mnFormTextStart(0), + mnFormTextShdwXVal(0), + mnFormTextShdwYVal(0), + mnFormTextShdwTransp(0), + meFormTextStyle(XFormTextStyle::NONE), + meFormTextAdjust(XFormTextAdjust::Center), + meFormTextShadow(XFormTextShadow::NONE), + maFormTextShdwColor(), + maOutline(), + maShadowOutline(), + mbFormTextMirror(false), + mbFormTextOutline(false) + { + } + + // data read access + sal_Int32 getFormTextDistance() const { return mnFormTextDistance; } + sal_Int32 getFormTextStart() const { return mnFormTextStart; } + sal_Int32 getFormTextShdwXVal() const { return mnFormTextShdwXVal; } + sal_Int32 getFormTextShdwYVal() const { return mnFormTextShdwYVal; } + XFormTextStyle getFormTextStyle() const { return meFormTextStyle; } + XFormTextAdjust getFormTextAdjust() const { return meFormTextAdjust; } + XFormTextShadow getFormTextShadow() const { return meFormTextShadow; } + const Color& getFormTextShdwColor() const { return maFormTextShdwColor; } + const SdrFormTextOutlineAttribute& getOutline() const { return maOutline; } + const SdrFormTextOutlineAttribute& getShadowOutline() const { return maShadowOutline; } + bool getFormTextMirror() const { return mbFormTextMirror; } + bool getFormTextOutline() const { return mbFormTextOutline; } + + // compare operator + bool operator==(const ImpSdrFormTextAttribute& rCandidate) const + { + return (getFormTextDistance() == rCandidate.getFormTextDistance() + && getFormTextStart() == rCandidate.getFormTextStart() + && getFormTextShdwXVal() == rCandidate.getFormTextShdwXVal() + && getFormTextShdwYVal() == rCandidate.getFormTextShdwYVal() + && mnFormTextShdwTransp == rCandidate.mnFormTextShdwTransp + && getFormTextStyle() == rCandidate.getFormTextStyle() + && getFormTextAdjust() == rCandidate.getFormTextAdjust() + && getFormTextShadow() == rCandidate.getFormTextShadow() + && getFormTextShdwColor() == rCandidate.getFormTextShdwColor() + && getOutline() == rCandidate.getOutline() + && getShadowOutline() == rCandidate.getShadowOutline() + && getFormTextMirror() == rCandidate.getFormTextMirror() + && getFormTextOutline() == rCandidate.getFormTextOutline()); + } + }; + + namespace + { + struct theGlobalDefault : + public rtl::Static< SdrFormTextAttribute::ImplType, theGlobalDefault > {}; + } + + SdrFormTextAttribute::SdrFormTextAttribute(const SfxItemSet& rSet) + : mpSdrFormTextAttribute(ImpSdrFormTextAttribute(rSet)) + { + } + + SdrFormTextAttribute::SdrFormTextAttribute() + : mpSdrFormTextAttribute(theGlobalDefault::get()) + { + } + + SdrFormTextAttribute::SdrFormTextAttribute(const SdrFormTextAttribute& rCandidate) + : mpSdrFormTextAttribute(rCandidate.mpSdrFormTextAttribute) + { + } + + SdrFormTextAttribute::SdrFormTextAttribute(SdrFormTextAttribute&& rCandidate) noexcept + : mpSdrFormTextAttribute(std::move(rCandidate.mpSdrFormTextAttribute)) + { + } + + SdrFormTextAttribute::~SdrFormTextAttribute() + { + } + + bool SdrFormTextAttribute::isDefault() const + { + return mpSdrFormTextAttribute.same_object(theGlobalDefault::get()); + } + + SdrFormTextAttribute& SdrFormTextAttribute::operator=(const SdrFormTextAttribute& rCandidate) + { + mpSdrFormTextAttribute = rCandidate.mpSdrFormTextAttribute; + return *this; + } + + SdrFormTextAttribute& SdrFormTextAttribute::operator=(SdrFormTextAttribute&& rCandidate) noexcept + { + mpSdrFormTextAttribute = std::move(rCandidate.mpSdrFormTextAttribute); + return *this; + } + + bool SdrFormTextAttribute::operator==(const SdrFormTextAttribute& rCandidate) const + { + // tdf#87509 default attr is always != non-default attr, even with same values + if(rCandidate.isDefault() != isDefault()) + return false; + + return rCandidate.mpSdrFormTextAttribute == mpSdrFormTextAttribute; + } + + sal_Int32 SdrFormTextAttribute::getFormTextDistance() const + { + return mpSdrFormTextAttribute->getFormTextDistance(); + } + + sal_Int32 SdrFormTextAttribute::getFormTextStart() const + { + return mpSdrFormTextAttribute->getFormTextStart(); + } + + sal_Int32 SdrFormTextAttribute::getFormTextShdwXVal() const + { + return mpSdrFormTextAttribute->getFormTextShdwXVal(); + } + + sal_Int32 SdrFormTextAttribute::getFormTextShdwYVal() const + { + return mpSdrFormTextAttribute->getFormTextShdwYVal(); + } + + XFormTextStyle SdrFormTextAttribute::getFormTextStyle() const + { + return mpSdrFormTextAttribute->getFormTextStyle(); + } + + XFormTextAdjust SdrFormTextAttribute::getFormTextAdjust() const + { + return mpSdrFormTextAttribute->getFormTextAdjust(); + } + + XFormTextShadow SdrFormTextAttribute::getFormTextShadow() const + { + return mpSdrFormTextAttribute->getFormTextShadow(); + } + + Color const & SdrFormTextAttribute::getFormTextShdwColor() const + { + return mpSdrFormTextAttribute->getFormTextShdwColor(); + } + + const SdrFormTextOutlineAttribute& SdrFormTextAttribute::getOutline() const + { + return mpSdrFormTextAttribute->getOutline(); + } + + const SdrFormTextOutlineAttribute& SdrFormTextAttribute::getShadowOutline() const + { + return mpSdrFormTextAttribute->getShadowOutline(); + } + + bool SdrFormTextAttribute::getFormTextMirror() const + { + return mpSdrFormTextAttribute->getFormTextMirror(); + } + + bool SdrFormTextAttribute::getFormTextOutline() const + { + return mpSdrFormTextAttribute->getFormTextOutline(); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdrformtextoutlineattribute.cxx b/svx/source/sdr/attribute/sdrformtextoutlineattribute.cxx new file mode 100644 index 000000000..fa23ff257 --- /dev/null +++ b/svx/source/sdr/attribute/sdrformtextoutlineattribute.cxx @@ -0,0 +1,141 @@ +/* -*- 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 <sdr/attribute/sdrformtextoutlineattribute.hxx> +#include <drawinglayer/attribute/lineattribute.hxx> +#include <drawinglayer/attribute/strokeattribute.hxx> +#include <rtl/instance.hxx> + + +namespace drawinglayer::attribute +{ + class ImpSdrFormTextOutlineAttribute + { + public: + // one set of attributes for FormText (FontWork) outline visualisation + LineAttribute maLineAttribute; + StrokeAttribute maStrokeAttribute; + sal_uInt8 mnTransparence; + + ImpSdrFormTextOutlineAttribute( + const LineAttribute& rLineAttribute, + const StrokeAttribute& rStrokeAttribute, + sal_uInt8 nTransparence) + : maLineAttribute(rLineAttribute), + maStrokeAttribute(rStrokeAttribute), + mnTransparence(nTransparence) + { + } + + ImpSdrFormTextOutlineAttribute() + : maLineAttribute(), + maStrokeAttribute(), + mnTransparence(0) + { + } + + // data read access + const LineAttribute& getLineAttribute() const { return maLineAttribute; } + const StrokeAttribute& getStrokeAttribute() const { return maStrokeAttribute; } + sal_uInt8 getTransparence() const { return mnTransparence; } + + // compare operator + bool operator==(const ImpSdrFormTextOutlineAttribute& rCandidate) const + { + return (getLineAttribute() == rCandidate.getLineAttribute() + && getStrokeAttribute() == rCandidate.getStrokeAttribute() + && getTransparence() == rCandidate.getTransparence()); + } + }; + + namespace + { + struct theGlobalDefault : + public rtl::Static< SdrFormTextOutlineAttribute::ImplType, theGlobalDefault > {}; + } + + SdrFormTextOutlineAttribute::SdrFormTextOutlineAttribute( + const LineAttribute& rLineAttribute, + const StrokeAttribute& rStrokeAttribute, + sal_uInt8 nTransparence) + : mpSdrFormTextOutlineAttribute( + ImpSdrFormTextOutlineAttribute( + rLineAttribute, rStrokeAttribute, nTransparence)) + { + } + + SdrFormTextOutlineAttribute::SdrFormTextOutlineAttribute() + : mpSdrFormTextOutlineAttribute(theGlobalDefault::get()) + { + } + + SdrFormTextOutlineAttribute::SdrFormTextOutlineAttribute(const SdrFormTextOutlineAttribute& rCandidate) + : mpSdrFormTextOutlineAttribute(rCandidate.mpSdrFormTextOutlineAttribute) + { + } + + SdrFormTextOutlineAttribute::~SdrFormTextOutlineAttribute() + { + } + + bool SdrFormTextOutlineAttribute::isDefault() const + { + return mpSdrFormTextOutlineAttribute.same_object(theGlobalDefault::get()); + } + + SdrFormTextOutlineAttribute& SdrFormTextOutlineAttribute::operator=(const SdrFormTextOutlineAttribute& rCandidate) + { + mpSdrFormTextOutlineAttribute = rCandidate.mpSdrFormTextOutlineAttribute; + return *this; + } + + SdrFormTextOutlineAttribute& SdrFormTextOutlineAttribute::operator=(SdrFormTextOutlineAttribute&& rCandidate) noexcept + { + mpSdrFormTextOutlineAttribute = std::move(rCandidate.mpSdrFormTextOutlineAttribute); + return *this; + } + + bool SdrFormTextOutlineAttribute::operator==(const SdrFormTextOutlineAttribute& rCandidate) const + { + // tdf#87509 default attr is always != non-default attr, even with same values + if(rCandidate.isDefault() != isDefault()) + return false; + + return rCandidate.mpSdrFormTextOutlineAttribute == mpSdrFormTextOutlineAttribute; + } + + const LineAttribute& SdrFormTextOutlineAttribute::getLineAttribute() const + { + return mpSdrFormTextOutlineAttribute->getLineAttribute(); + } + + const StrokeAttribute& SdrFormTextOutlineAttribute::getStrokeAttribute() const + { + return mpSdrFormTextOutlineAttribute->getStrokeAttribute(); + } + + sal_uInt8 SdrFormTextOutlineAttribute::getTransparence() const + { + return mpSdrFormTextOutlineAttribute->getTransparence(); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdrlineeffectstextattribute.cxx b/svx/source/sdr/attribute/sdrlineeffectstextattribute.cxx new file mode 100644 index 000000000..d2add9638 --- /dev/null +++ b/svx/source/sdr/attribute/sdrlineeffectstextattribute.cxx @@ -0,0 +1,78 @@ +/* -*- 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 <sdr/attribute/sdrlineeffectstextattribute.hxx> + + +namespace drawinglayer::attribute +{ + SdrLineEffectsTextAttribute::SdrLineEffectsTextAttribute( + const SdrLineAttribute& rLine, + const SdrLineStartEndAttribute& rLineStartEnd, + const SdrShadowAttribute& rShadow, + const SdrTextAttribute& rTextAttribute, + const SdrGlowAttribute& rGlow, + sal_Int32 nSoftEdgeRadius) + : SdrEffectsTextAttribute(rShadow, rTextAttribute, rGlow, nSoftEdgeRadius), + maLine(rLine), + maLineStartEnd(rLineStartEnd) + { + } + + SdrLineEffectsTextAttribute::SdrLineEffectsTextAttribute() + : SdrEffectsTextAttribute(), + maLine(), + maLineStartEnd() + { + } + + SdrLineEffectsTextAttribute::SdrLineEffectsTextAttribute(const SdrLineEffectsTextAttribute& rCandidate) + : SdrEffectsTextAttribute(rCandidate), + maLine(rCandidate.getLine()), + maLineStartEnd(rCandidate.getLineStartEnd()) + { + } + + SdrLineEffectsTextAttribute& SdrLineEffectsTextAttribute::operator=(const SdrLineEffectsTextAttribute& rCandidate) + { + SdrEffectsTextAttribute::operator=(rCandidate); + maLine = rCandidate.getLine(); + maLineStartEnd = rCandidate.getLineStartEnd(); + + return *this; + } + + bool SdrLineEffectsTextAttribute::isDefault() const + { + return(SdrEffectsTextAttribute::isDefault() + && getLine().isDefault() + && getLineStartEnd().isDefault()); + } + + bool SdrLineEffectsTextAttribute::operator==(const SdrLineEffectsTextAttribute& rCandidate) const + { + return(SdrEffectsTextAttribute::operator==(rCandidate) + && getLine() == rCandidate.getLine() + && getLineStartEnd() == rCandidate.getLineStartEnd()); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdrlinefilleffectstextattribute.cxx b/svx/source/sdr/attribute/sdrlinefilleffectstextattribute.cxx new file mode 100644 index 000000000..c9199435f --- /dev/null +++ b/svx/source/sdr/attribute/sdrlinefilleffectstextattribute.cxx @@ -0,0 +1,80 @@ +/* -*- 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 <sdr/attribute/sdrlinefilleffectstextattribute.hxx> + + +namespace drawinglayer::attribute +{ + SdrLineFillEffectsTextAttribute::SdrLineFillEffectsTextAttribute( + const SdrLineAttribute& rLine, + const SdrFillAttribute& rFill, + const SdrLineStartEndAttribute& rLineStartEnd, + const SdrShadowAttribute& rShadow, + const FillGradientAttribute& rFillFloatTransGradient, + const SdrTextAttribute& rTextAttribute, + const SdrGlowAttribute& rGlow, + sal_Int32 nSoftEdgeRadius) + : SdrLineEffectsTextAttribute(rLine, rLineStartEnd, rShadow, rTextAttribute, rGlow, nSoftEdgeRadius), + maFill(rFill), + maFillFloatTransGradient(rFillFloatTransGradient) + { + } + + SdrLineFillEffectsTextAttribute::SdrLineFillEffectsTextAttribute() + : SdrLineEffectsTextAttribute(), + maFill(), + maFillFloatTransGradient() + { + } + + SdrLineFillEffectsTextAttribute::SdrLineFillEffectsTextAttribute(const SdrLineFillEffectsTextAttribute& rCandidate) + : SdrLineEffectsTextAttribute(rCandidate), + maFill(rCandidate.getFill()), + maFillFloatTransGradient(rCandidate.getFillFloatTransGradient()) + { + } + + SdrLineFillEffectsTextAttribute& SdrLineFillEffectsTextAttribute::operator=(const SdrLineFillEffectsTextAttribute& rCandidate) + { + SdrLineEffectsTextAttribute::operator=(rCandidate); + maFill = rCandidate.getFill(); + maFillFloatTransGradient = rCandidate.getFillFloatTransGradient(); + + return *this; + } + + bool SdrLineFillEffectsTextAttribute::isDefault() const + { + return (SdrLineEffectsTextAttribute::isDefault() + && getFill().isDefault() + && getFillFloatTransGradient().isDefault()); + } + + bool SdrLineFillEffectsTextAttribute::operator==(const SdrLineFillEffectsTextAttribute& rCandidate) const + { + return(SdrLineEffectsTextAttribute::operator==(rCandidate) + && getFill() == rCandidate.getFill() + && getFillFloatTransGradient() == rCandidate.getFillFloatTransGradient()); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/attribute/sdrtextattribute.cxx b/svx/source/sdr/attribute/sdrtextattribute.cxx new file mode 100644 index 000000000..b0b8bf8f3 --- /dev/null +++ b/svx/source/sdr/attribute/sdrtextattribute.cxx @@ -0,0 +1,422 @@ +/* -*- 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 <sdr/attribute/sdrtextattribute.hxx> +#include <sdr/attribute/sdrformtextattribute.hxx> +#include <svx/svdotext.hxx> +#include <editeng/outlobj.hxx> +#include <svx/sdr/properties/properties.hxx> +#include <rtl/instance.hxx> + + +namespace drawinglayer::attribute +{ + class ImpSdrTextAttribute + { + public: + // all-text attributes. The SdrText itself and a copy + // of the OPO + const SdrText* mpSdrText; + std::shared_ptr<OutlinerParaObject> mxOutlinerParaObject; + + // Set when it's a FormText; contains all FormText attributes + SdrFormTextAttribute maSdrFormTextAttribute; + + // text distances + sal_Int32 maTextLeftDistance; + sal_Int32 maTextUpperDistance; + sal_Int32 maTextRightDistance; + sal_Int32 maTextLowerDistance; + + // #i101556# use versioning from text attributes to detect changes + sal_uInt32 maPropertiesVersion; + + // text alignments + SdrTextHorzAdjust maSdrTextHorzAdjust; + SdrTextVertAdjust maSdrTextVertAdjust; + + bool mbContour : 1; + bool mbFitToSize : 1; + bool mbAutoFit : 1; + bool mbHideContour : 1; + bool mbBlink : 1; + bool mbScroll : 1; + bool mbInEditMode : 1; + bool mbFixedCellHeight : 1; + bool mbWrongSpell : 1; + + bool mbChainable : 1; + + + public: + ImpSdrTextAttribute( + const SdrText* pSdrText, + const OutlinerParaObject& rOutlinerParaObject, + XFormTextStyle eFormTextStyle, + sal_Int32 aTextLeftDistance, + sal_Int32 aTextUpperDistance, + sal_Int32 aTextRightDistance, + sal_Int32 aTextLowerDistance, + SdrTextHorzAdjust aSdrTextHorzAdjust, + SdrTextVertAdjust aSdrTextVertAdjust, + bool bContour, + bool bFitToSize, + bool bAutoFit, + bool bHideContour, + bool bBlink, + bool bScroll, + bool bInEditMode, + bool bFixedCellHeight, + bool bWrongSpell, + bool bChainable) + : mpSdrText(pSdrText), + mxOutlinerParaObject(std::make_shared<OutlinerParaObject>(rOutlinerParaObject)), + maSdrFormTextAttribute(), + maTextLeftDistance(aTextLeftDistance), + maTextUpperDistance(aTextUpperDistance), + maTextRightDistance(aTextRightDistance), + maTextLowerDistance(aTextLowerDistance), + maPropertiesVersion(0), + maSdrTextHorzAdjust(aSdrTextHorzAdjust), + maSdrTextVertAdjust(aSdrTextVertAdjust), + mbContour(bContour), + mbFitToSize(bFitToSize), + mbAutoFit(bAutoFit), + mbHideContour(bHideContour), + mbBlink(bBlink), + mbScroll(bScroll), + mbInEditMode(bInEditMode), + mbFixedCellHeight(bFixedCellHeight), + mbWrongSpell(bWrongSpell), + mbChainable(bChainable) + { + if(pSdrText) + { + if(XFormTextStyle::NONE != eFormTextStyle) + { + // text on path. Create FormText attribute + const SfxItemSet& rSet = pSdrText->GetItemSet(); + maSdrFormTextAttribute = SdrFormTextAttribute(rSet); + } + + // #i101556# init with version number to detect changes of single text + // attribute and/or style sheets in primitive data without having to + // copy that data locally (which would be better from principle) + maPropertiesVersion = pSdrText->GetObject().GetProperties().getVersion(); + } + } + + ImpSdrTextAttribute() + : mpSdrText(nullptr), + maSdrFormTextAttribute(), + maTextLeftDistance(0), + maTextUpperDistance(0), + maTextRightDistance(0), + maTextLowerDistance(0), + maPropertiesVersion(0), + maSdrTextHorzAdjust(SDRTEXTHORZADJUST_LEFT), + maSdrTextVertAdjust(SDRTEXTVERTADJUST_TOP), + mbContour(false), + mbFitToSize(false), + mbAutoFit(false), + mbHideContour(false), + mbBlink(false), + mbScroll(false), + mbInEditMode(false), + mbFixedCellHeight(false), + mbWrongSpell(false), + mbChainable(false) + { + } + + // data read access + const SdrText& getSdrText() const + { + assert(mpSdrText && "Access to text of default version of ImpSdrTextAttribute (!)"); + return *mpSdrText; + } + + const OutlinerParaObject& getOutlinerParaObject() const + { + assert(mxOutlinerParaObject && "Access to OutlinerParaObject of default version of ImpSdrTextAttribute (!)"); + return *mxOutlinerParaObject; + } + + bool isContour() const { return mbContour; } + bool isFitToSize() const { return mbFitToSize; } + bool isAutoFit() const { return mbAutoFit; } + bool isHideContour() const { return mbHideContour; } + bool isBlink() const { return mbBlink; } + bool isScroll() const { return mbScroll; } + bool isInEditMode() const { return mbInEditMode; } + bool isFixedCellHeight() const { return mbFixedCellHeight; } + bool isChainable() const { return mbChainable; } + const SdrFormTextAttribute& getSdrFormTextAttribute() const { return maSdrFormTextAttribute; } + sal_Int32 getTextLeftDistance() const { return maTextLeftDistance; } + sal_Int32 getTextUpperDistance() const { return maTextUpperDistance; } + sal_Int32 getTextRightDistance() const { return maTextRightDistance; } + sal_Int32 getTextLowerDistance() const { return maTextLowerDistance; } + SdrTextHorzAdjust getSdrTextHorzAdjust() const { return maSdrTextHorzAdjust; } + SdrTextVertAdjust getSdrTextVertAdjust() const { return maSdrTextVertAdjust; } + + // compare operator + bool operator==(const ImpSdrTextAttribute& rCandidate) const + { + if (mxOutlinerParaObject.get() != rCandidate.mxOutlinerParaObject.get()) + { + if (mxOutlinerParaObject && rCandidate.mxOutlinerParaObject) + { + // compares OPO and it's contents, but traditionally not the RedLining + // which is not seen as model, but as temporary information + if(!(getOutlinerParaObject() == rCandidate.getOutlinerParaObject())) + { + return false; + } + + // #i102062# for primitive visualisation, the WrongList (SpellChecking) + // is important, too, so use isWrongListEqual since there is no WrongList + // comparison in the regular OutlinerParaObject compare (since it's + // not-persistent data) + if(!(getOutlinerParaObject().isWrongListEqual(rCandidate.getOutlinerParaObject()))) + { + return false; + } + } + else + { + // only one is zero; not equal + return false; + } + } + + return ( + getSdrFormTextAttribute() == rCandidate.getSdrFormTextAttribute() + && getTextLeftDistance() == rCandidate.getTextLeftDistance() + && getTextUpperDistance() == rCandidate.getTextUpperDistance() + && getTextRightDistance() == rCandidate.getTextRightDistance() + && getTextLowerDistance() == rCandidate.getTextLowerDistance() + && maPropertiesVersion == rCandidate.maPropertiesVersion + + && getSdrTextHorzAdjust() == rCandidate.getSdrTextHorzAdjust() + && getSdrTextVertAdjust() == rCandidate.getSdrTextVertAdjust() + + && isContour() == rCandidate.isContour() + && isFitToSize() == rCandidate.isFitToSize() + && isAutoFit() == rCandidate.isAutoFit() + && isHideContour() == rCandidate.isHideContour() + && isBlink() == rCandidate.isBlink() + && isScroll() == rCandidate.isScroll() + && isInEditMode() == rCandidate.isInEditMode() + && isFixedCellHeight() == rCandidate.isFixedCellHeight() + && mbWrongSpell == rCandidate.mbWrongSpell ); + } + }; + + namespace + { + struct theGlobalDefault : + public rtl::Static< SdrTextAttribute::ImplType, theGlobalDefault > {}; + } + + SdrTextAttribute::SdrTextAttribute( + const SdrText& rSdrText, + const OutlinerParaObject& rOutlinerParaObject, + XFormTextStyle eFormTextStyle, + sal_Int32 aTextLeftDistance, + sal_Int32 aTextUpperDistance, + sal_Int32 aTextRightDistance, + sal_Int32 aTextLowerDistance, + SdrTextHorzAdjust aSdrTextHorzAdjust, + SdrTextVertAdjust aSdrTextVertAdjust, + bool bContour, + bool bFitToSize, + bool bAutoFit, + bool bHideContour, + bool bBlink, + bool bScroll, + bool bInEditMode, + bool bFixedCellHeight, + bool bWrongSpell, + bool bChainable) + : mpSdrTextAttribute( + ImpSdrTextAttribute( + &rSdrText, rOutlinerParaObject, eFormTextStyle, aTextLeftDistance, + aTextUpperDistance, aTextRightDistance, aTextLowerDistance, + aSdrTextHorzAdjust, aSdrTextVertAdjust, bContour, bFitToSize, bAutoFit, + bHideContour, bBlink, bScroll, bInEditMode, bFixedCellHeight, bWrongSpell, + bChainable)) + { + } + + SdrTextAttribute::SdrTextAttribute() + : mpSdrTextAttribute(theGlobalDefault::get()) + { + } + + SdrTextAttribute::SdrTextAttribute(const SdrTextAttribute& rCandidate) + : mpSdrTextAttribute(rCandidate.mpSdrTextAttribute) + { + } + + SdrTextAttribute::SdrTextAttribute(SdrTextAttribute&& rCandidate) noexcept + : mpSdrTextAttribute(std::move(rCandidate.mpSdrTextAttribute)) + { + } + + SdrTextAttribute::~SdrTextAttribute() + { + } + + bool SdrTextAttribute::isDefault() const + { + return mpSdrTextAttribute.same_object(theGlobalDefault::get()); + } + + SdrTextAttribute& SdrTextAttribute::operator=(const SdrTextAttribute& rCandidate) + { + mpSdrTextAttribute = rCandidate.mpSdrTextAttribute; + return *this; + } + + SdrTextAttribute& SdrTextAttribute::operator=(SdrTextAttribute&& rCandidate) noexcept + { + mpSdrTextAttribute = std::move(rCandidate.mpSdrTextAttribute); + return *this; + } + + bool SdrTextAttribute::operator==(const SdrTextAttribute& rCandidate) const + { + // tdf#87509 default attr is always != non-default attr, even with same values + if(rCandidate.isDefault() != isDefault()) + return false; + + return rCandidate.mpSdrTextAttribute == mpSdrTextAttribute; + } + + const SdrText& SdrTextAttribute::getSdrText() const + { + return mpSdrTextAttribute->getSdrText(); + } + + const OutlinerParaObject& SdrTextAttribute::getOutlinerParaObject() const + { + return mpSdrTextAttribute->getOutlinerParaObject(); + } + + bool SdrTextAttribute::isContour() const + { + return mpSdrTextAttribute->isContour(); + } + + bool SdrTextAttribute::isFitToSize() const + { + return mpSdrTextAttribute->isFitToSize(); + } + + bool SdrTextAttribute::isAutoFit() const + { + return mpSdrTextAttribute->isAutoFit(); + } + + bool SdrTextAttribute::isHideContour() const + { + return mpSdrTextAttribute->isHideContour(); + } + + bool SdrTextAttribute::isBlink() const + { + return mpSdrTextAttribute->isBlink(); + } + + bool SdrTextAttribute::isScroll() const + { + return mpSdrTextAttribute->isScroll(); + } + + bool SdrTextAttribute::isInEditMode() const + { + return mpSdrTextAttribute->isInEditMode(); + } + + bool SdrTextAttribute::isChainable() const + { + return mpSdrTextAttribute->isChainable(); + } + + + bool SdrTextAttribute::isFixedCellHeight() const + { + return mpSdrTextAttribute->isFixedCellHeight(); + } + + const SdrFormTextAttribute& SdrTextAttribute::getSdrFormTextAttribute() const + { + return mpSdrTextAttribute->getSdrFormTextAttribute(); + } + + sal_Int32 SdrTextAttribute::getTextLeftDistance() const + { + return mpSdrTextAttribute->getTextLeftDistance(); + } + + sal_Int32 SdrTextAttribute::getTextUpperDistance() const + { + return mpSdrTextAttribute->getTextUpperDistance(); + } + + sal_Int32 SdrTextAttribute::getTextRightDistance() const + { + return mpSdrTextAttribute->getTextRightDistance(); + } + + sal_Int32 SdrTextAttribute::getTextLowerDistance() const + { + return mpSdrTextAttribute->getTextLowerDistance(); + } + + SdrTextHorzAdjust SdrTextAttribute::getSdrTextHorzAdjust() const + { + return mpSdrTextAttribute->getSdrTextHorzAdjust(); + } + + SdrTextVertAdjust SdrTextAttribute::getSdrTextVertAdjust() const + { + return mpSdrTextAttribute->getSdrTextVertAdjust(); + } + + void SdrTextAttribute::getBlinkTextTiming(drawinglayer::animation::AnimationEntryList& rAnimList) const + { + if(isBlink()) + { + getSdrText().GetObject().impGetBlinkTextTiming(rAnimList); + } + } + + void SdrTextAttribute::getScrollTextTiming(drawinglayer::animation::AnimationEntryList& rAnimList, double fFrameLength, double fTextLength) const + { + if(isScroll()) + { + getSdrText().GetObject().impGetScrollTextTiming(rAnimList, fFrameLength, fTextLength); + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/displayinfo.cxx b/svx/source/sdr/contact/displayinfo.cxx new file mode 100644 index 000000000..d837c8c1e --- /dev/null +++ b/svx/source/sdr/contact/displayinfo.cxx @@ -0,0 +1,88 @@ +/* -*- 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 <svx/sdr/contact/displayinfo.hxx> + + +namespace sdr::contact +{ + DisplayInfo::DisplayInfo() + : maProcessLayers(true), // init layer info with all bits set to draw everything on default + maRedrawArea(), + mbControlLayerProcessingActive(false), + mbPageProcessingActive(true), + mbGhostedDrawModeActive(false), + mbSubContentActive(false) + { + } + + // Access to LayerInfos (which layers to process) + void DisplayInfo::SetProcessLayers(const SdrLayerIDSet& rSet) + { + maProcessLayers = rSet; + } + + // access to RedrawArea + void DisplayInfo::SetRedrawArea(const vcl::Region& rRegion) + { + maRedrawArea = rRegion; + } + + void DisplayInfo::SetWriterPageFrame(basegfx::B2IRectangle const& rPageFrame) + { + m_WriterPageFrame = rPageFrame; + } + + void DisplayInfo::SetControlLayerProcessingActive(bool bDoProcess) + { + if(mbControlLayerProcessingActive != bDoProcess) + { + mbControlLayerProcessingActive = bDoProcess; + } + } + + void DisplayInfo::SetPageProcessingActive(bool bDoProcess) + { + if(mbPageProcessingActive != bDoProcess) + { + mbPageProcessingActive = bDoProcess; + } + } + + void DisplayInfo::ClearGhostedDrawMode() + { + mbGhostedDrawModeActive = false; + } + + void DisplayInfo::SetGhostedDrawMode() + { + mbGhostedDrawModeActive = true; + } + + void DisplayInfo::SetSubContentActive(bool bNew) + { + if(mbSubContentActive != bNew) + { + mbSubContentActive = bNew; + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/objectcontact.cxx b/svx/source/sdr/contact/objectcontact.cxx new file mode 100644 index 000000000..ee623c062 --- /dev/null +++ b/svx/source/sdr/contact/objectcontact.cxx @@ -0,0 +1,215 @@ +/* -*- 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 <svx/sdr/contact/objectcontact.hxx> +#include <tools/debug.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/contact/viewcontact.hxx> + +using namespace com::sun::star; + +namespace sdr::contact { + +bool ObjectContact::supportsGridOffsets() const +{ + // default does not support GridOffset + return false; +} + +void ObjectContact::calculateGridOffsetForViewOjectContact( + basegfx::B2DVector& /*rTarget*/, + const ViewObjectContact& /*rClient*/) const +{ + // default does not on-demand calculate GridOffset +} + +void ObjectContact::calculateGridOffsetForB2DRange( + basegfx::B2DVector& /*rTarget*/, + const basegfx::B2DRange& /*rB2DRange*/) const +{ + // default does not on-demand calculate GridOffset +} + +ObjectContact::ObjectContact() +: maViewObjectContactVector(), + maPrimitiveAnimator(), + mpViewObjectContactRedirector(nullptr), + maViewInformation2D(uno::Sequence< beans::PropertyValue >()), + mbIsPreviewRenderer(false) +{ +} + +ObjectContact::~ObjectContact() COVERITY_NOEXCEPT_FALSE +{ + // get rid of all registered contacts + // #i84257# To avoid that each 'delete pCandidate' again uses + // the local RemoveViewObjectContact with a search and removal in the + // vector, simply copy and clear local vector. + std::vector< ViewObjectContact* > aLocalVOCList; + aLocalVOCList.swap(maViewObjectContactVector); + + for (const auto & pCandidate : aLocalVOCList) + // ViewObjectContacts only make sense with View and Object contacts. + // When the contact to the SdrObject is deleted like in this case, + // all ViewObjectContacts can be deleted, too. + delete pCandidate; + + // assert when there were new entries added during deletion + DBG_ASSERT(maViewObjectContactVector.empty(), "Corrupted ViewObjectContactList (!)"); +} + +// LazyInvalidate request. Default implementation directly handles +// this by calling back triggerLazyInvalidate() at the VOC +void ObjectContact::setLazyInvalidate(ViewObjectContact& rVOC) +{ + rVOC.triggerLazyInvalidate(); +} + +// call this to support evtl. preparations for repaint. Default does nothing +void ObjectContact::PrepareProcessDisplay() +{ +} + +// A new ViewObjectContact was created and shall be remembered. +void ObjectContact::AddViewObjectContact(ViewObjectContact& rVOContact) +{ + maViewObjectContactVector.push_back(&rVOContact); +} + +// A ViewObjectContact was deleted and shall be forgotten. +void ObjectContact::RemoveViewObjectContact(ViewObjectContact& rVOContact) +{ + std::vector< ViewObjectContact* >::iterator aFindResult = std::find(maViewObjectContactVector.begin(), maViewObjectContactVector.end(), &rVOContact); + + if(aFindResult != maViewObjectContactVector.end()) + { + maViewObjectContactVector.erase(aFindResult); + } +} + +// Process the whole displaying +void ObjectContact::ProcessDisplay(DisplayInfo& /*rDisplayInfo*/) +{ + // default does nothing +} + +// test if visualizing of entered groups is switched on at all +bool ObjectContact::DoVisualizeEnteredGroup() const +{ + // Do not do that as default + return false; +} + +// get active group's (the entered group) ViewContact +const ViewContact* ObjectContact::getActiveViewContact() const +{ + // default has no active VC + return nullptr; +} + +// Invalidate given rectangle at the window/output which is represented by +// this ObjectContact. +void ObjectContact::InvalidatePartOfView(const basegfx::B2DRange& /*rRange*/) const +{ + // nothing to do here in the default version +} + +// Get info about the need to visualize GluePoints +bool ObjectContact::AreGluePointsVisible() const +{ + return false; +} + +// check if text animation is allowed. Default is sal_true. +bool ObjectContact::IsTextAnimationAllowed() const +{ + return true; +} + +// check if graphic animation is allowed. Default is sal_true. +bool ObjectContact::IsGraphicAnimationAllowed() const +{ + return true; +} + +void ObjectContact::SetViewObjectContactRedirector(ViewObjectContactRedirector* pNew) +{ + if(mpViewObjectContactRedirector != pNew) + { + mpViewObjectContactRedirector = pNew; + } +} + +// print? Default is false +bool ObjectContact::isOutputToPrinter() const +{ + return false; +} + +// recording MetaFile? Default is false +bool ObjectContact::isOutputToRecordingMetaFile() const +{ + return false; +} + +// pdf export? Default is false +bool ObjectContact::isOutputToPDFFile() const +{ + return false; +} + +// gray display mode +bool ObjectContact::isDrawModeGray() const +{ + return false; +} + +// high contrast display mode +bool ObjectContact::isDrawModeHighContrast() const +{ + return false; +} + +// access to SdrPageView. Default implementation returns NULL +SdrPageView* ObjectContact::TryToGetSdrPageView() const +{ + return nullptr; +} + +// access to OutputDevice. Default implementation returns NULL +OutputDevice* ObjectContact::TryToGetOutputDevice() const +{ + return nullptr; +} + +void ObjectContact::resetAllGridOffsets() +{ + const sal_uInt32 nVOCCount(getViewObjectContactCount()); + + for(sal_uInt32 a(0); a < nVOCCount; a++) + { + ViewObjectContact* pVOC(getViewObjectContact(a)); + assert(pVOC && "ObjectContact: ViewObjectContact list Corrupt (!)"); + pVOC->resetGridOffset(); + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/objectcontactofobjlistpainter.cxx b/svx/source/sdr/contact/objectcontactofobjlistpainter.cxx new file mode 100644 index 000000000..0fbecf793 --- /dev/null +++ b/svx/source/sdr/contact/objectcontactofobjlistpainter.cxx @@ -0,0 +1,189 @@ +/* -*- 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 <sdr/contact/objectcontactofobjlistpainter.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdobj.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/processor2d/baseprocessor2d.hxx> +#include <drawinglayer/processor2d/processor2dtools.hxx> +#include <svx/unoapi.hxx> +#include <tools/debug.hxx> +#include <vcl/gdimtf.hxx> +#include <memory> + +namespace sdr::contact { + +ObjectContactPainter::ObjectContactPainter() +{ +} + +// The destructor. +ObjectContactPainter::~ObjectContactPainter() +{ +} + +sal_uInt32 ObjectContactOfObjListPainter::GetPaintObjectCount() const +{ + return maStartObjects.size(); +} + +ViewContact& ObjectContactOfObjListPainter::GetPaintObjectViewContact(sal_uInt32 nIndex) +{ + const SdrObject* pObj = maStartObjects[nIndex]; + DBG_ASSERT(pObj, "ObjectContactOfObjListPainter: Corrupt SdrObjectVector (!)"); + return pObj->GetViewContact(); +} + +ObjectContactOfObjListPainter::ObjectContactOfObjListPainter( + OutputDevice& rTargetDevice, + const SdrObjectVector& rObjects, + const SdrPage* pProcessedPage) +: ObjectContactPainter(), + mrTargetOutputDevice(rTargetDevice), + maStartObjects(rObjects), + mpProcessedPage(pProcessedPage) +{ +} + +ObjectContactOfObjListPainter::~ObjectContactOfObjListPainter() +{ +} + +// Process the whole displaying +void ObjectContactOfObjListPainter::ProcessDisplay(DisplayInfo& rDisplayInfo) +{ + const sal_uInt32 nCount(GetPaintObjectCount()); + + if(nCount) + { + OutputDevice* pTargetDevice = TryToGetOutputDevice(); + + if(pTargetDevice) + { + // update current ViewInformation2D at the ObjectContact + const GDIMetaFile* pMetaFile = pTargetDevice->GetConnectMetaFile(); + const bool bOutputToRecordingMetaFile(pMetaFile && pMetaFile->IsRecord() && !pMetaFile->IsPause()); + basegfx::B2DRange aViewRange; + + // create ViewRange + if(!bOutputToRecordingMetaFile) + { + // use visible pixels, but transform to world coordinates + const Size aOutputSizePixel(pTargetDevice->GetOutputSizePixel()); + aViewRange = ::basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight()); + aViewRange.transform(pTargetDevice->GetInverseViewTransformation()); + } + + // update local ViewInformation2D + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D( + basegfx::B2DHomMatrix(), + pTargetDevice->GetViewTransformation(), + aViewRange, + GetXDrawPageForSdrPage(const_cast< SdrPage* >(mpProcessedPage)), + 0.0, + css::uno::Sequence<css::beans::PropertyValue>()); + updateViewInformation2D(aNewViewInformation2D); + + // collect primitive data in a sequence; this will already use the updated ViewInformation2D + drawinglayer::primitive2d::Primitive2DContainer xPrimitiveSequence; + + for(sal_uInt32 a(0); a < nCount; a++) + { + const ViewObjectContact& rViewObjectContact = GetPaintObjectViewContact(a).GetViewObjectContact(*this); + + xPrimitiveSequence.append(rViewObjectContact.getPrimitive2DSequenceHierarchy(rDisplayInfo)); + } + + // if there is something to show, use a vclProcessor to render it + if(!xPrimitiveSequence.empty()) + { + std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D(drawinglayer::processor2d::createProcessor2DFromOutputDevice( + *pTargetDevice, + getViewInformation2D())); + + if(pProcessor2D) + { + pProcessor2D->process(xPrimitiveSequence); + } + } + } + } +} + +// recording MetaFile? +bool ObjectContactOfObjListPainter::isOutputToRecordingMetaFile() const +{ + GDIMetaFile* pMetaFile = mrTargetOutputDevice.GetConnectMetaFile(); + return (pMetaFile && pMetaFile->IsRecord() && !pMetaFile->IsPause()); +} + +// pdf export? +bool ObjectContactOfObjListPainter::isOutputToPDFFile() const +{ + return OUTDEV_PDF == mrTargetOutputDevice.GetOutDevType(); +} + +OutputDevice* ObjectContactOfObjListPainter::TryToGetOutputDevice() const +{ + return &mrTargetOutputDevice; +} + +sal_uInt32 ObjectContactOfPagePainter::GetPaintObjectCount() const +{ + return (GetStartPage() ? 1 : 0); +} + +ViewContact& ObjectContactOfPagePainter::GetPaintObjectViewContact(sal_uInt32 /*nIndex*/) +{ + DBG_ASSERT(GetStartPage(), "ObjectContactOfPagePainter::GetPaintObjectViewContact: no StartPage set (!)"); + return GetStartPage()->GetViewContact(); +} + +ObjectContactOfPagePainter::ObjectContactOfPagePainter( + ObjectContact& rOriginalObjectContact) +: ObjectContactPainter(), + mrOriginalObjectContact(rOriginalObjectContact), + mxStartPage() +{ +} + +ObjectContactOfPagePainter::~ObjectContactOfPagePainter() +{ +} + +void ObjectContactOfPagePainter::SetStartPage(const SdrPage* pPage) +{ + if(pPage != GetStartPage()) + { + mxStartPage.reset(const_cast< SdrPage* >(pPage)); // no tools::WeakReference<SdrPage> available to hold a const SdrPage* + } +} + +OutputDevice* ObjectContactOfPagePainter::TryToGetOutputDevice() const +{ + return mrOriginalObjectContact.TryToGetOutputDevice(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/objectcontactofpageview.cxx b/svx/source/sdr/contact/objectcontactofpageview.cxx new file mode 100644 index 000000000..364b0d90b --- /dev/null +++ b/svx/source/sdr/contact/objectcontactofpageview.cxx @@ -0,0 +1,440 @@ +/* -*- 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_feature_desktop.h> + +#include <svx/sdr/contact/objectcontactofpageview.hxx> +#include <sdr/contact/viewobjectcontactofunocontrol.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdpage.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/svdview.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <svx/sdr/animation/objectanimator.hxx> +#include <svx/sdrpagewindow.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/processor2d/baseprocessor2d.hxx> +#include <drawinglayer/processor2d/processor2dtools.hxx> +#include <svx/unoapi.hxx> +#include <unotools/configmgr.hxx> +#include <vcl/canvastools.hxx> +#include <comphelper/lok.hxx> + +#include <memory> + +using namespace com::sun::star; + +namespace sdr::contact +{ + // internal access to SdrPage of SdrPageView + SdrPage* ObjectContactOfPageView::GetSdrPage() const + { + return GetPageWindow().GetPageView().GetPage(); + } + + ObjectContactOfPageView::ObjectContactOfPageView( + SdrPageWindow& rPageWindow, const char *pDebugName) + : ObjectContact() + , Idle(pDebugName) + , mrPageWindow(rPageWindow) + { + // init PreviewRenderer flag + setPreviewRenderer(static_cast<SdrPaintView&>(rPageWindow.GetPageView().GetView()).IsPreviewRenderer()); + + // init timer + SetPriority(TaskPriority::HIGH_IDLE); + Stop(); + } + + ObjectContactOfPageView::~ObjectContactOfPageView() + { + // execute missing LazyInvalidates and stop timer + Invoke(); + } + + // LazyInvalidate request. Take action. + void ObjectContactOfPageView::setLazyInvalidate(ViewObjectContact& /*rVOC*/) + { + // do NOT call parent, but remember that something is to do by + // starting the LazyInvalidateTimer + Start(); + } + + // call this to support evtl. preparations for repaint + void ObjectContactOfPageView::PrepareProcessDisplay() + { + if(IsActive()) + // there are still non-triggered LazyInvalidate events, trigger these + Invoke(); + } + + // From baseclass Timer, the timeout call triggered by the LazyInvalidate mechanism + void ObjectContactOfPageView::Invoke() + { + // stop the timer + Stop(); + + // invalidate all LazyInvalidate VOCs new situations + const sal_uInt32 nVOCCount(getViewObjectContactCount()); + + for(sal_uInt32 a(0); a < nVOCCount; a++) + { + ViewObjectContact* pCandidate = getViewObjectContact(a); + pCandidate->triggerLazyInvalidate(); + } + } + + // Process the whole displaying + void ObjectContactOfPageView::ProcessDisplay(DisplayInfo& rDisplayInfo) + { + const SdrPage* pStartPage = GetSdrPage(); + + if(pStartPage && !rDisplayInfo.GetProcessLayers().IsEmpty()) + { + const ViewContact& rDrawPageVC = pStartPage->GetViewContact(); + + if(rDrawPageVC.GetObjectCount()) + { + DoProcessDisplay(rDisplayInfo); + } + } + } + + // Process the whole displaying. Only use given DisplayInfo, do not access other + // OutputDevices then the given ones. + void ObjectContactOfPageView::DoProcessDisplay(DisplayInfo& rDisplayInfo) + { + OutputDevice& rTargetOutDev = GetPageWindow().GetPaintWindow().GetTargetOutputDevice(); + const Size aOutputSizePixel(rTargetOutDev.GetOutputSizePixel()); + if (!isOutputToRecordingMetaFile() // do those have outdev too? + && (0 == aOutputSizePixel.getWidth() || + 0 == aOutputSizePixel.getHeight())) + { + return; + } + + // visualize entered group when that feature is switched on and it's not + // a print output. #i29129# No ghosted display for printing. + bool bVisualizeEnteredGroup(DoVisualizeEnteredGroup() && !isOutputToPrinter()); + + // Visualize entered groups: Set to ghosted as default + // start. Do this only for the DrawPage, not for MasterPages + if(bVisualizeEnteredGroup) + { + rDisplayInfo.SetGhostedDrawMode(); + } + + // #114359# save old and set clip region + OutputDevice* pOutDev = TryToGetOutputDevice(); + OSL_ENSURE(nullptr != pOutDev, "ObjectContactOfPageView without OutDev, someone has overridden TryToGetOutputDevice wrong (!)"); + bool bClipRegionPushed(false); + const vcl::Region& rRedrawArea(rDisplayInfo.GetRedrawArea()); + + if(!rRedrawArea.IsEmpty() && !comphelper::LibreOfficeKit::isActive()) + { + bClipRegionPushed = true; + pOutDev->Push(PushFlags::CLIPREGION); + pOutDev->IntersectClipRegion(rRedrawArea); + } + + // Get start node and process DrawPage contents + const ViewObjectContact& rDrawPageVOContact = GetSdrPage()->GetViewContact().GetViewObjectContact(*this); + + // update current ViewInformation2D at the ObjectContact + const double fCurrentTime(getPrimitiveAnimator().GetTime()); + basegfx::B2DRange aViewRange; + + // create ViewRange + if(isOutputToRecordingMetaFile()) + { + if (!rDisplayInfo.GetRedrawArea().IsEmpty()) + { + // #i98402# if it's a PDF export, set the ClipRegion as ViewRange. This is + // mainly because SW does not use DrawingLayer Page-Oriented and if not doing this, + // all existing objects will be collected as primitives and processed. + // OD 2009-03-05 #i99876# perform the same also for SW on printing. + // fdo#78149 same thing also needed for plain MetaFile + // export, so why not do it always + const tools::Rectangle aLogicClipRectangle(rDisplayInfo.GetRedrawArea().GetBoundRect()); + + aViewRange = vcl::unotools::b2DRectangleFromRectangle(aLogicClipRectangle); + } + } + else + { + // use visible pixels, but transform to world coordinates + aViewRange = basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight()); + // if a clip region is set, use it + if(!rDisplayInfo.GetRedrawArea().IsEmpty()) + { + // get logic clip range and create discrete one + const tools::Rectangle aLogicClipRectangle(rDisplayInfo.GetRedrawArea().GetBoundRect()); + basegfx::B2DRange aLogicClipRange = vcl::unotools::b2DRectangleFromRectangle(aLogicClipRectangle); + basegfx::B2DRange aDiscreteClipRange(aLogicClipRange); + aDiscreteClipRange.transform(rTargetOutDev.GetViewTransformation()); + + // align the discrete one to discrete boundaries (pixel bounds). Also + // expand X and Y max by one due to Rectangle definition source + aDiscreteClipRange.expand(basegfx::B2DTuple( + floor(aDiscreteClipRange.getMinX()), + floor(aDiscreteClipRange.getMinY()))); + aDiscreteClipRange.expand(basegfx::B2DTuple( + 1.0 + ceil(aDiscreteClipRange.getMaxX()), + 1.0 + ceil(aDiscreteClipRange.getMaxY()))); + + // intersect current ViewRange with ClipRange + aViewRange.intersect(aDiscreteClipRange); + } + + // transform to world coordinates + aViewRange.transform(rTargetOutDev.GetInverseViewTransformation()); + } + + // update local ViewInformation2D + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D( + basegfx::B2DHomMatrix(), + rTargetOutDev.GetViewTransformation(), + aViewRange, + GetXDrawPageForSdrPage(GetSdrPage()), + fCurrentTime, + uno::Sequence<beans::PropertyValue>()); + updateViewInformation2D(aNewViewInformation2D); + + drawinglayer::primitive2d::Primitive2DContainer xPrimitiveSequence; +#if HAVE_FEATURE_DESKTOP || defined( ANDROID ) + // get whole Primitive2DContainer; this will already make use of updated ViewInformation2D + // and may use the MapMode from the Target OutDev in the DisplayInfo + xPrimitiveSequence = rDrawPageVOContact.getPrimitive2DSequenceHierarchy(rDisplayInfo); +#else + // Hmm, !HAVE_FEATURE_DESKTOP && !ANDROID means iOS, + // right? But does it makes sense to use a different code + // path for iOS than for Android; both use tiled rendering + // etc now. + + // HACK: this only works when we are drawing sdr shapes via + // drawinglayer; but it can happen that the hierarchy contains + // more than just the shapes, and then it fails. + // + // This is good enough for the tiled rendering for the moment, but + // we need to come up with the real solution shortly. + + // Only get the expensive hierarchy if we can be sure that the + // returned sequence won't be empty anyway. + bool bGetHierarchy = rRedrawArea.IsEmpty(); + if (!bGetHierarchy) + { + // Not empty? Then not doing a full redraw, check if + // getPrimitive2DSequenceHierarchy() is still needed. + sal_Int32 nObjCount = GetSdrPage()->GetObjCount(); + for (sal_Int32 i = 0; i < nObjCount; ++i) + { + SdrObject* pObject = GetSdrPage()->GetObj(i); + if (rRedrawArea.IsOver(pObject->GetCurrentBoundRect())) + { + bGetHierarchy = true; + break; + } + } + } + + if (bGetHierarchy) + // get whole Primitive2DContainer; this will already make use of updated ViewInformation2D + // and may use the MapMode from the Target OutDev in the DisplayInfo + xPrimitiveSequence = rDrawPageVOContact.getPrimitive2DSequenceHierarchy(rDisplayInfo); +#endif + + // if there is something to show, use a primitive processor to render it. There + // is a choice between VCL and Canvas processors currently. The decision is made in + // createProcessor2DFromOutputDevice and takes into account things like the + // Target is a MetaFile, a VDev or something else. The Canvas renderer is triggered + // currently using the shown boolean. Canvas is not yet the default. + if(!xPrimitiveSequence.empty()) + { + // prepare OutputDevice (historical stuff, maybe soon removed) + rDisplayInfo.ClearGhostedDrawMode(); // reset, else the VCL-paint with the processor will not do the right thing + pOutDev->SetLayoutMode(ComplexTextLayoutFlags::Default); // reset, default is no BiDi/RTL + + // create renderer + std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D( + drawinglayer::processor2d::createProcessor2DFromOutputDevice( + rTargetOutDev, getViewInformation2D())); + + if(pProcessor2D) + { + pProcessor2D->process(xPrimitiveSequence); + } + } + + // #114359# restore old ClipReghion + if(bClipRegionPushed) + { + pOutDev->Pop(); + } + + // Visualize entered groups: Reset to original DrawMode + if(bVisualizeEnteredGroup) + { + rDisplayInfo.ClearGhostedDrawMode(); + } + } + + // test if visualizing of entered groups is switched on at all + bool ObjectContactOfPageView::DoVisualizeEnteredGroup() const + { + return true; + } + + // get active group's (the entered group) ViewContact + const ViewContact* ObjectContactOfPageView::getActiveViewContact() const + { + SdrObjList* pActiveGroupList = GetPageWindow().GetPageView().GetObjList(); + + if(pActiveGroupList) + { + if(nullptr != pActiveGroupList->getSdrPageFromSdrObjList()) + { + // It's a Page itself + return &(pActiveGroupList->getSdrPageFromSdrObjList()->GetViewContact()); + } + else if(pActiveGroupList->getSdrObjectFromSdrObjList()) + { + // Group object + return &(pActiveGroupList->getSdrObjectFromSdrObjList()->GetViewContact()); + } + } + else if(GetSdrPage()) + { + // use page of associated SdrPageView + return &(GetSdrPage()->GetViewContact()); + } + + return nullptr; + } + + // Invalidate given rectangle at the window/output which is represented by + // this ObjectContact. + void ObjectContactOfPageView::InvalidatePartOfView(const basegfx::B2DRange& rRange) const + { + // invalidate at associated PageWindow + GetPageWindow().InvalidatePageWindow(rRange); + } + + // Get info about the need to visualize GluePoints + bool ObjectContactOfPageView::AreGluePointsVisible() const + { + return GetPageWindow().GetPageView().GetView().ImpIsGlueVisible(); + } + + // check if text animation is allowed. + bool ObjectContactOfPageView::IsTextAnimationAllowed() const + { + if (utl::ConfigManager::IsFuzzing()) + return true; + SdrView& rView = GetPageWindow().GetPageView().GetView(); + const SvtAccessibilityOptions& rOpt = rView.getAccessibilityOptions(); + return rOpt.GetIsAllowAnimatedText(); + } + + // check if graphic animation is allowed. + bool ObjectContactOfPageView::IsGraphicAnimationAllowed() const + { + if (utl::ConfigManager::IsFuzzing()) + return true; + SdrView& rView = GetPageWindow().GetPageView().GetView(); + const SvtAccessibilityOptions& rOpt = rView.getAccessibilityOptions(); + return rOpt.GetIsAllowAnimatedGraphics(); + } + + // print? + bool ObjectContactOfPageView::isOutputToPrinter() const + { + return (OUTDEV_PRINTER == mrPageWindow.GetPaintWindow().GetOutputDevice().GetOutDevType()); + } + + // recording MetaFile? + bool ObjectContactOfPageView::isOutputToRecordingMetaFile() const + { + GDIMetaFile* pMetaFile = mrPageWindow.GetPaintWindow().GetOutputDevice().GetConnectMetaFile(); + return (pMetaFile && pMetaFile->IsRecord() && !pMetaFile->IsPause()); + } + + // pdf export? + bool ObjectContactOfPageView::isOutputToPDFFile() const + { + return OUTDEV_PDF == mrPageWindow.GetPaintWindow().GetOutputDevice().GetOutDevType(); + } + + // gray display mode + bool ObjectContactOfPageView::isDrawModeGray() const + { + const DrawModeFlags nDrawMode(mrPageWindow.GetPaintWindow().GetOutputDevice().GetDrawMode()); + return (nDrawMode == (DrawModeFlags::GrayLine|DrawModeFlags::GrayFill|DrawModeFlags::BlackText|DrawModeFlags::GrayBitmap|DrawModeFlags::GrayGradient)); + } + + // high contrast display mode + bool ObjectContactOfPageView::isDrawModeHighContrast() const + { + const DrawModeFlags nDrawMode(mrPageWindow.GetPaintWindow().GetOutputDevice().GetDrawMode()); + return (nDrawMode == (DrawModeFlags::SettingsLine|DrawModeFlags::SettingsFill|DrawModeFlags::SettingsText|DrawModeFlags::SettingsGradient)); + } + + // access to SdrPageView + SdrPageView* ObjectContactOfPageView::TryToGetSdrPageView() const + { + return &(mrPageWindow.GetPageView()); + } + + + // access to OutputDevice + OutputDevice* ObjectContactOfPageView::TryToGetOutputDevice() const + { + SdrPreRenderDevice* pPreRenderDevice = mrPageWindow.GetPaintWindow().GetPreRenderDevice(); + + if(pPreRenderDevice) + { + return &(pPreRenderDevice->GetPreRenderDevice()); + } + else + { + return &(mrPageWindow.GetPaintWindow().GetOutputDevice()); + } + } + + // set all UNO controls displayed in the view to design/alive mode + void ObjectContactOfPageView::SetUNOControlsDesignMode( bool _bDesignMode ) const + { + const sal_uInt32 nCount(getViewObjectContactCount()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + const ViewObjectContact* pVOC = getViewObjectContact(a); + const ViewObjectContactOfUnoControl* pUnoObjectVOC = dynamic_cast< const ViewObjectContactOfUnoControl* >(pVOC); + + if(pUnoObjectVOC) + { + pUnoObjectVOC->setControlDesignMode(_bDesignMode); + } + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/sdrmediawindow.cxx b/svx/source/sdr/contact/sdrmediawindow.cxx new file mode 100644 index 000000000..086e12cee --- /dev/null +++ b/svx/source/sdr/contact/sdrmediawindow.cxx @@ -0,0 +1,174 @@ +/* -*- 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 "sdrmediawindow.hxx" +#include <vcl/transfer.hxx> + +#include <sdr/contact/viewobjectcontactofsdrmediaobj.hxx> +#include <vcl/window.hxx> +#include <vcl/commandevent.hxx> +#include <vcl/event.hxx> + +namespace sdr::contact { + + +SdrMediaWindow::SdrMediaWindow( vcl::Window* pParent, ViewObjectContactOfSdrMediaObj& rViewObjContact ) : + ::avmedia::MediaWindow( pParent, false ), + mrViewObjectContactOfSdrMediaObj( rViewObjContact ) +{ +} + + +SdrMediaWindow::~SdrMediaWindow() +{ +} + + +void SdrMediaWindow::MouseMove( const MouseEvent& rMEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + + if( pWindow && getWindow() ) + { + const MouseEvent aTransformedEvent( pWindow->ScreenToOutputPixel( getWindow()->OutputToScreenPixel( rMEvt.GetPosPixel() ) ), + rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), rMEvt.GetModifier() ); + + pWindow->MouseMove( aTransformedEvent ); + setPointer( pWindow->GetPointer() ); + } +} + + +void SdrMediaWindow::MouseButtonDown( const MouseEvent& rMEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + + if( pWindow && getWindow() ) + { + const MouseEvent aTransformedEvent( pWindow->ScreenToOutputPixel( getWindow()->OutputToScreenPixel( rMEvt.GetPosPixel() ) ), + rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), rMEvt.GetModifier() ); + + pWindow->MouseButtonDown( aTransformedEvent ); + } +} + + +void SdrMediaWindow::MouseButtonUp( const MouseEvent& rMEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + + if( pWindow && getWindow() ) + { + const MouseEvent aTransformedEvent( pWindow->ScreenToOutputPixel( getWindow()->OutputToScreenPixel( rMEvt.GetPosPixel() ) ), + rMEvt.GetClicks(), rMEvt.GetMode(), rMEvt.GetButtons(), rMEvt.GetModifier() ); + + pWindow->MouseButtonUp( aTransformedEvent ); + } +} + + +void SdrMediaWindow::KeyInput( const KeyEvent& rKEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + + if( pWindow ) + pWindow->KeyInput( rKEvt ); +} + + +void SdrMediaWindow::KeyUp( const KeyEvent& rKEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + + if( pWindow ) + pWindow->KeyUp( rKEvt ); +} + + +void SdrMediaWindow::Command( const CommandEvent& rCEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + + if( pWindow && getWindow() ) + { + const CommandEvent aTransformedEvent( pWindow->ScreenToOutputPixel( getWindow()->OutputToScreenPixel( rCEvt.GetMousePosPixel() ) ), + rCEvt.GetCommand(), rCEvt.IsMouseEvent(), rCEvt.GetEventData() ); + + pWindow->Command( aTransformedEvent ); + } +} + + +sal_Int8 SdrMediaWindow::AcceptDrop( const AcceptDropEvent& rEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + sal_Int8 nRet = DND_ACTION_NONE; + + if( pWindow ) + { + DropTargetHelper* pDropTargetHelper = dynamic_cast< DropTargetHelper* >( pWindow ); + + if( pDropTargetHelper ) + { + nRet = pDropTargetHelper->AcceptDrop( rEvt ); + } + } + + return nRet; +} + + +sal_Int8 SdrMediaWindow::ExecuteDrop( const ExecuteDropEvent& rEvt ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + sal_Int8 nRet = DND_ACTION_NONE; + + if( pWindow ) + { + DropTargetHelper* pDropTargetHelper = dynamic_cast< DropTargetHelper* >( pWindow ); + + if( pDropTargetHelper ) + { + nRet = pDropTargetHelper->ExecuteDrop( rEvt ); + } + } + + return nRet; +} + + +void SdrMediaWindow::StartDrag( sal_Int8 nAction, const Point& rPosPixel ) +{ + vcl::Window* pWindow = mrViewObjectContactOfSdrMediaObj.getWindow(); + + if( pWindow ) + { + DragSourceHelper* pDragSourceHelper = dynamic_cast< DragSourceHelper* >( pWindow ); + + if( pDragSourceHelper ) + { + pDragSourceHelper->StartDrag( nAction, rPosPixel ); + } + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/sdrmediawindow.hxx b/svx/source/sdr/contact/sdrmediawindow.hxx new file mode 100644 index 000000000..fb3cda6fc --- /dev/null +++ b/svx/source/sdr/contact/sdrmediawindow.hxx @@ -0,0 +1,60 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_SDR_CONTACT_SDRMEDIAWINDOW_HXX +#define INCLUDED_SVX_SOURCE_SDR_CONTACT_SDRMEDIAWINDOW_HXX + +#include <avmedia/mediawindow.hxx> + +namespace sdr::contact { + + +class ViewObjectContactOfSdrMediaObj; + +class SdrMediaWindow : public ::avmedia::MediaWindow +{ +public: + + SdrMediaWindow( vcl::Window* pParent, ViewObjectContactOfSdrMediaObj& rViewObjContact ); + virtual ~SdrMediaWindow() override; + + virtual void MouseMove( const MouseEvent& rMEvt ) override; + virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; + virtual void MouseButtonUp( const MouseEvent& rMEvt ) override; + + virtual void KeyInput( const KeyEvent& rKEvt ) override; + virtual void KeyUp( const KeyEvent& rKEvt ) override; + + virtual void Command( const CommandEvent& rCEvt ) override; + + virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override; + virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override; + + virtual void StartDrag( sal_Int8 nAction, const Point& rPosPixel ) override; + +private: + + ViewObjectContactOfSdrMediaObj& mrViewObjectContactOfSdrMediaObj; +}; + +} + +#endif // INCLUDED_SVX_SOURCE_SDR_CONTACT_SDRMEDIAWINDOW_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontact.cxx b/svx/source/sdr/contact/viewcontact.cxx new file mode 100644 index 000000000..0d19add7f --- /dev/null +++ b/svx/source/sdr/contact/viewcontact.cxx @@ -0,0 +1,288 @@ +/* -*- 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 <svx/sdr/contact/viewcontact.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/color/bcolor.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <tools/debug.hxx> + +namespace sdr::contact { + +// Create an Object-Specific ViewObjectContact, set ViewContact and +// ObjectContact. Always needs to return something. Default is to create +// a standard ViewObjectContact containing the given ObjectContact and *this +ViewObjectContact& ViewContact::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + return *(new ViewObjectContact(rObjectContact, *this)); +} + +ViewContact::ViewContact() +: maViewObjectContactVector(), + mxViewIndependentPrimitive2DSequence() +{ +} + +ViewContact::~ViewContact() +{ + deleteAllVOCs(); +} + +void ViewContact::deleteAllVOCs() +{ + // get rid of all VOCs + // #i84257# To avoid that each 'delete pCandidate' again uses + // the local RemoveViewObjectContact with a search and removal in the + // vector, simply copy and clear local vector. + std::vector< ViewObjectContact* > aLocalVOCList; + aLocalVOCList.swap(maViewObjectContactVector); + + for (const auto & pCandidate : aLocalVOCList) + // ViewObjectContacts only make sense with View and Object contacts. + // When the contact to the SdrObject is deleted like in this case, + // all ViewObjectContacts can be deleted, too. + delete pCandidate; + + // assert when there were new entries added during deletion + DBG_ASSERT(maViewObjectContactVector.empty(), "Corrupted ViewObjectContactList in VC (!)"); +} + +// get an Object-specific ViewObjectContact for a specific +// ObjectContact (->View). Always needs to return something. +ViewObjectContact& ViewContact::GetViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = nullptr; + const sal_uInt32 nCount(maViewObjectContactVector.size()); + + // first search if there exists a VOC for the given OC + for(sal_uInt32 a(0); !pRetval && a < nCount; a++) + { + ViewObjectContact* pCandidate = maViewObjectContactVector[a]; + DBG_ASSERT(pCandidate, "Corrupted ViewObjectContactList (!)"); + + if(&(pCandidate->GetObjectContact()) == &rObjectContact) + { + pRetval = pCandidate; + } + } + + if(!pRetval) + { + // create a new one. It's inserted to the local list from the + // ViewObjectContact constructor via AddViewObjectContact() + pRetval = &CreateObjectSpecificViewObjectContact(rObjectContact); + } + + return *pRetval; +} + +// A new ViewObjectContact was created and shall be remembered. +void ViewContact::AddViewObjectContact(ViewObjectContact& rVOContact) +{ + maViewObjectContactVector.push_back(&rVOContact); +} + +// A ViewObjectContact was deleted and shall be forgotten. +void ViewContact::RemoveViewObjectContact(ViewObjectContact& rVOContact) +{ + std::vector< ViewObjectContact* >::iterator aFindResult = std::find(maViewObjectContactVector.begin(), maViewObjectContactVector.end(), &rVOContact); + + if(aFindResult != maViewObjectContactVector.end()) + { + maViewObjectContactVector.erase(aFindResult); + } +} + +// Test if this ViewContact has ViewObjectContacts at all. This can +// be used to test if this ViewContact is visualized ATM or not +bool ViewContact::HasViewObjectContacts() const +{ + const sal_uInt32 nCount(maViewObjectContactVector.size()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + if(!maViewObjectContactVector[a]->GetObjectContact().IsPreviewRenderer()) + { + return true; + } + } + return false; +} + +// Test if this ViewContact has ViewObjectContacts at all. This can +// be used to test if this ViewContact is visualized ATM or not +bool ViewContact::isAnimatedInAnyViewObjectContact() const +{ + const sal_uInt32 nCount(maViewObjectContactVector.size()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + if(maViewObjectContactVector[a]->isAnimated()) + { + return true; + } + } + + return false; +} + +// Access to possible sub-hierarchy and parent. GetObjectCount() default is 0L +// and GetViewContact default pops up an assert since it's an error if +// GetObjectCount has a result != 0 and it's not overridden. +sal_uInt32 ViewContact::GetObjectCount() const +{ + // no sub-objects + return 0; +} + +ViewContact& ViewContact::GetViewContact(sal_uInt32 /*nIndex*/) const +{ + // This is the default implementation; call would be an error + OSL_FAIL("ViewContact::GetViewContact: This call needs to be overridden when GetObjectCount() can return results != 0 (!)"); + return const_cast<ViewContact&>(*this); +} + +ViewContact* ViewContact::GetParentContact() const +{ + // default has no parent + return nullptr; +} + +void ViewContact::ActionChildInserted(ViewContact& rChild) +{ + // propagate change to all existing visualisations which + // will force a VOC for the new child and invalidate its range + const sal_uInt32 nCount(maViewObjectContactVector.size()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + ViewObjectContact* pCandidate = maViewObjectContactVector[a]; + DBG_ASSERT(pCandidate, "ViewContact::GetViewObjectContact() invalid ViewObjectContactList (!)"); + + // take action at all VOCs. At the VOCs ObjectContact the initial + // rectangle will be invalidated at the associated OutputDevice. + pCandidate->ActionChildInserted(rChild); + } +} + +// React on changes of the object of this ViewContact +void ViewContact::ActionChanged() +{ + // propagate change to all existing VOCs. This will invalidate + // all drawn visualisations in all known views + const sal_uInt32 nCount(maViewObjectContactVector.size()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + ViewObjectContact* pCandidate = maViewObjectContactVector[a]; + DBG_ASSERT(pCandidate, "ViewContact::GetViewObjectContact() invalid ViewObjectContactList (!)"); + + pCandidate->ActionChanged(); + } +} + +// access to SdrObject and/or SdrPage. May return 0L like the default +// implementations do. Override as needed. +SdrObject* ViewContact::TryToGetSdrObject() const +{ + return nullptr; +} + +// primitive stuff + +drawinglayer::primitive2d::Primitive2DContainer ViewContact::createViewIndependentPrimitive2DSequence() const +{ + // This is the default implementation and should never be called (see header). If this is called, + // someone implemented a ViewContact (VC) visualisation object without defining the visualisation by + // providing a sequence of primitives -> which cannot be correct. + // Since we have no access to any known model data here, the default implementation creates a yellow placeholder + // hairline polygon with a default size of (1000, 1000, 5000, 3000) + OSL_FAIL("ViewContact::createViewIndependentPrimitive2DSequence(): Never call the fallback base implementation, this is always an error (!)"); + const basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromRect(basegfx::B2DRange(1000.0, 1000.0, 5000.0, 3000.0))); + const basegfx::BColor aYellow(1.0, 1.0, 0.0); + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aOutline, aYellow)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; +} + +drawinglayer::primitive2d::Primitive2DContainer const & ViewContact::getViewIndependentPrimitive2DContainer() const +{ + // local up-to-date checks. Create new list and compare. + drawinglayer::primitive2d::Primitive2DContainer xNew(createViewIndependentPrimitive2DSequence()); + + if(!xNew.empty()) + { + // allow evtl. embedding in object-specific infos, e.g. Name, Title, Description + xNew = embedToObjectSpecificInformation(std::move(xNew)); + } + + if(mxViewIndependentPrimitive2DSequence != xNew) + { + // has changed, copy content + const_cast< ViewContact* >(this)->mxViewIndependentPrimitive2DSequence = std::move(xNew); + } + + // return current Primitive2DContainer + return mxViewIndependentPrimitive2DSequence; +} + +// add Gluepoints (if available) +drawinglayer::primitive2d::Primitive2DContainer ViewContact::createGluePointPrimitive2DSequence() const +{ + // default returns empty reference + return drawinglayer::primitive2d::Primitive2DContainer(); +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContact::embedToObjectSpecificInformation(drawinglayer::primitive2d::Primitive2DContainer aSource) const +{ + // nothing to do for default + return aSource; +} + +basegfx::B2DRange ViewContact::getRange( const drawinglayer::geometry::ViewInformation2D& /*rViewInfo2D*/ ) const +{ + // Return empty range. + return basegfx::B2DRange(); +} + +void ViewContact::flushViewObjectContacts(bool bWithHierarchy) +{ + if(bWithHierarchy) + { + // flush DrawingLayer hierarchy + const sal_uInt32 nCount(GetObjectCount()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + ViewContact& rChild = GetViewContact(a); + rChild.flushViewObjectContacts(bWithHierarchy); + } + } + + // delete local VOCs + deleteAllVOCs(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofe3d.cxx b/svx/source/sdr/contact/viewcontactofe3d.cxx new file mode 100644 index 000000000..809c99d22 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofe3d.cxx @@ -0,0 +1,195 @@ +/* -*- 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 <sdr/contact/viewcontactofe3d.hxx> +#include <sdr/contact/viewobjectcontactofe3d.hxx> +#include <svx/obj3d.hxx> +#include <drawinglayer/primitive2d/embedded3dprimitive2d.hxx> +#include <svx/sdr/contact/viewcontactofe3dscene.hxx> +#include <svx/scene3d.hxx> +#include <drawinglayer/primitive3d/transformprimitive3d.hxx> +#include <drawinglayer/attribute/sdrsceneattribute3d.hxx> +#include <drawinglayer/attribute/sdrlightingattribute3d.hxx> +#include <drawinglayer/attribute/sdrlightattribute3d.hxx> + +namespace { + +const sdr::contact::ViewContactOfE3dScene* tryToFindVCOfE3DScene( + const sdr::contact::ViewContact& rCandidate, + basegfx::B3DHomMatrix& o_rInBetweenObjectTransform) +{ + const sdr::contact::ViewContactOfE3dScene* pSceneParent = + dynamic_cast< const sdr::contact::ViewContactOfE3dScene* >(rCandidate.GetParentContact()); + + if(pSceneParent) + { + // each 3d object (including in-between scenes) should have a scene as parent + const sdr::contact::ViewContactOfE3dScene* pSceneParentParent = + dynamic_cast< const sdr::contact::ViewContactOfE3dScene* >(pSceneParent->GetParentContact()); + + if(pSceneParentParent) + { + // the parent scene of rCandidate is an in-between scene, call recursively and collect + // the in-between scene's object transformation part in o_rInBetweenObjectTransform + const basegfx::B3DHomMatrix& rSceneParentTransform = pSceneParent->GetE3dScene().GetTransform(); + o_rInBetweenObjectTransform = rSceneParentTransform * o_rInBetweenObjectTransform; + return tryToFindVCOfE3DScene(*pSceneParent, o_rInBetweenObjectTransform); + } + else + { + // the parent scene is the outmost scene + return pSceneParent; + } + } + + // object hierarchy structure is incorrect; no result + return nullptr; +} + +} // end of anonymous namespace + +namespace sdr::contact { + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfE3d::impCreateWithGivenPrimitive3DContainer( + const drawinglayer::primitive3d::Primitive3DContainer& rxContent3D) const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + if(!rxContent3D.empty()) + { + // try to get the outmost ViewObjectContactOfE3dScene for this single 3d object, + // the ones on the way there are grouping scenes. Collect the in-between scene's + // transformations to build a correct object transformation for the embedded + // object + basegfx::B3DHomMatrix aInBetweenObjectTransform; + const ViewContactOfE3dScene* pVCOfE3DScene = tryToFindVCOfE3DScene(*this, aInBetweenObjectTransform); + + if(pVCOfE3DScene) + { + basegfx::B3DVector aLightNormal; + const double fShadowSlant(pVCOfE3DScene->getSdrSceneAttribute().getShadowSlant()); + const basegfx::B3DRange& rAllContentRange = pVCOfE3DScene->getAllContentRange3D(); + drawinglayer::geometry::ViewInformation3D aViewInformation3D(pVCOfE3DScene->getViewInformation3D()); + + if(!pVCOfE3DScene->getSdrLightingAttribute().getLightVector().empty()) + { + // get light normal from first light and normalize + aLightNormal = pVCOfE3DScene->getSdrLightingAttribute().getLightVector()[0].getDirection(); + aLightNormal.normalize(); + } + + if(!aInBetweenObjectTransform.isIdentity()) + { + // if aInBetweenObjectTransform is used, create combined ViewInformation3D which + // contains the correct object transformation for the embedded 3d object + aViewInformation3D = drawinglayer::geometry::ViewInformation3D( + aViewInformation3D.getObjectTransformation() * aInBetweenObjectTransform, + aViewInformation3D.getOrientation(), + aViewInformation3D.getProjection(), + aViewInformation3D.getDeviceToView(), + aViewInformation3D.getViewTime(), + aViewInformation3D.getExtendedInformationSequence()); + } + + // create embedded 2d primitive and add. LightNormal and ShadowSlant are needed for evtl. + // 3D shadow extraction for correct B2DRange calculation (shadow is part of the object) + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::Embedded3DPrimitive2D( + rxContent3D, + pVCOfE3DScene->getObjectTransformation(), + aViewInformation3D, + aLightNormal, + fShadowSlant, + rAllContentRange)); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + } + + return xRetval; +} + +ViewContactOfE3d::ViewContactOfE3d(E3dObject& rSdrObject) +: ViewContactOfSdrObj(rSdrObject) +{ +} + +ViewContactOfE3d::~ViewContactOfE3d() +{ +} + +drawinglayer::primitive3d::Primitive3DContainer const & ViewContactOfE3d::getVIP3DSWithoutObjectTransform() const +{ + // local up-to-date checks. Create new list and compare. + drawinglayer::primitive3d::Primitive3DContainer xNew(createViewIndependentPrimitive3DContainer()); + + if(mxViewIndependentPrimitive3DContainer != xNew) + { + // has changed, copy content + const_cast< ViewContactOfE3d* >(this)->mxViewIndependentPrimitive3DContainer = xNew; + } + + // return current Primitive2DContainer + return mxViewIndependentPrimitive3DContainer; +} + +drawinglayer::primitive3d::Primitive3DContainer ViewContactOfE3d::getViewIndependentPrimitive3DContainer() const +{ + // get sequence without object transform + drawinglayer::primitive3d::Primitive3DContainer xRetval(getVIP3DSWithoutObjectTransform()); + + if(!xRetval.empty()) + { + // add object transform if it's used + const basegfx::B3DHomMatrix& rObjectTransform(GetE3dObject().GetTransform()); + + if(!rObjectTransform.isIdentity()) + { + const drawinglayer::primitive3d::Primitive3DReference xReference( + new drawinglayer::primitive3d::TransformPrimitive3D( + rObjectTransform, + xRetval)); + + xRetval = { xReference }; + } + } + + // return current Primitive2DContainer + return xRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfE3d::createViewIndependentPrimitive2DSequence() const +{ + // also need to create a 2D embedding when the view-independent part is requested, + // see view-dependent part in ViewObjectContactOfE3d::createPrimitive2DSequence + // get 3d primitive vector, isPrimitiveVisible() is done in 3d creator + return impCreateWithGivenPrimitive3DContainer(getViewIndependentPrimitive3DContainer()); +} + +ViewObjectContact& ViewContactOfE3d::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfE3d(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContactOfE3d::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofe3dcube.cxx b/svx/source/sdr/contact/viewcontactofe3dcube.cxx new file mode 100644 index 000000000..00e990f57 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofe3dcube.cxx @@ -0,0 +1,89 @@ +/* -*- 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 <sdr/contact/viewcontactofe3dcube.hxx> +#include <svx/cube3d.hxx> +#include <drawinglayer/primitive3d/sdrcubeprimitive3d.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive3d/sdrattributecreator3d.hxx> +#include <basegfx/range/b3drange.hxx> +#include <memory> + + +namespace sdr::contact +{ + ViewContactOfE3dCube::ViewContactOfE3dCube(E3dCubeObj& rCubeObj) + : ViewContactOfE3d(rCubeObj) + { + } + + ViewContactOfE3dCube::~ViewContactOfE3dCube() + { + } + + drawinglayer::primitive3d::Primitive3DContainer ViewContactOfE3dCube::createViewIndependentPrimitive3DContainer() const + { + drawinglayer::primitive3d::Primitive3DContainer xRetval; + const SfxItemSet& rItemSet = GetE3dCubeObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillShadowAttribute3D aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillShadowAttribute(rItemSet, false)); + + // get cube geometry and use as translation and scaling for unit cube + basegfx::B3DRange aCubeRange; + const basegfx::B3DVector aCubeSize(GetE3dCubeObj().GetCubeSize()); + const basegfx::B3DPoint aCubePosition(GetE3dCubeObj().GetCubePos()); + basegfx::B3DHomMatrix aWorldTransform; + + if(GetE3dCubeObj().GetPosIsCenter()) + { + const basegfx::B3DVector aHalfCubeSize(aCubeSize / 2.0); + aCubeRange.expand(aCubePosition - aHalfCubeSize); + aCubeRange.expand(aCubePosition + aHalfCubeSize); + } + else + { + aCubeRange.expand(aCubePosition); + aCubeRange.expand(aCubePosition + aCubeSize); + } + + // add scale and translate to world transformation + const basegfx::B3DVector abjectRange(aCubeRange.getRange()); + aWorldTransform.scale(abjectRange.getX(), abjectRange.getY(), abjectRange.getZ()); + aWorldTransform.translate(aCubeRange.getMinX(), aCubeRange.getMinY(), aCubeRange.getMinZ()); + + // get 3D Object Attributes + std::unique_ptr<drawinglayer::attribute::Sdr3DObjectAttribute> pSdr3DObjectAttribute(drawinglayer::primitive2d::createNewSdr3DObjectAttribute(rItemSet)); + + // calculate texture size to get a perfect mapping for + // the front/back sides + const basegfx::B2DVector aTextureSize(aCubeSize.getX(), aCubeSize.getY()); + + // create primitive and add + const drawinglayer::primitive3d::Primitive3DReference xReference( + new drawinglayer::primitive3d::SdrCubePrimitive3D( + aWorldTransform, aTextureSize, aAttribute, *pSdr3DObjectAttribute)); + xRetval = { xReference }; + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofe3dextrude.cxx b/svx/source/sdr/contact/viewcontactofe3dextrude.cxx new file mode 100644 index 000000000..d510f9803 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofe3dextrude.cxx @@ -0,0 +1,84 @@ +/* -*- 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 <sdr/contact/viewcontactofe3dextrude.hxx> +#include <extrud3d.hxx> +#include <drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive3d/sdrattributecreator3d.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include <memory> + + +namespace sdr::contact +{ + ViewContactOfE3dExtrude::ViewContactOfE3dExtrude(E3dExtrudeObj& rExtrude) + : ViewContactOfE3d(rExtrude) + { + } + + ViewContactOfE3dExtrude::~ViewContactOfE3dExtrude() + { + } + + drawinglayer::primitive3d::Primitive3DContainer ViewContactOfE3dExtrude::createViewIndependentPrimitive3DContainer() const + { + drawinglayer::primitive3d::Primitive3DContainer xRetval; + const SfxItemSet& rItemSet = GetE3dExtrudeObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillShadowAttribute3D aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillShadowAttribute(rItemSet, false)); + + // get extrude geometry + const basegfx::B2DPolyPolygon aPolyPolygon(GetE3dExtrudeObj().GetExtrudePolygon()); + + // get 3D Object Attributes + std::unique_ptr<drawinglayer::attribute::Sdr3DObjectAttribute> pSdr3DObjectAttribute(drawinglayer::primitive2d::createNewSdr3DObjectAttribute(rItemSet)); + + // calculate texture size; use size of top/bottom cap to get a perfect mapping + // for the caps. The in-between geometry will get a stretched size with a + // relative factor size of caps to extrude depth + const basegfx::B2DRange aRange(basegfx::utils::getRange(aPolyPolygon)); + const basegfx::B2DVector aTextureSize(aRange.getWidth(), aRange.getHeight()); + + // get more data + const double fDepth(static_cast<double>(GetE3dExtrudeObj().GetExtrudeDepth())); + const double fDiagonal(static_cast<double>(GetE3dExtrudeObj().GetPercentDiagonal()) / 100.0); + const double fBackScale(static_cast<double>(GetE3dExtrudeObj().GetPercentBackScale()) / 100.0); + const bool bSmoothNormals(GetE3dExtrudeObj().GetSmoothNormals()); // Plane itself + const bool bSmoothLids(GetE3dExtrudeObj().GetSmoothLids()); // Front/back + const bool bCharacterMode(GetE3dExtrudeObj().GetCharacterMode()); + const bool bCloseFront(GetE3dExtrudeObj().GetCloseFront()); + const bool bCloseBack(GetE3dExtrudeObj().GetCloseBack()); + + // create primitive and add + const basegfx::B3DHomMatrix aWorldTransform; + const drawinglayer::primitive3d::Primitive3DReference xReference( + new drawinglayer::primitive3d::SdrExtrudePrimitive3D( + aWorldTransform, aTextureSize, aAttribute, *pSdr3DObjectAttribute, + aPolyPolygon, fDepth, fDiagonal, fBackScale, bSmoothNormals, bSmoothLids, + bCharacterMode, bCloseFront, bCloseBack)); + xRetval = { xReference }; + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofe3dlathe.cxx b/svx/source/sdr/contact/viewcontactofe3dlathe.cxx new file mode 100644 index 000000000..c76cae4df --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofe3dlathe.cxx @@ -0,0 +1,97 @@ +/* -*- 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 <sdr/contact/viewcontactofe3dlathe.hxx> +#include <svx/lathe3d.hxx> +#include <drawinglayer/primitive3d/sdrlatheprimitive3d.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive3d/sdrattributecreator3d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <memory> + + +namespace sdr::contact +{ + ViewContactOfE3dLathe::ViewContactOfE3dLathe(E3dLatheObj& rLathe) + : ViewContactOfE3d(rLathe) + { + } + + ViewContactOfE3dLathe::~ViewContactOfE3dLathe() + { + } + + drawinglayer::primitive3d::Primitive3DContainer ViewContactOfE3dLathe::createViewIndependentPrimitive3DContainer() const + { + drawinglayer::primitive3d::Primitive3DContainer xRetval; + const SfxItemSet& rItemSet = GetE3dLatheObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillShadowAttribute3D aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillShadowAttribute(rItemSet, false)); + + // get extrude geometry + const basegfx::B2DPolyPolygon aPolyPolygon(GetE3dLatheObj().GetPolyPoly2D()); + + // get 3D Object Attributes + std::unique_ptr<drawinglayer::attribute::Sdr3DObjectAttribute> pSdr3DObjectAttribute(drawinglayer::primitive2d::createNewSdr3DObjectAttribute(rItemSet)); + + // calculate texture size. Use the polygon length of the longest polygon for + // height and the rotated radius for width (using polygon center) to get a good + // texture mapping + double fPolygonMaxLength(0.0); + + for(auto const& rCandidate : aPolyPolygon) + { + const double fPolygonLength(basegfx::utils::getLength(rCandidate)); + fPolygonMaxLength = std::max(fPolygonMaxLength, fPolygonLength); + } + + const basegfx::B2DRange aPolyPolygonRange(basegfx::utils::getRange(aPolyPolygon)); + const basegfx::B2DVector aTextureSize( + F_PI * fabs(aPolyPolygonRange.getCenter().getX()), // PI * d + fPolygonMaxLength); + + // get more data + const sal_uInt32 nHorizontalSegments(GetE3dLatheObj().GetHorizontalSegments()); + const sal_uInt32 nVerticalSegments(GetE3dLatheObj().GetVerticalSegments()); + const double fDiagonal(static_cast<double>(GetE3dLatheObj().GetPercentDiagonal()) / 100.0); + const double fBackScale(static_cast<double>(GetE3dLatheObj().GetBackScale()) / 100.0); + const double fRotation((static_cast<double>(GetE3dLatheObj().GetEndAngle()) / 1800.0) * F_PI); + const bool bSmoothNormals(GetE3dLatheObj().GetSmoothNormals()); // Plane itself + const bool bSmoothLids(GetE3dLatheObj().GetSmoothLids()); // Front/back + const bool bCharacterMode(GetE3dLatheObj().GetCharacterMode()); + const bool bCloseFront(GetE3dLatheObj().GetCloseFront()); + const bool bCloseBack(GetE3dLatheObj().GetCloseBack()); + + // create primitive and add + const basegfx::B3DHomMatrix aWorldTransform; + const drawinglayer::primitive3d::Primitive3DReference xReference( + new drawinglayer::primitive3d::SdrLathePrimitive3D( + aWorldTransform, aTextureSize, aAttribute, *pSdr3DObjectAttribute, + aPolyPolygon, nHorizontalSegments, nVerticalSegments, + fDiagonal, fBackScale, fRotation, + bSmoothNormals, bSmoothLids, bCharacterMode, bCloseFront, bCloseBack)); + xRetval = { xReference }; + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofe3dpolygon.cxx b/svx/source/sdr/contact/viewcontactofe3dpolygon.cxx new file mode 100644 index 000000000..ec8a4be00 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofe3dpolygon.cxx @@ -0,0 +1,170 @@ +/* -*- 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 <sdr/contact/viewcontactofe3dpolygon.hxx> +#include <polygn3d.hxx> +#include <drawinglayer/primitive3d/sdrpolypolygonprimitive3d.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive3d/sdrattributecreator3d.hxx> +#include <basegfx/polygon/b3dpolygon.hxx> +#include <basegfx/polygon/b3dpolypolygontools.hxx> +#include <memory> + + +namespace sdr::contact +{ + ViewContactOfE3dPolygon::ViewContactOfE3dPolygon(E3dPolygonObj& rPolygon) + : ViewContactOfE3d(rPolygon) + { + } + + ViewContactOfE3dPolygon::~ViewContactOfE3dPolygon() + { + } + + drawinglayer::primitive3d::Primitive3DContainer ViewContactOfE3dPolygon::createViewIndependentPrimitive3DContainer() const + { + drawinglayer::primitive3d::Primitive3DContainer xRetval; + const SfxItemSet& rItemSet = GetE3dPolygonObj().GetMergedItemSet(); + const bool bSuppressFill(GetE3dPolygonObj().GetLineOnly()); + const drawinglayer::attribute::SdrLineFillShadowAttribute3D aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillShadowAttribute(rItemSet, bSuppressFill)); + + // get extrude geometry + basegfx::B3DPolyPolygon aPolyPolygon3D(GetE3dPolygonObj().GetPolyPolygon3D()); + const basegfx::B3DPolyPolygon aPolyNormals3D(GetE3dPolygonObj().GetPolyNormals3D()); + const basegfx::B2DPolyPolygon aPolyTexture2D(GetE3dPolygonObj().GetPolyTexture2D()); + const bool bNormals(aPolyNormals3D.count() && aPolyNormals3D.count() == aPolyPolygon3D.count()); + const bool bTexture(aPolyTexture2D.count() && aPolyTexture2D.count() == aPolyPolygon3D.count()); + + if(bNormals || bTexture) + { + for(sal_uInt32 a(0); a < aPolyPolygon3D.count(); a++) + { + basegfx::B3DPolygon aCandidate3D(aPolyPolygon3D.getB3DPolygon(a)); + basegfx::B3DPolygon aNormals3D; + basegfx::B2DPolygon aTexture2D; + + if(bNormals) + { + aNormals3D = aPolyNormals3D.getB3DPolygon(a); + } + + if(bTexture) + { + aTexture2D = aPolyTexture2D.getB2DPolygon(a); + } + + for(sal_uInt32 b(0); b < aCandidate3D.count(); b++) + { + if(bNormals) + { + sal_uInt32 nNormalCount = aNormals3D.count(); + if( b < nNormalCount ) + aCandidate3D.setNormal(b, aNormals3D.getB3DPoint(b)); + else if( nNormalCount > 0 ) + aCandidate3D.setNormal(b, aNormals3D.getB3DPoint(0)); + } + if(bTexture) + { + sal_uInt32 nTextureCount = aTexture2D.count(); + if( b < nTextureCount ) + aCandidate3D.setTextureCoordinate(b, aTexture2D.getB2DPoint(b)); + else if( nTextureCount > 0 ) + aCandidate3D.setTextureCoordinate(b, aTexture2D.getB2DPoint(0)); + } + } + + aPolyPolygon3D.setB3DPolygon(a, aCandidate3D); + } + } + + // get 3D Object Attributes + std::unique_ptr<drawinglayer::attribute::Sdr3DObjectAttribute> pSdr3DObjectAttribute(drawinglayer::primitive2d::createNewSdr3DObjectAttribute(rItemSet)); + + // calculate texture size + basegfx::B2DVector aTextureSize(1.0, 1.0); + + if(bTexture) + { + // #i98314# + // create texture size from object's size + const basegfx::B3DRange aObjectRange(basegfx::utils::getRange(aPolyPolygon3D)); + + double fWidth(0.0); + double fHeight(0.0); + + // this is a polygon object, so Width/Height and/or Depth may be zero (e.g. left + // wall of chart). Take this into account + if(basegfx::fTools::equalZero(aObjectRange.getWidth())) + { + // width is zero, use height and depth + fWidth = aObjectRange.getHeight(); + fHeight = aObjectRange.getDepth(); + } + else if(basegfx::fTools::equalZero(aObjectRange.getHeight())) + { + // height is zero, use width and depth + fWidth = aObjectRange.getWidth(); + fHeight = aObjectRange.getDepth(); + } + else + { + // use width and height + fWidth = aObjectRange.getWidth(); + fHeight = aObjectRange.getHeight(); + } + + if(basegfx::fTools::lessOrEqual(fWidth, 0.0) ||basegfx::fTools::lessOrEqual(fHeight, 0.0)) + { + // no texture; fallback to very small size + aTextureSize.setX(0.01); + aTextureSize.setY(0.01); + } + else + { + aTextureSize.setX(fWidth); + aTextureSize.setY(fHeight); + } + } + + // #i98295# + // unfortunately, this SdrObject type which allows a free 3d geometry definition was defined + // wrong topologically in relation to its plane normal and 3D visibility when it was invented + // a long time ago. Since the API allows creation of this SDrObject type, it is not possible to + // simply change this definition. Only the chart should use it, and at least this object type + // only exists at Runtime (is not saved and/or loaded in any FileFormat). Still someone external + // may have used it in its API. To not risk wrong 3D lightings, I have to switch the orientation + // of the polygon here + aPolyPolygon3D.flip(); + + // create primitive and add + const basegfx::B3DHomMatrix aWorldTransform; + const drawinglayer::primitive3d::Primitive3DReference xReference( + new drawinglayer::primitive3d::SdrPolyPolygonPrimitive3D( + aPolyPolygon3D, aWorldTransform, aTextureSize, aAttribute, *pSdr3DObjectAttribute)); + xRetval = { xReference }; + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofe3dscene.cxx b/svx/source/sdr/contact/viewcontactofe3dscene.cxx new file mode 100644 index 000000000..284cf3f64 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofe3dscene.cxx @@ -0,0 +1,454 @@ +/* -*- 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 <svx/sdr/contact/viewcontactofe3dscene.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/contact/viewobjectcontactofe3dscene.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <basegfx/range/b3drange.hxx> +#include <drawinglayer/primitive3d/baseprimitive3d.hxx> +#include <sdr/contact/viewcontactofe3d.hxx> +#include <drawinglayer/primitive2d/sceneprimitive2d.hxx> +#include <drawinglayer/primitive3d/transformprimitive3d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> + +using namespace com::sun::star; + +namespace { + +// pActiveVC is only true if ghosted is still activated and maybe needs to be switched off in this path +void createSubPrimitive3DVector( + const sdr::contact::ViewContact& rCandidate, + drawinglayer::primitive3d::Primitive3DContainer& o_rAllTarget, + drawinglayer::primitive3d::Primitive3DContainer* o_pVisibleTarget, + const SdrLayerIDSet* pVisibleSdrLayerIDSet, + const bool bTestSelectedVisibility) +{ + const sdr::contact::ViewContactOfE3dScene* pViewContactOfE3dScene = dynamic_cast< const sdr::contact::ViewContactOfE3dScene* >(&rCandidate); + + if(pViewContactOfE3dScene) + { + const sal_uInt32 nChildrenCount(rCandidate.GetObjectCount()); + + if(nChildrenCount) + { + // provide new collection sequences + drawinglayer::primitive3d::Primitive3DContainer aNewAllTarget; + drawinglayer::primitive3d::Primitive3DContainer aNewVisibleTarget; + + // add children recursively + for(sal_uInt32 a(0); a < nChildrenCount; a++) + { + createSubPrimitive3DVector( + rCandidate.GetViewContact(a), + aNewAllTarget, + o_pVisibleTarget ? &aNewVisibleTarget : nullptr, + pVisibleSdrLayerIDSet, + bTestSelectedVisibility); + } + + // create transform primitive for the created content combining content and transformtion + const drawinglayer::primitive3d::Primitive3DReference xReference(new drawinglayer::primitive3d::TransformPrimitive3D( + pViewContactOfE3dScene->GetE3dScene().GetTransform(), + aNewAllTarget)); + + // add created content to all target + o_rAllTarget.push_back(xReference); + + // add created content to visible target if exists + if(o_pVisibleTarget) + { + o_pVisibleTarget->push_back(xReference); + } + } + } + else + { + // access view independent representation of rCandidate + const sdr::contact::ViewContactOfE3d* pViewContactOfE3d = dynamic_cast< const sdr::contact::ViewContactOfE3d* >(&rCandidate); + + if(pViewContactOfE3d) + { + drawinglayer::primitive3d::Primitive3DContainer xPrimitive3DSeq(pViewContactOfE3d->getViewIndependentPrimitive3DContainer()); + + if(!xPrimitive3DSeq.empty()) + { + // add to all target vector + o_rAllTarget.append(xPrimitive3DSeq); + + if(o_pVisibleTarget) + { + // test visibility. Primitive is visible when both tests are true (AND) + bool bVisible(true); + + if(pVisibleSdrLayerIDSet) + { + // test layer visibility + const E3dObject& rE3dObject = pViewContactOfE3d->GetE3dObject(); + const SdrLayerID aLayerID(rE3dObject.GetLayer()); + + bVisible = pVisibleSdrLayerIDSet->IsSet(aLayerID); + } + + if(bVisible && bTestSelectedVisibility) + { + // test selected visibility (see 3D View's DrawMarkedObj implementation) + const E3dObject& rE3dObject = pViewContactOfE3d->GetE3dObject(); + + bVisible = rE3dObject.GetSelected(); + } + + if (bVisible) + { + // add to visible target vector + o_pVisibleTarget->append(xPrimitive3DSeq); + } + } + } + } + } +} + +} + +namespace sdr::contact { + +// Create an Object-Specific ViewObjectContact, set ViewContact and +// ObjectContact. Always needs to return something. +ViewObjectContact& ViewContactOfE3dScene::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfE3dScene(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContactOfE3dScene::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +ViewContactOfE3dScene::ViewContactOfE3dScene(E3dScene& rScene) +: ViewContactOfSdrObj(rScene), + maViewInformation3D(), + maObjectTransformation(), + maSdrSceneAttribute(), + maSdrLightingAttribute() +{ +} + +void ViewContactOfE3dScene::createViewInformation3D(const basegfx::B3DRange& rContentRange) +{ + basegfx::B3DHomMatrix aTransformation; + basegfx::B3DHomMatrix aOrientation; + basegfx::B3DHomMatrix aProjection; + basegfx::B3DHomMatrix aDeviceToView; + + // create transformation (scene as group's transformation) + // For historical reasons, the outmost scene's transformation is handles as part of the + // view transformation. This means that the BoundRect of the contained 3D Objects is + // without that transformation and makes it necessary to NOT add the first scene to the + // Primitive3DContainer of contained objects. + { + aTransformation = GetE3dScene().GetTransform(); + } + + // create orientation (world to camera coordinate system) + { + // calculate orientation from VRP, VPN and VUV + const B3dCamera& rSceneCamera = GetE3dScene().GetCameraSet(); + const basegfx::B3DPoint& aVRP(rSceneCamera.GetVRP()); + const basegfx::B3DVector& aVPN(rSceneCamera.GetVPN()); + const basegfx::B3DVector& aVUV(rSceneCamera.GetVUV()); + + aOrientation.orientation(aVRP, aVPN, aVUV); + } + + // create projection (camera coordinate system to relative 2d where X,Y and Z are [0.0 .. 1.0]) + { + const basegfx::B3DHomMatrix aWorldToCamera(aOrientation * aTransformation); + basegfx::B3DRange aCameraRange(rContentRange); + aCameraRange.transform(aWorldToCamera); + + // remember Z-Values, but change orientation + const double fMinZ(-aCameraRange.getMaxZ()); + const double fMaxZ(-aCameraRange.getMinZ()); + + // construct temporary matrix from world to device. Use unit values here to measure expansion + basegfx::B3DHomMatrix aWorldToDevice(aWorldToCamera); + const drawinglayer::attribute::SdrSceneAttribute& rSdrSceneAttribute = getSdrSceneAttribute(); + + if(css::drawing::ProjectionMode_PERSPECTIVE == rSdrSceneAttribute.getProjectionMode()) + { + aWorldToDevice.frustum(-1.0, 1.0, -1.0, 1.0, fMinZ, fMaxZ); + } + else + { + aWorldToDevice.ortho(-1.0, 1.0, -1.0, 1.0, fMinZ, fMaxZ); + } + + // create B3DRange in device. This will create the real used ranges + // in camera space. Do not use the Z-Values, though. + basegfx::B3DRange aDeviceRange(rContentRange); + aDeviceRange.transform(aWorldToDevice); + + // set projection + if(css::drawing::ProjectionMode_PERSPECTIVE == rSdrSceneAttribute.getProjectionMode()) + { + aProjection.frustum( + aDeviceRange.getMinX(), aDeviceRange.getMaxX(), + aDeviceRange.getMinY(), aDeviceRange.getMaxY(), + fMinZ, fMaxZ); + } + else + { + aProjection.ortho( + aDeviceRange.getMinX(), aDeviceRange.getMaxX(), + aDeviceRange.getMinY(), aDeviceRange.getMaxY(), + fMinZ, fMaxZ); + } + } + + // create device to view transform + { + // create standard deviceToView projection for geometry + // input is [-1.0 .. 1.0] in X,Y and Z. bring to [0.0 .. 1.0]. Also + // necessary to flip Y due to screen orientation + // Z is not needed, but will also be brought to [0.0 .. 1.0] + aDeviceToView.scale(0.5, -0.5, 0.5); + aDeviceToView.translate(0.5, 0.5, 0.5); + } + + const uno::Sequence< beans::PropertyValue > aEmptyProperties; + maViewInformation3D = drawinglayer::geometry::ViewInformation3D( + aTransformation, aOrientation, aProjection, + aDeviceToView, 0.0, aEmptyProperties); +} + +void ViewContactOfE3dScene::createObjectTransformation() +{ + // create 2d Object Transformation from relative point in 2d scene to world + const tools::Rectangle aRectangle(GetE3dScene().GetSnapRect()); + + maObjectTransformation.set(0, 0, aRectangle.getWidth()); + maObjectTransformation.set(1, 1, aRectangle.getHeight()); + maObjectTransformation.set(0, 2, aRectangle.Left()); + maObjectTransformation.set(1, 2, aRectangle.Top()); +} + +void ViewContactOfE3dScene::createSdrSceneAttribute() +{ + const SfxItemSet& rItemSet = GetE3dScene().GetMergedItemSet(); + maSdrSceneAttribute = drawinglayer::primitive2d::createNewSdrSceneAttribute(rItemSet); +} + +void ViewContactOfE3dScene::createSdrLightingAttribute() +{ + const SfxItemSet& rItemSet = GetE3dScene().GetMergedItemSet(); + maSdrLightingAttribute = drawinglayer::primitive2d::createNewSdrLightingAttribute(rItemSet); +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfE3dScene::createScenePrimitive2DSequence( + const SdrLayerIDSet* pLayerVisibility) const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const sal_uInt32 nChildrenCount(GetObjectCount()); + + if(nChildrenCount) + { + // create 3d scene primitive with visible content tested against rLayerVisibility + drawinglayer::primitive3d::Primitive3DContainer aAllSequence; + drawinglayer::primitive3d::Primitive3DContainer aVisibleSequence; + const bool bTestLayerVisibility(nullptr != pLayerVisibility); + const bool bTestSelectedVisibility(GetE3dScene().GetDrawOnlySelected()); + const bool bTestVisibility(bTestLayerVisibility || bTestSelectedVisibility); + + // add children recursively. Do NOT start with (*this), this would create + // a 3D transformPrimitive for the start scene. While this is theoretically not + // a bad thing, for historical reasons the transformation of the outmost scene + // is seen as part of the ViewTransformation (see text in createViewInformation3D) + for(sal_uInt32 a(0); a < nChildrenCount; a++) + { + createSubPrimitive3DVector( + GetViewContact(a), + aAllSequence, + bTestLayerVisibility ? &aVisibleSequence : nullptr, + bTestLayerVisibility ? pLayerVisibility : nullptr, + bTestSelectedVisibility); + } + + const size_t nAllSize(!aAllSequence.empty() ? aAllSequence.size() : 0); + const size_t nVisibleSize(!aVisibleSequence.empty() ? aVisibleSequence.size() : 0); + + if((bTestVisibility && nVisibleSize) || nAllSize) + { + // for getting the 3D range using getB3DRangeFromPrimitive3DContainer a ViewInformation3D + // needs to be given for evtl. decompositions. At the same time createViewInformation3D + // currently is based on creating the target-ViewInformation3D using a given range. To + // get the true range, use a neutral ViewInformation3D here. This leaves all matrices + // on identity and the time on 0.0. + const uno::Sequence< beans::PropertyValue > aEmptyProperties; + const drawinglayer::geometry::ViewInformation3D aNeutralViewInformation3D(aEmptyProperties); + const basegfx::B3DRange aContentRange(aAllSequence.getB3DRange(aNeutralViewInformation3D)); + + // create 2d primitive 3dscene with generated sub-list from collector + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::ScenePrimitive2D( + bTestVisibility ? aVisibleSequence : aAllSequence, + getSdrSceneAttribute(), + getSdrLightingAttribute(), + getObjectTransformation(), + getViewInformation3D(aContentRange))); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer{ xReference }; + } + } + + // always append an invisible outline for the cases where no visible content exists + xRetval.push_back( + drawinglayer::primitive2d::createHiddenGeometryPrimitives2D( + getObjectTransformation())); + + return xRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfE3dScene::createViewIndependentPrimitive2DSequence() const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + if(GetObjectCount()) + { + // create a default ScenePrimitive2D (without visibility test of members) + xRetval = createScenePrimitive2DSequence(nullptr); + } + + return xRetval; +} + +void ViewContactOfE3dScene::ActionChanged() +{ + // call parent + ViewContactOfSdrObj::ActionChanged(); + + // mark locally cached values as invalid + maViewInformation3D = drawinglayer::geometry::ViewInformation3D(); + maObjectTransformation.identity(); + maSdrSceneAttribute = drawinglayer::attribute::SdrSceneAttribute(); + maSdrLightingAttribute = drawinglayer::attribute::SdrLightingAttribute(); +} + +const drawinglayer::geometry::ViewInformation3D& ViewContactOfE3dScene::getViewInformation3D() const +{ + if(maViewInformation3D.isDefault()) + { + // this version will create the content range on demand locally and thus is less + // performant than the other one. Since the information is buffered the planned + // behaviour is that the version with the given range is used initially. + basegfx::B3DRange aContentRange(getAllContentRange3D()); + + if(aContentRange.isEmpty()) + { + // empty scene, no 3d action should be necessary. Prepare some + // fallback size + OSL_FAIL("No need to get ViewInformation3D from an empty scene (!)"); + aContentRange.expand(basegfx::B3DPoint(-100.0, -100.0, -100.0)); + aContentRange.expand(basegfx::B3DPoint( 100.0, 100.0, 100.0)); + } + + const_cast < ViewContactOfE3dScene* >(this)->createViewInformation3D(aContentRange); + } + + return maViewInformation3D; +} + +const drawinglayer::geometry::ViewInformation3D& ViewContactOfE3dScene::getViewInformation3D(const basegfx::B3DRange& rContentRange) const +{ + if(maViewInformation3D.isDefault()) + { + const_cast < ViewContactOfE3dScene* >(this)->createViewInformation3D(rContentRange); + } + + return maViewInformation3D; +} + +const basegfx::B2DHomMatrix& ViewContactOfE3dScene::getObjectTransformation() const +{ + if(maObjectTransformation.isIdentity()) + { + const_cast < ViewContactOfE3dScene* >(this)->createObjectTransformation(); + } + + return maObjectTransformation; +} + +const drawinglayer::attribute::SdrSceneAttribute& ViewContactOfE3dScene::getSdrSceneAttribute() const +{ + if(maSdrSceneAttribute.isDefault()) + { + const_cast < ViewContactOfE3dScene* >(this)->createSdrSceneAttribute(); + } + + return maSdrSceneAttribute; +} + +const drawinglayer::attribute::SdrLightingAttribute& ViewContactOfE3dScene::getSdrLightingAttribute() const +{ + if(maSdrLightingAttribute.isDefault()) + { + const_cast < ViewContactOfE3dScene* >(this)->createSdrLightingAttribute(); + } + + return maSdrLightingAttribute; +} + +drawinglayer::primitive3d::Primitive3DContainer ViewContactOfE3dScene::getAllPrimitive3DContainer() const +{ + drawinglayer::primitive3d::Primitive3DContainer aAllPrimitive3DContainer; + const sal_uInt32 nChildrenCount(GetObjectCount()); + + // add children recursively. Do NOT start with (*this), this would create + // a 3D transformPrimitive for the start scene. While this is theoretically not + // a bad thing, for historical reasons the transformation of the outmost scene + // is seen as part of the ViewTransformation (see text in createViewInformation3D) + for(sal_uInt32 a(0); a < nChildrenCount; a++) + { + createSubPrimitive3DVector(GetViewContact(a), aAllPrimitive3DContainer, nullptr, nullptr, false); + } + + return aAllPrimitive3DContainer; +} + +basegfx::B3DRange ViewContactOfE3dScene::getAllContentRange3D() const +{ + const drawinglayer::primitive3d::Primitive3DContainer xAllSequence(getAllPrimitive3DContainer()); + basegfx::B3DRange aAllContentRange3D; + + if(!xAllSequence.empty()) + { + // for getting the 3D range using getB3DRangeFromPrimitive3DContainer a ViewInformation3D + // needs to be given for evtl. decompositions. Use a neutral ViewInformation3D here. This + // leaves all matrices on identity and the time on 0.0. + const uno::Sequence< beans::PropertyValue > aEmptyProperties; + const drawinglayer::geometry::ViewInformation3D aNeutralViewInformation3D(aEmptyProperties); + + aAllContentRange3D = xAllSequence.getB3DRange(aNeutralViewInformation3D); + } + + return aAllContentRange3D; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofe3dsphere.cxx b/svx/source/sdr/contact/viewcontactofe3dsphere.cxx new file mode 100644 index 000000000..c34e09856 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofe3dsphere.cxx @@ -0,0 +1,81 @@ +/* -*- 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 <sdr/contact/viewcontactofe3dsphere.hxx> +#include <svx/sphere3d.hxx> +#include <drawinglayer/primitive3d/sdrsphereprimitive3d.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive3d/sdrattributecreator3d.hxx> +#include <memory> + + +namespace sdr::contact +{ + ViewContactOfE3dSphere::ViewContactOfE3dSphere(E3dSphereObj& rSphere) + : ViewContactOfE3d(rSphere) + { + } + + ViewContactOfE3dSphere::~ViewContactOfE3dSphere() + { + } + + drawinglayer::primitive3d::Primitive3DContainer ViewContactOfE3dSphere::createViewIndependentPrimitive3DContainer() const + { + drawinglayer::primitive3d::Primitive3DContainer xRetval; + const SfxItemSet& rItemSet = GetE3dSphereObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillShadowAttribute3D aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillShadowAttribute(rItemSet, false)); + + // get sphere center and size for geometry + const basegfx::B3DPoint aSpherePosition(GetE3dSphereObj().Center()); + const basegfx::B3DVector aSphereSize(GetE3dSphereObj().Size()); + basegfx::B3DHomMatrix aWorldTransform; + + aWorldTransform.translate(-0.5, -0.5, -0.5); + aWorldTransform.scale(aSphereSize.getX(), aSphereSize.getY(), aSphereSize.getZ()); + aWorldTransform.translate(aSpherePosition.getX(), aSpherePosition.getY(), aSpherePosition.getZ()); + + // get 3D Object Attributes + std::unique_ptr<drawinglayer::attribute::Sdr3DObjectAttribute> pSdr3DObjectAttribute(drawinglayer::primitive2d::createNewSdr3DObjectAttribute(rItemSet)); + + // get segment count + const sal_uInt32 nHorizontalSegments(GetE3dSphereObj().GetHorizontalSegments()); + const sal_uInt32 nVerticalSegments(GetE3dSphereObj().GetVerticalSegments()); + + // calculate texture size, use radii for (2 * PI * r) to get a perfect + // mapping on the sphere + const basegfx::B2DVector aTextureSize( + F_PI * ((aSphereSize.getX() + aSphereSize.getZ()) / 2.0), // PI * d + F_PI2 * aSphereSize.getY()); // half outline, (PI * d)/2 -> PI/2 * d + + // create primitive and add + const drawinglayer::primitive3d::Primitive3DReference xReference( + new drawinglayer::primitive3d::SdrSpherePrimitive3D( + aWorldTransform, aTextureSize, aAttribute, *pSdr3DObjectAttribute, + nHorizontalSegments, nVerticalSegments)); + xRetval = { xReference }; + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofgraphic.cxx b/svx/source/sdr/contact/viewcontactofgraphic.cxx new file mode 100644 index 000000000..8fceef864 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofgraphic.cxx @@ -0,0 +1,412 @@ +/* -*- 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 <sdr/contact/viewcontactofgraphic.hxx> +#include <sdr/contact/viewobjectcontactofgraphic.hxx> +#include <svx/svdograf.hxx> +#include <sdgtritm.hxx> +#include <svx/sdgluitm.hxx> +#include <sdgcoitm.hxx> +#include <svx/sdggaitm.hxx> +#include <sdginitm.hxx> +#include <svx/sdgmoitm.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <svl/itemset.hxx> +#include <tools/debug.hxx> + +#include <svx/sdgcpitm.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <sdr/primitive2d/sdrgrafprimitive2d.hxx> +#include <vcl/canvastools.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx> +#include <sdr/primitive2d/sdrtextprimitive2d.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/colritem.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> +#include <toolkit/helper/vclunohelper.hxx> + +#include <bitmaps.hlst> + +namespace sdr::contact +{ + // Create an Object-Specific ViewObjectContact, set ViewContact and + // ObjectContact. Always needs to return something. + ViewObjectContact& ViewContactOfGraphic::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) + { + ViewObjectContact* pRetval = new ViewObjectContactOfGraphic(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; + } + + ViewContactOfGraphic::ViewContactOfGraphic(SdrGrafObj& rGrafObj) + : ViewContactOfTextObj(rGrafObj) + { + } + + ViewContactOfGraphic::~ViewContactOfGraphic() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfGraphic::createVIP2DSForPresObj( + const basegfx::B2DHomMatrix& rObjectMatrix, + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute& rAttribute) const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + GraphicObject aEmptyGraphicObject; + GraphicAttr aEmptyGraphicAttr; + + // SdrGrafPrimitive2D without content in original size which carries all eventual attributes and texts + const drawinglayer::primitive2d::Primitive2DReference xReferenceA(new drawinglayer::primitive2d::SdrGrafPrimitive2D( + rObjectMatrix, + rAttribute, + aEmptyGraphicObject, + aEmptyGraphicAttr)); + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReferenceA }; + + // SdrGrafPrimitive2D with content (which is the preview graphic) scaled to smaller size and + // without attributes + basegfx::B2DHomMatrix aSmallerMatrix; + + // #i94431# for some reason, i forgot to take the PrefMapMode of the graphic + // into account. Since EmptyPresObj's are only used in Draw/Impress, it is + // safe to assume 100th mm as target. + Size aPrefSize(GetGrafObject().GetGrafPrefSize()); + + if(MapUnit::MapPixel == GetGrafObject().GetGrafPrefMapMode().GetMapUnit()) + { + aPrefSize = Application::GetDefaultDevice()->PixelToLogic(aPrefSize, MapMode(MapUnit::Map100thMM)); + } + else + { + aPrefSize = OutputDevice::LogicToLogic(aPrefSize, GetGrafObject().GetGrafPrefMapMode(), MapMode(MapUnit::Map100thMM)); + } + + // decompose object matrix to get single values + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + const double fOffsetX((aScale.getX() - aPrefSize.getWidth()) / 2.0); + const double fOffsetY((aScale.getY() - aPrefSize.getHeight()) / 2.0); + + if(basegfx::fTools::moreOrEqual(fOffsetX, 0.0) && basegfx::fTools::moreOrEqual(fOffsetY, 0.0)) + { + // create the EmptyPresObj fallback visualisation. The fallback graphic + // is already provided in rGraphicObject in this case, use it + aSmallerMatrix = basegfx::utils::createScaleTranslateB2DHomMatrix(aPrefSize.getWidth(), aPrefSize.getHeight(), fOffsetX, fOffsetY); + aSmallerMatrix = basegfx::utils::createShearXRotateTranslateB2DHomMatrix(fShearX, fRotate, aTranslate) + * aSmallerMatrix; + + const GraphicObject& rGraphicObject = GetGrafObject().GetGraphicObject(); + const GraphicAttr aLocalGrafInfo; + const drawinglayer::primitive2d::Primitive2DReference xReferenceB(new drawinglayer::primitive2d::SdrGrafPrimitive2D( + aSmallerMatrix, + drawinglayer::attribute::SdrLineFillEffectsTextAttribute(), + rGraphicObject, + aLocalGrafInfo)); + + xRetval.push_back(xReferenceB); + } + + return xRetval; + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfGraphic::createVIP2DSForDraft( + const basegfx::B2DHomMatrix& rObjectMatrix, + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute& rAttribute) const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + GraphicObject aEmptyGraphicObject; + GraphicAttr aEmptyGraphicAttr; + + // SdrGrafPrimitive2D without content in original size which carries all eventual attributes and texts + const drawinglayer::primitive2d::Primitive2DReference xReferenceA(new drawinglayer::primitive2d::SdrGrafPrimitive2D( + rObjectMatrix, + rAttribute, + aEmptyGraphicObject, + aEmptyGraphicAttr)); + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReferenceA }; + + if(rAttribute.getLine().isDefault()) + { + // create a surrounding frame when no linestyle given + const Color aColor(Application::GetSettings().GetStyleSettings().GetShadowColor()); + const basegfx::BColor aBColor(aColor.getBColor()); + basegfx::B2DPolygon aOutline(basegfx::utils::createUnitPolygon()); + aOutline.transform(rObjectMatrix); + + xRetval.push_back( + drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D( + aOutline, + aBColor))); + } + + // decompose object matrix to get single values + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + // define a distance value, used for distance from bitmap to borders and from bitmap + // to text, too (2 mm) + const double fDistance(200.0); + + // consume borders from values + aScale.setX(std::max(0.0, aScale.getX() - (2.0 * fDistance))); + aScale.setY(std::max(0.0, aScale.getY() - (2.0 * fDistance))); + aTranslate.setX(aTranslate.getX() + fDistance); + aTranslate.setY(aTranslate.getY() + fDistance); + + // draw a draft bitmap + const BitmapEx aDraftBitmap(BMAP_GrafikEi); + + if(!aDraftBitmap.IsEmpty()) + { + Size aPrefSize(aDraftBitmap.GetPrefSize()); + + if(MapUnit::MapPixel == aDraftBitmap.GetPrefMapMode().GetMapUnit()) + { + aPrefSize = Application::GetDefaultDevice()->PixelToLogic(aDraftBitmap.GetSizePixel(), MapMode(MapUnit::Map100thMM)); + } + else + { + aPrefSize = OutputDevice::LogicToLogic(aPrefSize, aDraftBitmap.GetPrefMapMode(), MapMode(MapUnit::Map100thMM)); + } + + const double fBitmapScaling(2.0); + const double fWidth(aPrefSize.getWidth() * fBitmapScaling); + const double fHeight(aPrefSize.getHeight() * fBitmapScaling); + + if(basegfx::fTools::more(fWidth, 1.0) + && basegfx::fTools::more(fHeight, 1.0) + && basegfx::fTools::lessOrEqual(fWidth, aScale.getX()) + && basegfx::fTools::lessOrEqual(fHeight, aScale.getY())) + { + const basegfx::B2DHomMatrix aBitmapMatrix(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + fWidth, fHeight, fShearX, fRotate, aTranslate.getX(), aTranslate.getY())); + + xRetval.push_back( + drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::BitmapPrimitive2D( + VCLUnoHelper::CreateVCLXBitmap(aDraftBitmap), + aBitmapMatrix))); + + // consume bitmap size in X + aScale.setX(std::max(0.0, aScale.getX() - (fWidth + fDistance))); + aTranslate.setX(aTranslate.getX() + fWidth + fDistance); + } + } + + // Build the text for the draft object + OUString aDraftText = GetGrafObject().GetFileName(); + + if (aDraftText.isEmpty()) + { + aDraftText = GetGrafObject().GetName() + " ..."; + } + + if (!aDraftText.isEmpty()) + { + // #i103255# Goal is to produce TextPrimitives which hold the given text as + // BlockText in the available space. It would be very tricky to do + // an own word wrap/line layout here. + // Using SdrBlockTextPrimitive2D OTOH is critical since it internally + // uses the SdrObject it references. To solve this, create a temp + // SdrObject with Attributes and Text, generate a SdrBlockTextPrimitive2D + // directly and immediately decompose it. After that, it is no longer + // needed and can be deleted. + + // create temp RectObj as TextObj and set needed attributes + SdrRectObj* pRectObj(new SdrRectObj(GetGrafObject().getSdrModelFromSdrObject(), OBJ_TEXT)); + pRectObj->NbcSetText(aDraftText); + pRectObj->SetMergedItem(SvxColorItem(COL_LIGHTRED, EE_CHAR_COLOR)); + + // get SdrText and OPO + SdrText* pSdrText(pRectObj->getText(0)); + OutlinerParaObject* pOPO(pRectObj->GetOutlinerParaObject()); + + if(pSdrText && pOPO) + { + // directly use the remaining space as TextRangeTransform + const basegfx::B2DHomMatrix aTextRangeTransform(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aScale, fShearX, fRotate, aTranslate)); + + // directly create temp SdrBlockTextPrimitive2D + rtl::Reference< drawinglayer::primitive2d::SdrBlockTextPrimitive2D > xBlockTextPrimitive(new drawinglayer::primitive2d::SdrBlockTextPrimitive2D( + pSdrText, + *pOPO, + aTextRangeTransform, + SDRTEXTHORZADJUST_LEFT, + SDRTEXTVERTADJUST_TOP, + false, + false, + false, + false)); + + // decompose immediately with neutral ViewInformation. This will + // layout the text to more simple TextPrimitives from drawinglayer + const drawinglayer::geometry::ViewInformation2D aViewInformation2D; + xBlockTextPrimitive->get2DDecomposition(xRetval, aViewInformation2D); + } + + // always use SdrObject::Free(...) for SdrObjects (!) + SdrObject* pTemp(pRectObj); + SdrObject::Free(pTemp); + } + + return xRetval; + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfGraphic::createViewIndependentPrimitive2DSequence() const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SfxItemSet& rItemSet = GetGrafObject().GetMergedItemSet(); + + // create and fill GraphicAttr + GraphicAttr aLocalGrafInfo; + const sal_uInt16 nTrans(rItemSet.Get(SDRATTR_GRAFTRANSPARENCE).GetValue()); + const SdrGrafCropItem& rCrop(rItemSet.Get(SDRATTR_GRAFCROP)); + aLocalGrafInfo.SetLuminance(rItemSet.Get(SDRATTR_GRAFLUMINANCE).GetValue()); + aLocalGrafInfo.SetContrast(rItemSet.Get(SDRATTR_GRAFCONTRAST).GetValue()); + aLocalGrafInfo.SetChannelR(rItemSet.Get(SDRATTR_GRAFRED).GetValue()); + aLocalGrafInfo.SetChannelG(rItemSet.Get(SDRATTR_GRAFGREEN).GetValue()); + aLocalGrafInfo.SetChannelB(rItemSet.Get(SDRATTR_GRAFBLUE).GetValue()); + aLocalGrafInfo.SetGamma(rItemSet.Get(SDRATTR_GRAFGAMMA).GetValue() * 0.01); + aLocalGrafInfo.SetTransparency(static_cast<sal_uInt8>(::basegfx::fround(std::min(nTrans, sal_uInt16(100)) * 2.55))); + aLocalGrafInfo.SetInvert(rItemSet.Get(SDRATTR_GRAFINVERT).GetValue()); + aLocalGrafInfo.SetDrawMode(rItemSet.Get(SDRATTR_GRAFMODE).GetValue()); + aLocalGrafInfo.SetCrop(rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom()); + + // we have content if graphic is not completely transparent + const bool bHasContent(255L != aLocalGrafInfo.GetTransparency()); + drawinglayer::attribute::SdrLineFillEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillEffectsTextAttribute( + rItemSet, + GetGrafObject().getText(0), + bHasContent)); + + // take unrotated snap rect for position and size. Directly use model data, not getBoundRect() or getSnapRect() + // which will use the primitive data we just create in the near future + const ::basegfx::B2DRange aObjectRange = vcl::unotools::b2DRectangleFromRectangle(GetGrafObject().GetGeoRect()); + + // look for mirroring + const GeoStat& rGeoStat(GetGrafObject().GetGeoStat()); + const sal_Int32 nRotationAngle(rGeoStat.nRotationAngle); + const bool bRota180(18000 == nRotationAngle); + const bool bMirrored(GetGrafObject().IsMirrored()); + const sal_uInt16 nMirrorCase(bRota180 ? (bMirrored ? 3 : 4) : (bMirrored ? 2 : 1)); + bool bHMirr((2 == nMirrorCase ) || (4 == nMirrorCase)); + bool bVMirr((3 == nMirrorCase ) || (4 == nMirrorCase)); + + // set mirror flags at LocalGrafInfo. Take into account that the geometry in + // aObjectRange is already changed and rotated when bRota180 is used. To rebuild + // that old behaviour (as long as part of the model data), correct the H/V flags + // accordingly. The created bitmapPrimitive WILL use the rotation, too. + if(bRota180) + { + // if bRota180 which is used for vertical mirroring, the graphic will already be rotated + // by 180 degrees. To correct, switch off VMirror and invert HMirroring. + bHMirr = !bHMirr; + bVMirr = false; + } + + if(bHMirr || bVMirr) + { + aLocalGrafInfo.SetMirrorFlags((bHMirr ? BmpMirrorFlags::Horizontal : BmpMirrorFlags::NONE)|(bVMirr ? BmpMirrorFlags::Vertical : BmpMirrorFlags::NONE)); + } + + // fill object matrix + const double fShearX(rGeoStat.nShearAngle ? tan((36000 - rGeoStat.nShearAngle) * F_PI18000) : 0.0); + const double fRotate(nRotationAngle ? (36000 - nRotationAngle) * F_PI18000 : 0.0); + const basegfx::B2DHomMatrix aObjectMatrix(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aObjectRange.getWidth(), aObjectRange.getHeight(), + fShearX, fRotate, + aObjectRange.getMinX(), aObjectRange.getMinY())); + + // get the current, unchanged graphic object from SdrGrafObj + const GraphicObject& rGraphicObject = GetGrafObject().GetGraphicObject(); + + if(visualisationUsesPresObj()) + { + // it's an EmptyPresObj, create the SdrGrafPrimitive2D without content and another scaled one + // with the content which is the placeholder graphic + xRetval = createVIP2DSForPresObj(aObjectMatrix, aAttribute); + } +#ifndef IOS // Enforce swap-in for tiled rendering for now, while we have no delayed updating mechanism + else if(visualisationUsesDraft()) + { + // #i102380# The graphic is swapped out. To not force a swap-in here, there is a mechanism + // which shows a swapped-out-visualisation (which gets created here now) and an asynchronous + // visual update mechanism for swapped-out graphics when they were loaded (see AsynchGraphicLoadingEvent + // and ViewObjectContactOfGraphic implementation). Not forcing the swap-in here allows faster + // (non-blocking) processing here and thus in the effect e.g. fast scrolling through pages + xRetval = createVIP2DSForDraft(aObjectMatrix, aAttribute); + } +#endif + else + { + // create primitive. Info: Calling the copy-constructor of GraphicObject in this + // SdrGrafPrimitive2D constructor will force a full swap-in of the graphic + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrGrafPrimitive2D( + aObjectMatrix, + aAttribute, + rGraphicObject, + aLocalGrafInfo)); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + + // always append an invisible outline for the cases where no visible content exists + xRetval.push_back( + drawinglayer::primitive2d::createHiddenGeometryPrimitives2D( + aObjectMatrix)); + + return xRetval; + } + + bool ViewContactOfGraphic::visualisationUsesPresObj() const + { + return GetGrafObject().IsEmptyPresObj(); + } + + bool ViewContactOfGraphic::visualisationUsesDraft() const + { + // no draft when already PresObj + if(visualisationUsesPresObj()) + return false; + + // draft when swapped out + const GraphicObject& rGraphicObject = GetGrafObject().GetGraphicObject(); + + // draft when no graphic + return GraphicType::NONE == rGraphicObject.GetType() || GraphicType::Default == rGraphicObject.GetType(); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofgroup.cxx b/svx/source/sdr/contact/viewcontactofgroup.cxx new file mode 100644 index 000000000..6a98565c0 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofgroup.cxx @@ -0,0 +1,83 @@ +/* -*- 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 <sdr/contact/viewcontactofgroup.hxx> +#include <svx/svdogrp.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <sdr/contact/viewobjectcontactofgroup.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> +#include <tools/debug.hxx> +#include <vcl/canvastools.hxx> + + +namespace sdr::contact +{ + // Create an Object-Specific ViewObjectContact, set ViewContact and + // ObjectContact. Always needs to return something. + ViewObjectContact& ViewContactOfGroup::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) + { + ViewObjectContact* pRetval = new ViewObjectContactOfGroup(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContactOfGroup::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; + } + + ViewContactOfGroup::ViewContactOfGroup(SdrObjGroup& rGroup) + : ViewContactOfSdrObj(rGroup) + { + } + + ViewContactOfGroup::~ViewContactOfGroup() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfGroup::createViewIndependentPrimitive2DSequence() const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const sal_uInt32 nObjectCount(GetObjectCount()); + + if(nObjectCount) + { + // collect all sub-primitives + for(sal_uInt32 a(0); a < nObjectCount; a++) + { + const ViewContact& rCandidate(GetViewContact(a)); + const drawinglayer::primitive2d::Primitive2DContainer& aCandSeq(rCandidate.getViewIndependentPrimitive2DContainer()); + + xRetval.insert(xRetval.end(), aCandSeq.begin(), aCandSeq.end()); + } + } + else + { + // append an invisible outline for the cases where no visible content exists + const basegfx::B2DRange aCurrentRange = vcl::unotools::b2DRectangleFromRectangle(GetSdrObjGroup().GetLastBoundRect()); + + const drawinglayer::primitive2d::Primitive2DReference xReference( + drawinglayer::primitive2d::createHiddenGeometryPrimitives2D( + false, aCurrentRange)); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofmasterpagedescriptor.cxx b/svx/source/sdr/contact/viewcontactofmasterpagedescriptor.cxx new file mode 100644 index 000000000..ab26e2d2d --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofmasterpagedescriptor.cxx @@ -0,0 +1,102 @@ +/* -*- 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 <sdr/contact/viewcontactofmasterpagedescriptor.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdobj.hxx> +#include <sdr/contact/viewobjectcontactofmasterpagedescriptor.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <drawinglayer/attribute/sdrfillattribute.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/attribute/fillgradientattribute.hxx> + + +namespace sdr::contact +{ + ViewObjectContact& ViewContactOfMasterPageDescriptor::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) + { + return *(new ViewObjectContactOfMasterPageDescriptor(rObjectContact, *this)); + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfMasterPageDescriptor::createViewIndependentPrimitive2DSequence() const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + drawinglayer::attribute::SdrFillAttribute aFill; + const SdrPageProperties* pCorrectProperties = GetMasterPageDescriptor().getCorrectSdrPageProperties(); + + if(pCorrectProperties) + { + // create page fill attributes when correct properties were identified + aFill = drawinglayer::primitive2d::createNewSdrFillAttribute(pCorrectProperties->GetItemSet()); + } + + if(!aFill.isDefault()) + { + // direct model data is the page size, get and use it + const SdrPage& rOwnerPage = GetMasterPageDescriptor().GetOwnerPage(); + const basegfx::B2DRange aInnerRange( + rOwnerPage.GetLeftBorder(), rOwnerPage.GetUpperBorder(), + rOwnerPage.GetWidth() - rOwnerPage.GetRightBorder(), + rOwnerPage.GetHeight() - rOwnerPage.GetLowerBorder()); + const basegfx::B2DPolygon aInnerPolgon(basegfx::utils::createPolygonFromRect(aInnerRange)); + const drawinglayer::primitive2d::Primitive2DReference xReference( + drawinglayer::primitive2d::createPolyPolygonFillPrimitive( + basegfx::B2DPolyPolygon(aInnerPolgon), + aFill, + drawinglayer::attribute::FillGradientAttribute())); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer{ xReference }; + } + + return xRetval; + } + + // basic constructor + ViewContactOfMasterPageDescriptor::ViewContactOfMasterPageDescriptor(sdr::MasterPageDescriptor& rDescriptor) + : ViewContact(), + mrMasterPageDescriptor(rDescriptor) + { + } + + // The destructor. + ViewContactOfMasterPageDescriptor::~ViewContactOfMasterPageDescriptor() + { + } + + sal_uInt32 ViewContactOfMasterPageDescriptor::GetObjectCount() const + { + return GetMasterPageDescriptor().GetUsedPage().GetObjCount(); + } + + ViewContact& ViewContactOfMasterPageDescriptor::GetViewContact(sal_uInt32 nIndex) const + { + return GetMasterPageDescriptor().GetUsedPage().GetObj(nIndex)->GetViewContact(); + } + + ViewContact* ViewContactOfMasterPageDescriptor::GetParentContact() const + { + return &(GetMasterPageDescriptor().GetOwnerPage().GetViewContact()); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofpageobj.cxx b/svx/source/sdr/contact/viewcontactofpageobj.cxx new file mode 100644 index 000000000..83da800b2 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofpageobj.cxx @@ -0,0 +1,79 @@ +/* -*- 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 <sdr/contact/viewcontactofpageobj.hxx> +#include <svx/svdopage.hxx> +#include <vcl/canvastools.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <sdr/contact/viewobjectcontactofpageobj.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> + +namespace sdr::contact { + +ViewObjectContact& ViewContactOfPageObj::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfPageObj(rObjectContact, *this); + return *pRetval; +} + +ViewContactOfPageObj::ViewContactOfPageObj(SdrPageObj& rPageObj) +: ViewContactOfSdrObj(rPageObj) +{ +} + +ViewContactOfPageObj::~ViewContactOfPageObj() +{ +} + +// #i35972# React on changes of the object of this ViewContact +void ViewContactOfPageObj::ActionChanged() +{ + static bool bIsInActionChange(false); + + if(!bIsInActionChange) + { + // set recursion flag, see description in *.hxx + bIsInActionChange = true; + + // call parent + ViewContactOfSdrObj::ActionChanged(); + + // reset recursion flag, see description in *.hxx + bIsInActionChange = false; + } +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfPageObj::createViewIndependentPrimitive2DSequence() const +{ + // create graphical visualisation data. Since this is the view-independent version which should not be used, + // create a replacement graphic visualisation here. Use GetLastBoundRect to access the model data directly + // which is aOutRect for SdrPageObj. + const tools::Rectangle aModelRectangle(GetPageObj().GetLastBoundRect()); + const basegfx::B2DRange aModelRange = vcl::unotools::b2DRectangleFromRectangle(aModelRectangle); + const basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromRect(aModelRange)); + const basegfx::BColor aYellow(1.0, 1.0, 0.0); + const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aOutline, aYellow)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrcaptionobj.cxx b/svx/source/sdr/contact/viewcontactofsdrcaptionobj.cxx new file mode 100644 index 000000000..4b0f06a77 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrcaptionobj.cxx @@ -0,0 +1,196 @@ +/* -*- 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 <sdr/contact/viewcontactofsdrcaptionobj.hxx> +#include <svx/svdocapt.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive2d/sdrcaptionprimitive2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> + + +// includes for special text box shadow (SC) + +#include <svl/itemset.hxx> +#include <svx/xhatch.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xflclit.hxx> +#include <svx/xfltrit.hxx> +#include <svx/xlineit0.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/sdprcitm.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <basegfx/polygon/b2dpolygonclipper.hxx> +#include <vcl/canvastools.hxx> + +using namespace com::sun::star; + +namespace sdr::contact +{ + ViewContactOfSdrCaptionObj::ViewContactOfSdrCaptionObj(SdrCaptionObj& rCaptionObj) + : ViewContactOfSdrRectObj(rCaptionObj) + { + } + + ViewContactOfSdrCaptionObj::~ViewContactOfSdrCaptionObj() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrCaptionObj::createViewIndependentPrimitive2DSequence() const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SdrCaptionObj& rCaptionObj(static_cast<const SdrCaptionObj&>(GetSdrObject())); + const SfxItemSet& rItemSet = rCaptionObj.GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillEffectsTextAttribute( + rItemSet, + rCaptionObj.getText(0), + false)); + + // take unrotated snap rect (direct model data) for position and size + const tools::Rectangle aRectangle(rCaptionObj.GetGeoRect()); + const ::basegfx::B2DRange aObjectRange = vcl::unotools::b2DRectangleFromRectangle(aRectangle); + const GeoStat& rGeoStat(rCaptionObj.GetGeoStat()); + + // fill object matrix + basegfx::B2DHomMatrix aObjectMatrix(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aObjectRange.getWidth(), aObjectRange.getHeight(), + rGeoStat.nShearAngle ? tan((36000 - rGeoStat.nShearAngle) * F_PI18000) : 0.0, + rGeoStat.nRotationAngle ? (36000 - rGeoStat.nRotationAngle) * F_PI18000 : 0.0, + aObjectRange.getMinX(), aObjectRange.getMinY())); + + // calculate corner radius + double fCornerRadiusX; + double fCornerRadiusY; + drawinglayer::primitive2d::calculateRelativeCornerRadius( + rCaptionObj.GetEckenradius(), aObjectRange, fCornerRadiusX, fCornerRadiusY); + const basegfx::B2DPolygon aTail(rCaptionObj.getTailPolygon()); + + // create primitive. Always create one (even if invisible) to let the decomposition + // of SdrCaptionPrimitive2D create needed invisible elements for HitTest and BoundRect + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrCaptionPrimitive2D( + aObjectMatrix, + aAttribute, + aTail, + fCornerRadiusX, + fCornerRadiusY)); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + + if(!aAttribute.isDefault() && rCaptionObj.GetSpecialTextBoxShadow()) + { + // for SC, the caption object may have a specialized shadow. The usual object shadow is off + // and a specialized shadow gets created here (see old paint) + const XColorItem& rShadColItem = rItemSet.Get(SDRATTR_SHADOWCOLOR); + const sal_uInt16 nShadowTransparence(rItemSet.Get(SDRATTR_SHADOWTRANSPARENCE).GetValue()); + const Color aShadowColor(rShadColItem.GetColorValue()); + const drawing::FillStyle eShadowStyle = rItemSet.Get(XATTR_FILLSTYLE).GetValue(); + + // Create own ItemSet and modify as needed + // Always hide lines for special calc shadow + SfxItemSet aSet(rItemSet); + aSet.Put(XLineStyleItem(drawing::LineStyle_NONE)); + + if(drawing::FillStyle_HATCH == eShadowStyle) + { + // #41666# Hatch color is set hard to shadow color + XHatch aHatch = rItemSet.Get(XATTR_FILLHATCH).GetHatchValue(); + aHatch.SetColor(aShadowColor); + aSet.Put(XFillHatchItem(OUString(),aHatch)); + } + else + { + if(drawing::FillStyle_SOLID != eShadowStyle) + { + // force fill to solid (for Gradient, Bitmap and *no* fill (#119750# not filled comments *have* shadow)) + aSet.Put(XFillStyleItem(drawing::FillStyle_SOLID)); + } + + aSet.Put(XFillColorItem(OUString(),aShadowColor)); + aSet.Put(XFillTransparenceItem(nShadowTransparence)); + } + + // create FillAttribute from modified ItemSet + const drawinglayer::attribute::SdrFillAttribute aFill( + drawinglayer::primitive2d::createNewSdrFillAttribute(aSet)); + drawinglayer::primitive2d::Primitive2DReference xSpecialShadow; + + if(!aFill.isDefault() && 1.0 != aFill.getTransparence()) + { + // add shadow offset to object matrix + const sal_uInt32 nXDist(rItemSet.Get(SDRATTR_SHADOWXDIST).GetValue()); + const sal_uInt32 nYDist(rItemSet.Get(SDRATTR_SHADOWYDIST).GetValue()); + + if(nXDist || nYDist) + { + // #119750# create object and shadow outline, clip shadow outline + // on object outline. If there is a rest, create shadow. Do this to + // emulate that shadow is *not* visible behind the object for + // transparent object fill for comments in excel + basegfx::B2DPolygon aObjectOutline( + basegfx::utils::createPolygonFromRect( + basegfx::B2DRange(0.0, 0.0, 1.0, 1.0), + fCornerRadiusX, + fCornerRadiusY)); + aObjectOutline.transform(aObjectMatrix); + + // create shadow outline + basegfx::B2DPolygon aShadowOutline(aObjectOutline); + aShadowOutline.transform( + basegfx::utils::createTranslateB2DHomMatrix(nXDist, nYDist)); + + // clip shadow outline against object outline + const basegfx::B2DPolyPolygon aClippedShadow( + basegfx::utils::clipPolygonOnPolyPolygon( + aShadowOutline, + basegfx::B2DPolyPolygon(aObjectOutline), + false, // take the outside + false)); + + if(aClippedShadow.count()) + { + // if there is shadow, create the specialized shadow primitive + xSpecialShadow = drawinglayer::primitive2d::createPolyPolygonFillPrimitive( + aClippedShadow, + aFill, + drawinglayer::attribute::FillGradientAttribute()); + } + } + } + + if(xSpecialShadow.is()) + { + // if we really got a special shadow, create a two-element retval with the shadow + // behind the standard object's geometry + xRetval.resize(2); + + xRetval[0] = xSpecialShadow; + xRetval[1] = xReference; + } + } + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrcircobj.cxx b/svx/source/sdr/contact/viewcontactofsdrcircobj.cxx new file mode 100644 index 000000000..6379c9609 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrcircobj.cxx @@ -0,0 +1,102 @@ +/* -*- 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 <sdr/contact/viewcontactofsdrcircobj.hxx> +#include <svx/svdocirc.hxx> +#include <svx/sdangitm.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive2d/sdrellipseprimitive2d.hxx> +#include <svl/itemset.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <vcl/canvastools.hxx> + + +namespace sdr::contact +{ + ViewContactOfSdrCircObj::ViewContactOfSdrCircObj(SdrCircObj& rCircObj) + : ViewContactOfSdrRectObj(rCircObj) + { + } + + ViewContactOfSdrCircObj::~ViewContactOfSdrCircObj() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrCircObj::createViewIndependentPrimitive2DSequence() const + { + const SfxItemSet& rItemSet = GetCircObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillEffectsTextAttribute( + rItemSet, + GetCircObj().getText(0), + false)); + + // take unrotated snap rect (direct model data) for position and size + const basegfx::B2DRange aObjectRange = vcl::unotools::b2DRectangleFromRectangle(GetCircObj().GetGeoRect()); + const GeoStat& rGeoStat(GetCircObj().GetGeoStat()); + + // fill object matrix + const basegfx::B2DHomMatrix aObjectMatrix( + basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aObjectRange.getWidth(), aObjectRange.getHeight(), + rGeoStat.nShearAngle ? tan((36000 - rGeoStat.nShearAngle) * F_PI18000) : 0.0, + rGeoStat.nRotationAngle ? (36000 - rGeoStat.nRotationAngle) * F_PI18000 : 0.0, + aObjectRange.getMinX(), aObjectRange.getMinY())); + + // create primitive data + const sal_uInt16 nIdentifier(GetCircObj().GetObjIdentifier()); + + // always create primitives to allow the decomposition of SdrEllipsePrimitive2D + // or SdrEllipseSegmentPrimitive2D to create needed invisible elements for HitTest + // and/or BoundRect + if(OBJ_CIRC == nIdentifier) + { + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrEllipsePrimitive2D( + aObjectMatrix, + aAttribute)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + else + { + const sal_Int32 nNewStart(rItemSet.Get(SDRATTR_CIRCSTARTANGLE).GetValue()); + const sal_Int32 nNewEnd(rItemSet.Get(SDRATTR_CIRCENDANGLE).GetValue()); + const double fStart(((36000 - nNewEnd) % 36000) * F_PI18000); + const double fEnd(((36000 - nNewStart) % 36000) * F_PI18000); + const bool bCloseSegment(OBJ_CARC != nIdentifier); + const bool bCloseUsingCenter(OBJ_SECT == nIdentifier); + + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrEllipseSegmentPrimitive2D( + aObjectMatrix, + aAttribute, + fStart, + fEnd, + bCloseSegment, + bCloseUsingCenter)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdredgeobj.cxx b/svx/source/sdr/contact/viewcontactofsdredgeobj.cxx new file mode 100644 index 000000000..e27bf663f --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdredgeobj.cxx @@ -0,0 +1,65 @@ +/* -*- 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 <sdr/contact/viewcontactofsdredgeobj.hxx> +#include <svx/svdoedge.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive2d/sdrconnectorprimitive2d.hxx> + + +namespace sdr::contact +{ + ViewContactOfSdrEdgeObj::ViewContactOfSdrEdgeObj(SdrEdgeObj& rEdgeObj) + : ViewContactOfTextObj(rEdgeObj) + { + } + + ViewContactOfSdrEdgeObj::~ViewContactOfSdrEdgeObj() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrEdgeObj::createViewIndependentPrimitive2DSequence() const + { + const basegfx::B2DPolygon aEdgeTrack(GetEdgeObj().getEdgeTrack()); + + // what to do when no EdgeTrack is provided (HitTest and selectability) ? + OSL_ENSURE(0 != aEdgeTrack.count(), "Connectors with no geometry are not allowed (!)"); + + // ckeck attributes + const SfxItemSet& rItemSet = GetEdgeObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineEffectsTextAttribute( + rItemSet, + GetEdgeObj().getText(0))); + + // create primitive. Always create primitives to allow the decomposition of + // SdrConnectorPrimitive2D to create needed invisible elements for HitTest + // and/or BoundRect + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrConnectorPrimitive2D( + aAttribute, + aEdgeTrack)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrmeasureobj.cxx b/svx/source/sdr/contact/viewcontactofsdrmeasureobj.cxx new file mode 100644 index 000000000..4676a6b72 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrmeasureobj.cxx @@ -0,0 +1,127 @@ +/* -*- 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 <sdr/contact/viewcontactofsdrmeasureobj.hxx> +#include <svx/svdomeas.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <svl/itemset.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/sxmbritm.hxx> +#include <svx/sxmtritm.hxx> +#include <sxmtaitm.hxx> +#include <sdr/primitive2d/sdrmeasureprimitive2d.hxx> +#include <svx/sxmtpitm.hxx> + + +namespace sdr::contact +{ + ViewContactOfSdrMeasureObj::ViewContactOfSdrMeasureObj(SdrMeasureObj& rMeasureObj) + : ViewContactOfTextObj(rMeasureObj) + { + } + + ViewContactOfSdrMeasureObj::~ViewContactOfSdrMeasureObj() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrMeasureObj::createViewIndependentPrimitive2DSequence() const + { + const SfxItemSet& rItemSet = GetMeasureObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineEffectsTextAttribute( + rItemSet, + GetMeasureObj().getText(0))); + + // take properties which are the model data. + const ::basegfx::B2DPoint aStart(GetMeasureObj().GetPoint(0).X(), GetMeasureObj().GetPoint(0).Y()); + const ::basegfx::B2DPoint aEnd(GetMeasureObj().GetPoint(1).X(), GetMeasureObj().GetPoint(1).Y()); + const double fDistance(rItemSet.Get(SDRATTR_MEASURELINEDIST).GetValue()); + const double fUpperDistance(rItemSet.Get(SDRATTR_MEASUREHELPLINEOVERHANG).GetValue()); + const double fLowerDistance(rItemSet.Get(SDRATTR_MEASUREHELPLINEDIST).GetValue()); + const double fLeftDelta(rItemSet.Get(SDRATTR_MEASUREHELPLINE1LEN).GetValue()); + const double fRightDelta(rItemSet.Get(SDRATTR_MEASUREHELPLINE2LEN).GetValue()); + const bool bBelow(rItemSet.Get(SDRATTR_MEASUREBELOWREFEDGE).GetValue()); + const bool bTextRotation(rItemSet.Get(SDRATTR_MEASURETEXTROTA90).GetValue()); + const bool bTextAutoAngle(rItemSet.Get(SDRATTR_MEASURETEXTAUTOANGLE).GetValue()); + drawinglayer::primitive2d::MeasureTextPosition aMTPHor(drawinglayer::primitive2d::MEASURETEXTPOSITION_AUTOMATIC); + drawinglayer::primitive2d::MeasureTextPosition aMTPVer(drawinglayer::primitive2d::MEASURETEXTPOSITION_AUTOMATIC); + + switch(rItemSet.Get(SDRATTR_MEASURETEXTHPOS).GetValue()) + { + case css::drawing::MeasureTextHorzPos::MeasureTextHorzPos_LEFTOUTSIDE: + { + aMTPHor = drawinglayer::primitive2d::MEASURETEXTPOSITION_NEGATIVE; + break; + } + case css::drawing::MeasureTextHorzPos::MeasureTextHorzPos_INSIDE: + { + aMTPHor = drawinglayer::primitive2d::MEASURETEXTPOSITION_CENTERED; + break; + } + case css::drawing::MeasureTextHorzPos::MeasureTextHorzPos_RIGHTOUTSIDE: + { + aMTPHor = drawinglayer::primitive2d::MEASURETEXTPOSITION_POSITIVE; + break; + } + default: // css::drawing::MeasureTextHorzPos::MeasureTextHorzPos_AUTO + { + break; + } + } + + switch(rItemSet.Get(SDRATTR_MEASURETEXTVPOS).GetValue()) + { + case css::drawing::MeasureTextVertPos_EAST: + { + aMTPVer = drawinglayer::primitive2d::MEASURETEXTPOSITION_NEGATIVE; + break; + } + case css::drawing::MeasureTextVertPos_CENTERED: + { + aMTPVer = drawinglayer::primitive2d::MEASURETEXTPOSITION_CENTERED; + break; + } + case css::drawing::MeasureTextVertPos_WEST: + { + aMTPVer = drawinglayer::primitive2d::MEASURETEXTPOSITION_POSITIVE; + break; + } + default : // css::drawing::MeasureTextVertPos_AUTO + { + break; + } + } + + // create primitive with the model data. Always create primitives to allow the + // decomposition of SdrMeasurePrimitive2D to create needed invisible elements for HitTest + // and/or BoundRect + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrMeasurePrimitive2D( + aAttribute, aStart, aEnd, + aMTPHor, aMTPVer, fDistance, + fUpperDistance, fLowerDistance, + fLeftDelta, fRightDelta, bBelow, + bTextRotation, bTextAutoAngle)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrmediaobj.cxx b/svx/source/sdr/contact/viewcontactofsdrmediaobj.cxx new file mode 100644 index 000000000..f836d4329 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrmediaobj.cxx @@ -0,0 +1,129 @@ +/* -*- 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 <svx/sdr/contact/viewcontactofsdrmediaobj.hxx> +#include <svx/svdomedia.hxx> +#include <sdr/contact/viewobjectcontactofsdrmediaobj.hxx> +#include <drawinglayer/primitive2d/mediaprimitive2d.hxx> +#include <vcl/canvastools.hxx> + +namespace sdr::contact { + +ViewContactOfSdrMediaObj::ViewContactOfSdrMediaObj( SdrMediaObj& rMediaObj ) : + ViewContactOfSdrObj( rMediaObj ) +{ +} + +ViewContactOfSdrMediaObj::~ViewContactOfSdrMediaObj() +{ +} + +ViewObjectContact& ViewContactOfSdrMediaObj::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + return *( new ViewObjectContactOfSdrMediaObj( rObjectContact, *this, static_cast< SdrMediaObj& >( GetSdrObject() ).getMediaProperties() ) ); +} + +Size ViewContactOfSdrMediaObj::getPreferredSize() const +{ + // #i71805# Since we may have a whole bunch of VOCs here, make a loop + // return first useful size -> the size from the first which is visualized as a window + const sal_uInt32 nCount(getViewObjectContactCount()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + ViewObjectContact* pCandidate = getViewObjectContact(a); + Size aSize(pCandidate ? static_cast< ViewObjectContactOfSdrMediaObj* >(pCandidate)->getPreferredSize() : Size()); + + if(0 != aSize.getWidth() || 0 != aSize.getHeight()) + { + return aSize; + } + } + + return Size(); +} + +void ViewContactOfSdrMediaObj::updateMediaItem( ::avmedia::MediaItem& rItem ) const +{ + // #i71805# Since we may have a whole bunch of VOCs here, make a loop + const sal_uInt32 nCount(getViewObjectContactCount()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + ViewObjectContact* pCandidate = getViewObjectContact(a); + + if(pCandidate) + { + static_cast< ViewObjectContactOfSdrMediaObj* >(pCandidate)->updateMediaItem(rItem); + } + } +} + +void ViewContactOfSdrMediaObj::executeMediaItem( const ::avmedia::MediaItem& rItem ) +{ + const sal_uInt32 nCount(getViewObjectContactCount()); + + for(sal_uInt32 a(0); a < nCount; a++) + { + ViewObjectContact* pCandidate = getViewObjectContact(a); + + if(pCandidate) + { + static_cast< ViewObjectContactOfSdrMediaObj* >(pCandidate)->executeMediaItem(rItem); + } + } +} + +void ViewContactOfSdrMediaObj::mediaPropertiesChanged( const ::avmedia::MediaItem& rNewState ) +{ + static_cast< SdrMediaObj& >(GetSdrObject()).mediaPropertiesChanged(rNewState); +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrMediaObj::createViewIndependentPrimitive2DSequence() const +{ + // create range using the model data directly. This is in SdrTextObj::aRect which i will access using + // GetGeoRect() to not trigger any calculations. It's the unrotated geometry which is okay for MediaObjects ATM. + const tools::Rectangle aRectangle(GetSdrMediaObj().GetGeoRect()); + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(aRectangle); + + // create object transform + basegfx::B2DHomMatrix aTransform; + aTransform.set(0, 0, aRange.getWidth()); + aTransform.set(1, 1, aRange.getHeight()); + aTransform.set(0, 2, aRange.getMinX()); + aTransform.set(1, 2, aRange.getMinY()); + + // create media primitive. Always create primitives to allow the + // decomposition of MediaPrimitive2D to create needed invisible elements for HitTest + // and/or BoundRect + const basegfx::BColor aBackgroundColor(67.0 / 255.0, 67.0 / 255.0, 67.0 / 255.0); + const OUString& rURL(GetSdrMediaObj().getURL()); + const sal_uInt32 nPixelBorder(4); + const drawinglayer::primitive2d::Primitive2DReference xRetval( + new drawinglayer::primitive2d::MediaPrimitive2D( + aTransform, rURL, aBackgroundColor, nPixelBorder, + GetSdrMediaObj().getSnapshot())); + + return drawinglayer::primitive2d::Primitive2DContainer { xRetval }; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrobj.cxx b/svx/source/sdr/contact/viewcontactofsdrobj.cxx new file mode 100644 index 000000000..6741c3bfe --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrobj.cxx @@ -0,0 +1,190 @@ +/* -*- 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 <svx/sdr/contact/viewcontactofsdrobj.hxx> +#include <svx/sdr/contact/viewobjectcontactofsdrobj.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/svdobj.hxx> +#include <tools/debug.hxx> +#include <svx/svdpage.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx> +#include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx> +#include <svx/svdhdl.hxx> + +namespace sdr::contact { + +// Create an Object-Specific ViewObjectContact, set ViewContact and +// ObjectContact. Always needs to return something. +ViewObjectContact& ViewContactOfSdrObj::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfSdrObj(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContactOfSdrObj::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +ViewContactOfSdrObj::ViewContactOfSdrObj(SdrObject& rObj) +: ViewContact(), + mrObject(rObj), + meRememberedAnimationKind(SdrTextAniKind::NONE) +{ + // init AnimationKind + if(dynamic_cast<const SdrTextObj*>( &GetSdrObject() ) != nullptr) + { + SdrTextObj& rTextObj = static_cast<SdrTextObj&>(GetSdrObject()); + meRememberedAnimationKind = rTextObj.GetTextAniKind(); + } +} + +ViewContactOfSdrObj::~ViewContactOfSdrObj() +{ +} + +// Access to possible sub-hierarchy +sal_uInt32 ViewContactOfSdrObj::GetObjectCount() const +{ + if(GetSdrObject().GetSubList()) + { + return GetSdrObject().GetSubList()->GetObjCount(); + } + + return 0; +} + +ViewContact& ViewContactOfSdrObj::GetViewContact(sal_uInt32 nIndex) const +{ + assert(GetSdrObject().GetSubList() && + "ViewContactOfSdrObj::GetViewContact: Access to non-existent Sub-List (!)"); + SdrObject* pObj = GetSdrObject().GetSubList()->GetObj(nIndex); + assert(pObj && "ViewContactOfSdrObj::GetViewContact: Corrupt SdrObjList (!)"); + return pObj->GetViewContact(); +} + +ViewContact* ViewContactOfSdrObj::GetParentContact() const +{ + ViewContact* pRetval = nullptr; + SdrObjList* pObjList = GetSdrObject().getParentSdrObjListFromSdrObject(); + + if(pObjList) + { + if(dynamic_cast<const SdrPage*>( pObjList) != nullptr) + { + // Is a page + pRetval = &(static_cast<SdrPage*>(pObjList)->GetViewContact()); + } + else + { + // Is a group? + if(pObjList->getSdrObjectFromSdrObjList()) + { + pRetval = &(pObjList->getSdrObjectFromSdrObjList()->GetViewContact()); + } + } + } + + return pRetval; +} + +// React on changes of the object of this ViewContact +void ViewContactOfSdrObj::ActionChanged() +{ + // look for own changes + if (SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>(&GetSdrObject())) + { + if (pTextObj->GetTextAniKind() != meRememberedAnimationKind) + { + // #i38135# now remember new type + meRememberedAnimationKind = pTextObj->GetTextAniKind(); + } + } + + // call parent + ViewContact::ActionChanged(); +} + +// override for accessing the SdrObject +SdrObject* ViewContactOfSdrObj::TryToGetSdrObject() const +{ + return &GetSdrObject(); +} + + +// primitive stuff + +// add Gluepoints (if available) +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrObj::createGluePointPrimitive2DSequence() const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SdrGluePointList* pGluePointList = GetSdrObject().GetGluePointList(); + + if(pGluePointList) + { + const sal_uInt32 nCount(pGluePointList->GetCount()); + + if(nCount) + { + // prepare point vector + std::vector< basegfx::B2DPoint > aGluepointVector; + + // create GluePoint primitives. ATM these are relative to the SnapRect + for(sal_uInt32 a(0); a < nCount; a++) + { + const SdrGluePoint& rCandidate = (*pGluePointList)[static_cast<sal_uInt16>(a)]; + const Point aPosition(rCandidate.GetAbsolutePos(GetSdrObject())); + + aGluepointVector.emplace_back(aPosition.X(), aPosition.Y()); + } + + if(!aGluepointVector.empty()) + { + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::MarkerArrayPrimitive2D( + aGluepointVector, SdrHdl::createGluePointBitmap())); + xRetval = drawinglayer::primitive2d::Primitive2DContainer{ xReference }; + } + } + } + + return xRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrObj::embedToObjectSpecificInformation(drawinglayer::primitive2d::Primitive2DContainer aSource) const +{ + if(!aSource.empty() && + (!GetSdrObject().GetName().isEmpty() || + !GetSdrObject().GetTitle().isEmpty() || + !GetSdrObject().GetDescription().isEmpty())) + { + const drawinglayer::primitive2d::Primitive2DReference xRef( + new drawinglayer::primitive2d::ObjectInfoPrimitive2D( + aSource, + GetSdrObject().GetName(), + GetSdrObject().GetTitle(), + GetSdrObject().GetDescription())); + + return drawinglayer::primitive2d::Primitive2DContainer { xRef }; + } + + return aSource; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrobjcustomshape.cxx b/svx/source/sdr/contact/viewcontactofsdrobjcustomshape.cxx new file mode 100644 index 000000000..e6e8d2f1d --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrobjcustomshape.cxx @@ -0,0 +1,243 @@ +/* -*- 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 <sdr/contact/viewcontactofsdrobjcustomshape.hxx> +#include <svx/svdoashp.hxx> +#include <svx/sdooitm.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive2d/sdrcustomshapeprimitive2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <svx/obj3d.hxx> +#include <vcl/canvastools.hxx> + + +namespace sdr::contact +{ + ViewContactOfSdrObjCustomShape::ViewContactOfSdrObjCustomShape(SdrObjCustomShape& rCustomShape) + : ViewContactOfTextObj(rCustomShape) + { + } + + ViewContactOfSdrObjCustomShape::~ViewContactOfSdrObjCustomShape() + { + } + + basegfx::B2DRange ViewContactOfSdrObjCustomShape::getCorrectedTextBoundRect() const + { + const tools::Rectangle aObjectBound(GetCustomShapeObj().GetGeoRect()); + tools::Rectangle aTextBound(aObjectBound); + GetCustomShapeObj().GetTextBounds(aTextBound); + basegfx::B2DRange aTextRange = vcl::unotools::b2DRectangleFromRectangle(aTextBound); + const basegfx::B2DRange aObjectRange = vcl::unotools::b2DRectangleFromRectangle(aObjectBound); + + // no need to correct if no extra text range + if(aTextRange != aObjectRange) + { + const GeoStat& rGeoStat(GetCustomShapeObj().GetGeoStat()); + + // only correct when rotation and/or shear is used + if(rGeoStat.nShearAngle || rGeoStat.nRotationAngle ) + { + // text range needs to be corrected by + // aObjectRange.getCenter() - aRotObjectRange.getCenter() since it's + // defined differently by using rotation around object center. Start + // with positive part + basegfx::B2DVector aTranslation(aObjectRange.getCenter()); + + // get rotated and sheared object's range + basegfx::B2DRange aRotObjectRange(aObjectRange); + basegfx::B2DHomMatrix aRotMatrix; + + aRotMatrix.translate(-aObjectRange.getMinimum().getX(), -aObjectRange.getMinimum().getY()); + + if(rGeoStat.nShearAngle) + { + aRotMatrix.shearX(tan((36000 - rGeoStat.nShearAngle) * F_PI18000)); + } + + if(rGeoStat.nRotationAngle) + { + aRotMatrix.rotate((36000 - rGeoStat.nRotationAngle) * F_PI18000); + } + + aRotMatrix.translate(aObjectRange.getMinimum().getX(), aObjectRange.getMinimum().getY()); + aRotObjectRange.transform(aRotMatrix); + + // add negative translation part + aTranslation -= aRotObjectRange.getCenter(); + + // create new range + aTextRange = basegfx::B2DRange( + aTextRange.getMinX() + aTranslation.getX(), aTextRange.getMinY() + aTranslation.getY(), + aTextRange.getMaxX() + aTranslation.getX(), aTextRange.getMaxY() + aTranslation.getY()); + } + + // NbcMirror() of SdrTextObj (from which SdrObjCustomShape is derived), adds a + // 180deg rotation around the shape center to GeoStat.nRotationAngle. So remove here the + // 180° rotation, which was added by GetTextBounds(). + if(GetCustomShapeObj().IsMirroredY()) + { + basegfx::B2DHomMatrix aRotMatrix(basegfx::utils::createRotateAroundPoint( + aObjectRange.getCenterX(), aObjectRange.getCenterY(), F_PI)); + aTextRange.transform(aRotMatrix); + } + } + + return aTextRange; + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrObjCustomShape::createViewIndependentPrimitive2DSequence() const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SfxItemSet& rItemSet = GetCustomShapeObj().GetMergedItemSet(); + + // #i98072# Get shadow and text; eventually suppress the text if it's + // a TextPath FontworkGallery object + const drawinglayer::attribute::SdrEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrEffectsTextAttribute( + rItemSet, + GetCustomShapeObj().getText(0), + GetCustomShapeObj().IsTextPath())); + drawinglayer::primitive2d::Primitive2DContainer xGroup; + bool bHasText(!aAttribute.getText().isDefault()); + + // create Primitive2DContainer from sub-geometry + const SdrObject* pSdrObjRepresentation = GetCustomShapeObj().GetSdrObjectFromCustomShape(); + bool b3DShape(false); + + if(pSdrObjRepresentation) + { + // tdf#118498 The processing of SdrObjListIter for SdrIterMode::DeepNoGroups + // did change for 3D-Objects, it now correctly enters and iterates the + // SdrObjects in the E3dScene (same as for SdrObjGroup). This is more correct + // as the old version which just checked for dynamic_cast<const SdrObjGroup*> + // and *only* entered these, ignoring E3dScene as grouping-object. + // But how to fix that? Taking back the SdrObjListIter change would be easy, but + // not correct. After checking ViewContactOfE3dScene and ViewContactOfGroup + // I see that both traverse their children by themselves (on VC-Level, + // see createViewIndependentPrimitive2DSequence implementations and usage of + // GetObjectCount()). Thus in principle iterating here (esp. 'deep') seems to + // be wrong anyways, it might have even created wrong and double geometries + // (only with complex CustomShapes with multiple representation SdrObects and + // only visible when transparency involved, but runtime-expensive). + // Thus: Just do not iterate, will check behaviour deeply. + b3DShape = (nullptr != dynamic_cast< const E3dObject* >(pSdrObjRepresentation)); + const drawinglayer::primitive2d::Primitive2DContainer& xNew( + pSdrObjRepresentation->GetViewContact().getViewIndependentPrimitive2DContainer()); + xGroup.insert(xGroup.end(), xNew.begin(), xNew.end()); + } + + if(bHasText || !xGroup.empty()) + { + // prepare text box geometry + basegfx::B2DHomMatrix aTextBoxMatrix; + bool bWordWrap(false); + + // take unrotated snap rect as default, then get the + // unrotated text box. Rotation needs to be done centered + const tools::Rectangle aObjectBound(GetCustomShapeObj().GetGeoRect()); + const basegfx::B2DRange aObjectRange = vcl::unotools::b2DRectangleFromRectangle(aObjectBound); + + if(bHasText) + { + // #i101684# get the text range unrotated and absolute to the object range + const basegfx::B2DRange aTextRange(getCorrectedTextBoundRect()); + + // Rotation before scaling + if(!basegfx::fTools::equalZero(GetCustomShapeObj().GetExtraTextRotation(true))) + { + basegfx::B2DVector aTranslation(0.5, 0.5); + aTextBoxMatrix.translate( -aTranslation.getX(), -aTranslation.getY() ); + aTextBoxMatrix.rotate(basegfx::deg2rad( + 360.0 - GetCustomShapeObj().GetExtraTextRotation(true))); + aTextBoxMatrix.translate( aTranslation.getX(), aTranslation.getY() ); + } + // give text object a size + aTextBoxMatrix.scale(aTextRange.getWidth(), aTextRange.getHeight()); + + // check if we have a rotation/shear at all to take care of + const double fExtraTextRotation(GetCustomShapeObj().GetExtraTextRotation()); + const GeoStat& rGeoStat(GetCustomShapeObj().GetGeoStat()); + + if(rGeoStat.nShearAngle || rGeoStat.nRotationAngle || !basegfx::fTools::equalZero(fExtraTextRotation)) + { + if(aObjectRange != aTextRange) + { + // move relative to unrotated object range + aTextBoxMatrix.translate( + aTextRange.getMinX() - aObjectRange.getMinimum().getX(), + aTextRange.getMinY() - aObjectRange.getMinimum().getY()); + } + + if(!basegfx::fTools::equalZero(fExtraTextRotation)) + { + basegfx::B2DVector aTranslation( + ( aTextRange.getWidth() / 2 ) + ( aTextRange.getMinX() - aObjectRange.getMinimum().getX() ), + ( aTextRange.getHeight() / 2 ) + ( aTextRange.getMinY() - aObjectRange.getMinimum().getY() ) ); + aTextBoxMatrix.translate( -aTranslation.getX(), -aTranslation.getY() ); + aTextBoxMatrix.rotate(basegfx::deg2rad(360.0 - fExtraTextRotation)); + aTextBoxMatrix.translate( aTranslation.getX(), aTranslation.getY() ); + } + + if(rGeoStat.nShearAngle) + { + aTextBoxMatrix.shearX(tan((36000 - rGeoStat.nShearAngle) * F_PI18000)); + } + + if(rGeoStat.nRotationAngle) + { + aTextBoxMatrix.rotate((36000 - rGeoStat.nRotationAngle) * F_PI18000); + } + + // give text it's target position + aTextBoxMatrix.translate(aObjectRange.getMinimum().getX(), aObjectRange.getMinimum().getY()); + } + else + { + aTextBoxMatrix.translate(aTextRange.getMinX(), aTextRange.getMinY()); + } + + // check if SdrTextWordWrapItem is set + bWordWrap = GetCustomShapeObj().GetMergedItem(SDRATTR_TEXT_WORDWRAP).GetValue(); + } + + // fill object matrix + const basegfx::B2DHomMatrix aObjectMatrix(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aObjectRange.getWidth(), aObjectRange.getHeight(), + /*fShearX=*/0, /*fRotate=*/0, + aObjectRange.getMinX(), aObjectRange.getMinY())); + + // create primitive + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrCustomShapePrimitive2D( + aAttribute, + xGroup, + aTextBoxMatrix, + bWordWrap, + b3DShape, + aObjectMatrix)); + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + + return xRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrole2obj.cxx b/svx/source/sdr/contact/viewcontactofsdrole2obj.cxx new file mode 100644 index 000000000..57077e7b3 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrole2obj.cxx @@ -0,0 +1,207 @@ +/* -*- 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 <drawinglayer/primitive2d/Tools.hxx> +#include <sdr/contact/viewcontactofsdrole2obj.hxx> +#include <svx/svdoole2.hxx> +#include <sdr/contact/viewobjectcontactofsdrole2obj.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <sdr/primitive2d/sdrole2primitive2d.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <vcl/canvastools.hxx> +#include <tools/debug.hxx> +#include <sdr/primitive2d/sdrolecontentprimitive2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <drawinglayer/primitive2d/transformprimitive2d.hxx> +#include <svx/charthelper.hxx> +#include <svtools/embedhlp.hxx> + +namespace sdr::contact { + +// Create an Object-Specific ViewObjectContact, set ViewContact and +// ObjectContact. Always needs to return something. +ViewObjectContact& ViewContactOfSdrOle2Obj::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfSdrOle2Obj(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +ViewContactOfSdrOle2Obj::ViewContactOfSdrOle2Obj(SdrOle2Obj& rOle2Obj) +: ViewContactOfSdrRectObj(rOle2Obj), + mxChartContent() +{ +} + +ViewContactOfSdrOle2Obj::~ViewContactOfSdrOle2Obj() +{ +} + +basegfx::B2DHomMatrix ViewContactOfSdrOle2Obj::createObjectTransform() const +{ + // take unrotated snap rect (direct model data) for position and size + const tools::Rectangle aRectangle(GetOle2Obj().GetGeoRect()); + const basegfx::B2DRange aObjectRange = vcl::unotools::b2DRectangleFromRectangle(aRectangle); + + // create object matrix + const GeoStat& rGeoStat(GetOle2Obj().GetGeoStat()); + const double fShearX(rGeoStat.nShearAngle ? tan((36000 - rGeoStat.nShearAngle) * F_PI18000) : 0.0); + const double fRotate(rGeoStat.nRotationAngle ? (36000 - rGeoStat.nRotationAngle) * F_PI18000 : 0.0); + + return basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aObjectRange.getWidth(), aObjectRange.getHeight(), + fShearX, + fRotate, + aObjectRange.getMinX(), aObjectRange.getMinY()); +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrOle2Obj::createPrimitive2DSequenceWithParameters() const +{ + // get object transformation + const basegfx::B2DHomMatrix aObjectMatrix(createObjectTransform()); + + // Prepare attribute settings, will be used soon anyways + const SfxItemSet& rItemSet = GetOle2Obj().GetMergedItemSet(); + + // this may be refined more granular; if no content, attributes may get simpler + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillEffectsTextAttribute( + rItemSet, + GetOle2Obj().getText(0), + true)); + drawinglayer::primitive2d::Primitive2DReference xContent; + + if(GetOle2Obj().IsChart()) + { + // #i123539# allow buffering and reuse of local chart data to not need to rebuild it + // on every ViewObjectContact::getPrimitive2DSequence call. TTTT: Not needed for + // aw080, there this mechanism already works differently + if(mxChartContent.is()) + { + xContent = mxChartContent; + } + else + { + // try to get chart primitives and chart range directly from xChartModel + basegfx::B2DRange aChartContentRange; + const drawinglayer::primitive2d::Primitive2DContainer aChartSequence( + ChartHelper::tryToGetChartContentAsPrimitive2DSequence( + GetOle2Obj().getXModel(), + aChartContentRange)); + const double fWidth(aChartContentRange.getWidth()); + const double fHeight(aChartContentRange.getHeight()); + + if(!aChartSequence.empty() + && basegfx::fTools::more(fWidth, 0.0) + && basegfx::fTools::more(fHeight, 0.0)) + { + // create embedding transformation + basegfx::B2DHomMatrix aEmbed( + basegfx::utils::createTranslateB2DHomMatrix( + -aChartContentRange.getMinX(), + -aChartContentRange.getMinY())); + + aEmbed.scale(1.0 / fWidth, 1.0 / fHeight); + aEmbed = aObjectMatrix * aEmbed; + xContent = new drawinglayer::primitive2d::TransformPrimitive2D( + aEmbed, + aChartSequence); + } + + if(xContent.is()) + { + const_cast< ViewContactOfSdrOle2Obj* >(this)->mxChartContent = xContent; + } + } + } + + if(!xContent.is()) + { + // #i102063# embed OLE content in an own primitive; this will be able to decompose accessing + // the weak SdrOle2 reference and will also implement getB2DRange() for fast BoundRect + // calculations without OLE Graphic access (which may trigger e.g. chart recalculation). + // It will also take care of HighContrast and ScaleContent + xContent = new drawinglayer::primitive2d::SdrOleContentPrimitive2D( + GetOle2Obj(), + aObjectMatrix, + + // #i104867# add GraphicVersion number to be able to check for + // content change in the primitive later + GetOle2Obj().getEmbeddedObjectRef().getGraphicVersion() ); + } + + // create primitive. Use Ole2 primitive here. Prepare attribute settings, will + // be used soon anyways. Always create primitives to allow the decomposition of + // SdrOle2Primitive2D to create needed invisible elements for HitTest and/or BoundRect + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrOle2Primitive2D( + drawinglayer::primitive2d::Primitive2DContainer { xContent }, + aObjectMatrix, + aAttribute)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; +} + +basegfx::B2DRange ViewContactOfSdrOle2Obj::getRange( const drawinglayer::geometry::ViewInformation2D& rViewInfo2D ) const +{ + // this may be refined more granular; if no content, attributes may get simpler + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute aAttribute = + drawinglayer::primitive2d::createNewSdrLineFillEffectsTextAttribute( + GetOle2Obj().GetMergedItemSet(), + GetOle2Obj().getText(0), + true); + + basegfx::B2DHomMatrix aObjectMatrix = createObjectTransform(); + + drawinglayer::primitive2d::Primitive2DReference xContent = + new drawinglayer::primitive2d::SdrOleContentPrimitive2D( + GetOle2Obj(), + aObjectMatrix, + GetOle2Obj().getEmbeddedObjectRef().getGraphicVersion()); + + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrOle2Primitive2D( + drawinglayer::primitive2d::Primitive2DContainer { xContent }, + aObjectMatrix, + aAttribute)); + + return drawinglayer::primitive2d::getB2DRangeFromPrimitive2DReference(xReference, rViewInfo2D); +} + +void ViewContactOfSdrOle2Obj::ActionChanged() +{ + // call parent + ViewContactOfSdrRectObj::ActionChanged(); + + // #i123539# if we have buffered chart data, reset it + if(mxChartContent.is()) + { + mxChartContent.clear(); + } +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrOle2Obj::createViewIndependentPrimitive2DSequence() const +{ + return createPrimitive2DSequenceWithParameters(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrpage.cxx b/svx/source/sdr/contact/viewcontactofsdrpage.cxx new file mode 100644 index 000000000..80d6ba00a --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrpage.cxx @@ -0,0 +1,624 @@ +/* -*- 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 <sdr/contact/viewcontactofsdrpage.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/svdpage.hxx> +#include <sdr/contact/viewobjectcontactofsdrpage.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <svtools/colorcfg.hxx> +#include <tools/debug.hxx> +#include <vcl/svapp.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> +#include <drawinglayer/attribute/fillgradientattribute.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <vcl/lazydelete.hxx> +#include <vcl/settings.hxx> +#include <drawinglayer/primitive2d/discreteshadowprimitive2d.hxx> +#include <drawinglayer/attribute/sdrfillattribute.hxx> +#include <bitmaps.hlst> + +namespace sdr::contact { + +ViewContactOfPageSubObject::ViewContactOfPageSubObject(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: mrParentViewContactOfSdrPage(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfPageSubObject::~ViewContactOfPageSubObject() +{ +} + +ViewContact* ViewContactOfPageSubObject::GetParentContact() const +{ + return &mrParentViewContactOfSdrPage; +} + +const SdrPage& ViewContactOfPageSubObject::getPage() const +{ + return mrParentViewContactOfSdrPage.GetSdrPage(); +} + +ViewObjectContact& ViewContactOfPageBackground::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfPageBackground(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfPageBackground::createViewIndependentPrimitive2DSequence() const +{ + // We have only the page information, not the view information. Use the + // svtools::DOCCOLOR color for initialisation + const svtools::ColorConfig aColorConfig; + const Color aInitColor(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor); + const basegfx::BColor aRGBColor(aInitColor.getBColor()); + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::BackgroundColorPrimitive2D(aRGBColor)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; +} + +ViewContactOfPageBackground::ViewContactOfPageBackground(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfPageBackground::~ViewContactOfPageBackground() +{ +} + +ViewObjectContact& ViewContactOfPageShadow::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfPageShadow(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfPageShadow::createViewIndependentPrimitive2DSequence() const +{ + static bool bUseOldPageShadow(false); // loplugin:constvars:ignore + const SdrPage& rPage = getPage(); + basegfx::B2DHomMatrix aPageMatrix; + aPageMatrix.set(0, 0, static_cast<double>(rPage.GetWidth())); + aPageMatrix.set(1, 1, static_cast<double>(rPage.GetHeight())); + + if(bUseOldPageShadow) + { + // create page shadow polygon + const double fPageBorderFactor(1.0 / 256.0); + basegfx::B2DPolygon aPageShadowPolygon; + aPageShadowPolygon.append(basegfx::B2DPoint(1.0, fPageBorderFactor)); + aPageShadowPolygon.append(basegfx::B2DPoint(1.0 + fPageBorderFactor, fPageBorderFactor)); + aPageShadowPolygon.append(basegfx::B2DPoint(1.0 + fPageBorderFactor, 1.0 + fPageBorderFactor)); + aPageShadowPolygon.append(basegfx::B2DPoint(fPageBorderFactor, 1.0 + fPageBorderFactor)); + aPageShadowPolygon.append(basegfx::B2DPoint(fPageBorderFactor, 1.0)); + aPageShadowPolygon.append(basegfx::B2DPoint(1.0, 1.0)); + aPageShadowPolygon.setClosed(true); + aPageShadowPolygon.transform(aPageMatrix); + + // We have only the page information, not the view information. Use the + // svtools::FONTCOLOR color for initialisation + const svtools::ColorConfig aColorConfig; + const Color aShadowColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); + const basegfx::BColor aRGBShadowColor(aShadowColor.getBColor()); + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( + basegfx::B2DPolyPolygon(aPageShadowPolygon), + aRGBShadowColor)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + else + { + static vcl::DeleteOnDeinit< drawinglayer::primitive2d::DiscreteShadow > aDiscreteShadow( + new drawinglayer::primitive2d::DiscreteShadow( + BitmapEx(SIP_SA_PAGESHADOW35X35))); + + if(aDiscreteShadow.get()) + { + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::DiscreteShadowPrimitive2D( + aPageMatrix, + *aDiscreteShadow.get())); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + + return drawinglayer::primitive2d::Primitive2DContainer(); + } +} + +ViewContactOfPageShadow::ViewContactOfPageShadow(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfPageShadow::~ViewContactOfPageShadow() +{ +} + +ViewObjectContact& ViewContactOfMasterPage::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfMasterPage(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfMasterPage::createViewIndependentPrimitive2DSequence() const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + // this class is used when the page is a MasterPage and is responsible to + // create a visualisation for the MPBGO, if exists. This needs to be suppressed + // when a SdrPage which uses a MasterPage creates it's output. Suppression + // is done in the corresponding VOC since DisplayInfo data is needed + const SdrPage& rPage = getPage(); + + if(rPage.IsMasterPage()) + { + if(0 == rPage.GetPageNum()) + { + // #i98063# + // filter MasterPage 0 since it's the HandoutPage. Thus, it's a + // MasterPage, but has no MPBGO, so there is nothing to do here. + } + else + { + drawinglayer::attribute::SdrFillAttribute aFill; + + // #i110846# Suppress SdrPage FillStyle for MasterPages without StyleSheets, + // else the PoolDefault (XFILL_COLOR and Blue8) will be used. Normally, all + // MasterPages should have a StyleSheet exactly for this reason, but historically + // e.g. the Notes MasterPage has no StyleSheet set (and there maybe others). + if(rPage.getSdrPageProperties().GetStyleSheet()) + { + // create page fill attributes with correct properties + aFill = drawinglayer::primitive2d::createNewSdrFillAttribute( + rPage.getSdrPageProperties().GetItemSet()); + } + + if(!aFill.isDefault()) + { + // direct model data is the page size, get and use it + const basegfx::B2DRange aInnerRange( + rPage.GetLeftBorder(), rPage.GetUpperBorder(), + rPage.GetWidth() - rPage.GetRightBorder(), rPage.GetHeight() - rPage.GetLowerBorder()); + const basegfx::B2DPolygon aInnerPolgon(basegfx::utils::createPolygonFromRect(aInnerRange)); + const drawinglayer::primitive2d::Primitive2DReference xReference( + drawinglayer::primitive2d::createPolyPolygonFillPrimitive( + basegfx::B2DPolyPolygon(aInnerPolgon), + aFill, + drawinglayer::attribute::FillGradientAttribute())); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + } + } + + return xRetval; +} + +ViewContactOfMasterPage::ViewContactOfMasterPage(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfMasterPage::~ViewContactOfMasterPage() +{ +} + +ViewObjectContact& ViewContactOfPageFill::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfPageFill(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfPageFill::createViewIndependentPrimitive2DSequence() const +{ + const SdrPage& rPage = getPage(); + const basegfx::B2DRange aPageFillRange(0.0, 0.0, static_cast<double>(rPage.GetWidth()), static_cast<double>(rPage.GetHeight())); + const basegfx::B2DPolygon aPageFillPolygon(basegfx::utils::createPolygonFromRect(aPageFillRange)); + + // We have only the page information, not the view information. Use the + // svtools::DOCCOLOR color for initialisation + const svtools::ColorConfig aColorConfig; + const Color aPageFillColor(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor); + + // create and add primitive + const basegfx::BColor aRGBColor(aPageFillColor.getBColor()); + const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aPageFillPolygon), aRGBColor)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; +} + +ViewContactOfPageFill::ViewContactOfPageFill(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfPageFill::~ViewContactOfPageFill() +{ +} + +ViewObjectContact& ViewContactOfOuterPageBorder::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfOuterPageBorder(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfOuterPageBorder::createViewIndependentPrimitive2DSequence() const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SdrPage& rPage = getPage(); + const basegfx::B2DRange aPageBorderRange(0.0, 0.0, static_cast<double>(rPage.GetWidth()), static_cast<double>(rPage.GetHeight())); + + // Changed to 0x949599 for renaissance, before svtools::FONTCOLOR was used. + // Added old case as fallback for HighContrast. + basegfx::BColor aRGBBorderColor(0x94 / double(0xff), 0x95 / double(0xff), 0x99 / double(0xff)); + + if(Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + const svtools::ColorConfig aColorConfig; + const Color aBorderColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); + + aRGBBorderColor = aBorderColor.getBColor(); + } + + if(rPage.getPageBorderOnlyLeftRight()) + { + // #i93597# for Report Designer, the page border shall be only displayed right and left, + // but not top and bottom. Create simplified geometry. + basegfx::B2DPolygon aLeft, aRight; + + aLeft.append(basegfx::B2DPoint(aPageBorderRange.getMinX(), aPageBorderRange.getMinY())); + aLeft.append(basegfx::B2DPoint(aPageBorderRange.getMinX(), aPageBorderRange.getMaxY())); + + aRight.append(basegfx::B2DPoint(aPageBorderRange.getMaxX(), aPageBorderRange.getMinY())); + aRight.append(basegfx::B2DPoint(aPageBorderRange.getMaxX(), aPageBorderRange.getMaxY())); + + xRetval.resize(2); + xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aLeft, aRGBBorderColor)); + xRetval[1] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aRight, aRGBBorderColor)); + } + else + { + xRetval.resize(1); + const basegfx::B2DPolygon aPageBorderPolygon(basegfx::utils::createPolygonFromRect(aPageBorderRange)); + xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aPageBorderPolygon, aRGBBorderColor)); + } + + return xRetval; +} + +ViewContactOfOuterPageBorder::ViewContactOfOuterPageBorder(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfOuterPageBorder::~ViewContactOfOuterPageBorder() +{ +} + +ViewObjectContact& ViewContactOfInnerPageBorder::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfInnerPageBorder(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfInnerPageBorder::createViewIndependentPrimitive2DSequence() const +{ + const SdrPage& rPage = getPage(); + const basegfx::B2DRange aPageBorderRange( + static_cast<double>(rPage.GetLeftBorder()), static_cast<double>(rPage.GetUpperBorder()), + static_cast<double>(rPage.GetWidth() - rPage.GetRightBorder()), static_cast<double>(rPage.GetHeight() - rPage.GetLowerBorder())); + const basegfx::B2DPolygon aPageBorderPolygon(basegfx::utils::createPolygonFromRect(aPageBorderRange)); + + // We have only the page information, not the view information. Use the + // svtools::FONTCOLOR or svtools::DOCBOUNDARIES color for initialisation + const svtools::ColorConfig aColorConfig; + Color aBorderColor; + + if(Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + aBorderColor = aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor; + } + else + { + svtools::ColorConfigValue aBorderConfig = aColorConfig.GetColorValue(svtools::DOCBOUNDARIES); + aBorderColor = aBorderConfig.bIsVisible ? aBorderConfig.nColor : + aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor; + } + + // create page outer border primitive + const basegfx::BColor aRGBBorderColor(aBorderColor.getBColor()); + const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aPageBorderPolygon, aRGBBorderColor)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; +} + +ViewContactOfInnerPageBorder::ViewContactOfInnerPageBorder(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfInnerPageBorder::~ViewContactOfInnerPageBorder() +{ +} + +ViewObjectContact& ViewContactOfPageHierarchy::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfPageHierarchy(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfPageHierarchy::createViewIndependentPrimitive2DSequence() const +{ + // collect sub-hierarchy + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const sal_uInt32 nObjectCount(GetObjectCount()); + + // collect all sub-primitives + for(sal_uInt32 a(0); a < nObjectCount; a++) + { + const ViewContact& rCandidate(GetViewContact(a)); + const drawinglayer::primitive2d::Primitive2DContainer& aCandSeq(rCandidate.getViewIndependentPrimitive2DContainer()); + + xRetval.insert(xRetval.end(), aCandSeq.begin(), aCandSeq.end()); + } + + return xRetval; +} + +ViewContactOfPageHierarchy::ViewContactOfPageHierarchy(ViewContactOfSdrPage& rParentViewContactOfSdrPage) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage) +{ +} + +ViewContactOfPageHierarchy::~ViewContactOfPageHierarchy() +{ +} + +sal_uInt32 ViewContactOfPageHierarchy::GetObjectCount() const +{ + return getPage().GetObjCount(); +} + +ViewContact& ViewContactOfPageHierarchy::GetViewContact(sal_uInt32 nIndex) const +{ + SdrObject* pObj = getPage().GetObj(nIndex); + assert(pObj && "ViewContactOfPageHierarchy::GetViewContact: Corrupt SdrObjList (!)"); + return pObj->GetViewContact(); +} + +ViewObjectContact& ViewContactOfGrid::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfPageGrid(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfGrid::createViewIndependentPrimitive2DSequence() const +{ + // We have only the page information, not the view information and thus no grid settings. Create empty + // default. For the view-dependent implementation, see ViewObjectContactOfPageGrid::createPrimitive2DSequence + return drawinglayer::primitive2d::Primitive2DContainer(); +} + +ViewContactOfGrid::ViewContactOfGrid(ViewContactOfSdrPage& rParentViewContactOfSdrPage, bool bFront) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage), + mbFront(bFront) +{ +} + +ViewContactOfGrid::~ViewContactOfGrid() +{ +} + +ViewObjectContact& ViewContactOfHelplines::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfPageHelplines(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfHelplines::createViewIndependentPrimitive2DSequence() const +{ + // We have only the page information, not the view information and thus no helplines. Create empty + // default. For the view-dependent implementation, see ViewObjectContactOfPageHelplines::createPrimitive2DSequence + return drawinglayer::primitive2d::Primitive2DContainer(); +} + +ViewContactOfHelplines::ViewContactOfHelplines(ViewContactOfSdrPage& rParentViewContactOfSdrPage, bool bFront) +: ViewContactOfPageSubObject(rParentViewContactOfSdrPage), + mbFront(bFront) +{ +} + +ViewContactOfHelplines::~ViewContactOfHelplines() +{ +} + +// Create an Object-Specific ViewObjectContact, set ViewContact and +// ObjectContact. Always needs to return something. +ViewObjectContact& ViewContactOfSdrPage::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact) +{ + ViewObjectContact* pRetval = new ViewObjectContactOfSdrPage(rObjectContact, *this); + DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)"); + + return *pRetval; +} + +ViewContactOfSdrPage::ViewContactOfSdrPage(SdrPage& rPage) +: ViewContact(), + mrPage(rPage), + maViewContactOfPageBackground(*this), + maViewContactOfPageShadow(*this), + maViewContactOfPageFill(*this), + maViewContactOfMasterPage(*this), + maViewContactOfOuterPageBorder(*this), + maViewContactOfInnerPageBorder(*this), + maViewContactOfGridBack(*this, false), + maViewContactOfHelplinesBack(*this, false), + maViewContactOfPageHierarchy(*this), + maViewContactOfGridFront(*this, true), + maViewContactOfHelplinesFront(*this, true) +{ +} + +ViewContactOfSdrPage::~ViewContactOfSdrPage() +{ +} + +// Access to possible sub-hierarchy +sal_uInt32 ViewContactOfSdrPage::GetObjectCount() const +{ + // Fixed count of content. It contains PageBackground (Wiese), PageShadow, PageFill, + // then - depending on if the page has a MasterPage - either MasterPage Hierarchy + // or MPBGO. Also OuterPageBorder, InnerPageBorder and two pairs of Grid and Helplines + // (for front and back) which internally are visible or not depending on the current + // front/back setting for those. + return 11; +} + +ViewContact& ViewContactOfSdrPage::GetViewContact(sal_uInt32 nIndex) const +{ + switch(nIndex) + { + case 0: return const_cast<ViewContactOfPageBackground&>(maViewContactOfPageBackground); + case 1: return const_cast<ViewContactOfPageShadow&>(maViewContactOfPageShadow); + case 2: return const_cast<ViewContactOfPageFill&>(maViewContactOfPageFill); + case 3: + { + const SdrPage& rPage = GetSdrPage(); + + if(rPage.TRG_HasMasterPage()) + { + return rPage.TRG_GetMasterPageDescriptorViewContact(); + } + else + { + return const_cast<ViewContactOfMasterPage&>(maViewContactOfMasterPage); + } + } + case 4: return const_cast<ViewContactOfOuterPageBorder&>(maViewContactOfOuterPageBorder); + case 5: return const_cast<ViewContactOfInnerPageBorder&>(maViewContactOfInnerPageBorder); + case 6: return const_cast<ViewContactOfGrid&>(maViewContactOfGridBack); + case 7: return const_cast<ViewContactOfHelplines&>(maViewContactOfHelplinesBack); + case 8: return const_cast<ViewContactOfPageHierarchy&>(maViewContactOfPageHierarchy); + case 9: return const_cast<ViewContactOfGrid&>(maViewContactOfGridFront); + case 10: case 11: return const_cast<ViewContactOfHelplines&>(maViewContactOfHelplinesFront); + default: assert(false);return const_cast<ViewContactOfHelplines&>(maViewContactOfHelplinesFront); + } +} + +// React on changes of the object of this ViewContact +void ViewContactOfSdrPage::ActionChanged() +{ + // call parent + ViewContact::ActionChanged(); + + // apply to local viewContacts, they all rely on page information. Exception + // is the sub hierarchy; this will not be influenced by the change + maViewContactOfPageBackground.ActionChanged(); + maViewContactOfPageShadow.ActionChanged(); + maViewContactOfPageFill.ActionChanged(); + + const SdrPage& rPage = GetSdrPage(); + + if(rPage.TRG_HasMasterPage()) + { + rPage.TRG_GetMasterPageDescriptorViewContact().ActionChanged(); + } + else if(rPage.IsMasterPage()) + { + maViewContactOfMasterPage.ActionChanged(); + } + + maViewContactOfOuterPageBorder.ActionChanged(); + maViewContactOfInnerPageBorder.ActionChanged(); + maViewContactOfGridBack.ActionChanged(); + maViewContactOfHelplinesBack.ActionChanged(); + maViewContactOfGridFront.ActionChanged(); + maViewContactOfHelplinesFront.ActionChanged(); +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrPage::createViewIndependentPrimitive2DSequence() const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + // collect all sub-sequences including sub hierarchy. + xRetval.append(maViewContactOfPageBackground.getViewIndependentPrimitive2DContainer()); + xRetval.append(maViewContactOfPageShadow.getViewIndependentPrimitive2DContainer()); + xRetval.append(maViewContactOfPageFill.getViewIndependentPrimitive2DContainer()); + + const SdrPage& rPage = GetSdrPage(); + + if(rPage.TRG_HasMasterPage()) + { + xRetval.append( + rPage.TRG_GetMasterPageDescriptorViewContact().getViewIndependentPrimitive2DContainer()); + } + else if(rPage.IsMasterPage()) + { + xRetval.append( + maViewContactOfMasterPage.getViewIndependentPrimitive2DContainer()); + } + + xRetval.append(maViewContactOfOuterPageBorder.getViewIndependentPrimitive2DContainer()); + xRetval.append(maViewContactOfInnerPageBorder.getViewIndependentPrimitive2DContainer()); + xRetval.append(maViewContactOfPageHierarchy.getViewIndependentPrimitive2DContainer()); + + // Only add front versions of grid and helplines since no visibility test is done, + // so adding the back incarnations is not necessary. This makes the Front + // visualisation the default when no visibility tests are done. + + // Since we have no view here, no grid and helpline definitions are available currently. The used + // methods at ViewContactOfHelplines and ViewContactOfGrid return only empty sequences and + // do not need to be called ATM. This may change later if grid or helpline info gets + // model data (it should not). Keeping the lines commented to hold this hint. + + // drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(xRetval, maViewContactOfGridFront.getViewIndependentPrimitive2DContainer()); + // drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(xRetval, maViewContactOfHelplinesFront.getViewIndependentPrimitive2DContainer()); + + return xRetval; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrpathobj.cxx b/svx/source/sdr/contact/viewcontactofsdrpathobj.cxx new file mode 100644 index 000000000..83fe88b6a --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrpathobj.cxx @@ -0,0 +1,206 @@ +/* -*- 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 <sdr/contact/viewcontactofsdrpathobj.hxx> +#include <svtools/optionsdrawinglayer.hxx> +#include <svx/svdopath.hxx> +#include <svx/svdpage.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include <basegfx/polygon/b2dpolygonclipper.hxx> +#include <sdr/primitive2d/sdrpathprimitive2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <vcl/canvastools.hxx> + +namespace sdr::contact +{ + ViewContactOfSdrPathObj::ViewContactOfSdrPathObj(SdrPathObj& rPathObj) + : ViewContactOfTextObj(rPathObj) + { + } + + ViewContactOfSdrPathObj::~ViewContactOfSdrPathObj() + { + } + + static sal_uInt32 ensureGeometry(basegfx::B2DPolyPolygon& rUnitPolyPolygon) + { + sal_uInt32 nPolyCount(rUnitPolyPolygon.count()); + sal_uInt32 nPointCount(0); + + for(auto const& rPolygon : rUnitPolyPolygon) + { + nPointCount += rPolygon.count(); + } + + if(!nPointCount) + { + OSL_FAIL("PolyPolygon object without geometry detected, this should not be created (!)"); + basegfx::B2DPolygon aFallbackLine; + aFallbackLine.append(basegfx::B2DPoint(0.0, 0.0)); + aFallbackLine.append(basegfx::B2DPoint(1000.0, 1000.0)); + rUnitPolyPolygon = basegfx::B2DPolyPolygon(aFallbackLine); + + nPolyCount = 1; + } + + return nPolyCount; + } + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrPathObj::createViewIndependentPrimitive2DSequence() const + { + const SfxItemSet& rItemSet = GetPathObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillEffectsTextAttribute( + rItemSet, + GetPathObj().getText(0), + false)); + basegfx::B2DPolyPolygon aUnitPolyPolygon(GetPathObj().GetPathPoly()); + sal_uInt32 nPolyCount(ensureGeometry(aUnitPolyPolygon)); + + // prepare object transformation and unit polygon (direct model data) + basegfx::B2DHomMatrix aObjectMatrix; + basegfx::B2DPolyPolygon aUnitDefinitionPolyPolygon; + bool bIsLine( + !aUnitPolyPolygon.areControlPointsUsed() + && 1 == nPolyCount + && 2 == aUnitPolyPolygon.getB2DPolygon(0).count()); + + if(bIsLine) + { + //tdf#63955 if we have an extremely long line then clip it to a + //very generous range of -1 page width/height vs +1 page + //width/height to avoid oom and massive churn generating a huge + //polygon chain to cover the length in applyLineDashing if this + //line is dashed + const SdrPage* pPage(GetPathObj().getSdrPageFromSdrObject()); + sal_Int32 nPageWidth = pPage ? pPage->GetWidth() : 0; + sal_Int32 nPageHeight = pPage ? pPage->GetHeight() : 0; + + //But, see tdf#101187, only do this if our generous clip region + //would not over flow into a tiny clip region + if (nPageWidth < SAL_MAX_INT32/2 && nPageHeight < SAL_MAX_INT32/2) + { + //But, see tdf#97276, tdf#126184 and tdf#98366. Don't clip too much if the + //underlying page dimension is unknown or a paste document + //where the page sizes use the odd default of 10x10 + const SvtOptionsDrawinglayer aDrawinglayerOpt; + const sal_Int32 nMaxPaperWidth = aDrawinglayerOpt.GetMaximumPaperWidth() * 1000; + const sal_Int32 nMaxPaperHeight = aDrawinglayerOpt.GetMaximumPaperHeight() * 1000; + nPageWidth = std::max<sal_Int32>(nPageWidth, nMaxPaperWidth); + nPageHeight = std::max<sal_Int32>(nPageHeight, nMaxPaperHeight); + basegfx::B2DRange aClipRange(-nPageWidth, -nPageHeight, + nPageWidth*2, nPageHeight*2); + + aUnitPolyPolygon = basegfx::utils::clipPolyPolygonOnRange(aUnitPolyPolygon, + aClipRange, true, true); + nPolyCount = ensureGeometry(aUnitPolyPolygon); + + // re-check that we have't been clipped out to oblivion + bIsLine = + !aUnitPolyPolygon.areControlPointsUsed() + && 1 == nPolyCount + && 2 == aUnitPolyPolygon.getB2DPolygon(0).count(); + } + } + + if(bIsLine) + { + + // special handling for single line mode (2 points) + const basegfx::B2DPolygon aSubPolygon(aUnitPolyPolygon.getB2DPolygon(0)); + const basegfx::B2DPoint aStart(aSubPolygon.getB2DPoint(0)); + const basegfx::B2DPoint aEnd(aSubPolygon.getB2DPoint(1)); + const basegfx::B2DVector aLine(aEnd - aStart); + + // #i102548# create new unit polygon for line (horizontal) + basegfx::B2DPolygon aNewPolygon; + aNewPolygon.append(basegfx::B2DPoint(0.0, 0.0)); + aNewPolygon.append(basegfx::B2DPoint(1.0, 0.0)); + aUnitPolyPolygon.setB2DPolygon(0, aNewPolygon); + + // #i102548# fill objectMatrix with rotation and offset (no shear for lines) + aObjectMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aLine.getLength(), 1.0, + 0.0, + atan2(aLine.getY(), aLine.getX()), + aStart.getX(), aStart.getY()); + } + else + { + // #i102548# create unscaled, unsheared, unrotated and untranslated polygon + // (unit polygon) by creating the object matrix and back-transforming the polygon + const basegfx::B2DRange aObjectRange(basegfx::utils::getRange(aUnitPolyPolygon)); + const GeoStat& rGeoStat(GetPathObj().GetGeoStat()); + const double fWidth(aObjectRange.getWidth()); + const double fHeight(aObjectRange.getHeight()); + const double fScaleX(basegfx::fTools::equalZero(fWidth) ? 1.0 : fWidth); + const double fScaleY(basegfx::fTools::equalZero(fHeight) ? 1.0 : fHeight); + + aObjectMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + fScaleX, fScaleY, + rGeoStat.nShearAngle ? tan((36000 - rGeoStat.nShearAngle) * F_PI18000) : 0.0, + rGeoStat.nRotationAngle ? (36000 - rGeoStat.nRotationAngle) * F_PI18000 : 0.0, + aObjectRange.getMinX(), aObjectRange.getMinY()); + + // create unit polygon from object's absolute path + basegfx::B2DHomMatrix aInverse(aObjectMatrix); + aInverse.invert(); + aUnitPolyPolygon.transform(aInverse); + + // OperationSmiley: Check if a FillGeometryDefiningShape is set + const SdrObject* pFillGeometryDefiningShape(GetPathObj().getFillGeometryDefiningShape()); + + if(nullptr != pFillGeometryDefiningShape) + { + // If yes, get it's BoundRange and use as defining Geometry for the FillStyle. + // If no, aUnitDefinitionPolyPolygon will just be empty and thus be interpreted + // as unused. + // Using SnapRect will make the FillDefinition to always be extended e.g. + // for rotated/sheared objects. + const tools::Rectangle& rSnapRect(pFillGeometryDefiningShape->GetSnapRect()); + + aUnitDefinitionPolyPolygon.append( + basegfx::utils::createPolygonFromRect( + vcl::unotools::b2DRectangleFromRectangle(rSnapRect))); + + // use same coordinate system as the shape geometry -> this + // makes it relative to shape's unit geometry and thus freely + // transformable with the shape + aUnitDefinitionPolyPolygon.transform(aInverse); + } + } + + // create primitive. Always create primitives to allow the decomposition of + // SdrPathPrimitive2D to create needed invisible elements for HitTest and/or BoundRect + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrPathPrimitive2D( + aObjectMatrix, + aAttribute, + aUnitPolyPolygon, + aUnitDefinitionPolyPolygon)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofsdrrectobj.cxx b/svx/source/sdr/contact/viewcontactofsdrrectobj.cxx new file mode 100644 index 000000000..5dfc826fb --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofsdrrectobj.cxx @@ -0,0 +1,88 @@ +/* -*- 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 <sdr/contact/viewcontactofsdrrectobj.hxx> +#include <svx/svdorect.hxx> +#include <sdr/primitive2d/sdrattributecreator.hxx> +#include <sdr/primitive2d/sdrrectangleprimitive2d.hxx> +#include <svl/itemset.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <svx/svdmodel.hxx> +#include <vcl/canvastools.hxx> +#include <svx/sdmetitm.hxx> + +namespace sdr::contact { + +ViewContactOfSdrRectObj::ViewContactOfSdrRectObj(SdrRectObj& rRectObj) +: ViewContactOfTextObj(rRectObj) +{ +} + +ViewContactOfSdrRectObj::~ViewContactOfSdrRectObj() +{ +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfSdrRectObj::createViewIndependentPrimitive2DSequence() const +{ + const SfxItemSet& rItemSet = GetRectObj().GetMergedItemSet(); + const drawinglayer::attribute::SdrLineFillEffectsTextAttribute aAttribute( + drawinglayer::primitive2d::createNewSdrLineFillEffectsTextAttribute( + rItemSet, + GetRectObj().getText(0), + false)); + + // take unrotated snap rect (direct model data) for position and size + const tools::Rectangle aRectangle(GetRectObj().GetGeoRect()); + const ::basegfx::B2DRange aObjectRange = vcl::unotools::b2DRectangleFromRectangle(aRectangle); + + const GeoStat& rGeoStat(GetRectObj().GetGeoStat()); + + // fill object matrix + basegfx::B2DHomMatrix aObjectMatrix(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix( + aObjectRange.getWidth(), aObjectRange.getHeight(), + rGeoStat.nShearAngle ? tan((36000 - rGeoStat.nShearAngle) * F_PI18000) : 0.0, + rGeoStat.nRotationAngle ? (36000 - rGeoStat.nRotationAngle) * F_PI18000 : 0.0, + aObjectRange.getMinX(), aObjectRange.getMinY())); + + // calculate corner radius + sal_uInt32 nCornerRadius(rItemSet.Get(SDRATTR_ECKENRADIUS).GetValue()); + double fCornerRadiusX; + double fCornerRadiusY; + drawinglayer::primitive2d::calculateRelativeCornerRadius(nCornerRadius, aObjectRange, fCornerRadiusX, fCornerRadiusY); + + // #i105856# use knowledge about pickthrough from the model + const bool bPickThroughTransparentTextFrames(GetRectObj().getSdrModelFromSdrObject().IsPickThroughTransparentTextFrames()); + + // create primitive. Always create primitives to allow the decomposition of + // SdrRectanglePrimitive2D to create needed invisible elements for HitTest and/or BoundRect + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::SdrRectanglePrimitive2D( + aObjectMatrix, + aAttribute, + fCornerRadiusX, + fCornerRadiusY, + // #i105856# use fill for HitTest when TextFrame and not PickThrough + GetRectObj().IsTextFrame() && !bPickThroughTransparentTextFrames)); + + return drawinglayer::primitive2d::Primitive2DContainer{ xReference }; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactoftextobj.cxx b/svx/source/sdr/contact/viewcontactoftextobj.cxx new file mode 100644 index 000000000..4f4cd9e40 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactoftextobj.cxx @@ -0,0 +1,36 @@ +/* -*- 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 <sdr/contact/viewcontactoftextobj.hxx> +#include <svx/svdotext.hxx> + +namespace sdr::contact { + +ViewContactOfTextObj::ViewContactOfTextObj(SdrTextObj& rTextObj) +: ViewContactOfSdrObj(rTextObj) +{ +} + +ViewContactOfTextObj::~ViewContactOfTextObj() +{ +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofunocontrol.cxx b/svx/source/sdr/contact/viewcontactofunocontrol.cxx new file mode 100644 index 000000000..899593be3 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofunocontrol.cxx @@ -0,0 +1,132 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/contact/viewcontactofunocontrol.hxx> +#include <sdr/contact/viewobjectcontactofunocontrol.hxx> +#include <svx/sdr/contact/objectcontactofpageview.hxx> +#include <svx/svdouno.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdview.hxx> +#include <svx/sdrpagewindow.hxx> + +#include <vcl/canvastools.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/primitive2d/controlprimitive2d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> + + +namespace sdr::contact { + + + using ::com::sun::star::awt::XControl; + using ::com::sun::star::uno::Reference; + using ::com::sun::star::awt::XControlContainer; + using ::com::sun::star::awt::XControlModel; + + + //= ViewContactOfUnoControl + + ViewContactOfUnoControl::ViewContactOfUnoControl( SdrUnoObj& _rUnoObject ) + :ViewContactOfSdrObj( _rUnoObject ) + { + } + + + ViewContactOfUnoControl::~ViewContactOfUnoControl() + { + } + + + Reference< XControl > ViewContactOfUnoControl::getTemporaryControlForWindow( + const vcl::Window& _rWindow, Reference< XControlContainer >& _inout_ControlContainer ) const + { + SdrUnoObj* pUnoObject = dynamic_cast< SdrUnoObj* >( TryToGetSdrObject() ); + OSL_ENSURE( pUnoObject, "ViewContactOfUnoControl::getTemporaryControlForDevice: no SdrUnoObj!" ); + if ( !pUnoObject ) + return nullptr; + return ViewObjectContactOfUnoControl::getTemporaryControlForWindow( _rWindow, _inout_ControlContainer, *pUnoObject ); + } + + + ViewObjectContact& ViewContactOfUnoControl::CreateObjectSpecificViewObjectContact( ObjectContact& _rObjectContact ) + { + // print or print preview requires special handling + const OutputDevice* pDevice = _rObjectContact.TryToGetOutputDevice(); + ObjectContactOfPageView* const pPageViewContact = dynamic_cast< ObjectContactOfPageView* >( &_rObjectContact ); + + const bool bPrintOrPreview = pPageViewContact + && ( ( ( pDevice != nullptr ) && ( pDevice->GetOutDevType() == OUTDEV_PRINTER ) ) + || pPageViewContact->GetPageWindow().GetPageView().GetView().IsPrintPreview() + ) + ; + + if ( bPrintOrPreview ) + return *new UnoControlPrintOrPreviewContact( *pPageViewContact, *this ); + + // all others are nowadays served by the same implementation + return *new ViewObjectContactOfUnoControl( _rObjectContact, *this ); + } + + + drawinglayer::primitive2d::Primitive2DContainer ViewContactOfUnoControl::createViewIndependentPrimitive2DSequence() const + { + // create range. Use model data directly, not getBoundRect()/getSnapRect; these will use + // the primitive data themselves in the long run. Use SdrUnoObj's (which is a SdrRectObj) + // call to GetGeoRect() to access SdrTextObj::aRect directly and without executing anything + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(GetSdrUnoObj().GetGeoRect()); + + // create object transform + basegfx::B2DHomMatrix aTransform; + + aTransform.set(0, 0, aRange.getWidth()); + aTransform.set(1, 1, aRange.getHeight()); + aTransform.set(0, 2, aRange.getMinX()); + aTransform.set(1, 2, aRange.getMinY()); + + Reference< XControlModel > xControlModel = GetSdrUnoObj().GetUnoControlModel(); + + if(xControlModel.is()) + { + // create control primitive WITHOUT possibly existing XControl; this would be done in + // the VOC in createPrimitive2DSequence() + const drawinglayer::primitive2d::Primitive2DReference xRetval( + new drawinglayer::primitive2d::ControlPrimitive2D( + aTransform, + xControlModel)); + + return drawinglayer::primitive2d::Primitive2DContainer { xRetval }; + } + else + { + // always append an invisible outline for the cases where no visible content exists + const drawinglayer::primitive2d::Primitive2DReference xRetval( + drawinglayer::primitive2d::createHiddenGeometryPrimitives2D( + aTransform)); + + return drawinglayer::primitive2d::Primitive2DContainer { xRetval }; + } + } + + +} // namespace sdr::contact + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewcontactofvirtobj.cxx b/svx/source/sdr/contact/viewcontactofvirtobj.cxx new file mode 100644 index 000000000..b2f92bd28 --- /dev/null +++ b/svx/source/sdr/contact/viewcontactofvirtobj.cxx @@ -0,0 +1,100 @@ +/* -*- 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 <svx/sdr/contact/viewcontactofvirtobj.hxx> +#include <svx/svdovirt.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/primitive2d/transformprimitive2d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> + +namespace sdr::contact { + +ViewContactOfVirtObj::ViewContactOfVirtObj(SdrVirtObj& rObj) +: ViewContactOfSdrObj(rObj) +{ +} + +ViewContactOfVirtObj::~ViewContactOfVirtObj() +{ +} + +SdrVirtObj& ViewContactOfVirtObj::GetVirtObj() const +{ + return static_cast<SdrVirtObj&>(mrObject); +} + +// Access to possible sub-hierarchy +sal_uInt32 ViewContactOfVirtObj::GetObjectCount() const +{ + // Here, SdrVirtObj's need to return 0L to show that they have no + // sub-hierarchy, even when they are group objects. This is necessary + // to avoid that the same VOCs will be added to the draw hierarchy + // twice which leads to problems. + + // This solution is only a first solution to get things running. Later + // this needs to be replaced with creating real VOCs for the objects + // referenced by virtual objects to avoid the 'trick' of setting the + // offset for painting at the destination OutputDevice. + + // As can be seen, with primitives, the problem will be solved using + // a transformPrimitive, so this solution can stay with primitives. + return 0; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewContactOfVirtObj::createViewIndependentPrimitive2DSequence() const +{ + // create displacement transformation if we have content + basegfx::B2DHomMatrix aObjectMatrix; + Point aAnchor(GetVirtObj().GetAnchorPos()); + + if(aAnchor.X() || aAnchor.Y()) + { + aObjectMatrix.set(0, 2, aAnchor.X()); + aObjectMatrix.set(1, 2, aAnchor.Y()); + } + + // use method from referenced object to get the Primitive2DContainer + const drawinglayer::primitive2d::Primitive2DContainer& xSequenceVirtual( + GetVirtObj().GetReferencedObj().GetViewContact().getViewIndependentPrimitive2DContainer()); + + if(!xSequenceVirtual.empty()) + { + // create transform primitive + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::TransformPrimitive2D( + aObjectMatrix, + xSequenceVirtual)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + else + { + // always append an invisible outline for the cases where no visible content exists + const drawinglayer::primitive2d::Primitive2DReference xReference( + drawinglayer::primitive2d::createHiddenGeometryPrimitives2D( + aObjectMatrix)); + + return drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ + diff --git a/svx/source/sdr/contact/viewobjectcontact.cxx b/svx/source/sdr/contact/viewobjectcontact.cxx new file mode 100644 index 000000000..3cad7e469 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontact.cxx @@ -0,0 +1,474 @@ +/* -*- 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 <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/animation/animationstate.hxx> +#include <svx/sdr/contact/viewobjectcontactredirector.hxx> +#include <basegfx/color/bcolor.hxx> +#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx> +#include <drawinglayer/primitive2d/animatedprimitive2d.hxx> +#include <drawinglayer/processor2d/baseprocessor2d.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <drawinglayer/primitive2d/transformprimitive2d.hxx> + +using namespace com::sun::star; + +namespace { + +// animated extractor + +// Necessary to filter a sequence of animated primitives from +// a sequence of primitives to find out if animated or not. The decision for +// what to decompose is hard-coded and only done for knowingly animated primitives +// to not decompose too deeply and unnecessarily. This implies that the list +// which is view-specific needs to be expanded by hand when new animated objects +// are added. This may eventually be changed to a dynamically configurable approach +// if necessary. +class AnimatedExtractingProcessor2D : public drawinglayer::processor2d::BaseProcessor2D +{ +protected: + // the found animated primitives + drawinglayer::primitive2d::Primitive2DContainer maPrimitive2DSequence; + + // text animation allowed? + bool mbTextAnimationAllowed : 1; + + // graphic animation allowed? + bool mbGraphicAnimationAllowed : 1; + + // as tooling, the process() implementation takes over API handling and calls this + // virtual render method when the primitive implementation is BasePrimitive2D-based. + virtual void processBasePrimitive2D(const drawinglayer::primitive2d::BasePrimitive2D& rCandidate) override; + +public: + AnimatedExtractingProcessor2D( + const drawinglayer::geometry::ViewInformation2D& rViewInformation, + bool bTextAnimationAllowed, + bool bGraphicAnimationAllowed); + + // data access + const drawinglayer::primitive2d::Primitive2DContainer& getPrimitive2DSequence() const { return maPrimitive2DSequence; } +}; + +AnimatedExtractingProcessor2D::AnimatedExtractingProcessor2D( + const drawinglayer::geometry::ViewInformation2D& rViewInformation, + bool bTextAnimationAllowed, + bool bGraphicAnimationAllowed) +: drawinglayer::processor2d::BaseProcessor2D(rViewInformation), + maPrimitive2DSequence(), + mbTextAnimationAllowed(bTextAnimationAllowed), + mbGraphicAnimationAllowed(bGraphicAnimationAllowed) +{ +} + +void AnimatedExtractingProcessor2D::processBasePrimitive2D(const drawinglayer::primitive2d::BasePrimitive2D& rCandidate) +{ + // known implementation, access directly + switch(rCandidate.getPrimitive2DID()) + { + // add and accept animated primitives directly, no need to decompose + case PRIMITIVE2D_ID_ANIMATEDSWITCHPRIMITIVE2D : + case PRIMITIVE2D_ID_ANIMATEDBLINKPRIMITIVE2D : + case PRIMITIVE2D_ID_ANIMATEDINTERPOLATEPRIMITIVE2D : + { + const drawinglayer::primitive2d::AnimatedSwitchPrimitive2D& rSwitchPrimitive = static_cast< const drawinglayer::primitive2d::AnimatedSwitchPrimitive2D& >(rCandidate); + + if((rSwitchPrimitive.isTextAnimation() && mbTextAnimationAllowed) + || (rSwitchPrimitive.isGraphicAnimation() && mbGraphicAnimationAllowed)) + { + const drawinglayer::primitive2d::Primitive2DReference xReference(const_cast< drawinglayer::primitive2d::BasePrimitive2D* >(&rCandidate)); + maPrimitive2DSequence.push_back(xReference); + } + break; + } + + // decompose animated gifs where SdrGrafPrimitive2D produces a GraphicPrimitive2D + // which then produces the animation infos (all when used/needed) + case PRIMITIVE2D_ID_SDRGRAFPRIMITIVE2D : + case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D : + + // decompose SdrObjects with evtl. animated text + case PRIMITIVE2D_ID_SDRCAPTIONPRIMITIVE2D : + case PRIMITIVE2D_ID_SDRCONNECTORPRIMITIVE2D : + case PRIMITIVE2D_ID_SDRCUSTOMSHAPEPRIMITIVE2D : + case PRIMITIVE2D_ID_SDRELLIPSEPRIMITIVE2D : + case PRIMITIVE2D_ID_SDRELLIPSESEGMENTPRIMITIVE2D : + case PRIMITIVE2D_ID_SDRMEASUREPRIMITIVE2D : + case PRIMITIVE2D_ID_SDRPATHPRIMITIVE2D : + case PRIMITIVE2D_ID_SDRRECTANGLEPRIMITIVE2D : + + // #121194# With Graphic as Bitmap FillStyle, also check + // for primitives filled with animated graphics + case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D: + case PRIMITIVE2D_ID_FILLGRAPHICPRIMITIVE2D: + case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D: + + // decompose evtl. animated text contained in MaskPrimitive2D + // or group primitives + case PRIMITIVE2D_ID_MASKPRIMITIVE2D : + case PRIMITIVE2D_ID_GROUPPRIMITIVE2D : + { + process(rCandidate); + break; + } + + default : + { + // nothing to do for the rest + break; + } + } +} + +} // end of anonymous namespace + +namespace sdr::contact { + +ViewObjectContact::ViewObjectContact(ObjectContact& rObjectContact, ViewContact& rViewContact) +: mrObjectContact(rObjectContact), + mrViewContact(rViewContact), + maObjectRange(), + mxPrimitive2DSequence(), + maGridOffset(0.0, 0.0), + mbLazyInvalidate(false) +{ + // make the ViewContact remember me + mrViewContact.AddViewObjectContact(*this); + + // make the ObjectContact remember me + mrObjectContact.AddViewObjectContact(*this); +} + +ViewObjectContact::~ViewObjectContact() +{ + // invalidate in view + if(!maObjectRange.isEmpty()) + { + GetObjectContact().InvalidatePartOfView(maObjectRange); + } + + // delete PrimitiveAnimation + mpPrimitiveAnimation.reset(); + + // take care of remembered ObjectContact. Remove from + // OC first. The VC removal (below) CAN trigger a StopGettingViewed() + // which (depending of its implementation) may destroy other OCs. This + // can trigger the deletion of the helper OC of a page visualising object + // which IS the OC of this object. Eventually StopGettingViewed() needs + // to get asynchron later + GetObjectContact().RemoveViewObjectContact(*this); + + // take care of remembered ViewContact + GetViewContact().RemoveViewObjectContact(*this); +} + +const basegfx::B2DRange& ViewObjectContact::getObjectRange() const +{ + if(maObjectRange.isEmpty()) + { + const drawinglayer::geometry::ViewInformation2D& rViewInfo2D = GetObjectContact().getViewInformation2D(); + basegfx::B2DRange aTempRange = GetViewContact().getRange(rViewInfo2D); + if (!aTempRange.isEmpty()) + { + const_cast< ViewObjectContact* >(this)->maObjectRange = aTempRange; + } + else + { + // if range is not computed (new or LazyInvalidate objects), force it + const DisplayInfo aDisplayInfo; + const drawinglayer::primitive2d::Primitive2DContainer xSequence(getPrimitive2DSequence(aDisplayInfo)); + + if(!xSequence.empty()) + { + const_cast< ViewObjectContact* >(this)->maObjectRange = + xSequence.getB2DRange(rViewInfo2D); + } + } + } + + return maObjectRange; +} + +void ViewObjectContact::ActionChanged() +{ + if(!mbLazyInvalidate) + { + // set local flag + mbLazyInvalidate = true; + + // force ObjectRange + getObjectRange(); + + if(!maObjectRange.isEmpty()) + { + // invalidate current valid range + GetObjectContact().InvalidatePartOfView(maObjectRange); + + // reset ObjectRange, it needs to be recalculated + maObjectRange.reset(); + } + + // register at OC for lazy invalidate + GetObjectContact().setLazyInvalidate(*this); + } +} + +void ViewObjectContact::triggerLazyInvalidate() +{ + if(mbLazyInvalidate) + { + // reset flag + mbLazyInvalidate = false; + + // force ObjectRange + getObjectRange(); + + if(!maObjectRange.isEmpty()) + { + // invalidate current valid range + GetObjectContact().InvalidatePartOfView(maObjectRange); + } + } +} + +// Take some action when new objects are inserted +void ViewObjectContact::ActionChildInserted(ViewContact& rChild) +{ + // force creation of the new VOC and trigger it's refresh, so it + // will take part in LazyInvalidate immediately + rChild.GetViewObjectContact(GetObjectContact()).ActionChanged(); + + // forward action to ObjectContact + // const ViewObjectContact& rChildVOC = rChild.GetViewObjectContact(GetObjectContact()); + // GetObjectContact().InvalidatePartOfView(rChildVOC.getObjectRange()); +} + +void ViewObjectContact::checkForPrimitive2DAnimations() +{ + // remove old one + mpPrimitiveAnimation.reset(); + + // check for animated primitives + if(!mxPrimitive2DSequence.empty()) + { + const bool bTextAnimationAllowed(GetObjectContact().IsTextAnimationAllowed()); + const bool bGraphicAnimationAllowed(GetObjectContact().IsGraphicAnimationAllowed()); + + if(bTextAnimationAllowed || bGraphicAnimationAllowed) + { + AnimatedExtractingProcessor2D aAnimatedExtractor(GetObjectContact().getViewInformation2D(), + bTextAnimationAllowed, bGraphicAnimationAllowed); + aAnimatedExtractor.process(mxPrimitive2DSequence); + + if(!aAnimatedExtractor.getPrimitive2DSequence().empty()) + { + // derived primitiveList is animated, setup new PrimitiveAnimation + mpPrimitiveAnimation.reset( new sdr::animation::PrimitiveAnimation(*this, aAnimatedExtractor.getPrimitive2DSequence()) ); + } + } + } +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContact::createPrimitive2DSequence(const DisplayInfo& rDisplayInfo) const +{ + // get the view-independent Primitive from the viewContact + drawinglayer::primitive2d::Primitive2DContainer xRetval(GetViewContact().getViewIndependentPrimitive2DContainer()); + + if(!xRetval.empty()) + { + // handle GluePoint + if(!GetObjectContact().isOutputToPrinter() && GetObjectContact().AreGluePointsVisible()) + { + const drawinglayer::primitive2d::Primitive2DContainer xGlue(GetViewContact().createGluePointPrimitive2DSequence()); + + if(!xGlue.empty()) + { + xRetval.append(xGlue); + } + } + + // handle ghosted + if(isPrimitiveGhosted(rDisplayInfo)) + { + const basegfx::BColor aRGBWhite(1.0, 1.0, 1.0); + const basegfx::BColorModifierSharedPtr aBColorModifier = + std::make_shared<basegfx::BColorModifier_interpolate>( + aRGBWhite, + 0.5); + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::ModifiedColorPrimitive2D( + xRetval, + aBColorModifier)); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + } + + return xRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer const & ViewObjectContact::getPrimitive2DSequence(const DisplayInfo& rDisplayInfo) const +{ + drawinglayer::primitive2d::Primitive2DContainer xNewPrimitiveSequence; + + // take care of redirectors and create new list + ViewObjectContactRedirector* pRedirector = GetObjectContact().GetViewObjectContactRedirector(); + + if(pRedirector) + { + xNewPrimitiveSequence = pRedirector->createRedirectedPrimitive2DSequence(*this, rDisplayInfo); + } + else + { + xNewPrimitiveSequence = createPrimitive2DSequence(rDisplayInfo); + } + + // local up-to-date checks. New list different from local one? + if(mxPrimitive2DSequence != xNewPrimitiveSequence) + { + // has changed, copy content + const_cast< ViewObjectContact* >(this)->mxPrimitive2DSequence = xNewPrimitiveSequence; + + // check for animated stuff + const_cast< ViewObjectContact* >(this)->checkForPrimitive2DAnimations(); + + // always update object range when PrimitiveSequence changes + const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D()); + const_cast< ViewObjectContact* >(this)->maObjectRange = mxPrimitive2DSequence.getB2DRange(rViewInformation2D); + + // check and eventually embed to GridOffset transform primitive + if(GetObjectContact().supportsGridOffsets()) + { + const basegfx::B2DVector& rGridOffset(getGridOffset()); + + if(0.0 != rGridOffset.getX() || 0.0 != rGridOffset.getY()) + { + const basegfx::B2DHomMatrix aTranslateGridOffset( + basegfx::utils::createTranslateB2DHomMatrix( + rGridOffset)); + const drawinglayer::primitive2d::Primitive2DReference aEmbed( + new drawinglayer::primitive2d::TransformPrimitive2D( + aTranslateGridOffset, + mxPrimitive2DSequence)); + + // Set values at local data. So for now, the mechanism is to reset some of the + // defining things (mxPrimitive2DSequence, maGridOffset) and re-create the + // buffered data (including maObjectRange). It *could* be changed to keep + // the unmodified PrimitiveSequence and only update the GridOffset, but this + // would require a 2nd instance of maObjectRange and mxPrimitive2DSequence. I + // started doing so, but it just makes the code more complicated. For now, + // just allow re-creation of the PrimitiveSequence (and removing buffered + // decomposed content of it). May be optimized, though. OTOH it only happens + // in calc which traditionally does not have a huge amount of DrawObjects anyways. + const_cast< ViewObjectContact* >(this)->mxPrimitive2DSequence = drawinglayer::primitive2d::Primitive2DContainer { aEmbed }; + const_cast< ViewObjectContact* >(this)->maObjectRange.transform(aTranslateGridOffset); + } + } + } + + // return current Primitive2DContainer + return mxPrimitive2DSequence; +} + +bool ViewObjectContact::isPrimitiveVisible(const DisplayInfo& /*rDisplayInfo*/) const +{ + // default: always visible + return true; +} + +bool ViewObjectContact::isPrimitiveGhosted(const DisplayInfo& rDisplayInfo) const +{ + // default: standard check + return (GetObjectContact().DoVisualizeEnteredGroup() && !GetObjectContact().isOutputToPrinter() && rDisplayInfo.IsGhostedDrawModeActive()); +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContact::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + // check model-view visibility + if(isPrimitiveVisible(rDisplayInfo)) + { + xRetval = getPrimitive2DSequence(rDisplayInfo); + + if(!xRetval.empty()) + { + // get ranges + const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D()); + const basegfx::B2DRange aObjectRange(xRetval.getB2DRange(rViewInformation2D)); + const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport()); + + // check geometrical visibility + bool bVisible = aViewRange.isEmpty() || aViewRange.overlaps(aObjectRange); + if(!bVisible) + { + // not visible, release + xRetval.clear(); + } + } + } + + return xRetval; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContact::getPrimitive2DSequenceSubHierarchy(DisplayInfo& rDisplayInfo) const +{ + const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount()); + drawinglayer::primitive2d::Primitive2DContainer xSeqRetval; + + for(sal_uInt32 a(0); a < nSubHierarchyCount; a++) + { + const ViewObjectContact& rCandidate(GetViewContact().GetViewContact(a).GetViewObjectContact(GetObjectContact())); + + xSeqRetval.append(rCandidate.getPrimitive2DSequenceHierarchy(rDisplayInfo)); + } + + return xSeqRetval; +} + +// Support getting a GridOffset per object and view for non-linear ViewToDevice +// transformation (calc). On-demand created by delegating to the ObjectContact +// (->View) that has then all needed information +const basegfx::B2DVector& ViewObjectContact::getGridOffset() const +{ + if(0.0 == maGridOffset.getX() && 0.0 == maGridOffset.getY() && GetObjectContact().supportsGridOffsets()) + { + // create on-demand + GetObjectContact().calculateGridOffsetForViewOjectContact(const_cast<ViewObjectContact*>(this)->maGridOffset, *this); + } + + return maGridOffset; +} + +void ViewObjectContact::resetGridOffset() +{ + // reset buffered GridOffset itself + maGridOffset.setX(0.0); + maGridOffset.setY(0.0); + + // also reset sequence to get a re-calculation when GridOffset changes + mxPrimitive2DSequence.clear(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofe3d.cxx b/svx/source/sdr/contact/viewobjectcontactofe3d.cxx new file mode 100644 index 000000000..f12290634 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofe3d.cxx @@ -0,0 +1,86 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofe3d.hxx> +#include <sdr/contact/viewcontactofe3d.hxx> +#include <basegfx/color/bcolor.hxx> +#include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx> + +namespace sdr::contact +{ + ViewObjectContactOfE3d::ViewObjectContactOfE3d(ObjectContact& rObjectContact, ViewContact& rViewContact) + : ViewObjectContactOfSdrObj(rObjectContact, rViewContact) + { + } + + ViewObjectContactOfE3d::~ViewObjectContactOfE3d() + { + } + + drawinglayer::primitive3d::Primitive3DContainer ViewObjectContactOfE3d::createPrimitive3DContainer(const DisplayInfo& rDisplayInfo) const + { + // get the view-independent Primitive from the viewContact + const ViewContactOfE3d& rViewContactOfE3d(dynamic_cast< const ViewContactOfE3d& >(GetViewContact())); + drawinglayer::primitive3d::Primitive3DContainer xRetval(rViewContactOfE3d.getViewIndependentPrimitive3DContainer()); + + // handle ghosted + if(isPrimitiveGhosted(rDisplayInfo)) + { + const ::basegfx::BColor aRGBWhite(1.0, 1.0, 1.0); + const ::basegfx::BColorModifierSharedPtr aBColorModifier = + std::make_shared<basegfx::BColorModifier_interpolate>( + aRGBWhite, + 0.5); + const drawinglayer::primitive3d::Primitive3DReference xReference( + new drawinglayer::primitive3d::ModifiedColorPrimitive3D( + xRetval, + aBColorModifier)); + + xRetval = { xReference }; + } + + return xRetval; + } + + drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfE3d::createPrimitive2DSequence(const DisplayInfo& rDisplayInfo) const + { + const ViewContactOfE3d& rViewContact = static_cast< const ViewContactOfE3d& >(GetViewContact()); + + // get 3d primitive vector, isPrimitiveVisible() is done in 3d creator + return rViewContact.impCreateWithGivenPrimitive3DContainer(getPrimitive3DContainer(rDisplayInfo)); + } + + drawinglayer::primitive3d::Primitive3DContainer const & ViewObjectContactOfE3d::getPrimitive3DContainer(const DisplayInfo& rDisplayInfo) const + { + drawinglayer::primitive3d::Primitive3DContainer xNewPrimitive3DSeq(createPrimitive3DContainer(rDisplayInfo)); + + // local up-to-date checks. New list different from local one? + if(mxPrimitive3DContainer != xNewPrimitive3DSeq) + { + // has changed, copy content + const_cast< ViewObjectContactOfE3d* >(this)->mxPrimitive3DContainer = xNewPrimitive3DSeq; + } + + // return current Primitive2DContainer + return mxPrimitive3DContainer; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofe3dscene.cxx b/svx/source/sdr/contact/viewobjectcontactofe3dscene.cxx new file mode 100644 index 000000000..cc34be5bf --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofe3dscene.cxx @@ -0,0 +1,137 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofe3dscene.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/sdr/contact/viewcontactofe3dscene.hxx> +#include <basegfx/color/bcolormodifier.hxx> +#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx> + + +using namespace com::sun::star; + + +namespace +{ + // Helper method to recursively travel the DrawHierarchy for 3D objects contained in + // the 2D Scene. This will create all VOCs for the current OC which are needed + // for ActionChanged() functionality + void impInternalSubHierarchyTraveller(const sdr::contact::ViewObjectContact& rVOC) + { + const sdr::contact::ViewContact& rVC = rVOC.GetViewContact(); + const sal_uInt32 nSubHierarchyCount(rVC.GetObjectCount()); + + for(sal_uInt32 a(0); a < nSubHierarchyCount; a++) + { + const sdr::contact::ViewObjectContact& rCandidate(rVC.GetViewContact(a).GetViewObjectContact(rVOC.GetObjectContact())); + impInternalSubHierarchyTraveller(rCandidate); + } + } +} // end of anonymous namespace + + +namespace sdr::contact +{ + ViewObjectContactOfE3dScene::ViewObjectContactOfE3dScene(ObjectContact& rObjectContact, ViewContact& rViewContact) + : ViewObjectContactOfSdrObj(rObjectContact, rViewContact) + { + } + + ViewObjectContactOfE3dScene::~ViewObjectContactOfE3dScene() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfE3dScene::createPrimitive2DSequence(const DisplayInfo& rDisplayInfo) const + { + // handle ghosted, else the whole 3d group will be encapsulated to a ghosted primitive set (see below) + const bool bHandleGhostedDisplay(GetObjectContact().DoVisualizeEnteredGroup() && !GetObjectContact().isOutputToPrinter() && rDisplayInfo.IsGhostedDrawModeActive()); + const bool bIsActiveVC(bHandleGhostedDisplay && GetObjectContact().getActiveViewContact() == &GetViewContact()); + + if(bIsActiveVC) + { + // switch off ghosted, display contents normal + const_cast< DisplayInfo& >(rDisplayInfo).ClearGhostedDrawMode(); + } + + // create 2d primitive with content, use layer visibility test + // this uses no ghosted mode, so scenes in scenes and entering them will not + // support ghosted for now. This is no problem currently but would need to be + // added when sub-groups in 3d will be added one day. + const ViewContactOfE3dScene& rViewContact = dynamic_cast< ViewContactOfE3dScene& >(GetViewContact()); + const SdrLayerIDSet& rVisibleLayers = rDisplayInfo.GetProcessLayers(); + drawinglayer::primitive2d::Primitive2DContainer xRetval(rViewContact.createScenePrimitive2DSequence(&rVisibleLayers)); + + if(!xRetval.empty()) + { + // allow evtl. embedding in object-specific infos, e.g. Name, Title, Description + xRetval = rViewContact.embedToObjectSpecificInformation(xRetval); + + // handle GluePoint + if(!GetObjectContact().isOutputToPrinter() && GetObjectContact().AreGluePointsVisible()) + { + const drawinglayer::primitive2d::Primitive2DContainer xGlue(GetViewContact().createGluePointPrimitive2DSequence()); + + if(!xGlue.empty()) + { + xRetval.append(xGlue); + } + } + + // handle ghosted + if(isPrimitiveGhosted(rDisplayInfo)) + { + const ::basegfx::BColor aRGBWhite(1.0, 1.0, 1.0); + const ::basegfx::BColorModifierSharedPtr aBColorModifier = + std::make_shared<basegfx::BColorModifier_interpolate>( + aRGBWhite, + 0.5); + const drawinglayer::primitive2d::Primitive2DReference xReference( + new drawinglayer::primitive2d::ModifiedColorPrimitive2D( + xRetval, + aBColorModifier)); + + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xReference }; + } + } + + if(bIsActiveVC) + { + // set back, display ghosted again + const_cast< DisplayInfo& >(rDisplayInfo).SetGhostedDrawMode(); + } + + return xRetval; + } + + drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfE3dScene::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const + { + // To get the VOCs for the contained 3D objects created to get the correct + // Draw hierarchy and ActionChanged() working properly, travel the DrawHierarchy + // using a local tooling method + impInternalSubHierarchyTraveller(*this); + + // call parent + return ViewObjectContactOfSdrObj::getPrimitive2DSequenceHierarchy(rDisplayInfo); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofgraphic.cxx b/svx/source/sdr/contact/viewobjectcontactofgraphic.cxx new file mode 100644 index 000000000..98ce62c8e --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofgraphic.cxx @@ -0,0 +1,62 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofgraphic.hxx> +#include <sdr/contact/viewcontactofgraphic.hxx> +#include <svx/sdr/contact/objectcontact.hxx> + +namespace sdr::contact +{ + drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfGraphic::createPrimitive2DSequence(const DisplayInfo& rDisplayInfo) const + { + // get return value by calling parent + drawinglayer::primitive2d::Primitive2DContainer xRetval = ViewObjectContactOfSdrObj::createPrimitive2DSequence(rDisplayInfo); + + if(!xRetval.empty()) + { + // #i103255# suppress when graphic needs draft visualisation and output + // is for PDF export/Printer + const ViewContactOfGraphic& rVCOfGraphic = static_cast< const ViewContactOfGraphic& >(GetViewContact()); + + if(rVCOfGraphic.visualisationUsesDraft()) + { + const ObjectContact& rObjectContact = GetObjectContact(); + + if(rObjectContact.isOutputToPDFFile() || rObjectContact.isOutputToPrinter()) + { + xRetval = drawinglayer::primitive2d::Primitive2DContainer(); + } + } + } + + return xRetval; + } + + ViewObjectContactOfGraphic::ViewObjectContactOfGraphic(ObjectContact& rObjectContact, ViewContact& rViewContact) + : ViewObjectContactOfSdrObj(rObjectContact, rViewContact) + { + } + + ViewObjectContactOfGraphic::~ViewObjectContactOfGraphic() + { + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofgroup.cxx b/svx/source/sdr/contact/viewobjectcontactofgroup.cxx new file mode 100644 index 000000000..a6198992a --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofgroup.cxx @@ -0,0 +1,106 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofgroup.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <svx/svdobj.hxx> + + +using namespace com::sun::star; + + +namespace sdr::contact +{ + ViewObjectContactOfGroup::ViewObjectContactOfGroup(ObjectContact& rObjectContact, ViewContact& rViewContact) + : ViewObjectContactOfSdrObj(rObjectContact, rViewContact) + { + } + + ViewObjectContactOfGroup::~ViewObjectContactOfGroup() + { + } + + drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfGroup::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + // check model-view visibility + if(isPrimitiveVisible(rDisplayInfo)) + { + const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount()); + + if(nSubHierarchyCount) + { + const bool bDoGhostedDisplaying( + GetObjectContact().DoVisualizeEnteredGroup() + && !GetObjectContact().isOutputToPrinter() + && GetObjectContact().getActiveViewContact() == &GetViewContact()); + + if(bDoGhostedDisplaying) + { + rDisplayInfo.ClearGhostedDrawMode(); + } + + // create object hierarchy + xRetval = getPrimitive2DSequenceSubHierarchy(rDisplayInfo); + + if(!xRetval.empty()) + { + // get ranges + const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D()); + const ::basegfx::B2DRange aObjectRange(xRetval.getB2DRange(rViewInformation2D)); + const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport()); + + // check geometrical visibility + if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange)) + { + // not visible, release + xRetval.clear(); + } + } + + if(bDoGhostedDisplaying) + { + rDisplayInfo.SetGhostedDrawMode(); + } + } + else + { + // draw replacement object for group. This will use ViewContactOfGroup::createViewIndependentPrimitive2DSequence + // which creates the replacement primitives for an empty group + xRetval = ViewObjectContactOfSdrObj::getPrimitive2DSequenceHierarchy(rDisplayInfo); + } + } + return xRetval; + } + + bool ViewObjectContactOfGroup::isPrimitiveVisibleOnAnyLayer(const SdrLayerIDSet& aLayers) const + { + SdrLayerIDSet aObjectLayers; + getSdrObject().getMergedHierarchySdrLayerIDSet(aObjectLayers); + aObjectLayers &= aLayers; + return !aObjectLayers.IsEmpty(); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofmasterpagedescriptor.cxx b/svx/source/sdr/contact/viewobjectcontactofmasterpagedescriptor.cxx new file mode 100644 index 000000000..d27093eb8 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofmasterpagedescriptor.cxx @@ -0,0 +1,131 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofmasterpagedescriptor.hxx> +#include <sdr/contact/viewcontactofmasterpagedescriptor.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/svdpage.hxx> +#include <drawinglayer/primitive2d/maskprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> + + +namespace sdr::contact +{ + ViewObjectContactOfMasterPageDescriptor::ViewObjectContactOfMasterPageDescriptor(ObjectContact& rObjectContact, ViewContact& rViewContact) + : ViewObjectContact(rObjectContact, rViewContact) + { + } + + ViewObjectContactOfMasterPageDescriptor::~ViewObjectContactOfMasterPageDescriptor() + { + } + + bool ViewObjectContactOfMasterPageDescriptor::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const + { + if(rDisplayInfo.GetControlLayerProcessingActive()) + { + return false; + } + + if(!rDisplayInfo.GetPageProcessingActive()) + { + return false; + } + + return true; + } + + drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfMasterPageDescriptor::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const + { + drawinglayer::primitive2d::Primitive2DContainer xRetval; + drawinglayer::primitive2d::Primitive2DContainer xMasterPageSequence; + const sdr::MasterPageDescriptor& rDescriptor = static_cast< ViewContactOfMasterPageDescriptor& >(GetViewContact()).GetMasterPageDescriptor(); + + // used range (retval) is fixed here, it's the MasterPage fill range + const SdrPage& rOwnerPage = rDescriptor.GetOwnerPage(); + const basegfx::B2DRange aPageFillRange( + rOwnerPage.GetLeftBorder(), rOwnerPage.GetUpperBorder(), + rOwnerPage.GetWidth() - rOwnerPage.GetRightBorder(), rOwnerPage.GetHeight() - rOwnerPage.GetLowerBorder()); + + // Modify DisplayInfo for MasterPageContent collection; remember original layers and + // set combined SdrLayerIDSet; set MasterPagePaint flag + const SdrLayerIDSet aRememberedLayers(rDisplayInfo.GetProcessLayers()); + SdrLayerIDSet aPreprocessedLayers(aRememberedLayers); + aPreprocessedLayers &= rDescriptor.GetVisibleLayers(); + rDisplayInfo.SetProcessLayers(aPreprocessedLayers); + rDisplayInfo.SetSubContentActive(true); + + // check layer visibility (traditionally was member of layer 1) + if(aPreprocessedLayers.IsSet(SdrLayerID(1))) + { + // hide PageBackground for special DrawModes; historical reasons + if(!GetObjectContact().isDrawModeGray() && !GetObjectContact().isDrawModeHighContrast()) + { + // if visible, create the default background primitive sequence + xRetval = static_cast< ViewContactOfMasterPageDescriptor& >(GetViewContact()).getViewIndependentPrimitive2DContainer(); + } + } + + // hide MasterPage content? Test self here for hierarchy + if(isPrimitiveVisible(rDisplayInfo)) + { + // get the VOC of the Master-SdrPage and get its object hierarchy + ViewContact& rViewContactOfMasterPage(rDescriptor.GetUsedPage().GetViewContact()); + ViewObjectContact& rVOCOfMasterPage(rViewContactOfMasterPage.GetViewObjectContact(GetObjectContact())); + + xMasterPageSequence = rVOCOfMasterPage.getPrimitive2DSequenceHierarchy(rDisplayInfo); + } + + // reset DisplayInfo changes for MasterPage paint + rDisplayInfo.SetProcessLayers(aRememberedLayers); + rDisplayInfo.SetSubContentActive(false); + + if(!xMasterPageSequence.empty()) + { + // get range of MasterPage sub hierarchy + const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D()); + const basegfx::B2DRange aSubHierarchyRange(xMasterPageSequence.getB2DRange(rViewInformation2D)); + + if(aPageFillRange.isInside(aSubHierarchyRange)) + { + // completely inside, just render MasterPage content. Add to target + xRetval.append(xMasterPageSequence); + } + else if(aPageFillRange.overlaps(aSubHierarchyRange)) + { + // overlapping, compute common area + basegfx::B2DRange aCommonArea(aPageFillRange); + aCommonArea.intersect(aSubHierarchyRange); + + // need to create a clip primitive, add clipped list to target + const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::MaskPrimitive2D( + basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aCommonArea)), xMasterPageSequence)); + xRetval.push_back(xReference); + } + } + + // return grouped primitive + return xRetval; + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofpageobj.cxx b/svx/source/sdr/contact/viewobjectcontactofpageobj.cxx new file mode 100644 index 000000000..ad1d0bf87 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofpageobj.cxx @@ -0,0 +1,319 @@ +/* -*- 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 <vcl/idle.hxx> +#include <sdr/contact/viewobjectcontactofpageobj.hxx> +#include <sdr/contact/viewcontactofpageobj.hxx> +#include <svx/svdopage.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svtools/colorcfg.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <sdr/contact/objectcontactofobjlistpainter.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <svx/svdpage.hxx> +#include <svx/unoapi.hxx> +#include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> +#include <vcl/canvastools.hxx> + +using namespace com::sun::star; + +namespace sdr::contact { + +class PagePrimitiveExtractor : public ObjectContactOfPagePainter, public Idle +{ +private: + // the ViewObjectContactOfPageObj using this painter + ViewObjectContactOfPageObj& mrViewObjectContactOfPageObj; + +public: + // basic constructor/destructor + explicit PagePrimitiveExtractor(ViewObjectContactOfPageObj& rVOC); + virtual ~PagePrimitiveExtractor() override; + + // LazyInvalidate request. Supported here to not automatically + // invalidate the second interaction state all the time at the + // original OC + virtual void setLazyInvalidate(ViewObjectContact& rVOC) override; + + // From baseclass Timer, the timeout call triggered by the LazyInvalidate mechanism + virtual void Invoke() final override; + + // get primitive visualization + drawinglayer::primitive2d::Primitive2DContainer createPrimitive2DSequenceForPage(); + + // Own reaction on changes which will be forwarded to the OC of the owner-VOC + virtual void InvalidatePartOfView(const basegfx::B2DRange& rRange) const override; + + // forward access to SdrPageView of ViewObjectContactOfPageObj + virtual bool isOutputToPrinter() const override; + virtual bool isOutputToRecordingMetaFile() const override; + virtual bool isOutputToPDFFile() const override; + virtual bool isDrawModeGray() const override; + virtual bool isDrawModeHighContrast() const override; + virtual SdrPageView* TryToGetSdrPageView() const override; + virtual OutputDevice* TryToGetOutputDevice() const override; +}; + +PagePrimitiveExtractor::PagePrimitiveExtractor( + ViewObjectContactOfPageObj& rVOC) +: ObjectContactOfPagePainter(rVOC.GetObjectContact()), + mrViewObjectContactOfPageObj(rVOC) +{ + // make this renderer a preview renderer + setPreviewRenderer(true); + + // init timer + SetPriority(TaskPriority::HIGH_IDLE); + Stop(); +} + +PagePrimitiveExtractor::~PagePrimitiveExtractor() +{ + // execute missing LazyInvalidates and stop timer + Invoke(); +} + +void PagePrimitiveExtractor::setLazyInvalidate(ViewObjectContact& /*rVOC*/) +{ + // do NOT call parent, but remember that something is to do by + // starting the LazyInvalidateTimer + Start(); +} + +// From baseclass Timer, the timeout call triggered by the LazyInvalidate mechanism +void PagePrimitiveExtractor::Invoke() +{ + // stop the timer + Stop(); + + // invalidate all LazyInvalidate VOCs new situations + const sal_uInt32 nVOCCount(getViewObjectContactCount()); + + for(sal_uInt32 a(0); a < nVOCCount; a++) + { + ViewObjectContact* pCandidate = getViewObjectContact(a); + pCandidate->triggerLazyInvalidate(); + } +} + +drawinglayer::primitive2d::Primitive2DContainer PagePrimitiveExtractor::createPrimitive2DSequenceForPage() +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + SdrPage* pStartPage = GetStartPage(); + + if(pStartPage) + { + // update own ViewInformation2D for visualized page + const drawinglayer::geometry::ViewInformation2D& rOriginalViewInformation = mrViewObjectContactOfPageObj.GetObjectContact().getViewInformation2D(); + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D( + rOriginalViewInformation.getObjectTransformation(), + rOriginalViewInformation.getViewTransformation(), + + // #i101075# use empty range for page content here to force + // the content not to be physically clipped in any way. This + // would be possible, but would require the internal transformation + // which maps between the page visualisation object and the page + // content, including the aspect ratios (for details see in + // PagePreviewPrimitive2D::create2DDecomposition) + basegfx::B2DRange(), + + GetXDrawPageForSdrPage(pStartPage), + 0.0, // no time; page previews are not animated + rOriginalViewInformation.getExtendedInformationSequence()); + updateViewInformation2D(aNewViewInformation2D); + + // create copy of DisplayInfo to set PagePainting + DisplayInfo aDisplayInfo; + + // get page's VOC + ViewObjectContact& rDrawPageVOContact = pStartPage->GetViewContact().GetViewObjectContact(*this); + + // get whole Primitive2DContainer + xRetval = rDrawPageVOContact.getPrimitive2DSequenceHierarchy(aDisplayInfo); + } + + return xRetval; +} + +void PagePrimitiveExtractor::InvalidatePartOfView(const basegfx::B2DRange& rRange) const +{ + // an invalidate is called at this view, this needs to be translated to an invalidate + // for the using VOC. Coordinates are in page coordinate system. + const SdrPage* pStartPage = GetStartPage(); + + if(pStartPage && !rRange.isEmpty()) + { + const basegfx::B2DRange aPageRange(0.0, 0.0, static_cast<double>(pStartPage->GetWidth()), static_cast<double>(pStartPage->GetHeight())); + + if(rRange.overlaps(aPageRange)) + { + // if object on the page is inside or overlapping with page, create ActionChanged() for + // involved VOC + mrViewObjectContactOfPageObj.ActionChanged(); + } + } +} + +// forward access to SdrPageView to VOCOfPageObj +bool PagePrimitiveExtractor::isOutputToPrinter() const { return mrViewObjectContactOfPageObj.GetObjectContact().isOutputToPrinter(); } +bool PagePrimitiveExtractor::isOutputToRecordingMetaFile() const { return mrViewObjectContactOfPageObj.GetObjectContact().isOutputToRecordingMetaFile(); } +bool PagePrimitiveExtractor::isOutputToPDFFile() const { return mrViewObjectContactOfPageObj.GetObjectContact().isOutputToPDFFile(); } +bool PagePrimitiveExtractor::isDrawModeGray() const { return mrViewObjectContactOfPageObj.GetObjectContact().isDrawModeGray(); } +bool PagePrimitiveExtractor::isDrawModeHighContrast() const { return mrViewObjectContactOfPageObj.GetObjectContact().isDrawModeHighContrast(); } +SdrPageView* PagePrimitiveExtractor::TryToGetSdrPageView() const { return mrViewObjectContactOfPageObj.GetObjectContact().TryToGetSdrPageView(); } +OutputDevice* PagePrimitiveExtractor::TryToGetOutputDevice() const { return mrViewObjectContactOfPageObj.GetObjectContact().TryToGetOutputDevice(); } + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfPageObj::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SdrPageObj& rPageObject(static_cast< ViewContactOfPageObj& >(GetViewContact()).GetPageObj()); + const SdrPage* pPage = rPageObject.GetReferencedPage(); + const svtools::ColorConfig aColorConfig; + + // get PageObject's geometry + basegfx::B2DHomMatrix aPageObjectTransform; + { + const tools::Rectangle aPageObjectModelData(rPageObject.GetLastBoundRect()); + const basegfx::B2DRange aPageObjectBound = vcl::unotools::b2DRectangleFromRectangle(aPageObjectModelData); + + aPageObjectTransform.set(0, 0, aPageObjectBound.getWidth()); + aPageObjectTransform.set(1, 1, aPageObjectBound.getHeight()); + aPageObjectTransform.set(0, 2, aPageObjectBound.getMinX()); + aPageObjectTransform.set(1, 2, aPageObjectBound.getMinY()); + } + + // #i102637# add gray frame also when printing and page exists (handout pages) + const bool bCreateGrayFrame(!GetObjectContact().isOutputToPrinter() || pPage); + + // get displayed page's content. This is the unscaled page content + if(mpExtractor && pPage) + { + // get displayed page's geometry + drawinglayer::primitive2d::Primitive2DContainer xPageContent; + const Size aPageSize(pPage->GetSize()); + const double fPageWidth(aPageSize.getWidth()); + const double fPageHeight(aPageSize.getHeight()); + + // The case that a PageObject contains another PageObject which visualizes the + // same page again would lead to a recursion. Limit that recursion depth to one + // by using a local static bool + static bool bInCreatePrimitive2D(false); + + if(bInCreatePrimitive2D) + { + // Recursion is possible. Create a replacement primitive + xPageContent.resize(2); + const Color aDocColor(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor); + svtools::ColorConfigValue aBorderConfig = aColorConfig.GetColorValue(svtools::DOCBOUNDARIES); + const Color aBorderColor = aBorderConfig.bIsVisible ? aBorderConfig.nColor : aDocColor; + const basegfx::B2DRange aPageBound(0.0, 0.0, fPageWidth, fPageHeight); + const basegfx::B2DPolygon aOutline(basegfx::utils::createPolygonFromRect(aPageBound)); + + // add replacement fill + xPageContent[0] = drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aOutline), aDocColor.getBColor())); + + // add replacement border + xPageContent[1] = drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aOutline, aBorderColor.getBColor())); + } + else + { + // set recursion flag + bInCreatePrimitive2D = true; + + // init extractor, guarantee existence, set page there + mpExtractor->SetStartPage(pPage); + + // #i105548# also need to copy the VOCRedirector for sub-content creation + mpExtractor->SetViewObjectContactRedirector(GetObjectContact().GetViewObjectContactRedirector()); + + // create page content + xPageContent = mpExtractor->createPrimitive2DSequenceForPage(); + + // #i105548# reset VOCRedirector to not accidentally have a pointer to a + // temporary class, so calls to it are avoided safely + mpExtractor->SetViewObjectContactRedirector(nullptr); + + // reset recursion flag + bInCreatePrimitive2D = false; + } + + // prepare retval + if(!xPageContent.empty()) + { + const uno::Reference< drawing::XDrawPage > xDrawPage(GetXDrawPageForSdrPage(const_cast< SdrPage*>(pPage))); + const drawinglayer::primitive2d::Primitive2DReference xPagePreview(new drawinglayer::primitive2d::PagePreviewPrimitive2D( + xDrawPage, aPageObjectTransform, fPageWidth, fPageHeight, xPageContent)); + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xPagePreview }; + } + } + else if(bCreateGrayFrame) + { + // #i105146# no content, but frame display. To make hitting the page preview objects + // on the handout page more simple, add hidden fill geometry + const drawinglayer::primitive2d::Primitive2DReference xFrameHit( + drawinglayer::primitive2d::createHiddenGeometryPrimitives2D( + aPageObjectTransform)); + xRetval = drawinglayer::primitive2d::Primitive2DContainer { xFrameHit }; + } + + // add a gray outline frame, except not when printing + if(bCreateGrayFrame) + { + const Color aFrameColor(aColorConfig.GetColorValue(svtools::OBJECTBOUNDARIES).nColor); + basegfx::B2DPolygon aOwnOutline(basegfx::utils::createUnitPolygon()); + aOwnOutline.transform(aPageObjectTransform); + + const drawinglayer::primitive2d::Primitive2DReference xGrayFrame( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aOwnOutline, aFrameColor.getBColor())); + + xRetval.push_back(xGrayFrame); + } + + return xRetval; +} + +ViewObjectContactOfPageObj::ViewObjectContactOfPageObj(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfSdrObj(rObjectContact, rViewContact), + mpExtractor(new PagePrimitiveExtractor(*this)) +{ +} + +ViewObjectContactOfPageObj::~ViewObjectContactOfPageObj() +{ + // delete the helper OC + if(mpExtractor) + { + // remember candidate and reset own pointer to avoid action when createPrimitive2DSequence() + // would be called for any reason + std::unique_ptr<PagePrimitiveExtractor> pCandidate = std::move(mpExtractor); + + // also reset the StartPage to avoid ActionChanged() forwardings in the + // PagePrimitiveExtractor::InvalidatePartOfView() implementation + pCandidate->SetStartPage(nullptr); + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofsdrmediaobj.cxx b/svx/source/sdr/contact/viewobjectcontactofsdrmediaobj.cxx new file mode 100644 index 000000000..d1636bd28 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofsdrmediaobj.cxx @@ -0,0 +1,158 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofsdrmediaobj.hxx> +#include <svx/sdr/contact/viewcontactofsdrmediaobj.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <vcl/outdev.hxx> +#include <vcl/window.hxx> +#include <avmedia/mediaitem.hxx> +#include "sdrmediawindow.hxx" + +namespace sdr::contact { + +ViewObjectContactOfSdrMediaObj::ViewObjectContactOfSdrMediaObj( ObjectContact& rObjectContact, + ViewContact& rViewContact, + const ::avmedia::MediaItem& rMediaItem ) : + ViewObjectContactOfSdrObj( rObjectContact, rViewContact ) +{ +#if HAVE_FEATURE_AVMEDIA + vcl::Window* pWindow = getWindow(); + + if( pWindow ) + { + mpMediaWindow.reset( new SdrMediaWindow( pWindow, *this ) ); + mpMediaWindow->hide(); + executeMediaItem( rMediaItem ); + } +#else + (void) rMediaItem; +#endif +} + +ViewObjectContactOfSdrMediaObj::~ViewObjectContactOfSdrMediaObj() +{ +} + + +vcl::Window* ViewObjectContactOfSdrMediaObj::getWindow() const +{ + vcl::Window* pRetval = nullptr; + + const OutputDevice* oPageOutputDev = getPageViewOutputDevice(); + if( oPageOutputDev ) + { + if(OUTDEV_WINDOW == oPageOutputDev->GetOutDevType()) + { + pRetval = static_cast< vcl::Window* >(&const_cast<OutputDevice&>(*oPageOutputDev)); + } + } + + return pRetval; +} + + +Size ViewObjectContactOfSdrMediaObj::getPreferredSize() const +{ + Size aRet; + +#if HAVE_FEATURE_AVMEDIA + if( mpMediaWindow ) + aRet = mpMediaWindow->getPreferredSize(); +#else + aRet = Size(0,0); +#endif + + return aRet; +} + + +void ViewObjectContactOfSdrMediaObj::updateMediaItem( ::avmedia::MediaItem& rItem ) const +{ +#if HAVE_FEATURE_AVMEDIA + if( mpMediaWindow ) + { + mpMediaWindow->updateMediaItem( rItem ); + + // show/hide is now dependent of play state + if(avmedia::MediaState::Stop == rItem.getState()) + { + mpMediaWindow->hide(); + } + else + { + basegfx::B2DRange aViewRange(getObjectRange()); + aViewRange.transform(GetObjectContact().getViewInformation2D().getViewTransformation()); + + const tools::Rectangle aViewRectangle( + static_cast<sal_Int32>(floor(aViewRange.getMinX())), static_cast<sal_Int32>(floor(aViewRange.getMinY())), + static_cast<sal_Int32>(ceil(aViewRange.getMaxX())), static_cast<sal_Int32>(ceil(aViewRange.getMaxY()))); + + // mpMediaWindow contains a SalObject window and gtk won't accept + // the size until after the SalObject widget is shown but if we + // show it before setting a size then vcl will detect that the + // vcl::Window has no size and make it invisible instead. If we + // call setPosSize twice with the same size before and after show + // then the second attempt is a no-op as vcl caches the size. + + // so call it initially with a size arbitrarily 1 pixel wider than + // we want so we have an initial size to make vcl happy + tools::Rectangle aInitialRect(aViewRectangle); + aInitialRect.AdjustRight(1); + mpMediaWindow->setPosSize(aInitialRect); + + // then make it visible + mpMediaWindow->show(); + + // set the final desired size which is different to let vcl send it + // through to gtk which will now accept it as the underlying + // m_pSocket of GtkSalObject::SetPosSize is now visible + mpMediaWindow->setPosSize(aViewRectangle); + } + } +#else + (void) rItem; +#endif +} + + +void ViewObjectContactOfSdrMediaObj::executeMediaItem( const ::avmedia::MediaItem& rItem ) +{ +#if HAVE_FEATURE_AVMEDIA + if( mpMediaWindow ) + { + ::avmedia::MediaItem aUpdatedItem; + + mpMediaWindow->executeMediaItem( rItem ); + + // query new properties after trying to set the new properties + updateMediaItem( aUpdatedItem ); + static_cast< ViewContactOfSdrMediaObj& >( GetViewContact() ).mediaPropertiesChanged( aUpdatedItem ); + } +#else + (void) rItem; +#endif +} + + +} // end of namespace sdr::contact + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofsdrobj.cxx b/svx/source/sdr/contact/viewobjectcontactofsdrobj.cxx new file mode 100644 index 000000000..96acb10e9 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofsdrobj.cxx @@ -0,0 +1,193 @@ +/* -*- 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 <svx/sdr/contact/viewobjectcontactofsdrobj.hxx> +#include <svx/sdr/contact/viewcontactofsdrobj.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/objectcontactofpageview.hxx> +#include <svx/sdrpagewindow.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdoole2.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdview.hxx> +#include <vcl/outdev.hxx> +#include <vcl/canvastools.hxx> + +#include <fmobj.hxx> + +namespace sdr::contact { + +const SdrObject& ViewObjectContactOfSdrObj::getSdrObject() const +{ + return static_cast< ViewContactOfSdrObj& >(GetViewContact()).GetSdrObject(); +} + +ViewObjectContactOfSdrObj::ViewObjectContactOfSdrObj(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContact(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfSdrObj::~ViewObjectContactOfSdrObj() +{ +} + +bool ViewObjectContactOfSdrObj::isPrimitiveVisibleOnAnyLayer(const SdrLayerIDSet& aLayers) const +{ + return aLayers.IsSet(getSdrObject().GetLayer()); +} + +bool ViewObjectContactOfSdrObj::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + const SdrObject& rObject = getSdrObject(); + + // Test layer visibility + if(!isPrimitiveVisibleOnAnyLayer(rDisplayInfo.GetProcessLayers())) + { + return false; + } + + if(GetObjectContact().isOutputToPrinter() ) + { + // Test if print output but not printable + if( !rObject.IsPrintable()) + return false; + } + else + { + // test is object is not visible on screen + if( !rObject.IsVisible() ) + return false; + } + + // Test for hidden object on MasterPage + if(rDisplayInfo.GetSubContentActive() && rObject.IsNotVisibleAsMaster()) + { + return false; + } + + // Test for Calc object hiding (for OLE and Graphic it's extra, see there) + const SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(pSdrPageView) + { + const SdrView& rSdrView = pSdrPageView->GetView(); + const bool bHideOle(rSdrView.getHideOle()); + const bool bHideChart(rSdrView.getHideChart()); + const bool bHideDraw(rSdrView.getHideDraw()); + const bool bHideFormControl(rSdrView.getHideFormControl()); + + if(bHideOle || bHideChart || bHideDraw || bHideFormControl) + { + if(OBJ_OLE2 == rObject.GetObjIdentifier()) + { + if(static_cast<const SdrOle2Obj&>(rObject).IsChart()) + { + // chart + if(bHideChart) + { + return false; + } + } + else + { + // OLE + if(bHideOle) + { + return false; + } + } + } + else if(OBJ_GRAF == rObject.GetObjIdentifier()) + { + // graphic handled like OLE + if(bHideOle) + { + return false; + } + } + else + { + const bool bIsFormControl = dynamic_cast< const FmFormObj * >( &rObject ) != nullptr; + if(bIsFormControl && bHideFormControl) + { + return false; + } + // any other draw object + if(!bIsFormControl && bHideDraw) + { + return false; + } + } + } + } + + // tdf#91260 check if the object is anchored on a different Writer page + // than the one being painted, and if so ignore it (Writer has only one + // SdrPage, so the part of the object that should be visible will be + // painted on the page where it is anchored) + // Note that we cannot check the ViewInformation2D ViewPort for this + // because it is only the part of the page that is currently visible. + basegfx::B2IPoint const& rAnchor(vcl::unotools::b2IPointFromPoint(getSdrObject().GetAnchorPos())); + if (rAnchor.getX() || rAnchor.getY()) // only Writer sets anchor position + { + if (!rDisplayInfo.GetWriterPageFrame().isEmpty() && + !rDisplayInfo.GetWriterPageFrame().isInside(rAnchor)) + { + return false; + } + } + + // Check if this object is in the visible range. + const drawinglayer::geometry::ViewInformation2D& rViewInfo = GetObjectContact().getViewInformation2D(); + basegfx::B2DRange aObjRange = GetViewContact().getRange(rViewInfo); + if (!aObjRange.isEmpty()) + { + const basegfx::B2DRange& rViewRange = rViewInfo.getViewport(); + bool bVisible = rViewRange.isEmpty() || rViewRange.overlaps(aObjRange); + if (!bVisible) + return false; + } + + return true; +} + +const OutputDevice* ViewObjectContactOfSdrObj::getPageViewOutputDevice() const +{ + ObjectContactOfPageView* pPageViewContact = dynamic_cast< ObjectContactOfPageView* >( &GetObjectContact() ); + if ( pPageViewContact ) + { + // if the PageWindow has a patched PaintWindow, use the original PaintWindow + // this ensures that our control is _not_ re-created just because somebody + // (temporarily) changed the window to paint onto. + // #i72429# / 2007-02-20 / frank.schoenheit (at) sun.com + SdrPageWindow& rPageWindow( pPageViewContact->GetPageWindow() ); + if ( rPageWindow.GetOriginalPaintWindow() ) + return &rPageWindow.GetOriginalPaintWindow()->GetOutputDevice(); + + return &rPageWindow.GetPaintWindow().GetOutputDevice(); + } + return nullptr; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofsdrole2obj.cxx b/svx/source/sdr/contact/viewobjectcontactofsdrole2obj.cxx new file mode 100644 index 000000000..200548577 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofsdrole2obj.cxx @@ -0,0 +1,150 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofsdrole2obj.hxx> +#include <svx/sdr/contact/viewobjectcontactofsdrobj.hxx> +#include <sdr/contact/viewcontactofsdrole2obj.hxx> +#include <svx/svdoole2.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdview.hxx> +#include <drawinglayer/primitive2d/PolyPolygonHatchPrimitive2D.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <com/sun/star/embed/EmbedMisc.hpp> +#include <com/sun/star/embed/EmbedStates.hpp> +#include <com/sun/star/embed/XEmbeddedObject.hpp> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <svtools/embedhlp.hxx> + +using namespace com::sun::star; + +namespace sdr::contact { + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfSdrOle2Obj::createPrimitive2DSequence( + const DisplayInfo& /*rDisplayInfo*/) const +{ + // override this method to do some things the old SdrOle2Obj::DoPaintObject did. + // In the future, some of these may be solved different, but ATM try to stay compatible + // with the old behaviour + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SdrOle2Obj& rSdrOle2 = static_cast< ViewContactOfSdrOle2Obj& >(GetViewContact()).GetOle2Obj(); + sal_Int32 nState(-1); + + { + const svt::EmbeddedObjectRef& xObjRef = rSdrOle2.getEmbeddedObjectRef(); + if ( xObjRef.is() ) + nState = xObjRef->getCurrentState(); + } + + const bool bIsOutplaceActive(nState == embed::EmbedStates::ACTIVE); + const bool bIsInplaceActive((nState == embed::EmbedStates::INPLACE_ACTIVE) || (nState == embed::EmbedStates::UI_ACTIVE)); + bool bDone(false); + + if (bIsInplaceActive) + { + if( !GetObjectContact().isOutputToPrinter() && !GetObjectContact().isOutputToRecordingMetaFile() ) + { + //no need to create a primitive sequence here as the OLE object does render itself + //in case of charts the superfluous creation of a metafile is strongly performance relevant! + bDone = true; + } + } + + if( !bDone ) + { + //old stuff that should be reworked + { + //if no replacement image is available load the OLE object +// if(!rSdrOle2.GetGraphic()) //try to fetch the metafile - this can lead to the actual creation of the metafile what can be extremely expensive (e.g. for big charts)!!! #i101925# +// { +// // try to create embedded object +// rSdrOle2.GetObjRef(); //this loads the OLE object if it is not loaded already +// } + const svt::EmbeddedObjectRef& xObjRef = rSdrOle2.getEmbeddedObjectRef(); + if(xObjRef.is()) + { + const sal_Int64 nMiscStatus(xObjRef->getStatus(rSdrOle2.GetAspect())); + + // this hack (to change model data during PAINT argh(!)) should be reworked + if(!rSdrOle2.IsResizeProtect() && (nMiscStatus & embed::EmbedMisc::EMBED_NEVERRESIZE)) + { + const_cast< SdrOle2Obj* >(&rSdrOle2)->SetResizeProtect(true); + } + + SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView(); + if(pPageView && (nMiscStatus & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE)) + { + // connect plugin object + pPageView->GetView().DoConnect(const_cast< SdrOle2Obj* >(&rSdrOle2)); + } + } + }//end old stuff to rework + + // create OLE primitive stuff directly at VC with HC as parameter + const ViewContactOfSdrOle2Obj& rVC = static_cast< const ViewContactOfSdrOle2Obj& >(GetViewContact()); + xRetval = rVC.createPrimitive2DSequenceWithParameters(); + + if(bIsOutplaceActive) + { + // do not shade when printing or PDF exporting + if(!GetObjectContact().isOutputToPrinter() && !GetObjectContact().isOutputToRecordingMetaFile()) + { + // get object transformation + const basegfx::B2DHomMatrix aObjectMatrix(static_cast< ViewContactOfSdrOle2Obj& >(GetViewContact()).createObjectTransform()); + + // shade the representation if the object is activated outplace + basegfx::B2DPolygon aObjectOutline(basegfx::utils::createUnitPolygon()); + aObjectOutline.transform(aObjectMatrix); + + // Use a FillHatchPrimitive2D with necessary attributes + const drawinglayer::attribute::FillHatchAttribute aFillHatch( + drawinglayer::attribute::HatchStyle::Single, // single hatch + 125.0, // 1.25 mm + basegfx::deg2rad(45.0), // 45 degree diagonal + COL_BLACK.getBColor(), // black color + 3, // same default as VCL, a minimum of three discrete units (pixels) offset + false); // no filling + + const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::PolyPolygonHatchPrimitive2D( + basegfx::B2DPolyPolygon(aObjectOutline), + COL_BLACK.getBColor(), + aFillHatch)); + + xRetval.push_back(xReference); + } + } + + } + + return xRetval; +} + +ViewObjectContactOfSdrOle2Obj::ViewObjectContactOfSdrOle2Obj(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfSdrObj(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfSdrOle2Obj::~ViewObjectContactOfSdrOle2Obj() +{ +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofsdrpage.cxx b/svx/source/sdr/contact/viewobjectcontactofsdrpage.cxx new file mode 100644 index 000000000..796fe0e23 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofsdrpage.cxx @@ -0,0 +1,633 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofsdrpage.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <sdr/contact/viewcontactofsdrpage.hxx> +#include <svx/svdview.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdpagv.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> +#include <drawinglayer/primitive2d/gridprimitive2d.hxx> +#include <drawinglayer/primitive2d/helplineprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <sdr/primitive2d/sdrprimitivetools.hxx> + +using namespace com::sun::star; + +namespace sdr::contact { + +const SdrPage& ViewObjectContactOfPageSubObject::getPage() const +{ + return static_cast< ViewContactOfPageSubObject& >(GetViewContact()).getPage(); +} + +ViewObjectContactOfPageSubObject::ViewObjectContactOfPageSubObject(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContact(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfPageSubObject::~ViewObjectContactOfPageSubObject() +{ +} + +bool ViewObjectContactOfPageSubObject::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(rDisplayInfo.GetSubContentActive()) + { + return false; + } + + if(rDisplayInfo.GetControlLayerProcessingActive()) + { + return false; + } + + if(!rDisplayInfo.GetPageProcessingActive()) + { + return false; + } + + if(GetObjectContact().isOutputToPrinter()) + { + return false; + } + + if(!GetObjectContact().TryToGetSdrPageView()) + { + return false; + } + + return true; +} + +bool ViewObjectContactOfPageSubObject::isPrimitiveGhosted(const DisplayInfo& /*rDisplayInfo*/) const +{ + // suppress ghosted for page parts + return false; +} + +ViewObjectContactOfPageBackground::ViewObjectContactOfPageBackground(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfPageBackground::~ViewObjectContactOfPageBackground() +{ +} + +bool ViewObjectContactOfPageBackground::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + // no page background for preview renderers + if(GetObjectContact().IsPreviewRenderer()) + { + return false; + } + + return true; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfPageBackground::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const +{ + // Initialize background. Dependent of IsPageVisible, use ApplicationBackgroundColor or ApplicationDocumentColor. Most + // old renderers for export (html, pdf, gallery, ...) set the page to not visible (SetPageVisible(false)). They expect the + // given OutputDevice to be initialized with the ApplicationDocumentColor then. + const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView(); + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + if(pPageView) + { + const SdrView& rView = pPageView->GetView(); + Color aInitColor; + + if(rView.IsPageVisible()) + { + aInitColor = pPageView->GetApplicationBackgroundColor(); + } + else + { + aInitColor = pPageView->GetApplicationDocumentColor(); + + if(COL_AUTO == aInitColor) + { + const svtools::ColorConfig aColorConfig; + aInitColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor; + } + } + + // init background with InitColor + xRetval.resize(1); + const basegfx::BColor aRGBColor(aInitColor.getBColor()); + xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::BackgroundColorPrimitive2D(aRGBColor, aInitColor.GetTransparency() / 255.0)); + } + + return xRetval; +} + +ViewObjectContactOfMasterPage::ViewObjectContactOfMasterPage(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfMasterPage::~ViewObjectContactOfMasterPage() +{ +} + +bool ViewObjectContactOfMasterPage::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + // this object is only used for MasterPages. When not the MasterPage is + // displayed as a page, but another page is using it as sub-object, the + // geometry needs to be hidden + if(rDisplayInfo.GetSubContentActive()) + { + return false; + } + + return true; +} + +ViewObjectContactOfPageFill::ViewObjectContactOfPageFill(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfPageFill::~ViewObjectContactOfPageFill() +{ +} + +bool ViewObjectContactOfPageFill::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(!pSdrPageView) + { + return false; + } + + if(!pSdrPageView->GetView().IsPageVisible()) + { + return false; + } + + return true; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfPageFill::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const +{ + const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView(); + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + if(pPageView) + { + const SdrPage& rPage = getPage(); + + const basegfx::B2DRange aPageFillRange(0.0, 0.0, static_cast<double>(rPage.GetWidth()), static_cast<double>(rPage.GetHeight())); + const basegfx::B2DPolygon aPageFillPolygon(basegfx::utils::createPolygonFromRect(aPageFillRange)); + Color aPageFillColor; + + if(pPageView->GetApplicationDocumentColor() != COL_AUTO) + { + aPageFillColor = pPageView->GetApplicationDocumentColor(); + } + else + { + const svtools::ColorConfig aColorConfig; + aPageFillColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor; + } + + // create and add primitive + xRetval.resize(1); + const basegfx::BColor aRGBColor(aPageFillColor.getBColor()); + xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aPageFillPolygon), aRGBColor)); + } + + return xRetval; +} + +ViewObjectContactOfPageShadow::ViewObjectContactOfPageShadow(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfPageShadow::~ViewObjectContactOfPageShadow() +{ +} + +bool ViewObjectContactOfPageShadow::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(!pSdrPageView) + { + return false; + } + + if(!pSdrPageView->GetView().IsPageVisible()) + { + return false; + } + + if(!pSdrPageView->GetView().IsPageShadowVisible()) + { + return false; + } + + // no page shadow for preview renderers + if(GetObjectContact().IsPreviewRenderer()) + { + return false; + } + + // no page shadow for high contrast mode + if(GetObjectContact().isDrawModeHighContrast()) + { + return false; + } + + return true; +} + +ViewObjectContactOfOuterPageBorder::ViewObjectContactOfOuterPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfOuterPageBorder::~ViewObjectContactOfOuterPageBorder() +{ +} + +bool ViewObjectContactOfOuterPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(!pSdrPageView) + { + return false; + } + + const SdrView& rView = pSdrPageView->GetView(); + + return rView.IsPageVisible() || !rView.IsPageBorderVisible(); +} + +ViewObjectContactOfInnerPageBorder::ViewObjectContactOfInnerPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfInnerPageBorder::~ViewObjectContactOfInnerPageBorder() +{ +} + +bool ViewObjectContactOfInnerPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(!pSdrPageView) + { + return false; + } + + if(!pSdrPageView->GetView().IsBordVisible()) + { + return false; + } + + const SdrPage& rPage = getPage(); + + if(!rPage.GetLeftBorder() && !rPage.GetUpperBorder() && !rPage.GetRightBorder() && !rPage.GetLowerBorder()) + { + return false; + } + + // no inner page border for preview renderers + if(GetObjectContact().IsPreviewRenderer()) + { + return false; + } + + return true; +} + +ViewObjectContactOfPageHierarchy::ViewObjectContactOfPageHierarchy(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfPageHierarchy::~ViewObjectContactOfPageHierarchy() +{ +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfPageHierarchy::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + // process local sub-hierarchy + const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount()); + + if(nSubHierarchyCount) + { + xRetval = getPrimitive2DSequenceSubHierarchy(rDisplayInfo); + + if(!xRetval.empty()) + { + // get ranges + const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D()); + const basegfx::B2DRange aObjectRange(xRetval.getB2DRange(rViewInformation2D)); + const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport()); + + // check geometrical visibility + if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange)) + { + // not visible, release + xRetval.clear(); + } + } + } + + return xRetval; +} + +ViewObjectContactOfPageGrid::ViewObjectContactOfPageGrid(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfPageGrid::~ViewObjectContactOfPageGrid() +{ +} + +bool ViewObjectContactOfPageGrid::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(!pSdrPageView) + { + return false; + } + + const SdrView& rView = pSdrPageView->GetView(); + + if(!rView.IsGridVisible()) + { + return false; + } + + // no page grid for preview renderers + if(GetObjectContact().IsPreviewRenderer()) + { + return false; + } + + if(static_cast< ViewContactOfGrid& >(GetViewContact()).getFront() != rView.IsGridFront()) + { + return false; + } + + return true; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfPageGrid::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const +{ + const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView(); + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + if(pPageView) + { + const SdrView& rView = pPageView->GetView(); + const SdrPage& rPage = getPage(); + const Color aGridColor(rView.GetGridColor()); + const basegfx::BColor aRGBGridColor(aGridColor.getBColor()); + + basegfx::B2DHomMatrix aGridMatrix; + aGridMatrix.set(0, 0, static_cast<double>(rPage.GetWidth() - (rPage.GetRightBorder() + rPage.GetLeftBorder()))); + aGridMatrix.set(1, 1, static_cast<double>(rPage.GetHeight() - (rPage.GetLowerBorder() + rPage.GetUpperBorder()))); + aGridMatrix.set(0, 2, static_cast<double>(rPage.GetLeftBorder())); + aGridMatrix.set(1, 2, static_cast<double>(rPage.GetUpperBorder())); + + const Size aRaw(rView.GetGridCoarse()); + const Size aFine(rView.GetGridFine()); + const double fWidthX(aRaw.getWidth()); + const double fWidthY(aRaw.getHeight()); + const sal_uInt32 nSubdivisionsX(aFine.getWidth() ? aRaw.getWidth() / aFine.getWidth() : 0); + const sal_uInt32 nSubdivisionsY(aFine.getHeight() ? aRaw.getHeight() / aFine.getHeight() : 0); + + xRetval.resize(1); + xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::GridPrimitive2D( + aGridMatrix, fWidthX, fWidthY, 10.0, 3.0, nSubdivisionsX, nSubdivisionsY, aRGBGridColor, + drawinglayer::primitive2d::createDefaultCross_3x3(aRGBGridColor))); + } + + return xRetval; +} + +ViewObjectContactOfPageHelplines::ViewObjectContactOfPageHelplines(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContactOfPageSubObject(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfPageHelplines::~ViewObjectContactOfPageHelplines() +{ +} + +bool ViewObjectContactOfPageHelplines::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const +{ + if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo)) + { + return false; + } + + SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(!pSdrPageView) + { + return false; + } + + const SdrView& rView = pSdrPageView->GetView(); + + if(!rView.IsHlplVisible()) + { + return false; + } + + // no helplines for preview renderers + if(GetObjectContact().IsPreviewRenderer()) + { + return false; + } + + if(static_cast< ViewContactOfHelplines& >(GetViewContact()).getFront() != rView.IsHlplFront()) + { + return false; + } + + return true; +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfPageHelplines::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView(); + + if(pPageView) + { + const SdrHelpLineList& rHelpLineList = pPageView->GetHelpLines(); + const sal_uInt32 nCount(rHelpLineList.GetCount()); + + if(nCount) + { + const basegfx::BColor aRGBColorA(1.0, 1.0, 1.0); + const basegfx::BColor aRGBColorB(0.0, 0.0, 0.0); + xRetval.resize(nCount); + + for(sal_uInt32 a(0); a < nCount; a++) + { + const SdrHelpLine& rHelpLine = rHelpLineList[static_cast<sal_uInt16>(a)]; + const basegfx::B2DPoint aPosition(static_cast<double>(rHelpLine.GetPos().X()), static_cast<double>(rHelpLine.GetPos().Y())); + const double fDiscreteDashLength(4.0); + + switch(rHelpLine.GetKind()) + { + default : // SdrHelpLineKind::Point + { + xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D( + aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HelplineStyle2D::Point, + aRGBColorA, aRGBColorB, fDiscreteDashLength)); + break; + } + case SdrHelpLineKind::Vertical : + { + xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D( + aPosition, basegfx::B2DVector(0.0, 1.0), drawinglayer::primitive2d::HelplineStyle2D::Line, + aRGBColorA, aRGBColorB, fDiscreteDashLength)); + break; + } + case SdrHelpLineKind::Horizontal : + { + xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D( + aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HelplineStyle2D::Line, + aRGBColorA, aRGBColorB, fDiscreteDashLength)); + break; + } + } + } + } + } + + return xRetval; +} + +ViewObjectContactOfSdrPage::ViewObjectContactOfSdrPage(ObjectContact& rObjectContact, ViewContact& rViewContact) +: ViewObjectContact(rObjectContact, rViewContact) +{ +} + +ViewObjectContactOfSdrPage::~ViewObjectContactOfSdrPage() +{ +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfSdrPage::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const +{ + drawinglayer::primitive2d::Primitive2DContainer xRetval; + + // process local sub-hierarchy + const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount()); + + if(nSubHierarchyCount) + { + const bool bDoGhostedDisplaying( + GetObjectContact().DoVisualizeEnteredGroup() + && !GetObjectContact().isOutputToPrinter() + && GetObjectContact().getActiveViewContact() == &GetViewContact()); + + if(bDoGhostedDisplaying) + { + rDisplayInfo.ClearGhostedDrawMode(); + } + + // create object hierarchy + xRetval = getPrimitive2DSequenceSubHierarchy(rDisplayInfo); + + if(!xRetval.empty()) + { + // get ranges + const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D()); + const basegfx::B2DRange aObjectRange(xRetval.getB2DRange(rViewInformation2D)); + const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport()); + + // check geometrical visibility + if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange)) + { + // not visible, release + xRetval.clear(); + } + } + + if(bDoGhostedDisplaying) + { + rDisplayInfo.SetGhostedDrawMode(); + } + } + + return xRetval; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactofunocontrol.cxx b/svx/source/sdr/contact/viewobjectcontactofunocontrol.cxx new file mode 100644 index 000000000..6f9ecf61c --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactofunocontrol.cxx @@ -0,0 +1,1786 @@ +/* -*- 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 <sdr/contact/viewobjectcontactofunocontrol.hxx> +#include <sdr/contact/viewcontactofunocontrol.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <svx/sdr/contact/objectcontactofpageview.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <svx/svdouno.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdview.hxx> +#include <svx/sdrpagewindow.hxx> + +#include <com/sun/star/awt/XControl.hpp> +#include <com/sun/star/awt/XControlModel.hpp> +#include <com/sun/star/awt/XControlContainer.hpp> +#include <com/sun/star/awt/XWindow2.hpp> +#include <com/sun/star/awt/PosSize.hpp> +#include <com/sun/star/awt/XView.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/lang/XComponent.hpp> +#include <com/sun/star/awt/InvalidateStyle.hpp> +#include <com/sun/star/util/XModeChangeListener.hpp> +#include <com/sun/star/util/XModeChangeBroadcaster.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/container/XContainerListener.hpp> +#include <com/sun/star/container/XContainer.hpp> + +#include <vcl/canvastools.hxx> +#include <vcl/svapp.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/scopeguard.hxx> +#include <cppuhelper/implbase.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <tools/diagnose_ex.h> +#include <tools/debug.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <drawinglayer/primitive2d/controlprimitive2d.hxx> + +/* + +Form controls (more precise: UNO Controls) in the drawing layer are ... prone to breakage, since they have some +specialities which the drawing layer currently doesn't capture too well. In particular, having a living VCL +window as child of the document window, and coupling this Window to a drawing layer object, makes things +difficult sometimes. + +Below is a list of issues which existed in the past. Whenever you change code here, you're encouraged to +verify those issues are still fixed. (Whenever you have some additional time, you're encouraged to write +an automatic test for one or more of those issues for which this is possible :) + +https://bz.apache.org/ooo/show_bug.cgi?id=105992 +zooming documents containing (alive) form controls improperly positions the controls + +https://bz.apache.org/ooo/show_bug.cgi?id=104362 +crash when copy a control + +https://bz.apache.org/ooo/show_bug.cgi?id=104544 +Gridcontrol duplicated after design view on/off + +https://bz.apache.org/ooo/show_bug.cgi?id=102089 +print preview shows control elements with property printable=false + +https://bz.apache.org/ooo/show_bug.cgi?id=102090 +problem with setVisible on TextControl + +https://bz.apache.org/ooo/show_bug.cgi?id=103138 +loop when insert a control in draw + +https://bz.apache.org/ooo/show_bug.cgi?id=101398 +initially-displaying a document with many controls is very slow + +https://bz.apache.org/ooo/show_bug.cgi?id=72429 +repaint error in form wizard in bugdoc database + +https://bz.apache.org/ooo/show_bug.cgi?id=72694 +form control artifacts when scrolling a text fast + +*/ + + +namespace sdr::contact { + + + using namespace ::com::sun::star::awt::InvalidateStyle; + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::uno::UNO_QUERY_THROW; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::uno::RuntimeException; + using ::com::sun::star::awt::XControl; + using ::com::sun::star::awt::XControlModel; + using ::com::sun::star::awt::XControlContainer; + using ::com::sun::star::awt::XWindow2; + using ::com::sun::star::awt::XWindowListener; + using ::com::sun::star::awt::PosSize::POSSIZE; + using ::com::sun::star::awt::XView; + using ::com::sun::star::awt::WindowEvent; + using ::com::sun::star::beans::XPropertySet; + using ::com::sun::star::lang::XComponent; + using ::com::sun::star::awt::XWindowPeer; + using ::com::sun::star::beans::XPropertyChangeListener; + using ::com::sun::star::util::XModeChangeListener; + using ::com::sun::star::util::XModeChangeBroadcaster; + using ::com::sun::star::util::ModeChangeEvent; + using ::com::sun::star::lang::EventObject; + using ::com::sun::star::beans::PropertyChangeEvent; + using ::com::sun::star::container::XContainerListener; + using ::com::sun::star::container::XContainer; + using ::com::sun::star::container::ContainerEvent; + using ::com::sun::star::uno::Any; + + namespace { + + class ControlHolder + { + private: + Reference< XControl > m_xControl; + Reference< XWindow2 > m_xControlWindow; + Reference< XView > m_xControlView; + + public: + ControlHolder() + :m_xControl() + ,m_xControlWindow() + ,m_xControlView() + { + } + + explicit ControlHolder( const Reference< XControl >& _rxControl ) + :m_xControl() + ,m_xControlWindow() + ,m_xControlView() + { + *this = _rxControl; + } + + ControlHolder& operator=( const Reference< XControl >& _rxControl ) + { + clear(); + + m_xControl = _rxControl; + if ( m_xControl.is() ) + { + m_xControlWindow.set( m_xControl, UNO_QUERY ); + m_xControlView.set( m_xControl, UNO_QUERY ); + if ( !m_xControlWindow.is() || !m_xControlView.is() ) + { + OSL_FAIL( "ControlHolder::operator=: invalid XControl, missing required interfaces!" ); + clear(); + } + } + + return *this; + } + + public: + bool is() const { return m_xControl.is() && m_xControlWindow.is() && m_xControlView.is(); } + void clear() { m_xControl.clear(); m_xControlWindow.clear(); m_xControlView.clear(); } + + // delegators for the methods of the UNO interfaces + // Note all those will crash if called for a NULL object. + bool isDesignMode() const { return m_xControl->isDesignMode(); } + void setDesignMode( const bool _bDesign ) const { m_xControl->setDesignMode( _bDesign ); } + bool isVisible() const { return m_xControlWindow->isVisible(); } + void setVisible( const bool _bVisible ) const { m_xControlWindow->setVisible( _bVisible ); } + Reference< XControlModel > + getModel() const { return m_xControl->getModel(); } + void setModel( const Reference< XControlModel >& _m ) const { m_xControl->setModel( _m ); } + + void addWindowListener( const Reference< XWindowListener >& _l ) const { m_xControlWindow->addWindowListener( _l ); } + void removeWindowListener( const Reference< XWindowListener >& _l ) const { m_xControlWindow->removeWindowListener( _l ); } + void setPosSize( const tools::Rectangle& _rPosSize ) const; + tools::Rectangle + getPosSize() const; + void setZoom( const ::basegfx::B2DVector& _rScale ) const; + ::basegfx::B2DVector + getZoom() const; + + void invalidate() const; + + public: + const Reference< XControl >& getControl() const { return m_xControl; } + }; + + bool operator==( const ControlHolder& _rControl, const Reference< XInterface >& _rxCompare ) + { + return _rControl.getControl() == _rxCompare; + } + + bool operator==( const ControlHolder& _rControl, const Any& _rxCompare ) + { + return _rControl == Reference< XInterface >( _rxCompare, UNO_QUERY ); + } + + } + + void ControlHolder::setPosSize( const tools::Rectangle& _rPosSize ) const + { + // no check whether we're valid, this is the responsibility of the caller + + // don't call setPosSize when pos/size did not change #i104181# + ::tools::Rectangle aCurrentRect( getPosSize() ); + if ( aCurrentRect != _rPosSize ) + { + m_xControlWindow->setPosSize( + _rPosSize.Left(), _rPosSize.Top(), _rPosSize.GetWidth(), _rPosSize.GetHeight(), + POSSIZE + ); + } + } + + + ::tools::Rectangle ControlHolder::getPosSize() const + { + // no check whether we're valid, this is the responsibility of the caller + return VCLUnoHelper::ConvertToVCLRect( m_xControlWindow->getPosSize() ); + } + + + void ControlHolder::setZoom( const ::basegfx::B2DVector& _rScale ) const + { + // no check whether we're valid, this is the responsibility of the caller + m_xControlView->setZoom( static_cast<float>(_rScale.getX()), static_cast<float>(_rScale.getY()) ); + } + + + void ControlHolder::invalidate() const + { + Reference< XWindowPeer > xPeer( m_xControl->getPeer() ); + if ( xPeer.is() ) + { + VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xPeer ); + OSL_ENSURE( pWindow, "ControlHolder::invalidate: no implementation access!" ); + if ( pWindow ) + pWindow->Invalidate(); + } + } + + + ::basegfx::B2DVector ControlHolder::getZoom() const + { + // no check whether we're valid, this is the responsibility of the caller + + // Argh. Why does XView have a setZoom only, but not a getZoom? + VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( m_xControl->getPeer() ); + OSL_ENSURE( pWindow, "ControlHolder::getZoom: no implementation access!" ); + + ::basegfx::B2DVector aZoom( 1, 1 ); + if ( pWindow ) + { + const Fraction& rZoom( pWindow->GetZoom() ); + aZoom.setX( static_cast<double>(rZoom) ); + aZoom.setY( static_cast<double>(rZoom) ); + } + return aZoom; + } + + namespace UnoControlContactHelper { + + /** positions a control, and sets its zoom mode, using a given transformation and output device + */ + static void adjustControlGeometry_throw( const ControlHolder& _rControl, const tools::Rectangle& _rLogicBoundingRect, + const basegfx::B2DHomMatrix& _rViewTransformation, const ::basegfx::B2DHomMatrix& _rZoomLevelNormalization ) + { + OSL_PRECOND( _rControl.is(), "UnoControlContactHelper::adjustControlGeometry_throw: illegal control!" ); + if ( !_rControl.is() ) + return; + + #if OSL_DEBUG_LEVEL > 0 + ::basegfx::B2DTuple aViewScale, aViewTranslate; + double nViewRotate(0), nViewShearX(0); + _rViewTransformation.decompose( aViewScale, aViewTranslate, nViewRotate, nViewShearX ); + + ::basegfx::B2DTuple aZoomScale, aZoomTranslate; + double nZoomRotate(0), nZoomShearX(0); + _rZoomLevelNormalization.decompose( aZoomScale, aZoomTranslate, nZoomRotate, nZoomShearX ); + #endif + + // transform the logic bound rect, using the view transformation, to pixel coordinates + ::basegfx::B2DPoint aTopLeft( _rLogicBoundingRect.Left(), _rLogicBoundingRect.Top() ); + aTopLeft *= _rViewTransformation; + ::basegfx::B2DPoint aBottomRight( _rLogicBoundingRect.Right(), _rLogicBoundingRect.Bottom() ); + aBottomRight *= _rViewTransformation; + + const tools::Rectangle aPaintRectPixel(static_cast<long>(std::round(aTopLeft.getX())), + static_cast<long>(std::round(aTopLeft.getY())), + static_cast<long>(std::round(aBottomRight.getX())), + static_cast<long>(std::round(aBottomRight.getY()))); + _rControl.setPosSize( aPaintRectPixel ); + + // determine the scale from the current view transformation, and the normalization matrix + ::basegfx::B2DHomMatrix aObtainResolutionDependentScale( _rViewTransformation * _rZoomLevelNormalization ); + ::basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + aObtainResolutionDependentScale.decompose( aScale, aTranslate, fRotate, fShearX ); + _rControl.setZoom( aScale ); + } + + /** disposes the given control + */ + static void disposeAndClearControl_nothrow( ControlHolder& _rControl ) + { + try + { + Reference< XComponent > xControlComp = _rControl.getControl(); + if ( xControlComp.is() ) + xControlComp->dispose(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + _rControl.clear(); + } + + } + + namespace { + + /** interface encapsulating access to an SdrPageView, stripped down to the methods we really need + */ + class IPageViewAccess + { + public: + /** determines whether the view is currently in design mode + */ + virtual bool isDesignMode() const = 0; + + /** retrieves the control container for a given output device + */ + virtual Reference< XControlContainer > + getControlContainer( const OutputDevice& _rDevice ) const = 0; + + /** determines whether a given layer is visible + */ + virtual bool isLayerVisible( SdrLayerID _nLayerID ) const = 0; + + protected: + ~IPageViewAccess() {} + }; + + /** is a ->IPageViewAccess implementation based on a real ->SdrPageView instance + */ + class SdrPageViewAccess : public IPageViewAccess + { + const SdrPageView& m_rPageView; + public: + explicit SdrPageViewAccess( const SdrPageView& _rPageView ) : m_rPageView( _rPageView ) { } + + virtual ~SdrPageViewAccess() {} + + virtual bool isDesignMode() const override; + virtual Reference< XControlContainer > + getControlContainer( const OutputDevice& _rDevice ) const override; + virtual bool isLayerVisible( SdrLayerID _nLayerID ) const override; + }; + + } + + bool SdrPageViewAccess::isDesignMode() const + { + return m_rPageView.GetView().IsDesignMode(); + } + + + Reference< XControlContainer > SdrPageViewAccess::getControlContainer( const OutputDevice& _rDevice ) const + { + Reference< XControlContainer > xControlContainer = m_rPageView.GetControlContainer( _rDevice ); + DBG_ASSERT( xControlContainer.is() || nullptr == m_rPageView.FindPageWindow( _rDevice ), + "SdrPageViewAccess::getControlContainer: the output device is known, but there is no control container for it?" ); + return xControlContainer; + } + + + bool SdrPageViewAccess::isLayerVisible( SdrLayerID _nLayerID ) const + { + return m_rPageView.GetVisibleLayers().IsSet( _nLayerID ); + } + + namespace { + + /** is a ->IPageViewAccess implementation which can be used to create an invisible control for + an arbitrary window + */ + class InvisibleControlViewAccess : public IPageViewAccess + { + private: + Reference< XControlContainer >& m_rControlContainer; + public: + explicit InvisibleControlViewAccess( Reference< XControlContainer >& _inout_ControlContainer ) + :m_rControlContainer( _inout_ControlContainer ) + { + } + + virtual ~InvisibleControlViewAccess() {} + + virtual bool isDesignMode() const override; + virtual Reference< XControlContainer > + getControlContainer( const OutputDevice& _rDevice ) const override; + virtual bool isLayerVisible( SdrLayerID _nLayerID ) const override; + }; + + } + + bool InvisibleControlViewAccess::isDesignMode() const + { + return true; + } + + + Reference< XControlContainer > InvisibleControlViewAccess::getControlContainer( const OutputDevice& _rDevice ) const + { + if ( !m_rControlContainer.is() ) + { + const vcl::Window* pWindow = dynamic_cast< const vcl::Window* >( &_rDevice ); + OSL_ENSURE( pWindow, "InvisibleControlViewAccess::getControlContainer: expected to be called for a window only!" ); + if ( pWindow ) + m_rControlContainer = VCLUnoHelper::CreateControlContainer( const_cast< vcl::Window* >( pWindow ) ); + } + return m_rControlContainer; + } + + + bool InvisibleControlViewAccess::isLayerVisible( SdrLayerID /*_nLayerID*/ ) const + { + return false; + } + + namespace { + + //= DummyPageViewAccess + + /** is a ->IPageViewAccess implementation which can be used to create a control for an arbitrary + non-Window device + + The implementation will report the "PageView" as being in design mode, all layers to be visible, + and will not return any ControlContainer, so all control container related features (notifications etc) + are not available. + */ + class DummyPageViewAccess : public IPageViewAccess + { + public: + DummyPageViewAccess() + { + } + + virtual ~DummyPageViewAccess() {} + + virtual bool isDesignMode() const override; + virtual Reference< XControlContainer > + getControlContainer( const OutputDevice& _rDevice ) const override; + virtual bool isLayerVisible( SdrLayerID _nLayerID ) const override; + }; + + } + + bool DummyPageViewAccess::isDesignMode() const + { + return true; + } + + + Reference< XControlContainer > DummyPageViewAccess::getControlContainer( const OutputDevice& /*_rDevice*/ ) const + { + return nullptr; + } + + + bool DummyPageViewAccess::isLayerVisible( SdrLayerID /*_nLayerID*/ ) const + { + return true; + } + + + //= ViewObjectContactOfUnoControl_Impl + + typedef ::cppu::WeakImplHelper < XWindowListener + , XPropertyChangeListener + , XContainerListener + , XModeChangeListener + > ViewObjectContactOfUnoControl_Impl_Base; + + class ViewObjectContactOfUnoControl_Impl: + public ViewObjectContactOfUnoControl_Impl_Base + { + private: + // tdf#41935 note that access to members is protected with SolarMutex; + // the class previously had its own mutex but that is prone to deadlock + + /// the instance whose IMPL we are + ViewObjectContactOfUnoControl* m_pAntiImpl; + + /// are we currently inside impl_ensureControl_nothrow? + bool m_bCreatingControl; + + /// the control we're responsible for + ControlHolder m_aControl; + + /// the ControlContainer where we inserted our control + Reference< XContainer > m_xContainer; + + /// the output device for which the control was created + VclPtr<OutputDevice> m_pOutputDeviceForWindow; + + /// flag indicating whether the control is currently visible + bool m_bControlIsVisible; + + /// are we currently listening at a design mode control? + bool m_bIsDesignModeListening; + + enum ViewControlMode + { + eDesign, + eAlive, + eUnknown + }; + /// is the control currently in design mode? + mutable ViewControlMode m_eControlDesignMode; + + ::basegfx::B2DHomMatrix m_aZoomLevelNormalization; + + public: + explicit ViewObjectContactOfUnoControl_Impl( ViewObjectContactOfUnoControl* _pAntiImpl ); + ViewObjectContactOfUnoControl_Impl(const ViewObjectContactOfUnoControl_Impl&) = delete; + ViewObjectContactOfUnoControl_Impl& operator=(const ViewObjectContactOfUnoControl_Impl&) = delete; + + /** disposes the instance, which is nonfunctional afterwards + */ + void dispose(); + + /** determines whether the instance is disposed + */ + bool isDisposed() const { return impl_isDisposed_nofail(); } + + /** returns the SdrUnoObject associated with the ViewContact + + @precond + We're not disposed. + */ + bool getUnoObject( SdrUnoObj*& _out_rpObject ) const; + + /** ensures that we have an ->XControl + + Must only be called if a control is needed when no DisplayInfo is present, yet. + + For creating a control, an ->OutputDevice is needed, and an ->SdrPageView. Both will be obtained + from a ->ObjectContactOfPageView. So, if our (anti-impl's) object contact is not a ->ObjectContactOfPageView, + this method fill fail. + + Failure of this method will be reported via an assertion in a non-product version. + */ + void ensureControl( const basegfx::B2DHomMatrix* _pInitialViewTransformationOrNULL ); + + /** returns our XControl, if it already has been created + + If you want to ensure that the control exists before accessing it, use ->ensureControl + */ + const ControlHolder& + getExistentControl() const { return m_aControl; } + + bool + hasControl() const { return m_aControl.is(); } + + /** positions our XControl according to the geometry settings in the SdrUnoObj, modified by the given + transformation, and sets proper zoom settings according to our device + + @precond + ->m_pOutputDeviceForWindow and ->m_aControl are not <NULL/> + */ + void positionAndZoomControl( const basegfx::B2DHomMatrix& _rViewTransformation ) const; + + /** determines whether or not our control is printable + + Effectively, this method returns the value of the "Printable" property + of the control's model. If we have no control, <FALSE/> is returned. + */ + bool isPrintableControl() const; + + /** sets the design mode on the control, or at least remembers the flag for the + time the control is created + */ + void setControlDesignMode( bool _bDesignMode ) const; + + /** determines whether our control is currently visible + @nofail + */ + bool isControlVisible() const { return m_bControlIsVisible; } + + /// creates an XControl for the given device and SdrUnoObj + static bool + createControlForDevice( + IPageViewAccess const & _rPageView, + const OutputDevice& _rDevice, + const SdrUnoObj& _rUnoObject, + const basegfx::B2DHomMatrix& _rInitialViewTransformation, + const basegfx::B2DHomMatrix& _rInitialZoomNormalization, + ControlHolder& _out_rControl + ); + + const ViewContactOfUnoControl& + getViewContact() const + { + ENSURE_OR_THROW( !impl_isDisposed_nofail(), "already disposed" ); + return static_cast< const ViewContactOfUnoControl& >( m_pAntiImpl->GetViewContact() ); + } + + protected: + virtual ~ViewObjectContactOfUnoControl_Impl() override; + + // XEventListener + virtual void SAL_CALL disposing( const EventObject& Source ) override; + + // XWindowListener + virtual void SAL_CALL windowResized( const WindowEvent& e ) override; + virtual void SAL_CALL windowMoved( const WindowEvent& e ) override; + virtual void SAL_CALL windowShown( const EventObject& e ) override; + virtual void SAL_CALL windowHidden( const EventObject& e ) override; + + // XPropertyChangeListener + virtual void SAL_CALL propertyChange( const PropertyChangeEvent& evt ) override; + + // XModeChangeListener + virtual void SAL_CALL modeChanged( const ModeChangeEvent& _rSource ) override; + + // XContainerListener + virtual void SAL_CALL elementInserted( const css::container::ContainerEvent& Event ) override; + virtual void SAL_CALL elementRemoved( const css::container::ContainerEvent& Event ) override; + virtual void SAL_CALL elementReplaced( const css::container::ContainerEvent& Event ) override; + + private: + /** retrieves the SdrPageView which our associated SdrPageViewWindow belongs to + + @param out_rpPageView + a reference to a pointer holding, upon return, the desired SdrPageView + + @return + <TRUE/> if and only if a ->SdrPageView could be obtained + + @precond + We really belong to an SdrPageViewWindow. Perhaps (I'm not sure ATM :) + there are instance for which this might not be true, but those instances + should never have a need to call this method. + + @precond + We're not disposed. + + @postcond + The method expects success, if it returns with <FALSE/>, this will have been + asserted. + + @nothrow + */ + bool impl_getPageView_nothrow( SdrPageView*& _out_rpPageView ); + + /** adjusts the control visibility so it respects its layer's visibility + + @precond + ->m_aControl is not <NULL/> + + @precond + We're not disposed. + + @precond + We really belong to an SdrPageViewWindow. There are instance for which this + might not be true, but those instances should never have a need to call + this method. + */ + void impl_adjustControlVisibilityToLayerVisibility_throw(); + + /** adjusts the control visibility so it respects its layer's visibility + + The control must never be visible if it's in design mode. + In alive mode, it must be visibility if and only it's on a visible layer. + + @param _rxControl + the control whose visibility is to be adjusted + + @param _rPageView + provides access to the attributes of the SdrPageView which the control finally belongs to + + @param _rUnoObject + our SdrUnoObj + + @param _bIsCurrentlyVisible + determines whether the control is currently visible. Note that this is only a shortcut for + querying _rxControl for the XWindow2 interface, and calling isVisible at this interface. + This shortcut has been chosen since the caller usually already has this information. + If _bForce is <TRUE/>, _bIsCurrentlyVisible is ignored. + + @param _bForce + set to <TRUE/> if you want to force a ->XWindow::setVisible call, + no matter if the control visibility is already correct + + @precond + We're not disposed. + */ + static void impl_adjustControlVisibilityToLayerVisibility_throw( const ControlHolder& _rxControl, const SdrUnoObj& _rUnoObject, + IPageViewAccess const & _rPageView, bool _bIsCurrentlyVisible, bool _bForce ); + + /** starts or stops listening at various aspects of our control + + @precond + ->m_aControl is not <NULL/> + */ + void impl_switchControlListening_nothrow( bool _bStart ); + + /** starts or stops listening at our control container + + @precond + ->m_xContainer is not <NULL/> + */ + void impl_switchContainerListening_nothrow( bool _bStart ); + + /** starts or stops listening at the control for design-mode relevant facets + */ + void impl_switchDesignModeListening_nothrow( bool _bStart ); + + /** starts or stops listening for all properties at our control + + @param _bStart + determines whether to start or to stop listening + + @precond + ->m_aControl is not <NULL/> + */ + void impl_switchPropertyListening_nothrow( bool _bStart ); + + /** disposes the instance + @param _bAlsoDisposeControl + determines whether the XControl should be disposed, too + */ + void impl_dispose_nothrow( bool _bAlsoDisposeControl ); + + /** determines whether the instance is disposed + @nofail + */ + bool impl_isDisposed_nofail() const { return m_pAntiImpl == nullptr; } + + /** determines whether the control currently is in design mode + + @precond + The design mode must already be known. It is known when we first had access to + an SdrPageView (which carries this flag), or somebody explicitly set it from + outside. + */ + bool impl_isControlDesignMode_nothrow() const + { + DBG_ASSERT( m_eControlDesignMode != eUnknown, "ViewObjectContactOfUnoControl_Impl::impl_isControlDesignMode_nothrow: mode is still unknown!" ); + return m_eControlDesignMode == eDesign; + } + + /** ensures that we have a control for the given PageView/OutputDevice + */ + bool impl_ensureControl_nothrow( + IPageViewAccess const & _rPageView, + const OutputDevice& _rDevice, + const basegfx::B2DHomMatrix& _rInitialViewTransformation + ); + + const OutputDevice& impl_getOutputDevice_throw() const; + }; + + namespace { + + class LazyControlCreationPrimitive2D : public ::drawinglayer::primitive2d::BufferedDecompositionPrimitive2D + { + private: + typedef ::drawinglayer::primitive2d::BufferedDecompositionPrimitive2D BufferedDecompositionPrimitive2D; + + protected: + virtual void + get2DDecomposition( + ::drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor, + const ::drawinglayer::geometry::ViewInformation2D& rViewInformation + ) const override; + + virtual void create2DDecomposition( + ::drawinglayer::primitive2d::Primitive2DContainer& rContainer, + const ::drawinglayer::geometry::ViewInformation2D& rViewInformation + ) const override; + + virtual ::basegfx::B2DRange + getB2DRange( + const ::drawinglayer::geometry::ViewInformation2D& rViewInformation + ) const override; + + public: + explicit LazyControlCreationPrimitive2D( const ::rtl::Reference< ViewObjectContactOfUnoControl_Impl >& _pVOCImpl ) + :m_pVOCImpl( _pVOCImpl ) + { + ENSURE_OR_THROW( m_pVOCImpl.is(), "Illegal argument." ); + getTransformation( m_pVOCImpl->getViewContact(), m_aTransformation ); + } + + virtual bool operator==(const BasePrimitive2D& rPrimitive) const override; + + // declare unique ID for this primitive class + virtual sal_uInt32 getPrimitive2DID() const override; + + static void getTransformation( const ViewContactOfUnoControl& _rVOC, ::basegfx::B2DHomMatrix& _out_Transformation ); + + private: + void impl_positionAndZoomControl( const ::drawinglayer::geometry::ViewInformation2D& _rViewInformation ) const + { + if ( !_rViewInformation.getViewport().isEmpty() ) + m_pVOCImpl->positionAndZoomControl( _rViewInformation.getObjectToViewTransformation() ); + } + + private: + ::rtl::Reference< ViewObjectContactOfUnoControl_Impl > m_pVOCImpl; + /** The geometry is part of the identity of a primitive, so we cannot calculate it on demand + (since the data the calculation is based on might have changed then), but need to calc + it at construction time, and remember it. + */ + ::basegfx::B2DHomMatrix m_aTransformation; + }; + + } + + ViewObjectContactOfUnoControl_Impl::ViewObjectContactOfUnoControl_Impl( ViewObjectContactOfUnoControl* _pAntiImpl ) + :m_pAntiImpl( _pAntiImpl ) + ,m_bCreatingControl( false ) + ,m_pOutputDeviceForWindow( nullptr ) + ,m_bControlIsVisible( false ) + ,m_bIsDesignModeListening( false ) + ,m_eControlDesignMode( eUnknown ) + ,m_aZoomLevelNormalization() + { + DBG_ASSERT( m_pAntiImpl, "ViewObjectContactOfUnoControl_Impl::ViewObjectContactOfUnoControl_Impl: invalid AntiImpl!" ); + + const OutputDevice& rPageViewDevice( impl_getOutputDevice_throw() ); + m_aZoomLevelNormalization = rPageViewDevice.GetInverseViewTransformation(); + + #if OSL_DEBUG_LEVEL > 0 + ::basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + m_aZoomLevelNormalization.decompose( aScale, aTranslate, fRotate, fShearX ); + #endif + + ::basegfx::B2DHomMatrix aScaleNormalization; + const MapMode& aCurrentDeviceMapMode( rPageViewDevice.GetMapMode() ); + aScaleNormalization.set( 0, 0, static_cast<double>(aCurrentDeviceMapMode.GetScaleX()) ); + aScaleNormalization.set( 1, 1, static_cast<double>(aCurrentDeviceMapMode.GetScaleY()) ); + m_aZoomLevelNormalization *= aScaleNormalization; + + #if OSL_DEBUG_LEVEL > 0 + m_aZoomLevelNormalization.decompose( aScale, aTranslate, fRotate, fShearX ); + #endif + } + + + ViewObjectContactOfUnoControl_Impl::~ViewObjectContactOfUnoControl_Impl() + { + if ( !impl_isDisposed_nofail() ) + { + acquire(); + dispose(); + } + + } + + + void ViewObjectContactOfUnoControl_Impl::impl_dispose_nothrow( bool _bAlsoDisposeControl ) + { + if ( impl_isDisposed_nofail() ) + return; + + if ( m_aControl.is() ) + impl_switchControlListening_nothrow( false ); + + if ( m_xContainer.is() ) + impl_switchContainerListening_nothrow( false ); + + // dispose the control + if ( _bAlsoDisposeControl ) + UnoControlContactHelper::disposeAndClearControl_nothrow( m_aControl ); + + m_aControl.clear(); + m_xContainer.clear(); + m_pOutputDeviceForWindow = nullptr; + m_bControlIsVisible = false; + + m_pAntiImpl = nullptr; + } + + + void ViewObjectContactOfUnoControl_Impl::dispose() + { + SolarMutexGuard aSolarGuard; + impl_dispose_nothrow( true ); + } + + + bool ViewObjectContactOfUnoControl_Impl::getUnoObject( SdrUnoObj*& _out_rpObject ) const + { + OSL_PRECOND( !impl_isDisposed_nofail(), "ViewObjectContactOfUnoControl_Impl::getUnoObject: already disposed()" ); + if ( impl_isDisposed_nofail() ) + _out_rpObject = nullptr; + else + { + _out_rpObject = dynamic_cast< SdrUnoObj* >( m_pAntiImpl->GetViewContact().TryToGetSdrObject() ); + DBG_ASSERT( _out_rpObject || !m_pAntiImpl->GetViewContact().TryToGetSdrObject(), + "ViewObjectContactOfUnoControl_Impl::getUnoObject: invalid SdrObject!" ); + } + return ( _out_rpObject != nullptr ); + } + + + void ViewObjectContactOfUnoControl_Impl::positionAndZoomControl( const basegfx::B2DHomMatrix& _rViewTransformation ) const + { + OSL_PRECOND( m_aControl.is(), "ViewObjectContactOfUnoControl_Impl::positionAndZoomControl: no output device or no control!" ); + if ( !m_aControl.is() ) + return; + + try + { + SdrUnoObj* pUnoObject( nullptr ); + if ( getUnoObject( pUnoObject ) ) + { + const tools::Rectangle aRect( pUnoObject->GetLogicRect() ); + UnoControlContactHelper::adjustControlGeometry_throw( m_aControl, aRect, _rViewTransformation, m_aZoomLevelNormalization ); + } + else + OSL_FAIL( "ViewObjectContactOfUnoControl_Impl::positionAndZoomControl: no SdrUnoObj!" ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void ViewObjectContactOfUnoControl_Impl::ensureControl( const basegfx::B2DHomMatrix* _pInitialViewTransformationOrNULL ) + { + OSL_PRECOND( !impl_isDisposed_nofail(), "ViewObjectContactOfUnoControl_Impl::ensureControl: already disposed()" ); + if ( impl_isDisposed_nofail() ) + return; + + ObjectContactOfPageView* pPageViewContact = dynamic_cast< ObjectContactOfPageView* >( &m_pAntiImpl->GetObjectContact() ); + if ( pPageViewContact ) + { + SdrPageViewAccess aPVAccess( pPageViewContact->GetPageWindow().GetPageView() ); + const OutputDevice& rDevice( *m_pAntiImpl->getPageViewOutputDevice() ); + impl_ensureControl_nothrow( + aPVAccess, + rDevice, + _pInitialViewTransformationOrNULL ? *_pInitialViewTransformationOrNULL : rDevice.GetViewTransformation() + ); + return; + } + + DummyPageViewAccess aNoPageView; + const OutputDevice& rDevice( impl_getOutputDevice_throw() ); + impl_ensureControl_nothrow( + aNoPageView, + rDevice, + _pInitialViewTransformationOrNULL ? *_pInitialViewTransformationOrNULL : rDevice.GetViewTransformation() + ); + } + + + const OutputDevice& ViewObjectContactOfUnoControl_Impl::impl_getOutputDevice_throw() const + { + // do not use ObjectContact::TryToGetOutputDevice, it would not care for the PageWindow's + // OriginalPaintWindow + const OutputDevice* oPageOutputDev = m_pAntiImpl->getPageViewOutputDevice(); + if( oPageOutputDev ) + return *oPageOutputDev; + + const OutputDevice* pDevice = m_pAntiImpl->GetObjectContact().TryToGetOutputDevice(); + ENSURE_OR_THROW( pDevice, "no output device -> no control" ); + return *pDevice; + } + + + namespace + { + void lcl_resetFlag( bool& rbFlag ) + { + rbFlag = false; + } + } + + + bool ViewObjectContactOfUnoControl_Impl::impl_ensureControl_nothrow( IPageViewAccess const & _rPageView, const OutputDevice& _rDevice, + const basegfx::B2DHomMatrix& _rInitialViewTransformation ) + { + if ( m_bCreatingControl ) + { + OSL_FAIL( "ViewObjectContactOfUnoControl_Impl::impl_ensureControl_nothrow: reentrance is not really good here!" ); + // We once had a situation where this was called reentrantly, which lead to all kind of strange effects. All + // those affected the grid control, which is the only control so far which is visible in design mode (and + // not only in alive mode). + // Creating the control triggered a Window::Update on some of its child windows, which triggered a + // Paint on parent of the grid control (e.g. the SwEditWin), which triggered a reentrant call to this method, + // which it is not really prepared for. + + // /me thinks that re-entrance should be caught on a higher level, i.e. the Drawing Layer should not allow + // reentrant paint requests. For the moment, until /me can discuss this with AW, catch it here. #i104544# + return false; + } + + m_bCreatingControl = true; + ::comphelper::ScopeGuard aGuard([&] () { lcl_resetFlag(m_bCreatingControl); }); + + if ( m_aControl.is() ) + { + if ( m_pOutputDeviceForWindow.get() == &_rDevice ) + return true; + + // Somebody requested a control for a new device, which means either of + // - our PageView's paint window changed since we were last here + // - we don't belong to a page view, and are simply painted onto different devices + // The first sounds strange (doesn't it?), the second means we could perhaps + // optimize this in the future - there is no need to re-create the control every time, + // is it? #i74523# + if ( m_xContainer.is() ) + impl_switchContainerListening_nothrow( false ); + impl_switchControlListening_nothrow( false ); + UnoControlContactHelper::disposeAndClearControl_nothrow( m_aControl ); + } + + SdrUnoObj* pUnoObject( nullptr ); + if ( !getUnoObject( pUnoObject ) ) + return false; + + ControlHolder aControl; + if ( !createControlForDevice( _rPageView, _rDevice, *pUnoObject, _rInitialViewTransformation, m_aZoomLevelNormalization, aControl ) ) + return false; + + m_pOutputDeviceForWindow = const_cast< OutputDevice * >( &_rDevice ); + m_aControl = aControl; + m_xContainer.set(_rPageView.getControlContainer( _rDevice ), css::uno::UNO_QUERY); + DBG_ASSERT( ( m_xContainer.is() // either have a XControlContainer + || ( ( !_rPageView.getControlContainer( _rDevice ).is() ) // or don't have any container, + && ( dynamic_cast< const vcl::Window* >( &_rDevice ) == nullptr ) // which is allowed for non-Window instances only + ) + ), + "ViewObjectContactOfUnoControl_Impl::impl_ensureControl_nothrow: no XContainer at the ControlContainer!" ); + + try + { + m_eControlDesignMode = m_aControl.isDesignMode() ? eDesign : eAlive; + m_bControlIsVisible = m_aControl.isVisible(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + // start listening at all aspects of the control which are interesting to us ... + impl_switchControlListening_nothrow( true ); + + // start listening at the control container, in case somebody tampers with our control + if ( m_xContainer.is() ) + impl_switchContainerListening_nothrow( true ); + + return m_aControl.is(); + } + + + bool ViewObjectContactOfUnoControl_Impl::createControlForDevice( IPageViewAccess const & _rPageView, + const OutputDevice& _rDevice, const SdrUnoObj& _rUnoObject, const basegfx::B2DHomMatrix& _rInitialViewTransformation, + const basegfx::B2DHomMatrix& _rInitialZoomNormalization, ControlHolder& _out_rControl ) + { + _out_rControl.clear(); + + const Reference< XControlModel >& xControlModel( _rUnoObject.GetUnoControlModel() ); + DBG_ASSERT( xControlModel.is(), "ViewObjectContactOfUnoControl_Impl::createControlForDevice: no control model at the SdrUnoObject!?" ); + if ( !xControlModel.is() ) + return false; + + bool bSuccess = false; + try + { + const OUString& sControlServiceName( _rUnoObject.GetUnoControlTypeName() ); + + Reference< css::uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + _out_rControl = Reference<XControl>( xContext->getServiceManager()->createInstanceWithContext(sControlServiceName, xContext), UNO_QUERY_THROW ); + + // knit the model and the control + _out_rControl.setModel( xControlModel ); + const tools::Rectangle aRect( _rUnoObject.GetLogicRect() ); + + // proper geometry + UnoControlContactHelper::adjustControlGeometry_throw( + _out_rControl, + aRect, + _rInitialViewTransformation, + _rInitialZoomNormalization + ); + + // set design mode before peer is created, + // this is also needed for accessibility + _out_rControl.setDesignMode( _rPageView.isDesignMode() ); + + // adjust the initial visibility according to the visibility of the layer + impl_adjustControlVisibilityToLayerVisibility_throw( _out_rControl, _rUnoObject, _rPageView, false, true ); + + // add the control to the respective control container + // do this last + Reference< XControlContainer > xControlContainer( _rPageView.getControlContainer( _rDevice ) ); + if ( xControlContainer.is() ) + xControlContainer->addControl( sControlServiceName, _out_rControl.getControl() ); + + bSuccess = true; + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + + if ( !bSuccess ) + { + // delete the control which might have been created already + UnoControlContactHelper::disposeAndClearControl_nothrow( _out_rControl ); + } + + return _out_rControl.is(); + } + + + bool ViewObjectContactOfUnoControl_Impl::impl_getPageView_nothrow( SdrPageView*& _out_rpPageView ) + { + OSL_PRECOND( !impl_isDisposed_nofail(), "ViewObjectContactOfUnoControl_Impl::impl_getPageView_nothrow: already disposed!" ); + + _out_rpPageView = nullptr; + if ( impl_isDisposed_nofail() ) + return false; + + ObjectContactOfPageView* pPageViewContact = dynamic_cast< ObjectContactOfPageView* >( &m_pAntiImpl->GetObjectContact() ); + if ( pPageViewContact ) + _out_rpPageView = &pPageViewContact->GetPageWindow().GetPageView(); + + DBG_ASSERT( _out_rpPageView != nullptr, "ViewObjectContactOfUnoControl_Impl::impl_getPageView_nothrow: this method is expected to always have success!" ); + return ( _out_rpPageView != nullptr ); + } + + + void ViewObjectContactOfUnoControl_Impl::impl_adjustControlVisibilityToLayerVisibility_throw() + { + OSL_PRECOND( m_aControl.is(), + "ViewObjectContactOfUnoControl_Impl::impl_adjustControlVisibilityToLayerVisibility_throw: only valid if we have a control!" ); + + SdrPageView* pPageView( nullptr ); + if ( !impl_getPageView_nothrow( pPageView ) ) + return; + + SdrUnoObj* pUnoObject( nullptr ); + if ( !getUnoObject( pUnoObject ) ) + return; + + SdrPageViewAccess aPVAccess( *pPageView ); + impl_adjustControlVisibilityToLayerVisibility_throw( m_aControl, *pUnoObject, aPVAccess, m_bControlIsVisible, false/*_bForce*/ ); + } + + + void ViewObjectContactOfUnoControl_Impl::impl_adjustControlVisibilityToLayerVisibility_throw( const ControlHolder& _rControl, + const SdrUnoObj& _rUnoObject, IPageViewAccess const & _rPageView, bool _bIsCurrentlyVisible, bool _bForce ) + { + // in design mode, there is no problem with the visibility: The XControl is hidden by + // default, and the Drawing Layer will simply not call our paint routine, if we're in + // a hidden layer. So, only alive mode matters. + if ( !_rControl.isDesignMode() ) + { + // the layer of our object + SdrLayerID nObjectLayer = _rUnoObject.GetLayer(); + // is the object we're residing in visible in this view? + bool bIsObjectVisible = _rUnoObject.IsVisible() && _rPageView.isLayerVisible( nObjectLayer ); + + if ( _bForce || ( bIsObjectVisible != _bIsCurrentlyVisible ) ) + { + _rControl.setVisible( bIsObjectVisible ); + } + } + } + + + void ViewObjectContactOfUnoControl_Impl::impl_switchContainerListening_nothrow( bool _bStart ) + { + OSL_PRECOND( m_xContainer.is(), "ViewObjectContactOfUnoControl_Impl::impl_switchContainerListening_nothrow: no control container!" ); + if ( !m_xContainer.is() ) + return; + + try + { + if ( _bStart ) + m_xContainer->addContainerListener( this ); + else + m_xContainer->removeContainerListener( this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void ViewObjectContactOfUnoControl_Impl::impl_switchControlListening_nothrow( bool _bStart ) + { + OSL_PRECOND( m_aControl.is(), "ViewObjectContactOfUnoControl_Impl::impl_switchControlListening_nothrow: invalid control!" ); + if ( !m_aControl.is() ) + return; + + try + { + // listen for visibility changes + if ( _bStart ) + m_aControl.addWindowListener( this ); + else + m_aControl.removeWindowListener( this ); + + // in design mode, listen for some more aspects + impl_switchDesignModeListening_nothrow( impl_isControlDesignMode_nothrow() && _bStart ); + + // listen for design mode changes + Reference< XModeChangeBroadcaster > xDesignModeChanges( m_aControl.getControl(), UNO_QUERY_THROW ); + if ( _bStart ) + xDesignModeChanges->addModeChangeListener( this ); + else + xDesignModeChanges->removeModeChangeListener( this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void ViewObjectContactOfUnoControl_Impl::impl_switchDesignModeListening_nothrow( bool _bStart ) + { + if ( m_bIsDesignModeListening != _bStart ) + { + m_bIsDesignModeListening = _bStart; + impl_switchPropertyListening_nothrow( _bStart ); + } + } + + + void ViewObjectContactOfUnoControl_Impl::impl_switchPropertyListening_nothrow( bool _bStart ) + { + OSL_PRECOND( m_aControl.is(), "ViewObjectContactOfUnoControl_Impl::impl_switchPropertyListening_nothrow: no control!" ); + if ( !m_aControl.is() ) + return; + + try + { + Reference< XPropertySet > xModelProperties( m_aControl.getModel(), UNO_QUERY_THROW ); + if ( _bStart ) + xModelProperties->addPropertyChangeListener( OUString(), this ); + else + xModelProperties->removePropertyChangeListener( OUString(), this ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + bool ViewObjectContactOfUnoControl_Impl::isPrintableControl() const + { + SdrUnoObj* pUnoObject( nullptr ); + if ( !getUnoObject( pUnoObject ) ) + return false; + + bool bIsPrintable = false; + try + { + Reference< XPropertySet > xModelProperties( pUnoObject->GetUnoControlModel(), UNO_QUERY_THROW ); + OSL_VERIFY( xModelProperties->getPropertyValue( "Printable" ) >>= bIsPrintable ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + return bIsPrintable; + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::disposing( const EventObject& Source ) + { + SolarMutexGuard aSolarGuard; + // some code below - in particular our disposal - might trigger actions which require the + // SolarMutex. In particular, in our disposal, we remove ourself as listener from the control, + // which alone needs the SolarMutex. Of course this - a removeFooListener needed the SolarMutex - + // is the real bug. Toolkit really is infested with solar mutex usage ... :( #i82169# + + if ( !m_aControl.is() ) + return; + + if ( ( m_aControl == Source.Source ) + || ( m_aControl.getModel() == Source.Source ) + ) + { + // the model or the control is dying ... hmm, not much sense in that we ourself continue + // living + impl_dispose_nothrow( false ); + return; + } + + DBG_ASSERT( Source.Source == m_xContainer, "ViewObjectContactOfUnoControl_Impl::disposing: Who's this?" ); + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::windowResized( const WindowEvent& /*e*/ ) + { + // not interested in + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::windowMoved( const WindowEvent& /*e*/ ) + { + // not interested in + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::windowShown( const EventObject& /*e*/ ) + { + SolarMutexGuard aSolarGuard; + m_bControlIsVisible = true; + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::windowHidden( const EventObject& /*e*/ ) + { + SolarMutexGuard aSolarGuard; + m_bControlIsVisible = false; + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::propertyChange( const PropertyChangeEvent& /*_rEvent*/ ) + { + SolarMutexGuard aSolarGuard; + // (re)painting might require VCL operations, which need the SolarMutex + + OSL_PRECOND( !impl_isDisposed_nofail(), "ViewObjectContactOfUnoControl_Impl::propertyChange: already disposed()" ); + if ( impl_isDisposed_nofail() ) + return; + + DBG_ASSERT( m_aControl.is(), "ViewObjectContactOfUnoControl_Impl::propertyChange: " ); + if ( !m_aControl.is() ) + return; + + // a generic property changed. If we're in design mode, we need to repaint the control + if ( impl_isControlDesignMode_nothrow() ) + { + m_pAntiImpl->propertyChange(); + } + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::modeChanged( const ModeChangeEvent& _rSource ) + { + SolarMutexGuard aSolarGuard; + + DBG_ASSERT( _rSource.NewMode == "design" || _rSource.NewMode == "alive", "ViewObjectContactOfUnoControl_Impl::modeChanged: unexpected mode!" ); + + m_eControlDesignMode = _rSource.NewMode == "design" ? eDesign : eAlive; + + impl_switchDesignModeListening_nothrow( impl_isControlDesignMode_nothrow() ); + + try + { + // if the control is part of an invisible layer, we need to explicitly hide it in alive mode + impl_adjustControlVisibilityToLayerVisibility_throw(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::elementInserted( const ContainerEvent& /*_Event*/ ) + { + // not interested in + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::elementRemoved( const ContainerEvent& Event ) + { + SolarMutexGuard aSolarGuard; + // some code below - in particular our disposal - might trigger actions which require the + // SolarMutex. In particular, in our disposal, we remove ourself as listener from the control, + // which alone needs the SolarMutex. Of course this - a removeFooListener needed the SolarMutex - + // is the real bug. Toolkit really is infested with solar mutex usage ... :( #i82169# + DBG_ASSERT( Event.Source == m_xContainer, "ViewObjectContactOfUnoControl_Impl::elementRemoved: where did this come from?" ); + + if ( m_aControl == Event.Element ) + impl_dispose_nothrow( false ); + } + + + void SAL_CALL ViewObjectContactOfUnoControl_Impl::elementReplaced( const ContainerEvent& Event ) + { + SolarMutexGuard aSolarGuard; + DBG_ASSERT( Event.Source == m_xContainer, "ViewObjectContactOfUnoControl_Impl::elementReplaced: where did this come from?" ); + + if ( ! ( m_aControl == Event.ReplacedElement ) ) + return; + + Reference< XControl > xNewControl( Event.Element, UNO_QUERY ); + DBG_ASSERT( xNewControl.is(), "ViewObjectContactOfUnoControl_Impl::elementReplaced: invalid new control!" ); + if ( !xNewControl.is() ) + return; + + ENSURE_OR_THROW( m_pOutputDeviceForWindow, "calling this without /me having an output device should be impossible." ); + + DBG_ASSERT( xNewControl->getModel() == m_aControl.getModel(), "ViewObjectContactOfUnoControl_Impl::elementReplaced: another model at the new control?" ); + // another model should - in the drawing layer - also imply another SdrUnoObj, which + // should also result in new ViewContact, and thus in new ViewObjectContacts + + impl_switchControlListening_nothrow( false ); + + ControlHolder aNewControl( xNewControl ); + aNewControl.setZoom( m_aControl.getZoom() ); + aNewControl.setPosSize( m_aControl.getPosSize() ); + aNewControl.setDesignMode( impl_isControlDesignMode_nothrow() ); + + m_aControl = xNewControl; + m_bControlIsVisible = m_aControl.isVisible(); + + impl_switchControlListening_nothrow( true ); + + m_pAntiImpl->onControlChangedOrModified( ViewObjectContactOfUnoControl::ImplAccess() ); + } + + + void ViewObjectContactOfUnoControl_Impl::setControlDesignMode( bool _bDesignMode ) const + { + if ( ( m_eControlDesignMode != eUnknown ) && ( _bDesignMode == impl_isControlDesignMode_nothrow() ) ) + // nothing to do + return; + m_eControlDesignMode = _bDesignMode ? eDesign : eAlive; + + if ( !m_aControl.is() ) + // nothing to do, the setting will be respected as soon as the control + // is created + return; + + try + { + m_aControl.setDesignMode( _bDesignMode ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + //= LazyControlCreationPrimitive2D + + + bool LazyControlCreationPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if ( !BufferedDecompositionPrimitive2D::operator==( rPrimitive ) ) + return false; + + const LazyControlCreationPrimitive2D* pRHS = dynamic_cast< const LazyControlCreationPrimitive2D* >( &rPrimitive ); + if ( !pRHS ) + return false; + + if ( m_pVOCImpl != pRHS->m_pVOCImpl ) + return false; + + if ( m_aTransformation != pRHS->m_aTransformation ) + return false; + + return true; + } + + + void LazyControlCreationPrimitive2D::getTransformation( const ViewContactOfUnoControl& _rVOC, ::basegfx::B2DHomMatrix& _out_Transformation ) + { + // Do use model data directly to create the correct geometry. Do NOT + // use getBoundRect()/getSnapRect() here; these will use the sequence of + // primitives themselves in the long run. + const tools::Rectangle aSdrGeoData( _rVOC.GetSdrUnoObj().GetGeoRect() ); + const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(aSdrGeoData); + + _out_Transformation.identity(); + _out_Transformation.set( 0, 0, aRange.getWidth() ); + _out_Transformation.set( 1, 1, aRange.getHeight() ); + _out_Transformation.set( 0, 2, aRange.getMinX() ); + _out_Transformation.set( 1, 2, aRange.getMinY() ); + } + + + ::basegfx::B2DRange LazyControlCreationPrimitive2D::getB2DRange( const ::drawinglayer::geometry::ViewInformation2D& /*rViewInformation*/ ) const + { + ::basegfx::B2DRange aRange( 0.0, 0.0, 1.0, 1.0 ); + aRange.transform( m_aTransformation ); + return aRange; + } + + + void LazyControlCreationPrimitive2D::get2DDecomposition( ::drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor, const ::drawinglayer::geometry::ViewInformation2D& _rViewInformation ) const + { + #if OSL_DEBUG_LEVEL > 0 + ::basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + _rViewInformation.getObjectToViewTransformation().decompose( aScale, aTranslate, fRotate, fShearX ); + #endif + if ( m_pVOCImpl->hasControl() ) + impl_positionAndZoomControl( _rViewInformation ); + BufferedDecompositionPrimitive2D::get2DDecomposition( rVisitor, _rViewInformation ); + } + + + void LazyControlCreationPrimitive2D::create2DDecomposition( ::drawinglayer::primitive2d::Primitive2DContainer& rContainer, const ::drawinglayer::geometry::ViewInformation2D& _rViewInformation ) const + { + #if OSL_DEBUG_LEVEL > 0 + ::basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + _rViewInformation.getObjectToViewTransformation().decompose( aScale, aTranslate, fRotate, fShearX ); + #endif + const bool bHadControl = m_pVOCImpl->getExistentControl().is(); + + // force control here to make it a VCL ChildWindow. Will be fetched + // and used below by getExistentControl() + m_pVOCImpl->ensureControl( &_rViewInformation.getObjectToViewTransformation() ); + impl_positionAndZoomControl( _rViewInformation ); + + // get needed data + const ViewContactOfUnoControl& rViewContactOfUnoControl( m_pVOCImpl->getViewContact() ); + Reference< XControlModel > xControlModel( rViewContactOfUnoControl.GetSdrUnoObj().GetUnoControlModel() ); + const ControlHolder& rControl( m_pVOCImpl->getExistentControl() ); + + if ( !bHadControl && rControl.is() && rControl.isVisible() ) + rControl.invalidate(); + + // check if we already have an XControl. + if ( !xControlModel.is() || !rControl.is() ) + { + // use the default mechanism. This will create a ControlPrimitive2D without + // handing over a XControl. If not even a XControlModel exists, it will + // create the SdrObject fallback visualisation + const drawinglayer::primitive2d::Primitive2DContainer& aTmp = rViewContactOfUnoControl.getViewIndependentPrimitive2DContainer(); + rContainer.insert(rContainer.end(), aTmp.begin(), aTmp.end()); + return; + } + + // create a primitive and hand over the existing xControl. This will + // allow the primitive to not need to create another one on demand. + rContainer.push_back( new ::drawinglayer::primitive2d::ControlPrimitive2D( + m_aTransformation, xControlModel, rControl.getControl() ) ); + } + + + ImplPrimitive2DIDBlock( LazyControlCreationPrimitive2D, PRIMITIVE2D_ID_SDRCONTROLPRIMITIVE2D ) + + ViewObjectContactOfUnoControl::ViewObjectContactOfUnoControl( ObjectContact& _rObjectContact, ViewContactOfUnoControl& _rViewContact ) + :ViewObjectContactOfSdrObj( _rObjectContact, _rViewContact ) + ,m_pImpl( new ViewObjectContactOfUnoControl_Impl( this ) ) + { + } + + + ViewObjectContactOfUnoControl::~ViewObjectContactOfUnoControl() + { + m_pImpl->dispose(); + m_pImpl = nullptr; + + } + + + Reference< XControl > ViewObjectContactOfUnoControl::getControl() + { + SolarMutexGuard aSolarGuard; + m_pImpl->ensureControl( nullptr ); + return m_pImpl->getExistentControl().getControl(); + } + + + Reference< XControl > ViewObjectContactOfUnoControl::getTemporaryControlForWindow( + const vcl::Window& _rWindow, Reference< XControlContainer >& _inout_ControlContainer, const SdrUnoObj& _rUnoObject ) + { + ControlHolder aControl; + + InvisibleControlViewAccess aSimulatePageView( _inout_ControlContainer ); + OSL_VERIFY( ViewObjectContactOfUnoControl_Impl::createControlForDevice( aSimulatePageView, _rWindow, _rUnoObject, + _rWindow.GetViewTransformation(), _rWindow.GetInverseViewTransformation(), aControl ) ); + return aControl.getControl(); + } + + + void ViewObjectContactOfUnoControl::ensureControlVisibility( bool _bVisible ) const + { + SolarMutexGuard aSolarGuard; + + try + { + const ControlHolder& rControl( m_pImpl->getExistentControl() ); + if ( !rControl.is() ) + return; + + // only need to care for alive mode + if ( rControl.isDesignMode() ) + return; + + // is the visibility correct? + if ( m_pImpl->isControlVisible() == _bVisible ) + return; + + // no -> adjust it + rControl.setVisible( _bVisible ); + DBG_ASSERT( m_pImpl->isControlVisible() == _bVisible, "ViewObjectContactOfUnoControl::ensureControlVisibility: this didn't work!" ); + // now this would mean that either isControlVisible is not reliable, + // or that showing/hiding the window did not work as intended. + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + + + void ViewObjectContactOfUnoControl::setControlDesignMode( bool _bDesignMode ) const + { + SolarMutexGuard aSolarGuard; + m_pImpl->setControlDesignMode( _bDesignMode ); + + if(!_bDesignMode) + { + // when live mode is switched on, a refresh is needed. The edit mode visualisation + // needs to be repainted and the now used VCL-Window needs to be positioned and + // sized. Both is done from the repaint refresh. + const_cast< ViewObjectContactOfUnoControl* >(this)->ActionChanged(); + } + } + + + drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactOfUnoControl::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const + { + if ( m_pImpl->isDisposed() ) + // our control already died. + // TODO: Is it worth re-creating the control? Finally, this is a pathological situation, it means some instance + // disposed the control though it doesn't own it. So, /me thinks we should not bother here. + return drawinglayer::primitive2d::Primitive2DContainer(); + + if ( GetObjectContact().getViewInformation2D().getViewTransformation().isIdentity() ) + // remove this when #i115754# is fixed + return drawinglayer::primitive2d::Primitive2DContainer(); + + // ignore existing controls which are in alive mode and manually switched to "invisible" #i102090# + const ControlHolder& rControl( m_pImpl->getExistentControl() ); + if ( rControl.is() && !rControl.isDesignMode() && !rControl.isVisible() ) + return drawinglayer::primitive2d::Primitive2DContainer(); + + ::drawinglayer::primitive2d::Primitive2DReference xPrimitive( new LazyControlCreationPrimitive2D( m_pImpl ) ); + return ::drawinglayer::primitive2d::Primitive2DContainer { xPrimitive }; + } + + + bool ViewObjectContactOfUnoControl::isPrimitiveVisible( const DisplayInfo& _rDisplayInfo ) const + { + SolarMutexGuard aSolarGuard; + + if ( m_pImpl->hasControl() ) + { + const ::drawinglayer::geometry::ViewInformation2D& rViewInformation( GetObjectContact().getViewInformation2D() ); + #if OSL_DEBUG_LEVEL > 0 + ::basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rViewInformation.getObjectToViewTransformation().decompose( aScale, aTranslate, fRotate, fShearX ); + #endif + + if ( !rViewInformation.getViewport().isEmpty() ) + { + // tdf#121963 check and eventually pre-multiply ViewTransformation + // with GridOffset transformation to avoid alternating positions of + // FormControls which are victims of the non-linear calc ViewTransformation + // aka GridOffset. For other paths (e.g. repaint) this is included already + // as part of the object's sequence of B2DPrimitive - representation + // (see ViewObjectContact::getPrimitive2DSequence and how getGridOffset is used there) + basegfx::B2DHomMatrix aViewTransformation(rViewInformation.getObjectToViewTransformation()); + + if(GetObjectContact().supportsGridOffsets()) + { + const basegfx::B2DVector& rGridOffset(getGridOffset()); + + if(0.0 != rGridOffset.getX() || 0.0 != rGridOffset.getY()) + { + // pre-multiply: GridOffset needs to be applied directly to logic model data + // of object coordinates, so multiply GridOffset from right to make it + // work as 1st change - these objects may still be part of groups/hierarchies + aViewTransformation = aViewTransformation * basegfx::utils::createTranslateB2DHomMatrix(rGridOffset); + } + } + + m_pImpl->positionAndZoomControl(aViewTransformation); + } + } + + return ViewObjectContactOfSdrObj::isPrimitiveVisible( _rDisplayInfo ); + } + + + void ViewObjectContactOfUnoControl::propertyChange() + { + impl_onControlChangedOrModified(); + } + + + void ViewObjectContactOfUnoControl::ActionChanged() + { + // call parent + ViewObjectContactOfSdrObj::ActionChanged(); + const ControlHolder& rControl(m_pImpl->getExistentControl()); + + if(rControl.is() && !rControl.isDesignMode()) + { + // #i93180# if layer visibility has changed and control is in live mode, it is necessary + // to correct visibility to make those control vanish on SdrObject LayerID changes + const SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView(); + + if(pSdrPageView) + { + const SdrObject& rObject = getSdrObject(); + const bool bIsLayerVisible( rObject.IsVisible() && pSdrPageView->GetVisibleLayers().IsSet(rObject.GetLayer())); + + if(rControl.isVisible() != bIsLayerVisible) + { + rControl.setVisible(bIsLayerVisible); + } + } + } + } + + + void ViewObjectContactOfUnoControl::impl_onControlChangedOrModified() + { + // graphical invalidate at all views + ActionChanged(); + + // #i93318# flush Primitive2DContainer to force recreation with updated XControlModel + // since e.g. background color has changed and existing decompositions are possibly no + // longer valid. Unfortunately this is not detected from ControlPrimitive2D::operator== + // since it only has a uno reference to the XControlModel + flushPrimitive2DSequence(); + } + + UnoControlPrintOrPreviewContact::UnoControlPrintOrPreviewContact( ObjectContactOfPageView& _rObjectContact, ViewContactOfUnoControl& _rViewContact ) + :ViewObjectContactOfUnoControl( _rObjectContact, _rViewContact ) + { + } + + + UnoControlPrintOrPreviewContact::~UnoControlPrintOrPreviewContact() + { + } + + + drawinglayer::primitive2d::Primitive2DContainer UnoControlPrintOrPreviewContact::createPrimitive2DSequence(const DisplayInfo& rDisplayInfo ) const + { + if ( !m_pImpl->isPrintableControl() ) + return drawinglayer::primitive2d::Primitive2DContainer(); + return ViewObjectContactOfUnoControl::createPrimitive2DSequence( rDisplayInfo ); + } + + +} // namespace sdr::contact + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/contact/viewobjectcontactredirector.cxx b/svx/source/sdr/contact/viewobjectcontactredirector.cxx new file mode 100644 index 000000000..59817d926 --- /dev/null +++ b/svx/source/sdr/contact/viewobjectcontactredirector.cxx @@ -0,0 +1,44 @@ +/* -*- 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 <svx/sdr/contact/viewobjectcontactredirector.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> + +namespace sdr::contact { + +// basic constructor. +ViewObjectContactRedirector::ViewObjectContactRedirector() +{ +} + +// The destructor. +ViewObjectContactRedirector::~ViewObjectContactRedirector() +{ +} + +drawinglayer::primitive2d::Primitive2DContainer ViewObjectContactRedirector::createRedirectedPrimitive2DSequence( + const sdr::contact::ViewObjectContact& rOriginal, + const sdr::contact::DisplayInfo& rDisplayInfo) +{ + return rOriginal.createPrimitive2DSequence(rDisplayInfo); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/misc/ImageMapInfo.cxx b/svx/source/sdr/misc/ImageMapInfo.cxx new file mode 100644 index 000000000..e396dc958 --- /dev/null +++ b/svx/source/sdr/misc/ImageMapInfo.cxx @@ -0,0 +1,120 @@ +/* -*- 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 <svx/ImageMapInfo.hxx> + +#include <svx/svdobj.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdoole2.hxx> +#include <vcl/imapobj.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> + +SvxIMapInfo* SvxIMapInfo::GetIMapInfo(SdrObject const* pObject) +{ + assert(pObject); + + SvxIMapInfo* pIMapInfo = nullptr; + sal_uInt16 nCount = pObject->GetUserDataCount(); + + // Can we find IMap information within the user data? + for (sal_uInt16 i = 0; i < nCount; i++) + { + SdrObjUserData* pUserData = pObject->GetUserData(i); + + if ((pUserData->GetInventor() == SdrInventor::StarDrawUserData) + && (pUserData->GetId() == SVX_IMAPINFO_ID)) + pIMapInfo = static_cast<SvxIMapInfo*>(pUserData); + } + + return pIMapInfo; +} + +IMapObject* SvxIMapInfo::GetHitIMapObject(const SdrObject* pObj, const Point& rWinPoint, + const vcl::Window* rCmpWnd) +{ + SvxIMapInfo* pIMapInfo = GetIMapInfo(pObj); + IMapObject* pIMapObj = nullptr; + + if (pIMapInfo) + { + const MapMode aMap100(MapUnit::Map100thMM); + Size aGraphSize; + Point aRelPoint(rWinPoint); + ImageMap& rImageMap = const_cast<ImageMap&>(pIMapInfo->GetImageMap()); + tools::Rectangle& rRect = const_cast<tools::Rectangle&>(pObj->GetLogicRect()); + + if (rCmpWnd) + { + MapMode aWndMode = rCmpWnd->GetMapMode(); + aRelPoint = rCmpWnd->LogicToLogic(rWinPoint, &aWndMode, &aMap100); + rRect = rCmpWnd->LogicToLogic(pObj->GetLogicRect(), &aWndMode, &aMap100); + } + + bool bObjSupported = false; + + // execute HitTest + if (auto pGrafObj = dynamic_cast<const SdrGrafObj*>(pObj)) // simple graphics object + { + const GeoStat& rGeo = pGrafObj->GetGeoStat(); + std::unique_ptr<SdrGrafObjGeoData> pGeoData( + static_cast<SdrGrafObjGeoData*>(pGrafObj->GetGeoData())); + + // Undo rotation + if (rGeo.nRotationAngle) + RotatePoint(aRelPoint, rRect.TopLeft(), -rGeo.nSin, rGeo.nCos); + + // Undo mirroring + if (pGeoData->bMirrored) + aRelPoint.setX(rRect.Right() + rRect.Left() - aRelPoint.X()); + + // Undo shearing + if (rGeo.nShearAngle) + ShearPoint(aRelPoint, rRect.TopLeft(), -rGeo.nTan); + + if (pGrafObj->GetGrafPrefMapMode().GetMapUnit() == MapUnit::MapPixel) + aGraphSize = Application::GetDefaultDevice()->PixelToLogic( + pGrafObj->GetGrafPrefSize(), aMap100); + else + aGraphSize = OutputDevice::LogicToLogic(pGrafObj->GetGrafPrefSize(), + pGrafObj->GetGrafPrefMapMode(), aMap100); + + bObjSupported = true; + } + else if (auto pOleObj = dynamic_cast<const SdrOle2Obj*>(pObj)) // OLE object + { + aGraphSize = pOleObj->GetOrigObjSize(); + bObjSupported = true; + } + + // Everything worked out well, thus execute HitTest + if (bObjSupported) + { + // Calculate relative position of mouse cursor + aRelPoint -= rRect.TopLeft(); + pIMapObj = rImageMap.GetHitIMapObject(aGraphSize, rRect.GetSize(), aRelPoint); + + // We don't care about deactivated objects + if (pIMapObj && !pIMapObj->IsActive()) + pIMapObj = nullptr; + } + } + + return pIMapObj; +} diff --git a/svx/source/sdr/overlay/overlayanimatedbitmapex.cxx b/svx/source/sdr/overlay/overlayanimatedbitmapex.cxx new file mode 100644 index 000000000..d659accb7 --- /dev/null +++ b/svx/source/sdr/overlay/overlayanimatedbitmapex.cxx @@ -0,0 +1,113 @@ +/* -*- 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 <svx/sdr/overlay/overlayanimatedbitmapex.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <sdr/overlay/overlaytools.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayAnimatedBitmapEx::createOverlayObjectPrimitive2DSequence() + { + if(mbOverlayState) + { + const drawinglayer::primitive2d::Primitive2DReference aPrimitive( + new drawinglayer::primitive2d::OverlayBitmapExPrimitive( + maBitmapEx1, + getBasePosition(), + mnCenterX1, + mnCenterY1, + getShearX(), + getRotation())); + + return drawinglayer::primitive2d::Primitive2DContainer { aPrimitive }; + } + else + { + const drawinglayer::primitive2d::Primitive2DReference aPrimitive( + new drawinglayer::primitive2d::OverlayBitmapExPrimitive( + maBitmapEx2, + getBasePosition(), + mnCenterX2, + mnCenterY2, + getShearX(), + getRotation())); + + return drawinglayer::primitive2d::Primitive2DContainer { aPrimitive }; + } + } + + OverlayAnimatedBitmapEx::OverlayAnimatedBitmapEx( + const basegfx::B2DPoint& rBasePos, + const BitmapEx& rBitmapEx1, + const BitmapEx& rBitmapEx2, + sal_uInt64 nBlinkTime, + sal_uInt16 nCenX1, + sal_uInt16 nCenY1, + sal_uInt16 nCenX2, + sal_uInt16 nCenY2, + double fShearX, + double fRotation) + : OverlayObjectWithBasePosition(rBasePos, COL_WHITE), + maBitmapEx1(rBitmapEx1), + maBitmapEx2(rBitmapEx2), + mnCenterX1(nCenX1), mnCenterY1(nCenY1), + mnCenterX2(nCenX2), mnCenterY2(nCenY2), + mnBlinkTime(impCheckBlinkTimeValueRange(nBlinkTime)), + mfShearX(fShearX), + mfRotation(fRotation), + mbOverlayState(false) + { + // set AllowsAnimation flag to mark this object as animation capable + mbAllowsAnimation = true; + } + + OverlayAnimatedBitmapEx::~OverlayAnimatedBitmapEx() + { + } + + void OverlayAnimatedBitmapEx::Trigger(sal_uInt32 nTime) + { + if(getOverlayManager()) + { + // #i53216# produce event after nTime + x + SetTime(nTime + mnBlinkTime); + + // switch state + if(mbOverlayState) + { + mbOverlayState = false; + } + else + { + mbOverlayState = true; + } + + // re-insert me as event + getOverlayManager()->InsertEvent(*this); + + // register change (after change) + objectChange(); + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlaybitmapex.cxx b/svx/source/sdr/overlay/overlaybitmapex.cxx new file mode 100644 index 000000000..75433989a --- /dev/null +++ b/svx/source/sdr/overlay/overlaybitmapex.cxx @@ -0,0 +1,72 @@ +/* -*- 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 <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> +#include <svx/sdr/overlay/overlaybitmapex.hxx> +#include <sdr/overlay/overlaytools.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayBitmapEx::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DReference aReference( + new drawinglayer::primitive2d::OverlayBitmapExPrimitive( + maBitmapEx, + getBasePosition(), + mnCenterX, + mnCenterY, + mfShearX, + mfRotation)); + + if(basegfx::fTools::more(mfAlpha, 0.0)) + { + const drawinglayer::primitive2d::Primitive2DContainer aNewTransPrimitiveVector { aReference }; + aReference = drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(aNewTransPrimitiveVector, mfAlpha)); + } + + return drawinglayer::primitive2d::Primitive2DContainer { aReference }; + } + + OverlayBitmapEx::OverlayBitmapEx( + const basegfx::B2DPoint& rBasePos, + const BitmapEx& rBitmapEx, + sal_uInt16 nCenX, + sal_uInt16 nCenY, + double fAlpha, + double fShearX, + double fRotation) + : OverlayObjectWithBasePosition(rBasePos, COL_WHITE), + maBitmapEx(rBitmapEx), + mnCenterX(nCenX), + mnCenterY(nCenY), + mfAlpha(fAlpha), + mfShearX(fShearX), + mfRotation(fRotation) + { + } + + OverlayBitmapEx::~OverlayBitmapEx() + { + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlaycrosshair.cxx b/svx/source/sdr/overlay/overlaycrosshair.cxx new file mode 100644 index 000000000..942534d68 --- /dev/null +++ b/svx/source/sdr/overlay/overlaycrosshair.cxx @@ -0,0 +1,67 @@ +/* -*- 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 <sdr/overlay/overlaycrosshair.hxx> +#include <sdr/overlay/overlaytools.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayCrosshairStriped::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if(getOverlayManager()) + { + const basegfx::BColor aRGBColorA(getOverlayManager()->getStripeColorA().getBColor()); + const basegfx::BColor aRGBColorB(getOverlayManager()->getStripeColorB().getBColor()); + const double fStripeLengthPixel(getOverlayManager()->getStripeLengthPixel()); + + const drawinglayer::primitive2d::Primitive2DReference aReference( + new drawinglayer::primitive2d::OverlayCrosshairPrimitive( + getBasePosition(), + aRGBColorA, + aRGBColorB, + fStripeLengthPixel)); + + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aReference }; + } + + return aRetval; + } + + void OverlayCrosshairStriped::stripeDefinitionHasChanged() + { + // react on OverlayManager's stripe definition change + objectChange(); + } + + OverlayCrosshairStriped::OverlayCrosshairStriped(const basegfx::B2DPoint& rBasePos) + : OverlayObjectWithBasePosition(rBasePos, COL_BLACK) + { + } + + OverlayCrosshairStriped::~OverlayCrosshairStriped() + { + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayhandle.cxx b/svx/source/sdr/overlay/overlayhandle.cxx new file mode 100644 index 000000000..c94da8e07 --- /dev/null +++ b/svx/source/sdr/overlay/overlayhandle.cxx @@ -0,0 +1,55 @@ +/* -*- 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 <sdr/overlay/overlayhandle.hxx> +#include <sdr/overlay/overlaytools.hxx> + +namespace sdr::overlay { + +using namespace drawinglayer; +using namespace basegfx; + +primitive2d::Primitive2DContainer OverlayHandle::createOverlayObjectPrimitive2DSequence() +{ + basegfx::BColor aStrokeColor = maStrokeColor.getBColor(); + basegfx::BColor aFillColor = getBaseColor().getBColor(); + + const primitive2d::Primitive2DReference aReference( + new primitive2d::OverlayStaticRectanglePrimitive(maBasePosition, maSize, aStrokeColor, aFillColor, 0.3f, 0.0f)); + + return primitive2d::Primitive2DContainer { aReference }; +} + +OverlayHandle::OverlayHandle(const B2DPoint& rBasePos, + const B2DSize& rSize, + Color const & rStrokeColor, + Color const & rFillColor) + : OverlayObjectWithBasePosition(rBasePos, rFillColor) + , maSize(rSize) + , maStrokeColor(rStrokeColor) +{ +} + +OverlayHandle::~OverlayHandle() +{ +} + +} // end of namespace sdr::overlay + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayhelpline.cxx b/svx/source/sdr/overlay/overlayhelpline.cxx new file mode 100644 index 000000000..9955122bb --- /dev/null +++ b/svx/source/sdr/overlay/overlayhelpline.cxx @@ -0,0 +1,74 @@ +/* -*- 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 <sdr/overlay/overlayhelpline.hxx> +#include <sdr/overlay/overlaytools.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayHelplineStriped::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if(getOverlayManager()) + { + const basegfx::BColor aRGBColorA(getOverlayManager()->getStripeColorA().getBColor()); + const basegfx::BColor aRGBColorB(getOverlayManager()->getStripeColorB().getBColor()); + const double fStripeLengthPixel(getOverlayManager()->getStripeLengthPixel()); + const drawinglayer::primitive2d::HelplineStyle aStyle( + SdrHelpLineKind::Point == getKind() ? drawinglayer::primitive2d::HELPLINESTYLE_POINT : + SdrHelpLineKind::Vertical == getKind() ? drawinglayer::primitive2d::HELPLINESTYLE_VERTICAL : + drawinglayer::primitive2d::HELPLINESTYLE_HORIZONTAL); + + const drawinglayer::primitive2d::Primitive2DReference aReference( + new drawinglayer::primitive2d::OverlayHelplineStripedPrimitive( + getBasePosition(), + aStyle, + aRGBColorA, + aRGBColorB, + fStripeLengthPixel)); + + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aReference }; + } + + return aRetval; + } + + void OverlayHelplineStriped::stripeDefinitionHasChanged() + { + // react on OverlayManager's stripe definition change + objectChange(); + } + + OverlayHelplineStriped::OverlayHelplineStriped( + const basegfx::B2DPoint& rBasePos, + SdrHelpLineKind eNewKind) + : OverlayObjectWithBasePosition(rBasePos, COL_BLACK), + meKind(eNewKind) + { + } + + OverlayHelplineStriped::~OverlayHelplineStriped() + { + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayline.cxx b/svx/source/sdr/overlay/overlayline.cxx new file mode 100644 index 000000000..de6da2475 --- /dev/null +++ b/svx/source/sdr/overlay/overlayline.cxx @@ -0,0 +1,74 @@ +/* -*- 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 <sdr/overlay/overlayline.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayLineStriped::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if(getOverlayManager()) + { + const basegfx::BColor aRGBColorA(getOverlayManager()->getStripeColorA().getBColor()); + const basegfx::BColor aRGBColorB(getOverlayManager()->getStripeColorB().getBColor()); + const double fStripeLengthPixel(getOverlayManager()->getStripeLengthPixel()); + basegfx::B2DPolygon aLine; + + aLine.append(getBasePosition()); + aLine.append(getSecondPosition()); + + const drawinglayer::primitive2d::Primitive2DReference aReference( + new drawinglayer::primitive2d::PolygonMarkerPrimitive2D( + aLine, + aRGBColorA, + aRGBColorB, + fStripeLengthPixel)); + + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aReference }; + } + + return aRetval; + } + + void OverlayLineStriped::stripeDefinitionHasChanged() + { + // react on OverlayManager's stripe definition change + objectChange(); + } + + OverlayLineStriped::OverlayLineStriped( + const basegfx::B2DPoint& rBasePos, + const basegfx::B2DPoint& rSecondPos) + : OverlayObjectWithBasePosition(rBasePos, COL_BLACK), + maSecondPosition(rSecondPos) + { + } + + OverlayLineStriped::~OverlayLineStriped() + { + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlaymanager.cxx b/svx/source/sdr/overlay/overlaymanager.cxx new file mode 100644 index 000000000..4c831869a --- /dev/null +++ b/svx/source/sdr/overlay/overlaymanager.cxx @@ -0,0 +1,349 @@ +/* -*- 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 <svx/sdr/overlay/overlaymanager.hxx> +#include <basegfx/range/b2drange.hxx> +#include <tools/gen.hxx> +#include <vcl/canvastools.hxx> +#include <vcl/outdev.hxx> +#include <vcl/window.hxx> +#include <svx/sdr/overlay/overlayobject.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/processor2d/baseprocessor2d.hxx> +#include <drawinglayer/processor2d/processor2dtools.hxx> +#include <memory> + + +using namespace com::sun::star; + + +namespace sdr::overlay +{ + void OverlayManager::ImpDrawMembers(const basegfx::B2DRange& rRange, OutputDevice& rDestinationDevice) const + { + const sal_uInt32 nSize(maOverlayObjects.size()); + + if(nSize) + { + const AntialiasingFlags nOriginalAA(rDestinationDevice.GetAntialiasing()); + const bool bIsAntiAliasing(getDrawinglayerOpt().IsAntiAliasing()); + + // create processor + std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor(drawinglayer::processor2d::createProcessor2DFromOutputDevice( + rDestinationDevice, + getCurrentViewInformation2D())); + + if(pProcessor) + { + for(const auto& rpOverlayObject : maOverlayObjects) + { + OSL_ENSURE(rpOverlayObject, "Corrupted OverlayObject List (!)"); + const OverlayObject& rCandidate = *rpOverlayObject; + + if(rCandidate.isVisible()) + { + const drawinglayer::primitive2d::Primitive2DContainer& rSequence = rCandidate.getOverlayObjectPrimitive2DSequence(); + + if(!rSequence.empty()) + { + if(rRange.overlaps(rCandidate.getBaseRange())) + { + if(bIsAntiAliasing && rCandidate.allowsAntiAliase()) + { + rDestinationDevice.SetAntialiasing(nOriginalAA | AntialiasingFlags::EnableB2dDraw); + } + else + { + rDestinationDevice.SetAntialiasing(nOriginalAA & ~AntialiasingFlags::EnableB2dDraw); + } + + pProcessor->process(rSequence); + } + } + } + } + + pProcessor.reset(); + } + + // restore AA settings + rDestinationDevice.SetAntialiasing(nOriginalAA); + } + } + + void OverlayManager::ImpStripeDefinitionChanged() + { + const sal_uInt32 nSize(maOverlayObjects.size()); + + if(nSize) + { + for(const auto& rpOverlayObject : maOverlayObjects) + { + OSL_ENSURE(rpOverlayObject, "Corrupted OverlayObject List (!)"); + OverlayObject& rCandidate = *rpOverlayObject; + rCandidate.stripeDefinitionHasChanged(); + } + } + } + + double OverlayManager::getDiscreteOne() const + { + if(basegfx::fTools::equalZero(mfDiscreteOne)) + { + const basegfx::B2DVector aDiscreteInLogic(getOutputDevice().GetInverseViewTransformation() * basegfx::B2DVector(1.0, 0.0)); + const_cast< OverlayManager* >(this)->mfDiscreteOne = aDiscreteInLogic.getLength(); + } + + return mfDiscreteOne; + } + + OverlayManager::OverlayManager(OutputDevice& rOutputDevice) + : Scheduler(), + mrOutputDevice(rOutputDevice), + maOverlayObjects(), + maStripeColorA(COL_BLACK), + maStripeColorB(COL_WHITE), + mnStripeLengthPixel(5), + maDrawinglayerOpt(), + maViewTransformation(), + maViewInformation2D(), + mfDiscreteOne(0.0) + { + // set Property 'ReducedDisplayQuality' to true to allow simpler interaction + // visualisations + uno::Sequence< beans::PropertyValue > xProperties(1); + xProperties[0].Name = "ReducedDisplayQuality"; + xProperties[0].Value <<= true; + maViewInformation2D = drawinglayer::geometry::ViewInformation2D(xProperties); + } + + rtl::Reference<OverlayManager> OverlayManager::create(OutputDevice& rOutputDevice) + { + return rtl::Reference<OverlayManager>(new OverlayManager(rOutputDevice)); + } + + drawinglayer::geometry::ViewInformation2D const & OverlayManager::getCurrentViewInformation2D() const + { + if(getOutputDevice().GetViewTransformation() != maViewTransformation) + { + basegfx::B2DRange aViewRange(maViewInformation2D.getViewport()); + + if(OUTDEV_WINDOW == getOutputDevice().GetOutDevType()) + { + const Size aOutputSizePixel(getOutputDevice().GetOutputSizePixel()); + + // only set when we *have* an output size, else let aViewRange + // stay on empty + if(aOutputSizePixel.Width() && aOutputSizePixel.Height()) + { + aViewRange = basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight()); + aViewRange.transform(getOutputDevice().GetInverseViewTransformation()); + } + } + + OverlayManager* pThis = const_cast< OverlayManager* >(this); + + pThis->maViewTransformation = getOutputDevice().GetViewTransformation(); + pThis->maViewInformation2D = drawinglayer::geometry::ViewInformation2D( + maViewInformation2D.getObjectTransformation(), + maViewTransformation, + aViewRange, + maViewInformation2D.getVisualizedPage(), + maViewInformation2D.getViewTime(), + maViewInformation2D.getExtendedInformationSequence()); + pThis->mfDiscreteOne = 0.0; + } + + return maViewInformation2D; + } + + void OverlayManager::impApplyRemoveActions(OverlayObject& rTarget) + { + // handle evtl. animation + if(rTarget.allowsAnimation()) + { + // remove from event chain + RemoveEvent(&rTarget); + } + + // make invisible + invalidateRange(rTarget.getBaseRange()); + + // clear manager + rTarget.mpOverlayManager = nullptr; + } + + void OverlayManager::impApplyAddActions(OverlayObject& rTarget) + { + // set manager + rTarget.mpOverlayManager = this; + + // make visible + invalidateRange(rTarget.getBaseRange()); + + // handle evtl. animation + if(rTarget.allowsAnimation()) + { + // Trigger at current time to get alive. This will do the + // object-specific next time calculation and hand over adding + // again to the scheduler to the animated object, too. This works for + // a paused or non-paused animator. + rTarget.Trigger(GetTime()); + } + } + + OverlayManager::~OverlayManager() + { + // The OverlayManager is not the owner of the OverlayObjects + // and thus will not delete them, but remove them. Profit here + // from knowing that all will be removed + const sal_uInt32 nSize(maOverlayObjects.size()); + + if(nSize) + { + for(const auto& rpOverlayObject : maOverlayObjects) + { + OSL_ENSURE(rpOverlayObject, "Corrupted OverlayObject List (!)"); + OverlayObject& rCandidate = *rpOverlayObject; + impApplyRemoveActions(rCandidate); + } + + // erase vector + maOverlayObjects.clear(); + } + } + + void OverlayManager::completeRedraw(const vcl::Region& rRegion, OutputDevice* pPreRenderDevice) const + { + if(!rRegion.IsEmpty() && !maOverlayObjects.empty()) + { + // check for changed MapModes. That may influence the + // logical size of pixel based OverlayObjects (like BitmapHandles) + //ImpCheckMapModeChange(); + + // paint members + const tools::Rectangle aRegionBoundRect(rRegion.GetBoundRect()); + const basegfx::B2DRange aRegionRange = vcl::unotools::b2DRectangleFromRectangle(aRegionBoundRect); + + OutputDevice& rTarget = pPreRenderDevice ? *pPreRenderDevice : getOutputDevice(); + ImpDrawMembers(aRegionRange, rTarget); + } + } + + void OverlayManager::flush() + { + // default has nothing to do + } + + void OverlayManager::add(OverlayObject& rOverlayObject) + { + OSL_ENSURE(nullptr == rOverlayObject.mpOverlayManager, "OverlayObject is added twice to an OverlayManager (!)"); + + // add to the end of chain to preserve display order in paint + maOverlayObjects.push_back(&rOverlayObject); + + // execute add actions + impApplyAddActions(rOverlayObject); + } + + void OverlayManager::remove(OverlayObject& rOverlayObject) + { + OSL_ENSURE(rOverlayObject.mpOverlayManager == this, "OverlayObject is removed from wrong OverlayManager (!)"); + + // execute remove actions + impApplyRemoveActions(rOverlayObject); + + // remove from vector + const OverlayObjectVector::iterator aFindResult = ::std::find(maOverlayObjects.begin(), maOverlayObjects.end(), &rOverlayObject); + const bool bFound(aFindResult != maOverlayObjects.end()); + OSL_ENSURE(bFound, "OverlayObject NOT found at OverlayManager (!)"); + + if(bFound) + { + maOverlayObjects.erase(aFindResult); + } + } + + tools::Rectangle OverlayManager::RangeToInvalidateRectangle(const basegfx::B2DRange& rRange) const + { + if (getDrawinglayerOpt().IsAntiAliasing()) + { + // assume AA needs one pixel more and invalidate one pixel more + const double fDiscreteOne(getDiscreteOne()); + const tools::Rectangle aInvalidateRectangle( + static_cast<sal_Int32>(floor(rRange.getMinX() - fDiscreteOne)), + static_cast<sal_Int32>(floor(rRange.getMinY() - fDiscreteOne)), + static_cast<sal_Int32>(ceil(rRange.getMaxX() + fDiscreteOne)), + static_cast<sal_Int32>(ceil(rRange.getMaxY() + fDiscreteOne))); + return aInvalidateRectangle; + } + else + { + // #i77674# transform to rectangle. Use floor/ceil to get all covered + // discrete pixels, see #i75163# and OverlayManagerBuffered::invalidateRange + const tools::Rectangle aInvalidateRectangle( + static_cast<sal_Int32>(floor(rRange.getMinX())), static_cast<sal_Int32>(floor(rRange.getMinY())), + static_cast<sal_Int32>(ceil(rRange.getMaxX())), static_cast<sal_Int32>(ceil(rRange.getMaxY()))); + return aInvalidateRectangle; + } + } + + void OverlayManager::invalidateRange(const basegfx::B2DRange& rRange) + { + if (OUTDEV_WINDOW == getOutputDevice().GetOutDevType()) + { + tools::Rectangle aInvalidateRectangle(RangeToInvalidateRectangle(rRange)); + // simply invalidate + static_cast<vcl::Window&>(getOutputDevice()).Invalidate(aInvalidateRectangle, InvalidateFlags::NoErase); + } + } + + // stripe support ColA + void OverlayManager::setStripeColorA(Color aNew) + { + if(aNew != maStripeColorA) + { + maStripeColorA = aNew; + ImpStripeDefinitionChanged(); + } + } + + // stripe support ColB + void OverlayManager::setStripeColorB(Color aNew) + { + if(aNew != maStripeColorB) + { + maStripeColorB = aNew; + ImpStripeDefinitionChanged(); + } + } + + // stripe support StripeLengthPixel + void OverlayManager::setStripeLengthPixel(sal_uInt32 nNew) + { + if(nNew != mnStripeLengthPixel) + { + mnStripeLengthPixel = nNew; + ImpStripeDefinitionChanged(); + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlaymanagerbuffered.cxx b/svx/source/sdr/overlay/overlaymanagerbuffered.cxx new file mode 100644 index 000000000..89f35a025 --- /dev/null +++ b/svx/source/sdr/overlay/overlaymanagerbuffered.cxx @@ -0,0 +1,440 @@ +/* -*- 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 <sdr/overlay/overlaymanagerbuffered.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <vcl/outdev.hxx> +#include <basegfx/range/b2drange.hxx> +#include <vcl/window.hxx> +#include <tools/fract.hxx> +#include <vcl/cursor.hxx> + + +namespace sdr::overlay +{ + void OverlayManagerBuffered::ImpPrepareBufferDevice() + { + // compare size of mpBufferDevice with size of visible area + if(mpBufferDevice->GetOutputSizePixel() != getOutputDevice().GetOutputSizePixel()) + { + // set new buffer size, copy as much content as possible (use bool parameter for vcl). + // Newly uncovered regions will be repainted. + mpBufferDevice->SetOutputSizePixel(getOutputDevice().GetOutputSizePixel(), false); + } + + // compare the MapModes for zoom/scroll changes + if(mpBufferDevice->GetMapMode() != getOutputDevice().GetMapMode()) + { + const bool bZoomed( + mpBufferDevice->GetMapMode().GetScaleX() != getOutputDevice().GetMapMode().GetScaleX() + || mpBufferDevice->GetMapMode().GetScaleY() != getOutputDevice().GetMapMode().GetScaleY()); + + if(!bZoomed) + { + const Point& rOriginOld = mpBufferDevice->GetMapMode().GetOrigin(); + const Point& rOriginNew = getOutputDevice().GetMapMode().GetOrigin(); + const bool bScrolled(rOriginOld != rOriginNew); + + if(bScrolled) + { + // get pixel bounds + const Point aOriginOldPixel(mpBufferDevice->LogicToPixel(rOriginOld)); + const Point aOriginNewPixel(mpBufferDevice->LogicToPixel(rOriginNew)); + const Size aOutputSizePixel(mpBufferDevice->GetOutputSizePixel()); + + // remember and switch off MapMode + const bool bMapModeWasEnabled(mpBufferDevice->IsMapModeEnabled()); + mpBufferDevice->EnableMapMode(false); + + // scroll internally buffered stuff + const Point aDestinationOffsetPixel(aOriginNewPixel - aOriginOldPixel); + mpBufferDevice->DrawOutDev( + aDestinationOffsetPixel, aOutputSizePixel, // destination + Point(), aOutputSizePixel); // source + + // restore MapMode + mpBufferDevice->EnableMapMode(bMapModeWasEnabled); + + // scroll remembered region, too. + if(!maBufferRememberedRangePixel.isEmpty()) + { + const basegfx::B2IPoint aIPointDestinationOffsetPixel(aDestinationOffsetPixel.X(), aDestinationOffsetPixel.Y()); + const basegfx::B2IPoint aNewMinimum(maBufferRememberedRangePixel.getMinimum() + aIPointDestinationOffsetPixel); + const basegfx::B2IPoint aNewMaximum(maBufferRememberedRangePixel.getMaximum() + aIPointDestinationOffsetPixel); + maBufferRememberedRangePixel = basegfx::B2IRange(aNewMinimum, aNewMaximum); + } + } + } + + // copy new MapMode + mpBufferDevice->SetMapMode(getOutputDevice().GetMapMode()); + } + + // #i29186# + mpBufferDevice->SetDrawMode(getOutputDevice().GetDrawMode()); + mpBufferDevice->SetSettings(getOutputDevice().GetSettings()); + mpBufferDevice->SetAntialiasing(getOutputDevice().GetAntialiasing()); + } + + void OverlayManagerBuffered::ImpRestoreBackground() const + { + const tools::Rectangle aRegionRectanglePixel( + maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(), + maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY()); + const vcl::Region aRegionPixel(aRegionRectanglePixel); + + ImpRestoreBackground(aRegionPixel); + } + + void OverlayManagerBuffered::ImpRestoreBackground(const vcl::Region& rRegionPixel) const + { + // MapModes off + const bool bMapModeWasEnabledDest(getOutputDevice().IsMapModeEnabled()); + const bool bMapModeWasEnabledSource(mpBufferDevice->IsMapModeEnabled()); + getOutputDevice().EnableMapMode(false); + const_cast<OverlayManagerBuffered*>(this)->mpBufferDevice->EnableMapMode(false); + + // local region + RectangleVector aRectangles; + rRegionPixel.GetRegionRectangles(aRectangles); + + for(const auto& rRect : aRectangles) + { + // restore the area + const Point aTopLeft(rRect.TopLeft()); + const Size aSize(rRect.GetSize()); + + getOutputDevice().DrawOutDev( + aTopLeft, aSize, // destination + aTopLeft, aSize, // source + *mpBufferDevice); + } + + // restore MapModes + getOutputDevice().EnableMapMode(bMapModeWasEnabledDest); + const_cast<OverlayManagerBuffered*>(this)->mpBufferDevice->EnableMapMode(bMapModeWasEnabledSource); + } + + void OverlayManagerBuffered::ImpSaveBackground(const vcl::Region& rRegion, OutputDevice* pPreRenderDevice) + { + // prepare source + OutputDevice& rSource = pPreRenderDevice ? *pPreRenderDevice : getOutputDevice(); + + // Ensure buffer is valid + ImpPrepareBufferDevice(); + + // build region which needs to be copied + vcl::Region aRegion(rSource.LogicToPixel(rRegion)); + + // limit to PaintRegion if it's a window. This will be evtl. the expanded one, + // but always the exact redraw area + if(OUTDEV_WINDOW == rSource.GetOutDevType()) + { + vcl::Window& rWindow = static_cast<vcl::Window&>(rSource); + vcl::Region aPaintRegionPixel = rWindow.LogicToPixel(rWindow.GetPaintRegion()); + aRegion.Intersect(aPaintRegionPixel); + + // #i72754# Make sure content is completely rendered, the window + // will be used as source of a DrawOutDev soon + rWindow.Flush(); + } + + // also limit to buffer size + const tools::Rectangle aBufferDeviceRectanglePixel(Point(), mpBufferDevice->GetOutputSizePixel()); + aRegion.Intersect(aBufferDeviceRectanglePixel); + + // MapModes off + const bool bMapModeWasEnabledDest(rSource.IsMapModeEnabled()); + const bool bMapModeWasEnabledSource(mpBufferDevice->IsMapModeEnabled()); + rSource.EnableMapMode(false); + mpBufferDevice->EnableMapMode(false); + + // prepare to iterate over the rectangles from the region in pixels + RectangleVector aRectangles; + aRegion.GetRegionRectangles(aRectangles); + + for(const auto& rRect : aRectangles) + { + // for each rectangle, save the area + const Point aTopLeft(rRect.TopLeft()); + const Size aSize(rRect.GetSize()); + + mpBufferDevice->DrawOutDev( + aTopLeft, aSize, // destination + aTopLeft, aSize, // source + rSource); + } + + // restore MapModes + rSource.EnableMapMode(bMapModeWasEnabledDest); + mpBufferDevice->EnableMapMode(bMapModeWasEnabledSource); + } + + IMPL_LINK_NOARG(OverlayManagerBuffered, ImpBufferTimerHandler, Timer*, void) + { + //Resolves: fdo#46728 ensure this exists until end of scope + rtl::Reference<OverlayManager> xKeepAlive(this); + + // stop timer + maBufferIdle.Stop(); + + if(!maBufferRememberedRangePixel.isEmpty()) + { + // logic size for impDrawMember call + basegfx::B2DRange aBufferRememberedRangeLogic( + maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(), + maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY()); + aBufferRememberedRangeLogic.transform(getOutputDevice().GetInverseViewTransformation()); + + // prepare cursor handling + const bool bTargetIsWindow(OUTDEV_WINDOW == mrOutputDevice.GetOutDevType()); + bool bCursorWasEnabled(false); + + // #i80730# switch off VCL cursor during overlay refresh + if(bTargetIsWindow) + { + vcl::Window& rWindow = static_cast< vcl::Window& >(mrOutputDevice); + vcl::Cursor* pCursor = rWindow.GetCursor(); + + if(pCursor && pCursor->IsVisible()) + { + pCursor->Hide(); + bCursorWasEnabled = true; + } + } + + // refresh with prerendering + { + // #i73602# ensure valid and sized mpOutputBufferDevice + const Size aDestinationSizePixel(mpBufferDevice->GetOutputSizePixel()); + const Size aOutputBufferSizePixel(mpOutputBufferDevice->GetOutputSizePixel()); + + if(aDestinationSizePixel != aOutputBufferSizePixel) + { + mpOutputBufferDevice->SetOutputSizePixel(aDestinationSizePixel); + } + + mpOutputBufferDevice->SetMapMode(getOutputDevice().GetMapMode()); + mpOutputBufferDevice->EnableMapMode(false); + mpOutputBufferDevice->SetDrawMode(mpBufferDevice->GetDrawMode()); + mpOutputBufferDevice->SetSettings(mpBufferDevice->GetSettings()); + mpOutputBufferDevice->SetAntialiasing(mpBufferDevice->GetAntialiasing()); + + // calculate sizes + tools::Rectangle aRegionRectanglePixel( + maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(), + maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY()); + + // truncate aRegionRectanglePixel to destination pixel size, more does + // not need to be prepared since destination is a buffer for a window. So, + // maximum size indirectly shall be limited to getOutputDevice().GetOutputSizePixel() + if(aRegionRectanglePixel.Left() < 0) + { + aRegionRectanglePixel.SetLeft( 0 ); + } + + if(aRegionRectanglePixel.Top() < 0) + { + aRegionRectanglePixel.SetTop( 0 ); + } + + if(aRegionRectanglePixel.Right() > aDestinationSizePixel.getWidth()) + { + aRegionRectanglePixel.SetRight( aDestinationSizePixel.getWidth() ); + } + + if(aRegionRectanglePixel.Bottom() > aDestinationSizePixel.getHeight()) + { + aRegionRectanglePixel.SetBottom( aDestinationSizePixel.getHeight() ); + } + + // get sizes + const Point aTopLeft(aRegionRectanglePixel.TopLeft()); + const Size aSize(aRegionRectanglePixel.GetSize()); + + { + const bool bMapModeWasEnabledDest(mpBufferDevice->IsMapModeEnabled()); + mpBufferDevice->EnableMapMode(false); + + mpOutputBufferDevice->DrawOutDev( + aTopLeft, aSize, // destination + aTopLeft, aSize, // source + *mpBufferDevice); + + // restore MapModes + mpBufferDevice->EnableMapMode(bMapModeWasEnabledDest); + } + + // paint overlay content for remembered region, use + // method from base class directly + mpOutputBufferDevice->EnableMapMode(); + OverlayManager::ImpDrawMembers(aBufferRememberedRangeLogic, *mpOutputBufferDevice); + mpOutputBufferDevice->EnableMapMode(false); + + // copy to output + { + const bool bMapModeWasEnabledDest(getOutputDevice().IsMapModeEnabled()); + getOutputDevice().EnableMapMode(false); + + getOutputDevice().DrawOutDev( + aTopLeft, aSize, // destination + aTopLeft, aSize, // source + *mpOutputBufferDevice); + + // debug + /*getOutputDevice().SetLineCOL_RED); + getOutputDevice().SetFillColor(); + getOutputDevice().DrawRect(Rectangle(aTopLeft, aSize));*/ + + // restore MapModes + getOutputDevice().EnableMapMode(bMapModeWasEnabledDest); + } + } + + // VCL hack for transparent child windows + // Problem is e.g. a radiobutton form control in life mode. The used window + // is a transparence vcl childwindow. This flag only allows the parent window to + // paint into the child windows area, but there is no mechanism which takes + // care for a repaint of the child window. A transparent child window is NOT + // a window which always keeps it's content consistent over the parent, but it's + // more like just a paint flag for the parent. + // To get the update, the windows in question are updated manually here. + if(bTargetIsWindow) + { + vcl::Window& rWindow = static_cast< vcl::Window& >(mrOutputDevice); + + const tools::Rectangle aRegionRectanglePixel( + maBufferRememberedRangePixel.getMinX(), + maBufferRememberedRangePixel.getMinY(), + maBufferRememberedRangePixel.getMaxX(), + maBufferRememberedRangePixel.getMaxY()); + PaintTransparentChildren(rWindow, aRegionRectanglePixel); + } + + // #i80730# restore visibility of VCL cursor + if(bCursorWasEnabled) + { + vcl::Window& rWindow = static_cast< vcl::Window& >(mrOutputDevice); + vcl::Cursor* pCursor = rWindow.GetCursor(); + + if(pCursor) + { + // check if cursor still exists. It may have been deleted from someone + pCursor->Show(); + } + } + + // forget remembered Region + maBufferRememberedRangePixel.reset(); + } + } + + OverlayManagerBuffered::OverlayManagerBuffered( + OutputDevice& rOutputDevice) + : OverlayManager(rOutputDevice), + mpBufferDevice(VclPtr<VirtualDevice>::Create()), + mpOutputBufferDevice(VclPtr<VirtualDevice>::Create()), + maBufferIdle("sdr overlay OverlayManagerBuffered Idle") + { + // Init timer + maBufferIdle.SetPriority( TaskPriority::POST_PAINT ); + maBufferIdle.SetInvokeHandler(LINK(this, OverlayManagerBuffered, ImpBufferTimerHandler)); + maBufferIdle.SetDebugName( "sdr::overlay::OverlayManagerBuffered maBufferIdle" ); + } + + rtl::Reference<OverlayManager> OverlayManagerBuffered::create( + OutputDevice& rOutputDevice) + { + return rtl::Reference<OverlayManager>(new OverlayManagerBuffered(rOutputDevice)); + } + + OverlayManagerBuffered::~OverlayManagerBuffered() + { + // Clear timer + maBufferIdle.Stop(); + + if(!maBufferRememberedRangePixel.isEmpty()) + { + // Restore all rectangles for remembered region from buffer + ImpRestoreBackground(); + } + } + + void OverlayManagerBuffered::completeRedraw(const vcl::Region& rRegion, OutputDevice* pPreRenderDevice) const + { + if(!rRegion.IsEmpty()) + { + // save new background + const_cast<OverlayManagerBuffered*>(this)->ImpSaveBackground(rRegion, pPreRenderDevice); + } + + // call parent + OverlayManager::completeRedraw(rRegion, pPreRenderDevice); + } + + void OverlayManagerBuffered::flush() + { + // call timer handler direct + ImpBufferTimerHandler(nullptr); + } + + void OverlayManagerBuffered::invalidateRange(const basegfx::B2DRange& rRange) + { + if(!rRange.isEmpty()) + { + // buffered output, do not invalidate but use the timer + // to trigger a timer event for refresh + maBufferIdle.Start(); + + // add the discrete range to the remembered region + // #i75163# use double precision and floor/ceil rounding to get overlapped pixel region, even + // when the given logic region has a width/height of 0.0. This does NOT work with LogicToPixel + // since it just transforms the top left and bottom right points equally without taking + // discrete pixel coverage into account. An empty B2DRange and thus empty logic Rectangle translated + // to an also empty discrete pixel rectangle - what is wrong. + basegfx::B2DRange aDiscreteRange(rRange); + aDiscreteRange.transform(getOutputDevice().GetViewTransformation()); + + if(maDrawinglayerOpt.IsAntiAliasing()) + { + // assume AA needs one pixel more and invalidate one pixel more + const double fDiscreteOne(getDiscreteOne()); + const basegfx::B2IPoint aTopLeft( + static_cast<sal_Int32>(floor(aDiscreteRange.getMinX() - fDiscreteOne)), + static_cast<sal_Int32>(floor(aDiscreteRange.getMinY() - fDiscreteOne))); + const basegfx::B2IPoint aBottomRight( + static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxX() + fDiscreteOne)), + static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxY() + fDiscreteOne))); + + maBufferRememberedRangePixel.expand(aTopLeft); + maBufferRememberedRangePixel.expand(aBottomRight); + } + else + { + const basegfx::B2IPoint aTopLeft(static_cast<sal_Int32>(floor(aDiscreteRange.getMinX())), static_cast<sal_Int32>(floor(aDiscreteRange.getMinY()))); + const basegfx::B2IPoint aBottomRight(static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxX())), static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxY()))); + + maBufferRememberedRangePixel.expand(aTopLeft); + maBufferRememberedRangePixel.expand(aBottomRight); + } + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayobject.cxx b/svx/source/sdr/overlay/overlayobject.cxx new file mode 100644 index 000000000..1be8b6f63 --- /dev/null +++ b/svx/source/sdr/overlay/overlayobject.cxx @@ -0,0 +1,229 @@ +/* -*- 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 <svx/sdr/overlay/overlayobject.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <basegfx/vector/b2dvector.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <drawinglayer/primitive2d/transformprimitive2d.hxx> + +namespace sdr::overlay +{ + void OverlayObject::objectChange() + { + const basegfx::B2DRange aPreviousRange(maBaseRange); + maBaseRange.reset(); + resetPrimitive2DSequence(); +// setPrimitive2DSequence(drawinglayer::primitive2d::Primitive2DContainer()); + + if(getOverlayManager() && !aPreviousRange.isEmpty()) + { + getOverlayManager()->invalidateRange(aPreviousRange); + } + + const basegfx::B2DRange& rCurrentRange = getBaseRange(); + + if(getOverlayManager() && rCurrentRange != aPreviousRange && !rCurrentRange.isEmpty()) + { + getOverlayManager()->invalidateRange(rCurrentRange); + } + } + + // OverlayObject implementations. + drawinglayer::primitive2d::Primitive2DContainer OverlayObject::createOverlayObjectPrimitive2DSequence() + { + // Default implementation has to assert a missing implementation. It cannot + // be useful to have overlay object derivations which have no visualisation + // at all + OSL_FAIL("OverlayObject derivation without visualisation definition (missing createOverlayObjectPrimitive2DSequence implementation) (!)"); + return drawinglayer::primitive2d::Primitive2DContainer(); + } + + sal_uInt32 OverlayObject::impCheckBlinkTimeValueRange(sal_uInt64 nBlinkTime) + { + if(nBlinkTime < 25) + { + nBlinkTime = 25; + } + else if(nBlinkTime > 10000) + { + nBlinkTime = 10000; + } + + return nBlinkTime; + } + + void OverlayObject::allowAntiAliase(bool bNew) + { + if(bNew != mbAllowsAntiAliase) + { + // remember new value + mbAllowsAntiAliase = bNew; + + // register change (after change) + objectChange(); + } + } + + OverlayObject::OverlayObject(Color aBaseColor) + : Event(), + mpOverlayManager(nullptr), + maPrimitive2DSequence(), + maOffset(0.0, 0.0), + maBaseColor(aBaseColor), + mbIsVisible(true), + mbIsHittable(true), + mbAllowsAnimation(false), + mbAllowsAntiAliase(true) + { + } + + OverlayObject::~OverlayObject() + { + OSL_ENSURE(nullptr == getOverlayManager(), "OverlayObject is destructed which is still registered at OverlayManager (!)"); + } + + drawinglayer::primitive2d::Primitive2DContainer OverlayObject::getOverlayObjectPrimitive2DSequence() const + { + if(getPrimitive2DSequence().empty()) + { + // no existing sequence; create one + const_cast< OverlayObject* >(this)->maPrimitive2DSequence = const_cast< OverlayObject* >(this)->createOverlayObjectPrimitive2DSequence(); + + if(!getOffset().equalZero()) + { + // embed to offset transformation + const basegfx::B2DHomMatrix aTranslateGridOffset( + basegfx::utils::createTranslateB2DHomMatrix( + getOffset())); + const drawinglayer::primitive2d::Primitive2DReference aEmbed( + new drawinglayer::primitive2d::TransformPrimitive2D( + aTranslateGridOffset, + maPrimitive2DSequence)); + + const_cast< OverlayObject* >(this)->maPrimitive2DSequence = drawinglayer::primitive2d::Primitive2DContainer { aEmbed }; + } + } + + return getPrimitive2DSequence(); + } + + const basegfx::B2DRange& OverlayObject::getBaseRange() const + { + if(getOverlayManager() && maBaseRange.isEmpty()) + { + const drawinglayer::primitive2d::Primitive2DContainer& rSequence = getOverlayObjectPrimitive2DSequence(); + + if(!rSequence.empty()) + { + const drawinglayer::geometry::ViewInformation2D aViewInformation2D(getOverlayManager()->getCurrentViewInformation2D()); + + const_cast< sdr::overlay::OverlayObject* >(this)->maBaseRange = + rSequence.getB2DRange(aViewInformation2D); + } + } + + return maBaseRange; + } + + void OverlayObject::setVisible(bool bNew) + { + if(bNew != mbIsVisible) + { + // remember new value + mbIsVisible = bNew; + + // register change (after change) + objectChange(); + } + } + + void OverlayObject::setHittable(bool bNew) + { + if(bNew != mbIsHittable) + { + // remember new value + mbIsHittable = bNew; + + // register change (after change) + objectChange(); + } + } + + void OverlayObject::setBaseColor(Color aNew) + { + if(aNew != maBaseColor) + { + // remember new value + maBaseColor = aNew; + + // register change (after change) + objectChange(); + } + } + + void OverlayObject::setOffset(const basegfx::B2DVector& rOffset) + { + if(rOffset != maOffset) + { + // remember new value + maOffset = rOffset; + + // register change (after change) + objectChange(); + } + } + + void OverlayObject::Trigger(sal_uInt32 /*nTime*/) + { + // default does not register again + } + + void OverlayObject::stripeDefinitionHasChanged() + { + // default does not need to do anything + } + + + OverlayObjectWithBasePosition::OverlayObjectWithBasePosition(const basegfx::B2DPoint& rBasePos, Color aBaseColor) + : OverlayObject(aBaseColor), + maBasePosition(rBasePos) + { + } + + OverlayObjectWithBasePosition::~OverlayObjectWithBasePosition() + { + } + + void OverlayObjectWithBasePosition::setBasePosition(const basegfx::B2DPoint& rNew) + { + if(rNew != maBasePosition) + { + // remember new value + maBasePosition = rNew; + + // register change (after change) + objectChange(); + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayobjectcell.cxx b/svx/source/sdr/overlay/overlayobjectcell.cxx new file mode 100644 index 000000000..68ab8281e --- /dev/null +++ b/svx/source/sdr/overlay/overlayobjectcell.cxx @@ -0,0 +1,81 @@ +/* -*- 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 <basegfx/numeric/ftools.hxx> +#include <sdr/overlay/overlayobjectcell.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> +#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> + +using namespace ::basegfx; + +namespace sdr::overlay +{ + OverlayObjectCell::OverlayObjectCell( const Color& rColor, const RangeVector& rRects ) + : OverlayObject( rColor ), + maRectangles( rRects ) + { + // no AA for selection overlays + allowAntiAliase(false); + } + + OverlayObjectCell::~OverlayObjectCell() + { + } + + drawinglayer::primitive2d::Primitive2DContainer OverlayObjectCell::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DContainer aRetval; + const sal_uInt32 nCount(maRectangles.size()); + + if(nCount) + { + const basegfx::BColor aRGBColor(getBaseColor().getBColor()); + aRetval.resize(nCount); + + // create primitives for all ranges + for(sal_uInt32 a(0); a < nCount; a++) + { + const basegfx::B2DRange& rRange(maRectangles[a]); + const basegfx::B2DPolygon aPolygon(basegfx::utils::createPolygonFromRect(rRange)); + + aRetval[a] = drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( + basegfx::B2DPolyPolygon(aPolygon), + aRGBColor)); + } + + + // embed in 50% transparent paint + const drawinglayer::primitive2d::Primitive2DReference aUnifiedTransparence( + new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D( + aRetval, + 0.5)); + + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aUnifiedTransparence }; + } + + return aRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayobjectlist.cxx b/svx/source/sdr/overlay/overlayobjectlist.cxx new file mode 100644 index 000000000..08a5a5c00 --- /dev/null +++ b/svx/source/sdr/overlay/overlayobjectlist.cxx @@ -0,0 +1,144 @@ +/* -*- 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 <svx/sdr/overlay/overlayobjectlist.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <vcl/outdev.hxx> +#include <tools/gen.hxx> + +#include <drawinglayer/processor2d/hittestprocessor2d.hxx> +#include <comphelper/lok.hxx> + +#define DEFAULT_VALUE_FOR_HITTEST_PIXEL (2) +#define DEFAULT_VALUE_FOR_HITTEST_TWIP (30) + +namespace sdr::overlay +{ + OverlayObjectList::~OverlayObjectList() + { + clear(); + } + + void OverlayObjectList::clear() + { + for(auto & pCandidate : maVector) + { + if(pCandidate->getOverlayManager()) + pCandidate->getOverlayManager()->remove(*pCandidate); + } + maVector.clear(); + } + + void OverlayObjectList::append(std::unique_ptr<OverlayObject> pOverlayObject) + { + assert(pOverlayObject && "tried to add invalid OverlayObject to OverlayObjectList"); + maVector.push_back(std::move(pOverlayObject)); + } + + bool OverlayObjectList::isHitLogic(const basegfx::B2DPoint& rLogicPosition, double fLogicTolerance) const + { + if(!maVector.empty()) + { + OverlayObject* pFirst = maVector.front().get(); + OverlayManager* pManager = pFirst->getOverlayManager(); + + if(pManager) + { + if(0.0 == fLogicTolerance) + { + Size aSizeLogic(pManager->getOutputDevice().PixelToLogic( + Size(DEFAULT_VALUE_FOR_HITTEST_PIXEL, DEFAULT_VALUE_FOR_HITTEST_PIXEL))); + + // When tiled rendering, we always work in logic units, use the non-pixel default. + if (comphelper::LibreOfficeKit::isActive()) + { + aSizeLogic = Size(DEFAULT_VALUE_FOR_HITTEST_TWIP, DEFAULT_VALUE_FOR_HITTEST_TWIP); + if (pManager->getOutputDevice().GetMapMode().GetMapUnit() == MapUnit::Map100thMM) + aSizeLogic = OutputDevice::LogicToLogic(aSizeLogic, MapMode(MapUnit::MapTwip), MapMode(MapUnit::Map100thMM)); + } + + fLogicTolerance = aSizeLogic.Width(); + } + + const drawinglayer::geometry::ViewInformation2D& aViewInformation2D(pManager->getCurrentViewInformation2D()); + drawinglayer::processor2d::HitTestProcessor2D aHitTestProcessor2D( + aViewInformation2D, + rLogicPosition, + fLogicTolerance, + false); + + for(auto & pCandidate : maVector) + { + if(pCandidate->isHittable()) + { + const drawinglayer::primitive2d::Primitive2DContainer& rSequence = pCandidate->getOverlayObjectPrimitive2DSequence(); + + if(!rSequence.empty()) + { + aHitTestProcessor2D.process(rSequence); + + if(aHitTestProcessor2D.getHit()) + { + return true; + } + } + } + } + } + } + + return false; + } + + bool OverlayObjectList::isHitPixel(const Point& rDiscretePosition) const + { + sal_uInt32 nDiscreteTolerance = DEFAULT_VALUE_FOR_HITTEST_PIXEL; + if(!maVector.empty()) + { + OverlayObject* pCandidate = maVector.front().get(); + OverlayManager* pManager = pCandidate->getOverlayManager(); + + if(pManager) + { + const Point aPosLogic(pManager->getOutputDevice().PixelToLogic(rDiscretePosition)); + const basegfx::B2DPoint aPosition(aPosLogic.X(), aPosLogic.Y()); + + const Size aSizeLogic(pManager->getOutputDevice().PixelToLogic(Size(nDiscreteTolerance, nDiscreteTolerance))); + return isHitLogic(aPosition, static_cast<double>(aSizeLogic.Width())); + } + } + + return false; + } + + basegfx::B2DRange OverlayObjectList::getBaseRange() const + { + basegfx::B2DRange aRetval; + + for(auto & pCandidate : maVector) + { + aRetval.expand(pCandidate->getBaseRange()); + } + + return aRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlaypolypolygon.cxx b/svx/source/sdr/overlay/overlaypolypolygon.cxx new file mode 100644 index 000000000..650b64207 --- /dev/null +++ b/svx/source/sdr/overlay/overlaypolypolygon.cxx @@ -0,0 +1,83 @@ +/* -*- 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 <svx/sdr/overlay/overlaypolypolygon.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <drawinglayer/primitive2d/PolyPolygonMarkerPrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonSelectionPrimitive2D.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayPolyPolygonStripedAndFilled::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if(getOverlayManager()) + { + const basegfx::BColor aRGBColorA(getOverlayManager()->getStripeColorA().getBColor()); + const basegfx::BColor aRGBColorB(getOverlayManager()->getStripeColorB().getBColor()); + const double fStripeLengthPixel(getOverlayManager()->getStripeLengthPixel()); + const drawinglayer::primitive2d::Primitive2DReference aStriped( + new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D( + getLinePolyPolygon(), + aRGBColorA, + aRGBColorB, + fStripeLengthPixel)); + + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aStriped }; + + const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer; + const basegfx::BColor aHilightColor(aSvtOptionsDrawinglayer.getHilightColor().getBColor()); + const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01); + + const drawinglayer::primitive2d::Primitive2DReference aFilled( + new drawinglayer::primitive2d::PolyPolygonSelectionPrimitive2D( + getLinePolyPolygon(), + aHilightColor, + fTransparence, + 3.0, + false)); + + aRetval.push_back(aFilled); + } + + return aRetval; + } + + void OverlayPolyPolygonStripedAndFilled::stripeDefinitionHasChanged() + { + // react on OverlayManager's stripe definition change + objectChange(); + } + + OverlayPolyPolygonStripedAndFilled::OverlayPolyPolygonStripedAndFilled( + const basegfx::B2DPolyPolygon& rLinePolyPolygon) + : OverlayObject(COL_BLACK), + maLinePolyPolygon(rLinePolyPolygon) + { + } + + OverlayPolyPolygonStripedAndFilled::~OverlayPolyPolygonStripedAndFilled() + { + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayprimitive2dsequenceobject.cxx b/svx/source/sdr/overlay/overlayprimitive2dsequenceobject.cxx new file mode 100644 index 000000000..9b589ed04 --- /dev/null +++ b/svx/source/sdr/overlay/overlayprimitive2dsequenceobject.cxx @@ -0,0 +1,42 @@ +/* -*- 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 <svx/sdr/overlay/overlayprimitive2dsequenceobject.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayPrimitive2DSequenceObject::createOverlayObjectPrimitive2DSequence() + { + return maSequence; + } + + OverlayPrimitive2DSequenceObject::OverlayPrimitive2DSequenceObject(const drawinglayer::primitive2d::Primitive2DContainer& rSequence) + : OverlayObjectWithBasePosition(basegfx::B2DPoint(), COL_BLACK), + maSequence(rSequence) + { + } + + OverlayPrimitive2DSequenceObject::~OverlayPrimitive2DSequenceObject() + { + } +} // end of namespace sdr::overlay + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayrectangle.cxx b/svx/source/sdr/overlay/overlayrectangle.cxx new file mode 100644 index 000000000..cf02b3498 --- /dev/null +++ b/svx/source/sdr/overlay/overlayrectangle.cxx @@ -0,0 +1,113 @@ +/* -*- 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 <sdr/overlay/overlayrectangle.hxx> +#include <sdr/overlay/overlaytools.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayRectangle::createOverlayObjectPrimitive2DSequence() + { + const basegfx::B2DRange aHatchRange(getBasePosition(), maSecondPosition); + basegfx::BColor aColor(getBaseColor().getBColor()); + static const double fChange(0.1); // just small optical change, do not make it annoying + + if(mbOverlayState) + { + aColor += basegfx::B3DTuple(fChange, fChange, fChange); + aColor.clamp(); + } + else + { + aColor -= basegfx::B3DTuple(fChange, fChange, fChange); + aColor.clamp(); + } + + const drawinglayer::primitive2d::Primitive2DReference aReference( + new drawinglayer::primitive2d::OverlayRectanglePrimitive( + aHatchRange, + aColor, + mfTransparence, + mfDiscreteGrow, + mfDiscreteShrink, + mfRotation)); + + return drawinglayer::primitive2d::Primitive2DContainer { aReference }; + } + + OverlayRectangle::OverlayRectangle( + const basegfx::B2DPoint& rBasePosition, + const basegfx::B2DPoint& rSecondPosition, + const Color& rHatchColor, + double fTransparence, + double fDiscreteGrow, + double fDiscreteShrink, + double fRotation, + bool bAnimate) + : OverlayObjectWithBasePosition(rBasePosition, rHatchColor), + maSecondPosition(rSecondPosition), + mfTransparence(fTransparence), + mfDiscreteGrow(fDiscreteGrow), + mfDiscreteShrink(fDiscreteShrink), + mfRotation(fRotation), + mnBlinkTime(impCheckBlinkTimeValueRange(500)), + mbOverlayState(false) + { + if(Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + // no animation in high contrast mode + bAnimate = false; + } + + // set AllowsAnimation flag to mark this object as animation capable + mbAllowsAnimation = bAnimate; + } + + void OverlayRectangle::Trigger(sal_uInt32 nTime) + { + if(getOverlayManager()) + { + // #i53216# produce event after nTime + x + SetTime(nTime + mnBlinkTime); + + // switch state + if(mbOverlayState) + { + mbOverlayState = false; + } + else + { + mbOverlayState = true; + } + + // re-insert me as event + getOverlayManager()->InsertEvent(*this); + + // register change (after change) + objectChange(); + } + } +} // end of namespace + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayrollingrectangle.cxx b/svx/source/sdr/overlay/overlayrollingrectangle.cxx new file mode 100644 index 000000000..1619139db --- /dev/null +++ b/svx/source/sdr/overlay/overlayrollingrectangle.cxx @@ -0,0 +1,117 @@ +/* -*- 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 <sdr/overlay/overlayrollingrectangle.hxx> +#include <sdr/overlay/overlaytools.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/primitive2d/PolyPolygonMarkerPrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonSelectionPrimitive2D.hxx> + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayRollingRectangleStriped::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DContainer aRetval; + + if(getOverlayManager() && (mbShowBounds || mbExtendedLines)) + { + const basegfx::BColor aRGBColorA(getOverlayManager()->getStripeColorA().getBColor()); + const basegfx::BColor aRGBColorB(getOverlayManager()->getStripeColorB().getBColor()); + const double fStripeLengthPixel(getOverlayManager()->getStripeLengthPixel()); + const basegfx::B2DRange aRollingRectangle(getBasePosition(), getSecondPosition()); + + if(mbShowBounds) + { + // view-independent part, create directly + const basegfx::B2DPolygon aPolygon(basegfx::utils::createPolygonFromRect(aRollingRectangle)); + + aRetval.resize(2); + aRetval[0] = new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D( + basegfx::B2DPolyPolygon(aPolygon), + aRGBColorA, + aRGBColorB, + fStripeLengthPixel); + + const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer; + const basegfx::BColor aHilightColor(aSvtOptionsDrawinglayer.getHilightColor().getBColor()); + const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01); + + aRetval[1] = new drawinglayer::primitive2d::PolyPolygonSelectionPrimitive2D( + basegfx::B2DPolyPolygon(aPolygon), + aHilightColor, + fTransparence, + 3.0, + false); + } + + if(mbExtendedLines) + { + // view-dependent part, use helper primitive + const drawinglayer::primitive2d::Primitive2DReference aReference( + new drawinglayer::primitive2d::OverlayRollingRectanglePrimitive( + aRollingRectangle, + aRGBColorA, + aRGBColorB, + fStripeLengthPixel)); + + aRetval.push_back(aReference); + } + } + + return aRetval; + } + + void OverlayRollingRectangleStriped::stripeDefinitionHasChanged() + { + // react on OverlayManager's stripe definition change + objectChange(); + } + + OverlayRollingRectangleStriped::OverlayRollingRectangleStriped( + const basegfx::B2DPoint& rBasePos, + const basegfx::B2DPoint& rSecondPos, + bool bExtendedLines, + bool bShowBounds) + : OverlayObjectWithBasePosition(rBasePos, COL_BLACK), + maSecondPosition(rSecondPos), + mbExtendedLines(bExtendedLines), + mbShowBounds(bShowBounds) + { + } + + OverlayRollingRectangleStriped::~OverlayRollingRectangleStriped() + { + } + + void OverlayRollingRectangleStriped::setSecondPosition(const basegfx::B2DPoint& rNew) + { + if(rNew != maSecondPosition) + { + // remember new value + maSecondPosition = rNew; + + // register change (after change) + objectChange(); + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlayselection.cxx b/svx/source/sdr/overlay/overlayselection.cxx new file mode 100644 index 000000000..4abcd2bd7 --- /dev/null +++ b/svx/source/sdr/overlay/overlayselection.cxx @@ -0,0 +1,223 @@ +/* -*- 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 <svx/sdr/overlay/overlayselection.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonHairlinePrimitive2D.hxx> +#include <svtools/optionsdrawinglayer.hxx> +#include <vcl/svapp.hxx> +#include <vcl/outdev.hxx> +#include <vcl/settings.hxx> +#include <drawinglayer/primitive2d/invertprimitive2d.hxx> +#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> +#include <basegfx/polygon/b2dpolypolygoncutter.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> + + +namespace sdr::overlay +{ + // combine rages geometrically to a single, ORed polygon + static basegfx::B2DPolyPolygon impCombineRangesToPolyPolygon(const std::vector< basegfx::B2DRange >& rRanges) + { + const sal_uInt32 nCount(rRanges.size()); + basegfx::B2DPolyPolygon aRetval; + + for(sal_uInt32 a(0); a < nCount; a++) + { + const basegfx::B2DPolygon aDiscretePolygon(basegfx::utils::createPolygonFromRect(rRanges[a])); + + if(0 == a) + { + aRetval.append(aDiscretePolygon); + } + else + { + aRetval = basegfx::utils::solvePolygonOperationOr(aRetval, basegfx::B2DPolyPolygon(aDiscretePolygon)); + } + } + + return aRetval; + } + + // check if wanted type OverlayType::Transparent or OverlayType::Solid + // is possible. If not, fallback to invert mode (classic mode) + static OverlayType impCheckPossibleOverlayType(OverlayType aOverlayType) + { + if(OverlayType::Invert != aOverlayType) + { + const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer; + + if(!aSvtOptionsDrawinglayer.IsTransparentSelection()) + { + // not possible when switched off by user + return OverlayType::Invert; + } + else if (const OutputDevice* pOut = Application::GetDefaultDevice()) + { + + if(pOut->GetSettings().GetStyleSettings().GetHighContrastMode()) + { + // not possible when in high contrast mode + return OverlayType::Invert; + } + + if(!pOut->SupportsOperation(OutDevSupportType::TransparentRect)) + { + // not possible when no fast transparence paint is supported on the system + return OverlayType::Invert; + } + } + } + + return aOverlayType; + } + + drawinglayer::primitive2d::Primitive2DContainer OverlaySelection::createOverlayObjectPrimitive2DSequence() + { + drawinglayer::primitive2d::Primitive2DContainer aRetval; + const sal_uInt32 nCount(getRanges().size()); + + if(nCount) + { + // create range primitives + const bool bInvert(OverlayType::Invert == maLastOverlayType); + basegfx::BColor aRGBColor(getBaseColor().getBColor()); + aRetval.resize(nCount); + + if(bInvert) + { + // force color to white for invert to get a full invert + aRGBColor = basegfx::BColor(1.0, 1.0, 1.0); + } + + for(sal_uInt32 a(0);a < nCount; a++) + { + const basegfx::B2DPolygon aPolygon(basegfx::utils::createPolygonFromRect(maRanges[a])); + aRetval[a] = drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( + basegfx::B2DPolyPolygon(aPolygon), + aRGBColor)); + } + + if(bInvert) + { + // embed all in invert primitive + const drawinglayer::primitive2d::Primitive2DReference aInvert( + new drawinglayer::primitive2d::InvertPrimitive2D( + aRetval)); + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aInvert }; + } + else if(OverlayType::Transparent == maLastOverlayType) + { + // embed all rectangles in transparent paint + const double fTransparence(mnLastTransparence / 100.0); + const drawinglayer::primitive2d::Primitive2DReference aUnifiedTransparence( + new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D( + aRetval, + fTransparence)); + + if(mbBorder) + { + const basegfx::B2DPolyPolygon aPolyPolygon(impCombineRangesToPolyPolygon(getRanges())); + const drawinglayer::primitive2d::Primitive2DReference aSelectionOutline( + new drawinglayer::primitive2d::PolyPolygonHairlinePrimitive2D( + aPolyPolygon, + aRGBColor)); + + // add both to result + aRetval.resize(2); + aRetval[0] = aUnifiedTransparence; + aRetval[1] = aSelectionOutline; + } + else + { + // just add transparent part + aRetval = drawinglayer::primitive2d::Primitive2DContainer { aUnifiedTransparence }; + } + } + } + + return aRetval; + } + + OverlaySelection::OverlaySelection( + OverlayType eType, + const Color& rColor, + const std::vector< basegfx::B2DRange >& rRanges, + bool bBorder) + : OverlayObject(rColor), + meOverlayType(eType), + maRanges(rRanges), + maLastOverlayType(eType), + mnLastTransparence(0), + mbBorder(bBorder) + { + // no AA for selection overlays + allowAntiAliase(false); + } + + OverlaySelection::~OverlaySelection() + { + if(getOverlayManager()) + { + getOverlayManager()->remove(*this); + } + } + + drawinglayer::primitive2d::Primitive2DContainer OverlaySelection::getOverlayObjectPrimitive2DSequence() const + { + // get current values + const OverlayType aNewOverlayType(impCheckPossibleOverlayType(meOverlayType)); + const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer; + const sal_uInt16 nNewTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent()); + + if(!getPrimitive2DSequence().empty()) + { + if(aNewOverlayType != maLastOverlayType + || nNewTransparence != mnLastTransparence) + { + // conditions of last local decomposition have changed, delete + const_cast< OverlaySelection* >(this)->resetPrimitive2DSequence(); + } + } + + if(getPrimitive2DSequence().empty()) + { + // remember new values + const_cast< OverlaySelection* >(this)->maLastOverlayType = aNewOverlayType; + const_cast< OverlaySelection* >(this)->mnLastTransparence = nNewTransparence; + } + + // call base implementation + return OverlayObject::getOverlayObjectPrimitive2DSequence(); + } + + void OverlaySelection::setRanges(const std::vector< basegfx::B2DRange >& rNew) + { + if(rNew != maRanges) + { + maRanges = rNew; + objectChange(); + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlaytools.cxx b/svx/source/sdr/overlay/overlaytools.cxx new file mode 100644 index 000000000..e3988797b --- /dev/null +++ b/svx/source/sdr/overlay/overlaytools.cxx @@ -0,0 +1,589 @@ +/* -*- 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 <sdr/overlay/overlaytools.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonHatchPrimitive2D.hxx> +#include <drawinglayer/geometry/viewinformation2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <toolkit/helper/vclunohelper.hxx> + + +namespace drawinglayer::primitive2d +{ + +OverlayStaticRectanglePrimitive::OverlayStaticRectanglePrimitive( + const basegfx::B2DPoint& rPosition, + const basegfx::B2DSize& rSize, + const basegfx::BColor& rStrokeColor, + const basegfx::BColor& rFillColor, + double fTransparence, + double fRotation) + : DiscreteMetricDependentPrimitive2D() + , maPosition(rPosition) + , maSize(rSize) + , maStrokeColor(rStrokeColor) + , maFillColor(rFillColor) + , mfTransparence(fTransparence) + , mfRotation(fRotation) +{} + +void OverlayStaticRectanglePrimitive::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const +{ + Primitive2DContainer aPrimitive2DSequence; + const double fHalfWidth = maSize.getX() * getDiscreteUnit() / 2.0; + const double fHalfHeight = maSize.getY() * getDiscreteUnit() / 2.0; + + basegfx::B2DRange aRange( + maPosition.getX() - fHalfWidth, maPosition.getY() - fHalfHeight, + maPosition.getX() + fHalfWidth, maPosition.getY() + fHalfHeight); + + if (basegfx::fTools::more(getDiscreteUnit(), 0.0) && mfTransparence <= 1.0) + { + basegfx::B2DPolygon aPolygon( + basegfx::utils::createPolygonFromRect(aRange)); + + // create filled primitive + basegfx::B2DPolyPolygon aPolyPolygon; + aPolyPolygon.append(aPolygon); + + const attribute::LineAttribute aLineAttribute(maStrokeColor, 1.0); + + // create data + const Primitive2DReference aStroke( + new PolyPolygonStrokePrimitive2D(aPolyPolygon, aLineAttribute)); + + // create fill primitive + const Primitive2DReference aFill( + new PolyPolygonColorPrimitive2D(aPolyPolygon, maFillColor)); + + aPrimitive2DSequence = Primitive2DContainer(2); + aPrimitive2DSequence[0] = aFill; + aPrimitive2DSequence[1] = aStroke; + + // embed filled to transparency (if used) + if (mfTransparence > 0.0) + { + const Primitive2DReference aFillTransparent( + new UnifiedTransparencePrimitive2D( + aPrimitive2DSequence, + mfTransparence)); + + aPrimitive2DSequence = Primitive2DContainer { aFillTransparent }; + } + } + + rContainer.insert(rContainer.end(), aPrimitive2DSequence.begin(), aPrimitive2DSequence.end()); +} + +bool OverlayStaticRectanglePrimitive::operator==(const BasePrimitive2D& rPrimitive) const +{ + if (DiscreteMetricDependentPrimitive2D::operator==(rPrimitive)) + { + const OverlayStaticRectanglePrimitive& rCompare = static_cast<const OverlayStaticRectanglePrimitive&>(rPrimitive); + + return (maPosition == rCompare.maPosition + && maSize == rCompare.maSize + && maStrokeColor == rCompare.maStrokeColor + && maFillColor == rCompare.maFillColor + && mfTransparence == rCompare.mfTransparence + && mfRotation == rCompare.mfRotation); + } + + return false; +} + +ImplPrimitive2DIDBlock(OverlayStaticRectanglePrimitive, PRIMITIVE2D_ID_OVERLAYRECTANGLEPRIMITIVE) + + + + OverlayBitmapExPrimitive::OverlayBitmapExPrimitive( + const BitmapEx& rBitmapEx, + const basegfx::B2DPoint& rBasePosition, + sal_uInt16 nCenterX, + sal_uInt16 nCenterY, + double fShearX, + double fRotation) + : DiscreteMetricDependentPrimitive2D(), + maBitmapEx(rBitmapEx), + maBasePosition(rBasePosition), + mnCenterX(nCenterX), + mnCenterY(nCenterY), + mfShearX(fShearX), + mfRotation(fRotation) + {} + + void OverlayBitmapExPrimitive::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const + { + const Size aBitmapSize(getBitmapEx().GetSizePixel()); + + if(!aBitmapSize.Width() || !aBitmapSize.Height() || !basegfx::fTools::more(getDiscreteUnit(), 0.0)) + return; + + // calculate back from internal bitmap's extreme coordinates (the edges) + // to logical coordinates. Only use a unified scaling value (getDiscreteUnit(), + // the prepared one which expresses how many logic units form a discrete unit) + // for this step. This primitive is to be displayed always unscaled (in its pixel size) + // and unrotated, more like a marker + const double fLeft((0.0 - getCenterX()) * getDiscreteUnit()); + const double fTop((0.0 - getCenterY()) * getDiscreteUnit()); + const double fRight((aBitmapSize.getWidth() - getCenterX()) * getDiscreteUnit()); + const double fBottom((aBitmapSize.getHeight() - getCenterY()) * getDiscreteUnit()); + + // create a BitmapPrimitive2D using those positions + basegfx::B2DHomMatrix aTransform; + + aTransform.set(0, 0, fRight - fLeft); + aTransform.set(1, 1, fBottom - fTop); + aTransform.set(0, 2, fLeft); + aTransform.set(1, 2, fTop); + + // if shearX is used, apply it, too + if(!basegfx::fTools::equalZero(getShearX())) + { + aTransform.shearX(getShearX()); + } + + // if rotation is used, apply it, too + if(!basegfx::fTools::equalZero(getRotation())) + { + aTransform.rotate(getRotation()); + } + + // add BasePosition + aTransform.translate(getBasePosition().getX(), getBasePosition().getY()); + + rContainer.push_back( + new BitmapPrimitive2D( + VCLUnoHelper::CreateVCLXBitmap(getBitmapEx()), + aTransform)); + } + + bool OverlayBitmapExPrimitive::operator==( const BasePrimitive2D& rPrimitive ) const + { + if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive)) + { + const OverlayBitmapExPrimitive& rCompare = static_cast< const OverlayBitmapExPrimitive& >(rPrimitive); + + return (getBitmapEx() == rCompare.getBitmapEx() + && getBasePosition() == rCompare.getBasePosition() + && getCenterX() == rCompare.getCenterX() + && getCenterY() == rCompare.getCenterY() + && getShearX() == rCompare.getShearX() + && getRotation() == rCompare.getRotation()); + } + + return false; + } + + ImplPrimitive2DIDBlock(OverlayBitmapExPrimitive, PRIMITIVE2D_ID_OVERLAYBITMAPEXPRIMITIVE) + + + + OverlayCrosshairPrimitive::OverlayCrosshairPrimitive( + const basegfx::B2DPoint& rBasePosition, + const basegfx::BColor& rRGBColorA, + const basegfx::BColor& rRGBColorB, + double fDiscreteDashLength) + : ViewportDependentPrimitive2D(), + maBasePosition(rBasePosition), + maRGBColorA(rRGBColorA), + maRGBColorB(rRGBColorB), + mfDiscreteDashLength(fDiscreteDashLength) + {} + + void OverlayCrosshairPrimitive::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const + { + // use the prepared Viewport information accessible using getViewport() + + if(!getViewport().isEmpty()) + { + basegfx::B2DPolygon aPolygon; + + aPolygon.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY())); + aPolygon.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY())); + + rContainer.push_back( + new PolygonMarkerPrimitive2D( + aPolygon, + getRGBColorA(), + getRGBColorB(), + getDiscreteDashLength())); + + aPolygon.clear(); + aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY())); + aPolygon.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY())); + + rContainer.push_back( + new PolygonMarkerPrimitive2D( + aPolygon, + getRGBColorA(), + getRGBColorB(), + getDiscreteDashLength())); + } + } + + bool OverlayCrosshairPrimitive::operator==( const BasePrimitive2D& rPrimitive ) const + { + if(ViewportDependentPrimitive2D::operator==(rPrimitive)) + { + const OverlayCrosshairPrimitive& rCompare = static_cast< const OverlayCrosshairPrimitive& >(rPrimitive); + + return (getBasePosition() == rCompare.getBasePosition() + && getRGBColorA() == rCompare.getRGBColorA() + && getRGBColorB() == rCompare.getRGBColorB() + && getDiscreteDashLength() == rCompare.getDiscreteDashLength()); + } + + return false; + } + + ImplPrimitive2DIDBlock(OverlayCrosshairPrimitive, PRIMITIVE2D_ID_OVERLAYCROSSHAIRPRIMITIVE) + + + + OverlayRectanglePrimitive::OverlayRectanglePrimitive( + const basegfx::B2DRange& rObjectRange, + const basegfx::BColor& rColor, + double fTransparence, + double fDiscreteGrow, + double fDiscreteShrink, + double fRotation) + : DiscreteMetricDependentPrimitive2D(), + maObjectRange(rObjectRange), + maColor(rColor), + mfTransparence(fTransparence), + mfDiscreteGrow(fDiscreteGrow), + mfDiscreteShrink(fDiscreteShrink), + mfRotation(fRotation) + {} + + void OverlayRectanglePrimitive::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const + { + Primitive2DContainer aRetval; + basegfx::B2DRange aInnerRange(getObjectRange()); + + if(!aInnerRange.isEmpty() && basegfx::fTools::more(getDiscreteUnit(), 0.0) && getTransparence() <= 1.0) + { + basegfx::B2DRange aOuterRange(getObjectRange()); + + // grow/shrink inner/outer polygons + aOuterRange.grow(getDiscreteUnit() * getDiscreteGrow()); + aInnerRange.grow(getDiscreteUnit() * -getDiscreteShrink()); + + // convert to polygons + const double fFullGrow(getDiscreteGrow() + getDiscreteShrink()); + const double fRelativeRadiusX(fFullGrow / aOuterRange.getWidth()); + const double fRelativeRadiusY(fFullGrow / aOuterRange.getHeight()); + basegfx::B2DPolygon aOuterPolygon( + basegfx::utils::createPolygonFromRect( + aOuterRange, + fRelativeRadiusX, + fRelativeRadiusY)); + basegfx::B2DPolygon aInnerPolygon( + basegfx::utils::createPolygonFromRect( + aInnerRange)); + + // apply evtl. existing rotation + if(!basegfx::fTools::equalZero(getRotation())) + { + const basegfx::B2DHomMatrix aTransform(basegfx::utils::createRotateAroundPoint( + getObjectRange().getMinX(), getObjectRange().getMinY(), getRotation())); + + aOuterPolygon.transform(aTransform); + aInnerPolygon.transform(aTransform); + } + + // create filled primitive + basegfx::B2DPolyPolygon aPolyPolygon; + + aPolyPolygon.append(aOuterPolygon); + aPolyPolygon.append(aInnerPolygon); + + if(Application::GetSettings().GetStyleSettings().GetHighContrastMode()) + { + // for high contrast, use hatch + const basegfx::BColor aHighContrastLineColor(Application::GetSettings().GetStyleSettings().GetFontColor().getBColor()); + const basegfx::BColor aEmptyColor(0.0, 0.0, 0.0); + const double fHatchRotation(basegfx::deg2rad(45)); + const double fDiscreteHatchDistance(3.0); + const drawinglayer::attribute::FillHatchAttribute aFillHatchAttribute( + drawinglayer::attribute::HatchStyle::Single, + fDiscreteHatchDistance * getDiscreteUnit(), + fHatchRotation - getRotation(), + aHighContrastLineColor, + 3, // same default as VCL, a minimum of three discrete units (pixels) offset + false); + const Primitive2DReference aHatch( + new PolyPolygonHatchPrimitive2D( + aPolyPolygon, + aEmptyColor, + aFillHatchAttribute)); + + aRetval = Primitive2DContainer { aHatch }; + } + else + { + // create fill primitive + const Primitive2DReference aFill( + new PolyPolygonColorPrimitive2D( + aPolyPolygon, + getColor())); + + aRetval = Primitive2DContainer { aFill }; + + // embed filled to transparency (if used) + if(getTransparence() > 0.0) + { + const Primitive2DReference aFillTransparent( + new UnifiedTransparencePrimitive2D( + aRetval, + getTransparence())); + + aRetval = Primitive2DContainer { aFillTransparent }; + } + } + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + bool OverlayRectanglePrimitive::operator==( const BasePrimitive2D& rPrimitive ) const + { + if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive)) + { + const OverlayRectanglePrimitive& rCompare = static_cast< const OverlayRectanglePrimitive& >(rPrimitive); + + return (getObjectRange() == rCompare.getObjectRange() + && getColor() == rCompare.getColor() + && getTransparence() == rCompare.getTransparence() + && getDiscreteGrow() == rCompare.getDiscreteGrow() + && getDiscreteShrink() == rCompare.getDiscreteShrink() + && getRotation() == rCompare.getRotation()); + } + + return false; + } + + ImplPrimitive2DIDBlock(OverlayRectanglePrimitive, PRIMITIVE2D_ID_OVERLAYRECTANGLEPRIMITIVE) + + + + OverlayHelplineStripedPrimitive::OverlayHelplineStripedPrimitive( + const basegfx::B2DPoint& rBasePosition, + HelplineStyle eStyle, + const basegfx::BColor& rRGBColorA, + const basegfx::BColor& rRGBColorB, + double fDiscreteDashLength) + : ViewportDependentPrimitive2D(), + maBasePosition(rBasePosition), + meStyle(eStyle), + maRGBColorA(rRGBColorA), + maRGBColorB(rRGBColorB), + mfDiscreteDashLength(fDiscreteDashLength) + {} + + void OverlayHelplineStripedPrimitive::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& rViewInformation) const + { + // use the prepared Viewport information accessible using getViewport() + + if(!getViewport().isEmpty()) + { + switch(getStyle()) + { + case HELPLINESTYLE_VERTICAL : + { + basegfx::B2DPolygon aLine; + + aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMinY())); + aLine.append(basegfx::B2DPoint(getBasePosition().getX(), getViewport().getMaxY())); + + rContainer.push_back( + new PolygonMarkerPrimitive2D( + aLine, + getRGBColorA(), + getRGBColorB(), + getDiscreteDashLength())); + break; + } + + case HELPLINESTYLE_HORIZONTAL : + { + basegfx::B2DPolygon aLine; + + aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getBasePosition().getY())); + aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getBasePosition().getY())); + + rContainer.push_back( + new PolygonMarkerPrimitive2D( + aLine, + getRGBColorA(), + getRGBColorB(), + getDiscreteDashLength())); + break; + } + + default: // case HELPLINESTYLE_POINT : + { + const double fDiscreteUnit((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0)).getLength()); + basegfx::B2DPolygon aLineA, aLineB; + + aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() - fDiscreteUnit)); + aLineA.append(basegfx::B2DPoint(getBasePosition().getX(), getBasePosition().getY() + fDiscreteUnit)); + + rContainer.push_back( + new PolygonMarkerPrimitive2D( + aLineA, + getRGBColorA(), + getRGBColorB(), + getDiscreteDashLength())); + + aLineB.append(basegfx::B2DPoint(getBasePosition().getX() - fDiscreteUnit, getBasePosition().getY())); + aLineB.append(basegfx::B2DPoint(getBasePosition().getX() + fDiscreteUnit, getBasePosition().getY())); + + rContainer.push_back( + new PolygonMarkerPrimitive2D( + aLineB, + getRGBColorA(), + getRGBColorB(), + getDiscreteDashLength())); + + break; + } + } + } + } + + bool OverlayHelplineStripedPrimitive::operator==( const BasePrimitive2D& rPrimitive ) const + { + if(ViewportDependentPrimitive2D::operator==(rPrimitive)) + { + const OverlayHelplineStripedPrimitive& rCompare = static_cast< const OverlayHelplineStripedPrimitive& >(rPrimitive); + + return (getBasePosition() == rCompare.getBasePosition() + && getStyle() == rCompare.getStyle() + && getRGBColorA() == rCompare.getRGBColorA() + && getRGBColorB() == rCompare.getRGBColorB() + && getDiscreteDashLength() == rCompare.getDiscreteDashLength()); + } + + return false; + } + + ImplPrimitive2DIDBlock(OverlayHelplineStripedPrimitive, PRIMITIVE2D_ID_OVERLAYHELPLINESTRIPEDPRIMITIVE) + + + + OverlayRollingRectanglePrimitive::OverlayRollingRectanglePrimitive( + const basegfx::B2DRange& aRollingRectangle, + const basegfx::BColor& rRGBColorA, + const basegfx::BColor& rRGBColorB, + double fDiscreteDashLength) + : ViewportDependentPrimitive2D(), + maRollingRectangle(aRollingRectangle), + maRGBColorA(rRGBColorA), + maRGBColorB(rRGBColorB), + mfDiscreteDashLength(fDiscreteDashLength) + {} + + void OverlayRollingRectanglePrimitive::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const + { + // use the prepared Viewport information accessible using getViewport() + + if(getViewport().isEmpty()) + return; + + basegfx::B2DPolygon aLine; + + // Left lines + aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMinY())); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + aLine.clear(); + aLine.append(basegfx::B2DPoint(getViewport().getMinX(), getRollingRectangle().getMaxY())); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + // Right lines + aLine.clear(); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY())); + aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMinY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + aLine.clear(); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY())); + aLine.append(basegfx::B2DPoint(getViewport().getMaxX(), getRollingRectangle().getMaxY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + // Top lines + aLine.clear(); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMinY())); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMinY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + aLine.clear(); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMinY())); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMinY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + // Bottom lines + aLine.clear(); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getRollingRectangle().getMaxY())); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMinX(), getViewport().getMaxY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + aLine.clear(); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getRollingRectangle().getMaxY())); + aLine.append(basegfx::B2DPoint(getRollingRectangle().getMaxX(), getViewport().getMaxY())); + rContainer.push_back(new PolygonMarkerPrimitive2D(aLine, getRGBColorA(), getRGBColorB(), getDiscreteDashLength())); + + } + + bool OverlayRollingRectanglePrimitive::operator==( const BasePrimitive2D& rPrimitive ) const + { + if(ViewportDependentPrimitive2D::operator==(rPrimitive)) + { + const OverlayRollingRectanglePrimitive& rCompare = static_cast< const OverlayRollingRectanglePrimitive& >(rPrimitive); + + return (getRollingRectangle() == rCompare.getRollingRectangle() + && getRGBColorA() == rCompare.getRGBColorA() + && getRGBColorB() == rCompare.getRGBColorB() + && getDiscreteDashLength() == rCompare.getDiscreteDashLength()); + } + + return false; + } + + ImplPrimitive2DIDBlock(OverlayRollingRectanglePrimitive, PRIMITIVE2D_ID_OVERLAYROLLINGRECTANGLEPRIMITIVE) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/overlay/overlaytriangle.cxx b/svx/source/sdr/overlay/overlaytriangle.cxx new file mode 100644 index 000000000..f46fcf1e2 --- /dev/null +++ b/svx/source/sdr/overlay/overlaytriangle.cxx @@ -0,0 +1,61 @@ +/* -*- 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 <sdr/overlay/overlaytriangle.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> + + +namespace sdr::overlay +{ + drawinglayer::primitive2d::Primitive2DContainer OverlayTriangle::createOverlayObjectPrimitive2DSequence() + { + basegfx::B2DPolygon aPolygon; + + aPolygon.append(getBasePosition()); + aPolygon.append(maSecondPosition); + aPolygon.append(maThirdPosition); + aPolygon.setClosed(true); + + const drawinglayer::primitive2d::Primitive2DReference aReference( + new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D( + basegfx::B2DPolyPolygon(aPolygon), + getBaseColor().getBColor())); + + return drawinglayer::primitive2d::Primitive2DContainer { aReference }; + } + + OverlayTriangle::OverlayTriangle( + const basegfx::B2DPoint& rBasePos, + const basegfx::B2DPoint& rSecondPos, + const basegfx::B2DPoint& rThirdPos, + Color aTriangleColor) + : OverlayObjectWithBasePosition(rBasePos, aTriangleColor), + maSecondPosition(rSecondPos), + maThirdPosition(rThirdPos) + { + } + + OverlayTriangle::~OverlayTriangle() + { + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/primitivefactory2d.cxx b/svx/source/sdr/primitive2d/primitivefactory2d.cxx new file mode 100644 index 000000000..2ce496052 --- /dev/null +++ b/svx/source/sdr/primitive2d/primitivefactory2d.cxx @@ -0,0 +1,113 @@ +/* -*- 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 <com/sun/star/graphic/XPrimitiveFactory2D.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <cppuhelper/compbase.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdpage.hxx> +#include <svx/unoapi.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <comphelper/sequence.hxx> + +using namespace com::sun::star; + +namespace { + +typedef cppu::WeakComponentImplHelper< css::graphic::XPrimitiveFactory2D, css::lang::XServiceInfo > PrimitiveFactory2DImplBase; + +// base class for C++ implementation of css::graphic::XPrimitiveFactory2D +class PrimitiveFactory2D + : protected cppu::BaseMutex, + public PrimitiveFactory2DImplBase +{ +public: + PrimitiveFactory2D(): PrimitiveFactory2DImplBase(m_aMutex) {} + + // Methods from XPrimitiveFactory2D + virtual css::uno::Sequence< css::uno::Reference< css::graphic::XPrimitive2D > > SAL_CALL createPrimitivesFromXShape( const css::uno::Reference< css::drawing::XShape >& xShape, const css::uno::Sequence< css::beans::PropertyValue >& aParms ) override; + virtual css::uno::Sequence< css::uno::Reference< css::graphic::XPrimitive2D > > SAL_CALL createPrimitivesFromXDrawPage( const css::uno::Reference< css::drawing::XDrawPage >& xDrawPage, const css::uno::Sequence< css::beans::PropertyValue >& aParms ) override; + + OUString SAL_CALL getImplementationName() override + { return "com.sun.star.comp.graphic.PrimitiveFactory2D"; } + + sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override + { return cppu::supportsService(this, ServiceName); } + + css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override + { + return css::uno::Sequence<OUString>{ + "com.sun.star.graphic.PrimitiveFactory2D"}; + } +}; + +css::uno::Sequence< css::uno::Reference< css::graphic::XPrimitive2D > > SAL_CALL PrimitiveFactory2D::createPrimitivesFromXShape( + const uno::Reference< drawing::XShape >& xShape, + const uno::Sequence< beans::PropertyValue >& /*aParms*/ ) +{ + css::uno::Sequence< css::uno::Reference< css::graphic::XPrimitive2D > > aRetval; + + if(xShape.is()) + { + SdrObject* pSource = GetSdrObjectFromXShape(xShape); + + if(pSource) + { + const sdr::contact::ViewContact& rSource(pSource->GetViewContact()); + aRetval = comphelper::containerToSequence(rSource.getViewIndependentPrimitive2DContainer()); + } + } + + return aRetval; +} + +css::uno::Sequence< css::uno::Reference< css::graphic::XPrimitive2D > > SAL_CALL PrimitiveFactory2D::createPrimitivesFromXDrawPage( + const uno::Reference< drawing::XDrawPage >& xDrawPage, + const uno::Sequence< beans::PropertyValue >& /*aParms*/ ) +{ + css::uno::Sequence< css::uno::Reference< css::graphic::XPrimitive2D > > aRetval; + + if(xDrawPage.is()) + { + SdrPage* pSource = GetSdrPageFromXDrawPage(xDrawPage); + + if(pSource) + { + const sdr::contact::ViewContact& rSource(pSource->GetViewContact()); + + aRetval = comphelper::containerToSequence(rSource.getViewIndependentPrimitive2DContainer()); + } + } + + return aRetval; +} + +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +com_sun_star_comp_graphic_PrimitiveFactory2D_get_implementation( + css::uno::XComponentContext *, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new PrimitiveFactory2D); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrattributecreator.cxx b/svx/source/sdr/primitive2d/sdrattributecreator.cxx new file mode 100644 index 000000000..027d6fe94 --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrattributecreator.cxx @@ -0,0 +1,1129 @@ +/* -*- 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 <sdr/primitive2d/sdrattributecreator.hxx> +#include <svl/itemset.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/sdooitm.hxx> +#include <svx/sdprcitm.hxx> +#include <svx/xdef.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflbmpit.hxx> +#include <svx/xlntrit.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlinjoit.hxx> +#include <svx/xlncapit.hxx> +#include <svx/xlnclit.hxx> +#include <svx/xlnstwit.hxx> +#include <svx/xlnedwit.hxx> +#include <svx/xlnstit.hxx> +#include <svx/xlnstcit.hxx> +#include <svx/xlnedit.hxx> +#include <svx/xlnedcit.hxx> +#include <svx/xdash.hxx> +#include <svx/xlndsit.hxx> +#include <svx/xfltrit.hxx> +#include <svx/xflftrit.hxx> +#include <svx/xflclit.hxx> +#include <svx/xgrscit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xflbckit.hxx> +#include <svx/xflbmsxy.hxx> +#include <svx/xflbtoxy.hxx> +#include <svx/xflboxy.hxx> +#include <svx/xflbmtit.hxx> +#include <svx/xflbstit.hxx> +#include <svx/xtextit0.hxx> +#include <drawinglayer/attribute/sdrfillgraphicattribute.hxx> +#include <svx/svdotext.hxx> +#include <sdr/attribute/sdrtextattribute.hxx> +#include <svx/xbtmpit.hxx> +#include <svl/itempool.hxx> +#include <vcl/svapp.hxx> +#include <basegfx/range/b2drange.hxx> +#include <svx/svx3ditems.hxx> +#include <com/sun/star/drawing/ProjectionMode.hpp> +#include <com/sun/star/drawing/ShadeMode.hpp> +#include <drawinglayer/attribute/sdrallattribute3d.hxx> +#include <svx/rectenum.hxx> +#include <svx/sdtfchim.hxx> +#include <svx/svdoutl.hxx> +#include <svx/svdmodel.hxx> +#include <svx/xflbmsli.hxx> +#include <editeng/editstat.hxx> +#include <drawinglayer/attribute/fillhatchattribute.hxx> +#include <drawinglayer/attribute/fillgradientattribute.hxx> +#include <sdr/attribute/sdreffectstextattribute.hxx> +#include <sdr/attribute/sdrlineeffectstextattribute.hxx> +#include <sdr/attribute/sdrformtextattribute.hxx> +#include <sdr/attribute/sdrlinefilleffectstextattribute.hxx> +#include <drawinglayer/attribute/sdrglowattribute.hxx> +#include <drawinglayer/attribute/sdrsceneattribute3d.hxx> +#include <drawinglayer/attribute/sdrlightingattribute3d.hxx> +#include <drawinglayer/attribute/sdrlightattribute3d.hxx> +#include <sdr/attribute/sdrfilltextattribute.hxx> +#include <com/sun/star/drawing/LineCap.hpp> + +#include <sal/log.hxx> + +using namespace com::sun::star; + +namespace drawinglayer +{ + namespace + { + attribute::GradientStyle XGradientStyleToGradientStyle(css::awt::GradientStyle eStyle) + { + switch(eStyle) + { + case css::awt::GradientStyle_LINEAR : + { + return attribute::GradientStyle::Linear; + } + case css::awt::GradientStyle_AXIAL : + { + return attribute::GradientStyle::Axial; + } + case css::awt::GradientStyle_RADIAL : + { + return attribute::GradientStyle::Radial; + } + case css::awt::GradientStyle_ELLIPTICAL : + { + return attribute::GradientStyle::Elliptical; + } + case css::awt::GradientStyle_SQUARE : + { + return attribute::GradientStyle::Square; + } + default : + { + return attribute::GradientStyle::Rect; // css::awt::GradientStyle_RECT + } + } + } + + attribute::HatchStyle XHatchStyleToHatchStyle(css::drawing::HatchStyle eStyle) + { + switch(eStyle) + { + case css::drawing::HatchStyle_SINGLE : + { + return attribute::HatchStyle::Single; + } + case css::drawing::HatchStyle_DOUBLE : + { + return attribute::HatchStyle::Double; + } + default : + { + return attribute::HatchStyle::Triple; // css::drawing::HatchStyle_TRIPLE + } + } + } + + basegfx::B2DLineJoin LineJointToB2DLineJoin(css::drawing::LineJoint eLineJoint) + { + switch(eLineJoint) + { + case css::drawing::LineJoint_BEVEL : + { + return basegfx::B2DLineJoin::Bevel; + } + case css::drawing::LineJoint_MIDDLE : + case css::drawing::LineJoint_MITER : + { + return basegfx::B2DLineJoin::Miter; + } + case css::drawing::LineJoint_ROUND : + { + return basegfx::B2DLineJoin::Round; + } + default : // css::drawing::LineJoint_NONE + { + return basegfx::B2DLineJoin::NONE; + } + } + } + + basegfx::B2DVector RectPointToB2DVector(RectPoint eRectPoint) + { + basegfx::B2DVector aRetval(0.0, 0.0); + + // position changes X + switch(eRectPoint) + { + case RectPoint::LT: case RectPoint::LM: case RectPoint::LB: + { + aRetval.setX(-1.0); + break; + } + + case RectPoint::RT: case RectPoint::RM: case RectPoint::RB: + { + aRetval.setX(1.0); + break; + } + + default : + { + break; + } + } + + // position changes Y + switch(eRectPoint) + { + case RectPoint::LT: case RectPoint::MT: case RectPoint::RT: + { + aRetval.setY(-1.0); + break; + } + + case RectPoint::LB: case RectPoint::MB: case RectPoint::RB: + { + aRetval.setY(1.0); + break; + } + + default : + { + break; + } + } + + return aRetval; + } + + attribute::SdrGlowAttribute createNewSdrGlowAttribute(const SfxItemSet& rSet) + { + sal_Int32 nRadius = rSet.Get(SDRATTR_GLOW_RADIUS).GetValue(); + if (!nRadius) + return attribute::SdrGlowAttribute(); + Color aColor(rSet.Get(SDRATTR_GLOW_COLOR).GetColorValue()); + sal_uInt16 nTransparency(rSet.Get(SDRATTR_GLOW_TRANSPARENCY).GetValue()); + if (nTransparency) + aColor.SetTransparency(std::round(nTransparency / 100.0 * 255.0)); + + attribute::SdrGlowAttribute glowAttr{ nRadius, aColor }; + return glowAttr; + } + + sal_Int32 getSoftEdgeRadius(const SfxItemSet& rSet) + { + return rSet.Get(SDRATTR_SOFTEDGE_RADIUS).GetValue(); + } + } // end of anonymous namespace +} // end of namespace drawinglayer + + +namespace drawinglayer::primitive2d +{ + attribute::SdrLineAttribute createNewSdrLineAttribute(const SfxItemSet& rSet) + { + const css::drawing::LineStyle eStyle(rSet.Get(XATTR_LINESTYLE).GetValue()); + + if(drawing::LineStyle_NONE != eStyle) + { + sal_uInt16 nTransparence(rSet.Get(XATTR_LINETRANSPARENCE).GetValue()); + + if(nTransparence > 100) + { + nTransparence = 100; + } + + if(100 != nTransparence) + { + const sal_uInt32 nWidth(rSet.Get(XATTR_LINEWIDTH).GetValue()); + const Color aColor(rSet.Get(XATTR_LINECOLOR).GetColorValue()); + const css::drawing::LineJoint eJoint(rSet.Get(XATTR_LINEJOINT).GetValue()); + const css::drawing::LineCap eCap(rSet.Get(XATTR_LINECAP).GetValue()); + ::std::vector< double > aDotDashArray; + double fFullDotDashLen(0.0); + + if(drawing::LineStyle_DASH == eStyle) + { + const XDash& rDash = rSet.Get(XATTR_LINEDASH).GetDashValue(); + + if(rDash.GetDots() || rDash.GetDashes()) + { + fFullDotDashLen = rDash.CreateDotDashArray(aDotDashArray, static_cast<double>(nWidth)); + } + } + + return attribute::SdrLineAttribute( + LineJointToB2DLineJoin(eJoint), + static_cast<double>(nWidth), + static_cast<double>(nTransparence) * 0.01, + aColor.getBColor(), + eCap, + aDotDashArray, + fFullDotDashLen); + } + } + + return attribute::SdrLineAttribute(); + } + + attribute::SdrLineStartEndAttribute createNewSdrLineStartEndAttribute( + const SfxItemSet& rSet, + double fWidth) + { + const sal_Int32 nTempStartWidth(rSet.Get(XATTR_LINESTARTWIDTH).GetValue()); + const sal_Int32 nTempEndWidth(rSet.Get(XATTR_LINEENDWIDTH).GetValue()); + basegfx::B2DPolyPolygon aStartPolyPolygon; + basegfx::B2DPolyPolygon aEndPolyPolygon; + double fStartWidth(0.0); + double fEndWidth(0.0); + bool bStartActive(false); + bool bEndActive(false); + bool bStartCentered(true); + bool bEndCentered(true); + + if(nTempStartWidth) + { + if(nTempStartWidth < 0) + { + fStartWidth = (static_cast<double>(-nTempStartWidth) * fWidth) * 0.01; + } + else + { + fStartWidth = static_cast<double>(nTempStartWidth); + } + + if(0.0 != fStartWidth) + { + aStartPolyPolygon = rSet.Get(XATTR_LINESTART).GetLineStartValue(); + + if(aStartPolyPolygon.count() && aStartPolyPolygon.getB2DPolygon(0).count()) + { + bStartActive = true; + bStartCentered = rSet.Get(XATTR_LINESTARTCENTER).GetValue(); + } + } + } + + if(nTempEndWidth) + { + if(nTempEndWidth < 0) + { + fEndWidth = (static_cast<double>(-nTempEndWidth) * fWidth) * 0.01; + } + else + { + fEndWidth = static_cast<double>(nTempEndWidth); + } + + if(0.0 != fEndWidth) + { + aEndPolyPolygon = rSet.Get(XATTR_LINEEND).GetLineEndValue(); + + if(aEndPolyPolygon.count() && aEndPolyPolygon.getB2DPolygon(0).count()) + { + bEndActive = true; + bEndCentered = rSet.Get(XATTR_LINEENDCENTER).GetValue(); + } + } + } + + if(bStartActive || bEndActive) + { + return attribute::SdrLineStartEndAttribute( + aStartPolyPolygon, aEndPolyPolygon, fStartWidth, fEndWidth, + bStartActive, bEndActive, bStartCentered, bEndCentered); + } + + return attribute::SdrLineStartEndAttribute(); + } + + attribute::SdrShadowAttribute createNewSdrShadowAttribute(const SfxItemSet& rSet) + { + const bool bShadow(rSet.Get(SDRATTR_SHADOW).GetValue()); + + if(bShadow) + { + sal_uInt16 nTransparence(rSet.Get(SDRATTR_SHADOWTRANSPARENCE).GetValue()); + + if(nTransparence > 100) + { + nTransparence = 100; + } + + if(nTransparence) + { + sal_uInt16 nFillTransparence(rSet.Get(XATTR_FILLTRANSPARENCE).GetValue()); + + if(nFillTransparence > 100) + { + nFillTransparence = 100; + } + + if(nTransparence == nFillTransparence) + { + // shadow does not really have an own transparence, but the application + // sets the shadow transparence equal to the object transparence for + // convenience. This is not useful for primitive creation, so take + // this as no shadow transparence + nTransparence = 0; + } + } + + if(100 != nTransparence) + { + const basegfx::B2DVector aOffset( + static_cast<double>(rSet.Get(SDRATTR_SHADOWXDIST).GetValue()), + static_cast<double>(rSet.Get(SDRATTR_SHADOWYDIST).GetValue())); + + const basegfx::B2DVector aSize( + static_cast<double>(rSet.Get(SDRATTR_SHADOWSIZEX).GetValue()), + static_cast<double>(rSet.Get(SDRATTR_SHADOWSIZEY).GetValue())); + + const Color aColor(rSet.Get(SDRATTR_SHADOWCOLOR).GetColorValue()); + + return attribute::SdrShadowAttribute(aOffset, aSize, static_cast<double>(nTransparence) * 0.01, aColor.getBColor()); + } + } + + return attribute::SdrShadowAttribute(); + } + + attribute::SdrFillAttribute createNewSdrFillAttribute(const SfxItemSet& rSet) + { + const drawing::FillStyle eStyle(rSet.Get(XATTR_FILLSTYLE).GetValue()); + + sal_uInt16 nTransparence(rSet.Get(XATTR_FILLTRANSPARENCE).GetValue()); + + if(nTransparence > 100) + { + nTransparence = 100; + } + + if(drawing::FillStyle_NONE != eStyle) + { + if(100 != nTransparence) + { + // need to check XFillFloatTransparence, object fill may still be completely transparent + const SfxPoolItem* pGradientItem; + + if(SfxItemState::SET == rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, true, &pGradientItem) + && static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->IsEnabled()) + { + const XGradient& rGradient = static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->GetGradientValue(); + const sal_uInt8 nStartLuminance(rGradient.GetStartColor().GetLuminance()); + const sal_uInt8 nEndLuminance(rGradient.GetEndColor().GetLuminance()); + const bool bCompletelyTransparent(0xff == nStartLuminance && 0xff == nEndLuminance); + + if(bCompletelyTransparent) + { + nTransparence = 100; + } + } + } + + if(100 != nTransparence) + { + const Color aColor(rSet.Get(XATTR_FILLCOLOR).GetColorValue()); + attribute::FillGradientAttribute aGradient; + attribute::FillHatchAttribute aHatch; + attribute::SdrFillGraphicAttribute aFillGraphic; + + switch(eStyle) + { + default: + { + // nothing to do, color is defined + break; + } + case drawing::FillStyle_GRADIENT : + { + XGradient aXGradient(rSet.Get(XATTR_FILLGRADIENT).GetGradientValue()); + + const Color aStartColor(aXGradient.GetStartColor()); + const sal_uInt16 nStartIntens(aXGradient.GetStartIntens()); + basegfx::BColor aStart(aStartColor.getBColor()); + + if(nStartIntens != 100) + { + const basegfx::BColor aBlack; + aStart = interpolate(aBlack, aStart, static_cast<double>(nStartIntens) * 0.01); + } + + const Color aEndColor(aXGradient.GetEndColor()); + const sal_uInt16 nEndIntens(aXGradient.GetEndIntens()); + basegfx::BColor aEnd(aEndColor.getBColor()); + + if(nEndIntens != 100) + { + const basegfx::BColor aBlack; + aEnd = interpolate(aBlack, aEnd, static_cast<double>(nEndIntens) * 0.01); + } + + aGradient = attribute::FillGradientAttribute( + XGradientStyleToGradientStyle(aXGradient.GetGradientStyle()), + static_cast<double>(aXGradient.GetBorder()) * 0.01, + static_cast<double>(aXGradient.GetXOffset()) * 0.01, + static_cast<double>(aXGradient.GetYOffset()) * 0.01, + static_cast<double>(aXGradient.GetAngle()) * F_PI1800, + aStart, + aEnd, + rSet.Get(XATTR_GRADIENTSTEPCOUNT).GetValue()); + + break; + } + case drawing::FillStyle_HATCH : + { + const XHatch& rHatch(rSet.Get(XATTR_FILLHATCH).GetHatchValue()); + const Color aColorB(rHatch.GetColor()); + + aHatch = attribute::FillHatchAttribute( + XHatchStyleToHatchStyle(rHatch.GetHatchStyle()), + static_cast<double>(rHatch.GetDistance()), + static_cast<double>(rHatch.GetAngle()) * F_PI1800, + aColorB.getBColor(), + 3, // same default as VCL, a minimum of three discrete units (pixels) offset + rSet.Get(XATTR_FILLBACKGROUND).GetValue()); + + break; + } + case drawing::FillStyle_BITMAP : + { + aFillGraphic = createNewSdrFillGraphicAttribute(rSet); + break; + } + } + + return attribute::SdrFillAttribute( + static_cast<double>(nTransparence) * 0.01, + aColor.getBColor(), + aGradient, + aHatch, + aFillGraphic); + } + } + + if(nTransparence == 100) + { + attribute::FillGradientAttribute aGradient; + attribute::FillHatchAttribute aHatch; + attribute::SdrFillGraphicAttribute aFillGraphic; + return attribute::SdrFillAttribute( + 1, + basegfx::BColor( 0, 0, 0 ), + aGradient, + aHatch, + aFillGraphic); + } + + return attribute::SdrFillAttribute(); + } + + // #i101508# Support handing over given text-to-border distances + attribute::SdrTextAttribute createNewSdrTextAttribute( + const SfxItemSet& rSet, + const SdrText& rText, + const sal_Int32* pLeft, + const sal_Int32* pUpper, + const sal_Int32* pRight, + const sal_Int32* pLower) + { + const SdrTextObj& rTextObj = rText.GetObject(); + + // Save chaining attributes + bool bChainable = rTextObj.IsChainable(); + + + if(rText.GetOutlinerParaObject()) + { + // added TextEdit text suppression + bool bInEditMode(false); + + if(rText.GetObject().getTextCount() > 1) + { + bInEditMode = rTextObj.IsInEditMode() && rText.GetObject().getActiveText() == &rText; + } + else + { + bInEditMode = rTextObj.IsInEditMode(); + } + + OutlinerParaObject aOutlinerParaObject(*rText.GetOutlinerParaObject()); + + if(bInEditMode) + { + std::unique_ptr<OutlinerParaObject> pTempObj = rTextObj.CreateEditOutlinerParaObject(); + + if(pTempObj) + { + aOutlinerParaObject = *pTempObj; + } + else + { + // #i100537# + // CreateEditOutlinerParaObject() returning no object does not mean that + // text edit mode is not active. Do not reset the flag here + // bInEditMode = false; + } + } + + const SdrTextAniKind eAniKind(rTextObj.GetTextAniKind()); + + // #i107346# + const SdrOutliner& rDrawTextOutliner(rText.GetObject().getSdrModelFromSdrObject().GetDrawOutliner(&rTextObj)); + const bool bWrongSpell(rDrawTextOutliner.GetControlWord() & EEControlBits::ONLINESPELLING); + + return attribute::SdrTextAttribute( + rText, + aOutlinerParaObject, + rSet.Get(XATTR_FORMTXTSTYLE).GetValue(), + pLeft ? *pLeft : rTextObj.GetTextLeftDistance(), + pUpper ? *pUpper : rTextObj.GetTextUpperDistance(), + pRight ? *pRight : rTextObj.GetTextRightDistance(), + pLower ? *pLower : rTextObj.GetTextLowerDistance(), + rTextObj.GetTextHorizontalAdjust(rSet), + rTextObj.GetTextVerticalAdjust(rSet), + rSet.Get(SDRATTR_TEXT_CONTOURFRAME).GetValue(), + rTextObj.IsFitToSize(), + rTextObj.IsAutoFit(), + rSet.Get(XATTR_FORMTXTHIDEFORM).GetValue(), + SdrTextAniKind::Blink == eAniKind, + SdrTextAniKind::Scroll == eAniKind || SdrTextAniKind::Alternate == eAniKind || SdrTextAniKind::Slide == eAniKind, + bInEditMode, + rSet.Get(SDRATTR_TEXT_USEFIXEDCELLHEIGHT).GetValue(), + bWrongSpell, + bChainable); + } + + return attribute::SdrTextAttribute(); + } + + attribute::FillGradientAttribute createNewTransparenceGradientAttribute(const SfxItemSet& rSet) + { + const SfxPoolItem* pGradientItem; + + if(SfxItemState::SET == rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, true, &pGradientItem) + && static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->IsEnabled()) + { + // test if float transparence is completely transparent + const XGradient& rGradient = static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->GetGradientValue(); + const sal_uInt8 nStartLuminance(rGradient.GetStartColor().GetLuminance()); + const sal_uInt8 nEndLuminance(rGradient.GetEndColor().GetLuminance()); + const bool bCompletelyTransparent(0xff == nStartLuminance && 0xff == nEndLuminance); + const bool bNotTransparent(0x00 == nStartLuminance && 0x00 == nEndLuminance); + + // create nothing when completely transparent: This case is already checked for the + // normal fill attributes, XFILL_NONE will be used. + // create nothing when not transparent: use normal fill, no need t create a FillGradientAttribute. + // Both cases are optimizations, always creating FillGradientAttribute will work, too + if(!bNotTransparent && !bCompletelyTransparent) + { + const double fStartLum(nStartLuminance / 255.0); + const double fEndLum(nEndLuminance / 255.0); + + return attribute::FillGradientAttribute( + XGradientStyleToGradientStyle(rGradient.GetGradientStyle()), + static_cast<double>(rGradient.GetBorder()) * 0.01, + static_cast<double>(rGradient.GetXOffset()) * 0.01, + static_cast<double>(rGradient.GetYOffset()) * 0.01, + static_cast<double>(rGradient.GetAngle()) * F_PI1800, + basegfx::BColor(fStartLum, fStartLum, fStartLum), + basegfx::BColor(fEndLum, fEndLum, fEndLum), + 0); + } + } + + return attribute::FillGradientAttribute(); + } + + attribute::SdrFillGraphicAttribute createNewSdrFillGraphicAttribute(const SfxItemSet& rSet) + { + Graphic aGraphic(rSet.Get(XATTR_FILLBITMAP).GetGraphicObject().GetGraphic()); + + if(!(GraphicType::Bitmap == aGraphic.GetType() || GraphicType::GdiMetafile == aGraphic.GetType())) + { + // no content if not bitmap or metafile + OSL_ENSURE(false, "No fill graphic in SfxItemSet (!)"); + return attribute::SdrFillGraphicAttribute(); + } + + Size aPrefSize(aGraphic.GetPrefSize()); + + if(!aPrefSize.Width() || !aPrefSize.Height()) + { + // if there is no logical size, create a size from pixel size and set MapMode accordingly + if(GraphicType::Bitmap == aGraphic.GetType()) + { + aGraphic.SetPrefSize(aGraphic.GetBitmapEx().GetSizePixel()); + aGraphic.SetPrefMapMode(MapMode(MapUnit::MapPixel)); + aPrefSize = aGraphic.GetPrefSize(); + } + } + + if(!aPrefSize.Width() || !aPrefSize.Height()) + { + // no content if no size + OSL_ENSURE(false, "Graphic has no size in SfxItemSet (!)"); + return attribute::SdrFillGraphicAttribute(); + } + + // convert size and MapMode to destination logical size and MapMode + const MapUnit aDestinationMapUnit(rSet.GetPool()->GetMetric(0)); + basegfx::B2DVector aGraphicLogicSize(aGraphic.GetPrefSize().Width(), aGraphic.GetPrefSize().Height()); + + if (aGraphic.GetPrefMapMode().GetMapUnit() != aDestinationMapUnit) + { + // #i100360# for MapUnit::MapPixel, LogicToLogic will not work properly, + // so fallback to Application::GetDefaultDevice() + Size aNewSize(0, 0); + + if(MapUnit::MapPixel == aGraphic.GetPrefMapMode().GetMapUnit()) + { + aNewSize = Application::GetDefaultDevice()->PixelToLogic( + aGraphic.GetPrefSize(), + MapMode(aDestinationMapUnit)); + } + else + { + aNewSize = OutputDevice::LogicToLogic( + aGraphic.GetPrefSize(), + aGraphic.GetPrefMapMode(), + MapMode(aDestinationMapUnit)); + } + + // #i124002# do not set new size using SetPrefSize at the graphic, this will lead to problems. + // Instead, adapt the GraphicLogicSize which will be used for further decompositions + aGraphicLogicSize = basegfx::B2DVector(aNewSize.Width(), aNewSize.Height()); + } + + // get size + const basegfx::B2DVector aSize( + static_cast<double>(rSet.Get(XATTR_FILLBMP_SIZEX).GetValue()), + static_cast<double>(rSet.Get(XATTR_FILLBMP_SIZEY).GetValue())); + const basegfx::B2DVector aOffset( + static_cast<double>(rSet.Get(XATTR_FILLBMP_TILEOFFSETX).GetValue()), + static_cast<double>(rSet.Get(XATTR_FILLBMP_TILEOFFSETY).GetValue())); + const basegfx::B2DVector aOffsetPosition( + static_cast<double>(rSet.Get(XATTR_FILLBMP_POSOFFSETX).GetValue()), + static_cast<double>(rSet.Get(XATTR_FILLBMP_POSOFFSETY).GetValue())); + + return attribute::SdrFillGraphicAttribute( + aGraphic, + aGraphicLogicSize, + aSize, + aOffset, + aOffsetPosition, + RectPointToB2DVector(rSet.GetItem<XFillBmpPosItem>(XATTR_FILLBMP_POS)->GetValue()), + rSet.Get(XATTR_FILLBMP_TILE).GetValue(), + rSet.Get(XATTR_FILLBMP_STRETCH).GetValue(), + rSet.Get(XATTR_FILLBMP_SIZELOG).GetValue()); + } + + attribute::SdrEffectsTextAttribute createNewSdrEffectsTextAttribute( + const SfxItemSet& rSet, + const SdrText* pText, + bool bSuppressText) + { + attribute::SdrTextAttribute aText; + + // #i98072# added option to suppress text + // look for text first + if(!bSuppressText && pText) + { + aText = createNewSdrTextAttribute(rSet, *pText); + } + + // try shadow + const attribute::SdrShadowAttribute aShadow(createNewSdrShadowAttribute(rSet)); + const attribute::SdrGlowAttribute aGlow(createNewSdrGlowAttribute(rSet)); + const sal_Int32 nSoftEdgeRadius(getSoftEdgeRadius(rSet)); + + return attribute::SdrEffectsTextAttribute(aShadow, aText, aGlow, nSoftEdgeRadius); + } + + attribute::SdrLineEffectsTextAttribute createNewSdrLineEffectsTextAttribute( + const SfxItemSet& rSet, + const SdrText* pText) + { + attribute::SdrLineAttribute aLine; + attribute::SdrLineStartEndAttribute aLineStartEnd; + attribute::SdrTextAttribute aText; + bool bFontworkHideContour(false); + + // look for text first + if(pText) + { + aText = createNewSdrTextAttribute(rSet, *pText); + + // when object has text and text is fontwork and hide contour is set for fontwork, force + // line and fill style to empty + if(!aText.isDefault() + && !aText.getSdrFormTextAttribute().isDefault() + && aText.isHideContour()) + { + bFontworkHideContour = true; + } + } + + // try line style + if(!bFontworkHideContour) + { + aLine = createNewSdrLineAttribute(rSet); + + if(!aLine.isDefault()) + { + // try LineStartEnd + aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth()); + } + } + + if(!aLine.isDefault() || !aText.isDefault()) + { + // try shadow + const attribute::SdrShadowAttribute aShadow(createNewSdrShadowAttribute(rSet)); + const attribute::SdrGlowAttribute aGlow = createNewSdrGlowAttribute(rSet); + const sal_Int32 nSoftEdgeRadius(getSoftEdgeRadius(rSet)); + + return attribute::SdrLineEffectsTextAttribute(aLine, aLineStartEnd, aShadow, aText, + aGlow, nSoftEdgeRadius); + } + + return attribute::SdrLineEffectsTextAttribute(); + } + + attribute::SdrLineFillEffectsTextAttribute createNewSdrLineFillEffectsTextAttribute( + const SfxItemSet& rSet, + const SdrText* pText, + bool bHasContent) + { + attribute::SdrLineAttribute aLine; + attribute::SdrFillAttribute aFill; + attribute::SdrLineStartEndAttribute aLineStartEnd; + attribute::FillGradientAttribute aFillFloatTransGradient; + attribute::SdrTextAttribute aText; + bool bFontworkHideContour(false); + + // look for text first + if(pText) + { + aText = createNewSdrTextAttribute(rSet, *pText); + + // when object has text and text is fontwork and hide contour is set for fontwork, force + // line and fill style to empty + if(!aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour()) + { + bFontworkHideContour = true; + } + } + + if(!bFontworkHideContour) + { + // try line style + aLine = createNewSdrLineAttribute(rSet); + + if(!aLine.isDefault()) + { + // try LineStartEnd + aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth()); + } + + // try fill style + aFill = createNewSdrFillAttribute(rSet); + + if(!aFill.isDefault()) + { + // try fillfloattransparence + aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet); + } + } + + // bHasContent is used from OLE and graphic objects. Normally a possible shadow + // depends on line, fill or text to be set, but for these objects it is possible + // to have none of these, but still content which needs to have a shadow (if set), + // so shadow needs to be tried + if(bHasContent || !aLine.isDefault() || !aFill.isDefault() || !aText.isDefault()) + { + // try shadow + const attribute::SdrShadowAttribute aShadow = createNewSdrShadowAttribute(rSet); + + // glow + const attribute::SdrGlowAttribute aGlow = createNewSdrGlowAttribute(rSet); + + const sal_Int32 nSoftEdgeRadius(getSoftEdgeRadius(rSet)); + + return attribute::SdrLineFillEffectsTextAttribute(aLine, aFill, aLineStartEnd, + aShadow, aFillFloatTransGradient, + aText, aGlow, nSoftEdgeRadius); + } + + return attribute::SdrLineFillEffectsTextAttribute(); + } + + attribute::SdrLineFillShadowAttribute3D createNewSdrLineFillShadowAttribute(const SfxItemSet& rSet, bool bSuppressFill) + { + attribute::SdrFillAttribute aFill; + attribute::SdrLineStartEndAttribute aLineStartEnd; + attribute::SdrShadowAttribute aShadow; + attribute::FillGradientAttribute aFillFloatTransGradient; + + // try line style + const attribute::SdrLineAttribute aLine(createNewSdrLineAttribute(rSet)); + + if(!aLine.isDefault()) + { + // try LineStartEnd + aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth()); + } + + // try fill style + if(!bSuppressFill) + { + aFill = createNewSdrFillAttribute(rSet); + + if(!aFill.isDefault()) + { + // try fillfloattransparence + aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet); + } + } + + if(!aLine.isDefault() || !aFill.isDefault()) + { + // try shadow + aShadow = createNewSdrShadowAttribute(rSet); + + return attribute::SdrLineFillShadowAttribute3D( + aLine, aFill, aLineStartEnd, aShadow, aFillFloatTransGradient); + } + + return attribute::SdrLineFillShadowAttribute3D(); + } + + attribute::SdrSceneAttribute createNewSdrSceneAttribute(const SfxItemSet& rSet) + { + // get perspective + css::drawing::ProjectionMode aProjectionMode(css::drawing::ProjectionMode_PARALLEL); + const sal_uInt16 nProjectionValue(rSet.Get(SDRATTR_3DSCENE_PERSPECTIVE).GetValue()); + + if(1 == nProjectionValue) + { + aProjectionMode = css::drawing::ProjectionMode_PERSPECTIVE; + } + + // get distance + const double fDistance(rSet.Get(SDRATTR_3DSCENE_DISTANCE).GetValue()); + + // get shadow slant + const double fShadowSlant( + basegfx::deg2rad(rSet.Get(SDRATTR_3DSCENE_SHADOW_SLANT).GetValue())); + + // get shade mode + css::drawing::ShadeMode aShadeMode(css::drawing::ShadeMode_FLAT); + const sal_uInt16 nShadeValue(rSet.Get(SDRATTR_3DSCENE_SHADE_MODE).GetValue()); + + if(1 == nShadeValue) + { + aShadeMode = css::drawing::ShadeMode_PHONG; + } + else if(2 == nShadeValue) + { + aShadeMode = css::drawing::ShadeMode_SMOOTH; + } + else if(3 == nShadeValue) + { + aShadeMode = css::drawing::ShadeMode_DRAFT; + } + + // get two sided lighting + const bool bTwoSidedLighting(rSet.Get(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING).GetValue()); + + return attribute::SdrSceneAttribute(fDistance, fShadowSlant, aProjectionMode, aShadeMode, bTwoSidedLighting); + } + + attribute::SdrLightingAttribute createNewSdrLightingAttribute(const SfxItemSet& rSet) + { + // extract lights from given SfxItemSet (from scene) + ::std::vector< attribute::Sdr3DLightAttribute > aLightVector; + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_1).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1).GetValue()); + aLightVector.emplace_back(aColor, aDirection, true); + } + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_2).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2).GetValue()); + aLightVector.emplace_back(aColor, aDirection, false); + } + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_3).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3).GetValue()); + aLightVector.emplace_back(aColor, aDirection, false); + } + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_4).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4).GetValue()); + aLightVector.emplace_back(aColor, aDirection, false); + } + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_5).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5).GetValue()); + aLightVector.emplace_back(aColor, aDirection, false); + } + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_6).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6).GetValue()); + aLightVector.emplace_back(aColor, aDirection, false); + } + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_7).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7).GetValue()); + aLightVector.emplace_back(aColor, aDirection, false); + } + + if(rSet.Get(SDRATTR_3DSCENE_LIGHTON_8).GetValue()) + { + const basegfx::BColor aColor(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8).GetValue().getBColor()); + const basegfx::B3DVector aDirection(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8).GetValue()); + aLightVector.emplace_back(aColor, aDirection, false); + } + + // get ambient color + const Color aAmbientValue(rSet.Get(SDRATTR_3DSCENE_AMBIENTCOLOR).GetValue()); + const basegfx::BColor aAmbientLight(aAmbientValue.getBColor()); + + return attribute::SdrLightingAttribute(aAmbientLight, aLightVector); + } + + void calculateRelativeCornerRadius(sal_Int32 nRadius, const basegfx::B2DRange& rObjectRange, double& rfCornerRadiusX, double& rfCornerRadiusY) + { + rfCornerRadiusX = rfCornerRadiusY = static_cast<double>(nRadius); + + if(0.0 != rfCornerRadiusX) + { + const double fHalfObjectWidth(rObjectRange.getWidth() * 0.5); + + if(0.0 != fHalfObjectWidth) + { + if(rfCornerRadiusX < 0.0) + { + rfCornerRadiusX = 0.0; + } + + if(rfCornerRadiusX > fHalfObjectWidth) + { + rfCornerRadiusX = fHalfObjectWidth; + } + + rfCornerRadiusX /= fHalfObjectWidth; + } + else + { + rfCornerRadiusX = 0.0; + } + } + + if(0.0 != rfCornerRadiusY) + { + const double fHalfObjectHeight(rObjectRange.getHeight() * 0.5); + + if(0.0 != fHalfObjectHeight) + { + if(rfCornerRadiusY < 0.0) + { + rfCornerRadiusY = 0.0; + } + + if(rfCornerRadiusY > fHalfObjectHeight) + { + rfCornerRadiusY = fHalfObjectHeight; + } + + rfCornerRadiusY /= fHalfObjectHeight; + } + else + { + rfCornerRadiusY = 0.0; + } + } + } + + // #i101508# Support handing over given text-to-border distances + attribute::SdrFillTextAttribute createNewSdrFillTextAttribute( + const SfxItemSet& rSet, + const SdrText* pText, + const sal_Int32* pLeft, + const sal_Int32* pUpper, + const sal_Int32* pRight, + const sal_Int32* pLower) + { + attribute::SdrFillAttribute aFill; + attribute::FillGradientAttribute aFillFloatTransGradient; + attribute::SdrTextAttribute aText; + bool bFontworkHideContour(false); + + // look for text first + if(pText) + { + aText = createNewSdrTextAttribute(rSet, *pText, pLeft, pUpper, pRight, pLower); + + // when object has text and text is fontwork and hide contour is set for fontwork, force + // fill style to empty + if(!aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour()) + { + bFontworkHideContour = true; + } + } + + if(!bFontworkHideContour) + { + // try fill style + aFill = createNewSdrFillAttribute(rSet); + + if(!aFill.isDefault()) + { + // try fillfloattransparence + aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet); + } + } + + if(!aFill.isDefault() || !aText.isDefault()) + { + return attribute::SdrFillTextAttribute(aFill, aFillFloatTransGradient, aText); + } + + return attribute::SdrFillTextAttribute(); + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrcaptionprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrcaptionprimitive2d.cxx new file mode 100644 index 000000000..5abce7ede --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrcaptionprimitive2d.cxx @@ -0,0 +1,166 @@ +/* -*- 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 <sdr/primitive2d/sdrcaptionprimitive2d.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + void SdrCaptionPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval; + + // create unit outline polygon + const basegfx::B2DPolygon aUnitOutline(basegfx::utils::createPolygonFromRect( + basegfx::B2DRange(0.0, 0.0, 1.0, 1.0), + getCornerRadiusX(), + getCornerRadiusY())); + + // add fill + if(getSdrLFSTAttribute().getFill().isDefault()) + { + // create invisible fill for HitTest + aRetval.push_back( + createHiddenGeometryPrimitives2D( + true, + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform())); + } + else + { + basegfx::B2DPolyPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + + // add line + if(getSdrLFSTAttribute().getLine().isDefault()) + { + // create invisible line for HitTest/BoundRect + aRetval.push_back( + createHiddenGeometryPrimitives2D( + false, + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform())); + + aRetval.push_back( + createHiddenGeometryPrimitives2D( + false, + basegfx::B2DPolyPolygon(getTail()), + getTransform())); + } + else + { + basegfx::B2DPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + attribute::SdrLineStartEndAttribute())); + + aTransformed = getTail(); + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + getSdrLFSTAttribute().getLineStartEnd())); + } + + // add text + if(!getSdrLFSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform(), + getSdrLFSTAttribute().getText(), + getSdrLFSTAttribute().getLine(), + false, + false)); + } + + // add shadow + if(!getSdrLFSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive(aRetval, getSdrLFSTAttribute().getShadow()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrCaptionPrimitive2D::SdrCaptionPrimitive2D( + const basegfx::B2DHomMatrix& rTransform, + const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute, + const basegfx::B2DPolygon& rTail, + double fCornerRadiusX, + double fCornerRadiusY) + : BufferedDecompositionPrimitive2D(), + maTransform(rTransform), + maSdrLFSTAttribute(rSdrLFSTAttribute), + maTail(rTail), + mfCornerRadiusX(fCornerRadiusX), + mfCornerRadiusY(fCornerRadiusY) + { + // transform maTail to unit polygon + if(getTail().count()) + { + basegfx::B2DHomMatrix aInverse(getTransform()); + aInverse.invert(); + maTail.transform(aInverse); + } + } + + bool SdrCaptionPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrCaptionPrimitive2D& rCompare = static_cast<const SdrCaptionPrimitive2D&>(rPrimitive); + + return (getCornerRadiusX() == rCompare.getCornerRadiusX() + && getCornerRadiusY() == rCompare.getCornerRadiusY() + && getTail() == rCompare.getTail() + && getTransform() == rCompare.getTransform() + && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute()); + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrCaptionPrimitive2D, PRIMITIVE2D_ID_SDRCAPTIONPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrconnectorprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrconnectorprimitive2d.cxx new file mode 100644 index 000000000..8b5c8413c --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrconnectorprimitive2d.cxx @@ -0,0 +1,105 @@ +/* -*- 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 <sdr/primitive2d/sdrconnectorprimitive2d.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + void SdrConnectorPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval; + + // add line + if(getSdrLSTAttribute().getLine().isDefault()) + { + // create invisible line for HitTest/BoundRect + aRetval.push_back( + createHiddenGeometryPrimitives2D( + basegfx::B2DPolyPolygon(getUnitPolygon()))); + } + else + { + aRetval.push_back( + createPolygonLinePrimitive( + getUnitPolygon(), + getSdrLSTAttribute().getLine(), + getSdrLSTAttribute().getLineStartEnd())); + } + + // add text + if(!getSdrLSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(getUnitPolygon()), + basegfx::B2DHomMatrix(), + getSdrLSTAttribute().getText(), + getSdrLSTAttribute().getLine(), + false, + false)); + } + + // add shadow + if(!getSdrLSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLSTAttribute().getShadow()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrConnectorPrimitive2D::SdrConnectorPrimitive2D( + const attribute::SdrLineEffectsTextAttribute& rSdrLSTAttribute, + const ::basegfx::B2DPolygon& rUnitPolygon) + : BufferedDecompositionPrimitive2D(), + maSdrLSTAttribute(rSdrLSTAttribute), + maUnitPolygon(rUnitPolygon) + { + } + + bool SdrConnectorPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrConnectorPrimitive2D& rCompare = static_cast<const SdrConnectorPrimitive2D&>(rPrimitive); + + return (getUnitPolygon() == rCompare.getUnitPolygon() + && getSdrLSTAttribute() == rCompare.getSdrLSTAttribute()); + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrConnectorPrimitive2D, PRIMITIVE2D_ID_SDRCONNECTORPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrcustomshapeprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrcustomshapeprimitive2d.cxx new file mode 100644 index 000000000..f237369e3 --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrcustomshapeprimitive2d.cxx @@ -0,0 +1,130 @@ +/* -*- 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 <sdr/primitive2d/sdrcustomshapeprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <drawinglayer/attribute/sdrlineattribute.hxx> + +#include <sal/log.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + void SdrCustomShapePrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval(getSubPrimitives()); + + // Soft edges should be before text, since text is not affected by soft edges + if (!aRetval.empty() && getSdrSTAttribute().getSoftEdgeRadius()) + { + aRetval = createEmbeddedSoftEdgePrimitive(aRetval, + getSdrSTAttribute().getSoftEdgeRadius()); + } + + // add text + if(!getSdrSTAttribute().getText().isDefault()) + { + const basegfx::B2DPolygon& aUnitOutline(basegfx::utils::createUnitPolygon()); + + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(aUnitOutline), + getTextBox(), + getSdrSTAttribute().getText(), + attribute::SdrLineAttribute(), + false, + getWordWrap())); + } + + // tdf#132199: put glow before shadow, to have shadow of the glow, not the opposite + if (!aRetval.empty() && !getSdrSTAttribute().getGlow().isDefault()) + { + // glow + aRetval = createEmbeddedGlowPrimitive(aRetval, getSdrSTAttribute().getGlow()); + } + + // add shadow + if(!aRetval.empty() && !getSdrSTAttribute().getShadow().isDefault()) + { + // #i105323# add generic shadow only for 2D shapes. For + // 3D shapes shadow will be set at the individual created + // visualisation objects and be visualized by the 3d renderer + // as a single shadow. + + // The shadow for AutoShapes could be handled uniformly by not setting any + // shadow items at the helper model objects and only adding shadow here for + // 2D and 3D (and it works, too), but this would lead to two 3D scenes for + // the 3D object; one for the shadow and one for the content. The one for the + // shadow will be correct (using ColorModifierStack), but expensive. + if(!get3DShape()) + { + aRetval = createEmbeddedShadowPrimitive(aRetval, getSdrSTAttribute().getShadow(), + maTransform); + } + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrCustomShapePrimitive2D::SdrCustomShapePrimitive2D( + const attribute::SdrEffectsTextAttribute& rSdrSTAttribute, + const Primitive2DContainer& rSubPrimitives, + const basegfx::B2DHomMatrix& rTextBox, + bool bWordWrap, + bool b3DShape, + const basegfx::B2DHomMatrix& rTransform) + : BufferedDecompositionPrimitive2D(), + maSdrSTAttribute(rSdrSTAttribute), + maSubPrimitives(rSubPrimitives), + maTextBox(rTextBox), + mbWordWrap(bWordWrap), + mb3DShape(b3DShape), + maTransform(rTransform) + { + } + + bool SdrCustomShapePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrCustomShapePrimitive2D& rCompare = static_cast<const SdrCustomShapePrimitive2D&>(rPrimitive); + + return (getSdrSTAttribute() == rCompare.getSdrSTAttribute() + && getSubPrimitives() == rCompare.getSubPrimitives() + && getTextBox() == rCompare.getTextBox() + && getWordWrap() == rCompare.getWordWrap() + && get3DShape() == rCompare.get3DShape()); + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrCustomShapePrimitive2D, PRIMITIVE2D_ID_SDRCUSTOMSHAPEPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrdecompositiontools.cxx b/svx/source/sdr/primitive2d/sdrdecompositiontools.cxx new file mode 100644 index 000000000..59b38300d --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrdecompositiontools.cxx @@ -0,0 +1,574 @@ +/* -*- 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 <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <drawinglayer/primitive2d/baseprimitive2d.hxx> +#include <drawinglayer/primitive2d/PolyPolygonGradientPrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonHatchPrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonGraphicPrimitive2D.hxx> +#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx> +#include <drawinglayer/primitive2d/softedgeprimitive2d.hxx> +#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> +#include <drawinglayer/primitive2d/transparenceprimitive2d.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx> +#include <drawinglayer/attribute/strokeattribute.hxx> +#include <drawinglayer/attribute/linestartendattribute.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <drawinglayer/attribute/sdrfillgraphicattribute.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/primitive2d/shadowprimitive2d.hxx> +#include <sdr/attribute/sdrtextattribute.hxx> +#include <drawinglayer/primitive2d/glowprimitive2d.hxx> +#include <sdr/primitive2d/sdrtextprimitive2d.hxx> +#include <svx/svdotext.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <drawinglayer/primitive2d/animatedprimitive2d.hxx> +#include <drawinglayer/animation/animationtiming.hxx> +#include <drawinglayer/primitive2d/maskprimitive2d.hxx> +#include <drawinglayer/geometry/viewinformation2d.hxx> +#include <drawinglayer/primitive2d/texthierarchyprimitive2d.hxx> +#include <drawinglayer/attribute/sdrfillattribute.hxx> +#include <drawinglayer/attribute/sdrlineattribute.hxx> +#include <drawinglayer/attribute/sdrlinestartendattribute.hxx> +#include <drawinglayer/attribute/sdrshadowattribute.hxx> +#include <drawinglayer/attribute/sdrglowattribute.hxx> +#include <sal/log.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + + class TransparencePrimitive2D; + + Primitive2DReference createPolyPolygonFillPrimitive( + const basegfx::B2DPolyPolygon& rPolyPolygon, + const attribute::SdrFillAttribute& rFill, + const attribute::FillGradientAttribute& rFillGradient) + { + // when we have no given definition range, use the range of the given geometry + // also for definition (simplest case) + const basegfx::B2DRange aRange(basegfx::utils::getRange(rPolyPolygon)); + + return createPolyPolygonFillPrimitive( + rPolyPolygon, + aRange, + rFill, + rFillGradient); + } + + Primitive2DReference createPolyPolygonFillPrimitive( + const basegfx::B2DPolyPolygon& rPolyPolygon, + const basegfx::B2DRange& rDefinitionRange, + const attribute::SdrFillAttribute& rFill, + const attribute::FillGradientAttribute& rFillGradient) + { + if(basegfx::fTools::moreOrEqual(rFill.getTransparence(), 1.0)) + { + return Primitive2DReference(); + } + + // prepare fully scaled polygon + BasePrimitive2D* pNewFillPrimitive = nullptr; + + if(!rFill.getGradient().isDefault()) + { + pNewFillPrimitive = new PolyPolygonGradientPrimitive2D( + rPolyPolygon, + rDefinitionRange, + rFill.getGradient()); + } + else if(!rFill.getHatch().isDefault()) + { + pNewFillPrimitive = new PolyPolygonHatchPrimitive2D( + rPolyPolygon, + rDefinitionRange, + rFill.getColor(), + rFill.getHatch()); + } + else if(!rFill.getFillGraphic().isDefault()) + { + pNewFillPrimitive = new PolyPolygonGraphicPrimitive2D( + rPolyPolygon, + rDefinitionRange, + rFill.getFillGraphic().createFillGraphicAttribute(rDefinitionRange)); + } + else + { + pNewFillPrimitive = new PolyPolygonColorPrimitive2D( + rPolyPolygon, + rFill.getColor()); + } + + if(0.0 != rFill.getTransparence()) + { + // create simpleTransparencePrimitive, add created fill primitive + const Primitive2DReference xRefA(pNewFillPrimitive); + const Primitive2DContainer aContent { xRefA }; + return Primitive2DReference(new UnifiedTransparencePrimitive2D(aContent, rFill.getTransparence())); + } + else if(!rFillGradient.isDefault()) + { + // create sequence with created fill primitive + const Primitive2DReference xRefA(pNewFillPrimitive); + const Primitive2DContainer aContent { xRefA }; + + // create FillGradientPrimitive2D for transparence and add to new sequence + // fillGradientPrimitive is enough here (compared to PolyPolygonGradientPrimitive2D) since float transparence will be masked anyways + const basegfx::B2DRange aRange(basegfx::utils::getRange(rPolyPolygon)); + const Primitive2DReference xRefB( + new FillGradientPrimitive2D( + aRange, + rDefinitionRange, + rFillGradient)); + const Primitive2DContainer aAlpha { xRefB }; + + // create TransparencePrimitive2D using alpha and content + return Primitive2DReference(new TransparencePrimitive2D(aContent, aAlpha)); + } + else + { + // add to decomposition + return Primitive2DReference(pNewFillPrimitive); + } + } + + Primitive2DReference createPolygonLinePrimitive( + const basegfx::B2DPolygon& rPolygon, + const attribute::SdrLineAttribute& rLine, + const attribute::SdrLineStartEndAttribute& rStroke) + { + // create line and stroke attribute + const attribute::LineAttribute aLineAttribute(rLine.getColor(), rLine.getWidth(), rLine.getJoin(), rLine.getCap()); + const attribute::StrokeAttribute aStrokeAttribute(rLine.getDotDashArray(), rLine.getFullDotDashLen()); + BasePrimitive2D* pNewLinePrimitive = nullptr; + + if(!rPolygon.isClosed() && !rStroke.isDefault()) + { + attribute::LineStartEndAttribute aStart(rStroke.getStartWidth(), rStroke.getStartPolyPolygon(), rStroke.isStartCentered()); + attribute::LineStartEndAttribute aEnd(rStroke.getEndWidth(), rStroke.getEndPolyPolygon(), rStroke.isEndCentered()); + + // create data + pNewLinePrimitive = new PolygonStrokeArrowPrimitive2D(rPolygon, aLineAttribute, aStrokeAttribute, aStart, aEnd); + } + else + { + // create data + pNewLinePrimitive = new PolygonStrokePrimitive2D(rPolygon, aLineAttribute, aStrokeAttribute); + } + + if(0.0 != rLine.getTransparence()) + { + // create simpleTransparencePrimitive, add created fill primitive + const Primitive2DReference xRefA(pNewLinePrimitive); + const Primitive2DContainer aContent { xRefA }; + return Primitive2DReference(new UnifiedTransparencePrimitive2D(aContent, rLine.getTransparence())); + } + else + { + // add to decomposition + return Primitive2DReference(pNewLinePrimitive); + } + } + + Primitive2DReference createTextPrimitive( + const basegfx::B2DPolyPolygon& rUnitPolyPolygon, + const basegfx::B2DHomMatrix& rObjectTransform, + const attribute::SdrTextAttribute& rText, + const attribute::SdrLineAttribute& rStroke, + bool bCellText, + bool bWordWrap) + { + basegfx::B2DHomMatrix aAnchorTransform(rObjectTransform); + std::unique_ptr<SdrTextPrimitive2D> pNew; + + if(rText.isContour()) + { + // contour text + if(!rStroke.isDefault() && 0.0 != rStroke.getWidth()) + { + // take line width into account and shrink contour polygon accordingly + // decompose to get scale + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rObjectTransform.decompose(aScale, aTranslate, fRotate, fShearX); + + // scale outline to object's size to allow growing with value relative to that size + // and also to keep aspect ratio + basegfx::B2DPolyPolygon aScaledUnitPolyPolygon(rUnitPolyPolygon); + aScaledUnitPolyPolygon.transform(basegfx::utils::createScaleB2DHomMatrix( + fabs(aScale.getX()), fabs(aScale.getY()))); + + // grow the polygon. To shrink, use negative value (half width) + aScaledUnitPolyPolygon = basegfx::utils::growInNormalDirection(aScaledUnitPolyPolygon, -(rStroke.getWidth() * 0.5)); + + // scale back to unit polygon + aScaledUnitPolyPolygon.transform(basegfx::utils::createScaleB2DHomMatrix( + 0.0 != aScale.getX() ? 1.0 / aScale.getX() : 1.0, + 0.0 != aScale.getY() ? 1.0 / aScale.getY() : 1.0)); + + // create with unit polygon + pNew.reset(new SdrContourTextPrimitive2D( + &rText.getSdrText(), + rText.getOutlinerParaObject(), + aScaledUnitPolyPolygon, + rObjectTransform)); + } + else + { + // create with unit polygon + pNew.reset(new SdrContourTextPrimitive2D( + &rText.getSdrText(), + rText.getOutlinerParaObject(), + rUnitPolyPolygon, + rObjectTransform)); + } + } + else if(!rText.getSdrFormTextAttribute().isDefault()) + { + // text on path, use scaled polygon + basegfx::B2DPolyPolygon aScaledPolyPolygon(rUnitPolyPolygon); + aScaledPolyPolygon.transform(rObjectTransform); + pNew.reset(new SdrPathTextPrimitive2D( + &rText.getSdrText(), + rText.getOutlinerParaObject(), + aScaledPolyPolygon, + rText.getSdrFormTextAttribute())); + } + else + { + // rObjectTransform is the whole SdrObject transformation from unit rectangle + // to its size and position. Decompose to allow working with single values. + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + rObjectTransform.decompose(aScale, aTranslate, fRotate, fShearX); + + // extract mirroring + const bool bMirrorX(basegfx::fTools::less(aScale.getX(), 0.0)); + const bool bMirrorY(basegfx::fTools::less(aScale.getY(), 0.0)); + aScale = basegfx::absolute(aScale); + + // Get the real size, since polygon outline and scale + // from the object transformation may vary (e.g. ellipse segments) + basegfx::B2DHomMatrix aJustScaleTransform; + aJustScaleTransform.set(0, 0, aScale.getX()); + aJustScaleTransform.set(1, 1, aScale.getY()); + basegfx::B2DPolyPolygon aScaledUnitPolyPolygon(rUnitPolyPolygon); + aScaledUnitPolyPolygon.transform(aJustScaleTransform); + const basegfx::B2DRange aSnapRange(basegfx::utils::getRange(aScaledUnitPolyPolygon)); + + // create a range describing the wanted text position and size (aTextAnchorRange). This + // means to use the text distance values here + const basegfx::B2DPoint aTopLeft(aSnapRange.getMinX() + rText.getTextLeftDistance(), aSnapRange.getMinY() + rText.getTextUpperDistance()); + const basegfx::B2DPoint aBottomRight(aSnapRange.getMaxX() - rText.getTextRightDistance(), aSnapRange.getMaxY() - rText.getTextLowerDistance()); + basegfx::B2DRange aTextAnchorRange; + aTextAnchorRange.expand(aTopLeft); + aTextAnchorRange.expand(aBottomRight); + + // now create a transformation from this basic range (aTextAnchorRange) + // #i121494# if we have no scale use at least 1.0 to have a carrier e.g. for + // mirror values, else these will get lost + aAnchorTransform = basegfx::utils::createScaleTranslateB2DHomMatrix( + basegfx::fTools::equalZero(aTextAnchorRange.getWidth()) ? 1.0 : aTextAnchorRange.getWidth(), + basegfx::fTools::equalZero(aTextAnchorRange.getHeight()) ? 1.0 : aTextAnchorRange.getHeight(), + aTextAnchorRange.getMinX(), aTextAnchorRange.getMinY()); + + // apply mirroring + aAnchorTransform.scale(bMirrorX ? -1.0 : 1.0, bMirrorY ? -1.0 : 1.0); + + // apply object's other transforms + aAnchorTransform = basegfx::utils::createShearXRotateTranslateB2DHomMatrix(fShearX, fRotate, aTranslate) + * aAnchorTransform; + + if(rText.isFitToSize()) + { + // stretched text in range + pNew.reset(new SdrStretchTextPrimitive2D( + &rText.getSdrText(), + rText.getOutlinerParaObject(), + aAnchorTransform, + rText.isFixedCellHeight())); + } + else if(rText.isAutoFit()) + { + // isotropically scaled text in range + pNew.reset(new SdrAutoFitTextPrimitive2D( + &rText.getSdrText(), + rText.getOutlinerParaObject(), + aAnchorTransform, + bWordWrap)); + } + else if( rText.isChainable() && !rText.isInEditMode() ) + { + pNew.reset(new SdrChainedTextPrimitive2D( + &rText.getSdrText(), + rText.getOutlinerParaObject(), + aAnchorTransform )); + } + else // text in range + { + // build new primitive + pNew.reset(new SdrBlockTextPrimitive2D( + &rText.getSdrText(), + rText.getOutlinerParaObject(), + aAnchorTransform, + rText.getSdrTextHorzAdjust(), + rText.getSdrTextVertAdjust(), + rText.isFixedCellHeight(), + rText.isScroll(), + bCellText, + bWordWrap)); + } + } + + OSL_ENSURE(pNew != nullptr, "createTextPrimitive: no text primitive created (!)"); + + if(rText.isBlink()) + { + // prepare animation and primitive list + drawinglayer::animation::AnimationEntryList aAnimationList; + rText.getBlinkTextTiming(aAnimationList); + + if(0.0 != aAnimationList.getDuration()) + { + // create content sequence + const Primitive2DReference xRefA(pNew.release()); + const Primitive2DContainer aContent { xRefA }; + + // create and add animated switch primitive + return Primitive2DReference(new AnimatedBlinkPrimitive2D(aAnimationList, aContent)); + } + else + { + // add to decomposition + return Primitive2DReference(pNew.release()); + } + } + + if(rText.isScroll()) + { + // suppress scroll when FontWork + if(rText.getSdrFormTextAttribute().isDefault()) + { + // get scroll direction + const SdrTextAniDirection eDirection(rText.getSdrText().GetObject().GetTextAniDirection()); + const bool bHorizontal(SdrTextAniDirection::Left == eDirection || SdrTextAniDirection::Right == eDirection); + + // decompose to get separated values for the scroll box + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + aAnchorTransform.decompose(aScale, aTranslate, fRotate, fShearX); + + // build transform from scaled only to full AnchorTransform and inverse + const basegfx::B2DHomMatrix aSRT(basegfx::utils::createShearXRotateTranslateB2DHomMatrix( + fShearX, fRotate, aTranslate)); + basegfx::B2DHomMatrix aISRT(aSRT); + aISRT.invert(); + + // bring the primitive back to scaled only and get scaled range, create new clone for this + std::unique_ptr<SdrTextPrimitive2D> pNew2 = pNew->createTransformedClone(aISRT); + OSL_ENSURE(pNew2, "createTextPrimitive: Could not create transformed clone of text primitive (!)"); + pNew = std::move(pNew2); + + // create neutral geometry::ViewInformation2D for local range and decompose calls. This is okay + // since the decompose is view-independent + const uno::Sequence< beans::PropertyValue > xViewParameters; + geometry::ViewInformation2D aViewInformation2D(xViewParameters); + + // get range + const basegfx::B2DRange aScaledRange(pNew->getB2DRange(aViewInformation2D)); + + // create left outside and right outside transformations. Also take care + // of the clip rectangle + basegfx::B2DHomMatrix aLeft, aRight; + basegfx::B2DPoint aClipTopLeft(0.0, 0.0); + basegfx::B2DPoint aClipBottomRight(aScale.getX(), aScale.getY()); + + if(bHorizontal) + { + aClipTopLeft.setY(aScaledRange.getMinY()); + aClipBottomRight.setY(aScaledRange.getMaxY()); + aLeft.translate(-aScaledRange.getMaxX(), 0.0); + aRight.translate(aScale.getX() - aScaledRange.getMinX(), 0.0); + } + else + { + aClipTopLeft.setX(aScaledRange.getMinX()); + aClipBottomRight.setX(aScaledRange.getMaxX()); + aLeft.translate(0.0, -aScaledRange.getMaxY()); + aRight.translate(0.0, aScale.getY() - aScaledRange.getMinY()); + } + + aLeft *= aSRT; + aRight *= aSRT; + + // prepare animation list + drawinglayer::animation::AnimationEntryList aAnimationList; + + if(bHorizontal) + { + rText.getScrollTextTiming(aAnimationList, aScale.getX(), aScaledRange.getWidth()); + } + else + { + rText.getScrollTextTiming(aAnimationList, aScale.getY(), aScaledRange.getHeight()); + } + + if(0.0 != aAnimationList.getDuration()) + { + // create a new Primitive2DContainer containing the animated text in its scaled only state. + // use the decomposition to force to simple text primitives, those will no longer + // need the outliner for formatting (alternatively it is also possible to just add + // pNew to aNewPrimitiveSequence) + Primitive2DContainer aAnimSequence; + pNew->get2DDecomposition(aAnimSequence, aViewInformation2D); + pNew.reset(); + + // create a new animatedInterpolatePrimitive and add it + std::vector< basegfx::B2DHomMatrix > aMatrixStack; + aMatrixStack.push_back(aLeft); + aMatrixStack.push_back(aRight); + const Primitive2DReference xRefA(new AnimatedInterpolatePrimitive2D(aMatrixStack, aAnimationList, aAnimSequence)); + const Primitive2DContainer aContent { xRefA }; + + // scrolling needs an encapsulating clipping primitive + const basegfx::B2DRange aClipRange(aClipTopLeft, aClipBottomRight); + basegfx::B2DPolygon aClipPolygon(basegfx::utils::createPolygonFromRect(aClipRange)); + aClipPolygon.transform(aSRT); + return Primitive2DReference(new MaskPrimitive2D(basegfx::B2DPolyPolygon(aClipPolygon), aContent)); + } + else + { + // add to decomposition + return Primitive2DReference(pNew.release()); + } + } + } + + if(rText.isInEditMode()) + { + // #i97628# + // encapsulate with TextHierarchyEditPrimitive2D to allow renderers + // to suppress actively edited content if needed + const Primitive2DReference xRefA(pNew.release()); + const Primitive2DContainer aContent { xRefA }; + + // create and add TextHierarchyEditPrimitive2D primitive + return Primitive2DReference(new TextHierarchyEditPrimitive2D(aContent)); + } + else + { + // add to decomposition + return Primitive2DReference(pNew.release()); + } + } + + Primitive2DContainer createEmbeddedShadowPrimitive( + const Primitive2DContainer& rContent, + const attribute::SdrShadowAttribute& rShadow, + const basegfx::B2DHomMatrix& rObjectMatrix) + { + if(!rContent.empty()) + { + Primitive2DContainer aRetval(2); + basegfx::B2DHomMatrix aShadowOffset; + + { + if(rShadow.getSize().getX() != 100000) + { + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate = 0; + double fShearX = 0; + rObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + // Scale the shadow + double nTranslateX = aTranslate.getX(); + double nTranslateY = aTranslate.getY(); + + // The origin for scaling is the top left corner by default. A negative + // shadow offset changes the origin. + if (rShadow.getOffset().getX() < 0) + nTranslateX += aScale.getX(); + if (rShadow.getOffset().getY() < 0) + nTranslateY += aScale.getY(); + + aShadowOffset.translate(-nTranslateX, -nTranslateY); + aShadowOffset.scale(rShadow.getSize().getX() * 0.00001, rShadow.getSize().getY() * 0.00001); + aShadowOffset.translate(nTranslateX, nTranslateY); + } + + aShadowOffset.translate(rShadow.getOffset().getX(), rShadow.getOffset().getY()); + } + + // create shadow primitive and add content + aRetval[0] = Primitive2DReference( + new ShadowPrimitive2D( + aShadowOffset, + rShadow.getColor(), + rContent)); + + if(0.0 != rShadow.getTransparence()) + { + // create SimpleTransparencePrimitive2D + const Primitive2DContainer aTempContent { aRetval[0] }; + + aRetval[0] = Primitive2DReference( + new UnifiedTransparencePrimitive2D( + aTempContent, + rShadow.getTransparence())); + } + + aRetval[1] = Primitive2DReference(new GroupPrimitive2D(rContent)); + return aRetval; + } + else + { + return rContent; + } + } + + Primitive2DContainer createEmbeddedGlowPrimitive( + const Primitive2DContainer& rContent, + const attribute::SdrGlowAttribute& rGlow) + { + if(rContent.empty()) + return rContent; + Primitive2DContainer aRetval(2); + aRetval[0] = Primitive2DReference( + new GlowPrimitive2D(rGlow.getColor(), rGlow.getRadius(), rContent)); + aRetval[1] = Primitive2DReference(new GroupPrimitive2D(rContent)); + return aRetval; + } + + Primitive2DContainer createEmbeddedSoftEdgePrimitive(const Primitive2DContainer& rContent, + sal_Int32 nRadius) + { + if (rContent.empty() || !nRadius) + return rContent; + Primitive2DContainer aRetval(1); + aRetval[0] = Primitive2DReference(new SoftEdgePrimitive2D(nRadius, rContent)); + return aRetval; + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrellipseprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrellipseprimitive2d.cxx new file mode 100644 index 000000000..1a341b8ff --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrellipseprimitive2d.cxx @@ -0,0 +1,261 @@ +/* -*- 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 <sdr/primitive2d/sdrellipseprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + void SdrEllipsePrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval; + + // create unit outline polygon + // Do use createPolygonFromUnitCircle, but let create from first quadrant to mimic old geometry creation. + // This is needed to have the same look when stroke is used since the polygon start point defines the + // stroke start, too. + basegfx::B2DPolygon aUnitOutline(basegfx::utils::createPolygonFromUnitCircle(1)); + + // scale and move UnitEllipse to UnitObject (-1,-1 1,1) -> (0,0 1,1) + const basegfx::B2DHomMatrix aUnitCorrectionMatrix( + basegfx::utils::createScaleTranslateB2DHomMatrix(0.5, 0.5, 0.5, 0.5)); + + // apply to the geometry + aUnitOutline.transform(aUnitCorrectionMatrix); + + // add fill + if(!getSdrLFSTAttribute().getFill().isDefault()) + { + basegfx::B2DPolyPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + + // add line + if(getSdrLFSTAttribute().getLine().isDefault()) + { + // create invisible line for HitTest/BoundRect + aRetval.push_back( + createHiddenGeometryPrimitives2D( + false, + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform())); + } + else + { + basegfx::B2DPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + attribute::SdrLineStartEndAttribute())); + } + + // add text + if(!getSdrLFSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform(), + getSdrLFSTAttribute().getText(), + getSdrLFSTAttribute().getLine(), + false, + false)); + } + + // add shadow + if(!getSdrLFSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLFSTAttribute().getShadow()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrEllipsePrimitive2D::SdrEllipsePrimitive2D( + const basegfx::B2DHomMatrix& rTransform, + const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute) + : BufferedDecompositionPrimitive2D(), + maTransform(rTransform), + maSdrLFSTAttribute(rSdrLFSTAttribute) + { + } + + bool SdrEllipsePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrEllipsePrimitive2D& rCompare = static_cast<const SdrEllipsePrimitive2D&>(rPrimitive); + + return (getTransform() == rCompare.getTransform() + && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute()); + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrEllipsePrimitive2D, PRIMITIVE2D_ID_SDRELLIPSEPRIMITIVE2D) + + + + void SdrEllipseSegmentPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval; + + // create unit outline polygon + basegfx::B2DPolygon aUnitOutline(basegfx::utils::createPolygonFromUnitEllipseSegment(mfStartAngle, mfEndAngle)); + + if(mbCloseSegment) + { + if(mbCloseUsingCenter) + { + // for compatibility, insert the center point at polygon start to get the same + // line stroking pattern as the old painting mechanisms. + aUnitOutline.insert(0, basegfx::B2DPoint(0.0, 0.0)); + } + + aUnitOutline.setClosed(true); + } + + // move and scale UnitEllipse to UnitObject (-1,-1 1,1) -> (0,0 1,1) + const basegfx::B2DHomMatrix aUnitCorrectionMatrix( + basegfx::utils::createScaleTranslateB2DHomMatrix(0.5, 0.5, 0.5, 0.5)); + + // apply to the geometry + aUnitOutline.transform(aUnitCorrectionMatrix); + + // add fill + if(!getSdrLFSTAttribute().getFill().isDefault() && aUnitOutline.isClosed()) + { + basegfx::B2DPolyPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + + // add line + if(getSdrLFSTAttribute().getLine().isDefault()) + { + // create invisible line for HitTest/BoundRect + aRetval.push_back( + createHiddenGeometryPrimitives2D( + false, + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform())); + } + else + { + basegfx::B2DPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + getSdrLFSTAttribute().getLineStartEnd())); + } + + // add text + if(!getSdrLFSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform(), + getSdrLFSTAttribute().getText(), + getSdrLFSTAttribute().getLine(), + false, + false)); + } + + // add shadow + if(!getSdrLFSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLFSTAttribute().getShadow()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrEllipseSegmentPrimitive2D::SdrEllipseSegmentPrimitive2D( + const basegfx::B2DHomMatrix& rTransform, + const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute, + double fStartAngle, + double fEndAngle, + bool bCloseSegment, + bool bCloseUsingCenter) + : SdrEllipsePrimitive2D(rTransform, rSdrLFSTAttribute), + mfStartAngle(fStartAngle), + mfEndAngle(fEndAngle), + mbCloseSegment(bCloseSegment), + mbCloseUsingCenter(bCloseUsingCenter) + { + } + + bool SdrEllipseSegmentPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(SdrEllipsePrimitive2D::operator==(rPrimitive)) + { + const SdrEllipseSegmentPrimitive2D& rCompare = static_cast<const SdrEllipseSegmentPrimitive2D&>(rPrimitive); + + if( mfStartAngle == rCompare.mfStartAngle + && mfEndAngle == rCompare.mfEndAngle + && mbCloseSegment == rCompare.mbCloseSegment + && mbCloseUsingCenter == rCompare.mbCloseUsingCenter) + { + return true; + } + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrEllipseSegmentPrimitive2D, PRIMITIVE2D_ID_SDRELLIPSESEGMENTPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrframeborderprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrframeborderprimitive2d.cxx new file mode 100644 index 000000000..979941720 --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrframeborderprimitive2d.cxx @@ -0,0 +1,934 @@ +/* -*- 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 <svx/sdr/primitive2d/sdrframeborderprimitive2d.hxx> +#include <drawinglayer/primitive2d/borderlineprimitive2d.hxx> +#include <drawinglayer/geometry/viewinformation2d.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <svtools/borderhelper.hxx> + +namespace +{ + double snapToDiscreteUnit( + double fValue, + double fMinimalDiscreteUnit) + { + if(0.0 != fValue) + { + fValue = std::max(fValue, fMinimalDiscreteUnit); + } + + return fValue; + } + + class StyleVectorCombination + { + private: + struct OffsetAndHalfWidthAndColor + { + double mfOffset; + double mfHalfWidth; + Color maColor; + + OffsetAndHalfWidthAndColor(double offset, double halfWidth, Color color) : + mfOffset(offset), + mfHalfWidth(halfWidth), + maColor(color) + {} + }; + + double mfRefModeOffset; + basegfx::B2DVector maB2DVector; + double mfAngle; + std::vector< OffsetAndHalfWidthAndColor > maOffsets; + + public: + StyleVectorCombination( + const svx::frame::Style& rStyle, + const basegfx::B2DVector& rB2DVector, + double fAngle, + bool bMirrored, + const Color* pForceColor, + double fMinimalDiscreteUnit) + : mfRefModeOffset(0.0), + maB2DVector(rB2DVector), + mfAngle(fAngle), + maOffsets() + { + if (rStyle.IsUsed()) + { + svx::frame::RefMode aRefMode(rStyle.GetRefMode()); + Color aPrim(rStyle.GetColorPrim()); + Color aSecn(rStyle.GetColorSecn()); + const bool bSecnUsed(0.0 != rStyle.Secn()); + + // Get the single segment line widths. This is the point where the + // minimal discrete unit will be used if given (fMinimalDiscreteUnit). If + // not given it's 0.0 and thus will have no influence. + double fPrim(snapToDiscreteUnit(rStyle.Prim(), fMinimalDiscreteUnit)); + const double fDist(snapToDiscreteUnit(rStyle.Dist(), fMinimalDiscreteUnit)); + double fSecn(snapToDiscreteUnit(rStyle.Secn(), fMinimalDiscreteUnit)); + + // Of course also do not use svx::frame::Style::GetWidth() for obvious + // reasons. + const double fStyleWidth(fPrim + fDist + fSecn); + + if(bMirrored) + { + switch(aRefMode) + { + case svx::frame::RefMode::Begin: aRefMode = svx::frame::RefMode::End; break; + case svx::frame::RefMode::End: aRefMode = svx::frame::RefMode::Begin; break; + default: break; + } + + if(bSecnUsed) + { + std::swap(aPrim, aSecn); + std::swap(fPrim, fSecn); + } + } + + if (svx::frame::RefMode::Centered != aRefMode) + { + const double fHalfWidth(fStyleWidth * 0.5); + + if (svx::frame::RefMode::Begin == aRefMode) + { + // move aligned below vector + mfRefModeOffset = fHalfWidth; + } + else if (svx::frame::RefMode::End == aRefMode) + { + // move aligned above vector + mfRefModeOffset = -fHalfWidth; + } + } + + if (bSecnUsed) + { + // both or all three lines used + const bool bPrimTransparent(0xff == rStyle.GetColorPrim().GetTransparency()); + const bool bDistTransparent(!rStyle.UseGapColor() || 0xff == rStyle.GetColorGap().GetTransparency()); + const bool bSecnTransparent(0xff == aSecn.GetTransparency()); + + if(!bPrimTransparent || !bDistTransparent || !bSecnTransparent) + { + const double a(mfRefModeOffset - (fStyleWidth * 0.5)); + const double b(a + fPrim); + const double c(b + fDist); + const double d(c + fSecn); + + maOffsets.push_back( + OffsetAndHalfWidthAndColor( + (a + b) * 0.5, + fPrim * 0.5, + nullptr != pForceColor ? *pForceColor : aPrim)); + + maOffsets.push_back( + OffsetAndHalfWidthAndColor( + (b + c) * 0.5, + fDist * 0.5, + rStyle.UseGapColor() + ? (nullptr != pForceColor ? *pForceColor : rStyle.GetColorGap()) + : COL_TRANSPARENT)); + + maOffsets.push_back( + OffsetAndHalfWidthAndColor( + (c + d) * 0.5, + fSecn * 0.5, + nullptr != pForceColor ? *pForceColor : aSecn)); + } + } + else + { + // one line used, push two values, from outer to inner + if(0xff != rStyle.GetColorPrim().GetTransparency()) + { + maOffsets.push_back( + OffsetAndHalfWidthAndColor( + mfRefModeOffset, + fPrim * 0.5, + nullptr != pForceColor ? *pForceColor : aPrim)); + } + } + } + } + + double getRefModeOffset() const { return mfRefModeOffset; } + const basegfx::B2DVector& getB2DVector() const { return maB2DVector; } + double getAngle() const { return mfAngle; } + bool empty() const { return maOffsets.empty(); } + size_t size() const { return maOffsets.size(); } + + void getColorAndOffsetAndHalfWidth(size_t nIndex, Color& rColor, double& rfOffset, double& rfHalfWidth) const + { + if(nIndex >= maOffsets.size()) + return; + const OffsetAndHalfWidthAndColor& rCandidate(maOffsets[nIndex]); + rfOffset = rCandidate.mfOffset; + rfHalfWidth = rCandidate.mfHalfWidth; + rColor = rCandidate.maColor; + } + }; + + class StyleVectorTable + { + private: + std::vector< StyleVectorCombination > maEntries; + + public: + StyleVectorTable() + : maEntries() + { + } + + void add( + const svx::frame::Style& rStyle, + const basegfx::B2DVector& rMyVector, + const basegfx::B2DVector& rOtherVector, + bool bMirrored, + double fMinimalDiscreteUnit) + { + if(rStyle.IsUsed() && !basegfx::areParallel(rMyVector, rOtherVector)) + { + // create angle between both. angle() needs vectors pointing away from the same point, + // so take the mirrored one. Add F_PI to get from -pi..+pi to [0..F_PI2] for sorting + const double fAngle(basegfx::B2DVector(-rMyVector.getX(), -rMyVector.getY()).angle(rOtherVector) + F_PI); + maEntries.emplace_back( + rStyle, + rOtherVector, + fAngle, + bMirrored, + nullptr, + fMinimalDiscreteUnit); + } + } + + void sort() + { + // sort inverse from highest to lowest + std::sort( + maEntries.begin(), + maEntries.end(), + [](const StyleVectorCombination& a, const StyleVectorCombination& b) + { return a.getAngle() > b.getAngle(); }); + } + + bool empty() const { return maEntries.empty(); } + const std::vector< StyleVectorCombination >& getEntries() const{ return maEntries; } + }; + + struct CutSet + { + double mfOLML; + double mfORML; + double mfOLMR; + double mfORMR; + + CutSet() : mfOLML(0.0), mfORML(0.0), mfOLMR(0.0), mfORMR(0.0) + { + } + + bool operator<( const CutSet& rOther) const + { + const double fA(mfOLML + mfORML + mfOLMR + mfORMR); + const double fB(rOther.mfOLML + rOther.mfORML + rOther.mfOLMR + rOther.mfORMR); + + return fA < fB; + } + + double getSum() const { return mfOLML + mfORML + mfOLMR + mfORMR; } + }; + + void getCutSet( + CutSet& rCutSet, + const basegfx::B2DPoint& rLeft, + const basegfx::B2DPoint& rRight, + const basegfx::B2DVector& rX, + const basegfx::B2DPoint& rOtherLeft, + const basegfx::B2DPoint& rOtherRight, + const basegfx::B2DVector& rOtherX) + { + basegfx::utils::findCut( + rLeft, + rX, + rOtherLeft, + rOtherX, + CutFlagValue::LINE, + &rCutSet.mfOLML); + + basegfx::utils::findCut( + rRight, + rX, + rOtherLeft, + rOtherX, + CutFlagValue::LINE, + &rCutSet.mfOLMR); + + basegfx::utils::findCut( + rLeft, + rX, + rOtherRight, + rOtherX, + CutFlagValue::LINE, + &rCutSet.mfORML); + + basegfx::utils::findCut( + rRight, + rX, + rOtherRight, + rOtherX, + CutFlagValue::LINE, + &rCutSet.mfORMR); + } + + struct ExtendSet + { + double mfExtLeft; + double mfExtRight; + + ExtendSet() : mfExtLeft(0.0), mfExtRight(0.0) {} + }; + + void getExtends( + std::vector<ExtendSet>& rExtendSet, // target Left/Right values to fill + const basegfx::B2DPoint& rOrigin, // own vector start + const StyleVectorCombination& rCombination, // own vector and offsets for lines + const basegfx::B2DVector& rPerpendX, // normalized perpendicular to own vector + const std::vector< StyleVectorCombination >& rStyleVector) // other vectors emerging in this point + { + if(!rCombination.empty() && !rStyleVector.empty() && rCombination.size() == rExtendSet.size()) + { + const size_t nOffsetA(rCombination.size()); + + if(1 == nOffsetA) + { + Color aMyColor; double fMyOffset(0.0); double fMyHalfWidth(0.0); + rCombination.getColorAndOffsetAndHalfWidth(0, aMyColor, fMyOffset, fMyHalfWidth); + + if(0xff != aMyColor.GetTransparency()) + { + const basegfx::B2DPoint aLeft(rOrigin + (rPerpendX * (fMyOffset - fMyHalfWidth))); + const basegfx::B2DPoint aRight(rOrigin + (rPerpendX * (fMyOffset + fMyHalfWidth))); + std::vector< CutSet > aCutSets; + + for(const auto& rStyleCandidate : rStyleVector) + { + const basegfx::B2DVector aOtherPerpend(basegfx::getNormalizedPerpendicular(rStyleCandidate.getB2DVector())); + const size_t nOffsetB(rStyleCandidate.size()); + + for(size_t other(0); other < nOffsetB; other++) + { + Color aOtherColor; double fOtherOffset(0.0); double fOtherHalfWidth(0.0); + rStyleCandidate.getColorAndOffsetAndHalfWidth(other, aOtherColor, fOtherOffset, fOtherHalfWidth); + + if(0xff != aOtherColor.GetTransparency()) + { + const basegfx::B2DPoint aOtherLeft(rOrigin + (aOtherPerpend * (fOtherOffset - fOtherHalfWidth))); + const basegfx::B2DPoint aOtherRight(rOrigin + (aOtherPerpend * (fOtherOffset + fOtherHalfWidth))); + + CutSet aNewCutSet; + getCutSet(aNewCutSet, aLeft, aRight, rCombination.getB2DVector(), aOtherLeft, aOtherRight, rStyleCandidate.getB2DVector()); + aCutSets.push_back(aNewCutSet); + } + } + } + + if(!aCutSets.empty()) + { + CutSet aCutSet(aCutSets[0]); + const size_t nNumCutSets(aCutSets.size()); + + if(1 != nNumCutSets) + { + double fCutSet(aCutSet.getSum()); + + for(size_t a(1); a < nNumCutSets; a++) + { + const CutSet& rCandidate(aCutSets[a]); + const double fCandidate(rCandidate.getSum()); + + if(basegfx::fTools::equalZero(fCandidate - fCutSet)) + { + // both have equal center point, use medium cut + const double fNewOLML(std::max(std::min(rCandidate.mfOLML, rCandidate.mfORML), std::min(aCutSet.mfOLML, aCutSet.mfORML))); + const double fNewORML(std::min(std::max(rCandidate.mfOLML, rCandidate.mfORML), std::max(aCutSet.mfOLML, aCutSet.mfORML))); + const double fNewOLMR(std::max(std::min(rCandidate.mfOLMR, rCandidate.mfORMR), std::min(aCutSet.mfOLMR, aCutSet.mfORMR))); + const double fNewORMR(std::min(std::max(rCandidate.mfOLMR, rCandidate.mfORMR), std::max(aCutSet.mfOLMR, aCutSet.mfORMR))); + aCutSet.mfOLML = fNewOLML; + aCutSet.mfORML = fNewORML; + aCutSet.mfOLMR = fNewOLMR; + aCutSet.mfORMR = fNewORMR; + fCutSet = aCutSet.getSum(); + } + else if(fCandidate < fCutSet) + { + // get minimum + fCutSet = fCandidate; + aCutSet = rCandidate; + } + } + } + + ExtendSet& rExt(rExtendSet[0]); + + rExt.mfExtLeft = std::min(aCutSet.mfOLML, aCutSet.mfORML); + rExt.mfExtRight = std::min(aCutSet.mfOLMR, aCutSet.mfORMR); + } + } + } + else + { + size_t nVisEdgeUp(0); + size_t nVisEdgeDn(0); + + for(size_t my(0); my < nOffsetA; my++) + { + Color aMyColor; double fMyOffset(0.0); double fMyHalfWidth(0.0); + rCombination.getColorAndOffsetAndHalfWidth(my, aMyColor, fMyOffset, fMyHalfWidth); + + if(0xff != aMyColor.GetTransparency()) + { + const basegfx::B2DPoint aLeft(rOrigin + (rPerpendX * (fMyOffset - fMyHalfWidth))); + const basegfx::B2DPoint aRight(rOrigin + (rPerpendX * (fMyOffset + fMyHalfWidth))); + const bool bUpper(my <= (nOffsetA >> 1)); + const StyleVectorCombination& rStyleCandidate(bUpper ? rStyleVector.front() : rStyleVector.back()); + const basegfx::B2DVector aOtherPerpend(basegfx::getNormalizedPerpendicular(rStyleCandidate.getB2DVector())); + const size_t nOffsetB(rStyleCandidate.size()); + std::vector< CutSet > aCutSets; + + for(size_t other(0); other < nOffsetB; other++) + { + Color aOtherColor; double fOtherOffset(0.0); double fOtherHalfWidth(0.0); + rStyleCandidate.getColorAndOffsetAndHalfWidth(other, aOtherColor, fOtherOffset, fOtherHalfWidth); + + if(0xff != aOtherColor.GetTransparency()) + { + const basegfx::B2DPoint aOtherLeft(rOrigin + (aOtherPerpend * (fOtherOffset - fOtherHalfWidth))); + const basegfx::B2DPoint aOtherRight(rOrigin + (aOtherPerpend * (fOtherOffset + fOtherHalfWidth))); + CutSet aCutSet; + getCutSet(aCutSet, aLeft, aRight, rCombination.getB2DVector(), aOtherLeft, aOtherRight, rStyleCandidate.getB2DVector()); + aCutSets.push_back(aCutSet); + } + } + + if(!aCutSets.empty()) + { + // sort: min to start, max to end + std::sort(aCutSets.begin(), aCutSets.end()); + const bool bOtherUpper(rStyleCandidate.getAngle() > F_PI); + + // check if we need min or max + // bUpper bOtherUpper MinMax + // t t max + // t f min + // f f max + // f t min + const bool bMax(bUpper == bOtherUpper); + size_t nBaseIndex(0); + const size_t nNumCutSets(aCutSets.size()); + + if(bMax) + { + // access at end + nBaseIndex = nNumCutSets - 1 - (bUpper ? nVisEdgeUp : nVisEdgeDn); + } + else + { + // access at start + nBaseIndex = bUpper ? nVisEdgeUp : nVisEdgeDn; + } + + const size_t nSecuredIndex(std::min(nNumCutSets - 1, std::max(nBaseIndex, static_cast< size_t >(0)))); + const CutSet& rCutSet(aCutSets[nSecuredIndex]); + ExtendSet& rExt(rExtendSet[my]); + + rExt.mfExtLeft = std::min(rCutSet.mfOLML, rCutSet.mfORML); + rExt.mfExtRight = std::min(rCutSet.mfOLMR, rCutSet.mfORMR); + } + + if(bUpper) + { + nVisEdgeUp++; + } + else + { + nVisEdgeDn++; + } + } + } + } + } + } + + /** + * Helper method to create the correct drawinglayer::primitive2d::BorderLinePrimitive2D + * for the given data, especially the correct drawinglayer::primitive2d::BorderLine entries + * including the correctly solved/created LineStartEnd extends + * + * rTarget : Here the evtl. created BorderLinePrimitive2D will be appended + * rOrigin : StartPoint of the Borderline + * rX : Vector of the Borderline + * rBorder : svx::frame::Style of the of the Borderline + * rStartStyleVectorTable : All other Borderlines which have to be taken into account because + * they have the same StartPoint as the current Borderline. These will be used to calculate + * the correct LineStartEnd extends tor the BorderLinePrimitive2D. The definition should be + * built up using svx::frame::StyleVectorTable and StyleVectorTable::add and includes: + * rStyle : the svx::frame::Style of one other BorderLine + * rMyVector : the Vector of the *new* to-be-defined BorderLine, identical to rX + * rOtherVector: the Vector of one other BorderLine (may be, but does not need to be normalized), + * always *pointing away* from the common StartPoint rOrigin + * bMirrored : define if rStyle of one other BorderLine shall be mirrored (e.g. bottom-right edges) + * With multiple BorderLines the definitions have to be CounterClockWise. This will be + * ensured by StyleVectorTable sorting the entries, but knowing this may allow more efficient + * data creation. + * rEndStyleVectorTable: All other BorderLines that have the same EndPoint. There are differences to + * the Start definitions: + * - do not forget to consequently use -rX for rMyVector + * - definitions have to be ClockWise for the EndBorderLines, will be ensured by sorting + * + * If you take all this into account, you will get correctly extended BorderLinePrimitive2D + * representations for the new to be defined BorderLine. That extensions will overlap nicely + * with the corresponding BorderLines and take all multiple line definitions in the ::Style into + * account. + * The internal solver is *not limited* to ::Style(s) with three parts (Left/Gap/Right), this is + * just due to svx::frame::Style's definitions. A new solver based on this one can be created + * anytime using more mulötiple borders based on the more flexible + * std::vector< drawinglayer::primitive2d::BorderLine > if needed. + */ + void CreateBorderPrimitives( + drawinglayer::primitive2d::Primitive2DContainer& rTarget, /// target for created primitives + const basegfx::B2DPoint& rOrigin, /// start point of borderline + const basegfx::B2DVector& rX, /// X-Axis of borderline with length + const svx::frame::Style& rBorder, /// Style of borderline + const StyleVectorTable& rStartStyleVectorTable, /// Styles and vectors (pointing away) at borderline start, ccw + const StyleVectorTable& rEndStyleVectorTable, /// Styles and vectors (pointing away) at borderline end, cw + const Color* pForceColor, /// If specified, overrides frame border color. + double fMinimalDiscreteUnit) /// minimal discrete unit to use for svx::frame::Style width values + { + // get offset color pairs for style, one per visible line + const StyleVectorCombination aCombination( + rBorder, + rX, + 0.0, + false, + pForceColor, + fMinimalDiscreteUnit); + + if(aCombination.empty()) + return; + + const basegfx::B2DVector aPerpendX(basegfx::getNormalizedPerpendicular(rX)); + const bool bHasStartStyles(!rStartStyleVectorTable.empty()); + const bool bHasEndStyles(!rEndStyleVectorTable.empty()); + const size_t nOffsets(aCombination.size()); + std::vector<ExtendSet> aExtendSetStart(nOffsets); + std::vector<ExtendSet> aExtendSetEnd(nOffsets); + + if(bHasStartStyles) + { + // create extends for line starts, use given point/vector and offsets + getExtends(aExtendSetStart, rOrigin, aCombination, aPerpendX, rStartStyleVectorTable.getEntries()); + } + + if(bHasEndStyles) + { + // Create extends for line ends, create inverse point/vector and inverse offsets. + const StyleVectorCombination aMirroredCombination( + rBorder, + -rX, + 0.0, + true, + pForceColor, + fMinimalDiscreteUnit); + + getExtends(aExtendSetEnd, rOrigin + rX, aMirroredCombination, -aPerpendX, rEndStyleVectorTable.getEntries()); + + // also need to inverse the result to apply to the correct lines + std::reverse(aExtendSetEnd.begin(), aExtendSetEnd.end()); + } + + std::vector< drawinglayer::primitive2d::BorderLine > aBorderlines; + const double fNegLength(-rX.getLength()); + + for(size_t a(0); a < nOffsets; a++) + { + Color aMyColor; + double fMyOffset(0.0); + double fMyHalfWidth(0.0); + aCombination.getColorAndOffsetAndHalfWidth(a, aMyColor, fMyOffset, fMyHalfWidth); + const ExtendSet& rExtStart(aExtendSetStart[a]); + const ExtendSet& rExtEnd(aExtendSetEnd[a]); + + if(0xff == aMyColor.GetTransparency()) + { + aBorderlines.push_back( + drawinglayer::primitive2d::BorderLine( + fMyHalfWidth * 2.0)); + } + else + { + aBorderlines.push_back( + drawinglayer::primitive2d::BorderLine( + drawinglayer::attribute::LineAttribute( + aMyColor.getBColor(), + fMyHalfWidth * 2.0), + fNegLength * rExtStart.mfExtLeft, + fNegLength * rExtStart.mfExtRight, + fNegLength * rExtEnd.mfExtRight, + fNegLength * rExtEnd.mfExtLeft)); + } + } + + static const double fPatScFact(10.0); // 10.0 multiply, see old code + const std::vector<double> aDashing(svtools::GetLineDashing(rBorder.Type(), rBorder.PatternScale() * fPatScFact)); + const drawinglayer::attribute::StrokeAttribute aStrokeAttribute(aDashing); + const basegfx::B2DPoint aStart(rOrigin + (aPerpendX * aCombination.getRefModeOffset())); + + rTarget.append( + drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::BorderLinePrimitive2D( + aStart, + aStart + rX, + aBorderlines, + aStrokeAttribute))); + } + + double getMinimalNonZeroValue(double fCurrent, double fNew) + { + if(0.0 != fNew) + { + if(0.0 != fCurrent) + { + fCurrent = std::min(fNew, fCurrent); + } + else + { + fCurrent = fNew; + } + } + + return fCurrent; + } + + double getMinimalNonZeroBorderWidthFromStyle(double fCurrent, const svx::frame::Style& rStyle) + { + if(rStyle.IsUsed()) + { + fCurrent = getMinimalNonZeroValue(fCurrent, rStyle.Prim()); + fCurrent = getMinimalNonZeroValue(fCurrent, rStyle.Dist()); + fCurrent = getMinimalNonZeroValue(fCurrent, rStyle.Secn()); + } + + return fCurrent; + } +} + +namespace drawinglayer::primitive2d +{ + SdrFrameBorderData::SdrConnectStyleData::SdrConnectStyleData( + const svx::frame::Style& rStyle, + const basegfx::B2DVector& rNormalizedPerpendicular, + bool bStyleMirrored) + : maStyle(rStyle), + maNormalizedPerpendicular(rNormalizedPerpendicular), + mbStyleMirrored(bStyleMirrored) + { + } + + bool SdrFrameBorderData::SdrConnectStyleData::operator==(const SdrFrameBorderData::SdrConnectStyleData& rCompare) const + { + return mbStyleMirrored == rCompare.mbStyleMirrored + && maStyle == rCompare.maStyle + && maNormalizedPerpendicular == rCompare.maNormalizedPerpendicular; + } + + SdrFrameBorderData::SdrFrameBorderData( + const basegfx::B2DPoint& rOrigin, + const basegfx::B2DVector& rX, + const svx::frame::Style& rStyle, + const Color* pForceColor) + : maOrigin(rOrigin), + maX(rX), + maStyle(rStyle), + maColor(nullptr != pForceColor ? *pForceColor : Color()), + mbForceColor(nullptr != pForceColor), + maStart(), + maEnd() + { + } + + void SdrFrameBorderData::addSdrConnectStyleData( + bool bStart, + const svx::frame::Style& rStyle, + const basegfx::B2DVector& rNormalizedPerpendicular, + bool bStyleMirrored) + { + if(rStyle.IsUsed()) + { + if(bStart) + { + maStart.emplace_back(rStyle, rNormalizedPerpendicular, bStyleMirrored); + } + else + { + maEnd.emplace_back(rStyle, rNormalizedPerpendicular, bStyleMirrored); + } + } + } + + void SdrFrameBorderData::create2DDecomposition( + Primitive2DContainer& rContainer, + double fMinimalDiscreteUnit) const + { + StyleVectorTable aStartVector; + StyleVectorTable aEndVector; + const basegfx::B2DVector aAxis(-maX); + + for(const auto& rStart : maStart) + { + aStartVector.add( + rStart.getStyle(), + maX, + rStart.getNormalizedPerpendicular(), + rStart.getStyleMirrored(), + fMinimalDiscreteUnit); + } + + for(const auto& rEnd : maEnd) + { + aEndVector.add( + rEnd.getStyle(), + aAxis, + rEnd.getNormalizedPerpendicular(), + rEnd.getStyleMirrored(), + fMinimalDiscreteUnit); + } + + aStartVector.sort(); + aEndVector.sort(); + + CreateBorderPrimitives( + rContainer, + maOrigin, + maX, + maStyle, + aStartVector, + aEndVector, + mbForceColor ? &maColor : nullptr, + fMinimalDiscreteUnit); + } + + double SdrFrameBorderData::getMinimalNonZeroBorderWidth() const + { + double fRetval(getMinimalNonZeroBorderWidthFromStyle(0.0, maStyle)); + + for(const auto& rStart : maStart) + { + fRetval = getMinimalNonZeroBorderWidthFromStyle(fRetval, rStart.getStyle()); + } + + for(const auto& rEnd : maEnd) + { + fRetval = getMinimalNonZeroBorderWidthFromStyle(fRetval, rEnd.getStyle()); + } + + return fRetval; + } + + + bool SdrFrameBorderData::operator==(const SdrFrameBorderData& rCompare) const + { + return maOrigin == rCompare.maOrigin + && maX == rCompare.maX + && maStyle == rCompare.maStyle + && maColor == rCompare.maColor + && mbForceColor == rCompare.mbForceColor + && maStart == rCompare.maStart + && maEnd == rCompare.maEnd; + } + + + void SdrFrameBorderPrimitive2D::create2DDecomposition( + Primitive2DContainer& rContainer, + const geometry::ViewInformation2D& /*aViewInformation*/) const + { + if(!getFrameBorders()) + { + return; + } + + Primitive2DContainer aRetval; + + // Check and use the minimal non-zero BorderWidth for decompose + // if that is set and wanted + const double fMinimalDiscreteUnit(doForceToSingleDiscreteUnit() + ? mfMinimalNonZeroBorderWidthUsedForDecompose + : 0.0); + + { + // decompose all buffered SdrFrameBorderData entries and try to merge them + // to reduce existing number of BorderLinePrimitive2D(s) + for(const auto& rCandidate : *getFrameBorders()) + { + // get decomposition on one SdrFrameBorderData entry + Primitive2DContainer aPartial; + rCandidate.create2DDecomposition( + aPartial, + fMinimalDiscreteUnit); + + for(const auto& aCandidatePartial : aPartial) + { + bool bDidMerge(false); + + // This algorithm is O(N^2) and repeated dynamic_cast inside would be quite costly. + // So check first and skip if the primitives aren't BorderLinePrimitive2D. + const drawinglayer::primitive2d::BorderLinePrimitive2D* candidatePartialAsBorder + = dynamic_cast<const drawinglayer::primitive2d::BorderLinePrimitive2D*>(aCandidatePartial.get()); + if(candidatePartialAsBorder) + { + for(auto& aCandidateRetval : aRetval) + { + const drawinglayer::primitive2d::BorderLinePrimitive2D* candidateRetvalAsBorder + = dynamic_cast<const drawinglayer::primitive2d::BorderLinePrimitive2D*>(aCandidateRetval.get()); + if(candidateRetvalAsBorder) + { + // try to merge by appending new data to existing data + const drawinglayer::primitive2d::Primitive2DReference aMergeRetvalPartial( + drawinglayer::primitive2d::tryMergeBorderLinePrimitive2D( + candidateRetvalAsBorder, + candidatePartialAsBorder)); + + if(aMergeRetvalPartial.is()) + { + // could append, replace existing data with merged data, done + aCandidateRetval = aMergeRetvalPartial; + bDidMerge = true; + break; + } + + // try to merge by appending existing data to new data + const drawinglayer::primitive2d::Primitive2DReference aMergePartialRetval( + drawinglayer::primitive2d::tryMergeBorderLinePrimitive2D( + candidatePartialAsBorder, + candidateRetvalAsBorder)); + + if(aMergePartialRetval.is()) + { + // could append, replace existing data with merged data, done + aCandidateRetval = aMergePartialRetval; + bDidMerge = true; + break; + } + } + } + } + + if(!bDidMerge) + { + // no merge after checking all existing data, append as new segment + aRetval.append(aCandidatePartial); + } + } + } + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrFrameBorderPrimitive2D::SdrFrameBorderPrimitive2D( + std::shared_ptr<SdrFrameBorderDataVector>& rFrameBorders, + bool bForceToSingleDiscreteUnit) + : BufferedDecompositionPrimitive2D(), + maFrameBorders(std::move(rFrameBorders)), + mfMinimalNonZeroBorderWidth(0.0), + mfMinimalNonZeroBorderWidthUsedForDecompose(0.0), + mbForceToSingleDiscreteUnit(bForceToSingleDiscreteUnit) + { + if(getFrameBorders() && doForceToSingleDiscreteUnit()) + { + // detect used minimal non-zero partial border width + for(const auto& rCandidate : *getFrameBorders()) + { + mfMinimalNonZeroBorderWidth = getMinimalNonZeroValue( + mfMinimalNonZeroBorderWidth, + rCandidate.getMinimalNonZeroBorderWidth()); + } + } + } + + bool SdrFrameBorderPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrFrameBorderPrimitive2D& rCompare = static_cast<const SdrFrameBorderPrimitive2D&>(rPrimitive); + + return (getFrameBorders() == rCompare.getFrameBorders() + || (getFrameBorders() && rCompare.getFrameBorders() + && *getFrameBorders() == *rCompare.getFrameBorders())) + && doForceToSingleDiscreteUnit() == rCompare.doForceToSingleDiscreteUnit(); + } + + return false; + } + + void SdrFrameBorderPrimitive2D::get2DDecomposition( + Primitive2DDecompositionVisitor& rVisitor, + const geometry::ViewInformation2D& rViewInformation) const + { + if(doForceToSingleDiscreteUnit()) + { + // Get the current DiscreteUnit, look at X and Y and use the maximum + const basegfx::B2DVector aDiscreteVector(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0)); + double fDiscreteUnit(std::min(fabs(aDiscreteVector.getX()), fabs(aDiscreteVector.getY()))); + + if(fDiscreteUnit <= mfMinimalNonZeroBorderWidth) + { + // no need to use it, reset + fDiscreteUnit = 0.0; + } + + if(fDiscreteUnit != mfMinimalNonZeroBorderWidthUsedForDecompose) + { + // conditions of last local decomposition have changed, delete + // possible content + if(!getBuffered2DDecomposition().empty()) + { + const_cast< SdrFrameBorderPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer()); + } + + // remember new conditions + const_cast< SdrFrameBorderPrimitive2D* >(this)->mfMinimalNonZeroBorderWidthUsedForDecompose = fDiscreteUnit; + } + } + + // call parent. This will call back ::create2DDecomposition above + // where mfMinimalNonZeroBorderWidthUsedForDecompose will be used + // when doForceToSingleDiscreteUnit() is true + BufferedDecompositionPrimitive2D::get2DDecomposition(rVisitor, rViewInformation); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrFrameBorderPrimitive2D, PRIMITIVE2D_ID_SDRFRAMEBORDERTPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrgrafprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrgrafprimitive2d.cxx new file mode 100644 index 000000000..8f8925201 --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrgrafprimitive2d.cxx @@ -0,0 +1,180 @@ +/* -*- 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 <sdr/primitive2d/sdrgrafprimitive2d.hxx> +#include <drawinglayer/primitive2d/graphicprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> + +namespace drawinglayer::primitive2d +{ + void SdrGrafPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval; + + // create unit outline polygon + const basegfx::B2DPolygon& aUnitOutline(basegfx::utils::createUnitPolygon()); + + // add fill, but only when graphic is transparent + if(!getSdrLFSTAttribute().getFill().isDefault() && isTransparent()) + { + basegfx::B2DPolyPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + + // add graphic content + if(255 != getGraphicAttr().GetTransparency()) + { + // standard graphic fill + const Primitive2DReference xGraphicContentPrimitive( + new GraphicPrimitive2D( + getTransform(), + getGraphicObject(), + getGraphicAttr())); + aRetval.push_back(xGraphicContentPrimitive); + } + + // add line + if(!getSdrLFSTAttribute().getLine().isDefault()) + { + // if line width is given, polygon needs to be grown by half of it to make the + // outline to be outside of the bitmap + if(0.0 != getSdrLFSTAttribute().getLine().getWidth()) + { + // decompose to get scale + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + getTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // create expanded range (add relative half line width to unit rectangle) + double fHalfLineWidth(getSdrLFSTAttribute().getLine().getWidth() * 0.5); + double fScaleX(0.0 != aScale.getX() ? fHalfLineWidth / fabs(aScale.getX()) : 1.0); + double fScaleY(0.0 != aScale.getY() ? fHalfLineWidth / fabs(aScale.getY()) : 1.0); + const basegfx::B2DRange aExpandedRange(-fScaleX, -fScaleY, 1.0 + fScaleX, 1.0 + fScaleY); + basegfx::B2DPolygon aExpandedUnitOutline(basegfx::utils::createPolygonFromRect(aExpandedRange)); + + aExpandedUnitOutline.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aExpandedUnitOutline, + getSdrLFSTAttribute().getLine(), + attribute::SdrLineStartEndAttribute())); + } + else + { + basegfx::B2DPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + attribute::SdrLineStartEndAttribute())); + } + } + + // Soft edges should be before text, since text is not affected by soft edges + if (!aRetval.empty() && getSdrLFSTAttribute().getSoftEdgeRadius()) + { + aRetval = createEmbeddedSoftEdgePrimitive( + aRetval, getSdrLFSTAttribute().getSoftEdgeRadius()); + } + + // add text + if(!getSdrLFSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform(), + getSdrLFSTAttribute().getText(), + getSdrLFSTAttribute().getLine(), + false, + false)); + } + + // tdf#132199: put glow before shadow, to have shadow of the glow, not the opposite + if (!aRetval.empty() && !getSdrLFSTAttribute().getGlow().isDefault()) + { + // glow + aRetval = createEmbeddedGlowPrimitive(aRetval, getSdrLFSTAttribute().getGlow()); + } + + // add shadow + if(!getSdrLFSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLFSTAttribute().getShadow(), + getTransform()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrGrafPrimitive2D::SdrGrafPrimitive2D( + const basegfx::B2DHomMatrix& rTransform, + const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute, + const GraphicObject& rGraphicObject, + const GraphicAttr& rGraphicAttr) + : BufferedDecompositionPrimitive2D(), + maTransform(rTransform), + maSdrLFSTAttribute(rSdrLFSTAttribute), + maGraphicObject(rGraphicObject), + maGraphicAttr(rGraphicAttr) + { + // reset some values from GraphicAttr which are part of transformation already + maGraphicAttr.SetRotation(0); + } + + bool SdrGrafPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrGrafPrimitive2D& rCompare = static_cast<const SdrGrafPrimitive2D&>(rPrimitive); + + return (getTransform() == rCompare.getTransform() + && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute() + && getGraphicObject() == rCompare.getGraphicObject() + && getGraphicAttr() == rCompare.getGraphicAttr()); + } + + return false; + } + + bool SdrGrafPrimitive2D::isTransparent() const + { + return ((0 != getGraphicAttr().GetTransparency()) + || (getGraphicObject().IsTransparent())); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrGrafPrimitive2D, PRIMITIVE2D_ID_SDRGRAFPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrmeasureprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrmeasureprimitive2d.cxx new file mode 100644 index 000000000..0b037e5fa --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrmeasureprimitive2d.cxx @@ -0,0 +1,495 @@ +/* -*- 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 <sdr/primitive2d/sdrmeasureprimitive2d.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <sdr/primitive2d/sdrtextprimitive2d.hxx> +#include <sdr/attribute/sdrtextattribute.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include <rtl/ref.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + Primitive2DReference SdrMeasurePrimitive2D::impCreatePart( + const attribute::SdrLineAttribute& rLineAttribute, + const basegfx::B2DHomMatrix& rObjectMatrix, + const basegfx::B2DPoint& rStart, + const basegfx::B2DPoint& rEnd, + bool bLeftActive, + bool bRightActive) const + { + const attribute::SdrLineStartEndAttribute& rLineStartEnd = getSdrLSTAttribute().getLineStartEnd(); + basegfx::B2DPolygon aPolygon; + + aPolygon.append(rStart); + aPolygon.append(rEnd); + aPolygon.transform(rObjectMatrix); + + if(rLineStartEnd.isDefault() || (!bLeftActive && !bRightActive)) + { + return createPolygonLinePrimitive( + aPolygon, + rLineAttribute, + attribute::SdrLineStartEndAttribute()); + } + + if(bLeftActive && bRightActive) + { + return createPolygonLinePrimitive( + aPolygon, + rLineAttribute, + rLineStartEnd); + } + + const basegfx::B2DPolyPolygon aEmpty; + const attribute::SdrLineStartEndAttribute aLineStartEnd( + bLeftActive ? rLineStartEnd.getStartPolyPolygon() : aEmpty, bRightActive ? rLineStartEnd.getEndPolyPolygon() : aEmpty, + bLeftActive ? rLineStartEnd.getStartWidth() : 0.0, bRightActive ? rLineStartEnd.getEndWidth() : 0.0, + bLeftActive && rLineStartEnd.isStartActive(), bRightActive && rLineStartEnd.isEndActive(), + bLeftActive && rLineStartEnd.isStartCentered(), bRightActive && rLineStartEnd.isEndCentered()); + + return createPolygonLinePrimitive( + aPolygon, + rLineAttribute, + aLineStartEnd); + } + + void SdrMeasurePrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const + { + Primitive2DContainer aRetval; + rtl::Reference<SdrBlockTextPrimitive2D> xBlockText; + basegfx::B2DRange aTextRange; + const basegfx::B2DVector aLine(getEnd() - getStart()); + const double fDistance(aLine.getLength()); + const double fAngle(atan2(aLine.getY(), aLine.getX())); + bool bAutoUpsideDown(false); + const attribute::SdrTextAttribute rTextAttribute = getSdrLSTAttribute().getText(); + const basegfx::B2DHomMatrix aObjectMatrix( + basegfx::utils::createShearXRotateTranslateB2DHomMatrix(0.0, fAngle, getStart())); + + // prepare text, but do not add yet; it needs to be aligned to + // the line geometry + if(!rTextAttribute.isDefault()) + { + basegfx::B2DHomMatrix aTextMatrix; + double fTestAngle(fAngle); + + if(getTextRotation()) + { + aTextMatrix.rotate(-F_PI2); + fTestAngle -= (F_PI2); + + if(getTextAutoAngle() && fTestAngle < -F_PI) + { + fTestAngle += F_2PI; + } + } + + if(getTextAutoAngle()) + { + if(fTestAngle > (F_PI / 4.0) || fTestAngle < (-F_PI * (3.0 / 4.0))) + { + bAutoUpsideDown = true; + } + } + + // create primitive and get text range + xBlockText = new SdrBlockTextPrimitive2D( + &rTextAttribute.getSdrText(), + rTextAttribute.getOutlinerParaObject(), + aTextMatrix, + SDRTEXTHORZADJUST_CENTER, + SDRTEXTVERTADJUST_CENTER, + rTextAttribute.isScroll(), + false, + false, + false); + + aTextRange = xBlockText->getB2DRange(aViewInformation); + } + + // prepare line attribute and result + double fTextX; + double fTextY; + { + const attribute::SdrLineAttribute rLineAttribute(getSdrLSTAttribute().getLine()); + bool bArrowsOutside(false); + bool bMainLineSplitted(false); + const attribute::SdrLineStartEndAttribute& rLineStartEnd = getSdrLSTAttribute().getLineStartEnd(); + double fStartArrowW(0.0); + double fStartArrowH(0.0); + double fEndArrowW(0.0); + double fEndArrowH(0.0); + + if(!rLineStartEnd.isDefault()) + { + if(rLineStartEnd.isStartActive()) + { + const basegfx::B2DRange aArrowRange(basegfx::utils::getRange(rLineStartEnd.getStartPolyPolygon())); + fStartArrowW = rLineStartEnd.getStartWidth(); + fStartArrowH = aArrowRange.getHeight() * fStartArrowW / aArrowRange.getWidth(); + + if(rLineStartEnd.isStartCentered()) + { + fStartArrowH *= 0.5; + } + } + + if(rLineStartEnd.isEndActive()) + { + const basegfx::B2DRange aArrowRange(basegfx::utils::getRange(rLineStartEnd.getEndPolyPolygon())); + fEndArrowW = rLineStartEnd.getEndWidth(); + fEndArrowH = aArrowRange.getHeight() * fEndArrowW / aArrowRange.getWidth(); + + if(rLineStartEnd.isEndCentered()) + { + fEndArrowH *= 0.5; + } + } + } + + const double fSpaceNeededByArrows(fStartArrowH + fEndArrowH + ((fStartArrowW + fEndArrowW) * 0.5)); + const double fArrowsOutsideLen((fStartArrowH + fEndArrowH + fStartArrowW + fEndArrowW) * 0.5); + const double fHalfLineWidth(rLineAttribute.getWidth() * 0.5); + + if(fSpaceNeededByArrows > fDistance) + { + bArrowsOutside = true; + } + + MeasureTextPosition eHorizontal(getHorizontal()); + MeasureTextPosition eVertical(getVertical()); + + if(MEASURETEXTPOSITION_AUTOMATIC == eVertical) + { + eVertical = MEASURETEXTPOSITION_NEGATIVE; + } + + if(MEASURETEXTPOSITION_CENTERED == eVertical) + { + bMainLineSplitted = true; + } + + if(MEASURETEXTPOSITION_AUTOMATIC == eHorizontal) + { + if(aTextRange.getWidth() > fDistance) + { + eHorizontal = MEASURETEXTPOSITION_NEGATIVE; + } + else + { + eHorizontal = MEASURETEXTPOSITION_CENTERED; + } + + if(bMainLineSplitted) + { + if(aTextRange.getWidth() + fSpaceNeededByArrows > fDistance) + { + bArrowsOutside = true; + } + } + else + { + const double fSmallArrowNeed(fStartArrowH + fEndArrowH + ((fStartArrowW + fEndArrowW) * 0.125)); + + if(aTextRange.getWidth() + fSmallArrowNeed > fDistance) + { + bArrowsOutside = true; + } + } + } + + if(MEASURETEXTPOSITION_CENTERED != eHorizontal) + { + bArrowsOutside = true; + } + + // switch text above/below? + if(getBelow() || (bAutoUpsideDown && !getTextRotation())) + { + if(MEASURETEXTPOSITION_NEGATIVE == eVertical) + { + eVertical = MEASURETEXTPOSITION_POSITIVE; + } + else if(MEASURETEXTPOSITION_POSITIVE == eVertical) + { + eVertical = MEASURETEXTPOSITION_NEGATIVE; + } + } + + const double fMainLineOffset(getBelow() ? getDistance() : -getDistance()); + const basegfx::B2DPoint aMainLeft(0.0, fMainLineOffset); + const basegfx::B2DPoint aMainRight(fDistance, fMainLineOffset); + + // main line + if(bArrowsOutside) + { + double fLenLeft(fArrowsOutsideLen); + double fLenRight(fArrowsOutsideLen); + + if(!bMainLineSplitted) + { + if(MEASURETEXTPOSITION_NEGATIVE == eHorizontal) + { + fLenLeft = fStartArrowH + aTextRange.getWidth(); + } + else if(MEASURETEXTPOSITION_POSITIVE == eHorizontal) + { + fLenRight = fEndArrowH + aTextRange.getWidth(); + } + } + + const basegfx::B2DPoint aMainLeftLeft(aMainLeft.getX() - fLenLeft, aMainLeft.getY()); + const basegfx::B2DPoint aMainRightRight(aMainRight.getX() + fLenRight, aMainRight.getY()); + + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aMainLeftLeft, aMainLeft, false, true)); + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aMainRight, aMainRightRight, true, false)); + + if(!bMainLineSplitted || MEASURETEXTPOSITION_CENTERED != eHorizontal) + { + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aMainLeft, aMainRight, false, false)); + } + } + else + { + if(bMainLineSplitted) + { + const double fHalfLength((fDistance - (aTextRange.getWidth() + (fStartArrowH + fEndArrowH) * 0.25)) * 0.5); + const basegfx::B2DPoint aMainInnerLeft(aMainLeft.getX() + fHalfLength, aMainLeft.getY()); + const basegfx::B2DPoint aMainInnerRight(aMainRight.getX() - fHalfLength, aMainRight.getY()); + + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aMainLeft, aMainInnerLeft, true, false)); + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aMainInnerRight, aMainRight, false, true)); + } + else + { + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aMainLeft, aMainRight, true, true)); + } + } + + // left/right help line value preparation + const double fTopEdge(getBelow() ? getUpper() + getDistance() : -getUpper() - getDistance()); + const double fBottomLeft(getBelow() ? getLower() - getLeftDelta() : getLeftDelta() - getLower()); + const double fBottomRight(getBelow() ? getLower() - getRightDelta() : getRightDelta() - getLower()); + + // left help line + const basegfx::B2DPoint aLeftUp(0.0, fTopEdge); + const basegfx::B2DPoint aLeftDown(0.0, fBottomLeft); + + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aLeftDown, aLeftUp, false, false)); + + // right help line + const basegfx::B2DPoint aRightUp(fDistance, fTopEdge); + const basegfx::B2DPoint aRightDown(fDistance, fBottomRight); + + aRetval.push_back(impCreatePart(rLineAttribute, aObjectMatrix, aRightDown, aRightUp, false, false)); + + // text horizontal position + if(MEASURETEXTPOSITION_NEGATIVE == eHorizontal) + { + // left + const double fSmall(fArrowsOutsideLen * 0.18); + fTextX = aMainLeft.getX() - (fStartArrowH + aTextRange.getWidth() + fSmall + fHalfLineWidth); + + if(bMainLineSplitted) + { + fTextX -= (fArrowsOutsideLen - fStartArrowH); + } + + if(!rTextAttribute.isDefault()) + { + fTextX -= rTextAttribute.getTextRightDistance(); + } + } + else if(MEASURETEXTPOSITION_POSITIVE == eHorizontal) + { + // right + const double fSmall(fArrowsOutsideLen * 0.18); + fTextX = aMainRight.getX() + (fEndArrowH + fSmall + fHalfLineWidth); + + if(bMainLineSplitted) + { + fTextX += (fArrowsOutsideLen - fEndArrowH); + } + + if(!rTextAttribute.isDefault()) + { + fTextX += rTextAttribute.getTextLeftDistance(); + } + } + else // MEASURETEXTPOSITION_CENTERED + { + // centered + fTextX = aMainLeft.getX() + ((fDistance - aTextRange.getWidth()) * 0.5); + + if(!rTextAttribute.isDefault()) + { + fTextX += (rTextAttribute.getTextLeftDistance() - rTextAttribute.getTextRightDistance()) / 2L; + } + } + + // text vertical position + if(MEASURETEXTPOSITION_NEGATIVE == eVertical) + { + // top + const double fSmall(fArrowsOutsideLen * 0.10); + fTextY = aMainLeft.getY() - (aTextRange.getHeight() + fSmall + fHalfLineWidth); + + if(!rTextAttribute.isDefault()) + { + fTextY -= rTextAttribute.getTextLowerDistance(); + } + } + else if(MEASURETEXTPOSITION_POSITIVE == eVertical) + { + // bottom + const double fSmall(fArrowsOutsideLen * 0.10); + fTextY = aMainLeft.getY() + (fSmall + fHalfLineWidth); + + if(!rTextAttribute.isDefault()) + { + fTextY += rTextAttribute.getTextUpperDistance(); + } + } + else // MEASURETEXTPOSITION_CENTERED + { + // centered + fTextY = aMainLeft.getY() - (aTextRange.getHeight() * 0.5); + + if(!rTextAttribute.isDefault()) + { + fTextY += (rTextAttribute.getTextUpperDistance() - rTextAttribute.getTextLowerDistance()) / 2L; + } + } + } + + if(getSdrLSTAttribute().getLine().isDefault()) + { + // embed line geometry to invisible (100% transparent) line group for HitTest + const Primitive2DReference xHiddenLines(new HiddenGeometryPrimitive2D(aRetval)); + + aRetval = Primitive2DContainer { xHiddenLines }; + } + + if(xBlockText.is()) + { + // create transformation to text primitive end position + basegfx::B2DHomMatrix aChange; + + // handle auto text rotation + if(bAutoUpsideDown) + { + aChange.rotate(F_PI); + } + + // move from aTextRange.TopLeft to fTextX, fTextY + aChange.translate(fTextX - aTextRange.getMinX(), fTextY - aTextRange.getMinY()); + + // apply object matrix + aChange *= aObjectMatrix; + + // apply to existing text primitive + std::unique_ptr<SdrTextPrimitive2D> pNewBlockText = xBlockText->createTransformedClone(aChange); + OSL_ENSURE(pNewBlockText, "SdrMeasurePrimitive2D::create2DDecomposition: Could not create transformed clone of text primitive (!)"); + xBlockText.clear(); + + // add to local primitives + aRetval.push_back(Primitive2DReference(pNewBlockText.release())); + } + + // add shadow + if(!getSdrLSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLSTAttribute().getShadow()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrMeasurePrimitive2D::SdrMeasurePrimitive2D( + const attribute::SdrLineEffectsTextAttribute& rSdrLSTAttribute, + const basegfx::B2DPoint& rStart, + const basegfx::B2DPoint& rEnd, + MeasureTextPosition eHorizontal, + MeasureTextPosition eVertical, + double fDistance, + double fUpper, + double fLower, + double fLeftDelta, + double fRightDelta, + bool bBelow, + bool bTextRotation, + bool bTextAutoAngle) + : BufferedDecompositionPrimitive2D(), + maSdrLSTAttribute(rSdrLSTAttribute), + maStart(rStart), + maEnd(rEnd), + meHorizontal(eHorizontal), + meVertical(eVertical), + mfDistance(fDistance), + mfUpper(fUpper), + mfLower(fLower), + mfLeftDelta(fLeftDelta), + mfRightDelta(fRightDelta), + mbBelow(bBelow), + mbTextRotation(bTextRotation), + mbTextAutoAngle(bTextAutoAngle) + { + } + + bool SdrMeasurePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrMeasurePrimitive2D& rCompare = static_cast<const SdrMeasurePrimitive2D&>(rPrimitive); + + return (getStart() == rCompare.getStart() + && getEnd() == rCompare.getEnd() + && getHorizontal() == rCompare.getHorizontal() + && getVertical() == rCompare.getVertical() + && getDistance() == rCompare.getDistance() + && getUpper() == rCompare.getUpper() + && getLower() == rCompare.getLower() + && getLeftDelta() == rCompare.getLeftDelta() + && getRightDelta() == rCompare.getRightDelta() + && getBelow() == rCompare.getBelow() + && getTextRotation() == rCompare.getTextRotation() + && getTextAutoAngle() == rCompare.getTextAutoAngle() + && getSdrLSTAttribute() == rCompare.getSdrLSTAttribute()); + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrMeasurePrimitive2D, PRIMITIVE2D_ID_SDRMEASUREPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrole2primitive2d.cxx b/svx/source/sdr/primitive2d/sdrole2primitive2d.cxx new file mode 100644 index 000000000..0c4dafcd7 --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrole2primitive2d.cxx @@ -0,0 +1,174 @@ +/* -*- 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 <sdr/primitive2d/sdrole2primitive2d.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + SdrOle2Primitive2D::SdrOle2Primitive2D( + const Primitive2DContainer& rOLEContent, + const basegfx::B2DHomMatrix& rTransform, + const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute) + : BasePrimitive2D(), + maOLEContent(rOLEContent), + maTransform(rTransform), + maSdrLFSTAttribute(rSdrLFSTAttribute) + { + } + + bool SdrOle2Primitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BasePrimitive2D::operator==(rPrimitive)) + { + const SdrOle2Primitive2D& rCompare = static_cast<const SdrOle2Primitive2D&>(rPrimitive); + + // #i108636# The standard operator== on two UNO sequences did not work as i + // would have expected; it just checks the .is() states and the data type + // of the sequence. What i need here is detection of equality of the whole + // sequence content, thus i need to use the arePrimitive2DSequencesEqual helper + // here instead of the operator== which lead to always returning false and thus + // always re-decompositions of the subcontent. + if(getOLEContent() == rCompare.getOLEContent() + && getTransform() == rCompare.getTransform() + && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute()) + { + return true; + } + } + + return false; + } + + void SdrOle2Primitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + // to take care of getSdrLFSTAttribute() later, the same as in SdrGrafPrimitive2D::create2DDecomposition + // should happen. For the moment we only need the OLE itself + // Added complete primitive preparation using getSdrLFSTAttribute() now. + Primitive2DContainer aRetval; + + // create unit outline polygon + const basegfx::B2DPolygon& aUnitOutline(basegfx::utils::createUnitPolygon()); + + // add fill + if(!getSdrLFSTAttribute().getFill().isDefault()) + { + basegfx::B2DPolyPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + + // add line + // #i97981# condition was inverse to purpose. When being compatible to paint version, + // border needs to be suppressed + if(!getSdrLFSTAttribute().getLine().isDefault()) + { + // if line width is given, polygon needs to be grown by half of it to make the + // outline to be outside of the bitmap + if(0.0 != getSdrLFSTAttribute().getLine().getWidth()) + { + // decompose to get scale + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + getTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // create expanded range (add relative half line width to unit rectangle) + double fHalfLineWidth(getSdrLFSTAttribute().getLine().getWidth() * 0.5); + double fScaleX(0.0 != aScale.getX() ? fHalfLineWidth / fabs(aScale.getX()) : 1.0); + double fScaleY(0.0 != aScale.getY() ? fHalfLineWidth / fabs(aScale.getY()) : 1.0); + const basegfx::B2DRange aExpandedRange(-fScaleX, -fScaleY, 1.0 + fScaleX, 1.0 + fScaleY); + basegfx::B2DPolygon aExpandedUnitOutline(basegfx::utils::createPolygonFromRect(aExpandedRange)); + + aExpandedUnitOutline.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aExpandedUnitOutline, + getSdrLFSTAttribute().getLine(), + attribute::SdrLineStartEndAttribute())); + } + else + { + basegfx::B2DPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + attribute::SdrLineStartEndAttribute())); + } + } + else + { + // if initially no line is defined, create one for HitTest and BoundRect + aRetval.push_back( + createHiddenGeometryPrimitives2D( + false, + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform())); + } + + // add graphic content + aRetval.append(getOLEContent()); + + // add text, no need to suppress to stay compatible since text was + // always supported by the old paints, too + if(!getSdrLFSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform(), + getSdrLFSTAttribute().getText(), + getSdrLFSTAttribute().getLine(), + false, + false)); + } + + // add shadow + if(!getSdrLFSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLFSTAttribute().getShadow()); + } + + rVisitor.append(aRetval); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrOle2Primitive2D, PRIMITIVE2D_ID_SDROLE2PRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrolecontentprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrolecontentprimitive2d.cxx new file mode 100644 index 000000000..8d12cb838 --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrolecontentprimitive2d.cxx @@ -0,0 +1,177 @@ +/* -*- 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 <sdr/primitive2d/sdrolecontentprimitive2d.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <svx/svdoole2.hxx> +#include <vcl/svapp.hxx> +#include <drawinglayer/primitive2d/graphicprimitive2d.hxx> +#include <svtools/colorcfg.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> + + +namespace drawinglayer::primitive2d +{ + void SdrOleContentPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + const SdrOle2Obj* pSource = mpSdrOle2Obj.get(); + bool bScaleContent(false); + Graphic aGraphic; + + if(pSource) + { + const Graphic* pOLEGraphic = pSource->GetGraphic(); + + if(pOLEGraphic) + { + aGraphic = *pOLEGraphic; + bScaleContent = pSource->IsEmptyPresObj(); + } + } +#ifdef _WIN32 // Little point in displaying the "broken OLE" graphic on OSes that don't have real OLE, maybe? + if(GraphicType::NONE == aGraphic.GetType()) + { + // no source, use fallback resource empty OLE graphic + aGraphic = SdrOle2Obj::GetEmptyOLEReplacementGraphic(); + bScaleContent = true; + } +#endif + if(GraphicType::NONE != aGraphic.GetType()) + { + const GraphicObject aGraphicObject(aGraphic); + const GraphicAttr aGraphicAttr; + + if(bScaleContent) + { + // get transformation atoms + basegfx::B2DVector aScale, aTranslate; + double fRotate, fShearX; + getObjectTransform().decompose(aScale, aTranslate, fRotate, fShearX); + + // get PrefSize from the graphic in 100th mm + Size aPrefSize(aGraphic.GetPrefSize()); + + if(MapUnit::MapPixel == aGraphic.GetPrefMapMode().GetMapUnit()) + { + aPrefSize = Application::GetDefaultDevice()->PixelToLogic(aPrefSize, MapMode(MapUnit::Map100thMM)); + } + else + { + aPrefSize = OutputDevice::LogicToLogic(aPrefSize, aGraphic.GetPrefMapMode(), MapMode(MapUnit::Map100thMM)); + } + + const double fOffsetX((aScale.getX() - aPrefSize.getWidth()) / 2.0); + const double fOffsetY((aScale.getY() - aPrefSize.getHeight()) / 2.0); + + if(basegfx::fTools::moreOrEqual(fOffsetX, 0.0) && basegfx::fTools::moreOrEqual(fOffsetY, 0.0)) + { + // if content fits into frame, create it + basegfx::B2DHomMatrix aInnerObjectMatrix(basegfx::utils::createScaleTranslateB2DHomMatrix( + aPrefSize.getWidth(), aPrefSize.getHeight(), fOffsetX, fOffsetY)); + aInnerObjectMatrix = basegfx::utils::createShearXRotateTranslateB2DHomMatrix(fShearX, fRotate, aTranslate) + * aInnerObjectMatrix; + + const drawinglayer::primitive2d::Primitive2DReference aGraphicPrimitive( + new drawinglayer::primitive2d::GraphicPrimitive2D( + aInnerObjectMatrix, + aGraphicObject, + aGraphicAttr)); + rContainer.push_back(aGraphicPrimitive); + } + } + else + { + // create graphic primitive for content + const drawinglayer::primitive2d::Primitive2DReference aGraphicPrimitive( + new drawinglayer::primitive2d::GraphicPrimitive2D( + getObjectTransform(), + aGraphicObject, + aGraphicAttr)); + rContainer.push_back(aGraphicPrimitive); + } + + // a standard gray outline is created for scaled content + if(bScaleContent) + { + const svtools::ColorConfig aColorConfig; + const svtools::ColorConfigValue aColor(aColorConfig.GetColorValue(svtools::OBJECTBOUNDARIES)); + + if(aColor.bIsVisible) + { + basegfx::B2DPolygon aOutline(basegfx::utils::createUnitPolygon()); + const Color aVclColor(aColor.nColor); + aOutline.transform(getObjectTransform()); + const drawinglayer::primitive2d::Primitive2DReference xOutline( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(aOutline, aVclColor.getBColor())); + rContainer.push_back(xOutline); + } + } + } + } + + SdrOleContentPrimitive2D::SdrOleContentPrimitive2D( + const SdrOle2Obj& rSdrOle2Obj, + const basegfx::B2DHomMatrix& rObjectTransform, + sal_uInt32 nGraphicVersion + ) + : BufferedDecompositionPrimitive2D(), + mpSdrOle2Obj(const_cast< SdrOle2Obj* >(&rSdrOle2Obj)), + maObjectTransform(rObjectTransform), + mnGraphicVersion(nGraphicVersion) + { + } + + bool SdrOleContentPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if( BufferedDecompositionPrimitive2D::operator==(rPrimitive) ) + { + const SdrOleContentPrimitive2D& rCompare = static_cast<const SdrOleContentPrimitive2D&>(rPrimitive); + const bool bBothNot(!mpSdrOle2Obj.is() && !rCompare.mpSdrOle2Obj.is()); + const bool bBothAndEqual(mpSdrOle2Obj.is() && rCompare.mpSdrOle2Obj.is() + && mpSdrOle2Obj.get() == rCompare.mpSdrOle2Obj.get()); + + return ((bBothNot || bBothAndEqual) + && getObjectTransform() == rCompare.getObjectTransform() + + // #i104867# to find out if the Graphic content of the + // OLE has changed, use GraphicVersion number + && mnGraphicVersion == rCompare.mnGraphicVersion + ); + } + + return false; + } + + basegfx::B2DRange SdrOleContentPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const + { + basegfx::B2DRange aRange(0.0, 0.0, 1.0, 1.0); + aRange.transform(getObjectTransform()); + + return aRange; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrOleContentPrimitive2D, PRIMITIVE2D_ID_SDROLECONTENTPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrpathprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrpathprimitive2d.cxx new file mode 100644 index 000000000..721eff0ce --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrpathprimitive2d.cxx @@ -0,0 +1,154 @@ +/* -*- 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 <sdr/primitive2d/sdrpathprimitive2d.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + void SdrPathPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval; + + // add fill + if(!getSdrLFSTAttribute().getFill().isDefault() + && getUnitPolyPolygon().isClosed()) + { + // #i108255# no need to use correctOrientations here; target is + // straight visualisation + basegfx::B2DPolyPolygon aTransformed(getUnitPolyPolygon()); + aTransformed.transform(getTransform()); + + // OperationSmiley: Check if a UnitDefinitionPolyPolygon is set + if(getUnitDefinitionPolyPolygon().count() + && getUnitDefinitionPolyPolygon() != getUnitPolyPolygon()) + { + // if yes, use the B2DRange of it's transformed form + basegfx::B2DPolyPolygon aTransformedDefinition(getUnitDefinitionPolyPolygon()); + aTransformedDefinition.transform(getTransform()); + + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + aTransformedDefinition.getB2DRange(), + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + else + { + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + } + + // add line + if(getSdrLFSTAttribute().getLine().isDefault()) + { + // if initially no line is defined, create one for HitTest and BoundRect + aRetval.push_back( + createHiddenGeometryPrimitives2D( + false, + getUnitPolyPolygon(), + getTransform())); + } + else + { + Primitive2DContainer aTemp(getUnitPolyPolygon().count()); + + for(sal_uInt32 a(0); a < getUnitPolyPolygon().count(); a++) + { + basegfx::B2DPolygon aTransformed(getUnitPolyPolygon().getB2DPolygon(a)); + + aTransformed.transform(getTransform()); + aTemp[a] = createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + getSdrLFSTAttribute().getLineStartEnd()); + } + + aRetval.append(aTemp); + } + + // add text + if(!getSdrLFSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + getUnitPolyPolygon(), + getTransform(), + getSdrLFSTAttribute().getText(), + getSdrLFSTAttribute().getLine(), + false, + false)); + } + + // add shadow + if(!getSdrLFSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLFSTAttribute().getShadow()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrPathPrimitive2D::SdrPathPrimitive2D( + const basegfx::B2DHomMatrix& rTransform, + const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute, + const basegfx::B2DPolyPolygon& rUnitPolyPolygon, + const basegfx::B2DPolyPolygon& rUnitDefinitionPolyPolygon) + : BufferedDecompositionPrimitive2D(), + maTransform(rTransform), + maSdrLFSTAttribute(rSdrLFSTAttribute), + maUnitPolyPolygon(rUnitPolyPolygon), + maUnitDefinitionPolyPolygon(rUnitDefinitionPolyPolygon) + { + } + + bool SdrPathPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrPathPrimitive2D& rCompare = static_cast<const SdrPathPrimitive2D&>(rPrimitive); + + return (getUnitPolyPolygon() == rCompare.getUnitPolyPolygon() + && getUnitDefinitionPolyPolygon() == rCompare.getUnitDefinitionPolyPolygon() + && getTransform() == rCompare.getTransform() + && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute()); + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrPathPrimitive2D, PRIMITIVE2D_ID_SDRPATHPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrprimitivetools.cxx b/svx/source/sdr/primitive2d/sdrprimitivetools.cxx new file mode 100644 index 000000000..7e0b22a3f --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrprimitivetools.cxx @@ -0,0 +1,64 @@ +/* -*- 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 <sdr/primitive2d/sdrprimitivetools.hxx> +#include <osl/mutex.hxx> +#include <vcl/lazydelete.hxx> +#include <vcl/BitmapTools.hxx> + + +// helper methods + +namespace drawinglayer::primitive2d +{ + BitmapEx createDefaultCross_3x3(const basegfx::BColor& rBColor) + { + static vcl::DeleteOnDeinit< BitmapEx > aRetVal(nullptr); + static basegfx::BColor aBColor; + static ::osl::Mutex aMutex; + + ::osl::MutexGuard aGuard(aMutex); + + if(!aRetVal.get() || rBColor != aBColor) + { + // copy values + aBColor = rBColor; + + // create bitmap + Color c(aBColor); + sal_uInt8 r = c.GetRed(); + sal_uInt8 g = c.GetGreen(); + sal_uInt8 b = c.GetBlue(); + sal_uInt8 a = 255; + const sal_uInt8 cross[] = { + 0, 0, 0, a, r, g, b, 0, 0, 0, 0, a, + r, g, b, 0, r, g, b, 0, r, g, b, 0, + 0, 0, 0, a, r, g, b, 0, 0, 0, 0, a + }; + BitmapEx aBitmap = vcl::bitmap::CreateFromData(cross, 3, 3, 12, 32); + + // create and exchange at aRetVal + aRetVal.set(std::make_unique<BitmapEx>(aBitmap)); + } + + return aRetVal.get() ? *aRetVal.get() : BitmapEx(); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrrectangleprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrrectangleprimitive2d.cxx new file mode 100644 index 000000000..0d3387f2f --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrrectangleprimitive2d.cxx @@ -0,0 +1,150 @@ +/* -*- 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 <sdr/primitive2d/sdrrectangleprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <sdr/primitive2d/sdrdecompositiontools.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> + + +using namespace com::sun::star; + + +namespace drawinglayer::primitive2d +{ + void SdrRectanglePrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const + { + Primitive2DContainer aRetval; + + // create unit outline polygon + const basegfx::B2DPolygon aUnitOutline(basegfx::utils::createPolygonFromRect( + basegfx::B2DRange(0.0, 0.0, 1.0, 1.0), + getCornerRadiusX(), + getCornerRadiusY())); + + // add fill + if(!getSdrLFSTAttribute().getFill().isDefault()) + { + basegfx::B2DPolyPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolyPolygonFillPrimitive( + aTransformed, + getSdrLFSTAttribute().getFill(), + getSdrLFSTAttribute().getFillFloatTransGradient())); + } + else if(getForceFillForHitTest()) + { + // if no fill and it's a text frame, create a fill for HitTest and + // BoundRect fallback + aRetval.push_back( + createHiddenGeometryPrimitives2D( + true, + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform())); + } + + // add line + if(!getSdrLFSTAttribute().getLine().isDefault()) + { + basegfx::B2DPolygon aTransformed(aUnitOutline); + + aTransformed.transform(getTransform()); + aRetval.push_back( + createPolygonLinePrimitive( + aTransformed, + getSdrLFSTAttribute().getLine(), + attribute::SdrLineStartEndAttribute())); + } + else if(!getForceFillForHitTest()) + { + // if initially no line is defined and it's not a text frame, create + // a line for HitTest and BoundRect + aRetval.push_back( + createHiddenGeometryPrimitives2D( + false, + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform())); + } + + // add text + if(!getSdrLFSTAttribute().getText().isDefault()) + { + aRetval.push_back( + createTextPrimitive( + basegfx::B2DPolyPolygon(aUnitOutline), + getTransform(), + getSdrLFSTAttribute().getText(), + getSdrLFSTAttribute().getLine(), + false, + false)); + } + + // add shadow + if(!getSdrLFSTAttribute().getShadow().isDefault()) + { + aRetval = createEmbeddedShadowPrimitive( + aRetval, + getSdrLFSTAttribute().getShadow()); + } + + rContainer.insert(rContainer.end(), aRetval.begin(), aRetval.end()); + } + + SdrRectanglePrimitive2D::SdrRectanglePrimitive2D( + const basegfx::B2DHomMatrix& rTransform, + const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute, + double fCornerRadiusX, + double fCornerRadiusY, + bool bForceFillForHitTest) + : BufferedDecompositionPrimitive2D(), + maTransform(rTransform), + maSdrLFSTAttribute(rSdrLFSTAttribute), + mfCornerRadiusX(fCornerRadiusX), + mfCornerRadiusY(fCornerRadiusY), + mbForceFillForHitTest(bForceFillForHitTest) + { + } + + bool SdrRectanglePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrRectanglePrimitive2D& rCompare = static_cast<const SdrRectanglePrimitive2D&>(rPrimitive); + + return (getCornerRadiusX() == rCompare.getCornerRadiusX() + && getCornerRadiusY() == rCompare.getCornerRadiusY() + && getTransform() == rCompare.getTransform() + && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute() + && getForceFillForHitTest() == rCompare.getForceFillForHitTest()); + } + + return false; + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrRectanglePrimitive2D, PRIMITIVE2D_ID_SDRRECTANGLEPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive2d/sdrtextprimitive2d.cxx b/svx/source/sdr/primitive2d/sdrtextprimitive2d.cxx new file mode 100644 index 000000000..75744d7ca --- /dev/null +++ b/svx/source/sdr/primitive2d/sdrtextprimitive2d.cxx @@ -0,0 +1,529 @@ +/* -*- 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 <sdr/primitive2d/sdrtextprimitive2d.hxx> +#include <svx/svdotext.hxx> +#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx> +#include <drawinglayer/primitive2d/texthierarchyprimitive2d.hxx> +#include <editeng/outlobj.hxx> +#include <editeng/editobj.hxx> +#include <editeng/flditem.hxx> +#include <drawinglayer/geometry/viewinformation2d.hxx> +#include <svx/unoapi.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdmodel.hxx> +#include <svx/svdoutl.hxx> +#include <com/sun/star/beans/XPropertySet.hpp> + + +using namespace com::sun::star; + + +namespace +{ + sal_Int16 getPageNumber(const uno::Reference< drawing::XDrawPage >& rxDrawPage) + { + sal_Int16 nRetval(0); + uno::Reference< beans::XPropertySet > xSet(rxDrawPage, uno::UNO_QUERY); + + if (xSet.is()) + { + try + { + const uno::Any aNumber(xSet->getPropertyValue("Number")); + aNumber >>= nRetval; + } + catch(const uno::Exception&) + { + OSL_ASSERT(false); + } + } + + return nRetval; + } + + sal_Int16 getPageCount(const uno::Reference< drawing::XDrawPage >& rxDrawPage) + { + sal_Int16 nRetval(0); + SdrPage* pPage = GetSdrPageFromXDrawPage(rxDrawPage); + + if(pPage) + { + if( (pPage->GetPageNum() == 0) && !pPage->IsMasterPage() ) + { + // handout page! + return pPage->getSdrModelFromSdrPage().getHandoutPageCount(); + } + else + { + const sal_uInt16 nPageCount(pPage->getSdrModelFromSdrPage().GetPageCount()); + nRetval = (static_cast<sal_Int16>(nPageCount) - 1) / 2; + } + } + + return nRetval; + } +} // end of anonymous namespace + + +namespace drawinglayer::primitive2d +{ + // support for XTEXT_PAINTSHAPE_BEGIN/XTEXT_PAINTSHAPE_END Metafile comments + // for slideshow. This uses TextHierarchyBlockPrimitive2D to mark a text block. + // ATM there is only one text block per SdrObject, this may get more in the future + void SdrTextPrimitive2D::encapsulateWithTextHierarchyBlockPrimitive2D(Primitive2DContainer& rContainer, const Primitive2DContainer& rCandidate) + { + rContainer.push_back(new TextHierarchyBlockPrimitive2D(rCandidate)); + } + + SdrTextPrimitive2D::SdrTextPrimitive2D( + const SdrText* pSdrText, + const OutlinerParaObject& rOutlinerParaObject) + : BufferedDecompositionPrimitive2D(), + mrSdrText(const_cast< SdrText* >(pSdrText)), + maOutlinerParaObject(rOutlinerParaObject), + mxLastVisualizingPage(), + mnLastPageNumber(0), + mnLastPageCount(0), + maLastTextBackgroundColor(), + mbContainsPageField(false), + mbContainsPageCountField(false), + mbContainsOtherFields(false) + { + const EditTextObject& rETO = maOutlinerParaObject.GetTextObject(); + + mbContainsPageField = rETO.HasField(SvxPageField::CLASS_ID); + mbContainsPageCountField = rETO.HasField(SvxPagesField::CLASS_ID); + mbContainsOtherFields = rETO.HasField(SvxHeaderField::CLASS_ID) + || rETO.HasField(SvxFooterField::CLASS_ID) + || rETO.HasField(SvxDateTimeField::CLASS_ID) + || rETO.HasField(SvxAuthorField::CLASS_ID); + } + + const SdrText* SdrTextPrimitive2D::getSdrText() const { return mrSdrText.get(); } + + bool SdrTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(BufferedDecompositionPrimitive2D::operator==(rPrimitive)) + { + const SdrTextPrimitive2D& rCompare = static_cast<const SdrTextPrimitive2D&>(rPrimitive); + + return ( + + // compare OPO and content, but not WrongList + getOutlinerParaObject() == rCompare.getOutlinerParaObject() + + // also compare WrongList (not-persistent data, but visualized) + && getOutlinerParaObject().isWrongListEqual(rCompare.getOutlinerParaObject())); + } + + return false; + } + + void SdrTextPrimitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const + { + uno::Reference< drawing::XDrawPage > xCurrentlyVisualizingPage; + bool bCurrentlyVisualizingPageIsSet(false); + Color aNewTextBackgroundColor; + bool bNewTextBackgroundColorIsSet(false); + sal_Int16 nCurrentlyValidPageNumber(0); + sal_Int16 nCurrentlyValidPageCount(0); + + if(!getBuffered2DDecomposition().empty()) + { + bool bDoDelete(false); + + // check visualized page + if(mbContainsPageField || mbContainsPageCountField || mbContainsOtherFields) + { + // get visualized page and remember + xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage(); + bCurrentlyVisualizingPageIsSet = true; + + if(xCurrentlyVisualizingPage != mxLastVisualizingPage) + { + bDoDelete = true; + } + + // #i98870# check visualized PageNumber + if(!bDoDelete && mbContainsPageField) + { + nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage); + + if(nCurrentlyValidPageNumber != mnLastPageNumber) + { + bDoDelete = true; + } + } + + // #i98870# check visualized PageCount, too + if(!bDoDelete && mbContainsPageCountField) + { + nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage); + + if(nCurrentlyValidPageCount != mnLastPageCount) + { + bDoDelete = true; + } + } + } + + // #i101443# check change of TextBackgroundolor + if(!bDoDelete && getSdrText()) + { + SdrOutliner& rDrawOutliner = getSdrText()->GetObject().getSdrModelFromSdrObject().GetDrawOutliner(); + aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor(); + bNewTextBackgroundColorIsSet = true; + + if(aNewTextBackgroundColor != maLastTextBackgroundColor) + { + bDoDelete = true; + } + } + + if(bDoDelete) + { + const_cast< SdrTextPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DContainer()); + } + } + + if(getBuffered2DDecomposition().empty()) + { + if(!bCurrentlyVisualizingPageIsSet && mbContainsPageField) + { + xCurrentlyVisualizingPage = rViewInformation.getVisualizedPage(); + } + + if(!nCurrentlyValidPageNumber && mbContainsPageField) + { + nCurrentlyValidPageNumber = getPageNumber(xCurrentlyVisualizingPage); + } + + if(!nCurrentlyValidPageCount && mbContainsPageCountField) + { + nCurrentlyValidPageCount = getPageCount(xCurrentlyVisualizingPage); + } + + if(!bNewTextBackgroundColorIsSet && getSdrText()) + { + SdrOutliner& rDrawOutliner = getSdrText()->GetObject().getSdrModelFromSdrObject().GetDrawOutliner(); + aNewTextBackgroundColor = rDrawOutliner.GetBackgroundColor(); + } + + const_cast< SdrTextPrimitive2D* >(this)->mxLastVisualizingPage = xCurrentlyVisualizingPage; + const_cast< SdrTextPrimitive2D* >(this)->mnLastPageNumber = nCurrentlyValidPageNumber; + const_cast< SdrTextPrimitive2D* >(this)->mnLastPageCount = nCurrentlyValidPageCount; + const_cast< SdrTextPrimitive2D* >(this)->maLastTextBackgroundColor = aNewTextBackgroundColor; + } + + // call parent + BufferedDecompositionPrimitive2D::get2DDecomposition(rVisitor, rViewInformation); + } + + + + + void SdrContourTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const + { + Primitive2DContainer aRetval; + getSdrText()->GetObject().impDecomposeContourTextPrimitive(aRetval, *this, aViewInformation); + + encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, aRetval); + } + + SdrContourTextPrimitive2D::SdrContourTextPrimitive2D( + const SdrText* pSdrText, + const OutlinerParaObject& rOutlinerParaObject, + const basegfx::B2DPolyPolygon& rUnitPolyPolygon, + const basegfx::B2DHomMatrix& rObjectTransform) + : SdrTextPrimitive2D(pSdrText, rOutlinerParaObject), + maUnitPolyPolygon(rUnitPolyPolygon), + maObjectTransform(rObjectTransform) + { + } + + bool SdrContourTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(SdrTextPrimitive2D::operator==(rPrimitive)) + { + const SdrContourTextPrimitive2D& rCompare = static_cast<const SdrContourTextPrimitive2D&>(rPrimitive); + + return (getUnitPolyPolygon() == rCompare.getUnitPolyPolygon() + && getObjectTransform() == rCompare.getObjectTransform()); + } + + return false; + } + + std::unique_ptr<SdrTextPrimitive2D> SdrContourTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const + { + return std::make_unique<SdrContourTextPrimitive2D>( + getSdrText(), + getOutlinerParaObject(), + getUnitPolyPolygon(), + rTransform * getObjectTransform()); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrContourTextPrimitive2D, PRIMITIVE2D_ID_SDRCONTOURTEXTPRIMITIVE2D) + + + + void SdrPathTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const + { + Primitive2DContainer aRetval; + getSdrText()->GetObject().impDecomposePathTextPrimitive(aRetval, *this, aViewInformation); + + encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, aRetval); + } + + SdrPathTextPrimitive2D::SdrPathTextPrimitive2D( + const SdrText* pSdrText, + const OutlinerParaObject& rOutlinerParaObject, + const basegfx::B2DPolyPolygon& rPathPolyPolygon, + const attribute::SdrFormTextAttribute& rSdrFormTextAttribute) + : SdrTextPrimitive2D(pSdrText, rOutlinerParaObject), + maPathPolyPolygon(rPathPolyPolygon), + maSdrFormTextAttribute(rSdrFormTextAttribute) + { + } + + bool SdrPathTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(SdrTextPrimitive2D::operator==(rPrimitive)) + { + const SdrPathTextPrimitive2D& rCompare = static_cast<const SdrPathTextPrimitive2D&>(rPrimitive); + + return (getPathPolyPolygon() == rCompare.getPathPolyPolygon() + && getSdrFormTextAttribute() == rCompare.getSdrFormTextAttribute()); + } + + return false; + } + + std::unique_ptr<SdrTextPrimitive2D> SdrPathTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const + { + basegfx::B2DPolyPolygon aNewPolyPolygon(getPathPolyPolygon()); + aNewPolyPolygon.transform(rTransform); + + return std::make_unique<SdrPathTextPrimitive2D>( + getSdrText(), + getOutlinerParaObject(), + aNewPolyPolygon, + getSdrFormTextAttribute()); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrPathTextPrimitive2D, PRIMITIVE2D_ID_SDRPATHTEXTPRIMITIVE2D) + + + + void SdrBlockTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const + { + Primitive2DContainer aRetval; + getSdrText()->GetObject().impDecomposeBlockTextPrimitive(aRetval, *this, aViewInformation); + + encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, aRetval); + } + + SdrBlockTextPrimitive2D::SdrBlockTextPrimitive2D( + const SdrText* pSdrText, + const OutlinerParaObject& rOutlinerParaObject, + const basegfx::B2DHomMatrix& rTextRangeTransform, + SdrTextHorzAdjust aSdrTextHorzAdjust, + SdrTextVertAdjust aSdrTextVertAdjust, + bool bFixedCellHeight, + bool bUnlimitedPage, + bool bCellText, + bool bWordWrap) + : SdrTextPrimitive2D(pSdrText, rOutlinerParaObject), + maTextRangeTransform(rTextRangeTransform), + maSdrTextHorzAdjust(aSdrTextHorzAdjust), + maSdrTextVertAdjust(aSdrTextVertAdjust), + mbFixedCellHeight(bFixedCellHeight), + mbUnlimitedPage(bUnlimitedPage), + mbCellText(bCellText), + mbWordWrap(bWordWrap) + { + } + + bool SdrBlockTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(SdrTextPrimitive2D::operator==(rPrimitive)) + { + const SdrBlockTextPrimitive2D& rCompare = static_cast<const SdrBlockTextPrimitive2D&>(rPrimitive); + + return (getTextRangeTransform() == rCompare.getTextRangeTransform() + && getSdrTextHorzAdjust() == rCompare.getSdrTextHorzAdjust() + && getSdrTextVertAdjust() == rCompare.getSdrTextVertAdjust() + && isFixedCellHeight() == rCompare.isFixedCellHeight() + && getUnlimitedPage() == rCompare.getUnlimitedPage() + && getCellText() == rCompare.getCellText() + && getWordWrap() == rCompare.getWordWrap()); + } + + return false; + } + + std::unique_ptr<SdrTextPrimitive2D> SdrBlockTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const + { + return std::make_unique<SdrBlockTextPrimitive2D>( + getSdrText(), + getOutlinerParaObject(), + rTransform * getTextRangeTransform(), + getSdrTextHorzAdjust(), + getSdrTextVertAdjust(), + isFixedCellHeight(), + getUnlimitedPage(), + getCellText(), + getWordWrap()); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrBlockTextPrimitive2D, PRIMITIVE2D_ID_SDRBLOCKTEXTPRIMITIVE2D) + + + + void SdrAutoFitTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const + { + Primitive2DContainer aRetval; + getSdrText()->GetObject().impDecomposeAutoFitTextPrimitive(aRetval, *this, aViewInformation); + + encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, aRetval); + } + + SdrAutoFitTextPrimitive2D::SdrAutoFitTextPrimitive2D( + const SdrText* pSdrText, + const OutlinerParaObject& rParaObj, + const ::basegfx::B2DHomMatrix& rTextRangeTransform, + bool bWordWrap) + : SdrTextPrimitive2D(pSdrText, rParaObj), + maTextRangeTransform(rTextRangeTransform), + mbWordWrap(bWordWrap) + { + } + + bool SdrAutoFitTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(SdrTextPrimitive2D::operator==(rPrimitive)) + { + const SdrBlockTextPrimitive2D& rCompare = static_cast<const SdrBlockTextPrimitive2D&>(rPrimitive); + + return (getTextRangeTransform() == rCompare.getTextRangeTransform() + && getWordWrap() == rCompare.getWordWrap()); + } + + return false; + } + + std::unique_ptr<SdrTextPrimitive2D> SdrAutoFitTextPrimitive2D::createTransformedClone(const ::basegfx::B2DHomMatrix& rTransform) const + { + return std::make_unique<SdrAutoFitTextPrimitive2D>(getSdrText(), getOutlinerParaObject(), rTransform * getTextRangeTransform(), getWordWrap()); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrAutoFitTextPrimitive2D, PRIMITIVE2D_ID_SDRAUTOFITTEXTPRIMITIVE2D) + + + + + SdrChainedTextPrimitive2D::SdrChainedTextPrimitive2D( + const SdrText* pSdrText, + const OutlinerParaObject& rOutlinerParaObject, + const basegfx::B2DHomMatrix& rTextRangeTransform) + : SdrTextPrimitive2D(pSdrText, rOutlinerParaObject), + maTextRangeTransform(rTextRangeTransform) + { } + + void SdrChainedTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const + { + Primitive2DContainer aRetval; + getSdrText()->GetObject().impDecomposeChainedTextPrimitive(aRetval, *this, aViewInformation); + + encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, aRetval); + } + + bool SdrChainedTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(SdrTextPrimitive2D::operator==(rPrimitive)) + { + const SdrBlockTextPrimitive2D& rCompare = static_cast<const SdrBlockTextPrimitive2D&>(rPrimitive); + + return (getTextRangeTransform() == rCompare.getTextRangeTransform()); + } + + return false; + } + + std::unique_ptr<SdrTextPrimitive2D> SdrChainedTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const + { + return std::make_unique<SdrChainedTextPrimitive2D>(getSdrText(), getOutlinerParaObject(), rTransform * getTextRangeTransform()); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrChainedTextPrimitive2D, PRIMITIVE2D_ID_SDRCHAINEDTEXTPRIMITIVE2D) + + + void SdrStretchTextPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const + { + Primitive2DContainer aRetval; + getSdrText()->GetObject().impDecomposeStretchTextPrimitive(aRetval, *this, aViewInformation); + + encapsulateWithTextHierarchyBlockPrimitive2D(rContainer, aRetval); + } + + SdrStretchTextPrimitive2D::SdrStretchTextPrimitive2D( + const SdrText* pSdrText, + const OutlinerParaObject& rOutlinerParaObject, + const basegfx::B2DHomMatrix& rTextRangeTransform, + bool bFixedCellHeight) + : SdrTextPrimitive2D(pSdrText, rOutlinerParaObject), + maTextRangeTransform(rTextRangeTransform), + mbFixedCellHeight(bFixedCellHeight) + { + } + + bool SdrStretchTextPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const + { + if(SdrTextPrimitive2D::operator==(rPrimitive)) + { + const SdrStretchTextPrimitive2D& rCompare = static_cast<const SdrStretchTextPrimitive2D&>(rPrimitive); + + return (getTextRangeTransform() == rCompare.getTextRangeTransform() + && isFixedCellHeight() == rCompare.isFixedCellHeight()); + } + + return false; + } + + std::unique_ptr<SdrTextPrimitive2D> SdrStretchTextPrimitive2D::createTransformedClone(const basegfx::B2DHomMatrix& rTransform) const + { + return std::make_unique<SdrStretchTextPrimitive2D>( + getSdrText(), + getOutlinerParaObject(), + rTransform * getTextRangeTransform(), + isFixedCellHeight()); + } + + // provide unique ID + ImplPrimitive2DIDBlock(SdrStretchTextPrimitive2D, PRIMITIVE2D_ID_SDRSTRETCHTEXTPRIMITIVE2D) + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/primitive3d/sdrattributecreator3d.cxx b/svx/source/sdr/primitive3d/sdrattributecreator3d.cxx new file mode 100644 index 000000000..c6721a152 --- /dev/null +++ b/svx/source/sdr/primitive3d/sdrattributecreator3d.cxx @@ -0,0 +1,145 @@ +/* -*- 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 <sdr/primitive3d/sdrattributecreator3d.hxx> +#include <svx/svx3ditems.hxx> +#include <svl/itemset.hxx> +#include <com/sun/star/drawing/NormalsKind.hpp> +#include <com/sun/star/drawing/TextureProjectionMode.hpp> +#include <com/sun/star/drawing/TextureKind2.hpp> +#include <com/sun/star/drawing/TextureMode.hpp> +#include <svx/xflclit.hxx> +#include <drawinglayer/attribute/materialattribute3d.hxx> +#include <drawinglayer/attribute/sdrobjectattribute3d.hxx> + + +namespace drawinglayer::primitive2d +{ + attribute::Sdr3DObjectAttribute* createNewSdr3DObjectAttribute(const SfxItemSet& rSet) + { + // get NormalsKind + css::drawing::NormalsKind aNormalsKind(css::drawing::NormalsKind_SPECIFIC); + const sal_uInt16 nNormalsValue(rSet.Get(SDRATTR_3DOBJ_NORMALS_KIND).GetValue()); + + if(1 == nNormalsValue) + { + aNormalsKind = css::drawing::NormalsKind_FLAT; + } + else if(2 == nNormalsValue) + { + aNormalsKind = css::drawing::NormalsKind_SPHERE; + } + + // get NormalsInvert flag + const bool bInvertNormals(rSet.Get(SDRATTR_3DOBJ_NORMALS_INVERT).GetValue()); + + // get TextureProjectionX + css::drawing::TextureProjectionMode aTextureProjectionX(css::drawing::TextureProjectionMode_OBJECTSPECIFIC); + const sal_uInt16 nTextureValueX(rSet.Get(SDRATTR_3DOBJ_TEXTURE_PROJ_X).GetValue()); + + if(1 == nTextureValueX) + { + aTextureProjectionX = css::drawing::TextureProjectionMode_PARALLEL; + } + else if(2 == nTextureValueX) + { + aTextureProjectionX = css::drawing::TextureProjectionMode_SPHERE; + } + + // get TextureProjectionY + css::drawing::TextureProjectionMode aTextureProjectionY(css::drawing::TextureProjectionMode_OBJECTSPECIFIC); + const sal_uInt16 nTextureValueY(rSet.Get(SDRATTR_3DOBJ_TEXTURE_PROJ_Y).GetValue()); + + if(1 == nTextureValueY) + { + aTextureProjectionY = css::drawing::TextureProjectionMode_PARALLEL; + } + else if(2 == nTextureValueY) + { + aTextureProjectionY = css::drawing::TextureProjectionMode_SPHERE; + } + + // get DoubleSided flag + const bool bDoubleSided(rSet.Get(SDRATTR_3DOBJ_DOUBLE_SIDED).GetValue()); + + // get Shadow3D flag + const bool bShadow3D(rSet.Get(SDRATTR_3DOBJ_SHADOW_3D).GetValue()); + + // get TextureFilter flag + const bool bTextureFilter(rSet.Get(SDRATTR_3DOBJ_TEXTURE_FILTER).GetValue()); + + // get texture kind + // TextureKind: 1 == Base3DTextureLuminance, 2 == Base3DTextureIntensity, 3 == Base3DTextureColor + css::drawing::TextureKind2 aTextureKind(css::drawing::TextureKind2_LUMINANCE); + const sal_uInt16 nTextureKind(rSet.Get(SDRATTR_3DOBJ_TEXTURE_KIND).GetValue()); + + if(2 == nTextureKind) + { + aTextureKind = css::drawing::TextureKind2_INTENSITY; + } + else if(3 == nTextureKind) + { + aTextureKind = css::drawing::TextureKind2_COLOR; + } + + // get texture mode + // TextureMode: 1 == Base3DTextureReplace, 2 == Base3DTextureModulate, 3 == Base3DTextureBlend + css::drawing::TextureMode aTextureMode(css::drawing::TextureMode_REPLACE); + const sal_uInt16 nTextureMode(rSet.Get(SDRATTR_3DOBJ_TEXTURE_MODE).GetValue()); + + if(2 == nTextureMode) + { + aTextureMode = css::drawing::TextureMode_MODULATE; + } + else if(3 == nTextureMode) + { + aTextureMode = css::drawing::TextureMode_BLEND; + } + + // get object color + const ::basegfx::BColor aObjectColor(rSet.Get(XATTR_FILLCOLOR).GetColorValue().getBColor()); + + // get specular color + const ::basegfx::BColor aSpecular(rSet.Get(SDRATTR_3DOBJ_MAT_SPECULAR).GetValue().getBColor()); + + // get emissive color + const ::basegfx::BColor aEmission(rSet.Get(SDRATTR_3DOBJ_MAT_EMISSION).GetValue().getBColor()); + + // get specular intensity + sal_uInt16 nSpecularIntensity(rSet.Get(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY).GetValue()); + + if(nSpecularIntensity > 128) + { + nSpecularIntensity = 128; + } + + // get reduced line geometry + const bool bReducedLineGeometry(rSet.Get(SDRATTR_3DOBJ_REDUCED_LINE_GEOMETRY).GetValue()); + + // prepare material + attribute::MaterialAttribute3D aMaterial(aObjectColor, aSpecular, aEmission, nSpecularIntensity); + + return new attribute::Sdr3DObjectAttribute( + aNormalsKind, aTextureProjectionX, aTextureProjectionY, + aTextureKind, aTextureMode, aMaterial, + bInvertNormals, bDoubleSided, bShadow3D, bTextureFilter, bReducedLineGeometry); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/attributeproperties.cxx b/svx/source/sdr/properties/attributeproperties.cxx new file mode 100644 index 000000000..dbed60b8a --- /dev/null +++ b/svx/source/sdr/properties/attributeproperties.cxx @@ -0,0 +1,526 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/attributeproperties.hxx> +#include <tools/debug.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svl/whiter.hxx> +#include <svl/poolitem.hxx> +#include <svx/svdobj.hxx> +#include <svx/svddef.hxx> +#include <svx/xbtmpit.hxx> +#include <svx/xlndsit.hxx> +#include <svx/xlnstit.hxx> +#include <svx/xlnedit.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xflftrit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/svdmodel.hxx> +#include <svx/svdpage.hxx> + +namespace sdr::properties +{ + void AttributeProperties::ImpSetParentAtSfxItemSet(bool bDontRemoveHardAttr) + { + if(HasSfxItemSet() && mpStyleSheet) + { + // Delete hard attributes where items are set in the style sheet + if(!bDontRemoveHardAttr) + { + const SfxItemSet& rStyle = mpStyleSheet->GetItemSet(); + SfxWhichIter aIter(rStyle); + sal_uInt16 nWhich = aIter.FirstWhich(); + + while(nWhich) + { + if(SfxItemState::SET == rStyle.GetItemState(nWhich)) + { + mpItemSet->ClearItem(nWhich); + } + + nWhich = aIter.NextWhich(); + } + } + + // set new stylesheet as parent + mpItemSet->SetParent(&mpStyleSheet->GetItemSet()); + } + else + { + OSL_ENSURE(false, "ImpSetParentAtSfxItemSet called without SfxItemSet/SfxStyleSheet (!)"); + } + } + + void AttributeProperties::ImpAddStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // test if old StyleSheet is cleared, else it would be lost + // after this method -> memory leak (!) + DBG_ASSERT(!mpStyleSheet, "Old style sheet not deleted before setting new one (!)"); + + if(pNewStyleSheet) + { + // local remember + mpStyleSheet = pNewStyleSheet; + + if(HasSfxItemSet()) + { + // register as listener + StartListening(*pNewStyleSheet->GetPool()); + StartListening(*pNewStyleSheet); + + // only apply the following when we have an SfxItemSet already, else + if(GetStyleSheet()) + { + ImpSetParentAtSfxItemSet(bDontRemoveHardAttr); + } + } + } + } + + void AttributeProperties::ImpRemoveStyleSheet() + { + // Check type since it is destroyed when the type is deleted + if(GetStyleSheet() && dynamic_cast<const SfxStyleSheet *>(mpStyleSheet) != nullptr) + { + EndListening(*mpStyleSheet); + if (auto const pool = mpStyleSheet->GetPool()) { // TTTT + EndListening(*pool); + } + + // reset parent of ItemSet + if(HasSfxItemSet()) + { + mpItemSet->SetParent(nullptr); + } + + SdrObject& rObj = GetSdrObject(); + rObj.SetBoundRectDirty(); + rObj.SetRectsDirty(true); + } + + mpStyleSheet = nullptr; + } + + // create a new itemset + std::unique_ptr<SfxItemSet> AttributeProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>(rPool, + + // ranges from SdrAttrObj + svl::Items<SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION>{}); + } + + AttributeProperties::AttributeProperties(SdrObject& rObj) + : DefaultProperties(rObj), + mpStyleSheet(nullptr) + { + // Do nothing else, esp. do *not* try to get and set + // a default SfxStyle sheet. Nothing is allowed to be done + // that may lead to calls to virtual functions like + // CreateObjectSpecificItemSet - these would go *wrong*. + // Thus the rest is lazy-init from here. + } + + AttributeProperties::AttributeProperties(const AttributeProperties& rProps, SdrObject& rObj) + : DefaultProperties(rProps, rObj), + mpStyleSheet(nullptr) + { + SfxStyleSheet* pTargetStyleSheet(rProps.GetStyleSheet()); + + if(pTargetStyleSheet) + { + const bool bModelChange(&rObj.getSdrModelFromSdrObject() != &rProps.GetSdrObject().getSdrModelFromSdrObject()); + + if(bModelChange) + { + // tdf#117506 + // The error shows that it is definitely necessary to solve this problem. + // Interestingly I already had a note here for 'work needed'. + // Checked in libreoffice-6-0 what happened there. In principle, the whole + // ::Clone of SdrPage and SdrObject happened in the same SdrModel, only + // afterwards a ::SetModel was used at the cloned SdrPage which went through + // all layers. The StyleSheet-problem was solved in + // AttributeProperties::MoveToItemPool at the end. There, a StyleSheet with the + // same name was searched for in the target-SdrModel. + // Start by resetting the current TargetStyleSheet so that nothing goes wrong + // when we do not find a fitting TargetStyleSheet. + // Note: The test for SdrModelChange above was wrong (compared the already set + // new SdrObject), so this never triggered and pTargetStyleSheet was never set to + // nullptr before. This means that a StyleSheet from another SdrModel was used + // what of course is very dangerous. Interestingly did not crash since when that + // other SdrModel was destroyed the ::Notify mechanism still worked reliably + // and de-connected this Properties successfully from the alien-StyleSheet. + pTargetStyleSheet = nullptr; + + // Check if we have a TargetStyleSheetPool at the target-SdrModel. This *should* + // be the case already (SdrModel::Merge and SdDrawDocument::InsertBookmarkAsPage + // have already cloned the StyleSheets to the target-SdrModel when used in Draw/impress). + // If none is found, ImpGetDefaultStyleSheet will be used to set a 'default' + // StyleSheet as StyleSheet implicitly later (that's what happened in the task, + // thus the FillStyle changed to the 'default' Blue). + // Note: It *may* be necessary to do more for StyleSheets, e.g. clone/copy the + // StyleSheet Hierarchy from the source SdrModel and/or add the Items from there + // as hard attributes. If needed, have a look at the older AttributeProperties::SetModel + // implementation from e.g. libreoffice-6-0. + SfxStyleSheetBasePool* pTargetStyleSheetPool(rObj.getSdrModelFromSdrObject().GetStyleSheetPool()); + + if(nullptr != pTargetStyleSheetPool) + { + // If we have a TargetStyleSheetPool, search for the used StyleSheet + // in the target SdrModel using the Name from the original StyleSheet + // in the source-SdrModel. + pTargetStyleSheet = dynamic_cast< SfxStyleSheet* >( + pTargetStyleSheetPool->Find( + rProps.GetStyleSheet()->GetName(), + SfxStyleFamily::All)); + } + } + } + + if(pTargetStyleSheet) + { + if(HasSfxItemSet()) + { + // The SfxItemSet has been cloned and exists, + // we can directly set the SfxStyleSheet at it + ImpAddStyleSheet(pTargetStyleSheet, true); + } + else + { + // No SfxItemSet exists yet (there is none in + // the source, so none was cloned). Remember the + // SfxStyleSheet to set it when the SfxItemSet + // got constructed on-demand + mpStyleSheet = pTargetStyleSheet; + } + } + } + + AttributeProperties::~AttributeProperties() + { + ImpRemoveStyleSheet(); + } + + std::unique_ptr<BaseProperties> AttributeProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new AttributeProperties(*this, rObj)); + } + + const SfxItemSet& AttributeProperties::GetObjectItemSet() const + { + // remember if we had a SfxItemSet already + const bool bHadSfxItemSet(HasSfxItemSet()); + + // call parent - this will guarantee SfxItemSet existence + DefaultProperties::GetObjectItemSet(); + + if(!bHadSfxItemSet) + { + // need to take care for SfxStyleSheet for newly + // created SfxItemSet + if(nullptr == mpStyleSheet) + { + // Set missing defaults without removal of hard attributes. + // This is more complicated historically than I first thought: + // Originally for GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj + // SetStyleSheet(..., false) was used, while for GetDefaultStyleSheet + // SetStyleSheet(..., true) was used. Thus, for SdrGrafObj and SdrOle2Obj + // bDontRemoveHardAttr == false -> *do* delete hard attributes was used. + // This was probably not done by purpose, adding the method + // GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj additionally to + // GetDefaultStyleSheet was an enhancement to allow for SdrGrafObj/SdrOle2Obj + // with full AttributeSet (adding e.g. FillAttributes). To stay as compatible + // as possible these SdrObjects got a new default-StyleSheet. + // There is no reason to delete the HardAttributes and it anyways has only + // AFAIK effects on a single Item - the SdrTextHorzAdjustItem. To get things + // unified I will stay with not deleting the HardAttributes and adapt the + // UnitTests in CppunitTest_sd_import_tests accordingly. + const_cast< AttributeProperties* >(this)->applyDefaultStyleSheetFromSdrModel(); + } + else + { + // Late-Init of setting parent to SfxStyleSheet after + // it's creation. Can only happen from copy-constructor + // (where creation of SfxItemSet is avoided due to the + // problem with constructors and virtual functions in C++), + // thus DontRemoveHardAttr is not needed. + const_cast< AttributeProperties* >(this)->SetStyleSheet( + mpStyleSheet, + true); + } + } + + return *mpItemSet; + } + + void AttributeProperties::ItemSetChanged(const SfxItemSet& /*rSet*/) + { + // own modifications + SdrObject& rObj = GetSdrObject(); + + rObj.SetBoundRectDirty(); + rObj.SetRectsDirty(true); + rObj.SetChanged(); + } + + void AttributeProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem) + { + if(pNewItem) + { + std::unique_ptr<SfxPoolItem> pResultItem; + SdrModel& rModel(GetSdrObject().getSdrModelFromSdrObject()); + + switch( nWhich ) + { + case XATTR_FILLBITMAP: + { + // TTTT checkForUniqueItem should use SdrModel& + pResultItem = static_cast<const XFillBitmapItem*>(pNewItem)->checkForUniqueItem( &rModel ); + break; + } + case XATTR_LINEDASH: + { + pResultItem = static_cast<const XLineDashItem*>(pNewItem)->checkForUniqueItem( &rModel ); + break; + } + case XATTR_LINESTART: + { + pResultItem = static_cast<const XLineStartItem*>(pNewItem)->checkForUniqueItem( &rModel ); + break; + } + case XATTR_LINEEND: + { + pResultItem = static_cast<const XLineEndItem*>(pNewItem)->checkForUniqueItem( &rModel ); + break; + } + case XATTR_FILLGRADIENT: + { + pResultItem = static_cast<const XFillGradientItem*>(pNewItem)->checkForUniqueItem( &rModel ); + break; + } + case XATTR_FILLFLOATTRANSPARENCE: + { + // #85953# allow all kinds of XFillFloatTransparenceItem to be set + pResultItem = static_cast<const XFillFloatTransparenceItem*>(pNewItem)->checkForUniqueItem( &rModel ); + break; + } + case XATTR_FILLHATCH: + { + pResultItem = static_cast<const XFillHatchItem*>(pNewItem)->checkForUniqueItem( &rModel ); + break; + } + } + + // guarantee SfxItemSet existence + GetObjectItemSet(); + + if(pResultItem) + { + // force ItemSet + mpItemSet->Put(*pResultItem); + + // delete item if it was a generated one + pResultItem.reset(); + } + else + { + mpItemSet->Put(*pNewItem); + } + } + else + { + // clear item if ItemSet exists + if(HasSfxItemSet()) + { + mpItemSet->ClearItem(nWhich); + } + } + } + + void AttributeProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // guarantee SfxItemSet existence + GetObjectItemSet(); + + ImpRemoveStyleSheet(); + ImpAddStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + SdrObject& rObj = GetSdrObject(); + rObj.SetBoundRectDirty(); + rObj.SetRectsDirty(true); + } + + SfxStyleSheet* AttributeProperties::GetStyleSheet() const + { + return mpStyleSheet; + } + + void AttributeProperties::ForceStyleToHardAttributes() + { + if(!GetStyleSheet() || dynamic_cast<const SfxStyleSheet *>(mpStyleSheet) == nullptr) + return; + + // guarantee SfxItemSet existence + GetObjectItemSet(); + + // prepare copied, new itemset, but WITHOUT parent + SfxItemSet* pDestItemSet = new SfxItemSet(*mpItemSet); + pDestItemSet->SetParent(nullptr); + + // prepare forgetting the current stylesheet like in RemoveStyleSheet() + EndListening(*mpStyleSheet); + EndListening(*mpStyleSheet->GetPool()); + + // prepare the iter; use the mpObjectItemSet which may have less + // WhichIDs than the style. + SfxWhichIter aIter(*pDestItemSet); + sal_uInt16 nWhich(aIter.FirstWhich()); + const SfxPoolItem *pItem = nullptr; + + // now set all hard attributes of the current at the new itemset + while(nWhich) + { + // #i61284# use mpItemSet with parents, makes things easier and reduces to + // one loop + if(SfxItemState::SET == mpItemSet->GetItemState(nWhich, true, &pItem)) + { + pDestItemSet->Put(*pItem); + } + + nWhich = aIter.NextWhich(); + } + + // replace itemsets + mpItemSet.reset(pDestItemSet); + + // set necessary changes like in RemoveStyleSheet() + GetSdrObject().SetBoundRectDirty(); + GetSdrObject().SetRectsDirty(true); + + mpStyleSheet = nullptr; + } + + void AttributeProperties::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) + { + bool bHintUsed(false); + + const SfxStyleSheetHint* pStyleHint = dynamic_cast<const SfxStyleSheetHint*>(&rHint); + + if(pStyleHint && pStyleHint->GetStyleSheet() == GetStyleSheet()) + { + SdrObject& rObj = GetSdrObject(); + //SdrPage* pPage = rObj.GetPage(); + + switch(pStyleHint->GetId()) + { + case SfxHintId::StyleSheetCreated : + { + // cannot happen, nothing to do + break; + } + case SfxHintId::StyleSheetModified : + case SfxHintId::StyleSheetChanged : + { + // notify change + break; + } + case SfxHintId::StyleSheetErased : + case SfxHintId::StyleSheetInDestruction : + { + // Style needs to be exchanged + SfxStyleSheet* pNewStSh = nullptr; + SdrModel& rModel(rObj.getSdrModelFromSdrObject()); + + // Do nothing if object is in destruction, else a StyleSheet may be found from + // a StyleSheetPool which is just being deleted itself. and thus it would be fatal + // to register as listener to that new StyleSheet. + if(!rObj.IsInDestruction()) + { + if(dynamic_cast<const SfxStyleSheet *>(GetStyleSheet()) != nullptr) + { + pNewStSh = static_cast<SfxStyleSheet*>(rModel.GetStyleSheetPool()->Find( + GetStyleSheet()->GetParent(), GetStyleSheet()->GetFamily())); + } + + if(!pNewStSh) + { + pNewStSh = rModel.GetDefaultStyleSheet(); + } + } + + // remove used style, it's erased or in destruction + ImpRemoveStyleSheet(); + + if(pNewStSh) + { + ImpAddStyleSheet(pNewStSh, true); + } + + break; + } + default: break; + } + + // Get old BoundRect. Do this after the style change is handled + // in the ItemSet parts because GetBoundRect() may calculate a new + tools::Rectangle aBoundRect = rObj.GetLastBoundRect(); + + rObj.SetRectsDirty(true); + + // tell the object about the change + rObj.SetChanged(); + rObj.BroadcastObjectChange(); + + //if(pPage && pPage->IsInserted()) + //{ + // rObj.BroadcastObjectChange(); + //} + + rObj.SendUserCall(SdrUserCallType::ChangeAttr, aBoundRect); + + bHintUsed = true; + } + + if(!bHintUsed) + { + // forward to SdrObject ATM. Not sure if this will be necessary + // in the future. + GetSdrObject().Notify(rBC, rHint); + } + } + + bool AttributeProperties::isUsedByModel() const + { + const SdrObject& rObj(GetSdrObject()); + if (rObj.IsInserted()) + { + const SdrPage* const pPage(rObj.getSdrPageFromSdrObject()); + if (pPage && pPage->IsInserted()) + return true; + } + return false; + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/captionproperties.cxx b/svx/source/sdr/properties/captionproperties.cxx new file mode 100644 index 000000000..0afd70af5 --- /dev/null +++ b/svx/source/sdr/properties/captionproperties.cxx @@ -0,0 +1,99 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/captionproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svx/svddef.hxx> +#include <editeng/eeitem.hxx> +#include <svx/svdocapt.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> CaptionProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>( + rPool, + svl::Items< + // Ranges from SdrAttrObj, SdrCaptionObj: + SDRATTR_START, SDRATTR_MISC_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + // Range from SdrTextObj: + EE_ITEMS_START, EE_ITEMS_END>{}); + } + + CaptionProperties::CaptionProperties(SdrObject& rObj) + : RectangleProperties(rObj) + { + } + + CaptionProperties::CaptionProperties(const CaptionProperties& rProps, SdrObject& rObj) + : RectangleProperties(rProps, rObj) + { + } + + CaptionProperties::~CaptionProperties() + { + } + + std::unique_ptr<BaseProperties> CaptionProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new CaptionProperties(*this, rObj)); + } + + void CaptionProperties::ItemSetChanged(const SfxItemSet& rSet) + { + SdrCaptionObj& rObj = static_cast<SdrCaptionObj&>(GetSdrObject()); + + // local changes + rObj.ImpRecalcTail(); + + // call parent + RectangleProperties::ItemSetChanged(rSet); + } + + void CaptionProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + RectangleProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + // local changes + SdrCaptionObj& rObj = static_cast<SdrCaptionObj&>(GetSdrObject()); + rObj.ImpRecalcTail(); + } + + void CaptionProperties::ForceDefaultAttributes() + { + // call parent + RectangleProperties::ForceDefaultAttributes(); + + // force ItemSet + GetObjectItemSet(); + + // this was set by TextProperties::ForceDefaultAttributes(), + // reset to default + mpItemSet->ClearItem(XATTR_LINESTYLE); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/circleproperties.cxx b/svx/source/sdr/properties/circleproperties.cxx new file mode 100644 index 000000000..895029ca7 --- /dev/null +++ b/svx/source/sdr/properties/circleproperties.cxx @@ -0,0 +1,123 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/circleproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svx/svddef.hxx> +#include <editeng/eeitem.hxx> +#include <svx/svdocirc.hxx> +#include <sxcikitm.hxx> +#include <svx/sxciaitm.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> CircleProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>( + rPool, + svl::Items< + // Ranges from SdrAttrObj, SdrCircObj + SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, + SDRATTR_CIRC_FIRST, SDRATTR_CIRC_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + // Range from SdrTextObj: + EE_ITEMS_START, EE_ITEMS_END>{}); + } + + CircleProperties::CircleProperties(SdrObject& rObj) + : RectangleProperties(rObj) + { + } + + CircleProperties::CircleProperties(const CircleProperties& rProps, SdrObject& rObj) + : RectangleProperties(rProps, rObj) + { + } + + CircleProperties::~CircleProperties() + { + } + + std::unique_ptr<BaseProperties> CircleProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new CircleProperties(*this, rObj)); + } + + void CircleProperties::ItemSetChanged(const SfxItemSet& rSet) + { + SdrCircObj& rObj = static_cast<SdrCircObj&>(GetSdrObject()); + + // call parent + RectangleProperties::ItemSetChanged(rSet); + + // local changes + rObj.ImpSetAttrToCircInfo(); + } + + void CircleProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + RectangleProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + // local changes + SdrCircObj& rObj = static_cast<SdrCircObj&>(GetSdrObject()); + rObj.SetXPolyDirty(); + + // local changes + rObj.ImpSetAttrToCircInfo(); + } + + void CircleProperties::ForceDefaultAttributes() + { + SdrCircObj& rObj = static_cast<SdrCircObj&>(GetSdrObject()); + SdrCircKind eKind = rObj.GetCircleKind(); + + if(eKind != SdrCircKind::Full) + { + // force ItemSet + GetObjectItemSet(); + + mpItemSet->Put(SdrCircKindItem(eKind)); + + if(rObj.GetStartAngle()) + { + mpItemSet->Put(makeSdrCircStartAngleItem(rObj.GetStartAngle())); + } + + if(rObj.GetEndAngle() != 36000) + { + mpItemSet->Put(makeSdrCircEndAngleItem(rObj.GetEndAngle())); + } + } + + // call parent after SetObjectItem(SdrCircKindItem()) + // because ForceDefaultAttr() will call + // ImpSetAttrToCircInfo() which needs a correct + // SdrCircKindItem + RectangleProperties::ForceDefaultAttributes(); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/connectorproperties.cxx b/svx/source/sdr/properties/connectorproperties.cxx new file mode 100644 index 000000000..29a2b7ede --- /dev/null +++ b/svx/source/sdr/properties/connectorproperties.cxx @@ -0,0 +1,87 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/connectorproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svx/svddef.hxx> +#include <editeng/eeitem.hxx> +#include <svx/svdoedge.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> ConnectorProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>( + rPool, + svl::Items< + // Ranges from SdrAttrObj, SdrEdgeObj: + SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_EDGE_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + // Range from SdrTextObj: + EE_ITEMS_START, EE_ITEMS_END>{}); + } + + ConnectorProperties::ConnectorProperties(SdrObject& rObj) + : TextProperties(rObj) + { + } + + ConnectorProperties::ConnectorProperties(const ConnectorProperties& rProps, SdrObject& rObj) + : TextProperties(rProps, rObj) + { + } + + ConnectorProperties::~ConnectorProperties() + { + } + + std::unique_ptr<BaseProperties> ConnectorProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new ConnectorProperties(*this, rObj)); + } + + void ConnectorProperties::ItemSetChanged(const SfxItemSet& rSet) + { + SdrEdgeObj& rObj = static_cast<SdrEdgeObj&>(GetSdrObject()); + + // call parent + TextProperties::ItemSetChanged(rSet); + + // local changes + rObj.ImpSetAttrToEdgeInfo(); + } + + void ConnectorProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + TextProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + // local changes + SdrEdgeObj& rObj = static_cast<SdrEdgeObj&>(GetSdrObject()); + rObj.ImpSetAttrToEdgeInfo(); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/customshapeproperties.cxx b/svx/source/sdr/properties/customshapeproperties.cxx new file mode 100644 index 000000000..0d1443081 --- /dev/null +++ b/svx/source/sdr/properties/customshapeproperties.cxx @@ -0,0 +1,231 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/customshapeproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svx/svdoashp.hxx> +#include <svx/sdooitm.hxx> +#include <editeng/eeitem.hxx> +#include <svl/whiter.hxx> +#include <svl/hint.hxx> + +#include <sal/log.hxx> + + +namespace sdr::properties +{ + void CustomShapeProperties::UpdateTextFrameStatus(bool bInvalidateRenderGeometry) + { + SdrObjCustomShape& rObj = static_cast< SdrObjCustomShape& >(GetSdrObject()); + const bool bOld(rObj.bTextFrame); + + // change TextFrame flag when bResizeShapeToFitText changes (which is mapped + // on the item SDRATTR_TEXT_AUTOGROWHEIGHT for custom shapes, argh) + rObj.bTextFrame = GetObjectItemSet().Get(SDRATTR_TEXT_AUTOGROWHEIGHT).GetValue(); + + // check if it did change + if(rObj.bTextFrame != bOld) + { + // on change also invalidate render geometry + bInvalidateRenderGeometry = true; + + // #115391# Potential recursion, since it calls SetObjectItemSet again, but rObj.bTextFrame + // will not change again. Thus it will be only one level and terminate safely + rObj.AdaptTextMinSize(); + } + + if(bInvalidateRenderGeometry) + { + // if asked for or bResizeShapeToFitText changed, make sure that + // the render geometry is reconstructed using changed parameters + rObj.InvalidateRenderGeometry(); + } + } + + std::unique_ptr<SfxItemSet> CustomShapeProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>( + rPool, + svl::Items< + // Ranges from SdrAttrObj: + SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + // Graphic attributes, 3D properties, CustomShape + // properties: + SDRATTR_GRAF_FIRST, SDRATTR_CUSTOMSHAPE_LAST, + SDRATTR_GLOW_FIRST, SDRATTR_SOFTEDGE_LAST, + // Range from SdrTextObj: + EE_ITEMS_START, EE_ITEMS_END>{}); + } + + bool CustomShapeProperties::AllowItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem ) const + { + bool bAllowItemChange = true; + if ( !pNewItem ) + { + if ( ( nWhich >= SDRATTR_CUSTOMSHAPE_FIRST ) && ( nWhich <= SDRATTR_CUSTOMSHAPE_LAST ) ) + bAllowItemChange = false; + } + if ( bAllowItemChange ) + bAllowItemChange = TextProperties::AllowItemChange( nWhich, pNewItem ); + return bAllowItemChange; + } + + void CustomShapeProperties::ClearObjectItem(const sal_uInt16 nWhich) + { + if ( !nWhich ) + { + SfxWhichIter aIter( *mpItemSet ); + sal_uInt16 nWhich2 = aIter.FirstWhich(); + while( nWhich2 ) + { + TextProperties::ClearObjectItemDirect( nWhich2 ); + nWhich2 = aIter.NextWhich(); + } + SfxItemSet aSet(GetSdrObject().GetObjectItemPool()); + ItemSetChanged(aSet); + } + else + TextProperties::ClearObjectItem( nWhich ); + } + + void CustomShapeProperties::ClearObjectItemDirect(const sal_uInt16 nWhich) + { + if ( !nWhich ) + { + SfxWhichIter aIter( *mpItemSet ); + sal_uInt16 nWhich2 = aIter.FirstWhich(); + while( nWhich2 ) + { + TextProperties::ClearObjectItemDirect( nWhich2 ); + nWhich2 = aIter.NextWhich(); + } + } + else + TextProperties::ClearObjectItemDirect( nWhich ); + } + + void CustomShapeProperties::ItemSetChanged(const SfxItemSet& rSet) + { + // call parent + TextProperties::ItemSetChanged(rSet); + + // update bTextFrame and RenderGeometry + UpdateTextFrameStatus(true); + } + + void CustomShapeProperties::PostItemChange(const sal_uInt16 nWhich) + { + switch(nWhich) + { + case SDRATTR_TEXT_AUTOGROWHEIGHT: + { + // #115391# update bTextFrame and RenderGeometry using AdaptTextMinSize() + UpdateTextFrameStatus(false); + break; + } + default: + { + break; + } + } + + // call parent + TextProperties::PostItemChange(nWhich); + } + + void CustomShapeProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem) + { + // call parent + TextProperties::ItemChange( nWhich, pNewItem ); + + // update bTextFrame and RenderGeometry + UpdateTextFrameStatus(true); + } + + void CustomShapeProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + TextProperties::SetStyleSheet( pNewStyleSheet, bDontRemoveHardAttr ); + + // update bTextFrame and RenderGeometry + UpdateTextFrameStatus(true); + } + + void CustomShapeProperties::ForceDefaultAttributes() + { + // update bTextFrame and RenderGeometry + UpdateTextFrameStatus(true); + + // SJ: Following is no good if creating customshapes, leading to objects that are white after loading via xml + // This means: Do *not* call parent here is by purpose... + } + + CustomShapeProperties::CustomShapeProperties(SdrObject& rObj) + : TextProperties(rObj) + { + } + + CustomShapeProperties::CustomShapeProperties(const CustomShapeProperties& rProps, SdrObject& rObj) + : TextProperties(rProps, rObj) + { + } + + CustomShapeProperties::~CustomShapeProperties() + { + } + + std::unique_ptr<BaseProperties> CustomShapeProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new CustomShapeProperties(*this, rObj)); + } + + void CustomShapeProperties::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) + { + TextProperties::Notify( rBC, rHint ); + + bool bRemoveRenderGeometry = false; + const SfxStyleSheetHint* pStyleHint = dynamic_cast<const SfxStyleSheetHint*>(&rHint); + + if ( pStyleHint && pStyleHint->GetStyleSheet() == GetStyleSheet() ) + { + switch( pStyleHint->GetId() ) + { + case SfxHintId::StyleSheetModified : + case SfxHintId::StyleSheetChanged : + bRemoveRenderGeometry = true; + break; + default: break; + } + } + else if ( rHint.GetId() == SfxHintId::DataChanged ) + { + bRemoveRenderGeometry = true; + } + + // update bTextFrame and RenderGeometry + UpdateTextFrameStatus(bRemoveRenderGeometry); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/defaultproperties.cxx b/svx/source/sdr/properties/defaultproperties.cxx new file mode 100644 index 000000000..587e9a652 --- /dev/null +++ b/svx/source/sdr/properties/defaultproperties.cxx @@ -0,0 +1,254 @@ +/* -*- 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 <sal/config.h> + +#include <svx/sdr/properties/defaultproperties.hxx> +#include <sdr/properties/itemsettools.hxx> +#include <svl/itemset.hxx> +#include <svl/whiter.hxx> +#include <vector> +#include <svx/svdobj.hxx> +#include <svx/svddef.hxx> +#include <editeng/eeitem.hxx> +#include <libxml/xmlwriter.h> +#include <svx/svdmodel.hxx> +#include <svx/svdtrans.hxx> +#include <svx/xbtmpit.hxx> + +namespace sdr::properties +{ + std::unique_ptr<SfxItemSet> DefaultProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + // Basic implementation; Basic object has NO attributes + return std::make_unique<SfxItemSet>(rPool); + } + + DefaultProperties::DefaultProperties(SdrObject& rObj) + : BaseProperties(rObj) + { + } + + DefaultProperties::DefaultProperties(const DefaultProperties& rProps, SdrObject& rObj) + : BaseProperties(rObj) + { + if(rProps.mpItemSet) + { + // Clone may be to another model and thus another ItemPool. + // SfxItemSet supports that thus we are able to Clone all + // SfxItemState::SET items to the target pool. + mpItemSet = rProps.mpItemSet->Clone( + true, + &rObj.getSdrModelFromSdrObject().GetItemPool()); + + // React on ModelChange: If metric has changed, scale items. + // As seen above, clone is supported, but scale is not included, + // thus: TTTT maybe add scale to SfxItemSet::Clone() (?) + // tdf#117707 correct ModelChange detection + const bool bModelChange(&rObj.getSdrModelFromSdrObject() != &rProps.GetSdrObject().getSdrModelFromSdrObject()); + + if(bModelChange) + { + const MapUnit aOldUnit(rProps.GetSdrObject().getSdrModelFromSdrObject().GetScaleUnit()); + const MapUnit aNewUnit(rObj.getSdrModelFromSdrObject().GetScaleUnit()); + const bool bScaleUnitChanged(aNewUnit != aOldUnit); + + if(bScaleUnitChanged) + { + const Fraction aMetricFactor(GetMapFactor(aOldUnit, aNewUnit).X()); + + ScaleItemSet(*mpItemSet, aMetricFactor); + } + } + + // do not keep parent info, this may be changed by later constructors. + // This class just copies the ItemSet, ignore parent. + if(mpItemSet && mpItemSet->GetParent()) + { + mpItemSet->SetParent(nullptr); + } + } + } + + std::unique_ptr<BaseProperties> DefaultProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new DefaultProperties(*this, rObj)); + } + + DefaultProperties::~DefaultProperties() {} + + const SfxItemSet& DefaultProperties::GetObjectItemSet() const + { + if(!mpItemSet) + { + const_cast<DefaultProperties*>(this)->mpItemSet = const_cast<DefaultProperties*>(this)->CreateObjectSpecificItemSet(GetSdrObject().GetObjectItemPool()); + const_cast<DefaultProperties*>(this)->ForceDefaultAttributes(); + } + + assert(mpItemSet && "Could not create an SfxItemSet(!)"); + + return *mpItemSet; + } + + void DefaultProperties::SetObjectItem(const SfxPoolItem& rItem) + { + const sal_uInt16 nWhichID(rItem.Which()); + + if(AllowItemChange(nWhichID, &rItem)) + { + ItemChange(nWhichID, &rItem); + PostItemChange(nWhichID); + + SfxItemSet aSet(GetSdrObject().GetObjectItemPool(), {{nWhichID, nWhichID}}); + aSet.Put(rItem); + ItemSetChanged(aSet); + } + } + + void DefaultProperties::SetObjectItemDirect(const SfxPoolItem& rItem) + { + const sal_uInt16 nWhichID(rItem.Which()); + + if(AllowItemChange(nWhichID, &rItem)) + { + ItemChange(nWhichID, &rItem); + } + } + + void DefaultProperties::ClearObjectItem(const sal_uInt16 nWhich) + { + if(AllowItemChange(nWhich)) + { + ItemChange(nWhich); + PostItemChange(nWhich); + + if(nWhich) + { + SfxItemSet aSet(GetSdrObject().GetObjectItemPool(), {{nWhich, nWhich}}); + ItemSetChanged(aSet); + } + } + } + + void DefaultProperties::ClearObjectItemDirect(const sal_uInt16 nWhich) + { + if(AllowItemChange(nWhich)) + { + ItemChange(nWhich); + } + } + + void DefaultProperties::SetObjectItemSet(const SfxItemSet& rSet) + { + if (rSet.HasItem(XATTR_FILLBITMAP)) + { + const XFillBitmapItem* pItem = rSet.GetItem(XATTR_FILLBITMAP); + const std::shared_ptr<VectorGraphicData>& pVectorData + = pItem->GetGraphicObject().GetGraphic().getVectorGraphicData(); + if (pVectorData) + { + // Shape is filled by a vector graphic: tell it our size as a hint. + basegfx::B2DTuple aSizeHint; + aSizeHint.setX(GetSdrObject().GetSnapRect().getWidth()); + aSizeHint.setY(GetSdrObject().GetSnapRect().getHeight()); + pVectorData->setSizeHint(aSizeHint); + } + } + + SfxWhichIter aWhichIter(rSet); + sal_uInt16 nWhich(aWhichIter.FirstWhich()); + const SfxPoolItem *pPoolItem; + std::vector< sal_uInt16 > aPostItemChangeList; + bool bDidChange(false); + SfxItemSet aSet(GetSdrObject().GetObjectItemPool(), svl::Items<SDRATTR_START, EE_ITEMS_END>{}); + + // give a hint to STL_Vector + aPostItemChangeList.reserve(rSet.Count()); + + while(nWhich) + { + if(SfxItemState::SET == rSet.GetItemState(nWhich, false, &pPoolItem)) + { + if(AllowItemChange(nWhich, pPoolItem)) + { + bDidChange = true; + ItemChange(nWhich, pPoolItem); + aPostItemChangeList.push_back( nWhich ); + aSet.Put(*pPoolItem); + } + } + + nWhich = aWhichIter.NextWhich(); + } + + if(bDidChange) + { + for (const auto& rItem : aPostItemChangeList) + { + PostItemChange(rItem); + } + + ItemSetChanged(aSet); + } + } + + void DefaultProperties::ItemSetChanged(const SfxItemSet& /*rSet*/) + { + } + + bool DefaultProperties::AllowItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) const + { + return true; + } + + void DefaultProperties::ItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) + { + } + + void DefaultProperties::PostItemChange(const sal_uInt16 nWhich ) + { + if( (nWhich == XATTR_FILLSTYLE) && (mpItemSet != nullptr) ) + CleanupFillProperties(*mpItemSet); + } + + void DefaultProperties::SetStyleSheet(SfxStyleSheet* /*pNewStyleSheet*/, bool /*bDontRemoveHardAttr*/) + { + // no StyleSheet in DefaultProperties + } + + SfxStyleSheet* DefaultProperties::GetStyleSheet() const + { + // no StyleSheet in DefaultProperties + return nullptr; + } + + void DefaultProperties::ForceDefaultAttributes() + { + } + + void DefaultProperties::dumpAsXml(xmlTextWriterPtr pWriter) const + { + xmlTextWriterStartElement(pWriter, BAD_CAST("DefaultProperties")); + BaseProperties::dumpAsXml(pWriter); + mpItemSet->dumpAsXml(pWriter); + xmlTextWriterEndElement(pWriter); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/e3dcompoundproperties.cxx b/svx/source/sdr/properties/e3dcompoundproperties.cxx new file mode 100644 index 000000000..8d023d033 --- /dev/null +++ b/svx/source/sdr/properties/e3dcompoundproperties.cxx @@ -0,0 +1,144 @@ +/* -*- 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 <sdr/properties/e3dcompoundproperties.hxx> +#include <svl/itemset.hxx> +#include <svx/obj3d.hxx> +#include <svx/scene3d.hxx> + + +namespace sdr::properties +{ + E3dCompoundProperties::E3dCompoundProperties(SdrObject& rObj) + : E3dProperties(rObj) + { + } + + E3dCompoundProperties::E3dCompoundProperties(const E3dCompoundProperties& rProps, SdrObject& rObj) + : E3dProperties(rProps, rObj) + { + } + + E3dCompoundProperties::~E3dCompoundProperties() + { + } + + std::unique_ptr<BaseProperties> E3dCompoundProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new E3dCompoundProperties(*this, rObj)); + } + + const SfxItemSet& E3dCompoundProperties::GetMergedItemSet() const + { + // include Items of scene this object belongs to + const E3dCompoundObject& rObj = static_cast<const E3dCompoundObject&>(GetSdrObject()); + E3dScene* pScene(rObj.getRootE3dSceneFromE3dObject()); + + if(nullptr != pScene) + { + // force ItemSet + GetObjectItemSet(); + + // add filtered scene properties (SDRATTR_3DSCENE_) to local itemset + SfxItemSet aSet(*mpItemSet->GetPool(), svl::Items<SDRATTR_3DSCENE_FIRST, SDRATTR_3DSCENE_LAST>{}); + aSet.Put(pScene->GetProperties().GetObjectItemSet()); + mpItemSet->Put(aSet); + } + + // call parent + return E3dProperties::GetMergedItemSet(); + } + + void E3dCompoundProperties::SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems) + { + // Set scene specific items at scene + E3dCompoundObject& rObj = static_cast<E3dCompoundObject&>(GetSdrObject()); + E3dScene* pScene(rObj.getRootE3dSceneFromE3dObject()); + + if(nullptr != pScene) + { + // force ItemSet + GetObjectItemSet(); + + // Generate filtered scene properties (SDRATTR_3DSCENE_) itemset + SfxItemSet aSet(*mpItemSet->GetPool(), svl::Items<SDRATTR_3DSCENE_FIRST, SDRATTR_3DSCENE_LAST>{}); + aSet.Put(rSet); + + if(bClearAllItems) + { + pScene->GetProperties().ClearObjectItem(); + } + + if(aSet.Count()) + { + pScene->GetProperties().SetObjectItemSet(aSet); + } + } + + // call parent. This will set items on local object, too. + E3dProperties::SetMergedItemSet(rSet, bClearAllItems); + } + + void E3dCompoundProperties::PostItemChange(const sal_uInt16 nWhich) + { + // call parent + E3dProperties::PostItemChange(nWhich); + + // handle value change + E3dCompoundObject& rObj = static_cast<E3dCompoundObject&>(GetSdrObject()); + + switch(nWhich) + { + // #i28528# + // Added extra Item (Bool) for chart2 to be able to show reduced line geometry + case SDRATTR_3DOBJ_REDUCED_LINE_GEOMETRY: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_DOUBLE_SIDED: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_NORMALS_KIND: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_NORMALS_INVERT: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_TEXTURE_PROJ_X: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_TEXTURE_PROJ_Y: + { + rObj.ActionChanged(); + break; + } + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/e3dextrudeproperties.cxx b/svx/source/sdr/properties/e3dextrudeproperties.cxx new file mode 100644 index 000000000..9b9ffd8be --- /dev/null +++ b/svx/source/sdr/properties/e3dextrudeproperties.cxx @@ -0,0 +1,74 @@ +/* -*- 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 <sdr/properties/e3dextrudeproperties.hxx> +#include <extrud3d.hxx> + + +namespace sdr::properties +{ + E3dExtrudeProperties::E3dExtrudeProperties(SdrObject& rObj) + : E3dCompoundProperties(rObj) + { + } + + E3dExtrudeProperties::E3dExtrudeProperties(const E3dExtrudeProperties& rProps, SdrObject& rObj) + : E3dCompoundProperties(rProps, rObj) + { + } + + E3dExtrudeProperties::~E3dExtrudeProperties() + { + } + + std::unique_ptr<BaseProperties> E3dExtrudeProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new E3dExtrudeProperties(*this, rObj)); + } + + void E3dExtrudeProperties::PostItemChange(const sal_uInt16 nWhich) + { + // call parent + E3dCompoundProperties::PostItemChange(nWhich); + + // handle value change + E3dExtrudeObj& rObj = static_cast<E3dExtrudeObj&>(GetSdrObject()); + + switch(nWhich) + { + case SDRATTR_3DOBJ_PERCENT_DIAGONAL: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_BACKSCALE: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_DEPTH: + { + rObj.ActionChanged(); + break; + } + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/e3dlatheproperties.cxx b/svx/source/sdr/properties/e3dlatheproperties.cxx new file mode 100644 index 000000000..feb546534 --- /dev/null +++ b/svx/source/sdr/properties/e3dlatheproperties.cxx @@ -0,0 +1,84 @@ +/* -*- 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 <sdr/properties/e3dlatheproperties.hxx> +#include <svx/lathe3d.hxx> + + +namespace sdr::properties +{ + E3dLatheProperties::E3dLatheProperties(SdrObject& rObj) + : E3dCompoundProperties(rObj) + { + } + + E3dLatheProperties::E3dLatheProperties(const E3dLatheProperties& rProps, SdrObject& rObj) + : E3dCompoundProperties(rProps, rObj) + { + } + + E3dLatheProperties::~E3dLatheProperties() + { + } + + std::unique_ptr<BaseProperties> E3dLatheProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new E3dLatheProperties(*this, rObj)); + } + + void E3dLatheProperties::PostItemChange(const sal_uInt16 nWhich) + { + // call parent + E3dCompoundProperties::PostItemChange(nWhich); + + // handle value change + E3dLatheObj& rObj = static_cast<E3dLatheObj&>(GetSdrObject()); + + switch(nWhich) + { + case SDRATTR_3DOBJ_HORZ_SEGS: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_VERT_SEGS: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_PERCENT_DIAGONAL: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_BACKSCALE: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_END_ANGLE: + { + rObj.ActionChanged(); + break; + } + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/e3dproperties.cxx b/svx/source/sdr/properties/e3dproperties.cxx new file mode 100644 index 000000000..0f435fd99 --- /dev/null +++ b/svx/source/sdr/properties/e3dproperties.cxx @@ -0,0 +1,75 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/e3dproperties.hxx> +#include <svl/itemset.hxx> +#include <svx/svddef.hxx> +#include <svx/obj3d.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> E3dProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>(rPool, + + // ranges from SdrAttrObj + svl::Items<SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + + // ranges from E3dObject, contains object and scene because of GetMergedItemSet() + SDRATTR_3D_FIRST, SDRATTR_3D_LAST>{}); + } + + E3dProperties::E3dProperties(SdrObject& rObj) + : AttributeProperties(rObj) + { + } + + E3dProperties::E3dProperties(const E3dProperties& rProps, SdrObject& rObj) + : AttributeProperties(rProps, rObj) + { + } + + E3dProperties::~E3dProperties() + { + } + + std::unique_ptr<BaseProperties> E3dProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new E3dProperties(*this, rObj)); + } + + void E3dProperties::ItemSetChanged(const SfxItemSet& rSet) + { + E3dObject& rObj = static_cast<E3dObject&>(GetSdrObject()); + + // call parent + AttributeProperties::ItemSetChanged(rSet); + + // local changes + rObj.StructureChanged(); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/e3dsceneproperties.cxx b/svx/source/sdr/properties/e3dsceneproperties.cxx new file mode 100644 index 000000000..de99a1835 --- /dev/null +++ b/svx/source/sdr/properties/e3dsceneproperties.cxx @@ -0,0 +1,292 @@ +/* -*- 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 <sdr/properties/e3dsceneproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/whiter.hxx> +#include <svx/svddef.hxx> +#include <svx/scene3d.hxx> +#include <memory> + + +namespace sdr::properties +{ + E3dSceneProperties::E3dSceneProperties(SdrObject& rObj) + : E3dProperties(rObj) + { + } + + E3dSceneProperties::E3dSceneProperties(const E3dSceneProperties& rProps, SdrObject& rObj) + : E3dProperties(rProps, rObj) + { + } + + E3dSceneProperties::~E3dSceneProperties() + { + } + + std::unique_ptr<BaseProperties> E3dSceneProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new E3dSceneProperties(*this, rObj)); + } + + const SfxItemSet& E3dSceneProperties::GetMergedItemSet() const + { + // prepare ItemSet + if(mpItemSet) + { + // filter for SDRATTR_3DSCENE_ items, only keep those items + SfxItemSet aNew(*mpItemSet->GetPool(), svl::Items<SDRATTR_3DSCENE_FIRST, SDRATTR_3DSCENE_LAST>{}); + aNew.Put(*mpItemSet); + mpItemSet->ClearItem(); + mpItemSet->Put(aNew); + } + else + { + // No ItemSet yet, force local ItemSet + GetObjectItemSet(); + } + + // collect all ItemSets of contained 3d objects + const SdrObjList* pSub(static_cast<const E3dScene&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + SdrObject* pObj = pSub->GetObj(a); + + if(dynamic_cast<const E3dCompoundObject* >(pObj)) + { + const SfxItemSet& rSet = pObj->GetMergedItemSet(); + SfxWhichIter aIter(rSet); + sal_uInt16 nWhich(aIter.FirstWhich()); + + while(nWhich) + { + // Leave out the SDRATTR_3DSCENE_ range, this would only be double + // and always equal. + if(nWhich <= SDRATTR_3DSCENE_FIRST || nWhich >= SDRATTR_3DSCENE_LAST) + { + if(SfxItemState::DONTCARE == rSet.GetItemState(nWhich, false)) + { + mpItemSet->InvalidateItem(nWhich); + } + else + { + mpItemSet->MergeValue(rSet.Get(nWhich), true); + } + } + + nWhich = aIter.NextWhich(); + } + } + } + + // call parent + return E3dProperties::GetMergedItemSet(); + } + + void E3dSceneProperties::SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems) + { + // Set SDRATTR_3DOBJ_ range at contained objects. + const SdrObjList* pSub(static_cast<const E3dScene&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + if(nCount) + { + // Generate filtered ItemSet which contains all but the SDRATTR_3DSCENE items. + // #i50808# Leak fix, Clone produces a new instance and we get ownership here + std::unique_ptr<SfxItemSet> pNewSet(rSet.Clone()); + DBG_ASSERT(pNewSet, "E3dSceneProperties::SetMergedItemSet(): Could not clone ItemSet (!)"); + + for(sal_uInt16 b(SDRATTR_3DSCENE_FIRST); b <= SDRATTR_3DSCENE_LAST; b++) + { + pNewSet->ClearItem(b); + } + + if(pNewSet->Count()) + { + for(size_t a = 0; a < nCount; ++a) + { + SdrObject* pObj = pSub->GetObj(a); + + if(dynamic_cast<const E3dCompoundObject* >(pObj)) + { + // set merged ItemSet at contained 3d object. + pObj->SetMergedItemSet(*pNewSet, bClearAllItems); + } + } + } + } + + // call parent. This will set items on local object, too. + E3dProperties::SetMergedItemSet(rSet, bClearAllItems); + } + + void E3dSceneProperties::SetMergedItem(const SfxPoolItem& rItem) + { + const SdrObjList* pSub(static_cast<const E3dScene&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + pSub->GetObj(a)->SetMergedItem(rItem); + } + + // #i43809# call parent. This will set items on local object, too. + E3dProperties::SetMergedItem(rItem); + } + + void E3dSceneProperties::ClearMergedItem(const sal_uInt16 nWhich) + { + const SdrObjList* pSub(static_cast<const E3dScene&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + pSub->GetObj(a)->ClearMergedItem(nWhich); + } + + // #i43809# call parent. This will clear items on local object, too. + E3dProperties::ClearMergedItem(nWhich); + } + + void E3dSceneProperties::PostItemChange(const sal_uInt16 nWhich) + { + // call parent + E3dProperties::PostItemChange(nWhich); + + // local changes + E3dScene& rObj = static_cast<E3dScene&>(GetSdrObject()); + rObj.StructureChanged(); + + switch(nWhich) + { + case SDRATTR_3DSCENE_PERSPECTIVE : + case SDRATTR_3DSCENE_DISTANCE : + case SDRATTR_3DSCENE_FOCAL_LENGTH : + { + // #83387#, #83391# + // one common function for the camera attributes + // since SetCamera() sets all three back to the ItemSet + Camera3D aSceneCam(rObj.GetCamera()); + bool bChange(false); + + // for SDRATTR_3DSCENE_PERSPECTIVE: + if(aSceneCam.GetProjection() != rObj.GetPerspective()) + { + aSceneCam.SetProjection(rObj.GetPerspective()); + bChange = true; + } + + // for SDRATTR_3DSCENE_DISTANCE: + basegfx::B3DPoint aActualPosition(aSceneCam.GetPosition()); + double fNew = rObj.GetDistance(); + + if(fNew != aActualPosition.getZ()) + { + aSceneCam.SetPosition(basegfx::B3DPoint(aActualPosition.getX(), aActualPosition.getY(), fNew)); + bChange = true; + } + + // for SDRATTR_3DSCENE_FOCAL_LENGTH: + fNew = rObj.GetFocalLength() / 100.0; + + if(aSceneCam.GetFocalLength() != fNew) + { + aSceneCam.SetFocalLength(fNew); + bChange = true; + } + + // for all + if(bChange) + { + rObj.SetCamera(aSceneCam); + } + + break; + } + } + } + + void E3dSceneProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + const SdrObjList* pSub(static_cast<const E3dScene&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + pSub->GetObj(a)->SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + } + } + + SfxStyleSheet* E3dSceneProperties::GetStyleSheet() const + { + SfxStyleSheet* pRetval = nullptr; + + const SdrObjList* pSub(static_cast<const E3dScene&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + SfxStyleSheet* pCandidate = pSub->GetObj(a)->GetStyleSheet(); + + if(pRetval) + { + if(pCandidate != pRetval) + { + // different StyleSheelts, return none + return nullptr; + } + } + else + { + pRetval = pCandidate; + } + } + + return pRetval; + } + + void E3dSceneProperties::SetSceneItemsFromCamera() + { + // force ItemSet + GetObjectItemSet(); + + E3dScene& rObj = static_cast<E3dScene&>(GetSdrObject()); + const Camera3D& aSceneCam(rObj.GetCamera()); + + // ProjectionType + mpItemSet->Put(Svx3DPerspectiveItem(aSceneCam.GetProjection())); + + // CamPos + mpItemSet->Put(makeSvx3DDistanceItem(static_cast<sal_uInt32>(aSceneCam.GetPosition().getZ() + 0.5))); + + // FocalLength + mpItemSet->Put(makeSvx3DFocalLengthItem(static_cast<sal_uInt32>((aSceneCam.GetFocalLength() * 100.0) + 0.5))); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/e3dsphereproperties.cxx b/svx/source/sdr/properties/e3dsphereproperties.cxx new file mode 100644 index 000000000..66f01748f --- /dev/null +++ b/svx/source/sdr/properties/e3dsphereproperties.cxx @@ -0,0 +1,69 @@ +/* -*- 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 <sdr/properties/e3dsphereproperties.hxx> +#include <svx/sphere3d.hxx> + + +namespace sdr::properties +{ + E3dSphereProperties::E3dSphereProperties(SdrObject& rObj) + : E3dCompoundProperties(rObj) + { + } + + E3dSphereProperties::E3dSphereProperties(const E3dSphereProperties& rProps, SdrObject& rObj) + : E3dCompoundProperties(rProps, rObj) + { + } + + E3dSphereProperties::~E3dSphereProperties() + { + } + + std::unique_ptr<BaseProperties> E3dSphereProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new E3dSphereProperties(*this, rObj)); + } + + void E3dSphereProperties::PostItemChange(const sal_uInt16 nWhich) + { + // call parent + E3dCompoundProperties::PostItemChange(nWhich); + + // handle value change + E3dSphereObj& rObj = static_cast<E3dSphereObj&>(GetSdrObject()); + + switch(nWhich) + { + case SDRATTR_3DOBJ_HORZ_SEGS: + { + rObj.ActionChanged(); + break; + } + case SDRATTR_3DOBJ_VERT_SEGS: + { + rObj.ActionChanged(); + break; + } + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/emptyproperties.cxx b/svx/source/sdr/properties/emptyproperties.cxx new file mode 100644 index 000000000..502fe2702 --- /dev/null +++ b/svx/source/sdr/properties/emptyproperties.cxx @@ -0,0 +1,118 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/emptyproperties.hxx> +#include <svl/itemset.hxx> +#include <svx/svdobj.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> EmptyProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + // Basic implementation; Basic object has NO attributes + assert(!"EmptyProperties::CreateObjectSpecificItemSet() should never be called"); + return std::make_unique<SfxItemSet>(rPool); + } + + EmptyProperties::EmptyProperties(SdrObject& rObj) + : BaseProperties(rObj) + { + } + + std::unique_ptr<BaseProperties> EmptyProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new EmptyProperties(rObj)); + } + + const SfxItemSet& EmptyProperties::GetObjectItemSet() const + { + if(!mpEmptyItemSet) + { + const_cast<EmptyProperties*>(this)->mpEmptyItemSet = const_cast<EmptyProperties*>(this)->CreateObjectSpecificItemSet(GetSdrObject().GetObjectItemPool()); + } + + assert(mpEmptyItemSet); + assert(!"EmptyProperties::GetObjectItemSet() should never be called"); + + return *mpEmptyItemSet; + } + + void EmptyProperties::SetObjectItem(const SfxPoolItem& /*rItem*/) + { + assert(!"EmptyProperties::SetObjectItem() should never be called"); + } + + void EmptyProperties::SetObjectItemDirect(const SfxPoolItem& /*rItem*/) + { + assert(!"EmptyProperties::SetObjectItemDirect() should never be called"); + } + + void EmptyProperties::ClearObjectItem(const sal_uInt16 /*nWhich*/) + { + assert(!"EmptyProperties::ClearObjectItem() should never be called"); + } + + void EmptyProperties::ClearObjectItemDirect(const sal_uInt16 /*nWhich*/) + { + assert(!"EmptyProperties::ClearObjectItemDirect() should never be called"); + } + + void EmptyProperties::SetObjectItemSet(const SfxItemSet& /*rSet*/) + { + assert(!"EmptyProperties::SetObjectItemSet() should never be called"); + } + + void EmptyProperties::ItemSetChanged(const SfxItemSet& /*rSet*/) + { + assert(!"EmptyProperties::ItemSetChanged() should never be called"); + } + + bool EmptyProperties::AllowItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) const + { + assert(!"EmptyProperties::AllowItemChange() should never be called"); + return true; + } + + void EmptyProperties::ItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) + { + assert(!"EmptyProperties::ItemChange() should never be called"); + } + + void EmptyProperties::PostItemChange(const sal_uInt16 /*nWhich*/) + { + assert(!"EmptyProperties::PostItemChange() should never be called"); + } + + void EmptyProperties::SetStyleSheet(SfxStyleSheet* /*pNewStyleSheet*/, bool /*bDontRemoveHardAttr*/) + { + assert(!"EmptyProperties::SetStyleSheet() should never be called"); + } + + SfxStyleSheet* EmptyProperties::GetStyleSheet() const + { + assert(!"EmptyProperties::GetStyleSheet() should never be called"); + return nullptr; + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/graphicproperties.cxx b/svx/source/sdr/properties/graphicproperties.cxx new file mode 100644 index 000000000..2819826ca --- /dev/null +++ b/svx/source/sdr/properties/graphicproperties.cxx @@ -0,0 +1,148 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/graphicproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svx/svddef.hxx> +#include <editeng/eeitem.hxx> +#include <svx/svdograf.hxx> +#include <svx/sdgcpitm.hxx> +#include <svx/svdmodel.hxx> +#include <svx/sdgluitm.hxx> +#include <sdgcoitm.hxx> +#include <svx/sdggaitm.hxx> +#include <sdgtritm.hxx> +#include <sdginitm.hxx> +#include <svx/sdgmoitm.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xlineit0.hxx> + +namespace sdr::properties +{ + void GraphicProperties::applyDefaultStyleSheetFromSdrModel() + { + SfxStyleSheet* pStyleSheet(GetSdrObject().getSdrModelFromSdrObject().GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj()); + + if(pStyleSheet) + { + // do not delete hard attributes when setting dsefault Style + SetStyleSheet(pStyleSheet, true); + } + else + { + SetMergedItem(XFillStyleItem(com::sun::star::drawing::FillStyle_NONE)); + SetMergedItem(XLineStyleItem(com::sun::star::drawing::LineStyle_NONE)); + } + } + + // create a new itemset + std::unique_ptr<SfxItemSet> GraphicProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>(rPool, + + // range from SdrAttrObj + svl::Items<SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + + // range from SdrGrafObj + SDRATTR_GRAF_FIRST, SDRATTR_GRAF_LAST, + + SDRATTR_GLOW_FIRST, SDRATTR_SOFTEDGE_LAST, + + // range from SdrTextObj + EE_ITEMS_START, EE_ITEMS_END>{}); + } + + GraphicProperties::GraphicProperties(SdrObject& rObj) + : RectangleProperties(rObj) + { + } + + GraphicProperties::GraphicProperties(const GraphicProperties& rProps, SdrObject& rObj) + : RectangleProperties(rProps, rObj) + { + } + + GraphicProperties::~GraphicProperties() + { + } + + std::unique_ptr<BaseProperties> GraphicProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new GraphicProperties(*this, rObj)); + } + + void GraphicProperties::ItemSetChanged(const SfxItemSet& rSet) + { + SdrGrafObj& rObj = static_cast<SdrGrafObj&>(GetSdrObject()); + + // local changes + rObj.SetXPolyDirty(); + + // #i29367# Update GraphicAttr, too. This was formerly + // triggered by SdrGrafObj::Notify, which is no longer + // called nowadays. BTW: strictly speaking, the whole + // ImpSetAttrToGrafInfostuff could + // be dumped, when SdrGrafObj::aGrafInfo is removed and + // always created on the fly for repaint. + rObj.ImpSetAttrToGrafInfo(); + + // call parent + RectangleProperties::ItemSetChanged(rSet); + } + + void GraphicProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + RectangleProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + // local changes + SdrGrafObj& rObj = static_cast<SdrGrafObj&>(GetSdrObject()); + rObj.SetXPolyDirty(); + + // local changes + rObj.ImpSetAttrToGrafInfo(); + } + + void GraphicProperties::ForceDefaultAttributes() + { + // call parent + RectangleProperties::ForceDefaultAttributes(); + + // force ItemSet + GetObjectItemSet(); + + mpItemSet->Put( SdrGrafLuminanceItem( 0 ) ); + mpItemSet->Put( SdrGrafContrastItem( 0 ) ); + mpItemSet->Put( SdrGrafRedItem( 0 ) ); + mpItemSet->Put( SdrGrafGreenItem( 0 ) ); + mpItemSet->Put( SdrGrafBlueItem( 0 ) ); + mpItemSet->Put( SdrGrafGamma100Item( 100 ) ); + mpItemSet->Put( SdrGrafTransparenceItem( 0 ) ); + mpItemSet->Put( SdrGrafInvertItem( false ) ); + mpItemSet->Put( SdrGrafModeItem( GraphicDrawMode::Standard ) ); + mpItemSet->Put( SdrGrafCropItem( 0, 0, 0, 0 ) ); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/groupproperties.cxx b/svx/source/sdr/properties/groupproperties.cxx new file mode 100644 index 000000000..4ccd517f4 --- /dev/null +++ b/svx/source/sdr/properties/groupproperties.cxx @@ -0,0 +1,275 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/groupproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/whiter.hxx> +#include <svx/svdogrp.hxx> +#include <svx/svdpage.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> GroupProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + // Groups have in principle no ItemSet. To support methods like + // GetMergedItemSet() the local one is used. Thus, all items in the pool + // may be used and a pool itemset is created. + return std::make_unique<SfxItemSet>(rPool); + } + + GroupProperties::GroupProperties(SdrObject& rObj) + : DefaultProperties(rObj) + { + } + + GroupProperties::GroupProperties(const GroupProperties& rProps, SdrObject& rObj) + : DefaultProperties(rProps, rObj) + { + } + + GroupProperties::~GroupProperties() + { + } + + std::unique_ptr<BaseProperties> GroupProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new GroupProperties(*this, rObj)); + } + + const SfxItemSet& GroupProperties::GetObjectItemSet() const + { + assert(!"GroupProperties::GetObjectItemSet() should never be called"); + return DefaultProperties::GetObjectItemSet(); + } + + const SfxItemSet& GroupProperties::GetMergedItemSet() const + { + // prepare ItemSet + if(mpItemSet) + { + // clear local itemset for merge + mpItemSet->ClearItem(); + } + else + { + // force local itemset + DefaultProperties::GetObjectItemSet(); + } + + // collect all ItemSets in mpItemSet + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + const SfxItemSet& rSet = pSub->GetObj(a)->GetMergedItemSet(); + SfxWhichIter aIter(rSet); + sal_uInt16 nWhich(aIter.FirstWhich()); + + while(nWhich) + { + if(SfxItemState::DONTCARE == rSet.GetItemState(nWhich, false)) + { + mpItemSet->InvalidateItem(nWhich); + } + else + { + mpItemSet->MergeValue(rSet.Get(nWhich), true); + } + + nWhich = aIter.NextWhich(); + } + } + + // For group properties, do not call parent since groups do + // not have local ItemSets. + return *mpItemSet; + } + + void GroupProperties::SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems) + { + // iterate over contained SdrObjects + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + SdrObject* pObj = pSub->GetObj(a); + + if(pObj) + { + // Set merged ItemSet at contained object + pObj->SetMergedItemSet(rSet, bClearAllItems); + } + } + + // Do not call parent here. Group objects do not have local ItemSets + // where items need to be set. + // DefaultProperties::SetMergedItemSet(rSet, bClearAllItems); + } + + void GroupProperties::SetObjectItem(const SfxPoolItem& /*rItem*/) + { + assert(!"GroupProperties::SetObjectItem() should never be called"); + } + + void GroupProperties::SetObjectItemDirect(const SfxPoolItem& /*rItem*/) + { + assert(!"GroupProperties::SetObjectItemDirect() should never be called"); + } + + void GroupProperties::ClearObjectItem(const sal_uInt16 nWhich) + { + // iterate over contained SdrObjects + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + SdrObject* pObj = pSub->GetObj(a); + + if(pObj) + { + pObj->GetProperties().ClearObjectItem(nWhich); + } + } + } + + void GroupProperties::ClearObjectItemDirect(const sal_uInt16 /*nWhich*/) + { + assert(!"GroupProperties::ClearObjectItemDirect() should never be called"); + } + + void GroupProperties::SetMergedItem(const SfxPoolItem& rItem) + { + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + pSub->GetObj(a)->GetProperties().SetMergedItem(rItem); + } + } + + void GroupProperties::ClearMergedItem(const sal_uInt16 nWhich) + { + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + pSub->GetObj(a)->GetProperties().ClearMergedItem(nWhich); + } + } + + void GroupProperties::SetObjectItemSet(const SfxItemSet& /*rSet*/) + { + assert(!"GroupProperties::SetObjectItemSet() should never be called"); + } + + void GroupProperties::ItemSetChanged(const SfxItemSet& /*rSet*/) + { + assert(!"GroupProperties::ItemSetChanged() should never be called"); + } + + bool GroupProperties::AllowItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) const + { + assert(!"GroupProperties::AllowItemChange() should never be called"); + return false; + } + + void GroupProperties::ItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) + { + assert(!"GroupProperties::ItemChange() should never be called"); + } + + void GroupProperties::PostItemChange(const sal_uInt16 /*nWhich*/) + { + assert(!"GroupProperties::PostItemChange() should never be called"); + } + + SfxStyleSheet* GroupProperties::GetStyleSheet() const + { + SfxStyleSheet* pRetval = nullptr; + + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + SfxStyleSheet* pCandidate = pSub->GetObj(a)->GetStyleSheet(); + + if(pRetval) + { + if(pCandidate != pRetval) + { + // different StyleSheelts, return none + return nullptr; + } + } + else + { + pRetval = pCandidate; + } + } + + return pRetval; + } + + void GroupProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + pSub->GetObj(a)->SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + } + } + + void GroupProperties::ForceDefaultAttributes() + { + // nothing to do here, groups have no items and thus no default items, too. + } + + void GroupProperties::ForceStyleToHardAttributes() + { + const SdrObjList* pSub(static_cast<const SdrObjGroup&>(GetSdrObject()).GetSubList()); + OSL_ENSURE(nullptr != pSub, "Children of SdrObject expected (!)"); + const size_t nCount(nullptr == pSub ? 0 : pSub->GetObjCount()); + + for(size_t a = 0; a < nCount; ++a) + { + pSub->GetObj(a)->GetProperties().ForceStyleToHardAttributes(); + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/itemsettools.cxx b/svx/source/sdr/properties/itemsettools.cxx new file mode 100644 index 000000000..b8be77812 --- /dev/null +++ b/svx/source/sdr/properties/itemsettools.cxx @@ -0,0 +1,86 @@ +/* -*- 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 <sdr/properties/itemsettools.hxx> +#include <tools/fract.hxx> +#include <svl/itemset.hxx> +#include <svl/whiter.hxx> +#include <svx/svdogrp.hxx> +#include <svx/svditer.hxx> +#include <memory> + +// class to remember broadcast start positions + +namespace sdr::properties +{ + ItemChangeBroadcaster::ItemChangeBroadcaster(const SdrObject& rObj) + { + if (const SdrObjGroup* pGroupObj = dynamic_cast<const SdrObjGroup*>(&rObj)) + { + SdrObjListIter aIter(pGroupObj->GetSubList(), SdrIterMode::DeepNoGroups); + maRectangles.reserve(aIter.Count()); + + while(aIter.IsMore()) + { + SdrObject* pObj = aIter.Next(); + + if(pObj) + { + maRectangles.push_back(pObj->GetLastBoundRect()); + } + } + } + else + { + maRectangles.push_back(rObj.GetLastBoundRect()); + } + } + + + void ScaleItemSet(SfxItemSet& rSet, const Fraction& rScale) + { + sal_Int32 nMul(rScale.GetNumerator()); + sal_Int32 nDiv(rScale.GetDenominator()); + + if(!rScale.IsValid() || !nDiv) + { + return; + } + + SfxWhichIter aIter(rSet); + sal_uInt16 nWhich(aIter.FirstWhich()); + const SfxPoolItem *pItem = nullptr; + + while(nWhich) + { + if(SfxItemState::SET == rSet.GetItemState(nWhich, false, &pItem)) + { + if(pItem->HasMetrics()) + { + std::unique_ptr<SfxPoolItem> pNewItem(pItem->Clone()); + pNewItem->ScaleMetrics(nMul, nDiv); + rSet.Put(std::move(pNewItem)); + } + } + nWhich = aIter.NextWhich(); + } + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/measureproperties.cxx b/svx/source/sdr/properties/measureproperties.cxx new file mode 100644 index 000000000..5519930e3 --- /dev/null +++ b/svx/source/sdr/properties/measureproperties.cxx @@ -0,0 +1,128 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/measureproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svx/svddef.hxx> +#include <editeng/eeitem.hxx> +#include <svx/svdomeas.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xlnstit.hxx> +#include <svx/xlnstwit.hxx> +#include <svx/xlnedit.hxx> +#include <svx/xlnedwit.hxx> +#include <svx/sdynitm.hxx> +#include <basegfx/point/b2dpoint.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> MeasureProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>( + rPool, + svl::Items< + // Ranges from SdrAttrObj, SdrMeasureObj: + SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, + SDRATTR_MEASURE_FIRST, SDRATTR_MEASURE_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + // Range from SdrTextObj: + EE_ITEMS_START, EE_ITEMS_END>{}); + } + + MeasureProperties::MeasureProperties(SdrObject& rObj) + : TextProperties(rObj) + { + } + + MeasureProperties::MeasureProperties(const MeasureProperties& rProps, SdrObject& rObj) + : TextProperties(rProps, rObj) + { + } + + MeasureProperties::~MeasureProperties() + { + } + + std::unique_ptr<BaseProperties> MeasureProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new MeasureProperties(*this, rObj)); + } + + void MeasureProperties::ItemSetChanged(const SfxItemSet& rSet) + { + SdrMeasureObj& rObj = static_cast<SdrMeasureObj&>(GetSdrObject()); + + // call parent + TextProperties::ItemSetChanged(rSet); + + // local changes + rObj.SetTextDirty(); + } + + void MeasureProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + TextProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + // local changes + // get access to dimension line object + SdrMeasureObj& rObj = static_cast<SdrMeasureObj&>(GetSdrObject()); + + // mark dimension line text as changed (dirty) in the dimension line object + rObj.SetTextDirty(); + + // tdf#98525 ask the dimension line object to redraw the changed text + rObj.UndirtyText(); + } + + void MeasureProperties::ForceDefaultAttributes() + { + // call parent + TextProperties::ForceDefaultAttributes(); + + // force ItemSet + GetObjectItemSet(); + + //#71958# by default, the show units Bool-Item is set as hard + // attribute to sal_True to avoid confusion when copying SdrMeasureObj's + // from one application to another + mpItemSet->Put(SdrYesNoItem(SDRATTR_MEASURESHOWUNIT, true)); + + basegfx::B2DPolygon aNewPolygon; + aNewPolygon.append(basegfx::B2DPoint(100.0, 0.0)); + aNewPolygon.append(basegfx::B2DPoint(200.0, 400.0)); + aNewPolygon.append(basegfx::B2DPoint(0.0, 400.0)); + aNewPolygon.setClosed(true); + + mpItemSet->Put(XLineStartItem(OUString(), basegfx::B2DPolyPolygon(aNewPolygon))); + mpItemSet->Put(XLineStartWidthItem(200)); + mpItemSet->Put(XLineEndItem(OUString(), basegfx::B2DPolyPolygon(aNewPolygon))); + mpItemSet->Put(XLineEndWidthItem(200)); + mpItemSet->Put(XLineStyleItem(css::drawing::LineStyle_SOLID)); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/oleproperties.cxx b/svx/source/sdr/properties/oleproperties.cxx new file mode 100644 index 000000000..2cdb55b70 --- /dev/null +++ b/svx/source/sdr/properties/oleproperties.cxx @@ -0,0 +1,73 @@ +/* -*- 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 <sdr/properties/oleproperties.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xlineit0.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdmodel.hxx> + +namespace sdr::properties +{ + void OleProperties::applyDefaultStyleSheetFromSdrModel() + { + SfxStyleSheet* pStyleSheet(GetSdrObject().getSdrModelFromSdrObject().GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj()); + + if(pStyleSheet) + { + // do not delete hard attributes when setting dsefault Style + SetStyleSheet(pStyleSheet, true); + } + else + { + SetMergedItem(XFillStyleItem(com::sun::star::drawing::FillStyle_NONE)); + SetMergedItem(XLineStyleItem(com::sun::star::drawing::LineStyle_NONE)); + } + } + + OleProperties::OleProperties(SdrObject& rObj) + : RectangleProperties(rObj) + { + } + + OleProperties::OleProperties(const OleProperties& rProps, SdrObject& rObj) + : RectangleProperties(rProps, rObj) + { + } + + OleProperties::~OleProperties() + { + } + + std::unique_ptr<BaseProperties> OleProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new OleProperties(*this, rObj)); + } + + void OleProperties::ForceDefaultAttributes() + { + // call parent + RectangleProperties::ForceDefaultAttributes(); + + // force ItemSet + GetObjectItemSet(); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/pageproperties.cxx b/svx/source/sdr/properties/pageproperties.cxx new file mode 100644 index 000000000..feca40ac7 --- /dev/null +++ b/svx/source/sdr/properties/pageproperties.cxx @@ -0,0 +1,99 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/pageproperties.hxx> +#include <svl/itemset.hxx> +#include <svx/svdobj.hxx> +#include <svx/xdef.hxx> +#include <tools/debug.hxx> + + +namespace sdr::properties +{ + // create a new itemset + std::unique_ptr<SfxItemSet> PageProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + // override to legally return a valid ItemSet + return std::make_unique<SfxItemSet>(rPool); + } + + PageProperties::PageProperties(SdrObject& rObj) + : EmptyProperties(rObj) + { + } + + PageProperties::PageProperties(const PageProperties& /*rProps*/, SdrObject& rObj) + : EmptyProperties(rObj) + { + } + + PageProperties::~PageProperties() + { + } + + std::unique_ptr<BaseProperties> PageProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new PageProperties(*this, rObj)); + } + + // get itemset. Override here to allow creating the empty itemset + // without asserting + const SfxItemSet& PageProperties::GetObjectItemSet() const + { + if(!mpEmptyItemSet) + { + const_cast<PageProperties*>(this)->mpEmptyItemSet = const_cast<PageProperties*>(this)->CreateObjectSpecificItemSet(GetSdrObject().GetObjectItemPool()); + } + + DBG_ASSERT(mpEmptyItemSet, "Could not create an SfxItemSet(!)"); + + return *mpEmptyItemSet; + } + + void PageProperties::ItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) + { + // #86481# simply ignore item setting on page objects + } + + SfxStyleSheet* PageProperties::GetStyleSheet() const + { + // override to legally return a 0L pointer here + return nullptr; + } + + void PageProperties::SetStyleSheet(SfxStyleSheet* /*pStyleSheet*/, bool /*bDontRemoveHardAttr*/) + { + // override to legally ignore the StyleSheet here + } + + void PageProperties::PostItemChange(const sal_uInt16 nWhich ) + { + if( (nWhich == XATTR_FILLSTYLE) && (mpEmptyItemSet != nullptr) ) + CleanupFillProperties(*mpEmptyItemSet); + } + + void PageProperties::ClearObjectItem(const sal_uInt16 /*nWhich*/) + { + // simply ignore item clearing on page objects + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/properties.cxx b/svx/source/sdr/properties/properties.cxx new file mode 100644 index 000000000..baf3a48d3 --- /dev/null +++ b/svx/source/sdr/properties/properties.cxx @@ -0,0 +1,192 @@ +/* -*- 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 <libxml/xmlwriter.h> + +#include <svx/sdr/properties/properties.hxx> +#include <sdr/properties/itemsettools.hxx> +#include <svl/itemset.hxx> +#include <svx/svdogrp.hxx> +#include <svx/svditer.hxx> +#include <svx/xdef.hxx> +#include <svx/xfillit0.hxx> +#include <svx/svdmodel.hxx> + +using namespace com::sun::star; + +namespace sdr::properties +{ + BaseProperties::BaseProperties(SdrObject& rObj) + : mrObject(rObj) + { + } + + BaseProperties::~BaseProperties() + { + } + + void BaseProperties::applyDefaultStyleSheetFromSdrModel() + { + SfxStyleSheet* pDefaultStyleSheet(GetSdrObject().getSdrModelFromSdrObject().GetDefaultStyleSheet()); + + // tdf#118139 Only do this when StyleSheet really differs. It may e.g. + // be the case that nullptr == pDefaultStyleSheet and there is none set yet, + // so indeed no need to set it (needed for some strange old MSWord2003 + // documents with CustomShape-'Group' and added Text-Frames, see task description) + if(pDefaultStyleSheet != GetStyleSheet()) + { + // do not delete hard attributes when setting dsefault Style + SetStyleSheet(pDefaultStyleSheet, true); + } + } + + const SdrObject& BaseProperties::GetSdrObject() const + { + return mrObject; + } + + SdrObject& BaseProperties::GetSdrObject() + { + return mrObject; + } + + const SfxItemSet& BaseProperties::GetMergedItemSet() const + { + // default implementation falls back to GetObjectItemSet() + return GetObjectItemSet(); + } + + void BaseProperties::SetMergedItemSet(const SfxItemSet& rSet, bool bClearAllItems) + { + // clear items if requested + if(bClearAllItems) + { + ClearObjectItem(); + } + + // default implementation falls back to SetObjectItemSet() + SetObjectItemSet(rSet); + } + + void BaseProperties::SetMergedItem(const SfxPoolItem& rItem) + { + // default implementation falls back to SetObjectItem() + SetObjectItem(rItem); + } + + void BaseProperties::ClearMergedItem(const sal_uInt16 nWhich) + { + // default implementation falls back to ClearObjectItem() + ClearObjectItem(nWhich); + } + + void BaseProperties::ForceStyleToHardAttributes() + { + // force all attributes which come from styles to hard attributes + // to be able to live without the style. Default implementation does nothing. + // Override where an ItemSet is implemented. + } + + void BaseProperties::SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, bool bClearAllItems) + { + ItemChangeBroadcaster aC(GetSdrObject()); + + if(bClearAllItems) + { + ClearObjectItem(); + } + + SetMergedItemSet(rSet); + BroadcastItemChange(aC); + } + + const SfxPoolItem& BaseProperties::GetItem(const sal_uInt16 nWhich) const + { + return GetObjectItemSet().Get(nWhich); + } + + void BaseProperties::BroadcastItemChange(const ItemChangeBroadcaster& rChange) + { + const sal_uInt32 nCount(rChange.GetRectangleCount()); + + // invalidate all new rectangles + if(dynamic_cast<const SdrObjGroup*>( &GetSdrObject() ) != nullptr) + { + SdrObjListIter aIter(static_cast<SdrObjGroup&>(GetSdrObject()), SdrIterMode::DeepNoGroups); + + while(aIter.IsMore()) + { + SdrObject* pObj = aIter.Next(); + pObj->BroadcastObjectChange(); + } + } + else + { + GetSdrObject().BroadcastObjectChange(); + } + + // also send the user calls + for(sal_uInt32 a(0); a < nCount; a++) + { + GetSdrObject().SendUserCall(SdrUserCallType::ChangeAttr, rChange.GetRectangle(a)); + } + } + + sal_uInt32 BaseProperties::getVersion() const + { + return 0; + } + + void BaseProperties::dumpAsXml(xmlTextWriterPtr pWriter) const + { + xmlTextWriterStartElement(pWriter, BAD_CAST("BaseProperties")); + xmlTextWriterEndElement(pWriter); + } + + void CleanupFillProperties( SfxItemSet& rItemSet ) + { + const bool bFillBitmap = rItemSet.GetItemState(XATTR_FILLBITMAP, false) == SfxItemState::SET; + const bool bFillGradient = rItemSet.GetItemState(XATTR_FILLGRADIENT, false) == SfxItemState::SET; + const bool bFillHatch = rItemSet.GetItemState(XATTR_FILLHATCH, false) == SfxItemState::SET; + if( bFillBitmap || bFillGradient || bFillHatch ) + { + const XFillStyleItem* pFillStyleItem = rItemSet.GetItem(XATTR_FILLSTYLE); + if( pFillStyleItem ) + { + if( bFillBitmap && (pFillStyleItem->GetValue() != drawing::FillStyle_BITMAP) ) + { + rItemSet.ClearItem( XATTR_FILLBITMAP ); + } + + if( bFillGradient && (pFillStyleItem->GetValue() != drawing::FillStyle_GRADIENT) ) + { + rItemSet.ClearItem( XATTR_FILLGRADIENT ); + } + + if( bFillHatch && (pFillStyleItem->GetValue() != drawing::FillStyle_HATCH) ) + { + rItemSet.ClearItem( XATTR_FILLHATCH ); + } + } + } + } + +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/rectangleproperties.cxx b/svx/source/sdr/properties/rectangleproperties.cxx new file mode 100644 index 000000000..84b4fc17e --- /dev/null +++ b/svx/source/sdr/properties/rectangleproperties.cxx @@ -0,0 +1,68 @@ +/* -*- 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 <sdr/properties/rectangleproperties.hxx> +#include <svx/svdorect.hxx> + + +namespace sdr::properties +{ + RectangleProperties::RectangleProperties(SdrObject& rObj) + : TextProperties(rObj) + { + } + + RectangleProperties::RectangleProperties(const RectangleProperties& rProps, SdrObject& rObj) + : TextProperties(rProps, rObj) + { + } + + RectangleProperties::~RectangleProperties() + { + } + + std::unique_ptr<BaseProperties> RectangleProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new RectangleProperties(*this, rObj)); + } + + void RectangleProperties::ItemSetChanged(const SfxItemSet& rSet) + { + SdrRectObj& rObj = static_cast<SdrRectObj&>(GetSdrObject()); + + // call parent + TextProperties::ItemSetChanged(rSet); + + // local changes + rObj.SetXPolyDirty(); + } + + // set a new StyleSheet and broadcast + void RectangleProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + TextProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + // local changes + SdrRectObj& rObj = static_cast<SdrRectObj&>(GetSdrObject()); + rObj.SetXPolyDirty(); + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/sdr/properties/textproperties.cxx b/svx/source/sdr/properties/textproperties.cxx new file mode 100644 index 000000000..e2cedd10f --- /dev/null +++ b/svx/source/sdr/properties/textproperties.cxx @@ -0,0 +1,611 @@ +/* -*- 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 <sal/config.h> + +#include <sdr/properties/textproperties.hxx> +#include <svl/itemset.hxx> +#include <svl/style.hxx> +#include <svl/itemiter.hxx> +#include <svl/hint.hxx> +#include <svx/svddef.hxx> +#include <svx/svdotext.hxx> +#include <svx/svdoutl.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/sdtditm.hxx> +#include <editeng/writingmodeitem.hxx> +#include <svx/svdmodel.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/outlobj.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <editeng/adjustitem.hxx> +#include <svx/svdetc.hxx> +#include <editeng/editeng.hxx> +#include <editeng/flditem.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xlnwtit.hxx> + +using namespace com::sun::star; + +namespace sdr::properties +{ + std::unique_ptr<SfxItemSet> TextProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool) + { + return std::make_unique<SfxItemSet>(rPool, + + // range from SdrAttrObj + svl::Items<SDRATTR_START, SDRATTR_SHADOW_LAST, + SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST, + SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, + + // range from SdrTextObj + EE_ITEMS_START, EE_ITEMS_END>{}); + } + + TextProperties::TextProperties(SdrObject& rObj) + : AttributeProperties(rObj), + maVersion(0) + { + } + + TextProperties::TextProperties(const TextProperties& rProps, SdrObject& rObj) + : AttributeProperties(rProps, rObj), + maVersion(rProps.getVersion()) + { + } + + TextProperties::~TextProperties() + { + } + + std::unique_ptr<BaseProperties> TextProperties::Clone(SdrObject& rObj) const + { + return std::unique_ptr<BaseProperties>(new TextProperties(*this, rObj)); + } + + void TextProperties::ItemSetChanged(const SfxItemSet& rSet) + { + SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject()); + + // #i101556# ItemSet has changed -> new version + maVersion++; + + const svx::ITextProvider& rTextProvider(getTextProvider()); + sal_Int32 nText = rTextProvider.getTextCount(); + while (nText--) + { + SdrText* pText = rTextProvider.getText( nText ); + + OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr; + + if(pParaObj) + { + const bool bTextEdit = rObj.IsTextEditActive() && (rObj.getActiveText() == pText); + + // handle outliner attributes + GetObjectItemSet(); + Outliner* pOutliner = rObj.GetTextEditOutliner(); + + if(!bTextEdit) + { + pOutliner = &rObj.ImpGetDrawOutliner(); + pOutliner->SetText(*pParaObj); + } + + sal_Int32 nParaCount(pOutliner->GetParagraphCount()); + + for(sal_Int32 nPara = 0; nPara < nParaCount; nPara++) + { + SfxItemSet aSet(pOutliner->GetParaAttribs(nPara)); + aSet.Put(rSet); + pOutliner->SetParaAttribs(nPara, aSet); + } + + if(!bTextEdit) + { + if(nParaCount) + { + // force ItemSet + GetObjectItemSet(); + + SfxItemSet aNewSet(pOutliner->GetParaAttribs(0)); + mpItemSet->Put(aNewSet); + } + + std::unique_ptr<OutlinerParaObject> pTemp = pOutliner->CreateParaObject(0, nParaCount); + pOutliner->Clear(); + + rObj.NbcSetOutlinerParaObjectForText(std::move(pTemp),pText); + } + } + } + + // Extra-Repaint for radical layout changes (#43139#) + if(SfxItemState::SET == rSet.GetItemState(SDRATTR_TEXT_CONTOURFRAME)) + { + // Here only repaint wanted + rObj.ActionChanged(); + //rObj.BroadcastObjectChange(); + } + + // call parent + AttributeProperties::ItemSetChanged(rSet); + } + + void TextProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem) + { + SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject()); + + // #i25616# + sal_Int32 nOldLineWidth(0); + + if(XATTR_LINEWIDTH == nWhich && rObj.DoesSupportTextIndentingOnLineWidthChange()) + { + nOldLineWidth = GetItem(XATTR_LINEWIDTH).GetValue(); + } + + if(pNewItem && (SDRATTR_TEXTDIRECTION == nWhich)) + { + bool bVertical(css::text::WritingMode_TB_RL == static_cast<const SvxWritingModeItem*>(pNewItem)->GetValue()); + rObj.SetVerticalWriting(bVertical); + } + + // #95501# reset to default + if(!pNewItem && !nWhich && rObj.HasText() ) + { + SdrOutliner& rOutliner = rObj.ImpGetDrawOutliner(); + + const svx::ITextProvider& rTextProvider(getTextProvider()); + sal_Int32 nCount = rTextProvider.getTextCount(); + while (nCount--) + { + SdrText* pText = rTextProvider.getText( nCount ); + OutlinerParaObject* pParaObj = pText->GetOutlinerParaObject(); + if( pParaObj ) + { + rOutliner.SetText(*pParaObj); + sal_Int32 nParaCount(rOutliner.GetParagraphCount()); + + if(nParaCount) + { + ESelection aSelection( 0, 0, EE_PARA_ALL, EE_TEXTPOS_ALL); + rOutliner.RemoveAttribs(aSelection, true, 0); + + std::unique_ptr<OutlinerParaObject> pTemp = rOutliner.CreateParaObject(0, nParaCount); + rOutliner.Clear(); + + rObj.NbcSetOutlinerParaObjectForText( std::move(pTemp), pText ); + } + } + } + } + + // call parent + AttributeProperties::ItemChange( nWhich, pNewItem ); + + // #i25616# + if(XATTR_LINEWIDTH == nWhich && rObj.DoesSupportTextIndentingOnLineWidthChange()) + { + const sal_Int32 nNewLineWidth(GetItem(XATTR_LINEWIDTH).GetValue()); + const sal_Int32 nDifference((nNewLineWidth - nOldLineWidth) / 2); + + if(nDifference) + { + const bool bLineVisible(drawing::LineStyle_NONE != GetItem(XATTR_LINESTYLE).GetValue()); + + if(bLineVisible) + { + const sal_Int32 nLeftDist(GetItem(SDRATTR_TEXT_LEFTDIST).GetValue()); + const sal_Int32 nRightDist(GetItem(SDRATTR_TEXT_RIGHTDIST).GetValue()); + const sal_Int32 nUpperDist(GetItem(SDRATTR_TEXT_UPPERDIST).GetValue()); + const sal_Int32 nLowerDist(GetItem(SDRATTR_TEXT_LOWERDIST).GetValue()); + + SetObjectItemDirect(makeSdrTextLeftDistItem(nLeftDist + nDifference)); + SetObjectItemDirect(makeSdrTextRightDistItem(nRightDist + nDifference)); + SetObjectItemDirect(makeSdrTextUpperDistItem(nUpperDist + nDifference)); + SetObjectItemDirect(makeSdrTextLowerDistItem(nLowerDist + nDifference)); + } + } + } + } + + const svx::ITextProvider& TextProperties::getTextProvider() const + { + return static_cast<const SdrTextObj&>(GetSdrObject()); + } + + void TextProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr) + { + // call parent (always first thing to do, may create the SfxItemSet) + AttributeProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr); + + // #i101556# StyleSheet has changed -> new version + SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject()); + maVersion++; + + if(!rObj.IsLinkedText() ) + { + SdrOutliner& rOutliner = rObj.ImpGetDrawOutliner(); + + const svx::ITextProvider& rTextProvider(getTextProvider()); + sal_Int32 nText = rTextProvider.getTextCount(); + while (nText--) + { + SdrText* pText = rTextProvider.getText( nText ); + + OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr; + if( !pParaObj ) + continue; + + // apply StyleSheet to all paragraphs + rOutliner.SetText(*pParaObj); + sal_Int32 nParaCount(rOutliner.GetParagraphCount()); + + if(nParaCount) + { + for(sal_Int32 nPara = 0; nPara < nParaCount; nPara++) + { + std::unique_ptr<SfxItemSet> pTempSet; + + // since setting the stylesheet removes all para attributes + if(bDontRemoveHardAttr) + { + // we need to remember them if we want to keep them + pTempSet.reset(new SfxItemSet(rOutliner.GetParaAttribs(nPara))); + } + + if(GetStyleSheet()) + { + if((OBJ_OUTLINETEXT == rObj.GetTextKind()) && (SdrInventor::Default == rObj.GetObjInventor())) + { + OUString aNewStyleSheetName(GetStyleSheet()->GetName()); + aNewStyleSheetName = aNewStyleSheetName.copy(0, aNewStyleSheetName.getLength() - 1); + sal_Int16 nDepth = rOutliner.GetDepth(nPara); + aNewStyleSheetName += OUString::number( nDepth <= 0 ? 1 : nDepth + 1); + SfxStyleSheetBasePool* pStylePool(rObj.getSdrModelFromSdrObject().GetStyleSheetPool()); + SfxStyleSheet* pNewStyle = nullptr; + if(pStylePool) + pNewStyle = static_cast<SfxStyleSheet*>(pStylePool->Find(aNewStyleSheetName, GetStyleSheet()->GetFamily())); + DBG_ASSERT( pNewStyle, "AutoStyleSheetName - Style not found!" ); + + if(pNewStyle) + { + rOutliner.SetStyleSheet(nPara, pNewStyle); + } + } + else + { + rOutliner.SetStyleSheet(nPara, GetStyleSheet()); + } + } + else + { + // remove StyleSheet + rOutliner.SetStyleSheet(nPara, nullptr); + } + + if(bDontRemoveHardAttr) + { + if(pTempSet) + { + // restore para attributes + rOutliner.SetParaAttribs(nPara, *pTempSet); + } + } + else + { + if(pNewStyleSheet) + { + // remove all hard paragraph attributes + // which occur in StyleSheet, take care of + // parents (!) + SfxItemIter aIter(pNewStyleSheet->GetItemSet()); + + for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; + pItem = aIter.NextItem()) + { + if(!IsInvalidItem(pItem)) + { + sal_uInt16 nW(pItem->Which()); + + if(nW >= EE_ITEMS_START && nW <= EE_ITEMS_END) + { + rOutliner.RemoveCharAttribs(nPara, nW); + } + } + } + } + } + } + + std::unique_ptr<OutlinerParaObject> pTemp = rOutliner.CreateParaObject(0, nParaCount); + rOutliner.Clear(); + rObj.NbcSetOutlinerParaObjectForText(std::move(pTemp), pText); + } + } + } + + if(rObj.IsTextFrame()) + { + rObj.NbcAdjustTextFrameWidthAndHeight(); + } + } + + void TextProperties::ForceDefaultAttributes() + { + SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject()); + + if( rObj.GetObjInventor() == SdrInventor::Default ) + { + const sal_uInt16 nSdrObjKind = rObj.GetObjIdentifier(); + + if( nSdrObjKind == OBJ_TITLETEXT || nSdrObjKind == OBJ_OUTLINETEXT ) + return; // no defaults for presentation objects + } + + bool bTextFrame(rObj.IsTextFrame()); + + // force ItemSet + GetObjectItemSet(); + + if(bTextFrame) + { + mpItemSet->Put(XLineStyleItem(drawing::LineStyle_NONE)); + mpItemSet->Put(XFillColorItem(OUString(), COL_WHITE)); + mpItemSet->Put(XFillStyleItem(drawing::FillStyle_NONE)); + } + else + { + mpItemSet->Put(SvxAdjustItem(SvxAdjust::Center, EE_PARA_JUST)); + mpItemSet->Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER)); + mpItemSet->Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER)); + } + } + + void TextProperties::ForceStyleToHardAttributes() + { + // #i61284# call parent first to get the hard ObjectItemSet + AttributeProperties::ForceStyleToHardAttributes(); + + // #i61284# push hard ObjectItemSet to OutlinerParaObject attributes + // using existing functionality + GetObjectItemSet(); // force ItemSet + ItemSetChanged(*mpItemSet); + + // now the standard TextProperties stuff + SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject()); + + if(!rObj.IsTextEditActive() && !rObj.IsLinkedText()) + { + std::unique_ptr<Outliner> pOutliner = SdrMakeOutliner(OutlinerMode::OutlineObject, rObj.getSdrModelFromSdrObject()); + const svx::ITextProvider& rTextProvider(getTextProvider()); + sal_Int32 nText = rTextProvider.getTextCount(); + while (nText--) + { + SdrText* pText = rTextProvider.getText( nText ); + + OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr; + if( !pParaObj ) + continue; + + pOutliner->SetText(*pParaObj); + + sal_Int32 nParaCount(pOutliner->GetParagraphCount()); + + if(nParaCount) + { + bool bBurnIn(false); + + for(sal_Int32 nPara = 0; nPara < nParaCount; nPara++) + { + SfxStyleSheet* pSheet = pOutliner->GetStyleSheet(nPara); + + if(pSheet) + { + SfxItemSet aParaSet(pOutliner->GetParaAttribs(nPara)); + SfxItemSet aSet(*aParaSet.GetPool()); + aSet.Put(pSheet->GetItemSet()); + + /** the next code handles a special case for paragraphs that contain a + url field. The color for URL fields is either the system color for + urls or the char color attribute that formats the portion in which the + url field is contained. + When we set a char color attribute to the paragraphs item set from the + styles item set, we would have this char color attribute as an attribute + that is spanned over the complete paragraph after xml import due to some + problems in the xml import (using a XCursor on import so it does not know + the paragraphs and can't set char attributes to paragraphs ). + + To avoid this, as soon as we try to set a char color attribute from the style + we + 1. check if we have at least one url field in this paragraph + 2. if we found at least one url field, we span the char color attribute over + all portions that are not url fields and remove the char color attribute + from the paragraphs item set + */ + + bool bHasURL(false); + + if(aSet.GetItemState(EE_CHAR_COLOR) == SfxItemState::SET) + { + EditEngine* pEditEngine = const_cast<EditEngine*>(&(pOutliner->GetEditEngine())); + std::vector<EECharAttrib> aAttribs; + pEditEngine->GetCharAttribs(nPara, aAttribs); + + for(const auto& rAttrib : aAttribs) + { + if(rAttrib.pAttr && EE_FEATURE_FIELD == rAttrib.pAttr->Which()) + { + const SvxFieldItem* pFieldItem = static_cast<const SvxFieldItem*>(rAttrib.pAttr); + + if(pFieldItem) + { + const SvxFieldData* pData = pFieldItem->GetField(); + + if(dynamic_cast<const SvxURLField*>( pData)) + { + bHasURL = true; + break; + } + } + } + } + + if(bHasURL) + { + SfxItemSet aColorSet(*aSet.GetPool(), svl::Items<EE_CHAR_COLOR, EE_CHAR_COLOR>{} ); + aColorSet.Put(aSet, false); + + ESelection aSel(nPara, 0); + + for(const auto& rAttrib : aAttribs) + { + if(EE_FEATURE_FIELD == rAttrib.pAttr->Which()) + { + aSel.nEndPos = rAttrib.nStart; + + if(aSel.nStartPos != aSel.nEndPos) + pEditEngine->QuickSetAttribs(aColorSet, aSel); + + aSel.nStartPos = rAttrib.nEnd; + } + } + + aSel.nEndPos = pEditEngine->GetTextLen(nPara); + + if(aSel.nStartPos != aSel.nEndPos) + { + pEditEngine->QuickSetAttribs( aColorSet, aSel ); + } + } + + } + + aSet.Put(aParaSet, false); + + if(bHasURL) + { + aSet.ClearItem(EE_CHAR_COLOR); + } + + pOutliner->SetParaAttribs(nPara, aSet); + bBurnIn = true; // #i51163# Flag was set wrong + } + } + + if(bBurnIn) + { + std::unique_ptr<OutlinerParaObject> pTemp = pOutliner->CreateParaObject(0, nParaCount); + rObj.NbcSetOutlinerParaObjectForText(std::move(pTemp),pText); + } + } + + pOutliner->Clear(); + } + } + } + + void TextProperties::SetObjectItemNoBroadcast(const SfxPoolItem& rItem) + { + GetObjectItemSet(); + mpItemSet->Put(rItem); + } + + + void TextProperties::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) + { + // call parent + AttributeProperties::Notify(rBC, rHint); + + SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject()); + if(rObj.HasText()) + { + const svx::ITextProvider& rTextProvider(getTextProvider()); + if(dynamic_cast<const SfxStyleSheet *>(&rBC) != nullptr) + { + SfxHintId nId(rHint.GetId()); + + if(SfxHintId::DataChanged == nId) + { + sal_Int32 nText = rTextProvider.getTextCount(); + while (nText--) + { + OutlinerParaObject* pParaObj = rTextProvider.getText( nText )->GetOutlinerParaObject(); + if( pParaObj ) + pParaObj->ClearPortionInfo(); + } + rObj.SetTextSizeDirty(); + + if(rObj.IsTextFrame() && rObj.NbcAdjustTextFrameWidthAndHeight()) + { + // here only repaint wanted + rObj.ActionChanged(); + //rObj.BroadcastObjectChange(); + } + + // #i101556# content of StyleSheet has changed -> new version + maVersion++; + } + + if(SfxHintId::Dying == nId) + { + sal_Int32 nText = rTextProvider.getTextCount(); + while (nText--) + { + OutlinerParaObject* pParaObj = rTextProvider.getText( nText )->GetOutlinerParaObject(); + if( pParaObj ) + pParaObj->ClearPortionInfo(); + } + } + } + else if(dynamic_cast<const SfxStyleSheetBasePool *>(&rBC) != nullptr) + { + const SfxStyleSheetModifiedHint* pExtendedHint = dynamic_cast<const SfxStyleSheetModifiedHint*>(&rHint); + + if(pExtendedHint + && SfxHintId::StyleSheetModified == pExtendedHint->GetId()) + { + const OUString& aOldName(pExtendedHint->GetOldName()); + OUString aNewName(pExtendedHint->GetStyleSheet()->GetName()); + SfxStyleFamily eFamily = pExtendedHint->GetStyleSheet()->GetFamily(); + + if(aOldName != aNewName) + { + sal_Int32 nText = rTextProvider.getTextCount(); + while (nText--) + { + OutlinerParaObject* pParaObj = rTextProvider.getText( nText )->GetOutlinerParaObject(); + if( pParaObj ) + pParaObj->ChangeStyleSheetName(eFamily, aOldName, aNewName); + } + } + } + } + } + } + + // #i101556# Handout version information + sal_uInt32 TextProperties::getVersion() const + { + return maVersion; + } +} // end of namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |