svx/source/table/tablehandles.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 "tablehandles.hxx"
  22
  23 #include <vcl/svapp.hxx>
  24 #include <vcl/outdev.hxx>
  25 #include <vcl/canvastools.hxx>
  26 #include <vcl/hatch.hxx>
  27 #include <vcl/ptrstyle.hxx>
  28 #include <basegfx/polygon/b2dpolygon.hxx>
  29 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  30 #include <basegfx/range/b2drectangle.hxx>
  31 #include <basegfx/polygon/b2dpolygontools.hxx>
  32 #include <svx/sdr/overlay/overlayobject.hxx>
  33 #include <svx/sdr/overlay/overlaymanager.hxx>
  34 #include <svx/sdrpagewindow.hxx>
  35 #include <svx/sdrpaintwindow.hxx>
  36 #include <svx/svdmrkv.hxx>
  37 #include <svx/svdpagv.hxx>
  38 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  39 #include <sdr/overlay/overlayrectangle.hxx>
  40 #include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx>
  41
  42 namespace sdr { namespace table {
  43
  44
  45 class OverlayTableEdge : public sdr::overlay::OverlayObject
  46 {
  47 protected:
  48     basegfx::B2DPolyPolygon const maPolyPolygon;
  49     bool const                    mbVisible;
  50
  51     // geometry creation for OverlayObject
  52     virtual drawinglayer::primitive2d::Primitive2DContainer createOverlayObjectPrimitive2DSequence() override;
  53
  54 public:
  55     OverlayTableEdge( const basegfx::B2DPolyPolygon& rPolyPolygon, bool bVisible );
  56 };
  57
  58
  59 TableEdgeHdl::TableEdgeHdl( const Point& rPnt, bool bHorizontal, sal_Int32 nMin, sal_Int32 nMax, sal_Int32 nEdges )
  60 : SdrHdl( rPnt, SdrHdlKind::User )
  61 , mbHorizontal( bHorizontal )
  62 , mnMin( nMin )
  63 , mnMax( nMax )
  64 , maEdges(nEdges)
  65 {
  66 }
  67
  68 void TableEdgeHdl::SetEdge( sal_Int32 nEdge, sal_Int32 nStart, sal_Int32 nEnd, TableEdgeState eState )
  69 {
  70     if( (nEdge >= 0) && (nEdge <= sal::static_int_cast<sal_Int32>(maEdges.size())) )
  71     {
  72         maEdges[nEdge].mnStart = nStart;
  73         maEdges[nEdge].mnEnd = nEnd;
  74         maEdges[nEdge].meState = eState;
  75     }
  76     else
  77     {
  78         OSL_FAIL( "sdr::table::TableEdgeHdl::SetEdge(), invalid edge!" );
  79     }
  80 }
  81
  82 PointerStyle TableEdgeHdl::GetPointer() const
  83 {
  84     if( mbHorizontal )
  85         return PointerStyle::VSplit;
  86     else
  87         return PointerStyle::HSplit;
  88 }
  89
  90 sal_Int32 TableEdgeHdl::GetValidDragOffset( const SdrDragStat& rDrag ) const
  91 {
  92     return std::min( std::max( static_cast<sal_Int32>(mbHorizontal ? rDrag.GetDY() : rDrag.GetDX()), mnMin ), mnMax );
  93 }
  94
  95 basegfx::B2DPolyPolygon TableEdgeHdl::getSpecialDragPoly(const SdrDragStat& rDrag) const
  96 {
  97     basegfx::B2DPolyPolygon aVisible;
  98     basegfx::B2DPolyPolygon aInvisible;
  99
 100     // create and return visible and non-visible parts for drag
 101     getPolyPolygon(aVisible, aInvisible, &rDrag);
 102     aVisible.append(aInvisible);
 103
 104     return aVisible;
 105 }
 106
 107 void TableEdgeHdl::getPolyPolygon(basegfx::B2DPolyPolygon& rVisible, basegfx::B2DPolyPolygon& rInvisible, const SdrDragStat* pDrag) const
 108 {
 109     // changed method to create visible and invisible partial polygons in one run in
 110     // separate PolyPolygons; both kinds are used
 111     basegfx::B2DPoint aOffset(aPos.X(), aPos.Y());
 112     rVisible.clear();
 113     rInvisible.clear();
 114
 115     if( pDrag )
 116     {
 117         int n = mbHorizontal ? 1 : 0;
 118         aOffset[n] = aOffset[n] + GetValidDragOffset( *pDrag );
 119     }
 120
 121     basegfx::B2DPoint aStart(aOffset), aEnd(aOffset);
 122     int nPos = mbHorizontal ? 0 : 1;
 123
 124     for( const TableEdge& aEdge : maEdges )
 125     {
 126         aStart[nPos] = aOffset[nPos] + aEdge.mnStart;
 127         aEnd[nPos] = aOffset[nPos] + aEdge.mnEnd;
 128
 129         basegfx::B2DPolygon aPolygon;
 130         aPolygon.append( aStart );
 131         aPolygon.append( aEnd );
 132
 133         if(aEdge.meState == Visible)
 134         {
 135             rVisible.append(aPolygon);
 136         }
 137         else
 138         {
 139             rInvisible.append(aPolygon);
 140         }
 141     }
 142 }
 143
 144 void TableEdgeHdl::CreateB2dIAObject()
 145 {
 146     GetRidOfIAObject();
 147
 148     if(pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden())
 149     {
 150         SdrMarkView* pView = pHdlList->GetView();
 151         SdrPageView* pPageView = pView->GetSdrPageView();
 152
 153         if(pPageView)
 154         {
 155             basegfx::B2DPolyPolygon aVisible;
 156             basegfx::B2DPolyPolygon aInvisible;
 157
 158             // get visible and invisible parts
 159             getPolyPolygon(aVisible, aInvisible, nullptr);
 160
 161             if(aVisible.count() || aInvisible.count())
 162             {
 163                 for(sal_uInt32 nWindow = 0; nWindow < pPageView->PageWindowCount(); nWindow++)
 164                 {
 165                     const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(nWindow);
 166
 167                     if(rPageWindow.GetPaintWindow().OutputToWindow())
 168                     {
 169                         const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager();
 170                         if (xManager.is())
 171                         {
 172                             if(aVisible.count())
 173                             {
 174                                 // create overlay object for visible parts
 175                                 std::unique_ptr<sdr::overlay::OverlayObject> pOverlayObject(new OverlayTableEdge(aVisible, true));
 176
 177                                 // OVERLAYMANAGER
 178                                 insertNewlyCreatedOverlayObjectForSdrHdl(
 179                                     std::move(pOverlayObject),
 180                                     rPageWindow.GetObjectContact(),
 181                                     *xManager);
 182                             }
 183
 184                             if(aInvisible.count())
 185                             {
 186                                 // also create overlay object for invisible parts to allow
 187                                 // a standard HitTest using the primitives from that overlay object
 188                                 // (see OverlayTableEdge implementation)
 189                                 std::unique_ptr<sdr::overlay::OverlayObject> pOverlayObject(new OverlayTableEdge(aInvisible, false));
 190
 191                                 // OVERLAYMANAGER
 192                                 insertNewlyCreatedOverlayObjectForSdrHdl(
 193                                     std::move(pOverlayObject),
 194                                     rPageWindow.GetObjectContact(),
 195                                     *xManager);
 196                             }
 197                         }
 198                     }
 199                 }
 200             }
 201         }
 202     }
 203 }
 204
 205
 206 OverlayTableEdge::OverlayTableEdge( const basegfx::B2DPolyPolygon& rPolyPolygon, bool bVisible )
 207 :   OverlayObject(COL_GRAY)
 208 ,   maPolyPolygon( rPolyPolygon )
 209 ,   mbVisible(bVisible)
 210 {
 211 }
 212
 213 drawinglayer::primitive2d::Primitive2DContainer OverlayTableEdge::createOverlayObjectPrimitive2DSequence()
 214 {
 215     drawinglayer::primitive2d::Primitive2DContainer aRetval;
 216
 217     if(maPolyPolygon.count())
 218     {
 219         // Discussed with CL. Currently i will leave the transparence out since this
 220         // a little bit expensive. We may check the look with drag polygons later
 221         const drawinglayer::primitive2d::Primitive2DReference aReference(
 222             new drawinglayer::primitive2d::PolyPolygonHairlinePrimitive2D(
 223                 maPolyPolygon,
 224                 getBaseColor().getBColor()));
 225
 226         if(mbVisible)
 227         {
 228             // visible, just return as sequence
 229             aRetval = drawinglayer::primitive2d::Primitive2DContainer { aReference };
 230         }
 231         else
 232         {
 233             // embed in HiddenGeometryPrimitive2D to support HitTest of this invisible
 234             // overlay object
 235             const drawinglayer::primitive2d::Primitive2DContainer aSequence { aReference };
 236             const drawinglayer::primitive2d::Primitive2DReference aNewReference(
 237                 new drawinglayer::primitive2d::HiddenGeometryPrimitive2D(aSequence));
 238             aRetval = drawinglayer::primitive2d::Primitive2DContainer { aNewReference };
 239         }
 240     }
 241
 242     return aRetval;
 243 }
 244
 245
 246 TableBorderHdl::TableBorderHdl(
 247     const tools::Rectangle& rRect,
 248     bool bAnimate)
 249 :   SdrHdl(rRect.TopLeft(), SdrHdlKind::Move),
 250     maRectangle(rRect),
 251     mbAnimate(bAnimate)
 252 {
 253 }
 254
 255 PointerStyle TableBorderHdl::GetPointer() const
 256 {
 257     return PointerStyle::Move;
 258 }
 259
 260 // create marker for this kind
 261 void TableBorderHdl::CreateB2dIAObject()
 262 {
 263     GetRidOfIAObject();
 264
 265     if (pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden())
 266     {
 267         SdrMarkView* pView = pHdlList->GetView();
 268         SdrPageView* pPageView = pView->GetSdrPageView();
 269
 270         if (!pPageView)
 271             return;
 272
 273         for(sal_uInt32 nWindow = 0; nWindow < pPageView->PageWindowCount(); nWindow++)
 274         {
 275             const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(nWindow);
 276
 277             if (rPageWindow.GetPaintWindow().OutputToWindow())
 278             {
 279                 const rtl::Reference<sdr::overlay::OverlayManager>& xManager = rPageWindow.GetOverlayManager();
 280
 281                 if (xManager.is())
 282                 {
 283                     const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(maRectangle);
 284                     const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
 285                     const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor());
 286                     const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
 287                     // make animation dependent from text edit active, because for tables
 288                     // this handle is also used when text edit *is* active for it. This
 289                     // interferes too much concerning repaint stuff (at least as long as
 290                     // text edit is not yet on the overlay)
 291                     const bool bAnimate = getAnimate();
 292
 293                     OutputDevice& rOutDev = rPageWindow.GetPaintWindow().GetOutputDevice();
 294                     float fScaleFactor = rOutDev.GetDPIScaleFactor();
 295                     double fWidth = fScaleFactor * 6.0;
 296
 297                     std::unique_ptr<sdr::overlay::OverlayObject> pOverlayObject(
 298                         new sdr::overlay::OverlayRectangle(aRange.getMinimum(), aRange.getMaximum(),
 299                                                            aHilightColor, fTransparence,
 300                                                            fWidth, 0.0, 0.0, bAnimate));
 301
 302                     // OVERLAYMANAGER
 303                     insertNewlyCreatedOverlayObjectForSdrHdl(
 304                         std::move(pOverlayObject),
 305                         rPageWindow.GetObjectContact(),
 306                         *xManager);
 307                 }
 308             }
 309         }
 310     }
 311 }
 312
 313
 314 } // end of namespace table
 315 } // end of namespace sdr
 316
 317 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */