xref: /aoo41x/main/svx/source/table/viewcontactoftableobj.cxx (revision f6e50924)

/**************************************************************
 *
 * 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 "viewcontactoftableobj.hxx"
#include <svx/svdotable.hxx>
#include <com/sun/star/table/XTable.hpp>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <svx/sdr/primitive2d/sdrattributecreator.hxx>
#include <drawinglayer/primitive2d/groupprimitive2d.hxx>
#include <svx/sdr/primitive2d/sdrdecompositiontools.hxx>
#include <svx/sdr/primitive2d/sdrattributecreator.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <svx/sdr/attribute/sdrtextattribute.hxx>
#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
#include <editeng/borderline.hxx>
#include <drawinglayer/primitive2d/borderlineprimitive2d.hxx>
#include <svx/sdr/attribute/sdrfilltextattribute.hxx>
#include <drawinglayer/attribute/sdrlineattribute.hxx>
#include <drawinglayer/attribute/sdrshadowattribute.hxx>
#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>

#include "cell.hxx"
#include "tablelayouter.hxx"

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

using namespace com::sun::star;

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

namespace drawinglayer
{
	namespace primitive2d
	{
		class SdrCellPrimitive2D : public BufferedDecompositionPrimitive2D
		{
		private:
			basegfx::B2DHomMatrix						maTransform;
			attribute::SdrFillTextAttribute				maSdrFTAttribute;

		protected:
			// local decomposition.
			virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& aViewInformation) const;

		public:
			SdrCellPrimitive2D(
				const basegfx::B2DHomMatrix& rTransform,
				const attribute::SdrFillTextAttribute& rSdrFTAttribute)
			:	BufferedDecompositionPrimitive2D(),
				maTransform(rTransform),
				maSdrFTAttribute(rSdrFTAttribute)
			{
			}

			// data access
			const basegfx::B2DHomMatrix& getTransform() const { return maTransform; }
			const attribute::SdrFillTextAttribute& getSdrFTAttribute() const { return maSdrFTAttribute; }

			// compare operator
			virtual bool operator==(const BasePrimitive2D& rPrimitive) const;

			// provide unique ID
			DeclPrimitrive2DIDBlock()
		};

		Primitive2DSequence SdrCellPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*aViewInformation*/) const
		{
			// prepare unit polygon
			Primitive2DSequence aRetval;
			const basegfx::B2DPolyPolygon aUnitPolyPolygon(basegfx::tools::createUnitPolygon());

			// add fill
			if(!getSdrFTAttribute().getFill().isDefault())
			{
				appendPrimitive2DReferenceToPrimitive2DSequence(aRetval,
					createPolyPolygonFillPrimitive(
						aUnitPolyPolygon,
						getTransform(),
						getSdrFTAttribute().getFill(),
						getSdrFTAttribute().getFillFloatTransGradient()));
			}
            else
            {
                // if no fill create one for HitTest and BoundRect fallback
                appendPrimitive2DReferenceToPrimitive2DSequence(aRetval,
                    createHiddenGeometryPrimitives2D(
                        true,
                        aUnitPolyPolygon,
                        getTransform()));
            }

			// add text
			if(!getSdrFTAttribute().getText().isDefault())
			{
				appendPrimitive2DReferenceToPrimitive2DSequence(aRetval,
					createTextPrimitive(
						aUnitPolyPolygon,
						getTransform(),
						getSdrFTAttribute().getText(),
						attribute::SdrLineAttribute(),
						true,
						false,
						false));
			}

			return aRetval;
		}

		bool SdrCellPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
		{
			if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
			{
				const SdrCellPrimitive2D& rCompare = (SdrCellPrimitive2D&)rPrimitive;

				return (getTransform() == rCompare.getTransform()
					&& getSdrFTAttribute() == rCompare.getSdrFTAttribute());
			}

			return false;
		}

		// provide unique ID
		ImplPrimitrive2DIDBlock(SdrCellPrimitive2D, PRIMITIVE2D_ID_SDRCELLPRIMITIVE2D)

	} // end of namespace primitive2d
} // end of namespace drawinglayer

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

namespace drawinglayer
{
	namespace primitive2d
	{
		class SdrBorderlinePrimitive2D : public BufferedDecompositionPrimitive2D
		{
		private:
			basegfx::B2DHomMatrix						maTransform;
			SvxBorderLine								maLeftLine;
			SvxBorderLine								maBottomLine;
			SvxBorderLine								maRightLine;
			SvxBorderLine								maTopLine;

