svx/source/table/viewcontactoftableobj.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "viewcontactoftableobj.hxx"
  22 #include <svx/svdotable.hxx>
  23 #include <com/sun/star/table/XTable.hpp>
  24 #include <basegfx/polygon/b2dpolygontools.hxx>
  25 #include <basegfx/polygon/b2dpolygon.hxx>
  26 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  27 #include <svx/sdr/primitive2d/sdrattributecreator.hxx>
  28 #include <drawinglayer/primitive2d/groupprimitive2d.hxx>
  29 #include <svx/sdr/primitive2d/sdrdecompositiontools.hxx>
  30 #include <basegfx/matrix/b2dhommatrix.hxx>
  31 #include <svx/sdr/attribute/sdrtextattribute.hxx>
  32 #include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
  33 #include <editeng/borderline.hxx>
  34 #include <drawinglayer/primitive2d/borderlineprimitive2d.hxx>
  35 #include <sdr/attribute/sdrfilltextattribute.hxx>
  36 #include <drawinglayer/attribute/sdrlineattribute.hxx>
  37 #include <drawinglayer/attribute/sdrshadowattribute.hxx>
  38 #include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx>
  39 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  40 #include <svx/framelink.hxx>
  41
  42 #include <cell.hxx>
  43 #include "tablelayouter.hxx"
  44
  45
  46 using editeng::SvxBorderLine;
  47 using namespace com::sun::star;
  48
  49
  50 namespace drawinglayer
  51 {
  52     namespace primitive2d
  53     {
  54         class SdrCellPrimitive2D : public BufferedDecompositionPrimitive2D
  55         {
  56         private:
  57             basegfx::B2DHomMatrix                       maTransform;
  58             attribute::SdrFillTextAttribute             maSdrFTAttribute;
  59
  60         protected:
  61             // local decomposition.
  62             virtual void create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& aViewInformation) const override;
  63
  64         public:
  65             SdrCellPrimitive2D(
  66                 const basegfx::B2DHomMatrix& rTransform,
  67                 const attribute::SdrFillTextAttribute& rSdrFTAttribute)
  68             :   BufferedDecompositionPrimitive2D(),
  69                 maTransform(rTransform),
  70                 maSdrFTAttribute(rSdrFTAttribute)
  71             {
  72             }
  73
  74             // data access
  75             const basegfx::B2DHomMatrix& getTransform() const { return maTransform; }
  76             const attribute::SdrFillTextAttribute& getSdrFTAttribute() const { return maSdrFTAttribute; }
  77
  78             // compare operator
  79             virtual bool operator==(const BasePrimitive2D& rPrimitive) const override;
  80
  81             // provide unique ID
  82             DeclPrimitive2DIDBlock()
  83         };
  84
  85         void SdrCellPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const
  86         {
  87             // prepare unit polygon
  88             const basegfx::B2DPolyPolygon aUnitPolyPolygon(basegfx::utils::createUnitPolygon());
  89
  90             // add fill
  91             if(!getSdrFTAttribute().getFill().isDefault())
  92             {
  93                 basegfx::B2DPolyPolygon aTransformed(aUnitPolyPolygon);
  94
  95                 aTransformed.transform(getTransform());
  96                 rContainer.push_back(
  97                     createPolyPolygonFillPrimitive(
  98                         aTransformed,
  99                         getSdrFTAttribute().getFill(),
 100                         getSdrFTAttribute().getFillFloatTransGradient()));
 101             }
 102             else
 103             {
 104                 // if no fill create one for HitTest and BoundRect fallback
 105                 rContainer.push_back(
 106                     createHiddenGeometryPrimitives2D(
 107                         true,
 108                         aUnitPolyPolygon,
 109                         getTransform()));
 110             }
 111
 112             // add text
 113             if(!getSdrFTAttribute().getText().isDefault())
 114             {
 115                 rContainer.push_back(
 116                     createTextPrimitive(
 117                         aUnitPolyPolygon,
 118                         getTransform(),
 119                         getSdrFTAttribute().getText(),
 120                         attribute::SdrLineAttribute(),
 121                         true,
 122                         false));
 123             }
 124         }
 125
 126         bool SdrCellPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 127         {
 128             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
 129             {
 130                 const SdrCellPrimitive2D& rCompare = static_cast<const SdrCellPrimitive2D&>(rPrimitive);
 131
 132                 return (getTransform() == rCompare.getTransform()
 133                     && getSdrFTAttribute() == rCompare.getSdrFTAttribute());
 134             }
 135
 136             return false;
 137         }
 138
 139         // provide unique ID
 140         ImplPrimitive2DIDBlock(SdrCellPrimitive2D, PRIMITIVE2D_ID_SDRCELLPRIMITIVE2D)
 141
 142     } // end of namespace primitive2d
 143 } // end of namespace drawinglayer
 144
 145 namespace sdr
 146 {
 147     namespace contact
 148     {
 149         svx::frame::Style impGetLineStyle(
 150             const sdr::table::TableLayouter& rLayouter,
 151             sal_Int32 nX,
 152             sal_Int32 nY,
 153             bool bHorizontal,
 154             sal_Int32 nColCount,
 155             sal_Int32 nRowCount,
 156             bool bIsRTL)
 157         {
 158             if(nX >= 0 && nX <= nColCount && nY >= 0 && nY <= nRowCount)
 159             {
 160                 const SvxBorderLine* pLine = rLayouter.getBorderLine(nX, nY, bHorizontal);
 161
 162                 if(pLine)
 163                 {
 164                     // copy line content
 165                     SvxBorderLine aLine(*pLine);
 166
 167                     // check for mirroring. This shall always be done when it is
 168                     // not a top- or rightmost line
 169                     bool bMirror(aLine.isDouble());
 170
 171                     if(bMirror)
 172                     {
 173                         if(bHorizontal)
 174                         {
 175                             // mirror all bottom lines
 176                             bMirror = (0 != nY);
 177                         }
 178                         else
 179                         {
 180                             // mirror all left lines
 181                             bMirror = (bIsRTL ? 0 != nX : nX != nColCount);
 182                         }
 183                     }
 184
 185                     if(bMirror)
 186                     {
 187                         aLine.SetMirrorWidths( );
 188                     }
 189
 190                     const double fTwipsToMM(127.0 / 72.0);
 191                     return svx::frame::Style(&aLine, fTwipsToMM);
 192                 }
 193             }
 194
 195             // no success, copy empty line
 196             return svx::frame::Style();
 197         }
 198
 199         void createForVector(bool bHor, drawinglayer::primitive2d::Primitive2DContainer& rContainer, const basegfx::B2DPoint& rOrigin, const basegfx::B2DVector& rX,
 200             const svx::frame::Style& rLine,
 201             const svx::frame::Style& rLeftA, const svx::frame::Style& rLeftB, const svx::frame::Style& rLeftC,
 202             const svx::frame::Style& rRightA, const svx::frame::Style& rRightB, const svx::frame::Style& rRightC)
 203         {
 204             /// top-left and bottom-right Style Tables
 205             const basegfx::B2DVector aY(basegfx::getNormalizedPerpendicular(rX));
 206
 207             /// Fill top-left Style Table
 208             svx::frame::StyleVectorTable aStart;
 209
 210             aStart.add(rLeftA, rX, -aY, bHor); // bHor ? true : false));
 211             aStart.add(rLeftB, rX, -rX, true); // bHor ? true : true));
 212             aStart.add(rLeftC, rX, aY, !bHor); // bHor ? false : true));
 213             aStart.sort();
 214
 215             /// Fill bottom-right Style Table
 216             svx::frame::StyleVectorTable aEnd;
 217             const basegfx::B2DVector aAxis(-rX);
 218
 219             aEnd.add(rRightA, aAxis, -aY, bHor); // bHor ? true : false));
 220             aEnd.add(rRightB, aAxis, rX, false); // bHor ? false : false));
 221             aEnd.add(rRightC, aAxis, aY, !bHor); // bHor ? false : true));
 222             aEnd.sort();
 223
 224             CreateBorderPrimitives(
 225                 rContainer,
 226                 rOrigin,
 227                 rX,
 228                 rLine,
 229                 aStart,
 230                 aEnd,
 231                 nullptr
 232             );
 233         }
 234
 235         drawinglayer::primitive2d::Primitive2DContainer ViewContactOfTableObj::createViewIndependentPrimitive2DSequence() const
 236         {
 237             const sdr::table::SdrTableObj& rTableObj = static_cast<const sdr::table::SdrTableObj&>(GetSdrObject());
 238             const uno::Reference< css::table::XTable > xTable = rTableObj.getTable();
 239
 240             if(xTable.is())
 241             {
 242                 // create primitive representation for table. Cell info goes
 243                 // directly to aRetval, Border info to aBorderSequence and added
 244                 // later to get the correct overlapping
 245                 drawinglayer::primitive2d::Primitive2DContainer aRetval;
 246                 const sal_Int32 nRowCount(xTable->getRowCount());
 247                 const sal_Int32 nColCount(xTable->getColumnCount());
 248                 const sal_Int32 nAllCount(nRowCount * nColCount);
 249
 250                 if(nAllCount)
 251                 {
 252                     const sdr::table::TableLayouter& rTableLayouter = rTableObj.getTableLayouter();
 253                     const bool bIsRTL(css::text::WritingMode_RL_TB == rTableObj.GetWritingMode());
 254                     sdr::table::CellPos aCellPos;
 255                     sdr::table::CellRef xCurrentCell;
 256                     basegfx::B2IRectangle aCellArea;
 257
 258                     // create range using the model data directly. This is in SdrTextObj::aRect which i will access using
 259                     // GetGeoRect() to not trigger any calculations. It's the unrotated geometry.
 260                     const tools::Rectangle& rObjectRectangle(rTableObj.GetGeoRect());
 261                     const basegfx::B2DRange aObjectRange(rObjectRectangle.Left(), rObjectRectangle.Top(), rObjectRectangle.Right(), rObjectRectangle.Bottom());
 262
 263                     // for each cell we need potentially a cell primitive and a border primitive
 264                     // (e.g. single cell). Prepare sequences and input counters
 265                     drawinglayer::primitive2d::Primitive2DContainer aBorderSequence;
 266
 267                     // create single primitives per cell
 268                     for(aCellPos.mnRow = 0; aCellPos.mnRow < nRowCount; aCellPos.mnRow++)
 269                     {
 270                         for(aCellPos.mnCol = 0; aCellPos.mnCol < nColCount; aCellPos.mnCol++)
 271                         {
 272                             xCurrentCell.set(dynamic_cast< sdr::table::Cell* >(xTable->getCellByPosition(aCellPos.mnCol, aCellPos.mnRow).get()));
 273
 274                             if(xCurrentCell.is() && !xCurrentCell->isMerged())
 275                             {
 276                                 if(rTableLayouter.getCellArea(xCurrentCell, aCellPos, aCellArea))
 277                                 {
 278                                     // create cell transformation matrix
 279                                     basegfx::B2DHomMatrix aCellMatrix;
 280                                     aCellMatrix.set(0, 0, (double)aCellArea.getWidth());
 281                                     aCellMatrix.set(1, 1, (double)aCellArea.getHeight());
 282                                     aCellMatrix.set(0, 2, (double)aCellArea.getMinX() + aObjectRange.getMinX());
 283                                     aCellMatrix.set(1, 2, (double)aCellArea.getMinY() + aObjectRange.getMinY());
 284
 285                                     // handle cell fillings and text
 286                                     const SfxItemSet& rCellItemSet = xCurrentCell->GetItemSet();
 287                                     const sal_uInt32 nTextIndex(nColCount * aCellPos.mnRow + aCellPos.mnCol);
 288                                     const SdrText* pSdrText = rTableObj.getText(nTextIndex);
 289                                     drawinglayer::attribute::SdrFillTextAttribute aAttribute;
 290
 291                                     if(pSdrText)
 292                                     {
 293                                         // #i101508# take cell's local text frame distances into account
 294                                         const sal_Int32 nLeft(xCurrentCell->GetTextLeftDistance());
 295                                         const sal_Int32 nRight(xCurrentCell->GetTextRightDistance());
 296                                         const sal_Int32 nUpper(xCurrentCell->GetTextUpperDistance());
 297                                         const sal_Int32 nLower(xCurrentCell->GetTextLowerDistance());
 298
 299                                         aAttribute = drawinglayer::primitive2d::createNewSdrFillTextAttribute(
 300                                             rCellItemSet,
 301                                             pSdrText,
 302                                             &nLeft,
 303                                             &nUpper,
 304                                             &nRight,
 305                                             &nLower);
 306                                     }
 307                                     else
 308                                     {
 309                                         aAttribute = drawinglayer::primitive2d::createNewSdrFillTextAttribute(
 310                                             rCellItemSet,
 311                                             pSdrText);
 312                                     }
 313
 314                                     // always create cell primitives for BoundRect and HitTest
 315                                     {
 316                                         const drawinglayer::primitive2d::Primitive2DReference xCellReference(
 317                                             new drawinglayer::primitive2d::SdrCellPrimitive2D(
 318                                                 aCellMatrix, aAttribute));
 319                                         aRetval.append(xCellReference);
 320                                     }
 321
 322                                     // handle cell borders
 323                                     const sal_Int32 nX(bIsRTL ? nColCount - aCellPos.mnCol : aCellPos.mnCol);
 324                                     const sal_Int32 nY(aCellPos.mnRow);
 325
 326                                     // get access values for X,Y at the cell's end
 327                                     const sal_Int32 nXSpan(xCurrentCell->getColumnSpan());
 328                                     const sal_Int32 nYSpan(xCurrentCell->getRowSpan());
 329                                     const sal_Int32 nXRight(bIsRTL ? nX - nXSpan : nX + nXSpan);
 330                                     const sal_Int32 nYBottom(nY + nYSpan);
 331
 332                                     // get basic lines
 333                                     const svx::frame::Style aLeftLine(impGetLineStyle(rTableLayouter, nX, nY, false, nColCount, nRowCount, bIsRTL));
 334                                     //To resolve the bug fdo#59117
 335                                     //In RTL table as BottomLine & TopLine are drawn from Left Side to Right, nX should be nX-1
 336                                     const svx::frame::Style aBottomLine(impGetLineStyle(rTableLayouter, bIsRTL?nX-1:nX, nYBottom, true, nColCount, nRowCount, bIsRTL));
 337                                     const svx::frame::Style aRightLine(impGetLineStyle(rTableLayouter, nXRight, nY, false, nColCount, nRowCount, bIsRTL));
 338                                     const svx::frame::Style aTopLine(impGetLineStyle(rTableLayouter, bIsRTL?nX-1:nX, nY, true, nColCount, nRowCount, bIsRTL));
 339
 340                                     if(aLeftLine.IsUsed() || aBottomLine.IsUsed() || aRightLine.IsUsed() || aTopLine.IsUsed())
 341                                     {
 342                                         // get the neighbor cells' borders
 343                                         const svx::frame::Style aLeftFromTLine(impGetLineStyle(rTableLayouter, nX, nY - 1, false, nColCount, nRowCount, bIsRTL));
 344                                         const svx::frame::Style aLeftFromBLine(impGetLineStyle(rTableLayouter, nX, nYBottom + 1, false, nColCount, nRowCount, bIsRTL));
 345                                         const svx::frame::Style aRightFromTLine(impGetLineStyle(rTableLayouter, nXRight, nY - 1, false, nColCount, nRowCount, bIsRTL));
 346                                         const svx::frame::Style aRightFromBLine(impGetLineStyle(rTableLayouter, nXRight, nYBottom + 1, false, nColCount, nRowCount, bIsRTL));
 347                                         const svx::frame::Style aTopFromLLine(impGetLineStyle(rTableLayouter, nX - 1, nY, true, nColCount, nRowCount, bIsRTL));
 348                                         const svx::frame::Style aTopFromRLine(impGetLineStyle(rTableLayouter, nXRight + 1, nY, true, nColCount, nRowCount, bIsRTL));
 349                                         const svx::frame::Style aBottomFromLLine(impGetLineStyle(rTableLayouter, nX - 1, nYBottom, true, nColCount, nRowCount, bIsRTL));
 350                                         const svx::frame::Style aBottomFromRLine(impGetLineStyle(rTableLayouter, nXRight + 1, nYBottom, true, nColCount, nRowCount, bIsRTL));
 351
 352                                         // get cell coordinate system
 353                                         const basegfx::B2DPoint aOrigin(aCellMatrix * basegfx::B2DPoint(0.0, 0.0));
 354                                         const basegfx::B2DVector aX(aCellMatrix * basegfx::B2DVector(1.0, 0.0));
 355                                         const basegfx::B2DVector aY(aCellMatrix * basegfx::B2DVector(0.0, 1.0));
 356
 357                                         if(aLeftLine.IsUsed())
 358                                         {
 359                                             createForVector(false, aBorderSequence, aOrigin, aY, aLeftLine,
 360                                                 aTopLine, aLeftFromTLine, aTopFromLLine,
 361                                                 aBottomLine, aLeftFromBLine, aBottomFromLLine);
 362                                         }
 363
 364                                         if(aBottomLine.IsUsed())
 365                                         {
 366                                             createForVector(true, aBorderSequence, aOrigin + aY, aX, aBottomLine,
 367                                                 aLeftLine, aBottomFromLLine, aLeftFromBLine,
 368                                                 aRightLine, aBottomFromRLine, aRightFromBLine);
 369                                         }
 370
 371                                         if(aRightLine.IsUsed())
 372                                         {
 373                                             createForVector(false, aBorderSequence, aOrigin + aX, aY, aRightLine,
 374                                                 aTopFromRLine, aRightFromTLine, aTopLine,
 375                                                 aBottomFromRLine, aRightFromBLine, aBottomLine);
 376                                         }
 377
 378                                         if(aTopLine.IsUsed())
 379                                         {
 380                                             createForVector(true, aBorderSequence, aOrigin, aX, aTopLine,
 381                                                 aLeftFromTLine, aTopFromLLine, aLeftLine,
 382                                                 aRightFromTLine, aTopFromRLine, aRightLine);
 383                                         }
 384                                     }
 385                                 }
 386                             }
 387                         }
 388                     }
 389
 390                     // append Border info to target. We want fillings and text first
 391                     aRetval.append(aBorderSequence);
 392                 }
 393
 394                 if(!aRetval.empty())
 395                 {
 396                     // check and create evtl. shadow for created content
 397                     const SfxItemSet& rObjectItemSet = rTableObj.GetMergedItemSet();
 398                     const drawinglayer::attribute::SdrShadowAttribute aNewShadowAttribute(
 399                         drawinglayer::primitive2d::createNewSdrShadowAttribute(rObjectItemSet));
 400
 401                     if(!aNewShadowAttribute.isDefault())
 402                     {
 403                         aRetval = drawinglayer::primitive2d::createEmbeddedShadowPrimitive(aRetval, aNewShadowAttribute);
 404                     }
 405                 }
 406
 407                 return aRetval;
 408             }
 409             else
 410             {
 411                 // take unrotated snap rect (direct model data) for position and size
 412                 const tools::Rectangle& rRectangle = rTableObj.GetGeoRect();
 413                 const basegfx::B2DRange aObjectRange(
 414                     rRectangle.Left(), rRectangle.Top(),
 415                     rRectangle.Right(), rRectangle.Bottom());
 416
 417                 // create object matrix
 418                 const GeoStat& rGeoStat(rTableObj.GetGeoStat());
 419                 const double fShearX(rGeoStat.nShearAngle ? tan((36000 - rGeoStat.nShearAngle) * F_PI18000) : 0.0);
 420                 const double fRotate(rGeoStat.nRotationAngle ? (36000 - rGeoStat.nRotationAngle) * F_PI18000 : 0.0);
 421                 const basegfx::B2DHomMatrix aObjectMatrix(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
 422                     aObjectRange.getWidth(), aObjectRange.getHeight(), fShearX, fRotate,
 423                     aObjectRange.getMinX(), aObjectRange.getMinY()));
 424
 425                 // created an invisible outline for the cases where no visible content exists
 426                 const drawinglayer::primitive2d::Primitive2DReference xReference(
 427                     drawinglayer::primitive2d::createHiddenGeometryPrimitives2D(
 428                         aObjectMatrix));
 429
 430                 return drawinglayer::primitive2d::Primitive2DContainer { xReference };
 431             }
 432         }
 433
 434         ViewContactOfTableObj::ViewContactOfTableObj(sdr::table::SdrTableObj& rTableObj)
 435         :   ViewContactOfSdrObj(rTableObj)
 436         {
 437         }
 438
 439         ViewContactOfTableObj::~ViewContactOfTableObj()
 440         {
 441         }
 442     } // end of namespace contact
 443 } // end of namespace sdr
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */