| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| #include "tablehandles.hxx" |
| |
| #include <vcl/svapp.hxx> |
| #include <vcl/outdev.hxx> |
| #include <vcl/salbtype.hxx> |
| #include <vcl/canvastools.hxx> |
| #include <vcl/hatch.hxx> |
| #include <basegfx/polygon/b2dpolygon.hxx> |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> |
| #include <basegfx/range/b2drectangle.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <svx/sdr/overlay/overlayobject.hxx> |
| #include <svx/sdr/overlay/overlaymanager.hxx> |
| #include <svx/sdrpagewindow.hxx> |
| #include <svx/sdrpaintwindow.hxx> |
| #include <svx/svdmrkv.hxx> |
| #include <svx/svdpagv.hxx> |
| #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx> |
| #include <svx/sdr/overlay/overlayrectangle.hxx> |
| #include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx> |
| |
| namespace sdr { namespace table { |
| |
| // -------------------------------------------------------------------- |
| |
| class OverlayTableEdge : public sdr::overlay::OverlayObject |
| { |
| protected: |
| basegfx::B2DPolyPolygon maPolyPolygon; |
| bool mbVisible; |
| |
| // geometry creation for OverlayObject |
| virtual drawinglayer::primitive2d::Primitive2DSequence createOverlayObjectPrimitive2DSequence(); |
| |
| public: |
| OverlayTableEdge( const basegfx::B2DPolyPolygon& rPolyPolygon, bool bVisible ); |
| virtual ~OverlayTableEdge(); |
| }; |
| |
| // -------------------------------------------------------------------- |
| |
| TableEdgeHdl::TableEdgeHdl( const Point& rPnt, bool bHorizontal, sal_Int32 nMin, sal_Int32 nMax, sal_Int32 nEdges ) |
| : SdrHdl( rPnt, HDL_USER ) |
| , mbHorizontal( bHorizontal ) |
| , mnMin( nMin ) |
| , mnMax( nMax ) |
| , maEdges(nEdges) |
| { |
| } |
| |
| void TableEdgeHdl::SetEdge( sal_Int32 nEdge, sal_Int32 nStart, sal_Int32 nEnd, TableEdgeState eState ) |
| { |
| if( (nEdge >= 0) && (nEdge <= sal::static_int_cast<sal_Int32>(maEdges.size())) ) |
| { |
| maEdges[nEdge].mnStart = nStart; |
| maEdges[nEdge].mnEnd = nEnd; |
| maEdges[nEdge].meState = eState; |
| } |
| else |
| { |
| OSL_ENSURE( false, "sdr::table::TableEdgeHdl::SetEdge(), invalid edge!" ); |
| } |
| } |
| |
| Pointer TableEdgeHdl::GetPointer() const |
| { |
| if( mbHorizontal ) |
| return POINTER_VSPLIT; |
| else |
| return POINTER_HSPLIT; |
| } |
| |
| sal_Int32 TableEdgeHdl::GetValidDragOffset( const SdrDragStat& rDrag ) const |
| { |
| return std::min( std::max( static_cast<sal_Int32>(mbHorizontal ? rDrag.GetDY() : rDrag.GetDX()), mnMin ), mnMax ); |
| } |
| |
| basegfx::B2DPolyPolygon TableEdgeHdl::getSpecialDragPoly(const SdrDragStat& rDrag) const |
| { |
| basegfx::B2DPolyPolygon aVisible; |
| basegfx::B2DPolyPolygon aInvisible; |
| |
| // create and return visible and non-visible parts for drag |
| getPolyPolygon(aVisible, aInvisible, &rDrag); |
| aVisible.append(aInvisible); |
| |
| return aVisible; |
| } |
| |
| void TableEdgeHdl::getPolyPolygon(basegfx::B2DPolyPolygon& rVisible, basegfx::B2DPolyPolygon& rInvisible, const SdrDragStat* pDrag) const |
| { |
| // changed method to create visible and invisible partial polygons in one run in |
| // separate PolyPolygons; both kinds are used |
| basegfx::B2DPoint aOffset(aPos.X(), aPos.Y()); |
| rVisible.clear(); |
| rInvisible.clear(); |
| |
| if( pDrag ) |
| { |
| int n = mbHorizontal ? 1 : 0; |
| aOffset[n] = aOffset[n] + GetValidDragOffset( *pDrag ); |
| } |
| |
| basegfx::B2DPoint aStart(aOffset), aEnd(aOffset); |
| int nPos = mbHorizontal ? 0 : 1; |
| TableEdgeVector::const_iterator aIter( maEdges.begin() ); |
| |
| while( aIter != maEdges.end() ) |
| { |
| TableEdge aEdge(*aIter++); |
| |
| aStart[nPos] = aOffset[nPos] + aEdge.mnStart; |
| aEnd[nPos] = aOffset[nPos] + aEdge.mnEnd; |
| |
| basegfx::B2DPolygon aPolygon; |
| aPolygon.append( aStart ); |
| aPolygon.append( aEnd ); |
| |
| if(aEdge.meState == Visible) |
| { |
| rVisible.append(aPolygon); |
| } |
| else |
| { |
| rInvisible.append(aPolygon); |
| } |
| } |
| } |
| |
| void TableEdgeHdl::CreateB2dIAObject() |
| { |
| GetRidOfIAObject(); |
| |
| if(pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden()) |
| { |
| SdrMarkView* pView = pHdlList->GetView(); |
| SdrPageView* pPageView = pView->GetSdrPageView(); |
| |
| if(pPageView) |
| { |
| basegfx::B2DPolyPolygon aVisible; |
| basegfx::B2DPolyPolygon aInvisible; |
| |
| // get visible and invisible parts |
| getPolyPolygon(aVisible, aInvisible, 0); |
| |
| if(aVisible.count() || aInvisible.count()) |
| { |
| for(sal_uInt32 nWindow = 0; nWindow < pPageView->PageWindowCount(); nWindow++) |
| { |
| const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(nWindow); |
| |
| if(rPageWindow.GetPaintWindow().OutputToWindow()) |
| { |
| if(rPageWindow.GetOverlayManager()) |
| { |
| if(aVisible.count()) |
| { |
| // create overlay object for visible parts |
| sdr::overlay::OverlayObject* pOverlayObject = new OverlayTableEdge(aVisible, true); |
| rPageWindow.GetOverlayManager()->add(*pOverlayObject); |
| maOverlayGroup.append(*pOverlayObject); |
| } |
| |
| if(aInvisible.count()) |
| { |
| // also create overlay object vor invisible parts to allow |
| // a standard HitTest using the primitives from that overlay object |
| // (see OverlayTableEdge implementation) |
| sdr::overlay::OverlayObject* pOverlayObject = new OverlayTableEdge(aInvisible, false); |
| rPageWindow.GetOverlayManager()->add(*pOverlayObject); |
| maOverlayGroup.append(*pOverlayObject); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| OverlayTableEdge::OverlayTableEdge( const basegfx::B2DPolyPolygon& rPolyPolygon, bool bVisible ) |
| : OverlayObject(Color(COL_GRAY)) |
| , maPolyPolygon( rPolyPolygon ) |
| , mbVisible(bVisible) |
| { |
| } |
| |
| OverlayTableEdge::~OverlayTableEdge() |
| { |
| } |
| |
| drawinglayer::primitive2d::Primitive2DSequence OverlayTableEdge::createOverlayObjectPrimitive2DSequence() |
| { |
| drawinglayer::primitive2d::Primitive2DSequence aRetval; |
| |
| if(maPolyPolygon.count()) |
| { |
| // Discussed with CL. Currently i will leave the transparence out since this |
| // a little bit expensive. We may check the look with drag polygons later |
| const drawinglayer::primitive2d::Primitive2DReference aReference( |
| new drawinglayer::primitive2d::PolyPolygonHairlinePrimitive2D( |
| maPolyPolygon, |
| getBaseColor().getBColor())); |
| |
| if(mbVisible) |
| { |
| // visible, just return as sequence |
| aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aReference, 1); |
| } |
| else |
| { |
| // embed in HiddenGeometryPrimitive2D to support HitTest of this invisible |
| // overlay object |
| const drawinglayer::primitive2d::Primitive2DSequence aSequence(&aReference, 1); |
| const drawinglayer::primitive2d::Primitive2DReference aNewReference( |
| new drawinglayer::primitive2d::HiddenGeometryPrimitive2D(aSequence)); |
| aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aNewReference, 1); |
| } |
| } |
| |
| return aRetval; |
| } |
| |
| // ==================================================================== |
| |
| TableBorderHdl::TableBorderHdl( |
| const Rectangle& rRect, |
| bool bAnimate) |
| : SdrHdl(rRect.TopLeft(), HDL_MOVE), |
| maRectangle(rRect), |
| mbAnimate(bAnimate) |
| { |
| } |
| |
| Pointer TableBorderHdl::GetPointer() const |
| { |
| return POINTER_MOVE; |
| } |
| |
| // create marker for this kind |
| void TableBorderHdl::CreateB2dIAObject() |
| { |
| GetRidOfIAObject(); |
| |
| if(pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden()) |
| { |
| SdrMarkView* pView = pHdlList->GetView(); |
| SdrPageView* pPageView = pView->GetSdrPageView(); |
| |
| if(pPageView) |
| { |
| for(sal_uInt32 nWindow = 0; nWindow < pPageView->PageWindowCount(); nWindow++) |
| { |
| const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(nWindow); |
| |
| if(rPageWindow.GetPaintWindow().OutputToWindow()) |
| { |
| if(rPageWindow.GetOverlayManager()) |
| { |
| const basegfx::B2DRange aRange(vcl::unotools::b2DRectangleFromRectangle(maRectangle)); |
| const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer; |
| const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor()); |
| const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01); |
| |
| sdr::overlay::OverlayObject* pOverlayObject = new sdr::overlay::OverlayRectangle( |
| aRange.getMinimum(), |
| aRange.getMaximum(), |
| aHilightColor, |
| fTransparence, |
| 6.0, |
| 0.0, |
| 0.0, |
| 500, |
| // make animation dependent from text edit active, because for tables |
| // this handle is also used when text edit *is* active for it. This |
| // interferes too much concerning repaint stuff (at least as long as |
| // text edit is not yet on the overlay) |
| getAnimate()); |
| |
| rPageWindow.GetOverlayManager()->add(*pOverlayObject); |
| maOverlayGroup.append(*pOverlayObject); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| } // end of namespace table |
| } // end of namespace sdr |