			// bitfield
			unsigned									mbLeftIsOutside : 1;
			unsigned									mbBottomIsOutside : 1;
			unsigned									mbRightIsOutside : 1;
			unsigned									mbTopIsOutside : 1;
			unsigned									mbInTwips : 1;

		protected:
			// local decomposition.
			virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& aViewInformation) const;

		public:
			SdrBorderlinePrimitive2D(
				const basegfx::B2DHomMatrix& rTransform,
				const SvxBorderLine& rLeftLine,
				const SvxBorderLine& rBottomLine,
				const SvxBorderLine& rRightLine,
				const SvxBorderLine& rTopLine,
				bool bLeftIsOutside,
				bool bBottomIsOutside,
				bool bRightIsOutside,
				bool bTopIsOutside,
				bool bInTwips)
			:	BufferedDecompositionPrimitive2D(),
				maTransform(rTransform),
				maLeftLine(rLeftLine),
				maBottomLine(rBottomLine),
				maRightLine(rRightLine),
				maTopLine(rTopLine),
				mbLeftIsOutside(bLeftIsOutside),
				mbBottomIsOutside(bBottomIsOutside),
				mbRightIsOutside(bRightIsOutside),
				mbTopIsOutside(bTopIsOutside),
				mbInTwips(bInTwips)
			{
			}


			// data access
			const basegfx::B2DHomMatrix& getTransform() const { return maTransform; }
			const SvxBorderLine& getLeftLine() const { return maLeftLine; }
			const SvxBorderLine& getBottomLine() const { return maBottomLine; }
			const SvxBorderLine& getRightLine() const { return maRightLine; }
			const SvxBorderLine& getTopLine() const { return maTopLine; }
			bool getLeftIsOutside() const { return mbLeftIsOutside; }
			bool getBottomIsOutside() const { return mbBottomIsOutside; }
			bool getRightIsOutside() const { return mbRightIsOutside; }
			bool getTopIsOutside() const { return mbTopIsOutside; }
			bool getInTwips() const { return mbInTwips; }

			// compare operator
			virtual bool operator==(const BasePrimitive2D& rPrimitive) const;

			// provide unique ID
			DeclPrimitrive2DIDBlock()
		};

		sal_uInt16 getBorderLineOutWidth(const SvxBorderLine& rLineA)
		{
			return (1 == rLineA.GetOutWidth() ? 0 : rLineA.GetOutWidth());
		}

		sal_uInt16 getBorderLineDistance(const SvxBorderLine& rLineA)
		{
			return (1 == rLineA.GetDistance() ? 0 : rLineA.GetDistance());
		}

		sal_uInt16 getBorderLineInWidth(const SvxBorderLine& rLineA)
		{
			return (1 == rLineA.GetInWidth() ? 0 : rLineA.GetInWidth());
		}

		sal_uInt16 getBorderLineWidth(const SvxBorderLine& rLineA)
		{
			return getBorderLineOutWidth(rLineA) + getBorderLineDistance(rLineA) + getBorderLineInWidth(rLineA);
		}

		double getInnerExtend(const SvxBorderLine& rLineA, bool bSideToUse)
		{
			if(!rLineA.isEmpty())
			{
				if(rLineA.isDouble())
				{
					// reduce to inner edge of associated matching line
					return -((getBorderLineWidth(rLineA) / 2.0) - (bSideToUse ? getBorderLineOutWidth(rLineA) : getBorderLineInWidth(rLineA)));
				}
				else
				{
					// extend to overlap with single line
					return getBorderLineWidth(rLineA) / 2.0;
				}
			}

			return 0.0;
		}

		double getOuterExtend(const SvxBorderLine& rLineA)
		{
			if(!rLineA.isEmpty())
			{
				// extend to overlap with single line
				return getBorderLineWidth(rLineA) / 2.0;
			}

			return 0.0;
		}

		double getChangedValue(sal_uInt16 nValue, bool bChangeToMM)
		{
			if(1 == nValue)
				return 1.0;

			if(bChangeToMM)
				return nValue * (127.0 / 72.0);

			return (double)nValue;
		}

