/**************************************************************
*
* 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.
*
*************************************************************/
#include "precompiled_reportdesign.hxx"
#include "ViewsWindow.hxx"
#include "ScrollHelper.hxx"
#include "UndoActions.hxx"
#include "ReportWindow.hxx"
#include "DesignView.hxx"
#include <svtools/colorcfg.hxx>
#include "ReportController.hxx"
#include "UITools.hxx"
#include "RptDef.hxx"
#include "RptResId.hrc"
#include "SectionView.hxx"
#include "ReportSection.hxx"
#include "uistrings.hrc"
#include "rptui_slotid.hrc"
#include "dlgedclip.hxx"
#include "ColorChanger.hxx"
#include "RptObject.hxx"
#include "RptObject.hxx"
#include "ModuleHelper.hxx"
#include "EndMarker.hxx"
#include <svx/svdpagv.hxx>
#include <svx/unoshape.hxx>
#include <vcl/svapp.hxx>
#include <boost/bind.hpp>
#include "helpids.hrc"
#include <svx/svdundo.hxx>
#include <toolkit/helper/convert.hxx>
#include <algorithm>
#include <numeric>
namespace rptui
{
#define DEFAUL_MOVE_SIZE 100
using namespace ::com::sun::star;
using namespace ::comphelper;
// -----------------------------------------------------------------------------
bool lcl_getNewRectSize(const Rectangle& _aObjRect,long& _nXMov, long& _nYMov,SdrObject* _pObj,SdrView* _pView,sal_Int32 _nControlModification, bool _bBoundRects)
{
bool bMoveAllowed = _nXMov != 0 || _nYMov != 0;
if ( bMoveAllowed )
{
Rectangle aNewRect = _aObjRect;
SdrObject* pOverlappedObj = NULL;
do
{
aNewRect = _aObjRect;
switch(_nControlModification)
{
case ControlModification::HEIGHT_GREATEST:
case ControlModification::WIDTH_GREATEST:
aNewRect.setWidth(_nXMov);
aNewRect.setHeight(_nYMov);
break;
default:
aNewRect.Move(_nXMov,_nYMov);
break;
}
if (dynamic_cast<OUnoObject*>(_pObj) != NULL || dynamic_cast<OOle2Obj*>(_pObj) != NULL)
{
pOverlappedObj = isOver(aNewRect,*_pObj->GetPage(),*_pView,true,_pObj);
if ( pOverlappedObj && _pObj != pOverlappedObj )
{
Rectangle aOverlappingRect = (_bBoundRects ? pOverlappedObj->GetCurrentBoundRect() : pOverlappedObj->GetSnapRect());
sal_Int32 nXTemp = _nXMov;
sal_Int32 nYTemp = _nYMov;
switch(_nControlModification)
{
case ControlModification::LEFT:
nXTemp += aOverlappingRect.Right() - aNewRect.Left();
bMoveAllowed = _nXMov != nXTemp;
break;
case ControlModification::RIGHT:
nXTemp += aOverlappingRect.Left() - aNewRect.Right();
bMoveAllowed = _nXMov != nXTemp;
break;
case ControlModification::TOP:
nYTemp += aOverlappingRect.Bottom() - aNewRect.Top();
bMoveAllowed = _nYMov != nYTemp;
break;
case ControlModification::BOTTOM:
nYTemp += aOverlappingRect.Top() - aNewRect.Bottom();
bMoveAllowed = _nYMov != nYTemp;
break;
case ControlModification::CENTER_HORIZONTAL:
if ( _aObjRect.Left() < aOverlappingRect.Left() )
nXTemp += aOverlappingRect.Left() - aNewRect.Left() - aNewRect.getWidth();
else
nXTemp += aOverlappingRect.Right() - aNewRect.Left();
bMoveAllowed = _nXMov != nXTemp;
break;
case ControlModification::CENTER_VERTICAL:
if ( _aObjRect.Top() < aOverlappingRect.Top() )
nYTemp += aOverlappingRect.Top() - aNewRect.Top() - aNewRect.getHeight();
else
nYTemp += aOverlappingRect.Bottom() - aNewRect.Top();
bMoveAllowed = _nYMov != nYTemp;
break;
case ControlModification::HEIGHT_GREATEST:
case ControlModification::WIDTH_GREATEST:
{
Rectangle aIntersectionRect = aNewRect.GetIntersection(aOverlappingRect);
if ( !aIntersectionRect.IsEmpty() )
{
if ( _nControlModification == ControlModification::WIDTH_GREATEST )
{
if ( aNewRect.Left() < aIntersectionRect.Left() )
{
aNewRect.Right() = aIntersectionRect.Left();
}
else if ( aNewRect.Left() < aIntersectionRect.Right() )
{
aNewRect.Left() = aIntersectionRect.Right();
}
}
else if ( _nControlModification == ControlModification::HEIGHT_GREATEST )
{
if ( aNewRect.Top() < aIntersectionRect.Top() )
{
aNewRect.Bottom() = aIntersectionRect.Top();
}
else if ( aNewRect.Top() < aIntersectionRect.Bottom() )
{
aNewRect.Top() = aIntersectionRect.Bottom();
}
}
nYTemp = aNewRect.getHeight();
bMoveAllowed = _nYMov != nYTemp;
nXTemp = aNewRect.getWidth();
bMoveAllowed = bMoveAllowed && _nXMov != nXTemp;
}
}
break;
default:
break;
}
_nXMov = nXTemp;
_nYMov = nYTemp;
}
else
pOverlappedObj = NULL;
}
}
while ( pOverlappedObj && bMoveAllowed );
}
return bMoveAllowed;
}
// -----------------------------------------------------------------------------
DBG_NAME( rpt_OViewsWindow );
OViewsWindow::OViewsWindow( OReportWindow* _pReportWindow)
: Window( _pReportWindow,WB_DIALOGCONTROL)
,m_pParent(_pReportWindow)
,m_bInUnmark(sal_False)
{
DBG_CTOR( rpt_OViewsWindow,NULL);
SetPaintTransparent(sal_True);
SetUniqueId(UID_RPT_VIEWSWINDOW);
SetMapMode( MapMode( MAP_100TH_MM ) );
m_aColorConfig.AddListener(this);
ImplInitSettings();
}
// -----------------------------------------------------------------------------
OViewsWindow::~OViewsWindow()
{
m_aColorConfig.RemoveListener(this);
m_aSections.clear();
DBG_DTOR( rpt_OViewsWindow,NULL);
}
// -----------------------------------------------------------------------------
void OViewsWindow::initialize()
{
}
// -----------------------------------------------------------------------------
void OViewsWindow::impl_resizeSectionWindow(OSectionWindow& _rSectionWindow,Point& _rStartPoint,bool _bSet)
{
const uno::Reference< report::XSection> xSection = _rSectionWindow.getReportSection().getSection();
Size aSectionSize = _rSectionWindow.LogicToPixel( Size( 0,xSection->getHeight() ) );
aSectionSize.Width() = getView()->GetTotalWidth();
const sal_Int32 nMinHeight = _rSectionWindow.getStartMarker().getMinHeight();
if ( _rSectionWindow.getStartMarker().isCollapsed() || nMinHeight > aSectionSize.Height() )
{
aSectionSize.Height() = nMinHeight;
}
const StyleSettings& rSettings = GetSettings().GetStyleSettings();
aSectionSize.Height() += (long)(rSettings.GetSplitSize() * (double)_rSectionWindow.GetMapMode().GetScaleY());
if ( _bSet )
_rSectionWindow.SetPosSizePixel(_rStartPoint,aSectionSize);
_rStartPoint.Y() += aSectionSize.Height();
}
// -----------------------------------------------------------------------------
void OViewsWindow::resize(const OSectionWindow& _rSectionWindow)
{
bool bSet = false;
Point aStartPoint;
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (;aIter != aEnd ; ++aIter)
{
const ::boost::shared_ptr<OSectionWindow> pSectionWindow = (*aIter);
if ( pSectionWindow.get() == &_rSectionWindow )
{
aStartPoint = pSectionWindow->GetPosPixel();
bSet = true;
} // if ( pSectionWindow.get() == &_rSectionWindow )
if ( bSet )
{
impl_resizeSectionWindow(*pSectionWindow.get(),aStartPoint,bSet);
static sal_Int32 nIn = INVALIDATE_UPDATE | INVALIDATE_TRANSPARENT;
pSectionWindow->getStartMarker().Invalidate( nIn ); // INVALIDATE_NOERASE |INVALIDATE_NOCHILDREN| INVALIDATE_TRANSPARENT
pSectionWindow->getEndMarker().Invalidate( nIn );
}
} // for (;aIter != aEnd ; ++aIter,++nPos)
Fraction aStartWidth(long(REPORT_STARTMARKER_WIDTH));
aStartWidth *= GetMapMode().GetScaleX();
Size aOut = GetOutputSizePixel();
aOut.Width() = aStartWidth;
aOut = PixelToLogic(aOut);
m_pParent->notifySizeChanged();
Rectangle aRect(PixelToLogic(Point(0,0)),aOut);
}
//------------------------------------------------------------------------------
void OViewsWindow::Resize()
{
Window::Resize();
if ( !m_aSections.empty() )
{
const Point aOffset(m_pParent->getThumbPos());
Point aStartPoint(0,-aOffset.Y());
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (sal_uInt16 nPos=0;aIter != aEnd ; ++aIter,++nPos)
{
const ::boost::shared_ptr<OSectionWindow> pSectionWindow = (*aIter);
impl_resizeSectionWindow(*pSectionWindow.get(),aStartPoint,true);
} // for (;aIter != aEnd ; ++aIter)
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::Paint( const Rectangle& rRect )
{
Window::Paint( rRect );
Size aOut = GetOutputSizePixel();
Fraction aStartWidth(long(REPORT_STARTMARKER_WIDTH));
aStartWidth *= GetMapMode().GetScaleX();
aOut.Width() -= (long)aStartWidth;
aOut = PixelToLogic(aOut);
Rectangle aRect(PixelToLogic(Point(aStartWidth,0)),aOut);
Wallpaper aWall( m_aColorConfig.GetColorValue(::svtools::APPBACKGROUND).nColor );
DrawWallpaper(aRect,aWall);
}
//------------------------------------------------------------------------------
void OViewsWindow::ImplInitSettings()
{
EnableChildTransparentMode( sal_True );
SetBackground( );
SetFillColor( Application::GetSettings().GetStyleSettings().GetDialogColor() );
SetTextFillColor( Application::GetSettings().GetStyleSettings().GetDialogColor() );
}
//-----------------------------------------------------------------------------
void OViewsWindow::DataChanged( const DataChangedEvent& rDCEvt )
{
Window::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
(rDCEvt.GetFlags() & SETTINGS_STYLE) )
{
ImplInitSettings();
Invalidate();
}
}
//----------------------------------------------------------------------------
void OViewsWindow::addSection(const uno::Reference< report::XSection >& _xSection,const ::rtl::OUString& _sColorEntry,sal_uInt16 _nPosition)
{
::boost::shared_ptr<OSectionWindow> pSectionWindow( new OSectionWindow(this,_xSection,_sColorEntry) );
m_aSections.insert(getIteratorAtPos(_nPosition) , TSectionsMap::value_type(pSectionWindow));
m_pParent->setMarked(&pSectionWindow->getReportSection().getSectionView(),m_aSections.size() == 1);
Resize();
}
//----------------------------------------------------------------------------
void OViewsWindow::removeSection(sal_uInt16 _nPosition)
{
if ( _nPosition < m_aSections.size() )
{
TSectionsMap::iterator aPos = getIteratorAtPos(_nPosition);
TSectionsMap::iterator aNew = getIteratorAtPos(_nPosition == 0 ? _nPosition+1: _nPosition - 1);
m_pParent->getReportView()->UpdatePropertyBrowserDelayed((*aNew)->getReportSection().getSectionView());
m_aSections.erase(aPos);
Resize();
} // if ( _nPosition < m_aSections.size() )
}
//------------------------------------------------------------------------------
void OViewsWindow::toggleGrid(sal_Bool _bVisible)
{
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(&OReportSection::SetGridVisible,_1,_bVisible),TReportPairHelper()));
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(&OReportSection::Window::Invalidate,_1,INVALIDATE_NOERASE),TReportPairHelper()));
}
//------------------------------------------------------------------------------
sal_Int32 OViewsWindow::getTotalHeight() const
{
sal_Int32 nHeight = 0;
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (;aIter != aEnd ; ++aIter)
{
nHeight += (*aIter)->GetSizePixel().Height();
}
return nHeight;
}
//----------------------------------------------------------------------------
sal_uInt16 OViewsWindow::getSectionCount() const
{
return static_cast<sal_uInt16>(m_aSections.size());
}
//----------------------------------------------------------------------------
void OViewsWindow::SetInsertObj( sal_uInt16 eObj,const ::rtl::OUString& _sShapeType )
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (;aIter != aEnd ; ++aIter)
(*aIter)->getReportSection().getSectionView().SetCurrentObj( eObj, ReportInventor );
m_sShapeType = _sShapeType;
}
//----------------------------------------------------------------------------
rtl::OUString OViewsWindow::GetInsertObjString() const
{
return m_sShapeType;
}
//------------------------------------------------------------------------------
void OViewsWindow::SetMode( DlgEdMode eNewMode )
{
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(&OReportSection::SetMode,_1,eNewMode),TReportPairHelper()));
}
//----------------------------------------------------------------------------
sal_Bool OViewsWindow::HasSelection() const
{
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (;aIter != aEnd && !(*aIter)->getReportSection().getSectionView().AreObjectsMarked(); ++aIter)
;
return aIter != aEnd;
}
//----------------------------------------------------------------------------
void OViewsWindow::Delete()
{
m_bInUnmark = sal_True;
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::mem_fn(&OReportSection::Delete),TReportPairHelper()));
m_bInUnmark = sal_False;
}
//----------------------------------------------------------------------------
void OViewsWindow::Copy()
{
uno::Sequence< beans::NamedValue > aAllreadyCopiedObjects;
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(&OReportSection::Copy,_1,::boost::ref(aAllreadyCopiedObjects)),TReportPairHelper()));
//TSectionsMap::iterator aIter = m_aSections.begin();
//TSectionsMap::iterator aEnd = m_aSections.end();
//for (; aIter != aEnd; ++aIter)
// (*aIter)->getReportSection().Copy(aAllreadyCopiedObjects);
OReportExchange* pCopy = new OReportExchange(aAllreadyCopiedObjects);
uno::Reference< datatransfer::XTransferable> aEnsureDelete = pCopy;
pCopy->CopyToClipboard(this);
}
//----------------------------------------------------------------------------
void OViewsWindow::Paste()
{
TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(this));
OReportExchange::TSectionElements aCopies = OReportExchange::extractCopies(aTransferData);
if ( aCopies.getLength() > 1 )
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(&OReportSection::Paste,_1,aCopies,false),TReportPairHelper()));
else
{
::boost::shared_ptr<OSectionWindow> pMarkedSection = getMarkedSection();
if ( pMarkedSection )
pMarkedSection->getReportSection().Paste(aCopies,true);
}
}
// ---------------------------------------------------------------------------
::boost::shared_ptr<OSectionWindow> OViewsWindow::getSectionWindow(const uno::Reference< report::XSection>& _xSection) const
{
OSL_ENSURE(_xSection.is(),"Section is NULL!");
::boost::shared_ptr<OSectionWindow> pSectionWindow;
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (; aIter != aEnd ; ++aIter)
{
if ((*aIter)->getReportSection().getSection() == _xSection)
{
pSectionWindow = (*aIter);
break;
}
}
return pSectionWindow;
}
//----------------------------------------------------------------------------
::boost::shared_ptr<OSectionWindow> OViewsWindow::getMarkedSection(NearSectionAccess nsa) const
{
::boost::shared_ptr<OSectionWindow> pRet;
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
sal_uInt32 nCurrentPosition = 0;
for (; aIter != aEnd ; ++aIter)
{
if ( (*aIter)->getStartMarker().isMarked() )
{
if (nsa == CURRENT)
{
pRet = (*aIter);
break;
}
else if ( nsa == PREVIOUS )
{
if (nCurrentPosition > 0)
{
pRet = (*(--aIter));
if( !bool(pRet) )
pRet = (*m_aSections.begin());
}
else
{
// if we are out of bounds return the first one
pRet = (*m_aSections.begin());
}
break;
}
else if ( nsa == POST )
{
sal_uInt32 nSize = m_aSections.size();
if ((nCurrentPosition + 1) < nSize)
{
pRet = *(++aIter);
if( !bool(pRet) )
pRet = (*(--aEnd));
}
else
{
// if we are out of bounds return the last one
pRet = (*(--aEnd));
}
break;
}
} // ( (*aIter).second->isMarked() )
++nCurrentPosition;
} // for (; aIter != aEnd ; ++aIter)
return pRet;
}
// -------------------------------------------------------------------------
void OViewsWindow::markSection(const sal_uInt16 _nPos)
{
if ( _nPos < m_aSections.size() )
m_pParent->setMarked(m_aSections[_nPos]->getReportSection().getSection(),sal_True);
}
//----------------------------------------------------------------------------
sal_Bool OViewsWindow::IsPasteAllowed() const
{
TransferableDataHelper aTransferData( TransferableDataHelper::CreateFromSystemClipboard( const_cast< OViewsWindow* >( this ) ) );
return aTransferData.HasFormat(OReportExchange::getDescriptorFormatId());
}
//-----------------------------------------------------------------------------
void OViewsWindow::SelectAll(const sal_uInt16 _nObjectType)
{
m_bInUnmark = sal_True;
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(::boost::mem_fn(&OReportSection::SelectAll),_1,_nObjectType),TReportPairHelper()));
m_bInUnmark = sal_False;
}
//-----------------------------------------------------------------------------
void OViewsWindow::unmarkAllObjects(OSectionView* _pSectionView)
{
if ( !m_bInUnmark )
{
m_bInUnmark = sal_True;
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd ; ++aIter)
{
if ( &(*aIter)->getReportSection().getSectionView() != _pSectionView )
{
(*aIter)->getReportSection().deactivateOle();
(*aIter)->getReportSection().getSectionView().UnmarkAllObj();
}
} // for (; aIter != aEnd ; ++aIter)
m_bInUnmark = sal_False;
}
}
//-----------------------------------------------------------------------------
/*
::boost::shared_ptr<OSectionWindow> OViewsWindow::getReportSection(const uno::Reference< report::XSection >& _xSection)
{
OSL_ENSURE(_xSection.is(),"Section is NULL!");
::boost::shared_ptr<OSectionWindow> pRet;
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd ; ++aIter)
{
if ( (*aIter)->getReportSection().getSection() == _xSection )
{
pRet = (*aIter);
break;
} // if ( (*aIter)->getSection() == _xSection )
} // for (; aIter != aEnd ; ++aIter)
return pRet;
}
*/
// -----------------------------------------------------------------------
void OViewsWindow::ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32)
{
ImplInitSettings();
Invalidate();
}
// -----------------------------------------------------------------------------
void OViewsWindow::MouseButtonDown( const MouseEvent& rMEvt )
{
if ( rMEvt.IsLeft() )
{
GrabFocus();
const uno::Sequence< beans::PropertyValue> aArgs;
getView()->getReportView()->getController().executeChecked(SID_SELECT_REPORT,aArgs);
}
Window::MouseButtonDown(rMEvt);
}
//----------------------------------------------------------------------------
void OViewsWindow::showRuler(sal_Bool _bShow)
{
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(&OStartMarker::showRuler,_1,_bShow),TStartMarkerHelper()));
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::bind(&OStartMarker::Window::Invalidate,_1,sal_uInt16(INVALIDATE_NOERASE)),TStartMarkerHelper()));
}
//----------------------------------------------------------------------------
void OViewsWindow::MouseButtonUp( const MouseEvent& rMEvt )
{
if ( rMEvt.IsLeft() )
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (;aIter != aEnd ; ++aIter)
{
if ( (*aIter)->getReportSection().getSectionView().AreObjectsMarked() )
{
(*aIter)->getReportSection().MouseButtonUp(rMEvt);
break;
}
}
// remove special insert mode
for (aIter = m_aSections.begin();aIter != aEnd ; ++aIter)
{
(*aIter)->getReportSection().getPage()->resetSpecialMode();
}
}
}
//------------------------------------------------------------------------------
sal_Bool OViewsWindow::handleKeyEvent(const KeyEvent& _rEvent)
{
sal_Bool bRet = sal_False;
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (;aIter != aEnd ; ++aIter)
{
//if ( (*aIter).getReportSection().getSectionView().->AreObjectsMarked() )
if ( (*aIter)->getStartMarker().isMarked() )
{
bRet = (*aIter)->getReportSection().handleKeyEvent(_rEvent);
}
}
return bRet;
}
//----------------------------------------------------------------------------
OViewsWindow::TSectionsMap::iterator OViewsWindow::getIteratorAtPos(sal_uInt16 _nPos)
{
TSectionsMap::iterator aRet = m_aSections.end();
if ( _nPos < m_aSections.size() )
aRet = m_aSections.begin() + _nPos;
return aRet;
}
//------------------------------------------------------------------------
void OViewsWindow::setMarked(OSectionView* _pSectionView,sal_Bool _bMark)
{
OSL_ENSURE(_pSectionView != NULL,"SectionView is NULL!");
if ( _pSectionView )
setMarked(_pSectionView->getReportSection()->getSection(),_bMark);
}
//------------------------------------------------------------------------
void OViewsWindow::setMarked(const uno::Reference< report::XSection>& _xSection,sal_Bool _bMark)
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd ; ++aIter)
{
if ( (*aIter)->getReportSection().getSection() != _xSection )
{
(*aIter)->setMarked(sal_False);
}
else if ( (*aIter)->getStartMarker().isMarked() != _bMark )
{
(*aIter)->setMarked(_bMark);
}
}
}
//------------------------------------------------------------------------
void OViewsWindow::setMarked(const uno::Sequence< uno::Reference< report::XReportComponent> >& _aShapes,sal_Bool _bMark)
{
bool bFirst = true;
const uno::Reference< report::XReportComponent>* pIter = _aShapes.getConstArray();
const uno::Reference< report::XReportComponent>* pEnd = pIter + _aShapes.getLength();
for(;pIter != pEnd;++pIter)
{
const uno::Reference< report::XSection> xSection = (*pIter)->getSection();
if ( xSection.is() )
{
if ( bFirst )
{
bFirst = false;
m_pParent->setMarked(xSection,_bMark);
}
::boost::shared_ptr<OSectionWindow> pSectionWindow = getSectionWindow(xSection);
if ( pSectionWindow )
{
SvxShape* pShape = SvxShape::getImplementation( *pIter );
SdrObject* pObject = pShape ? pShape->GetSdrObject() : NULL;
OSL_ENSURE( pObject, "OViewsWindow::setMarked: no SdrObject for the shape!" );
if ( pObject )
pSectionWindow->getReportSection().getSectionView().MarkObj( pObject, pSectionWindow->getReportSection().getSectionView().GetSdrPageView(), !_bMark );
}
}
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::collectRectangles(TRectangleMap& _rSortRectangles, bool _bBoundRects)
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (aIter = m_aSections.begin();aIter != aEnd ; ++aIter)
{
OSectionView& rView = (*aIter)->getReportSection().getSectionView();
if ( rView.AreObjectsMarked() )
{
rView.SortMarkedObjects();
const sal_uInt32 nCount = rView.GetMarkedObjectCount();
for (sal_uInt32 i=0; i < nCount; ++i)
{
const SdrMark* pM = rView.GetSdrMarkByIndex(i);
SdrObject* pObj = pM->GetMarkedSdrObj();
Rectangle aObjRect(_bBoundRects ? pObj->GetCurrentBoundRect() : pObj->GetSnapRect());
_rSortRectangles.insert(TRectangleMap::value_type(aObjRect,TRectangleMap::mapped_type(pObj,&rView)));
}
}
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::collectBoundResizeRect(const TRectangleMap& _rSortRectangles,sal_Int32 _nControlModification,bool _bAlignAtSection, bool _bBoundRects,Rectangle& _rBound,Rectangle& _rResize)
{
bool bOnlyOnce = false;
TRectangleMap::const_iterator aRectIter = _rSortRectangles.begin();
TRectangleMap::const_iterator aRectEnd = _rSortRectangles.end();
for (;aRectIter != aRectEnd ; ++aRectIter)
{
Rectangle aObjRect = aRectIter->first;
if ( _rResize.IsEmpty() )
_rResize = aObjRect;
switch(_nControlModification)
{
case ControlModification::WIDTH_SMALLEST:
if ( _rResize.getWidth() > aObjRect.getWidth() )
_rResize = aObjRect;
break;
case ControlModification::HEIGHT_SMALLEST:
if ( _rResize.getHeight() > aObjRect.getHeight() )
_rResize = aObjRect;
break;
case ControlModification::WIDTH_GREATEST:
if ( _rResize.getWidth() < aObjRect.getWidth() )
_rResize = aObjRect;
break;
case ControlModification::HEIGHT_GREATEST:
if ( _rResize.getHeight() < aObjRect.getHeight() )
_rResize = aObjRect;
break;
}
SdrObjTransformInfoRec aInfo;
const SdrObject* pObj = aRectIter->second.first;
pObj->TakeObjInfo(aInfo);
sal_Bool bHasFixed = !aInfo.bMoveAllowed || pObj->IsMoveProtect();
if ( bHasFixed )
_rBound.Union(aObjRect);
else
{
if ( _bAlignAtSection || _rSortRectangles.size() == 1 )
{ // einzelnes Obj an der Seite ausrichten
if ( ! bOnlyOnce )
{
bOnlyOnce = true;
OReportSection* pReportSection = aRectIter->second.second->getReportSection();
const uno::Reference< report::XSection> xSection = pReportSection->getSection();
try
{
uno::Reference<report::XReportDefinition> xReportDefinition = xSection->getReportDefinition();
_rBound.Union(Rectangle(getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_LEFTMARGIN),0,
getStyleProperty<awt::Size>(xReportDefinition,PROPERTY_PAPERSIZE).Width - getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_RIGHTMARGIN),
xSection->getHeight()));
}
catch(uno::Exception){}
}
}
else
{
if (_bBoundRects)
_rBound.Union(aRectIter->second.second->GetMarkedObjBoundRect());
else
_rBound.Union(aRectIter->second.second->GetMarkedObjRect());
}
}
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::alignMarkedObjects(sal_Int32 _nControlModification,bool _bAlignAtSection, bool _bBoundRects)
{
if ( _nControlModification == ControlModification::NONE )
return;
Point aRefPoint;
RectangleLess::CompareMode eCompareMode = RectangleLess::POS_LEFT;
switch (_nControlModification)
{
case ControlModification::TOP : eCompareMode = RectangleLess::POS_UPPER; break;
case ControlModification::BOTTOM: eCompareMode = RectangleLess::POS_DOWN; break;
case ControlModification::LEFT : eCompareMode = RectangleLess::POS_LEFT; break;
case ControlModification::RIGHT : eCompareMode = RectangleLess::POS_RIGHT; break;
case ControlModification::CENTER_HORIZONTAL :
case ControlModification::CENTER_VERTICAL :
{
eCompareMode = (ControlModification::CENTER_VERTICAL == _nControlModification) ? RectangleLess::POS_CENTER_VERTICAL : RectangleLess::POS_CENTER_HORIZONTAL;
uno::Reference<report::XSection> xSection = (*m_aSections.begin())->getReportSection().getSection();
uno::Reference<report::XReportDefinition> xReportDefinition = xSection->getReportDefinition();
aRefPoint = Rectangle(getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_LEFTMARGIN),0,
getStyleProperty<awt::Size>(xReportDefinition,PROPERTY_PAPERSIZE).Width - getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_RIGHTMARGIN),
xSection->getHeight()).Center();
}
break;
default: break;
}
RectangleLess aCompare(eCompareMode,aRefPoint);
TRectangleMap aSortRectangles(aCompare);
collectRectangles(aSortRectangles,_bBoundRects);
Rectangle aBound;
Rectangle aResize;
collectBoundResizeRect(aSortRectangles,_nControlModification,_bAlignAtSection,_bBoundRects,aBound,aResize);
bool bMove = true;
::std::mem_fun_t<long&,Rectangle> aGetFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Bottom);
::std::mem_fun_t<long&,Rectangle> aRefFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Top);
TRectangleMap::iterator aRectIter = aSortRectangles.begin();
TRectangleMap::iterator aRectEnd = aSortRectangles.end();
for (;aRectIter != aRectEnd ; ++aRectIter)
{
Rectangle aObjRect = aRectIter->first;
SdrObject* pObj = aRectIter->second.first;
SdrView* pView = aRectIter->second.second;
Point aCenter(aBound.Center());
SdrObjTransformInfoRec aInfo;
pObj->TakeObjInfo(aInfo);
if (aInfo.bMoveAllowed && !pObj->IsMoveProtect())
{
long nXMov = 0;
long nYMov = 0;
long* pValue = &nXMov;
switch(_nControlModification)
{
case ControlModification::TOP :
aGetFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Top);
aRefFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Bottom);
pValue = &nYMov;
break;
case ControlModification::BOTTOM:
// defaults are already set
pValue = &nYMov;
break;
case ControlModification::CENTER_VERTICAL:
nYMov = aCenter.Y() - aObjRect.Center().Y();
pValue = &nYMov;
bMove = false;
break;
case ControlModification::RIGHT :
aGetFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Right);
aRefFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Left);
break;
case ControlModification::CENTER_HORIZONTAL:
nXMov = aCenter.X() - aObjRect.Center().X();
bMove = false;
break;
case ControlModification::LEFT :
aGetFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Left);
aRefFun = ::std::mem_fun<long&,Rectangle>(&Rectangle::Right);
break;
default:
bMove = false;
break;
}
if ( bMove )
{
Rectangle aTest = aObjRect;
aGetFun(&aTest) = aGetFun(&aBound);
TRectangleMap::iterator aInterSectRectIter = aSortRectangles.begin();
for (; aInterSectRectIter != aRectIter; ++aInterSectRectIter)
{
if ( pView == aInterSectRectIter->second.second && (dynamic_cast<OUnoObject*>(aInterSectRectIter->second.first) || dynamic_cast<OOle2Obj*>(aInterSectRectIter->second.first)))
{
SdrObject* pPreviousObj = aInterSectRectIter->second.first;
Rectangle aIntersectRect = aTest.GetIntersection(_bBoundRects ? pPreviousObj->GetCurrentBoundRect() : pPreviousObj->GetSnapRect());
if ( !aIntersectRect.IsEmpty() && (aIntersectRect.Left() != aIntersectRect.Right() && aIntersectRect.Top() != aIntersectRect.Bottom() ) )
{
*pValue = aRefFun(&aIntersectRect) - aGetFun(&aObjRect);
break;
}
}
}
if ( aInterSectRectIter == aRectIter )
*pValue = aGetFun(&aBound) - aGetFun(&aObjRect);
}
if ( lcl_getNewRectSize(aObjRect,nXMov,nYMov,pObj,pView,_nControlModification,_bBoundRects) )
{
const Size aSize(nXMov,nYMov);
pView->AddUndo(pView->GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pObj,aSize));
pObj->Move(aSize);
aObjRect = (_bBoundRects ? pObj->GetCurrentBoundRect() : pObj->GetSnapRect());
}
// resizing control
if ( !aResize.IsEmpty() && aObjRect != aResize )
{
nXMov = aResize.getWidth();
nYMov = aResize.getHeight();
switch(_nControlModification)
{
case ControlModification::WIDTH_GREATEST:
case ControlModification::HEIGHT_GREATEST:
if ( _nControlModification == ControlModification::HEIGHT_GREATEST )
nXMov = aObjRect.getWidth();
else if ( _nControlModification == ControlModification::WIDTH_GREATEST )
nYMov = aObjRect.getHeight();
lcl_getNewRectSize(aObjRect,nXMov,nYMov,pObj,pView,_nControlModification,_bBoundRects);
// run through
case ControlModification::WIDTH_SMALLEST:
case ControlModification::HEIGHT_SMALLEST:
pView->AddUndo( pView->GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
{
OObjectBase* pObjBase = dynamic_cast<OObjectBase*>(pObj);
OSL_ENSURE(pObjBase,"Where comes this object from?");
if ( pObjBase )
{
if ( _nControlModification == ControlModification::WIDTH_SMALLEST || _nControlModification == ControlModification::WIDTH_GREATEST )
pObjBase->getReportComponent()->setSize(awt::Size(nXMov,aObjRect.getHeight()));
//pObj->Resize(aObjRect.TopLeft(),Fraction(nXMov,aObjRect.getWidth()),Fraction(1,1));
else if ( _nControlModification == ControlModification::HEIGHT_GREATEST || _nControlModification == ControlModification::HEIGHT_SMALLEST )
pObjBase->getReportComponent()->setSize(awt::Size(aObjRect.getWidth(),nYMov));
//pObj->Resize(aObjRect.TopLeft(),Fraction(1,1),Fraction(nYMov,aObjRect.getHeight()));
}
}
break;
default:
break;
}
}
}
pView->AdjustMarkHdl();
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::createDefault()
{
::boost::shared_ptr<OSectionWindow> pMarkedSection = getMarkedSection();
if ( pMarkedSection )
pMarkedSection->getReportSection().createDefault(m_sShapeType);
}
// -----------------------------------------------------------------------------
void OViewsWindow::setGridSnap(sal_Bool bOn)
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd ; ++aIter)
{
(*aIter)->getReportSection().getSectionView().SetGridSnap(bOn);
static sal_Int32 nIn = 0;
(*aIter)->getReportSection().Invalidate(nIn);
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::setDragStripes(sal_Bool bOn)
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd ; ++aIter)
(*aIter)->getReportSection().getSectionView().SetDragStripes(bOn);
}
// -----------------------------------------------------------------------------
sal_uInt16 OViewsWindow::getPosition(const OSectionWindow* _pSectionWindow) const
{
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
sal_uInt16 nPosition = 0;
for (; aIter != aEnd ; ++aIter)
{
if ( _pSectionWindow == (*aIter).get() )
{
break;
}
++nPosition;
}
return nPosition;
}
// -----------------------------------------------------------------------------
::boost::shared_ptr<OSectionWindow> OViewsWindow::getSectionWindow(const sal_uInt16 _nPos) const
{
::boost::shared_ptr<OSectionWindow> aReturn;
if ( _nPos < m_aSections.size() )
aReturn = m_aSections[_nPos];
return aReturn;
}
// -----------------------------------------------------------------------------
namespace
{
enum SectionViewAction
{
eEndDragObj,
eEndAction,
eMoveAction,
eMarkAction,
eForceToAnotherPage,
eBreakAction
};
class ApplySectionViewAction : public ::std::unary_function< OViewsWindow::TSectionsMap::value_type, void >
{
private:
SectionViewAction m_eAction;
sal_Bool m_bCopy;
Point m_aPoint;
public:
ApplySectionViewAction( sal_Bool _bCopy ) : m_eAction( eEndDragObj ), m_bCopy( _bCopy ) { }
ApplySectionViewAction(SectionViewAction _eAction = eEndAction ) : m_eAction( _eAction ) { }
ApplySectionViewAction( const Point& _rPoint, SectionViewAction _eAction = eMoveAction ) : m_eAction( _eAction ), m_bCopy( sal_False ), m_aPoint( _rPoint ) { }
void operator() ( const OViewsWindow::TSectionsMap::value_type& _rhs )
{
OSectionView& rView( _rhs->getReportSection().getSectionView() );
switch ( m_eAction )
{
case eEndDragObj:
rView.EndDragObj( m_bCopy );
break;
case eEndAction:
if ( rView.IsAction() )
rView.EndAction ( );
break;
case eMoveAction:
rView.MovAction ( m_aPoint );
break;
case eMarkAction:
rView.BegMarkObj ( m_aPoint );
break;
case eForceToAnotherPage:
rView.ForceMarkedToAnotherPage();
break;
case eBreakAction:
if ( rView.IsAction() )
rView.BrkAction ( );
break;
// default:
}
}
};
}
// -----------------------------------------------------------------------------
void OViewsWindow::BrkAction()
{
EndDragObj_removeInvisibleObjects();
::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction(eBreakAction) );
}
// -----------------------------------------------------------------------------
void OViewsWindow::BegDragObj_createInvisibleObjectAtPosition(const Rectangle& _aRect, const OSectionView& _rSection)
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
Point aNewPos(0,0);
for (; aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
rReportSection.getPage()->setSpecialMode();
OSectionView& rView = rReportSection.getSectionView();
if ( &rView != &_rSection )
{
// SdrRectObj *pNewObj = new SdrRectObj(OBJ_RECT, _aRect);
// SdrObject *pNewObj = new SdrUnoObj(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Temp Label")));
SdrObject *pNewObj = new SdrUnoObj(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.form.component.FixedText")));
if (pNewObj)
{
pNewObj->SetLogicRect(_aRect);
// pNewObj->SetSize(_aRect.GetSize());
// pNewObj->Move(Size(_aRect.Left(), _aRect.Top()));
pNewObj->Move(Size(0, aNewPos.Y()));
sal_Bool bChanged = rView.GetModel()->IsChanged();
rReportSection.getPage()->InsertObject(pNewObj);
rView.GetModel()->SetChanged(bChanged);
m_aBegDragTempList.push_back(pNewObj);
Rectangle aRect = pNewObj->GetLogicRect();
// pNewObj->SetText(String::CreateFromAscii("Drag helper"));
rView.MarkObj( pNewObj, rView.GetSdrPageView() );
}
}
const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
aNewPos.Y() -= nSectionHeight;
// aNewPos.Y() -= PixelToLogic(aIter->second.second->GetSizePixel()).Height();
}
}
// -----------------------------------------------------------------------------
bool OViewsWindow::isObjectInMyTempList(SdrObject *_pObj)
{
return ::std::find(m_aBegDragTempList.begin(),m_aBegDragTempList.end(),_pObj) != m_aBegDragTempList.end();
}
// -----------------------------------------------------------------------------
void OViewsWindow::BegDragObj(const Point& _aPnt, SdrHdl* _pHdl,const OSectionView* _pSection)
{
OSL_TRACE("BegDragObj Clickpoint X:%d Y:%d\n", _aPnt.X(), _aPnt.Y() );
m_aBegDragTempList.clear();
// Calculate the absolute clickpoint in the views
Point aAbsolutePnt = _aPnt;
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
OSectionView* pView = &rReportSection.getSectionView();
if (pView == _pSection)
break;
const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
aAbsolutePnt.Y() += nSectionHeight;
}
m_aDragDelta = Point(SAL_MAX_INT32, SAL_MAX_INT32);
OSL_TRACE("BegDragObj Absolute X:%d Y:%d\n", aAbsolutePnt.X(), aAbsolutePnt.Y() );
// Create drag lines over all viewable Views
// Therefore we need to identify the marked objects
// and create temporary objects on all other views at the same position
// relative to its occurrence.
OSL_TRACE("BegDragObj createInvisible Objects\n" );
int nViewCount = 0;
Point aNewObjPos(0,0);
Point aLeftTop = Point(SAL_MAX_INT32, SAL_MAX_INT32);
for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
OSectionView& rView = rReportSection.getSectionView();
if ( rView.AreObjectsMarked() )
{
const sal_uInt32 nCount = rView.GetMarkedObjectCount();
for (sal_uInt32 i=0; i < nCount; ++i)
{
const SdrMark* pM = rView.GetSdrMarkByIndex(i);
SdrObject* pObj = pM->GetMarkedSdrObj();
if (!isObjectInMyTempList(pObj))
{
Rectangle aRect( pObj->GetCurrentBoundRect() );
aRect.Move(0, aNewObjPos.Y());
aLeftTop.X() = ::std::min( aRect.Left(), aLeftTop.X() );
aLeftTop.Y() = ::std::min( aRect.Top(), aLeftTop.Y() );
OSL_TRACE("BegDragObj createInvisible X:%d Y:%d on View #%d\n", aRect.Left(), aRect.Top(), nViewCount );
BegDragObj_createInvisibleObjectAtPosition(aRect, rView);
// calculate the clickpoint
// const sal_Int32 nDeltaX = abs(aRect.Left() - aAbsolutePnt.X());
// const sal_Int32 nDeltaY = abs(aRect.Top() - aAbsolutePnt.Y());
// if (m_aDragDelta.X() > nDeltaX)
// m_aDragDelta.X() = nDeltaX;
// if (m_aDragDelta.Y() > nDeltaY)
// m_aDragDelta.Y() = nDeltaY;
}
}
}
++nViewCount;
Rectangle aClipRect = rView.GetWorkArea();
aClipRect.Top() = -aNewObjPos.Y();
rView.SetWorkArea( aClipRect );
const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
aNewObjPos.Y() += nSectionHeight;
// don't subtract the height of the lines between the views
// aNewObjPos.Y() -= PixelToLogic(aIter->second.second->GetSizePixel()).Height();
}
const sal_Int32 nDeltaX = abs(aLeftTop.X() - aAbsolutePnt.X());
const sal_Int32 nDeltaY = abs(aLeftTop.Y() - aAbsolutePnt.Y());
m_aDragDelta.X() = nDeltaX;
m_aDragDelta.Y() = nDeltaY;
Point aNewPos = aAbsolutePnt;
// for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
// {
// OReportSection& rReportSection = (*aIter)->getReportSection();
// if ( &rReportSection.getSectionView() == _pSection )
// break;
// aNewPos.Y() += rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
// }
const short nDrgLog = static_cast<short>(PixelToLogic(Size(3,0)).Width());
// long nLastSectionHeight = 0;
// bool bAdd = true;
nViewCount = 0;
for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
// if ( &rReportSection.getSectionView() == _pSection )
// {
// bAdd = false;
// aNewPos = _aPnt;
// }
// else if ( bAdd )
// {
// const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
// aNewPos.Y() += nSectionHeight;
// }
// else
// {
// aNewPos.Y() -= nLastSectionHeight;
// }
//?
SdrHdl* pHdl = _pHdl;
if ( pHdl )
{
if ( &rReportSection.getSectionView() != _pSection )
{
const SdrHdlList& rHdlList = rReportSection.getSectionView().GetHdlList();
pHdl = rHdlList.GetHdl(_pHdl->GetKind());
}
}
OSL_TRACE("BegDragObj X:%d Y:%d on View#%d\n", aNewPos.X(), aNewPos.Y(), nViewCount++ );
rReportSection.getSectionView().BegDragObj(aNewPos, (OutputDevice*)NULL, pHdl, nDrgLog, NULL);
const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
aNewPos.Y() -= nSectionHeight;
// subtract the height between the views, because they are visible but not from interest here.
// aNewPos.Y() -= PixelToLogic(aIter->second.second->GetSizePixel()).Height();
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::ForceMarkedToAnotherPage()
{
::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction(eForceToAnotherPage ) );
}
// -----------------------------------------------------------------------------
void OViewsWindow::BegMarkObj(const Point& _aPnt,const OSectionView* _pSection)
{
bool bAdd = true;
Point aNewPos = _aPnt;
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
long nLastSectionHeight = 0;
for (; aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
if ( &rReportSection.getSectionView() == _pSection )
{
bAdd = false;
aNewPos = _aPnt; // 2,2
}
else if ( bAdd )
{
const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
aNewPos.Y() += nSectionHeight;
}
else
{
aNewPos.Y() -= nLastSectionHeight;
}
rReportSection.getSectionView().BegMarkObj ( aNewPos );
nLastSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
// aNewPos.Y() -= PixelToLogic(aIter->second.second->GetSizePixel()).Height();
}
//::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction( _aPnt , eMarkAction) );
}
// -----------------------------------------------------------------------------
OSectionView* OViewsWindow::getSectionRelativeToPosition(const OSectionView* _pSection,Point& _rPnt)
{
OSectionView* pSection = NULL;
sal_Int32 nCount = 0;
TSectionsMap::iterator aIter = m_aSections.begin();
const TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd ; ++aIter,++nCount)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
if ( &rReportSection.getSectionView() == _pSection)
break;
}
OSL_ENSURE(aIter != aEnd,"This can never happen!");
if ( _rPnt.Y() < 0 )
{
if ( nCount )
--aIter;
for (; nCount && (_rPnt.Y() < 0); --nCount)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
const sal_Int32 nHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
_rPnt.Y() += nHeight;
if ( (nCount -1) > 0 && (_rPnt.Y() < 0) )
--aIter;
}
if ( nCount == 0 )
pSection = &(*m_aSections.begin())->getReportSection().getSectionView();
else
pSection = &(*aIter)->getReportSection().getSectionView();
}
else
{
for (; aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
const long nHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
if ( (_rPnt.Y() - nHeight) < 0 )
break;
_rPnt.Y() -= nHeight;
}
if ( aIter != aEnd )
pSection = &(*aIter)->getReportSection().getSectionView();
else
pSection = &(*(aEnd-1))->getReportSection().getSectionView();
}
return pSection;
}
// -----------------------------------------------------------------------------
void OViewsWindow::EndDragObj_removeInvisibleObjects()
{
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
rReportSection.getPage()->resetSpecialMode();
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::EndDragObj(sal_Bool _bControlKeyPressed, const OSectionView* _pSection,const Point& _aPnt)
{
const String sUndoAction = String((ModuleRes(RID_STR_UNDO_CHANGEPOSITION)));
const UndoContext aUndoContext( getView()->getReportView()->getController().getUndoManager(), sUndoAction );
Point aNewPos = _aPnt;
OSectionView* pInSection = getSectionRelativeToPosition(_pSection, aNewPos);
if (!_bControlKeyPressed &&
(_pSection && ( _pSection->IsDragResize() == false ) ) && /* Not in resize mode */
_pSection != pInSection)
{
EndDragObj_removeInvisibleObjects();
// we need to manipulate the current clickpoint, we subtract the old delta from BeginDrag
// OSectionView* pInSection = getSectionRelativeToPosition(_pSection, aPnt);
// aNewPos.X() -= m_aDragDelta.X();
// aNewPos.Y() -= m_aDragDelta.Y();
aNewPos -= m_aDragDelta;
uno::Sequence< beans::NamedValue > aAllreadyCopiedObjects;
TSectionsMap::iterator aIter = m_aSections.begin();
const TSectionsMap::iterator aEnd = m_aSections.end();
for (; aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
if ( pInSection != &rReportSection.getSectionView() )
{
rReportSection.getSectionView().BrkAction();
rReportSection.Copy(aAllreadyCopiedObjects,true);
}
else
pInSection->EndDragObj(sal_False);
} // for (; aIter != aEnd; ++aIter)
if ( aAllreadyCopiedObjects.getLength() )
{
beans::NamedValue* pIter = aAllreadyCopiedObjects.getArray();
const beans::NamedValue* pEnd = pIter + aAllreadyCopiedObjects.getLength();
try
{
uno::Reference<report::XReportDefinition> xReportDefinition = getView()->getReportView()->getController().getReportDefinition();
const sal_Int32 nLeftMargin = getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_LEFTMARGIN);
const sal_Int32 nRightMargin = getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_RIGHTMARGIN);
const sal_Int32 nPaperWidth = getStyleProperty<awt::Size>(xReportDefinition,PROPERTY_PAPERSIZE).Width;
if ( aNewPos.X() < nLeftMargin )
aNewPos.X() = nLeftMargin;
if ( aNewPos.Y() < 0 )
aNewPos.Y() = 0;
Point aPrevious;
for (; pIter != pEnd; ++pIter)
{
uno::Sequence< uno::Reference<report::XReportComponent> > aClones;
pIter->Value >>= aClones;
uno::Reference<report::XReportComponent>* pColIter = aClones.getArray();
const uno::Reference<report::XReportComponent>* pColEnd = pColIter + aClones.getLength();
// move the cloned Components to new positions
for (; pColIter != pColEnd; ++pColIter)
{
uno::Reference< report::XReportComponent> xRC(*pColIter);
aPrevious = VCLPoint(xRC->getPosition());
awt::Size aSize = xRC->getSize();
if ( aNewPos.X() < nLeftMargin )
{
aNewPos.X() = nLeftMargin;
}
else if ( (aNewPos.X() + aSize.Width) > (nPaperWidth - nRightMargin) )
{
aNewPos.X() = nPaperWidth - nRightMargin - aSize.Width;
}
if ( aNewPos.Y() < 0 )
{
aNewPos.Y() = 0;
}
if ( aNewPos.X() < 0 )
{
aSize.Width += aNewPos.X();
aNewPos.X()= 0;
xRC->setSize(aSize);
}
xRC->setPosition(AWTPoint(aNewPos));
if ( (pColIter+1) != pColEnd )
{
// bring aNewPos to the position of the next object
uno::Reference< report::XReportComponent> xRCNext(*(pColIter + 1),uno::UNO_QUERY);
Point aNextPosition = VCLPoint(xRCNext->getPosition());
aNewPos += (aNextPosition - aPrevious);
}
}
}
}
catch(uno::Exception&)
{
}
pInSection->getReportSection()->Paste(aAllreadyCopiedObjects,true);
}
}
else
{
::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction( sal_False ) );
EndDragObj_removeInvisibleObjects();
}
m_aDragDelta = Point(SAL_MAX_INT32, SAL_MAX_INT32);
}
// -----------------------------------------------------------------------------
void OViewsWindow::EndAction()
{
::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction() );
}
// -----------------------------------------------------------------------------
void OViewsWindow::MovAction(const Point& _aPnt,const OSectionView* _pSection,bool _bMove, bool _bControlKeySet)
{
(void)_bMove;
Point aRealMousePos = _aPnt;
Point aCurrentSectionPos;
OSL_TRACE("MovAction X:%d Y:%d\n", aRealMousePos.X(), aRealMousePos.Y() );
Point aHdlPos;
SdrHdl* pHdl = _pSection->GetDragHdl();
if ( pHdl )
{
aHdlPos = pHdl->GetPos();
}
TSectionsMap::iterator aIter/* = m_aSections.begin() */;
TSectionsMap::iterator aEnd = m_aSections.end();
//if ( _bMove )
//{
for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
if ( &rReportSection.getSectionView() == _pSection )
break;
const long nSectionHeight = (*aIter)->PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
aCurrentSectionPos.Y() += nSectionHeight;
} // for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
//}
aRealMousePos += aCurrentSectionPos;
// If control key is pressed the work area is limited to the section with the current selection.
Point aPosForWorkArea(0,0);
for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
OSectionView& rView = rReportSection.getSectionView();
const long nSectionHeight = (*aIter)->PixelToLogic((*aIter)->GetOutputSizePixel()).Height();
if (_bControlKeySet)
{
Rectangle aClipRect = rView.GetWorkArea();
aClipRect.Top() = aCurrentSectionPos.Y() - aPosForWorkArea.Y();
// if (aClipRect.Top() < 0) aClipRect.Top() = 0;
aClipRect.Bottom() = aClipRect.Top() + nSectionHeight;
rView.SetWorkArea( aClipRect );
}
else
{
Rectangle aClipRect = rView.GetWorkArea();
aClipRect.Top() = -aPosForWorkArea.Y();
rView.SetWorkArea( aClipRect );
}
aPosForWorkArea.Y() += nSectionHeight;
// aNewPos.Y() += PixelToLogic(aIter->second.second->GetSizePixel()).Height();
}
for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
SdrHdl* pCurrentHdl = rReportSection.getSectionView().GetDragHdl();
if ( pCurrentHdl )
{
if ( aRealMousePos.Y() > 0 )
aRealMousePos = _aPnt + pCurrentHdl->GetPos() - aHdlPos;
}
rReportSection.getSectionView().MovAction ( aRealMousePos );
const long nSectionHeight = (*aIter)->PixelToLogic((*aIter)->GetOutputSizePixel()).Height();
aRealMousePos.Y() -= nSectionHeight;
}
#if 0
#if OSL_DEBUG_LEVEL > 0
// TEST TEST TEST TEST
// Ich versuche gerade rauszubekommen, ob ich ein Object bewege oder nur resize.
// TEST TEST TEST TEST
for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
OSectionView& rView = rReportSection.getSectionView();
if ( rView.AreObjectsMarked() )
{
rView.SortMarkedObjects();
const sal_uInt32 nCount = rView.GetMarkedObjectCount();
for (sal_uInt32 i=0; i < nCount; ++i)
{
const SdrMark* pM = rView.GetSdrMarkByIndex(i);
SdrObject* pObj = pM->GetMarkedSdrObj();
(void)pObj;
int dummy = 0;
(void)dummy;
}
}
/*
OReportSection& rReportSection = (*aIter)->getReportSection();
OSectionView& rView = rReportSection.getSectionView();
const SdrHdlList& rHdlList = rView.GetHdlList();
SdrHdl* pHdl2 = rHdlList.GetFocusHdl();
if ( pHdl2 != 0 )
{
SdrHdlKind eKind = pHdl->GetKind();
int dummy = 0;
switch(eKind)
{
case HDL_UPLFT: // Oben links
case HDL_UPPER: // Oben
case HDL_UPRGT: // Oben rechts
case HDL_LEFT: // Links
case HDL_RIGHT: // Rechts
case HDL_LWLFT: // Unten links
case HDL_LOWER: // Unten
case HDL_LWRGT: // Unten rechts
dummy = 1;
break;
default:
dummy = 0;
}
}
*/
}
// TEST TEST TEST TEST
#endif
#endif
}
// -----------------------------------------------------------------------------
sal_Bool OViewsWindow::IsAction() const
{
sal_Bool bAction = sal_False;
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (; !bAction && aIter != aEnd; ++aIter)
bAction = (*aIter)->getReportSection().getSectionView().IsAction();
return bAction;
}
// -----------------------------------------------------------------------------
sal_Bool OViewsWindow::IsDragObj() const
{
sal_Bool bAction = sal_False;
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (; !bAction && aIter != aEnd; ++aIter)
bAction = (*aIter)->getReportSection().getSectionView().IsAction();
return bAction;
}
// -----------------------------------------------------------------------------
sal_uInt32 OViewsWindow::getMarkedObjectCount() const
{
sal_uInt32 nCount = 0;
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (; aIter != aEnd; ++aIter)
nCount += (*aIter)->getReportSection().getSectionView().GetMarkedObjectCount();
return nCount;
}
// -----------------------------------------------------------------------------
void OViewsWindow::handleKey(const KeyCode& _rCode)
{
const sal_uInt16 nCode = _rCode.GetCode();
if ( _rCode.IsMod1() )
{
// scroll page
OScrollWindowHelper* pScrollWindow = getView()->getScrollWindow();
ScrollBar* pScrollBar = ( nCode == KEY_LEFT || nCode == KEY_RIGHT ) ? pScrollWindow->GetHScroll() : pScrollWindow->GetVScroll();
if ( pScrollBar && pScrollBar->IsVisible() )
pScrollBar->DoScrollAction(( nCode == KEY_RIGHT || nCode == KEY_UP ) ? SCROLL_LINEUP : SCROLL_LINEDOWN );
return;
}
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (; aIter != aEnd; ++aIter)
{
OReportSection& rReportSection = (*aIter)->getReportSection();
long nX = 0;
long nY = 0;
if ( nCode == KEY_UP )
nY = -1;
else if ( nCode == KEY_DOWN )
nY = 1;
else if ( nCode == KEY_LEFT )
nX = -1;
else if ( nCode == KEY_RIGHT )
nX = 1;
if ( rReportSection.getSectionView().AreObjectsMarked() )
{
if ( _rCode.IsMod2() )
{
// move in 1 pixel distance
const Size aPixelSize = rReportSection.PixelToLogic( Size( 1, 1 ) );
nX *= aPixelSize.Width();
nY *= aPixelSize.Height();
}
else
{
// move in 1 mm distance
nX *= DEFAUL_MOVE_SIZE;
nY *= DEFAUL_MOVE_SIZE;
}
OSectionView& rView = rReportSection.getSectionView();
const SdrHdlList& rHdlList = rView.GetHdlList();
SdrHdl* pHdl = rHdlList.GetFocusHdl();
if ( pHdl == 0 )
{
// no handle selected
if ( rView.IsMoveAllowed() )
{
// restrict movement to work area
Rectangle rWorkArea = rView.GetWorkArea();
rWorkArea.Right()++;
if ( !rWorkArea.IsEmpty() )
{
if ( rWorkArea.Top() < 0 )
rWorkArea.Top() = 0;
Rectangle aMarkRect( rView.GetMarkedObjRect() );
aMarkRect.Move( nX, nY );
if ( !rWorkArea.IsInside( aMarkRect ) )
{
if ( aMarkRect.Left() < rWorkArea.Left() )
nX += rWorkArea.Left() - aMarkRect.Left();
if ( aMarkRect.Right() > rWorkArea.Right() )
nX -= aMarkRect.Right() - rWorkArea.Right();
if ( aMarkRect.Top() < rWorkArea.Top() )
nY += rWorkArea.Top() - aMarkRect.Top();
if ( aMarkRect.Bottom() > rWorkArea.Bottom() )
nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
}
bool bCheck = false;
const SdrMarkList& rMarkList = rView.GetMarkedObjectList();
for (sal_uInt32 i = 0; !bCheck && i < rMarkList.GetMarkCount();++i )
{
SdrMark* pMark = rMarkList.GetMark(i);
bCheck = dynamic_cast<OUnoObject*>(pMark->GetMarkedSdrObj()) != NULL|| dynamic_cast<OOle2Obj*>(pMark->GetMarkedSdrObj());
}
if ( bCheck )
{
SdrObject* pOverlapped = isOver(aMarkRect,*rReportSection.getPage(),rView);
if ( pOverlapped )
{
do
{
Rectangle aOver = pOverlapped->GetLastBoundRect();
Point aPos;
if ( nCode == KEY_UP )
{
aPos.X() = aMarkRect.Left();
aPos.Y() = aOver.Top() - aMarkRect.getHeight();
nY += (aPos.Y() - aMarkRect.Top());
}
else if ( nCode == KEY_DOWN )
{
aPos.X() = aMarkRect.Left();
aPos.Y() = aOver.Bottom();
nY += (aPos.Y() - aMarkRect.Top());
}
else if ( nCode == KEY_LEFT )
{
aPos.X() = aOver.Left() - aMarkRect.getWidth();
aPos.Y() = aMarkRect.Top();
nX += (aPos.X() - aMarkRect.Left());
}
else if ( nCode == KEY_RIGHT )
{
aPos.X() = aOver.Right();
aPos.Y() = aMarkRect.Top();
nX += (aPos.X() - aMarkRect.Left());
}
aMarkRect.SetPos(aPos);
if ( !rWorkArea.IsInside( aMarkRect ) )
{
break;
}
pOverlapped = isOver(aMarkRect,*rReportSection.getPage(),rView);
}
while(pOverlapped != NULL);
if (pOverlapped != NULL)
break;
}
}
}
if ( nX != 0 || nY != 0 )
{
rView.MoveAllMarked( Size( nX, nY ) );
rView.MakeVisible( rView.GetAllMarkedRect(), rReportSection);
}
}
}
else
{
// move the handle
if ( pHdl && ( nX || nY ) )
{
const Point aStartPoint( pHdl->GetPos() );
const Point aEndPoint( pHdl->GetPos() + Point( nX, nY ) );
const SdrDragStat& rDragStat = rView.GetDragStat();
// start dragging
rView.BegDragObj( aStartPoint, 0, pHdl, 0 );
if ( rView.IsDragObj() )
{
const FASTBOOL bWasNoSnap = rDragStat.IsNoSnap();
const sal_Bool bWasSnapEnabled = rView.IsSnapEnabled();
// switch snapping off
if ( !bWasNoSnap )
((SdrDragStat&)rDragStat).SetNoSnap( sal_True );
if ( bWasSnapEnabled )
rView.SetSnapEnabled( sal_False );
Rectangle aNewRect;
bool bCheck = false;
const SdrMarkList& rMarkList = rView.GetMarkedObjectList();
for (sal_uInt32 i = 0; !bCheck && i < rMarkList.GetMarkCount();++i )
{
SdrMark* pMark = rMarkList.GetMark(i);
bCheck = dynamic_cast<OUnoObject*>(pMark->GetMarkedSdrObj()) != NULL || dynamic_cast<OOle2Obj*>(pMark->GetMarkedSdrObj()) != NULL;
if ( bCheck )
aNewRect.Union(pMark->GetMarkedSdrObj()->GetLastBoundRect());
}
switch(pHdl->GetKind())
{
case HDL_LEFT:
case HDL_UPLFT:
case HDL_LWLFT:
case HDL_UPPER:
aNewRect.Left() += nX;
aNewRect.Top() += nY;
break;
case HDL_UPRGT:
case HDL_RIGHT:
case HDL_LWRGT:
case HDL_LOWER:
aNewRect.setWidth(aNewRect.getWidth() + nX);
aNewRect.setHeight(aNewRect.getHeight() + nY);
break;
default:
break;
}
if ( !(bCheck && isOver(aNewRect,*rReportSection.getPage(),rView)) )
rView.MovAction(aEndPoint);
rView.EndDragObj();
// restore snap
if ( !bWasNoSnap )
((SdrDragStat&)rDragStat).SetNoSnap( bWasNoSnap );
if ( bWasSnapEnabled )
rView.SetSnapEnabled( bWasSnapEnabled );
}
// make moved handle visible
const Rectangle aVisRect( aEndPoint - Point( DEFAUL_MOVE_SIZE, DEFAUL_MOVE_SIZE ), Size( 200, 200 ) );
rView.MakeVisible( aVisRect, rReportSection);
}
}
rView.AdjustMarkHdl();
}
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::stopScrollTimer()
{
::std::for_each(m_aSections.begin(),m_aSections.end(),
::std::compose1(::boost::mem_fn(&OReportSection::stopScrollTimer),TReportPairHelper()));
}
// -----------------------------------------------------------------------------
void OViewsWindow::fillCollapsedSections(::std::vector<sal_uInt16>& _rCollapsedPositions) const
{
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for (sal_uInt16 i = 0;aIter != aEnd ; ++aIter,++i)
{
if ( (*aIter)->getStartMarker().isCollapsed() )
_rCollapsedPositions.push_back(i);
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::collapseSections(const uno::Sequence< beans::PropertyValue>& _aCollpasedSections)
{
const beans::PropertyValue* pIter = _aCollpasedSections.getConstArray();
const beans::PropertyValue* pEnd = pIter + _aCollpasedSections.getLength();
for (; pIter != pEnd; ++pIter)
{
sal_uInt16 nPos = sal_uInt16(-1);
if ( (pIter->Value >>= nPos) && nPos < m_aSections.size() )
{
m_aSections[nPos]->setCollapsed(sal_True);
}
}
}
// -----------------------------------------------------------------------------
void OViewsWindow::zoom(const Fraction& _aZoom)
{
const MapMode& aMapMode = GetMapMode();
Fraction aStartWidth(long(REPORT_STARTMARKER_WIDTH));
if ( _aZoom < aMapMode.GetScaleX() )
aStartWidth *= aMapMode.GetScaleX();
else
aStartWidth *= _aZoom;
setZoomFactor(_aZoom,*this);
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (;aIter != aEnd ; ++aIter)
{
(*aIter)->zoom(_aZoom);
} // for (;aIter != aEnd ; ++aIter)
Resize();
Size aOut = GetOutputSizePixel();
aOut.Width() = aStartWidth;
aOut = PixelToLogic(aOut);
Rectangle aRect(PixelToLogic(Point(0,0)),aOut);
static sal_Int32 nIn = INVALIDATE_NOCHILDREN;
Invalidate(aRect,nIn);
}
//----------------------------------------------------------------------------
void OViewsWindow::scrollChildren(const Point& _aThumbPos)
{
const Point aPos(PixelToLogic(_aThumbPos));
{
MapMode aMapMode = GetMapMode();
const Point aOld = aMapMode.GetOrigin();
aMapMode.SetOrigin(m_pParent->GetMapMode().GetOrigin());
const Point aPosY(m_pParent->PixelToLogic(_aThumbPos,aMapMode));
aMapMode.SetOrigin( Point(aOld.X() , - aPosY.Y()));
SetMapMode( aMapMode );
//OWindowPositionCorrector aCorrector(this,0,-( aOld.Y() + aPosY.Y()));
Scroll(0, -( aOld.Y() + aPosY.Y()),SCROLL_CHILDREN);
}
TSectionsMap::iterator aIter = m_aSections.begin();
TSectionsMap::iterator aEnd = m_aSections.end();
for (;aIter != aEnd ; ++aIter)
{
(*aIter)->scrollChildren(aPos.X());
} // for (;aIter != aEnd ; ++aIter)
}
// -----------------------------------------------------------------------------
void OViewsWindow::fillControlModelSelection(::std::vector< uno::Reference< uno::XInterface > >& _rSelection) const
{
TSectionsMap::const_iterator aIter = m_aSections.begin();
TSectionsMap::const_iterator aEnd = m_aSections.end();
for(;aIter != aEnd; ++aIter)
{
(*aIter)->getReportSection().fillControlModelSelection(_rSelection);
}
}
//==============================================================================
} // rptui
//==============================================================================