svx/source/table/tablehandles.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include "tablehandles.hxx"
  31
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/outdev.hxx>
  34 #include <vcl/salbtype.hxx>
  35 #include <vcl/canvastools.hxx>
  36 #include <vcl/hatch.hxx>
  37 #include <basegfx/polygon/b2dpolygon.hxx>
  38 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  39 #include <basegfx/range/b2drectangle.hxx>
  40 #include <basegfx/polygon/b2dpolygontools.hxx>
  41 #include <svx/sdr/overlay/overlayobject.hxx>
  42 #include <svx/sdr/overlay/overlaymanager.hxx>
  43 #include <svx/sdrpagewindow.hxx>
  44 #include <svx/sdrpaintwindow.hxx>
  45 #include <svx/svdmrkv.hxx>
  46 #include <svx/svdpagv.hxx>
  47 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  48 #include <svx/sdr/overlay/overlayhatchrect.hxx>
  49 #include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx>
  50
  51 namespace sdr { namespace table {
  52
  53 // --------------------------------------------------------------------
  54
  55 class OverlayTableEdge : public sdr::overlay::OverlayObject
  56 {
  57 protected:
  58     basegfx::B2DPolyPolygon maPolyPolygon;
  59     bool                    mbVisible;
  60
  61     // geometry creation for OverlayObject
  62     virtual drawinglayer::primitive2d::Primitive2DSequence createOverlayObjectPrimitive2DSequence();
  63
  64 public:
  65     OverlayTableEdge( const basegfx::B2DPolyPolygon& rPolyPolygon, bool bVisible );
  66     virtual ~OverlayTableEdge();
  67 };
  68
  69 // --------------------------------------------------------------------
  70
  71 TableEdgeHdl::TableEdgeHdl( const Point& rPnt, bool bHorizontal, sal_Int32 nMin, sal_Int32 nMax, sal_Int32 nEdges )
  72 : SdrHdl( rPnt, HDL_USER )
  73 , mbHorizontal( bHorizontal )
  74 , mnMin( nMin )
  75 , mnMax( nMax )
  76 , maEdges(nEdges)
  77 {
  78 }
  79
  80 void TableEdgeHdl::SetEdge( sal_Int32 nEdge, sal_Int32 nStart, sal_Int32 nEnd, TableEdgeState eState )
  81 {
  82     if( (nEdge >= 0) && (nEdge <= sal::static_int_cast<sal_Int32>(maEdges.size())) )
  83     {
  84         maEdges[nEdge].mnStart = nStart;
  85         maEdges[nEdge].mnEnd = nEnd;
  86         maEdges[nEdge].meState = eState;
  87     }
  88     else
  89     {
  90         OSL_FAIL( "sdr::table::TableEdgeHdl::SetEdge(), invalid edge!" );
  91     }
  92 }
  93
  94 Pointer TableEdgeHdl::GetPointer() const
  95 {
  96     if( mbHorizontal )
  97         return POINTER_VSPLIT;
  98     else
  99         return POINTER_HSPLIT;
 100 }
 101
 102 sal_Int32 TableEdgeHdl::GetValidDragOffset( const SdrDragStat& rDrag ) const
 103 {
 104     return std::min( std::max( static_cast<sal_Int32>(mbHorizontal ? rDrag.GetDY() : rDrag.GetDX()), mnMin ), mnMax );
 105 }
 106
 107 basegfx::B2DPolyPolygon TableEdgeHdl::getSpecialDragPoly(const SdrDragStat& rDrag) const
 108 {
 109     basegfx::B2DPolyPolygon aVisible;
 110     basegfx::B2DPolyPolygon aInvisible;
 111
 112     // create and return visible and non-visible parts for drag
 113     getPolyPolygon(aVisible, aInvisible, &rDrag);
 114     aVisible.append(aInvisible);
 115
 116     return aVisible;
 117 }
 118
 119 void TableEdgeHdl::getPolyPolygon(basegfx::B2DPolyPolygon& rVisible, basegfx::B2DPolyPolygon& rInvisible, const SdrDragStat* pDrag) const
 120 {
 121     // changed method to create visible and invisible partial polygons in one run in
 122     // separate PolyPolygons; both kinds are used
 123     basegfx::B2DPoint aOffset(aPos.X(), aPos.Y());
 124     rVisible.clear();
 125     rInvisible.clear();
 126
 127     if( pDrag )
 128     {
 129         int n = mbHorizontal ? 1 : 0;
 130         aOffset[n] = aOffset[n] + GetValidDragOffset( *pDrag );
 131     }
 132
 133     basegfx::B2DPoint aStart(aOffset), aEnd(aOffset);
 134     int nPos = mbHorizontal ? 0 : 1;
 135     TableEdgeVector::const_iterator aIter( maEdges.begin() );
 136
 137     while( aIter != maEdges.end() )
 138     {
 139         TableEdge aEdge(*aIter++);
 140
 141         aStart[nPos] = aOffset[nPos] + aEdge.mnStart;
 142         aEnd[nPos] = aOffset[nPos] + aEdge.mnEnd;
 143
 144         basegfx::B2DPolygon aPolygon;
 145         aPolygon.append( aStart );
 146         aPolygon.append( aEnd );
 147
 148         if(aEdge.meState == Visible)
 149         {
 150             rVisible.append(aPolygon);
 151         }
 152         else
 153         {
 154             rInvisible.append(aPolygon);
 155         }
 156     }
 157 }
 158
 159 void TableEdgeHdl::CreateB2dIAObject()
 160 {
 161     GetRidOfIAObject();
 162
 163     if(pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden())
 164     {
 165         SdrMarkView* pView = pHdlList->GetView();
 166         SdrPageView* pPageView = pView->GetSdrPageView();
 167
 168         if(pPageView)
 169         {
 170             basegfx::B2DPolyPolygon aVisible;
 171             basegfx::B2DPolyPolygon aInvisible;
 172
 173             // get visible and invisible parts
 174             getPolyPolygon(aVisible, aInvisible, 0);
 175
 176             if(aVisible.count() || aInvisible.count())
 177             {
 178                 for(sal_uInt32 nWindow = 0; nWindow < pPageView->PageWindowCount(); nWindow++)
 179                 {
 180                     const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(nWindow);
 181
 182                     if(rPageWindow.GetPaintWindow().OutputToWindow())
 183                     {
 184                         rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
 185                         if (xManager.is())
 186                         {
 187                             if(aVisible.count())
 188                             {
 189                                 // create overlay object for visible parts
 190                                 sdr::overlay::OverlayObject* pOverlayObject = new OverlayTableEdge(aVisible, true);
 191                                 xManager->add(*pOverlayObject);
 192                                 maOverlayGroup.append(*pOverlayObject);
 193                             }
 194
 195                             if(aInvisible.count())
 196                             {
 197                                 // also create overlay object vor invisible parts to allow
 198                                 // a standard HitTest using the primitives from that overlay object
 199                                 // (see OverlayTableEdge implementation)
 200                                 sdr::overlay::OverlayObject* pOverlayObject = new OverlayTableEdge(aInvisible, false);
 201                                 xManager->add(*pOverlayObject);
 202                                 maOverlayGroup.append(*pOverlayObject);
 203                             }
 204                         }
 205                     }
 206                 }
 207             }
 208         }
 209     }
 210 }
 211
 212 //////////////////////////////////////////////////////////////////////////////
 213
 214 OverlayTableEdge::OverlayTableEdge( const basegfx::B2DPolyPolygon& rPolyPolygon, bool bVisible )
 215 :   OverlayObject(Color(COL_GRAY))
 216 ,   maPolyPolygon( rPolyPolygon )
 217 ,   mbVisible(bVisible)
 218 {
 219 }
 220
 221 OverlayTableEdge::~OverlayTableEdge()
 222 {
 223 }
 224
 225 drawinglayer::primitive2d::Primitive2DSequence OverlayTableEdge::createOverlayObjectPrimitive2DSequence()
 226 {
 227     drawinglayer::primitive2d::Primitive2DSequence aRetval;
 228
 229     if(maPolyPolygon.count())
 230     {
 231         // Discussed with CL. Currently i will leave the transparence out since this
 232         // a little bit expensive. We may check the look with drag polygons later
 233         const drawinglayer::primitive2d::Primitive2DReference aReference(
 234             new drawinglayer::primitive2d::PolyPolygonHairlinePrimitive2D(
 235                 maPolyPolygon,
 236                 getBaseColor().getBColor()));
 237
 238         if(mbVisible)
 239         {
 240             // visible, just return as sequence
 241             aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aReference, 1);
 242         }
 243         else
 244         {
 245             // embed in HiddenGeometryPrimitive2D to support HitTest of this invisible
 246             // overlay object
 247             const drawinglayer::primitive2d::Primitive2DSequence aSequence(&aReference, 1);
 248             const drawinglayer::primitive2d::Primitive2DReference aNewReference(
 249                 new drawinglayer::primitive2d::HiddenGeometryPrimitive2D(aSequence));
 250             aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aNewReference, 1);
 251         }
 252     }
 253
 254     return aRetval;
 255 }
 256
 257 // ====================================================================
 258
 259 TableBorderHdl::TableBorderHdl( const Rectangle& rRect )
 260 : SdrHdl( rRect.TopLeft(), HDL_MOVE )
 261 , maRectangle( rRect )
 262 {
 263
 264 }
 265
 266 Pointer TableBorderHdl::GetPointer() const
 267 {
 268     return POINTER_MOVE;
 269 }
 270
 271 // create marker for this kind
 272 void TableBorderHdl::CreateB2dIAObject()
 273 {
 274     GetRidOfIAObject();
 275
 276     if(pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden())
 277     {
 278         SdrMarkView* pView = pHdlList->GetView();
 279         SdrPageView* pPageView = pView->GetSdrPageView();
 280
 281         if(pPageView)
 282         {
 283             for(sal_uInt32 nWindow = 0; nWindow < pPageView->PageWindowCount(); nWindow++)
 284             {
 285                 // const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b];
 286                 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(nWindow);
 287
 288                 if(rPageWindow.GetPaintWindow().OutputToWindow())
 289                 {
 290                     rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
 291                     if (xManager.is())
 292                     {
 293                         const basegfx::B2DRange aRange(vcl::unotools::b2DRectangleFromRectangle(maRectangle));
 294                         sdr::overlay::OverlayObject* pOverlayObject = new sdr::overlay::OverlayHatchRect(
 295                             aRange.getMinimum(),
 296                             aRange.getMaximum(),
 297                             Color(0x80, 0x80, 0x80),
 298                             6.0,
 299                             0.0,
 300                             45 * F_PI180,
 301                             0.0);
 302
 303                         xManager->add(*pOverlayObject);
 304                         maOverlayGroup.append(*pOverlayObject);
 305                     }
 306                 }
 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: */