		Primitive2DSequence SdrBorderlinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*aViewInformation*/) const
		{
			Primitive2DSequence xRetval(4);
			sal_uInt32 nInsert(0);
			const double fTwipsToMM(getInTwips() ? (127.0 / 72.0) : 1.0);

			if(!getLeftLine().isEmpty())
			{
				// create left line from top to bottom
				const basegfx::B2DPoint aStart(getTransform() * basegfx::B2DPoint(0.0, 0.0));
				const basegfx::B2DPoint aEnd(getTransform() * basegfx::B2DPoint(0.0, 1.0));

				if(!aStart.equal(aEnd))
				{
					const double fExtendIS(getInnerExtend(getTopLine(), false));
					const double fExtendIE(getInnerExtend(getBottomLine(), true));
					double fExtendOS(0.0);
					double fExtendOE(0.0);

					if(getLeftIsOutside())
					{
						if(getTopIsOutside())
						{
							fExtendOS = getOuterExtend(getTopLine());
						}

						if(getBottomIsOutside())
						{
							fExtendOE = getOuterExtend(getBottomLine());
						}
					}

					xRetval[nInsert++] = Primitive2DReference(new BorderLinePrimitive2D(
						aStart,
						aEnd,
						getChangedValue(getLeftLine().GetOutWidth(), getInTwips()),
						getChangedValue(getLeftLine().GetDistance(), getInTwips()),
						getChangedValue(getLeftLine().GetInWidth(), getInTwips()),
						fExtendIS * fTwipsToMM,
						fExtendIE * fTwipsToMM,
						fExtendOS * fTwipsToMM,
						fExtendOE * fTwipsToMM,
						true,
						getLeftIsOutside(),
						getLeftLine().GetColor().getBColor()));
				}
			}

			if(!getBottomLine().isEmpty())
			{
				// create bottom line from left to right
				const basegfx::B2DPoint aStart(getTransform() * basegfx::B2DPoint(0.0, 1.0));
				const basegfx::B2DPoint aEnd(getTransform() * basegfx::B2DPoint(1.0, 1.0));

				if(!aStart.equal(aEnd))
				{
					const double fExtendIS(getInnerExtend(getLeftLine(), true));
					const double fExtendIE(getInnerExtend(getRightLine(), false));
					double fExtendOS(0.0);
					double fExtendOE(0.0);

					if(getBottomIsOutside())
					{
						if(getLeftIsOutside())
						{
							fExtendOS = getOuterExtend(getLeftLine());
						}

						if(getRightIsOutside())
						{
							fExtendOE = getOuterExtend(getRightLine());
						}
					}

					xRetval[nInsert++] = Primitive2DReference(new BorderLinePrimitive2D(
						aStart,
						aEnd,
						getChangedValue(getBottomLine().GetOutWidth(), getInTwips()),
						getChangedValue(getBottomLine().GetDistance(), getInTwips()),
						getChangedValue(getBottomLine().GetInWidth(), getInTwips()),
						fExtendIS * fTwipsToMM,
						fExtendIE * fTwipsToMM,
						fExtendOS * fTwipsToMM,
						fExtendOE * fTwipsToMM,
						true,
						getBottomIsOutside(),
						getBottomLine().GetColor().getBColor()));
				}
			}

			if(!getRightLine().isEmpty())
			{
				// create right line from top to bottom
				const basegfx::B2DPoint aStart(getTransform() * basegfx::B2DPoint(1.0, 0.0));
				const basegfx::B2DPoint aEnd(getTransform() * basegfx::B2DPoint(1.0, 1.0));

				if(!aStart.equal(aEnd))
				{
					const double fExtendIS(getInnerExtend(getTopLine(), false));
					const double fExtendIE(getInnerExtend(getBottomLine(), true));
					double fExtendOS(0.0);
					double fExtendOE(0.0);

					if(getRightIsOutside())
					{
						if(getTopIsOutside())
						{
							fExtendOS = getOuterExtend(getTopLine());
						}

						if(getBottomIsOutside())
						{
							fExtendOE = getOuterExtend(getBottomLine());
						}
					}

					xRetval[nInsert++] = Primitive2DReference(new BorderLinePrimitive2D(
						aStart,
						aEnd,
						getChangedValue(getRightLine().GetOutWidth(), getInTwips()),
						getChangedValue(getRightLine().GetDistance(), getInTwips()),
						getChangedValue(getRightLine().GetInWidth(), getInTwips()),
						fExtendOS * fTwipsToMM,
						fExtendOE * fTwipsToMM,
						fExtendIS * fTwipsToMM,
						fExtendIE * fTwipsToMM,
						getRightIsOutside(),
						true,
						getRightLine().GetColor().getBColor()));
				}
			}

			if(!getTopLine().isEmpty())
			{
				// create top line from left to right
				const basegfx::B2DPoint aStart(getTransform() * basegfx::B2DPoint(0.0, 0.0));
				const basegfx::B2DPoint aEnd(getTransform() * basegfx::B2DPoint(1.0, 0.0));

				if(!aStart.equal(aEnd))
				{
					const double fExtendIS(getInnerExtend(getLeftLine(), true));
					const double fExtendIE(getInnerExtend(getRightLine(), false));
					double fExtendOS(0.0);
					double fExtendOE(0.0);

					if(getTopIsOutside())
					{
						if(getLeftIsOutside())
						{
							fExtendOS = getOuterExtend(getLeftLine());
						}

						if(getRightIsOutside())
						{
							fExtendOE = getOuterExtend(getRightLine());
						}
					}

					xRetval[nInsert++] = Primitive2DReference(new BorderLinePrimitive2D(
						aStart,
						aEnd,
						getChangedValue(getTopLine().GetOutWidth(), getInTwips()),
						getChangedValue(getTopLine().GetDistance(), getInTwips()),
						getChangedValue(getTopLine().GetInWidth(), getInTwips()),
						fExtendOS * fTwipsToMM,
						fExtendOE * fTwipsToMM,
						fExtendIS * fTwipsToMM,
						fExtendIE * fTwipsToMM,
						getTopIsOutside(),
						true,
						getTopLine().GetColor().getBColor()));
				}
			}

			xRetval.realloc(nInsert);
			return xRetval;
		}

		bool SdrBorderlinePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
		{
			if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
			{
				const SdrBorderlinePrimitive2D& rCompare = (SdrBorderlinePrimitive2D&)rPrimitive;

				return (getTransform() == rCompare.getTransform()
					&& getLeftLine() == rCompare.getLeftLine()
					&& getBottomLine() == rCompare.getBottomLine()
					&& getRightLine() == rCompare.getRightLine()
					&& getTopLine() == rCompare.getTopLine()
					&& getLeftIsOutside() == rCompare.getLeftIsOutside()
					&& getBottomIsOutside() == rCompare.getBottomIsOutside()
					&& getRightIsOutside() == rCompare.getRightIsOutside()
					&& getTopIsOutside() == rCompare.getTopIsOutside()
					&& getInTwips() == rCompare.getInTwips());
			}

			return false;
		}

		// provide unique ID
		ImplPrimitrive2DIDBlock(SdrBorderlinePrimitive2D, PRIMITIVE2D_ID_SDRBORDERLINEPRIMITIVE2D)

	} // end of namespace primitive2d
} // end of namespace drawinglayer

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

