svx/source/table/tablehandles.cxx

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