| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_slideshow.hxx" |
| |
| #include <canvas/debug.hxx> |
| #include <tools/diagnose_ex.h> |
| #include "clippingfunctor.hxx" |
| #include "transitiontools.hxx" |
| |
| #include <basegfx/polygon/b2dpolypolygoncutter.hxx> |
| #include <basegfx/polygon/b2dpolygonclipper.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <basegfx/polygon/b2dpolypolygoncutter.hxx> |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> |
| |
| namespace slideshow |
| { |
| namespace internal |
| { |
| ClippingFunctor::ClippingFunctor(const ParametricPolyPolygonSharedPtr& rPolygon, |
| const TransitionInfo& rTransitionInfo, |
| bool bDirectionForward, |
| bool bModeIn ) : |
| mpParametricPoly( rPolygon ), |
| maStaticTransformation(), |
| // AW: Not needed |
| // maBackgroundRect( createUnitRect() ), |
| mbForwardParameterSweep( true ), |
| mbSubtractPolygon( false ), |
| mbScaleIsotrophically( rTransitionInfo.mbScaleIsotrophically ), |
| mbFlip(false) |
| { |
| ENSURE_OR_THROW( rPolygon, |
| "ClippingFunctor::ClippingFunctor(): Invalid parametric polygon" ); |
| |
| // maBackgroundRect serves as the minuent when |
| // subtracting a given clip polygon from the |
| // background. To speed up the clipper algo, avoid |
| // actual intersections of the generated |
| // poly-polygon with the minuent - i.e. choose the |
| // polygon to subtract from sufficiently large. |
| |
| // blow up unit rect to (-1,-1),(2,2) |
| // AW: Not needed, just use range |
| // ::basegfx::B2DHomMatrix aMatrix; |
| // aMatrix.scale(3.0,3.0); |
| // aMatrix.translate(-1.0,-1.0); |
| // maBackgroundRect.transform( aMatrix ); |
| |
| // extract modification info from maTransitionInfo |
| // ----------------------------------------------- |
| |
| // perform general transformations _before_ the reverse |
| // mode changes. This allows the Transition table to be |
| // filled more constitently (otherwise, when e.g. rotating |
| // a clip 90 degrees, the REVERSEMETHOD_FLIP_X becomes |
| // REVERSEMETHOD_FLIP_Y instead) |
| if (rTransitionInfo.mnRotationAngle != 0.0 || |
| rTransitionInfo.mnScaleX != 1.0 || |
| rTransitionInfo.mnScaleY != 1.0) |
| { |
| maStaticTransformation.translate( -0.5, -0.5 ); |
| // apply further transformations: |
| if (rTransitionInfo.mnRotationAngle != 0.0) |
| { |
| maStaticTransformation.rotate( |
| basegfx::deg2rad(rTransitionInfo.mnRotationAngle) ); |
| } |
| if (rTransitionInfo.mnScaleX != 1.0 || |
| rTransitionInfo.mnScaleY != 1.0) |
| { |
| maStaticTransformation.scale( |
| rTransitionInfo.mnScaleX, |
| rTransitionInfo.mnScaleY ); |
| } |
| maStaticTransformation.translate( 0.5, 0.5 ); |
| } |
| |
| if( !bDirectionForward ) |
| { |
| // Client has requested reversed |
| // direction. Apply TransitionInfo's choice |
| // for that |
| switch( rTransitionInfo.meReverseMethod ) |
| { |
| default: |
| ENSURE_OR_THROW( |
| false, |
| "TransitionFactory::TransitionFactory(): Unexpected reverse method" ); |
| break; |
| |
| case TransitionInfo::REVERSEMETHOD_IGNORE: |
| break; |
| |
| case TransitionInfo::REVERSEMETHOD_INVERT_SWEEP: |
| mbForwardParameterSweep = !mbForwardParameterSweep; |
| break; |
| |
| case TransitionInfo::REVERSEMETHOD_SUBTRACT_POLYGON: |
| mbSubtractPolygon = !mbSubtractPolygon; |
| break; |
| |
| case TransitionInfo::REVERSEMETHOD_SUBTRACT_AND_INVERT: |
| mbForwardParameterSweep = !mbForwardParameterSweep; |
| mbSubtractPolygon = !mbSubtractPolygon; |
| break; |
| |
| case TransitionInfo::REVERSEMETHOD_ROTATE_180: |
| maStaticTransformation = basegfx::tools::createRotateAroundPoint(0.5, 0.5, M_PI) |
| * maStaticTransformation; |
| break; |
| |
| case TransitionInfo::REVERSEMETHOD_FLIP_X: |
| maStaticTransformation = basegfx::tools::createScaleTranslateB2DHomMatrix(-1.0, 1.0, 1.0, 0.0) |
| * maStaticTransformation; |
| mbFlip = true; |
| break; |
| |
| case TransitionInfo::REVERSEMETHOD_FLIP_Y: |
| maStaticTransformation = basegfx::tools::createScaleTranslateB2DHomMatrix(1.0, -1.0, 0.0, 1.0) |
| * maStaticTransformation; |
| mbFlip = true; |
| break; |
| } |
| } |
| |
| if( !bModeIn ) |
| { |
| // client has requested 'out' mode. Apply |
| // TransitionInfo's method of choice |
| if( rTransitionInfo.mbOutInvertsSweep ) |
| mbForwardParameterSweep = !mbForwardParameterSweep; |
| else |
| mbSubtractPolygon = !mbSubtractPolygon; |
| } |
| } |
| |
| ::basegfx::B2DPolyPolygon ClippingFunctor::operator()( double nValue, |
| const ::basegfx::B2DSize& rTargetSize ) |
| { |
| // modify clip polygon according to static |
| // transformation plus current shape size |
| ::basegfx::B2DHomMatrix aMatrix( maStaticTransformation ); |
| |
| // retrieve current clip polygon |
| ::basegfx::B2DPolyPolygon aClipPoly = (*mpParametricPoly)( |
| mbForwardParameterSweep ? nValue : 1.0 - nValue ); |
| |
| // TODO(Q4): workaround here, better be fixed in cppcanvas |
| if (aClipPoly.count() == 0) |
| aClipPoly.append( basegfx::B2DPolygon() ); |
| |
| if (mbFlip) |
| aClipPoly.flip(); |
| |
| // currently, clipper cannot cope with curves. Subdivide first |
| // AW: Should be no longer necessary; clipping tools are now bezier-safe |
| // if( aClipPoly.areControlPointsUsed() ) |
| // aClipPoly = ::basegfx::tools::adaptiveSubdivideByAngle(aClipPoly); |
| |
| if( mbSubtractPolygon ) |
| { |
| // subtract given polygon from background |
| // rect. Do that before any transformations. |
| |
| // calc maBackgroundRect \ aClipPoly |
| // ================================= |
| |
| // AW: Simplified |
| // use a range with fixed size (-1,-1),(2,2) |
| const basegfx::B2DRange aBackgroundRange(-1, -1, 2, 2); |
| const basegfx::B2DRange aClipPolyRange(aClipPoly.getB2DRange()); |
| |
| if(aBackgroundRange.isInside(aClipPolyRange)) |
| { |
| // combine polygons; make the clip polygon the hole |
| aClipPoly = ::basegfx::tools::correctOrientations(aClipPoly); |
| aClipPoly.flip(); |
| aClipPoly.insert(0, basegfx::tools::createPolygonFromRect(aBackgroundRange)); |
| } |
| else |
| { |
| // when not completely inside aBackgroundRange clipping is needed |
| // substract aClipPoly from aBackgroundRange |
| const basegfx::B2DPolyPolygon aBackgroundPolyPoly(basegfx::tools::createPolygonFromRect(aBackgroundRange)); |
| aClipPoly = basegfx::tools::solvePolygonOperationDiff(aBackgroundPolyPoly, aClipPoly); |
| } |
| } |
| |
| // scale polygon up to current shape size |
| if( mbScaleIsotrophically ) |
| { |
| const double nScale( ::std::max( rTargetSize.getX(), |
| rTargetSize.getY() ) ); |
| aMatrix.scale( nScale, nScale ); |
| aMatrix.translate( -(nScale-rTargetSize.getX())/2.0, |
| -(nScale-rTargetSize.getY())/2.0 ); |
| } |
| else |
| { |
| aMatrix.scale( rTargetSize.getX(), |
| rTargetSize.getY() ); |
| } |
| |
| // apply cumulative transformation to clip polygon |
| aClipPoly.transform( aMatrix ); |
| |
| return aClipPoly; |
| } |
| |
| } |
| } |