namespace sdr
{
	namespace contact
	{
		void impGetLine(SvxBorderLine& aLine, const sdr::table::TableLayouter& rLayouter, sal_Int32 nX, sal_Int32 nY, bool bHorizontal, sal_Int32 nColCount, sal_Int32 nRowCount, bool bIsRTL)
		{
			if(nX >= 0 && nX <= nColCount && nY >= 0 && nY <= nRowCount)
			{
				const SvxBorderLine* pLine = rLayouter.getBorderLine(nX, nY, bHorizontal);

				if(pLine)
				{
					// copy line content
					aLine = *pLine;

					// check for mirroring. This shall always be done when it is
					// not a top- or rightmost line
					bool bMirror(aLine.isDouble());

					if(bMirror)
					{
						if(bHorizontal)
						{
							// mirror all bottom lines
							bMirror = (0 != nY);
						}
						else
						{
							// mirror all left lines
							bMirror = (bIsRTL ? 0 != nX : nX != nColCount);
						}
					}

					if(bMirror)
					{
						aLine.SetOutWidth(pLine->GetInWidth());
						aLine.SetInWidth(pLine->GetOutWidth());
					}

					return;
				}
			}

			// no success, copy empty line
			const SvxBorderLine aEmptyLine;
			aLine = aEmptyLine;
		}

