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