summaryrefslogtreecommitdiff
path: root/svx/source/sdr/contact/viewobjectcontact.cxx
blob: 479d09d50f6311585c170d1cd87493c8f6daf9f1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
/* -*- 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 <vcl/region.hxx>
#include <svx/sdr/animation/objectanimator.hxx>
#include <svx/sdr/animation/animationstate.hxx>
#include <svx/sdr/contact/viewobjectcontactredirector.hxx>
#include <basegfx/numeric/ftools.hxx>
#include <basegfx/color/bcolor.hxx>
#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
#include <basegfx/tools/canvastools.hxx>
#include <drawinglayer/primitive2d/animatedprimitive2d.hxx>
#include <drawinglayer/processor2d/baseprocessor2d.hxx>
#include <svx/sdr/primitive2d/svx_primitivetypes2d.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::Primitive2DSequence  maPrimitive2DSequence;

        // bitfield
        // text animation allowed?
        unsigned                                        mbTextAnimationAllowed : 1;

        // graphic animation allowed?
        unsigned                                        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);

    public:
        AnimatedExtractingProcessor2D(
            const drawinglayer::geometry::ViewInformation2D& rViewInformation,
            bool bTextAnimationAllowed,
            bool bGraphicAnimationAllowed);
        virtual ~AnimatedExtractingProcessor2D();

        // data access
        const drawinglayer::primitive2d::Primitive2DSequence& getPrimitive2DSequence() const { return maPrimitive2DSequence; }
        bool isTextAnimationAllowed() const { return mbTextAnimationAllowed; }
        bool isGraphicAnimationAllowed() const { return mbGraphicAnimationAllowed; }
    };

    AnimatedExtractingProcessor2D::AnimatedExtractingProcessor2D(
        const drawinglayer::geometry::ViewInformation2D& rViewInformation,
        bool bTextAnimationAllowed,
        bool bGraphicAnimationAllowed)
    :   drawinglayer::processor2d::BaseProcessor2D(rViewInformation),
        maPrimitive2DSequence(),
        mbTextAnimationAllowed(bTextAnimationAllowed),
        mbGraphicAnimationAllowed(bGraphicAnimationAllowed)
    {
    }

    AnimatedExtractingProcessor2D::~AnimatedExtractingProcessor2D()
    {
    }

    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() && isTextAnimationAllowed())
                    || (rSwitchPrimitive.isGraphicAnimation() && isGraphicAnimationAllowed()))
                {
                    const drawinglayer::primitive2d::Primitive2DReference xReference(const_cast< drawinglayer::primitive2d::BasePrimitive2D* >(&rCandidate));
                    drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(maPrimitive2DSequence, 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 :

            // decompose evtl. animated text contained in MaskPrimitive2D
            // or group rimitives
            case PRIMITIVE2D_ID_MASKPRIMITIVE2D :
            case PRIMITIVE2D_ID_GROUPPRIMITIVE2D :
            {
                process(rCandidate.get2DDecomposition(getViewInformation2D()));
                break;
            }

            default :
            {
                // nothing to do for the rest
                break;
            }
        }
    }
} // end of anonymous namespace

//////////////////////////////////////////////////////////////////////////////

namespace sdr
{
    namespace contact
    {
        ViewObjectContact::ViewObjectContact(ObjectContact& rObjectContact, ViewContact& rViewContact)
        :   mrObjectContact(rObjectContact),
            mrViewContact(rViewContact),
            maObjectRange(),
            mxPrimitive2DSequence(),
            mpPrimitiveAnimation(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
            if(mpPrimitiveAnimation)
            {
                delete mpPrimitiveAnimation;
                mpPrimitiveAnimation = 0;
            }

            // take care of remebered ObjectContact. Remove from
            // OC first. The VC removal (below) CAN trigger a StopGettingViewed()
            // which (depending of it's 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 remebered ViewContact
            GetViewContact().RemoveViewObjectContact(*this);
        }

        const basegfx::B2DRange& ViewObjectContact::getObjectRange() const
        {
            if(maObjectRange.isEmpty())
            {
                // if range is not computed (new or LazyInvalidate objects), force it
                const DisplayInfo aDisplayInfo;
                const drawinglayer::primitive2d::Primitive2DSequence xSequence(getPrimitive2DSequence(aDisplayInfo));

                if(xSequence.hasElements())
                {
                    const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D());
                    const_cast< ViewObjectContact* >(this)->maObjectRange =
                        drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xSequence, rViewInformation2D);
                }
            }

            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
            if(mpPrimitiveAnimation)
            {
                delete mpPrimitiveAnimation;
                mpPrimitiveAnimation = 0;
            }

            // check for animated primitives
            if(mxPrimitive2DSequence.hasElements())
            {
                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().hasElements())
                    {
                        // dervied primitiveList is animated, setup new PrimitiveAnimation
                        mpPrimitiveAnimation =  new sdr::animation::PrimitiveAnimation(*this, aAnimatedExtractor.getPrimitive2DSequence());
                    }
                }
            }
        }

        drawinglayer::primitive2d::Primitive2DSequence ViewObjectContact::createPrimitive2DSequence(const DisplayInfo& rDisplayInfo) const
        {
            // get the view-independent Primitive from the viewContact
            drawinglayer::primitive2d::Primitive2DSequence xRetval(GetViewContact().getViewIndependentPrimitive2DSequence());

            if(xRetval.hasElements())
            {
                // handle GluePoint
                if(!GetObjectContact().isOutputToPrinter() && GetObjectContact().AreGluePointsVisible())
                {
                    const drawinglayer::primitive2d::Primitive2DSequence xGlue(GetViewContact().createGluePointPrimitive2DSequence());

                    if(xGlue.hasElements())
                    {
                        drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(xRetval, xGlue);
                    }
                }

                // handle ghosted
                if(isPrimitiveGhosted(rDisplayInfo))
                {
                    const basegfx::BColor aRGBWhite(1.0, 1.0, 1.0);
                    const basegfx::BColorModifier aBColorModifier(aRGBWhite, 0.5, basegfx::BCOLORMODIFYMODE_INTERPOLATE);
                    const drawinglayer::primitive2d::Primitive2DReference xReference(new drawinglayer::primitive2d::ModifiedColorPrimitive2D(xRetval, aBColorModifier));
                    xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xReference, 1);
                }
            }

            return xRetval;
        }

        drawinglayer::primitive2d::Primitive2DSequence ViewObjectContact::getPrimitive2DSequence(const DisplayInfo& rDisplayInfo) const
        {
            drawinglayer::primitive2d::Primitive2DSequence 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(!drawinglayer::primitive2d::arePrimitive2DSequencesEqual(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 =
                    drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(mxPrimitive2DSequence, rViewInformation2D);
            }

            // return current Primitive2DSequence
            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::Primitive2DSequence ViewObjectContact::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const
        {
            drawinglayer::primitive2d::Primitive2DSequence xRetval;

            // check model-view visibility
            if(isPrimitiveVisible(rDisplayInfo))
            {
                xRetval = getPrimitive2DSequence(rDisplayInfo);

                if(xRetval.hasElements())
                {
                    // get ranges
                    const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D());
                    const basegfx::B2DRange aObjectRange(drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xRetval, rViewInformation2D));
                    const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport());

                    // check geometrical visibility
                    if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange))
                    {
                        // not visible, release
                        xRetval.realloc(0);
                    }
                }
            }

            return xRetval;
        }

        drawinglayer::primitive2d::Primitive2DSequence ViewObjectContact::getPrimitive2DSequenceSubHierarchy(DisplayInfo& rDisplayInfo) const
        {
            const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount());
            drawinglayer::primitive2d::Primitive2DSequence xSeqRetval;

            for(sal_uInt32 a(0); a < nSubHierarchyCount; a++)
            {
                const ViewObjectContact& rCandidate(GetViewContact().GetViewContact(a).GetViewObjectContact(GetObjectContact()));

                drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(xSeqRetval, rCandidate.getPrimitive2DSequenceHierarchy(rDisplayInfo));
            }

            return xSeqRetval;
        }
    } // end of namespace contact
} // end of namespace sdr

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */