You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by al...@apache.org on 2013/10/04 19:20:26 UTC
svn commit: r1529226 [2/4] - in /openoffice/branches/alg/aw080/main:
basegfx/inc/basegfx/matrix/ basegfx/source/matrix/ filter/source/msfilter/
offapi/com/sun/star/drawing/ sd/inc/pch/ sd/source/ui/dlg/
sd/source/ui/func/ sd/source/ui/inc/ sd/source/ui...
Added: openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrglue.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrglue.cxx?rev=1529226&view=auto
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrglue.cxx (added)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrglue.cxx Fri Oct 4 17:20:25 2013
@@ -0,0 +1,554 @@
+/**************************************************************
+ *
+ * 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_svx.hxx"
+
+#include <svx/sdrglue.hxx>
+#include <basegfx/range/b2drange.hxx>
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace sdr
+{
+ namespace glue
+ {
+ Point::Point(
+ const basegfx::B2DPoint& rUnitPosition,
+ sal_uInt16 eEscapeDirections,
+ Alignment eHorizontalAlignment,
+ Alignment eVerticalAlignment,
+ bool bRelative,
+ bool bUserDefined)
+ : maUnitPosition(basegfx::B2DRange::getUnitB2DRange().clamp(rUnitPosition)),
+ meEscapeDirections(eEscapeDirections),
+ meHorizontalAlignment(eHorizontalAlignment),
+ meVerticalAlignment(eVerticalAlignment),
+ maID(0),
+ mbRelative(bRelative),
+ mbUserDefined(bUserDefined)
+ {
+ }
+
+ basegfx::B2DPoint Point::getUnitPosition() const
+ {
+ return basegfx::B2DRange::getUnitB2DRange().clamp(maUnitPosition);
+ }
+
+ void Point::setUnitPosition(const basegfx::B2DPoint& rNew)
+ {
+ const basegfx::B2DPoint aClampedNew(basegfx::B2DRange::getUnitB2DRange().clamp(rNew));
+
+ if(aClampedNew != maUnitPosition)
+ {
+ maUnitPosition = aClampedNew;
+ }
+ }
+
+ void Point::setRelative(bool bNew)
+ {
+ if(mbRelative != bNew)
+ {
+ mbRelative = bNew;
+
+ if(mbRelative)
+ {
+ // truncate UnitPosition when switching off; the non-relative mode allows
+ // values outside the UnitRange to represent positions moving outside the
+ // range
+ maUnitPosition = basegfx::B2DRange::getUnitB2DRange().clamp(maUnitPosition);
+ }
+ }
+ }
+
+ void Point::adaptToChangedScale(const basegfx::B2DVector& rOldScale, const basegfx::B2DVector& rNewScale)
+ {
+ if(!getRelative())
+ {
+ const bool bChangeX(!basegfx::fTools::equal(rOldScale.getX(), rNewScale.getX()));
+ const bool bChangeY(!basegfx::fTools::equal(rOldScale.getY(), rNewScale.getY()));
+
+ if(bChangeX || bChangeY)
+ {
+ // do not use getUnitPosition() here, we do not want to clamp the value
+ basegfx::B2DPoint aChangedPos(maUnitPosition);
+
+ if(bChangeX)
+ {
+ // avoid using values below 1.0 when working with relative scales; thus even the
+ // values outside the unit range will be preserved
+ const double fCorrectedOldX(std::max(1.0, rOldScale.getX()));
+ const double fCorrectedNewX(std::max(1.0, rNewScale.getX()));
+
+ switch(getHorizontalAlignment())
+ {
+ case Point::Alignment_Minimum:
+ {
+ // anchored left
+ aChangedPos.setX((aChangedPos.getX() * fCorrectedOldX) / fCorrectedNewX);
+ break;
+ }
+ case Point::Alignment_Center:
+ {
+ aChangedPos.setX(((0.5 * fCorrectedNewX) + (fCorrectedOldX * (aChangedPos.getX() - 0.5))) / fCorrectedNewX);
+ break;
+ }
+ default: // case Point::Alignment_Maximum:
+ {
+ aChangedPos.setX((fCorrectedNewX - (fCorrectedOldX * (1.0 - aChangedPos.getX()))) / fCorrectedNewX);
+ break;
+ }
+ }
+ }
+
+ if(bChangeY)
+ {
+ // avoid using values below 1.0 when working with relative scales; thus even the
+ // values outside the unit range will be preserved
+ const double fCorrectedOldY(std::max(1.0, rOldScale.getY()));
+ const double fCorrectedNewY(std::max(1.0, rNewScale.getY()));
+
+ switch(getVerticalAlignment())
+ {
+ case Point::Alignment_Minimum:
+ {
+ // anchored left
+ aChangedPos.setY((aChangedPos.getY() * fCorrectedOldY) / fCorrectedNewY);
+ break;
+ }
+ case Point::Alignment_Center:
+ {
+ aChangedPos.setY(((0.5 * fCorrectedNewY) + (fCorrectedOldY * (aChangedPos.getY() - 0.5))) / fCorrectedNewY);
+ break;
+ }
+ default: // case Point::Alignment_Maximum:
+ {
+ aChangedPos.setY((fCorrectedNewY - (fCorrectedOldY * (1.0 - aChangedPos.getY()))) / fCorrectedNewY);
+ break;
+ }
+ }
+ }
+
+ if(!aChangedPos.equal(maUnitPosition))
+ {
+ // do not use setUnitPosition() here, we do not want to clamp the value
+ maUnitPosition = aChangedPos;
+ }
+ }
+ }
+ }
+
+ com::sun::star::drawing::GluePoint2 Point::convertToGluePoint2(const basegfx::B2DVector& rAbsoluteScale) const
+ {
+ com::sun::star::drawing::GluePoint2 aRetval;
+
+ // copy UserDefined
+ aRetval.IsUserDefined = getUserDefined();
+
+ // copy relative
+ aRetval.IsRelative = getRelative();
+
+ // copy position; get maUnitPosition directly, we do not want to crop here
+ double fX(maUnitPosition.getX());
+ double fY(maUnitPosition.getY());
+
+ switch(getHorizontalAlignment())
+ {
+ case Alignment_Minimum: break;
+ case Alignment_Center: fX = fX - 0.5; break;
+ case Alignment_Maximum: fX = fX - 1.0; break;
+ }
+
+ switch(getVerticalAlignment())
+ {
+ case Alignment_Minimum: break;
+ case Alignment_Center: fY = fY - 0.5; break;
+ case Alignment_Maximum: fY = fY - 1.0; break;
+ }
+
+ if(aRetval.IsRelative)
+ {
+ fX *= 10000.0;
+ fY *= 10000.0;
+ }
+ else
+ {
+ // avoid values below 1.0 to not lose relative values outside object scale
+ fX *= std::max(1.0, rAbsoluteScale.getX());
+ fY *= std::max(1.0, rAbsoluteScale.getY());
+ }
+
+ aRetval.Position.X = basegfx::fround(fX);
+ aRetval.Position.Y = basegfx::fround(fY);
+
+ // copy alignment
+ switch(getHorizontalAlignment())
+ {
+ case Alignment_Minimum:
+ switch(getVerticalAlignment())
+ {
+ case Alignment_Minimum:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_TOP_LEFT;
+ break;
+ case Alignment_Maximum:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_BOTTOM_LEFT;
+ break;
+ default:
+ case Alignment_Center:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_LEFT;
+ break;
+ }
+ break;
+ case Alignment_Maximum:
+ switch(getVerticalAlignment())
+ {
+ case Alignment_Minimum:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_TOP_RIGHT;
+ break;
+ case Alignment_Maximum:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_BOTTOM_RIGHT;
+ break;
+ default:
+ case Alignment_Center:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_RIGHT;
+ break;
+ }
+ break;
+ default:
+ case Alignment_Center:
+ switch(getVerticalAlignment())
+ {
+ case Alignment_Minimum:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_TOP;
+ break;
+ case Alignment_Maximum:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_BOTTOM;
+ break;
+ default:
+ case Alignment_Center:
+ aRetval.PositionAlignment = com::sun::star::drawing::Alignment_CENTER;
+ break;
+ }
+ break;
+ }
+
+ // copy escape directions
+ switch( getEscapeDirections() )
+ {
+ case ESCAPE_DIRECTION_LEFT:
+ aRetval.Escape = com::sun::star::drawing::EscapeDirection_LEFT;
+ break;
+ case ESCAPE_DIRECTION_RIGHT:
+ aRetval.Escape = com::sun::star::drawing::EscapeDirection_RIGHT;
+ break;
+ case ESCAPE_DIRECTION_TOP:
+ aRetval.Escape = com::sun::star::drawing::EscapeDirection_UP;
+ break;
+ case ESCAPE_DIRECTION_BOTTOM:
+ aRetval.Escape = com::sun::star::drawing::EscapeDirection_DOWN;
+ break;
+ case ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_RIGHT:
+ aRetval.Escape = com::sun::star::drawing::EscapeDirection_HORIZONTAL;
+ break;
+ case ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_BOTTOM:
+ aRetval.Escape = com::sun::star::drawing::EscapeDirection_VERTICAL;
+ break;
+
+ // Unfortunately the enum EscapeDirection in the EscapeDirection.idl definition
+ // is wrong in the sense that it does not reflect the possibility to define a free
+ // combination of the directions left/right/up/down from which the router may choose
+ // the best. Below (and in the idl file) are suggestions how this could be expanded,
+ // but it would be incompatible
+ //
+ //case ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_TOP:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_LEFTUP;
+ // break;
+ //case ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_RIGHT:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_UPRIGHT;
+ // break;
+ //case ESCAPE_DIRECTION_RIGHT|ESCAPE_DIRECTION_BOTTOM:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_RIGHTDOWN;
+ // break;
+ //case ESCAPE_DIRECTION_BOTTOM|ESCAPE_DIRECTION_LEFT:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_DOWNLEFT;
+ // break;
+ //case ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_RIGHT:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_UPWARD;
+ // break;
+ //case ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_RIGHT|ESCAPE_DIRECTION_DOWN:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_RIGHTWARD;
+ // break;
+ //case ESCAPE_DIRECTION_RIGHT|ESCAPE_DIRECTION_DOWN|ESCAPE_DIRECTION_LEFT:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_DOWNWARD;
+ // break;
+ //case ESCAPE_DIRECTION_DOWN|ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_UP:
+ // aRetval.Escape = com::sun::star::drawing::EscapeDirection_LEFTWARD;
+ // break;
+ default:
+ case ESCAPE_DIRECTION_SMART:
+ aRetval.Escape = com::sun::star::drawing::EscapeDirection_SMART;
+ break;
+ }
+
+ return aRetval;
+ }
+
+ Point::Point(
+ const com::sun::star::drawing::GluePoint2& rGluePoint2,
+ const basegfx::B2DVector& rAbsoluteScale)
+ : maUnitPosition(0.5, 0.5),
+ meEscapeDirections(ESCAPE_DIRECTION_SMART),
+ meHorizontalAlignment(Alignment_Center),
+ meVerticalAlignment(Alignment_Center),
+ maID(0),
+ mbRelative(rGluePoint2.IsRelative), // copy relative
+ mbUserDefined(rGluePoint2.IsUserDefined) // copy UserDefined
+ {
+ // copy alignment
+ switch( rGluePoint2.PositionAlignment )
+ {
+ case com::sun::star::drawing::Alignment_TOP_LEFT:
+ meHorizontalAlignment = Alignment_Minimum;
+ meVerticalAlignment = Alignment_Minimum;
+ break;
+ case com::sun::star::drawing::Alignment_TOP:
+ meHorizontalAlignment = Alignment_Center;
+ meVerticalAlignment = Alignment_Minimum;
+ break;
+ case com::sun::star::drawing::Alignment_TOP_RIGHT:
+ meHorizontalAlignment = Alignment_Maximum;
+ meVerticalAlignment = Alignment_Minimum;
+ break;
+ case com::sun::star::drawing::Alignment_RIGHT:
+ meHorizontalAlignment = Alignment_Maximum;
+ meVerticalAlignment = Alignment_Center;
+ break;
+ case com::sun::star::drawing::Alignment_BOTTOM_LEFT:
+ meHorizontalAlignment = Alignment_Minimum;
+ meVerticalAlignment = Alignment_Maximum;
+ break;
+ case com::sun::star::drawing::Alignment_BOTTOM:
+ meHorizontalAlignment = Alignment_Center;
+ meVerticalAlignment = Alignment_Maximum;
+ break;
+ case com::sun::star::drawing::Alignment_BOTTOM_RIGHT:
+ meHorizontalAlignment = Alignment_Maximum;
+ meVerticalAlignment = Alignment_Maximum;
+ break;
+ case com::sun::star::drawing::Alignment_LEFT:
+ meHorizontalAlignment = Alignment_Minimum;
+ meVerticalAlignment = Alignment_Center;
+ break;
+ default:
+ case com::sun::star::drawing::Alignment_CENTER:
+ meHorizontalAlignment = Alignment_Center;
+ meVerticalAlignment = Alignment_Center;
+ break;
+ }
+
+ // copy position (after alignment is computed)
+ double fX(rGluePoint2.Position.X);
+ double fY(rGluePoint2.Position.Y);
+
+ if(mbRelative)
+ {
+ fX /= 10000.0;
+ fY /= 10000.0;
+ }
+ else
+ {
+ // avoid values below 1.0 to not lose relative values outside object scale
+ fX /= std::max(1.0, rAbsoluteScale.getX());
+ fY /= std::max(1.0, rAbsoluteScale.getY());
+ }
+
+ switch(meHorizontalAlignment)
+ {
+ case Alignment_Minimum: break;
+ case Alignment_Center: fX = fX + 0.5; break;
+ case Alignment_Maximum: fX = fX + 1.0; break;
+ }
+
+ switch(meVerticalAlignment)
+ {
+ case Alignment_Minimum: break;
+ case Alignment_Center: fY = fY + 0.5; break;
+ case Alignment_Maximum: fY = fY + 1.0; break;
+ }
+
+ maUnitPosition = basegfx::B2DPoint(fX, fY);
+
+ // copy escape directions
+ switch( rGluePoint2.Escape )
+ {
+ case com::sun::star::drawing::EscapeDirection_LEFT:
+ meEscapeDirections = ESCAPE_DIRECTION_LEFT;
+ break;
+ case com::sun::star::drawing::EscapeDirection_RIGHT:
+ meEscapeDirections = ESCAPE_DIRECTION_RIGHT;
+ break;
+ case com::sun::star::drawing::EscapeDirection_UP:
+ meEscapeDirections = ESCAPE_DIRECTION_TOP;
+ break;
+ case com::sun::star::drawing::EscapeDirection_DOWN:
+ meEscapeDirections = ESCAPE_DIRECTION_BOTTOM;
+ break;
+ case com::sun::star::drawing::EscapeDirection_HORIZONTAL:
+ meEscapeDirections = ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_RIGHT;
+ break;
+ case com::sun::star::drawing::EscapeDirection_VERTICAL:
+ meEscapeDirections = ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_BOTTOM;
+ break;
+
+ // Unfortunately the enum EscapeDirection in the EscapeDirection.idl definition
+ // is wrong in the sense that it does not reflect the possibility to define a free
+ // combination of the directions left/right/up/down from which the router may choose
+ // the best. Below (and in the idl file) are suggestions how this could be expanded,
+ // but it would be incompatible
+ //
+ //case com::sun::star::drawing::EscapeDirection_LEFTUP:
+ // meEscapeDirections = ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_TOP;
+ // break;
+ //case com::sun::star::drawing::EscapeDirection_UPRIGHT:
+ // meEscapeDirections = ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_RIGHT;
+ // break;
+ //case com::sun::star::drawing::EscapeDirection_RIGHTDOWN:
+ // meEscapeDirections = ESCAPE_DIRECTION_RIGHT|ESCAPE_DIRECTION_BOTTOM;
+ // break;
+ //case com::sun::star::drawing::EscapeDirection_DOWNLEFT:
+ // meEscapeDirections = ESCAPE_DIRECTION_BOTTOM|ESCAPE_DIRECTION_LEFT;
+ // break;
+ //case com::sun::star::drawing::EscapeDirection_UPWARD:
+ // meEscapeDirections = ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_RIGHT;
+ // break;
+ //case com::sun::star::drawing::EscapeDirection_RIGHTWARD:
+ // meEscapeDirections = ESCAPE_DIRECTION_TOP|ESCAPE_DIRECTION_RIGHT|ESCAPE_DIRECTION_BOTTOM;
+ // break;
+ //case com::sun::star::drawing::EscapeDirection_DOWNWARD:
+ // meEscapeDirections = ESCAPE_DIRECTION_RIGHT|ESCAPE_DIRECTION_BOTTOM|ESCAPE_DIRECTION_LEFT;
+ // break;
+ //case com::sun::star::drawing::EscapeDirection_LEFTWARD:
+ // meEscapeDirections = ESCAPE_DIRECTION_BOTTOM|ESCAPE_DIRECTION_LEFT|ESCAPE_DIRECTION_TOP;
+ // break;
+ case com::sun::star::drawing::EscapeDirection_SMART:
+ default:
+ meEscapeDirections = ESCAPE_DIRECTION_SMART;
+ break;
+ }
+ }
+ } // end of namespace glue
+} // end of namespace sdr
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace sdr
+{
+ namespace glue
+ {
+ bool PointComparator::operator()(const Point& rA, const Point& rB) const
+ {
+ // sort by ID
+ return rA.getID() < rB.getID();
+ }
+
+ Point& List::add(const Point& rNew)
+ {
+ OSL_ENSURE(0 == rNew.getID(), "Someone is adding a new GluePoint which already has an ID");
+
+ if(!maPointSet.size())
+ {
+ const_cast< Point& >(rNew).setID(0);
+ maPointSet.insert(rNew);
+ return *maPointSet.begin();
+ }
+
+ PointSet::iterator aFound(maPointSet.end());
+ aFound--;
+ const_cast< Point& >(rNew).setID(aFound->getID() + 1);
+ maPointSet.insert(rNew);
+ aFound = maPointSet.end();
+ aFound--;
+
+ return *aFound;
+ }
+
+ void List::remove(const Point& rNew)
+ {
+ const PointSet::const_iterator aFound(maPointSet.find(rNew));
+
+ if(aFound == maPointSet.end())
+ {
+ // not a member
+ OSL_ENSURE(false, "GluePoint for removal not found (!)");
+ return;
+ }
+
+ maPointSet.erase(aFound);
+ }
+
+ Point* List::findByID(sal_uInt32 nID) const
+ {
+ Point aPoint;
+
+ aPoint.setID(nID);
+
+ const PointSet::const_iterator aFound(maPointSet.find(aPoint));
+
+ if(aFound == maPointSet.end())
+ {
+ return 0;
+ }
+
+ const Point& rResult = *aFound;
+
+ return &const_cast< Point& >(rResult);
+ }
+
+ PointVector List::getVector() const
+ {
+ PointVector aRetval;
+
+ aRetval.reserve(maPointSet.size());
+
+ for(PointSet::const_iterator aFound(maPointSet.begin()); aFound != maPointSet.end(); aFound++)
+ {
+ aRetval.push_back(&const_cast< Point& >(*aFound));
+ }
+
+ return aRetval;
+ }
+
+ void List::adaptToChangedScale(const basegfx::B2DVector& rOldScale, const basegfx::B2DVector& rNewScale)
+ {
+ if(!rOldScale.equal(rNewScale))
+ {
+ for(PointSet::iterator aFound(maPointSet.begin()); aFound != maPointSet.end(); aFound++)
+ {
+ aFound->adaptToChangedScale(rOldScale, rNewScale);
+ }
+ }
+ }
+
+ } // end of namespace glue
+} // end of namespace sdr
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// eof
Propchange: openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrglue.cxx
------------------------------------------------------------------------------
svn:executable = *
Added: openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrobjecttools.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrobjecttools.cxx?rev=1529226&view=auto
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrobjecttools.cxx (added)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrobjecttools.cxx Fri Oct 4 17:20:25 2013
@@ -0,0 +1,157 @@
+/**************************************************************
+ *
+ * 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_svx.hxx"
+
+#include <svx/sdrobjecttools.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <svx/svdopath.hxx>
+#include <svx/svdlegacy.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+void initializeDefaultSdrPathObjByObjectType(SdrPathObj& rObj, DefaultSdrPathObjType eType, const basegfx::B2DRange& rRange, bool bClose)
+{
+ basegfx::B2DPolyPolygon aNewPolyPolygon;
+
+ switch(eType)
+ {
+ case DefaultSdrPathObjType_Line:
+ {
+ basegfx::B2DPolygon aInnerPoly;
+
+ aInnerPoly.append(basegfx::B2DPoint(rRange.getMinX(), rRange.getCenterY()));
+ aInnerPoly.append(basegfx::B2DPoint(rRange.getMaxX(), rRange.getCenterY()));
+ aNewPolyPolygon.append(aInnerPoly);
+ break;
+ }
+ case DefaultSdrPathObjType_BezierFill:
+ {
+ const basegfx::B2DPolygon aInnerPoly(
+ basegfx::tools::createPolygonFromEllipse(
+ rRange.getCenter(),
+ rRange.getWidth() * 0.5,
+ rRange.getHeight() * 0.5));
+
+ aNewPolyPolygon.append(aInnerPoly);
+ break;
+ }
+ case DefaultSdrPathObjType_Bezier:
+ {
+ basegfx::B2DPolygon aInnerPoly;
+ const basegfx::B2DPoint aTopLeft(rRange.getMinimum());
+ const basegfx::B2DVector aScale(rRange.getRange());
+
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.0, 1.0)));
+ aInnerPoly.appendBezierSegment(
+ aTopLeft + (aScale * basegfx::B2DTuple(0.25, 1.0)),
+ aTopLeft + (aScale * basegfx::B2DTuple(0.5, 1.0)),
+ aTopLeft + (aScale * basegfx::B2DTuple(0.5, 0.5)));
+ aInnerPoly.appendBezierSegment(
+ aTopLeft + (aScale * basegfx::B2DTuple(0.5, 0.0)),
+ aTopLeft + (aScale * basegfx::B2DTuple(0.75, 0.0)),
+ aTopLeft + (aScale * basegfx::B2DTuple(1.0, 0.0)));
+ aNewPolyPolygon.append(aInnerPoly);
+ break;
+ }
+ case DefaultSdrPathObjType_Freeline:
+ {
+ basegfx::B2DPolygon aInnerPoly;
+ const basegfx::B2DPoint aTopLeft(rRange.getMinimum());
+ const basegfx::B2DVector aScale(rRange.getRange());
+
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.0, 1.0)));
+ aInnerPoly.appendBezierSegment(
+ aTopLeft + (aScale * basegfx::B2DTuple(0.0, 0.5)),
+ aTopLeft + (aScale * basegfx::B2DTuple(0.5, 0.25)),
+ aTopLeft + (aScale * basegfx::B2DTuple(0.5, 0.5)));
+ aInnerPoly.appendBezierSegment(
+ aTopLeft + (aScale * basegfx::B2DTuple(0.5, 0.75)),
+ aTopLeft + (aScale * basegfx::B2DTuple(1.0, 0.5)),
+ aTopLeft + (aScale * basegfx::B2DTuple(1.0, 0.0)));
+
+ if(bClose)
+ {
+ aInnerPoly.append(aTopLeft + aScale);
+ }
+
+ aNewPolyPolygon.append(aInnerPoly);
+ break;
+ }
+ case DefaultSdrPathObjType_Polygon:
+ {
+ basegfx::B2DPolygon aInnerPoly;
+ const basegfx::B2DPoint aTopLeft(rRange.getMinimum());
+ const basegfx::B2DVector aScale(rRange.getRange());
+
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.1, 1.0)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.3, 0.6)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.0, 0.3)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.2, 0.0)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.6, 0.2)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.8, 0.0)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.7, 0.8)));
+ aInnerPoly.append(aTopLeft + aScale);
+
+ if(!bClose)
+ {
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.6, 1.0)));
+ }
+
+ aNewPolyPolygon.append(aInnerPoly);
+ break;
+ }
+ case DefaultSdrPathObjType_XPolygon:
+ {
+ basegfx::B2DPolygon aInnerPoly;
+ const basegfx::B2DPoint aTopLeft(rRange.getMinimum());
+ const basegfx::B2DVector aScale(rRange.getRange());
+
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.0, 1.0)));
+ aInnerPoly.append(aTopLeft);
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.5, 0.0)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.5, 0.5)));
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(1.0, 0.5)));
+ aInnerPoly.append(aTopLeft + aScale);
+
+ if(!bClose)
+ {
+ aInnerPoly.append(aTopLeft + (aScale * basegfx::B2DTuple(0.7, 1.0)));
+ }
+
+ aNewPolyPolygon.append(aInnerPoly);
+ break;
+ }
+ }
+
+ if(bClose)
+ {
+ aNewPolyPolygon.setClosed(true);
+ }
+
+ rObj.setB2DPolyPolygonInObjectCoordinates(aNewPolyPolygon);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
Propchange: openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrobjecttools.cxx
------------------------------------------------------------------------------
svn:executable = *
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrselection.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrselection.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrselection.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/sdrselection.cxx Fri Oct 4 17:20:25 2013
@@ -102,59 +102,59 @@ namespace sdr
}
}
- void Selection::checkGlueIndexCorrection()
- {
- for(IndicesMap::iterator aIndices(maGlueIndices.begin()); aIndices != maGlueIndices.end();)
- {
- SdrObject* pCandidate = aIndices->first;
- OSL_ENSURE(pCandidate, "Missing SdrObject pointer in glue selection(!)");
- bool bErase(false);
- IndicesMap::iterator aNext(aIndices);
- const SdrGluePointList* pGPL = pCandidate->GetGluePointList();
-
- aNext++;
-
- // for each SdrObject check if it has GluePoints at all
- if(pGPL)
- {
- Indices aCurrent = aIndices->second;
- Indices aNewList;
-
- // check for each selected GluePoint if it exists at the SdrObject. If yes, take
- // it over to a new list. Thus, all no longer existing GluePoints will be erased
- for(Indices::const_iterator aIter(aCurrent.begin()); aIter != aCurrent.end(); aIter++)
- {
- if(SDRGLUEPOINT_NOTFOUND != pGPL->FindGluePoint(*aIter))
- {
- aNewList.insert(aNewList.end(), *aIter);
- }
- }
-
- if(aNewList.empty())
- {
- // no glues left
- bErase = true;
- }
- else
- {
- // copy back new list
- aIndices->second = aNewList;
- }
- }
- else
- {
- // no glues at all
- bErase = true;
- }
-
- if(bErase)
- {
- maGlueIndices.erase(aIndices);
- }
+ void Selection::checkGlueIndexCorrection()
+ {
+ for(IndicesMap::iterator aIndices(maGlueIndices.begin()); aIndices != maGlueIndices.end();)
+ {
+ SdrObject* pCandidate = aIndices->first;
+ OSL_ENSURE(pCandidate, "Missing SdrObject pointer in glue selection(!)");
+ bool bErase(false);
+ IndicesMap::iterator aNext(aIndices);
+ const sdr::glue::List* pGPL = pCandidate->GetGluePointList(false);
+
+ aNext++;
+
+ // for each SdrObject check if it has GluePoints at all
+ if(pGPL)
+ {
+ Indices aCurrent = aIndices->second;
+ Indices aNewList;
+
+ // check for each selected GluePoint if it exists at the SdrObject. If yes, take
+ // it over to a new list. Thus, all no longer existing GluePoints will be erased
+ for(Indices::const_iterator aIter(aCurrent.begin()); aIter != aCurrent.end(); aIter++)
+ {
+ if(pGPL->findByID(*aIter))
+ {
+ aNewList.insert(aNewList.end(), *aIter);
+ }
+ }
+
+ if(aNewList.empty())
+ {
+ // no glues left
+ bErase = true;
+ }
+ else
+ {
+ // copy back new list
+ aIndices->second = aNewList;
+ }
+ }
+ else
+ {
+ // no glues at all
+ bErase = true;
+ }
+
+ if(bErase)
+ {
+ maGlueIndices.erase(aIndices);
+ }
- aIndices = aNext;
- }
- }
+ aIndices = aNext;
+ }
+ }
void Selection::handleChange()
{
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svdcrtv.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svdcrtv.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svdcrtv.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svdcrtv.cxx Fri Oct 4 17:20:25 2013
@@ -69,40 +69,41 @@ public:
};
ImplConnectMarkerOverlay::ImplConnectMarkerOverlay(const SdrCreateView& rView, SdrObject& rObject)
-: mrObject(rObject)
+: mrObject(rObject)
{
- basegfx::B2DPolyPolygon aB2DPolyPolygon(rObject.TakeXorPoly());
+ basegfx::B2DPolyPolygon aB2DPolyPolygon(rObject.TakeXorPoly());
- for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++)
- {
- SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
- ::sdr::overlay::OverlayManager* pTargetOverlay = pCandidate->GetOverlayManager();
+ for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++)
+ {
+ SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
+ ::sdr::overlay::OverlayManager* pTargetOverlay = pCandidate->GetOverlayManager();
- if(pTargetOverlay)
- {
- const basegfx::B2DVector aHalfLogicSize(pTargetOverlay->getOutputDevice().GetInverseViewTransformation() * basegfx::B2DVector(4.0, 4.0));
+ if(pTargetOverlay)
+ {
+ const basegfx::B2DVector aHalfLogicSize(pTargetOverlay->getOutputDevice().GetInverseViewTransformation() * basegfx::B2DVector(4.0, 4.0));
- // object
- ::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
+ // object
+ ::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
aB2DPolyPolygon);
- pTargetOverlay->add(*pNew);
- maObjects.append(*pNew);
+ pTargetOverlay->add(*pNew);
+ maObjects.append(*pNew);
- // gluepoints
- for(sal_uInt32 i(0); i < 4; i++)
- {
- const SdrGluePoint aGluePoint(rObject.GetVertexGluePoint(i));
- const basegfx::B2DPoint& rPosition = aGluePoint.GetAbsolutePos(sdr::legacy::GetSnapRange(rObject));
- const basegfx::B2DRange aBigRange(rPosition - aHalfLogicSize, rPosition + aHalfLogicSize);
- const basegfx::B2DPolygon aTempPoly(basegfx::tools::createPolygonFromRect(aBigRange));
+ // TTTT:GLUE
+ // gluepoints
+ for(sal_uInt32 i(0); i < 4; i++)
+ {
+ const sdr::glue::Point aGluePoint(rObject.GetVertexGluePoint(i));
+ const basegfx::B2DPoint aPosition(rObject.getSdrObjectTransformation() * aGluePoint.getUnitPosition());
+ const basegfx::B2DRange aBigRange(aPosition - aHalfLogicSize, aPosition + aHalfLogicSize);
+ const basegfx::B2DPolygon aTempPoly(basegfx::tools::createPolygonFromRect(aBigRange));
pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
basegfx::B2DPolyPolygon(aTempPoly));
- pTargetOverlay->add(*pNew);
- maObjects.append(*pNew);
- }
- }
- }
+ pTargetOverlay->add(*pNew);
+ maObjects.append(*pNew);
+ }
+ }
+ }
}
ImplConnectMarkerOverlay::~ImplConnectMarkerOverlay()
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgmt.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgmt.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgmt.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgmt.cxx Fri Oct 4 17:20:25 2013
@@ -524,43 +524,51 @@ void SdrDragMethod::createSdrDragEntries
void SdrDragMethod::createSdrDragEntries_GlueDrag()
{
- if(getSdrView().areSdrObjectsSelected())
- {
- const SdrObjectVector aSelection(getSdrView().getSelectedSdrObjectVectorFromSdrMarkView());
- std::vector< basegfx::B2DPoint > aPositions;
-
- for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
- {
- const sdr::selection::Indices aMarkedGluePoints(getSdrView().getSelectedGluesForSelectedSdrObject(*aSelection[nm]));
+ if(getSdrView().areSdrObjectsSelected())
+ {
+ const SdrObjectVector aSelection(getSdrView().getSelectedSdrObjectVectorFromSdrMarkView());
+ std::vector< basegfx::B2DPoint > aPositions;
+
+ for(sal_uInt32 nm(0); nm < aSelection.size(); nm++)
+ {
+ const SdrObject* pSdrObjCandidate = aSelection[nm];
- if(aMarkedGluePoints.size())
- {
- const SdrGluePointList* pGPL = aSelection[nm]->GetGluePointList();
-
- if(pGPL)
- {
- const basegfx::B2DRange aSnapRange(sdr::legacy::GetSnapRange(*aSelection[nm]));
-
- for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
- aCurrent != aMarkedGluePoints.end(); aCurrent++)
- {
- const sal_uInt32 nObjPt(*aCurrent);
- const sal_uInt32 nGlueNum(pGPL->FindGluePoint(nObjPt));
+ if(pSdrObjCandidate)
+ {
+ const sdr::selection::Indices aMarkedGluePoints(getSdrView().getSelectedGluesForSelectedSdrObject(*pSdrObjCandidate));
- if(SDRGLUEPOINT_NOTFOUND != nGlueNum)
- {
- aPositions.push_back((*pGPL)[nGlueNum].GetAbsolutePos(aSnapRange));
- }
- }
- }
- }
- }
+ if(aMarkedGluePoints.size())
+ {
+ // TTTT:GLUE
+ const sdr::glue::List* pGPL = pSdrObjCandidate->GetGluePointList(false);
- if(aPositions.size())
- {
- addSdrDragEntry(new SdrDragEntryPointGlueDrag(aPositions, false));
- }
- }
+ if(pGPL)
+ {
+ for(sdr::selection::Indices::const_iterator aCurrent(aMarkedGluePoints.begin());
+ aCurrent != aMarkedGluePoints.end(); aCurrent++)
+ {
+ const sal_uInt32 nObjPt(*aCurrent);
+ const sdr::glue::Point* pCandidate = pGPL->findByID(nObjPt);
+
+ if(pCandidate)
+ {
+ aPositions.push_back(pSdrObjCandidate->getSdrObjectTransformation() * pCandidate->getUnitPosition());
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ OSL_ENSURE(false, "ObjectSelection vector with unallowed gaps (!)");
+ }
+ }
+
+ if(aPositions.size())
+ {
+ addSdrDragEntry(new SdrDragEntryPointGlueDrag(aPositions, false));
+ }
+ }
}
void SdrDragMethod::TakeMarkedDescriptionString(sal_uInt16 nStrCacheID, XubString& rStr, sal_uInt16 nVal) const
@@ -599,21 +607,10 @@ SdrObject* SdrDragMethod::GetDragObj() c
void SdrDragMethod::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
{
// use get/setSdrObjectTransformation now. This will also work when object has a path
- basegfx::B2DHomMatrix aObjectMatrix(rTarget.getSdrObjectTransformation());
-
- // check for zero-width/height objects
- if(basegfx::fTools::equalZero(aObjectMatrix.get(0, 0)))
- {
- // no width
- aObjectMatrix.set(0, 0, 1.0);
- }
-
- if(basegfx::fTools::equalZero(aObjectMatrix.get(1, 1)))
- {
- // no height
- aObjectMatrix.set(1, 1, 1.0);
- }
+ // correct to minimal scaling for zero-width/height objects
+ basegfx::B2DHomMatrix aObjectMatrix(basegfx::tools::guaranteeMinimalScaling(rTarget.getSdrObjectTransformation()));
+ // apply current transformation and set
aObjectMatrix = getCurrentTransformation() * aObjectMatrix;
rTarget.setSdrObjectTransformation(aObjectMatrix);
}
@@ -1686,99 +1683,124 @@ void SdrDragMove::MoveSdrDrag(const base
}
}
- if(getSdrView().IsDraggingGluePoints() && getSdrView().areSdrObjectsSelected())
- {
- // Klebepunkte aufs BoundRect des Obj limitieren
- aNewPos -= DragStat().GetStart();
- const SdrObjectVector aSelection(getSdrView().getSelectedSdrObjectVectorFromSdrMarkView());
-
- for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
- {
- const SdrObject* pObj = aSelection[nMarkNum];
- const sdr::selection::Indices rMarkedGluePoints = getSdrView().getSelectedGluesForSelectedSdrObject(*pObj);
-
- if(rMarkedGluePoints.size())
- {
- const SdrGluePointList* pGPL = pObj->GetGluePointList();
- const basegfx::B2DRange& rObjectRange(pObj->getObjectRange(&getSdrView()));
- const basegfx::B2DRange aObjectSnapRange(sdr::legacy::GetSnapRange(*pObj));
+ if(getSdrView().IsDraggingGluePoints() && getSdrView().areSdrObjectsSelected())
+ {
+ // limit delta move to possible GluePoint move possibilities
+ const basegfx::B2DVector aOriginalAbsoluteDelta(aNewPos - DragStat().GetStart());
+ basegfx::B2DVector aNewAbsoluteDelta(aOriginalAbsoluteDelta);
+ const SdrObjectVector aSelection(getSdrView().getSelectedSdrObjectVectorFromSdrMarkView());
- for(sdr::selection::Indices::const_iterator aCurrent(rMarkedGluePoints.begin()); aCurrent != rMarkedGluePoints.end(); aCurrent++)
- {
- const sal_uInt32 nId(*aCurrent);
- const sal_uInt32 nGlueNum(pGPL->FindGluePoint(nId));
-
- if(SDRGLUEPOINT_NOTFOUND != nGlueNum)
- {
- basegfx::B2DPoint aPt((*pGPL)[nGlueNum].GetAbsolutePos(aObjectSnapRange) + aNewPos);
+ for(sal_uInt32 nMarkNum(0); nMarkNum < aSelection.size(); nMarkNum++)
+ {
+ const SdrObject* pObj = aSelection[nMarkNum];
- if(aPt.getX() < rObjectRange.getMinX())
- {
- aNewPos.setX(aNewPos.getX() - (aPt.getX() - rObjectRange.getMinX()));
- }
- if(aPt.getX() > rObjectRange.getMaxX())
- {
- aNewPos.setX(aNewPos.getX() - (aPt.getX() - rObjectRange.getMaxX()));
- }
- if(aPt.getY() < rObjectRange.getMinY())
- {
- aNewPos.setY(aNewPos.getY() - (aPt.getY() - rObjectRange.getMinY()));
- }
- if(aPt.getY() > rObjectRange.getMaxY())
- {
- aNewPos.setY(aNewPos.getY() - (aPt.getY() - rObjectRange.getMaxY()));
- }
- }
- }
- }
- }
+ if(pObj)
+ {
+ const sdr::selection::Indices rMarkedGluePoints = getSdrView().getSelectedGluesForSelectedSdrObject(*pObj);
- aNewPos += DragStat().GetStart();
- }
+ if(rMarkedGluePoints.size())
+ {
+ const sdr::glue::List* pGPL = pObj->GetGluePointList(false);
- if(getSdrView().IsOrthogonal())
- {
- aNewPos = OrthoDistance8(DragStat().GetStart(), aNewPos, false);
- }
+ if(pGPL)
+ {
+ // the SdrObject candidate with potentially moved GluePoints is identified. GetObjectMatrix,
+ // but take care for objects with zero width/height. Also prepare inverse transformation
+ const basegfx::B2DHomMatrix aCorrectedObjectTransformation(basegfx::tools::guaranteeMinimalScaling(pObj->getSdrObjectTransformation()));
+ basegfx::B2DHomMatrix aInverseCorrectedObjectTransformation(aCorrectedObjectTransformation);
+
+ aInverseCorrectedObjectTransformation.invert();
+
+ for(sdr::selection::Indices::const_iterator aCurrent(rMarkedGluePoints.begin()); aCurrent != rMarkedGluePoints.end(); aCurrent++)
+ {
+ const sal_uInt32 nId(*aCurrent);
+ const sdr::glue::Point* pGlueCandidate = pGPL->findByID(nId);
+
+ if(pGlueCandidate)
+ {
+ // get potentially moved position as absolute position and add absolute delta
+ const basegfx::B2DPoint aAbsolutePosition(aCorrectedObjectTransformation * pGlueCandidate->getUnitPosition());
+ basegfx::B2DPoint aClampedAbsolutePosition(aAbsolutePosition + aNewAbsoluteDelta);
+
+ // calculate back to unit position of moved point, clamp that position in unit coordinates
+ // to unit coordinates and convert back to absolute coordinates; this gives the clamped potentially
+ // moved position
+ aClampedAbsolutePosition = aInverseCorrectedObjectTransformation * aClampedAbsolutePosition;
+ aClampedAbsolutePosition = basegfx::B2DRange::getUnitB2DRange().clamp(aClampedAbsolutePosition);
+ aClampedAbsolutePosition = aCorrectedObjectTransformation * aClampedAbsolutePosition;
+
+ // calculate the potentially changed delta move
+ const basegfx::B2DVector aClampedDelta(aClampedAbsolutePosition - aAbsolutePosition);
+
+ // prefer the new delta move vector when it's shorter than the original
+ if(aClampedDelta.getLength() < aNewAbsoluteDelta.getLength())
+ {
+ aNewAbsoluteDelta = aClampedDelta;
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ OSL_ENSURE(false, "ObjectSelection vector with illegal empty slots (!)");
+ }
+ }
- if(!aNewPos.equal(DragStat().GetNow()))
- {
- Hide();
- DragStat().NextMove(aNewPos);
- basegfx::B2DRange aActionRange(GetMarkedRange());
- aActionRange.transform(basegfx::tools::createTranslateB2DHomMatrix(DragStat().GetNow() - DragStat().GetPrev()));
- DragStat().SetActionRange(aActionRange);
- Show();
- }
- }
+ if(!aOriginalAbsoluteDelta.equal(aNewAbsoluteDelta))
+ {
+ aNewPos = aNewPos - aOriginalAbsoluteDelta + aNewAbsoluteDelta;
+ }
+ }
+
+ if(getSdrView().IsOrthogonal())
+ {
+ aNewPos = OrthoDistance8(DragStat().GetStart(), aNewPos, false);
+ }
+
+ if(!aNewPos.equal(DragStat().GetNow()))
+ {
+ Hide();
+ DragStat().NextMove(aNewPos);
+ basegfx::B2DRange aActionRange(GetMarkedRange());
+ aActionRange.transform(basegfx::tools::createTranslateB2DHomMatrix(DragStat().GetNow() - DragStat().GetPrev()));
+ DragStat().SetActionRange(aActionRange);
+ Show();
+ }
+ }
}
bool SdrDragMove::EndSdrDrag(bool bCopy)
{
- Hide();
+ Hide();
- if(getSdrView().IsInsObjPoint() || (getSdrView().GetDragMethod() && getSdrView().IsInsertGluePoint()))
- {
- bCopy = false;
- }
+ if(getSdrView().IsInsObjPoint() || (getSdrView().GetDragMethod() && getSdrView().IsInsertGluePoint()))
+ {
+ bCopy = false;
+ }
- if(IsDraggingPoints())
- {
- getSdrView().TransformMarkedPoints(
- basegfx::tools::createTranslateB2DHomMatrix(DragStat().GetNow() - DragStat().GetPrev()),
- SDRREPFUNC_OBJ_MOVE,
- bCopy);
- }
- else if (IsDraggingGluePoints())
- {
- getSdrView().MoveMarkedGluePoints(DragStat().GetNow() - DragStat().GetPrev(), bCopy);
- }
- else
- {
- getSdrView().MoveMarkedObj(DragStat().GetNow() - DragStat().GetPrev(), bCopy);
- }
-
- return true;
+ if(IsDraggingPoints())
+ {
+ getSdrView().TransformMarkedPoints(
+ basegfx::tools::createTranslateB2DHomMatrix(DragStat().GetNow() - DragStat().GetPrev()),
+ SDRREPFUNC_OBJ_MOVE,
+ bCopy);
+ }
+ else if(IsDraggingGluePoints())
+ {
+ getSdrView().TransformMarkedGluePoints(
+ basegfx::tools::createTranslateB2DHomMatrix(DragStat().GetNow() - DragStat().GetPrev()),
+ SDRREPFUNC_OBJ_MOVE,
+ bCopy);
+ // TTTT:GLUE getSdrView().MoveMarkedGluePoints(DragStat().GetNow() - DragStat().GetPrev(), bCopy);
+ }
+ else
+ {
+ getSdrView().MoveMarkedObj(DragStat().GetNow() - DragStat().GetPrev(), bCopy);
+ }
+
+ return true;
}
Pointer SdrDragMove::GetSdrDragPointer() const
@@ -2049,31 +2071,41 @@ void SdrDragResize::MoveSdrDrag(const ba
bool SdrDragResize::EndSdrDrag(bool bCopy)
{
- Hide();
+ Hide();
- if(IsDraggingPoints())
- {
- basegfx::B2DHomMatrix aTransform;
+ if(IsDraggingPoints())
+ {
+ basegfx::B2DHomMatrix aTransform;
- aTransform.translate(-DragStat().GetRef1());
- aTransform.scale(maScale);
- aTransform.translate(DragStat().GetRef1());
-
- getSdrView().TransformMarkedPoints(
- aTransform,
- SDRREPFUNC_OBJ_RESIZE,
- bCopy);
- }
- else if (IsDraggingGluePoints())
- {
- getSdrView().ResizeMarkedGluePoints(DragStat().GetRef1(), maScale, bCopy);
- }
- else
- {
- getSdrView().ResizeMarkedObj(DragStat().GetRef1(), maScale, bCopy);
- }
+ aTransform.translate(-DragStat().GetRef1());
+ aTransform.scale(maScale);
+ aTransform.translate(DragStat().GetRef1());
+
+ getSdrView().TransformMarkedPoints(
+ aTransform,
+ SDRREPFUNC_OBJ_RESIZE,
+ bCopy);
+ }
+ else if(IsDraggingGluePoints())
+ {
+ basegfx::B2DHomMatrix aTransform;
- return true;
+ aTransform.translate(-DragStat().GetRef1());
+ aTransform.scale(maScale);
+ aTransform.translate(DragStat().GetRef1());
+
+ getSdrView().TransformMarkedGluePoints(
+ aTransform,
+ SDRREPFUNC_OBJ_MOVE,
+ bCopy);
+ // TTTT:GLUE getSdrView().ResizeMarkedGluePoints(DragStat().GetRef1(), maScale, bCopy);
+ }
+ else
+ {
+ getSdrView().ResizeMarkedObj(DragStat().GetRef1(), maScale, bCopy);
+ }
+
+ return true;
}
Pointer SdrDragResize::GetSdrDragPointer() const
@@ -2179,27 +2211,31 @@ void SdrDragRotate::MoveSdrDrag(const ba
bool SdrDragRotate::EndSdrDrag(bool bCopy)
{
- Hide();
+ Hide();
- if(!basegfx::fTools::equalZero(mfDeltaRotation))
- {
- if(IsDraggingPoints())
- {
- getSdrView().TransformMarkedPoints(
- basegfx::tools::createRotateAroundPoint(DragStat().GetRef1(), mfDeltaRotation),
- SDRREPFUNC_OBJ_ROTATE,
- bCopy);
- }
- else if(IsDraggingGluePoints())
- {
- getSdrView().RotateMarkedGluePoints(DragStat().GetRef1(), mfDeltaRotation, bCopy);
- }
- else
- {
- getSdrView().RotateMarkedObj(DragStat().GetRef1(), mfDeltaRotation, bCopy);
- }
- }
- return true;
+ if(!basegfx::fTools::equalZero(mfDeltaRotation))
+ {
+ if(IsDraggingPoints())
+ {
+ getSdrView().TransformMarkedPoints(
+ basegfx::tools::createRotateAroundPoint(DragStat().GetRef1(), mfDeltaRotation),
+ SDRREPFUNC_OBJ_ROTATE,
+ bCopy);
+ }
+ else if(IsDraggingGluePoints())
+ {
+ getSdrView().TransformMarkedGluePoints(
+ basegfx::tools::createRotateAroundPoint(DragStat().GetRef1(), mfDeltaRotation),
+ SDRREPFUNC_OBJ_ROTATE,
+ bCopy);
+ // TTTT:GLUE getSdrView().RotateMarkedGluePoints(DragStat().GetRef1(), mfDeltaRotation, bCopy);
+ }
+ else
+ {
+ getSdrView().RotateMarkedObj(DragStat().GetRef1(), mfDeltaRotation, bCopy);
+ }
+ }
+ return true;
}
Pointer SdrDragRotate::GetSdrDragPointer() const
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgv.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgv.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgv.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svddrgv.cxx Fri Oct 4 17:20:25 2013
@@ -836,70 +836,80 @@ bool SdrDragView::IsInsGluePointPossible
bool SdrDragView::BegInsGluePoint(const basegfx::B2DPoint& rPnt)
{
- bool bRetval(false);
- SdrObject* pObj = 0;
- sal_uInt32 nMarkNum;
-
- if(PickMarkedObj(rPnt, pObj, &nMarkNum, SDRSEARCH_PASS2BOUND))
- {
- BrkAction();
- MarkGluePoints(0, true);
- mpInsPointUndo = dynamic_cast< SdrUndoGeoObj* >( getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj) );
- DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
- XubString aStr(ImpGetResStr(STR_DragInsertGluePoint));
- XubString aName;
-
- pObj->TakeObjNameSingul(aName);
- aStr.SearchAndReplaceAscii("%1", aName);
- maInsPointUndoStr = aStr;
- SdrGluePointList* pGPL=pObj->ForceGluePointList();
+ bool bRetval(false);
+ SdrObject* pObj = 0;
+ sal_uInt32 nMarkNum;
+
+ if(PickMarkedObj(rPnt, pObj, &nMarkNum, SDRSEARCH_PASS2BOUND))
+ {
+ BrkAction();
+ MarkGluePoints(0, true);
+ mpInsPointUndo = dynamic_cast< SdrUndoGeoObj* >( getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pObj) );
+ DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
+ XubString aStr(ImpGetResStr(STR_DragInsertGluePoint));
+ XubString aName;
+
+ pObj->TakeObjNameSingul(aName);
+ aStr.SearchAndReplaceAscii("%1", aName);
+ maInsPointUndoStr = aStr;
+ sdr::glue::List* pGPL=pObj->GetGluePointList(true);
- if(pGPL)
- {
- const sal_uInt32 nGlueIdx(pGPL->Insert(SdrGluePoint()));
- SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
- const sal_uInt32 nGlueId(rGP.GetId());
- SdrHdl* pHdl = 0;
-
- rGP.SetAbsolutePos(rPnt, sdr::legacy::GetSnapRange(*pObj));
-
- if(MarkGluePoint(pObj, nGlueId))
- {
- pHdl=GetGluePointHdl(pObj,nGlueId);
- }
-
- if(pHdl && HDL_GLUE == pHdl->GetKind() && pHdl->GetObj() == pObj && pHdl->GetObjHdlNum() == nGlueId)
- {
- SetInsertGluePoint(true);
- bRetval = BegDragObj(rPnt, pHdl, 0.0);
-
- if(bRetval)
- {
- GetDragStat().SetMinMoved();
- MovDragObj(rPnt);
- }
- else
- {
- SetInsertGluePoint(false);
- delete mpInsPointUndo;
- mpInsPointUndo = 0;
- }
- }
- else
- {
- DBG_ERROR("BegInsGluePoint(): GluePoint-Handle nicht gefunden");
- }
- }
- else
- {
- // Keine Klebepunkte moeglich bei diesem Objekt (z.B. Edge)
- SetInsertGluePoint(false);
- delete mpInsPointUndo;
- mpInsPointUndo = 0;
- }
- }
+ if(pGPL)
+ {
+ sdr::glue::Point& rNew = pGPL->add(sdr::glue::Point());
+ const sal_uInt32 nGlueId(rNew.getID());
+ SdrHdl* pHdl = 0;
+
+ // TTTT:GLUE
+ //const sal_uInt32 nGlueIdx(pGPL->Insert(sdr::glue::Point()));
+ //sdr::glue::Point& rGP=(*pGPL)[nGlueIdx];
+ //const sal_uInt32 nGlueId(rGP.GetId());
+
+ // the moved candidate is identified. GetObjectMatrix, but take care for objects
+ // with zero width/height
+ basegfx::B2DHomMatrix aCorrectedObjectTransformation(basegfx::tools::guaranteeMinimalScaling(pObj->getSdrObjectTransformation()));
+
+ aCorrectedObjectTransformation.invert();
+ rNew.setUnitPosition(aCorrectedObjectTransformation * rPnt);
+ // rGP.SetAbsolutePos(rPnt, sdr::legacy::GetSnapRange(*pObj));
+
+ if(MarkGluePoint(pObj, nGlueId))
+ {
+ pHdl = GetGluePointHdl(pObj, nGlueId);
+ }
+
+ if(pHdl && HDL_GLUE == pHdl->GetKind() && pHdl->GetObj() == pObj && pHdl->GetObjHdlNum() == nGlueId)
+ {
+ SetInsertGluePoint(true);
+ bRetval = BegDragObj(rPnt, pHdl, 0.0);
+
+ if(bRetval)
+ {
+ GetDragStat().SetMinMoved();
+ MovDragObj(rPnt);
+ }
+ else
+ {
+ SetInsertGluePoint(false);
+ delete mpInsPointUndo;
+ mpInsPointUndo = 0;
+ }
+ }
+ else
+ {
+ DBG_ERROR("BegInsGluePoint(): GluePoint-Handle nicht gefunden");
+ }
+ }
+ else
+ {
+ // Keine Klebepunkte moeglich bei diesem Objekt (z.B. Edge)
+ SetInsertGluePoint(false);
+ delete mpInsPointUndo;
+ mpInsPointUndo = 0;
+ }
+ }
- return bRetval;
+ return bRetval;
}
void SdrDragView::ShowDragObj()
Modified: openoffice/branches/alg/aw080/main/svx/source/svdraw/svdedtv1.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/alg/aw080/main/svx/source/svdraw/svdedtv1.cxx?rev=1529226&r1=1529225&r2=1529226&view=diff
==============================================================================
--- openoffice/branches/alg/aw080/main/svx/source/svdraw/svdedtv1.cxx (original)
+++ openoffice/branches/alg/aw080/main/svx/source/svdraw/svdedtv1.cxx Fri Oct 4 17:20:25 2013
@@ -251,21 +251,10 @@ void SdrEditView::ResizeMarkedObj(const
AddUndo( getSdrModelFromSdrView().GetSdrUndoFactory().CreateUndoGeoObject(*pO));
}
- basegfx::B2DHomMatrix aObjectMatrix(pO->getSdrObjectTransformation());
-
- // check for zero-width/height objects
- if(basegfx::fTools::equalZero(aObjectMatrix.get(0, 0)))
- {
- // no width
- aObjectMatrix.set(0, 0, 1.0);
- }
-
- if(basegfx::fTools::equalZero(aObjectMatrix.get(1, 1)))
- {
- // no height
- aObjectMatrix.set(1, 1, 1.0);
- }
+ // get transformation and correct to minimal scaling for zero-width/height objects
+ basegfx::B2DHomMatrix aObjectMatrix(basegfx::tools::guaranteeMinimalScaling(pO->getSdrObjectTransformation()));
+ // apply current transformation and set
aObjectMatrix = aTransformation * aObjectMatrix;
pO->setSdrObjectTransformation(aObjectMatrix);
}