		drawinglayer::primitive2d::Primitive2DSequence ViewContactOfTableObj::createViewIndependentPrimitive2DSequence() const
        {
			const sdr::table::SdrTableObj& rTableObj = GetTableObj();
            const uno::Reference< com::sun::star::table::XTable > xTable = rTableObj.getTable();

            if(xTable.is())
            {
                // create primitive representation for table
	            drawinglayer::primitive2d::Primitive2DSequence xRetval;
                const sal_Int32 nRowCount(xTable->getRowCount());
                const sal_Int32 nColCount(xTable->getColumnCount());
                const sal_Int32 nAllCount(nRowCount * nColCount);

                if(nAllCount)
                {
					const sdr::table::TableLayouter& rTableLayouter = rTableObj.getTableLayouter();
					const bool bIsRTL(com::sun::star::text::WritingMode_RL_TB == rTableObj.GetWritingMode());
                	sdr::table::CellPos aCellPos;
					sdr::table::CellRef xCurrentCell;
					basegfx::B2IRectangle aCellArea;

		            // 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.
		            const Rectangle& rObjectRectangle(rTableObj.GetGeoRect());
		            const basegfx::B2DRange aObjectRange(rObjectRectangle.Left(), rObjectRectangle.Top(), rObjectRectangle.Right(), rObjectRectangle.Bottom());

					// for each cell we need potentially a cell primitive and a border primitive
					// (e.g. single cell). Prepare sequences and input counters
					drawinglayer::primitive2d::Primitive2DSequence xCellSequence(nAllCount);
					drawinglayer::primitive2d::Primitive2DSequence xBorderSequence(nAllCount);
					sal_uInt32 nCellInsert(0);
					sal_uInt32 nBorderInsert(0);

					// variables for border lines
					SvxBorderLine aLeftLine;
					SvxBorderLine aBottomLine;
					SvxBorderLine aRightLine;
					SvxBorderLine aTopLine;

					// create single primitives per cell
					for(aCellPos.mnRow = 0; aCellPos.mnRow < nRowCount; aCellPos.mnRow++)
                    {
		                for(aCellPos.mnCol = 0; aCellPos.mnCol < nColCount; aCellPos.mnCol++)
                        {
							xCurrentCell.set(dynamic_cast< sdr::table::Cell* >(xTable->getCellByPosition(aCellPos.mnCol, aCellPos.mnRow).get()));

							if(xCurrentCell.is() && !xCurrentCell->isMerged())
							{
								if(rTableLayouter.getCellArea(aCellPos, aCellArea))
								{
									// create cell transformation matrix
									basegfx::B2DHomMatrix aCellMatrix;
									aCellMatrix.set(0, 0, (double)aCellArea.getWidth());
									aCellMatrix.set(1, 1, (double)aCellArea.getHeight());
									aCellMatrix.set(0, 2, (double)aCellArea.getMinX() + aObjectRange.getMinX());
									aCellMatrix.set(1, 2, (double)aCellArea.getMinY() + aObjectRange.getMinY());

									// handle cell fillings and text
									const SfxItemSet& rCellItemSet = xCurrentCell->GetItemSet();
									const sal_uInt32 nTextIndex(nColCount * aCellPos.mnRow + aCellPos.mnCol);
									const SdrText* pSdrText = rTableObj.getText(nTextIndex);
									drawinglayer::attribute::SdrFillTextAttribute aAttribute;

									if(pSdrText)
									{
										// #i101508# take cell's local text frame distances into account
										const sal_Int32 nLeft(xCurrentCell->GetTextLeftDistance());
										const sal_Int32 nRight(xCurrentCell->GetTextRightDistance());
										const sal_Int32 nUpper(xCurrentCell->GetTextUpperDistance());
										const sal_Int32 nLower(xCurrentCell->GetTextLowerDistance());

										aAttribute = drawinglayer::primitive2d::createNewSdrFillTextAttribute(
											rCellItemSet,
											pSdrText,
											&nLeft,
											&nUpper,
											&nRight,
											&nLower);
									}
									else
									{
										aAttribute = drawinglayer::primitive2d::createNewSdrFillTextAttribute(
											rCellItemSet,
											pSdrText);
									}

                                    // always create cell primitives for BoundRect and HitTest
									{
										const drawinglayer::primitive2d::Primitive2DReference xCellReference(
											new drawinglayer::primitive2d::SdrCellPrimitive2D(
												aCellMatrix, aAttribute));
										xCellSequence[nCellInsert++] = xCellReference;
									}

									// handle cell borders
									const sal_Int32 nX(bIsRTL ? nColCount - aCellPos.mnCol : aCellPos.mnCol);
									const sal_Int32 nY(aCellPos.mnRow);

									// get access values for X,Y at the cell's end
									const sal_Int32 nXSpan(xCurrentCell->getColumnSpan());
									const sal_Int32 nYSpan(xCurrentCell->getRowSpan());
									const sal_Int32 nXRight(bIsRTL ? nX - nXSpan : nX + nXSpan);
									const sal_Int32 nYBottom(nY + nYSpan);

									// get basic lines
									impGetLine(aLeftLine, rTableLayouter, nX, nY, false, nColCount, nRowCount, bIsRTL);
									impGetLine(aBottomLine, rTableLayouter, nX, nYBottom, true, nColCount, nRowCount, bIsRTL);
									impGetLine(aRightLine, rTableLayouter, nXRight, nY, false, nColCount, nRowCount, bIsRTL);
									impGetLine(aTopLine, rTableLayouter, nX, nY, true, nColCount, nRowCount, bIsRTL);

									// create the primtive containing all data for one cell with borders
									xBorderSequence[nBorderInsert++] = drawinglayer::primitive2d::Primitive2DReference(
										new drawinglayer::primitive2d::SdrBorderlinePrimitive2D(
											aCellMatrix,
											aLeftLine,
											aBottomLine,
											aRightLine,
											aTopLine,
											bIsRTL ? nX == nColCount : 0 == nX,
											nRowCount == nYBottom,
											bIsRTL ? 0 == nXRight : nXRight == nColCount,
											0 == nY,
											true));
								}
							}
                        }
					}

					// no empty references; reallocate sequences by used count
					xCellSequence.realloc(nCellInsert);
					xBorderSequence.realloc(nBorderInsert);

					// append to target. We want fillings and text first
					xRetval = xCellSequence;
					drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(xRetval, xBorderSequence);
				}

				if(xRetval.hasElements())
				{
					// check and create evtl. shadow for created content
	           		const SfxItemSet& rObjectItemSet = rTableObj.GetMergedItemSet();
					const drawinglayer::attribute::SdrShadowAttribute aNewShadowAttribute(
						drawinglayer::primitive2d::createNewSdrShadowAttribute(rObjectItemSet));

					if(!aNewShadowAttribute.isDefault())
					{
						xRetval = drawinglayer::primitive2d::createEmbeddedShadowPrimitive(xRetval, aNewShadowAttribute);
					}
				}

				return xRetval;
			}
			else
			{
				// take unrotated snap rect (direct model data) for position and size
				const Rectangle& rRectangle = rTableObj.GetGeoRect();
				const basegfx::B2DRange aObjectRange(
					rRectangle.Left(), rRectangle.Top(),
					rRectangle.Right(), rRectangle.Bottom());

				// create object matrix
				const GeoStat& rGeoStat(rTableObj.GetGeoStat());
				const double fShearX(rGeoStat.nShearWink ? tan((36000 - rGeoStat.nShearWink) * F_PI18000) : 0.0);
				const double fRotate(rGeoStat.nDrehWink ? (36000 - rGeoStat.nDrehWink) * F_PI18000 : 0.0);
				const basegfx::B2DHomMatrix aObjectMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
					aObjectRange.getWidth(), aObjectRange.getHeight(), fShearX, fRotate,
					aObjectRange.getMinX(), aObjectRange.getMinY()));

				// credate an invisible outline for the cases where no visible content exists
	            const drawinglayer::primitive2d::Primitive2DReference xReference(
					drawinglayer::primitive2d::createHiddenGeometryPrimitives2D(
						false,
						aObjectMatrix));

				return drawinglayer::primitive2d::Primitive2DSequence(&xReference, 1);
			}
        }

		ViewContactOfTableObj::ViewContactOfTableObj(::sdr::table::SdrTableObj& rTableObj)
		:	ViewContactOfSdrObj(rTableObj)
		{
		}

		ViewContactOfTableObj::~ViewContactOfTableObj()
		{
		}
	} // end of namespace contact
} // end of namespace sdr

//////////////////////////////////////////////////////////////////////////////
// eof