reportdesign/source/ui/report/ViewsWindow.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "ViewsWindow.hxx"
  21 #include "ScrollHelper.hxx"
  22 #include "UndoActions.hxx"
  23 #include "ReportWindow.hxx"
  24 #include "DesignView.hxx"
  25 #include <svtools/colorcfg.hxx>
  26 #include "ReportController.hxx"
  27 #include "UITools.hxx"
  28 #include "RptDef.hxx"
  29 #include "RptResId.hrc"
  30 #include "SectionView.hxx"
  31 #include "ReportSection.hxx"
  32 #include "uistrings.hrc"
  33 #include "rptui_slotid.hrc"
  34 #include "dlgedclip.hxx"
  35 #include "ColorChanger.hxx"
  36 #include "RptObject.hxx"
  37 #include "ModuleHelper.hxx"
  38 #include "EndMarker.hxx"
  39 #include <svx/svdpagv.hxx>
  40 #include <svx/unoshape.hxx>
  41 #include <vcl/svapp.hxx>
  42 #include <vcl/settings.hxx>
  43
  44 #include <boost/bind.hpp>
  45
  46 #include "helpids.hrc"
  47 #include <svx/svdundo.hxx>
  48 #include <toolkit/helper/convert.hxx>
  49 #include <algorithm>
  50 #include <cstdlib>
  51 #include <numeric>
  52 #include <o3tl/compat_functional.hxx>
  53
  54 namespace rptui
  55 {
  56 #define DEFAUL_MOVE_SIZE    100
  57
  58 using namespace ::com::sun::star;
  59 using namespace ::comphelper;
  60
  61 bool lcl_getNewRectSize(const Rectangle& _aObjRect,long& _nXMov, long& _nYMov,SdrObject* _pObj,SdrView* _pView,sal_Int32 _nControlModification, bool _bBoundRects)
  62 {
  63     bool bMoveAllowed = _nXMov != 0 || _nYMov != 0;
  64     if ( bMoveAllowed )
  65     {
  66         Rectangle aNewRect = _aObjRect;
  67         SdrObject* pOverlappedObj = NULL;
  68         do
  69         {
  70             aNewRect = _aObjRect;
  71             switch(_nControlModification)
  72             {
  73                 case ControlModification::HEIGHT_GREATEST:
  74                 case ControlModification::WIDTH_GREATEST:
  75                     aNewRect.setWidth(_nXMov);
  76                     aNewRect.setHeight(_nYMov);
  77                     break;
  78                 default:
  79                     aNewRect.Move(_nXMov,_nYMov);
  80                     break;
  81             }
  82             if (dynamic_cast<OUnoObject*>(_pObj) != NULL || dynamic_cast<OOle2Obj*>(_pObj) != NULL)
  83             {
  84                 pOverlappedObj = isOver(aNewRect,*_pObj->GetPage(),*_pView,true,_pObj);
  85                 if ( pOverlappedObj && _pObj != pOverlappedObj )
  86                 {
  87                     Rectangle aOverlappingRect = (_bBoundRects ? pOverlappedObj->GetCurrentBoundRect() : pOverlappedObj->GetSnapRect());
  88                     sal_Int32 nXTemp = _nXMov;
  89                     sal_Int32 nYTemp = _nYMov;
  90                     switch(_nControlModification)
  91                     {
  92                         case ControlModification::LEFT:
  93                             nXTemp += aOverlappingRect.Right() - aNewRect.Left();
  94                             bMoveAllowed = _nXMov != nXTemp;
  95                             break;
  96                         case ControlModification::RIGHT:
  97                             nXTemp += aOverlappingRect.Left() - aNewRect.Right();
  98                             bMoveAllowed = _nXMov != nXTemp;
  99                             break;
 100                         case ControlModification::TOP:
 101                             nYTemp += aOverlappingRect.Bottom() - aNewRect.Top();
 102                             bMoveAllowed = _nYMov != nYTemp;
 103                             break;
 104                         case ControlModification::BOTTOM:
 105                             nYTemp += aOverlappingRect.Top() - aNewRect.Bottom();
 106                             bMoveAllowed = _nYMov != nYTemp;
 107                             break;
 108                         case ControlModification::CENTER_HORIZONTAL:
 109                             if ( _aObjRect.Left() < aOverlappingRect.Left() )
 110                                 nXTemp += aOverlappingRect.Left() - aNewRect.Left() - aNewRect.getWidth();
 111                             else
 112                                 nXTemp += aOverlappingRect.Right() - aNewRect.Left();
 113                             bMoveAllowed = _nXMov != nXTemp;
 114                             break;
 115                         case ControlModification::CENTER_VERTICAL:
 116                             if ( _aObjRect.Top() < aOverlappingRect.Top() )
 117                                 nYTemp += aOverlappingRect.Top() - aNewRect.Top() - aNewRect.getHeight();
 118                             else
 119                                 nYTemp += aOverlappingRect.Bottom() - aNewRect.Top();
 120                             bMoveAllowed = _nYMov != nYTemp;
 121                             break;
 122                         case ControlModification::HEIGHT_GREATEST:
 123                         case ControlModification::WIDTH_GREATEST:
 124                             {
 125                                 Rectangle aIntersectionRect = aNewRect.GetIntersection(aOverlappingRect);
 126                                 if ( !aIntersectionRect.IsEmpty() )
 127                                 {
 128                                     if ( _nControlModification == ControlModification::WIDTH_GREATEST )
 129                                     {
 130                                         if ( aNewRect.Left() < aIntersectionRect.Left() )
 131                                         {
 132                                             aNewRect.Right() = aIntersectionRect.Left();
 133                                         }
 134                                         else if ( aNewRect.Left() < aIntersectionRect.Right() )
 135                                         {
 136                                             aNewRect.Left() = aIntersectionRect.Right();
 137                                         }
 138                                     }
 139                                     else if ( _nControlModification == ControlModification::HEIGHT_GREATEST )
 140                                     {
 141                                         if ( aNewRect.Top() < aIntersectionRect.Top() )
 142                                         {
 143                                             aNewRect.Bottom() = aIntersectionRect.Top();
 144                                         }
 145                                         else if ( aNewRect.Top() < aIntersectionRect.Bottom() )
 146                                         {
 147                                             aNewRect.Top() = aIntersectionRect.Bottom();
 148                                         }
 149                                     }
 150                                     nYTemp = aNewRect.getHeight();
 151                                     bMoveAllowed = _nYMov != nYTemp;
 152                                     nXTemp = aNewRect.getWidth();
 153                                     bMoveAllowed = bMoveAllowed && _nXMov != nXTemp;
 154                                 }
 155                             }
 156                             break;
 157                         default:
 158                             break;
 159                     }
 160
 161                     _nXMov = nXTemp;
 162                     _nYMov = nYTemp;
 163                 }
 164                 else
 165                     pOverlappedObj = NULL;
 166             }
 167         }
 168         while ( pOverlappedObj && bMoveAllowed );
 169     }
 170     return bMoveAllowed;
 171 }
 172
 173
 174 OViewsWindow::OViewsWindow( OReportWindow* _pReportWindow)
 175     : Window( _pReportWindow,WB_DIALOGCONTROL)
 176     , m_pParent(_pReportWindow)
 177     , m_bInUnmark(false)
 178 {
 179     SetPaintTransparent(true);
 180     SetUniqueId(UID_RPT_VIEWSWINDOW);
 181     SetMapMode(MapMode(MAP_100TH_MM));
 182     m_aColorConfig.AddListener(this);
 183     ImplInitSettings();
 184 }
 185
 186 OViewsWindow::~OViewsWindow()
 187 {
 188     disposeOnce();
 189 }
 190
 191 void OViewsWindow::dispose()
 192 {
 193     m_aColorConfig.RemoveListener(this);
 194     for (auto i = m_aSections.begin(); i != m_aSections.end(); ++i)
 195         i->disposeAndClear();
 196     m_aSections.clear();
 197     m_pParent.clear();
 198     vcl::Window::dispose();
 199 }
 200
 201 void OViewsWindow::impl_resizeSectionWindow(OSectionWindow& _rSectionWindow,Point& _rStartPoint,bool _bSet)
 202 {
 203     const uno::Reference< report::XSection> xSection = _rSectionWindow.getReportSection().getSection();
 204
 205     Size aSectionSize = _rSectionWindow.LogicToPixel( Size( 0,xSection->getHeight() ) );
 206     aSectionSize.Width() = getView()->GetTotalWidth();
 207
 208     const sal_Int32 nMinHeight = _rSectionWindow.getStartMarker().getMinHeight();
 209     if ( _rSectionWindow.getStartMarker().isCollapsed() || nMinHeight > aSectionSize.Height() )
 210     {
 211         aSectionSize.Height() = nMinHeight;
 212     }
 213     const StyleSettings& rSettings = GetSettings().GetStyleSettings();
 214     aSectionSize.Height() += (long)(rSettings.GetSplitSize() * (double)_rSectionWindow.GetMapMode().GetScaleY());
 215
 216     if ( _bSet )
 217         _rSectionWindow.SetPosSizePixel(_rStartPoint,aSectionSize);
 218
 219     _rStartPoint.Y() += aSectionSize.Height();
 220 }
 221
 222
 223 void OViewsWindow::resize(const OSectionWindow& _rSectionWindow)
 224 {
 225     bool bSet = false;
 226     Point aStartPoint;
 227     TSectionsMap::iterator aIter = m_aSections.begin();
 228     TSectionsMap::iterator aEnd = m_aSections.end();
 229     for (;aIter != aEnd ; ++aIter)
 230     {
 231         OSectionWindow* pSectionWindow = (*aIter);
 232         if ( pSectionWindow == &_rSectionWindow )
 233         {
 234             aStartPoint = pSectionWindow->GetPosPixel();
 235             bSet = true;
 236         }
 237
 238         if ( bSet )
 239         {
 240             impl_resizeSectionWindow(*pSectionWindow,aStartPoint,bSet);
 241             static sal_Int32 nIn = INVALIDATE_UPDATE | INVALIDATE_TRANSPARENT;
 242             pSectionWindow->getStartMarker().Invalidate( nIn ); // INVALIDATE_NOERASE |INVALIDATE_NOCHILDREN| INVALIDATE_TRANSPARENT
 243             pSectionWindow->getEndMarker().Invalidate( nIn );
 244         }
 245     }
 246     m_pParent->notifySizeChanged();
 247 }
 248
 249 void OViewsWindow::Resize()
 250 {
 251     Window::Resize();
 252     if ( !m_aSections.empty() )
 253     {
 254         const Point aOffset(m_pParent->getThumbPos());
 255         Point aStartPoint(0,-aOffset.Y());
 256         TSectionsMap::iterator aIter = m_aSections.begin();
 257         TSectionsMap::iterator aEnd = m_aSections.end();
 258         for (;aIter != aEnd ; ++aIter)
 259         {
 260             OSectionWindow* pSectionWindow = (*aIter);
 261             impl_resizeSectionWindow(*pSectionWindow,aStartPoint,true);
 262         }
 263     }
 264 }
 265
 266 void OViewsWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle& rRect)
 267 {
 268     Window::Paint(rRenderContext, rRect);
 269
 270     rRenderContext.SetBackground();
 271     rRenderContext.SetFillColor(Application::GetSettings().GetStyleSettings().GetDialogColor());
 272     rRenderContext.SetTextFillColor(Application::GetSettings().GetStyleSettings().GetDialogColor());
 273
 274     Size aOut(GetOutputSizePixel());
 275     Fraction aStartWidth(long(REPORT_STARTMARKER_WIDTH));
 276     aStartWidth *= rRenderContext.GetMapMode().GetScaleX();
 277
 278     aOut.Width() -= long(aStartWidth);
 279     aOut = rRenderContext.PixelToLogic(aOut);
 280
 281     Rectangle aRect(rRenderContext.PixelToLogic(Point(aStartWidth,0)), aOut);
 282     Wallpaper aWall(m_aColorConfig.GetColorValue(::svtools::APPBACKGROUND).nColor);
 283     rRenderContext.DrawWallpaper(aRect, aWall);
 284 }
 285
 286 void OViewsWindow::ImplInitSettings()
 287 {
 288     EnableChildTransparentMode(true);
 289 }
 290
 291 void OViewsWindow::DataChanged( const DataChangedEvent& rDCEvt )
 292 {
 293     Window::DataChanged( rDCEvt );
 294
 295     if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 296          (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
 297     {
 298         ImplInitSettings();
 299         Invalidate();
 300     }
 301 }
 302
 303 void OViewsWindow::addSection(const uno::Reference< report::XSection >& _xSection,const OUString& _sColorEntry,sal_uInt16 _nPosition)
 304 {
 305     VclPtrInstance<OSectionWindow> pSectionWindow(this,_xSection,_sColorEntry);
 306     m_aSections.insert(getIteratorAtPos(_nPosition) , TSectionsMap::value_type(pSectionWindow));
 307     m_pParent->setMarked(&pSectionWindow->getReportSection().getSectionView(),m_aSections.size() == 1);
 308     Resize();
 309 }
 310
 311 void OViewsWindow::removeSection(sal_uInt16 _nPosition)
 312 {
 313     if ( _nPosition < m_aSections.size() )
 314     {
 315         TSectionsMap::iterator aPos = getIteratorAtPos(_nPosition);
 316         TSectionsMap::iterator aNew = getIteratorAtPos(_nPosition == 0 ? _nPosition+1: _nPosition - 1);
 317
 318         m_pParent->getReportView()->UpdatePropertyBrowserDelayed((*aNew)->getReportSection().getSectionView());
 319
 320         aPos->disposeAndClear();;
 321         m_aSections.erase(aPos);
 322         Resize();
 323     }
 324 }
 325
 326 void OViewsWindow::toggleGrid(bool _bVisible)
 327 {
 328     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 329         ::o3tl::compose1(::boost::bind(&OReportSection::SetGridVisible,_1,_bVisible),TReportPairHelper()));
 330     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 331         ::o3tl::compose1(::boost::bind(&OReportSection::Window::Invalidate,_1,INVALIDATE_NOERASE),TReportPairHelper()));
 332 }
 333
 334 sal_Int32 OViewsWindow::getTotalHeight() const
 335 {
 336     sal_Int32 nHeight = 0;
 337     TSectionsMap::const_iterator aIter = m_aSections.begin();
 338     TSectionsMap::const_iterator aEnd = m_aSections.end();
 339     for (;aIter != aEnd ; ++aIter)
 340     {
 341         nHeight += (*aIter)->GetSizePixel().Height();
 342     }
 343     return nHeight;
 344 }
 345
 346 sal_uInt16 OViewsWindow::getSectionCount() const
 347 {
 348     return static_cast<sal_uInt16>(m_aSections.size());
 349 }
 350
 351 void OViewsWindow::SetInsertObj( sal_uInt16 eObj,const OUString& _sShapeType )
 352 {
 353     TSectionsMap::iterator aIter = m_aSections.begin();
 354     TSectionsMap::iterator aEnd = m_aSections.end();
 355     for (;aIter != aEnd ; ++aIter)
 356         (*aIter)->getReportSection().getSectionView().SetCurrentObj( eObj, ReportInventor );
 357
 358     m_sShapeType = _sShapeType;
 359 }
 360
 361
 362
 363 void OViewsWindow::SetMode( DlgEdMode eNewMode )
 364 {
 365     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 366         ::o3tl::compose1(::boost::bind(&OReportSection::SetMode,_1,eNewMode),TReportPairHelper()));
 367 }
 368
 369 bool OViewsWindow::HasSelection() const
 370 {
 371     TSectionsMap::const_iterator aIter = m_aSections.begin();
 372     TSectionsMap::const_iterator aEnd = m_aSections.end();
 373     for (;aIter != aEnd && !(*aIter)->getReportSection().getSectionView().AreObjectsMarked(); ++aIter)
 374         ;
 375     return aIter != aEnd;
 376 }
 377
 378 void OViewsWindow::Delete()
 379 {
 380     m_bInUnmark = true;
 381     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 382         ::o3tl::compose1(::boost::mem_fn(&OReportSection::Delete),TReportPairHelper()));
 383     m_bInUnmark = false;
 384 }
 385
 386 void OViewsWindow::Copy()
 387 {
 388     uno::Sequence< beans::NamedValue > aAllreadyCopiedObjects;
 389     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 390         ::o3tl::compose1(::boost::bind(&OReportSection::Copy,_1,::boost::ref(aAllreadyCopiedObjects)),TReportPairHelper()));
 391
 392     OReportExchange* pCopy = new OReportExchange(aAllreadyCopiedObjects);
 393     uno::Reference< datatransfer::XTransferable> aEnsureDelete = pCopy;
 394     pCopy->CopyToClipboard(this);
 395 }
 396
 397 void OViewsWindow::Paste()
 398 {
 399     TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(this));
 400     OReportExchange::TSectionElements aCopies = OReportExchange::extractCopies(aTransferData);
 401     if ( aCopies.getLength() > 1 )
 402         ::std::for_each(m_aSections.begin(),m_aSections.end(),
 403             ::o3tl::compose1(::boost::bind(&OReportSection::Paste,_1,aCopies,false),TReportPairHelper()));
 404     else
 405     {
 406         OSectionWindow*  pMarkedSection = getMarkedSection();
 407         if ( pMarkedSection )
 408             pMarkedSection->getReportSection().Paste(aCopies,true);
 409     }
 410 }
 411
 412 OSectionWindow* OViewsWindow::getSectionWindow(const uno::Reference< report::XSection>& _xSection) const
 413 {
 414     OSL_ENSURE(_xSection.is(),"Section is NULL!");
 415
 416     OSectionWindow* pSectionWindow = NULL;
 417     TSectionsMap::const_iterator aIter = m_aSections.begin();
 418     TSectionsMap::const_iterator aEnd = m_aSections.end();
 419     for (; aIter != aEnd ; ++aIter)
 420     {
 421         if ((*aIter)->getReportSection().getSection() == _xSection)
 422         {
 423             pSectionWindow = (*aIter);
 424             break;
 425         }
 426     }
 427
 428     return pSectionWindow;
 429 }
 430
 431
 432 OSectionWindow* OViewsWindow::getMarkedSection(NearSectionAccess nsa) const
 433 {
 434     OSectionWindow* pRet = NULL;
 435     TSectionsMap::const_iterator aIter = m_aSections.begin();
 436     TSectionsMap::const_iterator aEnd = m_aSections.end();
 437     sal_uInt32 nCurrentPosition = 0;
 438     for (; aIter != aEnd ; ++aIter)
 439     {
 440         if ( (*aIter)->getStartMarker().isMarked() )
 441         {
 442             if (nsa == CURRENT)
 443             {
 444                 pRet = (*aIter);
 445                 break;
 446             }
 447             else if ( nsa == PREVIOUS )
 448             {
 449                 if (nCurrentPosition > 0)
 450                 {
 451                     pRet = (*(--aIter));
 452                     if (pRet == 0)
 453                     {
 454                         pRet = (*m_aSections.begin());
 455                     }
 456                 }
 457                 else
 458                 {
 459                     // if we are out of bounds return the first one
 460                     pRet = (*m_aSections.begin());
 461                 }
 462                 break;
 463             }
 464             else if ( nsa == POST )
 465             {
 466                 sal_uInt32 nSize = m_aSections.size();
 467                 if ((nCurrentPosition + 1) < nSize)
 468                 {
 469                     pRet = *(++aIter);
 470                     if (pRet == 0)
 471                     {
 472                         pRet = (*(--aEnd));
 473                     }
 474                 }
 475                 else
 476                 {
 477                     // if we are out of bounds return the last one
 478                     pRet = (*(--aEnd));
 479                 }
 480                 break;
 481             }
 482         }
 483         ++nCurrentPosition;
 484     }
 485
 486     return pRet;
 487 }
 488
 489 void OViewsWindow::markSection(const sal_uInt16 _nPos)
 490 {
 491     if ( _nPos < m_aSections.size() )
 492         m_pParent->setMarked(m_aSections[_nPos]->getReportSection().getSection(),true);
 493 }
 494
 495 bool OViewsWindow::IsPasteAllowed() const
 496 {
 497     TransferableDataHelper aTransferData( TransferableDataHelper::CreateFromSystemClipboard( const_cast< OViewsWindow* >( this ) ) );
 498     return aTransferData.HasFormat(OReportExchange::getDescriptorFormatId());
 499 }
 500
 501 void OViewsWindow::SelectAll(const sal_uInt16 _nObjectType)
 502 {
 503     m_bInUnmark = true;
 504     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 505         ::o3tl::compose1(::boost::bind(::boost::mem_fn(&OReportSection::SelectAll),_1,_nObjectType),TReportPairHelper()));
 506     m_bInUnmark = false;
 507 }
 508
 509 void OViewsWindow::unmarkAllObjects(OSectionView* _pSectionView)
 510 {
 511     if ( !m_bInUnmark )
 512     {
 513         m_bInUnmark = true;
 514         TSectionsMap::iterator aIter = m_aSections.begin();
 515         TSectionsMap::iterator aEnd = m_aSections.end();
 516         for (; aIter != aEnd ; ++aIter)
 517         {
 518             if ( &(*aIter)->getReportSection().getSectionView() != _pSectionView )
 519             {
 520                 (*aIter)->getReportSection().deactivateOle();
 521                 (*aIter)->getReportSection().getSectionView().UnmarkAllObj();
 522             }
 523         }
 524         m_bInUnmark = false;
 525     }
 526 }
 527
 528 void OViewsWindow::ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32)
 529 {
 530     ImplInitSettings();
 531     Invalidate();
 532 }
 533
 534 void OViewsWindow::MouseButtonDown( const MouseEvent& rMEvt )
 535 {
 536     if ( rMEvt.IsLeft() )
 537     {
 538         GrabFocus();
 539         const uno::Sequence< beans::PropertyValue> aArgs;
 540         getView()->getReportView()->getController().executeChecked(SID_SELECT_REPORT,aArgs);
 541     }
 542     Window::MouseButtonDown(rMEvt);
 543 }
 544
 545 void OViewsWindow::showRuler(bool _bShow)
 546 {
 547     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 548         ::o3tl::compose1(::boost::bind(&OStartMarker::showRuler,_1,_bShow),TStartMarkerHelper()));
 549     ::std::for_each(m_aSections.begin(),m_aSections.end(),
 550         ::o3tl::compose1(::boost::bind(&OStartMarker::Window::Invalidate, _1, sal_uInt16(INVALIDATE_NOERASE)), TStartMarkerHelper()));
 551 }
 552
 553 void OViewsWindow::MouseButtonUp( const MouseEvent& rMEvt )
 554 {
 555     if ( rMEvt.IsLeft() )
 556     {
 557         TSectionsMap::iterator aIter = m_aSections.begin();
 558         TSectionsMap::iterator aEnd = m_aSections.end();
 559         for (;aIter != aEnd ; ++aIter)
 560         {
 561             if ( (*aIter)->getReportSection().getSectionView().AreObjectsMarked() )
 562             {
 563                 (*aIter)->getReportSection().MouseButtonUp(rMEvt);
 564                 break;
 565             }
 566         }
 567
 568         // remove special insert mode
 569         for (aIter = m_aSections.begin();aIter != aEnd ; ++aIter)
 570         {
 571             (*aIter)->getReportSection().getPage()->resetSpecialMode();
 572         }
 573     }
 574 }
 575
 576 bool OViewsWindow::handleKeyEvent(const KeyEvent& _rEvent)
 577 {
 578     bool bRet = false;
 579     TSectionsMap::iterator aIter = m_aSections.begin();
 580     TSectionsMap::iterator aEnd = m_aSections.end();
 581     for (;aIter != aEnd ; ++aIter)
 582     {
 583         if ( (*aIter)->getStartMarker().isMarked() )
 584         {
 585             bRet = (*aIter)->getReportSection().handleKeyEvent(_rEvent);
 586         }
 587     }
 588     return bRet;
 589 }
 590
 591 OViewsWindow::TSectionsMap::iterator OViewsWindow::getIteratorAtPos(sal_uInt16 _nPos)
 592 {
 593     TSectionsMap::iterator aRet = m_aSections.end();
 594     if ( _nPos < m_aSections.size() )
 595         aRet = m_aSections.begin() + _nPos;
 596     return aRet;
 597 }
 598
 599 void OViewsWindow::setMarked(OSectionView* _pSectionView, bool _bMark)
 600 {
 601     OSL_ENSURE(_pSectionView != NULL,"SectionView is NULL!");
 602     if ( _pSectionView )
 603         setMarked(_pSectionView->getReportSection()->getSection(),_bMark);
 604 }
 605
 606 void OViewsWindow::setMarked(const uno::Reference< report::XSection>& _xSection, bool _bMark)
 607 {
 608     TSectionsMap::iterator aIter = m_aSections.begin();
 609     TSectionsMap::iterator aEnd = m_aSections.end();
 610     for (; aIter != aEnd ; ++aIter)
 611     {
 612         if ( (*aIter)->getReportSection().getSection() != _xSection )
 613         {
 614             (*aIter)->setMarked(false);
 615         }
 616         else if ( (*aIter)->getStartMarker().isMarked() != _bMark )
 617         {
 618             (*aIter)->setMarked(_bMark);
 619         }
 620     }
 621 }
 622
 623 void OViewsWindow::setMarked(const uno::Sequence< uno::Reference< report::XReportComponent> >& _aShapes, bool _bMark)
 624 {
 625     bool bFirst = true;
 626     const uno::Reference< report::XReportComponent>* pIter = _aShapes.getConstArray();
 627     const uno::Reference< report::XReportComponent>* pEnd  = pIter + _aShapes.getLength();
 628     for(;pIter != pEnd;++pIter)
 629     {
 630         const uno::Reference< report::XSection> xSection = (*pIter)->getSection();
 631         if ( xSection.is() )
 632         {
 633             if ( bFirst )
 634             {
 635                 bFirst = false;
 636                 m_pParent->setMarked(xSection,_bMark);
 637             }
 638             OSectionWindow* pSectionWindow = getSectionWindow(xSection);
 639             if ( pSectionWindow )
 640             {
 641                 SvxShape* pShape = SvxShape::getImplementation( *pIter );
 642                 SdrObject* pObject = pShape ? pShape->GetSdrObject() : NULL;
 643                 OSL_ENSURE( pObject, "OViewsWindow::setMarked: no SdrObject for the shape!" );
 644                 if ( pObject )
 645                     pSectionWindow->getReportSection().getSectionView().MarkObj( pObject, pSectionWindow->getReportSection().getSectionView().GetSdrPageView(), !_bMark );
 646             }
 647         }
 648     }
 649 }
 650
 651 void OViewsWindow::collectRectangles(TRectangleMap& _rSortRectangles,  bool _bBoundRects)
 652 {
 653     TSectionsMap::iterator aIter = m_aSections.begin();
 654     TSectionsMap::iterator aEnd = m_aSections.end();
 655     for (aIter = m_aSections.begin();aIter != aEnd ; ++aIter)
 656     {
 657         OSectionView& rView = (*aIter)->getReportSection().getSectionView();
 658         if ( rView.AreObjectsMarked() )
 659         {
 660             rView.SortMarkedObjects();
 661             const size_t nCount = rView.GetMarkedObjectCount();
 662             for (size_t i=0; i < nCount; ++i)
 663             {
 664                 const SdrMark* pM = rView.GetSdrMarkByIndex(i);
 665                 SdrObject* pObj = pM->GetMarkedSdrObj();
 666                 Rectangle aObjRect(_bBoundRects ? pObj->GetCurrentBoundRect() : pObj->GetSnapRect());
 667                 _rSortRectangles.insert(TRectangleMap::value_type(aObjRect,TRectangleMap::mapped_type(pObj,&rView)));
 668             }
 669         }
 670     }
 671 }
 672
 673 void OViewsWindow::collectBoundResizeRect(const TRectangleMap& _rSortRectangles,sal_Int32 _nControlModification,bool _bAlignAtSection, bool _bBoundRects,Rectangle& _rBound,Rectangle& _rResize)
 674 {
 675     bool bOnlyOnce = false;
 676     TRectangleMap::const_iterator aRectIter = _rSortRectangles.begin();
 677     TRectangleMap::const_iterator aRectEnd = _rSortRectangles.end();
 678     for (;aRectIter != aRectEnd ; ++aRectIter)
 679     {
 680         Rectangle aObjRect = aRectIter->first;
 681         if ( _rResize.IsEmpty() )
 682             _rResize = aObjRect;
 683         switch(_nControlModification)
 684         {
 685             case ControlModification::WIDTH_SMALLEST:
 686                 if ( _rResize.getWidth() > aObjRect.getWidth() )
 687                     _rResize = aObjRect;
 688                 break;
 689             case ControlModification::HEIGHT_SMALLEST:
 690                 if ( _rResize.getHeight() > aObjRect.getHeight() )
 691                     _rResize = aObjRect;
 692                 break;
 693             case ControlModification::WIDTH_GREATEST:
 694                 if ( _rResize.getWidth() < aObjRect.getWidth() )
 695                     _rResize = aObjRect;
 696                 break;
 697             case ControlModification::HEIGHT_GREATEST:
 698                 if ( _rResize.getHeight() < aObjRect.getHeight() )
 699                     _rResize = aObjRect;
 700                 break;
 701         }
 702
 703         SdrObjTransformInfoRec aInfo;
 704         const SdrObject* pObj =  aRectIter->second.first;
 705         pObj->TakeObjInfo(aInfo);
 706         bool bHasFixed = !aInfo.bMoveAllowed || pObj->IsMoveProtect();
 707         if ( bHasFixed )
 708             _rBound.Union(aObjRect);
 709         else
 710         {
 711             if ( _bAlignAtSection || _rSortRectangles.size() == 1 )
 712             { // einzelnes Obj an der Seite ausrichten
 713                 if ( ! bOnlyOnce )
 714                 {
 715                     bOnlyOnce = true;
 716                     OReportSection* pReportSection = aRectIter->second.second->getReportSection();
 717                     const uno::Reference< report::XSection> xSection = pReportSection->getSection();
 718                     try
 719                     {
 720                         uno::Reference<report::XReportDefinition> xReportDefinition = xSection->getReportDefinition();
 721                         _rBound.Union(Rectangle(getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_LEFTMARGIN),0,
 722                                             getStyleProperty<awt::Size>(xReportDefinition,PROPERTY_PAPERSIZE).Width  - getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_RIGHTMARGIN),
 723                                             xSection->getHeight()));
 724                     }
 725                     catch(const uno::Exception &){}
 726                 }
 727             }
 728             else
 729             {
 730                 if (_bBoundRects)
 731                     _rBound.Union(aRectIter->second.second->GetMarkedObjBoundRect());
 732                 else
 733                     _rBound.Union(aRectIter->second.second->GetMarkedObjRect());
 734             }
 735         }
 736     }
 737 }
 738
 739 void OViewsWindow::alignMarkedObjects(sal_Int32 _nControlModification,bool _bAlignAtSection, bool _bBoundRects)
 740 {
 741     if ( _nControlModification == ControlModification::NONE )
 742         return;
 743
 744     Point aRefPoint;
 745     RectangleLess::CompareMode eCompareMode = RectangleLess::POS_LEFT;
 746     switch (_nControlModification)
 747     {
 748         case ControlModification::TOP   : eCompareMode = RectangleLess::POS_UPPER; break;
 749         case ControlModification::BOTTOM: eCompareMode = RectangleLess::POS_DOWN; break;
 750         case ControlModification::LEFT  : eCompareMode = RectangleLess::POS_LEFT; break;
 751         case ControlModification::RIGHT : eCompareMode = RectangleLess::POS_RIGHT; break;
 752         case ControlModification::CENTER_HORIZONTAL :
 753         case ControlModification::CENTER_VERTICAL :
 754             {
 755                 eCompareMode = (ControlModification::CENTER_VERTICAL == _nControlModification) ?  RectangleLess::POS_CENTER_VERTICAL :  RectangleLess::POS_CENTER_HORIZONTAL;
 756                 uno::Reference<report::XSection> xSection = (*m_aSections.begin())->getReportSection().getSection();
 757                 uno::Reference<report::XReportDefinition> xReportDefinition = xSection->getReportDefinition();
 758                 aRefPoint = Rectangle(getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_LEFTMARGIN),0,
 759                                         getStyleProperty<awt::Size>(xReportDefinition,PROPERTY_PAPERSIZE).Width  - getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_RIGHTMARGIN),
 760                                         xSection->getHeight()).Center();
 761             }
 762             break;
 763         default: break;
 764     }
 765     RectangleLess aCompare(eCompareMode,aRefPoint);
 766     TRectangleMap aSortRectangles(aCompare);
 767     collectRectangles(aSortRectangles,_bBoundRects);
 768
 769     Rectangle aBound;
 770     Rectangle aResize;
 771     collectBoundResizeRect(aSortRectangles,_nControlModification,_bAlignAtSection,_bBoundRects,aBound,aResize);
 772
 773     bool bMove = true;
 774
 775     ::std::mem_fun_t<long&,Rectangle> aGetFun       = ::std::mem_fun<long&,Rectangle>(&Rectangle::Bottom);
 776     ::std::mem_fun_t<long&,Rectangle> aRefFun       = ::std::mem_fun<long&,Rectangle>(&Rectangle::Top);
 777     TRectangleMap::iterator aRectIter = aSortRectangles.begin();
 778     TRectangleMap::iterator aRectEnd = aSortRectangles.end();
 779     for (;aRectIter != aRectEnd ; ++aRectIter)
 780     {
 781         Rectangle aObjRect = aRectIter->first;
 782         SdrObject* pObj = aRectIter->second.first;
 783         SdrView* pView = aRectIter->second.second;
 784         Point aCenter(aBound.Center());
 785         SdrObjTransformInfoRec aInfo;
 786         pObj->TakeObjInfo(aInfo);
 787         if (aInfo.bMoveAllowed && !pObj->IsMoveProtect())
 788         {
 789             long nXMov = 0;
 790             long nYMov = 0;
 791             long* pValue = &nXMov;
 792             switch(_nControlModification)
 793             {
 794                 case ControlModification::TOP   :
 795                     aGetFun  = ::std::mem_fun<long&,Rectangle>(&Rectangle::Top);
 796                     aRefFun  = ::std::mem_fun<long&,Rectangle>(&Rectangle::Bottom);
 797                     pValue = &nYMov;
 798                     break;
 799                 case ControlModification::BOTTOM:
 800                     // defaults are already set
 801                     pValue = &nYMov;
 802                     break;
 803                 case ControlModification::CENTER_VERTICAL:
 804                     nYMov = aCenter.Y() - aObjRect.Center().Y();
 805                     pValue = &nYMov;
 806                     bMove = false;
 807                     break;
 808                 case ControlModification::RIGHT :
 809                     aGetFun  = ::std::mem_fun<long&,Rectangle>(&Rectangle::Right);
 810                     aRefFun  = ::std::mem_fun<long&,Rectangle>(&Rectangle::Left);
 811                     break;
 812                 case ControlModification::CENTER_HORIZONTAL:
 813                     nXMov = aCenter.X() - aObjRect.Center().X();
 814                     bMove = false;
 815                     break;
 816                 case ControlModification::LEFT  :
 817                     aGetFun  = ::std::mem_fun<long&,Rectangle>(&Rectangle::Left);
 818                     aRefFun  = ::std::mem_fun<long&,Rectangle>(&Rectangle::Right);
 819                     break;
 820                 default:
 821                     bMove = false;
 822                     break;
 823             }
 824             if ( bMove )
 825             {
 826                 Rectangle aTest = aObjRect;
 827                 aGetFun(&aTest) = aGetFun(&aBound);
 828                 TRectangleMap::iterator aInterSectRectIter = aSortRectangles.begin();
 829                 for (; aInterSectRectIter != aRectIter; ++aInterSectRectIter)
 830                 {
 831                     if ( pView == aInterSectRectIter->second.second && (dynamic_cast<OUnoObject*>(aInterSectRectIter->second.first) || dynamic_cast<OOle2Obj*>(aInterSectRectIter->second.first)))
 832                     {
 833                         SdrObject* pPreviousObj = aInterSectRectIter->second.first;
 834                         Rectangle aIntersectRect = aTest.GetIntersection(_bBoundRects ? pPreviousObj->GetCurrentBoundRect() : pPreviousObj->GetSnapRect());
 835                         if ( !aIntersectRect.IsEmpty() && (aIntersectRect.Left() != aIntersectRect.Right() && aIntersectRect.Top() != aIntersectRect.Bottom() ) )
 836                         {
 837                             *pValue = aRefFun(&aIntersectRect) - aGetFun(&aObjRect);
 838                             break;
 839                         }
 840                     }
 841                 }
 842                 if ( aInterSectRectIter == aRectIter )
 843                     *pValue = aGetFun(&aBound) - aGetFun(&aObjRect);
 844             }
 845
 846             if ( lcl_getNewRectSize(aObjRect,nXMov,nYMov,pObj,pView,_nControlModification,_bBoundRects) )
 847             {
 848                 const Size aSize(nXMov,nYMov);
 849                 pView->AddUndo(pView->GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pObj,aSize));
 850                 pObj->Move(aSize);
 851                 aObjRect = (_bBoundRects ? pObj->GetCurrentBoundRect() : pObj->GetSnapRect());
 852             }
 853
 854             // resizing control
 855             if ( !aResize.IsEmpty() && aObjRect != aResize )
 856             {
 857                 nXMov = aResize.getWidth();
 858                 nYMov = aResize.getHeight();
 859                 switch(_nControlModification)
 860                 {
 861                     case ControlModification::WIDTH_GREATEST:
 862                     case ControlModification::HEIGHT_GREATEST:
 863                         if ( _nControlModification == ControlModification::HEIGHT_GREATEST )
 864                             nXMov = aObjRect.getWidth();
 865                         else if ( _nControlModification == ControlModification::WIDTH_GREATEST )
 866                             nYMov = aObjRect.getHeight();
 867                         lcl_getNewRectSize(aObjRect,nXMov,nYMov,pObj,pView,_nControlModification,_bBoundRects);
 868                         // run through
 869                     case ControlModification::WIDTH_SMALLEST:
 870                     case ControlModification::HEIGHT_SMALLEST:
 871                         pView->AddUndo( pView->GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
 872                         {
 873                             OObjectBase* pObjBase = dynamic_cast<OObjectBase*>(pObj);
 874                             OSL_ENSURE(pObjBase,"Where comes this object from?");
 875                             if ( pObjBase )
 876                             {
 877                                 if ( _nControlModification == ControlModification::WIDTH_SMALLEST || _nControlModification == ControlModification::WIDTH_GREATEST )
 878                                     pObjBase->getReportComponent()->setSize(awt::Size(nXMov,aObjRect.getHeight()));
 879                                 else if ( _nControlModification == ControlModification::HEIGHT_GREATEST || _nControlModification == ControlModification::HEIGHT_SMALLEST )
 880                                     pObjBase->getReportComponent()->setSize(awt::Size(aObjRect.getWidth(),nYMov));
 881                             }
 882                         }
 883                         break;
 884                     default:
 885                         break;
 886                 }
 887             }
 888         }
 889         pView->AdjustMarkHdl();
 890     }
 891 }
 892
 893 void OViewsWindow::createDefault()
 894 {
 895     OSectionWindow* pMarkedSection = getMarkedSection();
 896     if ( pMarkedSection )
 897         pMarkedSection->getReportSection().createDefault(m_sShapeType);
 898 }
 899
 900 void OViewsWindow::setGridSnap(bool bOn)
 901 {
 902     TSectionsMap::iterator aIter = m_aSections.begin();
 903     TSectionsMap::iterator aEnd = m_aSections.end();
 904     for (; aIter != aEnd ; ++aIter)
 905     {
 906         (*aIter)->getReportSection().getSectionView().SetGridSnap(bOn);
 907         static sal_Int32 nIn = 0;
 908         (*aIter)->getReportSection().Invalidate(nIn);
 909     }
 910 }
 911
 912 void OViewsWindow::setDragStripes(bool bOn)
 913 {
 914     TSectionsMap::iterator aIter = m_aSections.begin();
 915     TSectionsMap::iterator aEnd = m_aSections.end();
 916     for (; aIter != aEnd ; ++aIter)
 917         (*aIter)->getReportSection().getSectionView().SetDragStripes(bOn);
 918 }
 919
 920 sal_uInt16 OViewsWindow::getPosition(const OSectionWindow* _pSectionWindow) const
 921 {
 922     TSectionsMap::const_iterator aIter = m_aSections.begin();
 923     TSectionsMap::const_iterator aEnd = m_aSections.end();
 924     sal_uInt16 nPosition = 0;
 925     for (; aIter != aEnd ; ++aIter)
 926     {
 927         if ( _pSectionWindow == (*aIter).get() )
 928         {
 929             break;
 930         }
 931         ++nPosition;
 932     }
 933     return nPosition;
 934 }
 935
 936 OSectionWindow* OViewsWindow::getSectionWindow(const sal_uInt16 _nPos) const
 937 {
 938     OSectionWindow* aReturn = NULL;
 939
 940     if ( _nPos < m_aSections.size() )
 941         aReturn = m_aSections[_nPos];
 942
 943     return aReturn;
 944 }
 945
 946 namespace
 947 {
 948     enum SectionViewAction
 949     {
 950         eEndDragObj,
 951         eEndAction,
 952         eForceToAnotherPage,
 953         eBreakAction
 954     };
 955     class ApplySectionViewAction : public ::std::unary_function< OViewsWindow::TSectionsMap::value_type, void >
 956     {
 957     private:
 958         SectionViewAction   m_eAction;
 959         bool                m_bCopy;
 960
 961     public:
 962         ApplySectionViewAction(bool _bCopy)
 963             : m_eAction(eEndDragObj)
 964             , m_bCopy(_bCopy)
 965         {
 966         }
 967
 968         ApplySectionViewAction(SectionViewAction _eAction = eEndAction)
 969             : m_eAction(_eAction)
 970             , m_bCopy(false)
 971         {
 972         }
 973
 974         void operator() ( const OViewsWindow::TSectionsMap::value_type& _rhs )
 975         {
 976             OSectionView& rView( _rhs->getReportSection().getSectionView() );
 977             switch ( m_eAction )
 978             {
 979             case eEndDragObj:
 980                 rView.EndDragObj( m_bCopy  );
 981                 break;
 982             case eEndAction:
 983                 if ( rView.IsAction() )
 984                     rView.EndAction (      );
 985                 break;
 986             case eForceToAnotherPage:
 987                 rView.ForceMarkedToAnotherPage();
 988                 break;
 989             case eBreakAction:
 990                 if ( rView.IsAction() )
 991                     rView.BrkAction (      );
 992                 break;
 993                 // default:
 994
 995             }
 996         }
 997     };
 998 }
 999
1000 void OViewsWindow::BrkAction()
1001 {
1002     EndDragObj_removeInvisibleObjects();
1003     ::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction(eBreakAction) );
1004 }
1005
1006 void OViewsWindow::BegDragObj_createInvisibleObjectAtPosition(const Rectangle& _aRect, const OSectionView& _rSection)
1007 {
1008     TSectionsMap::iterator aIter = m_aSections.begin();
1009     TSectionsMap::iterator aEnd = m_aSections.end();
1010     Point aNewPos(0,0);
1011
1012     for (; aIter != aEnd; ++aIter)
1013     {
1014         OReportSection& rReportSection = (*aIter)->getReportSection();
1015         rReportSection.getPage()->setSpecialMode();
1016         OSectionView& rView = rReportSection.getSectionView();
1017
1018         if ( &rView != &_rSection )
1019         {
1020             SdrObject *pNewObj = new SdrUnoObj(OUString("com.sun.star.form.component.FixedText"));
1021             pNewObj->SetLogicRect(_aRect);
1022
1023             pNewObj->Move(Size(0, aNewPos.Y()));
1024             bool bChanged = rView.GetModel()->IsChanged();
1025             rReportSection.getPage()->InsertObject(pNewObj);
1026             rView.GetModel()->SetChanged(bChanged);
1027             m_aBegDragTempList.push_back(pNewObj);
1028
1029             rView.MarkObj( pNewObj, rView.GetSdrPageView() );
1030         }
1031         const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1032         aNewPos.Y() -= nSectionHeight;
1033     }
1034 }
1035
1036 bool OViewsWindow::isObjectInMyTempList(SdrObject *_pObj)
1037 {
1038     return ::std::find(m_aBegDragTempList.begin(),m_aBegDragTempList.end(),_pObj) != m_aBegDragTempList.end();
1039 }
1040
1041
1042 void OViewsWindow::BegDragObj(const Point& _aPnt, SdrHdl* _pHdl,const OSectionView* _pSection)
1043 {
1044     SAL_INFO(
1045         "reportdesign", "Clickpoint X:" << _aPnt.X() << " Y:" << _aPnt.Y());
1046
1047     m_aBegDragTempList.clear();
1048
1049     // Calculate the absolute clickpoint in the views
1050     Point aAbsolutePnt = _aPnt;
1051     TSectionsMap::iterator aIter = m_aSections.begin();
1052     TSectionsMap::iterator aEnd = m_aSections.end();
1053     for (; aIter != aEnd; ++aIter)
1054     {
1055         OReportSection& rReportSection = (*aIter)->getReportSection();
1056         OSectionView* pView = &rReportSection.getSectionView();
1057         if (pView == _pSection)
1058             break;
1059         const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1060         aAbsolutePnt.Y() +=  nSectionHeight;
1061     }
1062     m_aDragDelta = Point(SAL_MAX_INT32, SAL_MAX_INT32);
1063     SAL_INFO(
1064         "reportdesign",
1065         "Absolute X:" << aAbsolutePnt.X() << " Y:" << aAbsolutePnt.Y());
1066
1067     // Create drag lines over all viewable Views
1068     // Therefore we need to identify the marked objects
1069     // and create temporary objects on all other views at the same position
1070     // relative to its occurrence.
1071
1072     OSL_TRACE("BegDragObj createInvisible Objects" );
1073     int nViewCount = 0;
1074     Point aNewObjPos(0,0);
1075     Point aLeftTop = Point(SAL_MAX_INT32, SAL_MAX_INT32);
1076     for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
1077     {
1078         OReportSection& rReportSection = (*aIter)->getReportSection();
1079
1080         OSectionView& rView = rReportSection.getSectionView();
1081
1082         if ( rView.AreObjectsMarked() )
1083         {
1084             const size_t nCount = rView.GetMarkedObjectCount();
1085             for (size_t i=0; i < nCount; ++i)
1086             {
1087                 const SdrMark* pM = rView.GetSdrMarkByIndex(i);
1088                 SdrObject* pObj = pM->GetMarkedSdrObj();
1089                 if (!isObjectInMyTempList(pObj))
1090                 {
1091                     Rectangle aRect( pObj->GetCurrentBoundRect() );
1092                     aRect.Move(0, aNewObjPos.Y());
1093
1094                     aLeftTop.X() = ::std::min( aRect.Left(), aLeftTop.X() );
1095                     aLeftTop.Y() = ::std::min( aRect.Top(), aLeftTop.Y() );
1096
1097                     SAL_INFO(
1098                         "reportdesign",
1099                         "createInvisible X:" << aRect.Left() << " Y:"
1100                             << aRect.Top() << " on View #" << nViewCount);
1101
1102                     BegDragObj_createInvisibleObjectAtPosition(aRect, rView);
1103                 }
1104             }
1105         }
1106         ++nViewCount;
1107         Rectangle aClipRect = rView.GetWorkArea();
1108         aClipRect.Top() = -aNewObjPos.Y();
1109         rView.SetWorkArea( aClipRect );
1110
1111         const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1112         aNewObjPos.Y() += nSectionHeight;
1113     }
1114
1115     const sal_Int32 nDeltaX = std::abs(aLeftTop.X() - aAbsolutePnt.X());
1116     const sal_Int32 nDeltaY = std::abs(aLeftTop.Y() - aAbsolutePnt.Y());
1117     m_aDragDelta.X() = nDeltaX;
1118     m_aDragDelta.Y() = nDeltaY;
1119
1120     Point aNewPos = aAbsolutePnt;
1121
1122     const short nDrgLog = static_cast<short>(PixelToLogic(Size(3,0)).Width());
1123     nViewCount = 0;
1124     for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
1125     {
1126         OReportSection& rReportSection = (*aIter)->getReportSection();
1127
1128         SdrHdl* pHdl = _pHdl;
1129         if ( pHdl )
1130         {
1131             if ( &rReportSection.getSectionView() != _pSection )
1132             {
1133                 const SdrHdlList& rHdlList = rReportSection.getSectionView().GetHdlList();
1134                 pHdl = rHdlList.GetHdl(_pHdl->GetKind());
1135             }
1136         }
1137         SAL_INFO(
1138             "reportdesign",
1139             "X:" << aNewPos.X() << " Y:" << aNewPos.Y() << " on View#"
1140                 << nViewCount++);
1141         rReportSection.getSectionView().BegDragObj(aNewPos, (OutputDevice*)NULL, pHdl, nDrgLog, NULL);
1142
1143         const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1144         aNewPos.Y() -= nSectionHeight;
1145     }
1146 }
1147
1148
1149 void OViewsWindow::ForceMarkedToAnotherPage()
1150 {
1151     ::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction(eForceToAnotherPage ) );
1152 }
1153
1154 void OViewsWindow::BegMarkObj(const Point& _aPnt,const OSectionView* _pSection)
1155 {
1156     bool bAdd = true;
1157     Point aNewPos = _aPnt;
1158
1159     TSectionsMap::iterator aIter = m_aSections.begin();
1160     TSectionsMap::iterator aEnd = m_aSections.end();
1161     long nLastSectionHeight = 0;
1162     for (; aIter != aEnd; ++aIter)
1163     {
1164         OReportSection& rReportSection = (*aIter)->getReportSection();
1165         if ( &rReportSection.getSectionView() == _pSection )
1166         {
1167             bAdd = false;
1168             aNewPos = _aPnt; // 2,2
1169         }
1170         else if ( bAdd )
1171         {
1172             const long nSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1173             aNewPos.Y() += nSectionHeight;
1174         }
1175         else
1176         {
1177             aNewPos.Y() -= nLastSectionHeight;
1178         }
1179         rReportSection.getSectionView().BegMarkObj ( aNewPos );
1180         nLastSectionHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1181     }
1182 }
1183
1184 OSectionView* OViewsWindow::getSectionRelativeToPosition(const OSectionView* _pSection,Point& _rPnt)
1185 {
1186     OSectionView* pSection = NULL;
1187     sal_Int32 nCount = 0;
1188     TSectionsMap::iterator aIter = m_aSections.begin();
1189     const TSectionsMap::iterator aEnd = m_aSections.end();
1190     for (; aIter != aEnd ; ++aIter,++nCount)
1191     {
1192         OReportSection& rReportSection = (*aIter)->getReportSection();
1193         if ( &rReportSection.getSectionView() == _pSection)
1194             break;
1195     }
1196     OSL_ENSURE(aIter != aEnd,"This can never happen!");
1197     if ( _rPnt.Y() < 0 )
1198     {
1199         if ( nCount )
1200             --aIter;
1201         for (; nCount && (_rPnt.Y() < 0); --nCount)
1202         {
1203             OReportSection& rReportSection = (*aIter)->getReportSection();
1204             const sal_Int32 nHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1205             _rPnt.Y() += nHeight;
1206             if ( (nCount -1) > 0 && (_rPnt.Y() < 0) )
1207                 --aIter;
1208         }
1209         if ( nCount == 0 )
1210             pSection = &(*m_aSections.begin())->getReportSection().getSectionView();
1211         else
1212             pSection = &(*aIter)->getReportSection().getSectionView();
1213     }
1214     else
1215     {
1216         for (; aIter != aEnd; ++aIter)
1217         {
1218             OReportSection& rReportSection = (*aIter)->getReportSection();
1219             const long nHeight = rReportSection.PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1220             if ( (_rPnt.Y() - nHeight) < 0  )
1221                 break;
1222             _rPnt.Y() -= nHeight;
1223         }
1224         if ( aIter != aEnd )
1225             pSection = &(*aIter)->getReportSection().getSectionView();
1226         else
1227             pSection = &(*(aEnd-1))->getReportSection().getSectionView();
1228     }
1229
1230     return pSection;
1231 }
1232
1233 void OViewsWindow::EndDragObj_removeInvisibleObjects()
1234 {
1235     TSectionsMap::iterator aIter = m_aSections.begin();
1236     TSectionsMap::iterator aEnd = m_aSections.end();
1237
1238     for (; aIter != aEnd; ++aIter)
1239     {
1240         OReportSection& rReportSection = (*aIter)->getReportSection();
1241         rReportSection.getPage()->resetSpecialMode();
1242     }
1243 }
1244
1245 void OViewsWindow::EndDragObj(bool _bControlKeyPressed, const OSectionView* _pSection, const Point& _aPnt)
1246 {
1247     const OUString sUndoAction = ModuleRes(RID_STR_UNDO_CHANGEPOSITION);
1248     const UndoContext aUndoContext( getView()->getReportView()->getController().getUndoManager(), sUndoAction );
1249
1250     Point aNewPos = _aPnt;
1251     OSectionView* pInSection = getSectionRelativeToPosition(_pSection, aNewPos);
1252     if (!_bControlKeyPressed &&
1253         _pSection && !_pSection->IsDragResize() && /* Not in resize mode */
1254         _pSection != pInSection)
1255     {
1256         EndDragObj_removeInvisibleObjects();
1257
1258         // we need to manipulate the current clickpoint, we subtract the old delta from BeginDrag
1259         aNewPos -= m_aDragDelta;
1260
1261         uno::Sequence< beans::NamedValue > aAllreadyCopiedObjects;
1262         TSectionsMap::iterator aIter = m_aSections.begin();
1263         const TSectionsMap::iterator aEnd = m_aSections.end();
1264         for (; aIter != aEnd; ++aIter)
1265         {
1266             OReportSection& rReportSection = (*aIter)->getReportSection();
1267             if ( pInSection != &rReportSection.getSectionView() )
1268             {
1269                 rReportSection.getSectionView().BrkAction();
1270                 rReportSection.Copy(aAllreadyCopiedObjects,true);
1271             }
1272             else
1273                 pInSection->EndDragObj(false);
1274         }
1275
1276         if ( aAllreadyCopiedObjects.getLength() )
1277         {
1278             beans::NamedValue* pIter = aAllreadyCopiedObjects.getArray();
1279             const beans::NamedValue* pEnd = pIter + aAllreadyCopiedObjects.getLength();
1280             try
1281             {
1282                 uno::Reference<report::XReportDefinition> xReportDefinition = getView()->getReportView()->getController().getReportDefinition();
1283                 const sal_Int32 nLeftMargin  = getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_LEFTMARGIN);
1284                 const sal_Int32 nRightMargin = getStyleProperty<sal_Int32>(xReportDefinition,PROPERTY_RIGHTMARGIN);
1285                 const sal_Int32 nPaperWidth  = getStyleProperty<awt::Size>(xReportDefinition,PROPERTY_PAPERSIZE).Width;
1286
1287                 if ( aNewPos.X() < nLeftMargin )
1288                     aNewPos.X() = nLeftMargin;
1289                 if ( aNewPos.Y() < 0 )
1290                     aNewPos.Y() = 0;
1291
1292                 Point aPrevious;
1293                 for (; pIter != pEnd; ++pIter)
1294                 {
1295                     uno::Sequence< uno::Reference<report::XReportComponent> > aClones;
1296                     pIter->Value >>= aClones;
1297                     uno::Reference<report::XReportComponent>* pColIter = aClones.getArray();
1298                     const uno::Reference<report::XReportComponent>* pColEnd = pColIter + aClones.getLength();
1299
1300                     // move the cloned Components to new positions
1301                     for (; pColIter != pColEnd; ++pColIter)
1302                     {
1303                         uno::Reference< report::XReportComponent> xRC(*pColIter);
1304                         aPrevious = VCLPoint(xRC->getPosition());
1305                         awt::Size aSize = xRC->getSize();
1306
1307                         if ( aNewPos.X() < nLeftMargin )
1308                         {
1309                             aNewPos.X() = nLeftMargin;
1310                         }
1311                         else if ( (aNewPos.X() + aSize.Width) > (nPaperWidth - nRightMargin) )
1312                         {
1313                             aNewPos.X() = nPaperWidth - nRightMargin - aSize.Width;
1314                         }
1315                         if ( aNewPos.Y() < 0 )
1316                         {
1317                             aNewPos.Y() = 0;
1318                         }
1319                         if ( aNewPos.X() < 0 )
1320                         {
1321                             aSize.Width += aNewPos.X();
1322                             aNewPos.X()= 0;
1323                             xRC->setSize(aSize);
1324                         }
1325                         xRC->setPosition(AWTPoint(aNewPos));
1326                         if ( (pColIter+1) != pColEnd )
1327                         {
1328                             // bring aNewPos to the position of the next object
1329                             uno::Reference< report::XReportComponent> xRCNext(*(pColIter + 1),uno::UNO_QUERY);
1330                             Point aNextPosition = VCLPoint(xRCNext->getPosition());
1331                             aNewPos += (aNextPosition - aPrevious);
1332                         }
1333                     }
1334                 }
1335             }
1336             catch(uno::Exception&)
1337             {
1338             }
1339             pInSection->getReportSection()->Paste(aAllreadyCopiedObjects,true);
1340         }
1341     }
1342     else
1343     {
1344         ::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction( false ) );
1345         EndDragObj_removeInvisibleObjects();
1346     }
1347     m_aDragDelta = Point(SAL_MAX_INT32, SAL_MAX_INT32);
1348 }
1349
1350 void OViewsWindow::EndAction()
1351 {
1352     ::std::for_each( m_aSections.begin(), m_aSections.end(), ApplySectionViewAction() );
1353 }
1354
1355 void OViewsWindow::MovAction(const Point& _aPnt,const OSectionView* _pSection,bool _bMove, bool _bControlKeySet)
1356 {
1357     (void)_bMove;
1358
1359     Point aRealMousePos = _aPnt;
1360     Point aCurrentSectionPos;
1361     SAL_INFO(
1362         "reportdesign",
1363         "X:" << aRealMousePos.X() << " Y:" << aRealMousePos.Y());
1364
1365     Point aHdlPos;
1366     SdrHdl* pHdl = _pSection->GetDragHdl();
1367     if ( pHdl )
1368     {
1369         aHdlPos = pHdl->GetPos();
1370     }
1371
1372     TSectionsMap::iterator aIter;
1373     TSectionsMap::iterator aEnd = m_aSections.end();
1374
1375     for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
1376     {
1377         OReportSection& rReportSection = (*aIter)->getReportSection();
1378         if ( &rReportSection.getSectionView() == _pSection )
1379             break;
1380         const long nSectionHeight = (*aIter)->PixelToLogic(rReportSection.GetOutputSizePixel()).Height();
1381         aCurrentSectionPos.Y() += nSectionHeight;
1382     }
1383     aRealMousePos += aCurrentSectionPos;
1384
1385     // If control key is pressed the work area is limited to the section with the current selection.
1386     Point aPosForWorkArea(0,0);
1387     for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
1388     {
1389         OReportSection& rReportSection = (*aIter)->getReportSection();
1390         OSectionView& rView = rReportSection.getSectionView();
1391         const long nSectionHeight = (*aIter)->PixelToLogic((*aIter)->GetOutputSizePixel()).Height();
1392
1393         if (_bControlKeySet)
1394         {
1395             Rectangle aClipRect = rView.GetWorkArea();
1396             aClipRect.Top() = aCurrentSectionPos.Y() - aPosForWorkArea.Y();
1397             aClipRect.Bottom() = aClipRect.Top() + nSectionHeight;
1398             rView.SetWorkArea( aClipRect );
1399         }
1400         else
1401         {
1402             Rectangle aClipRect = rView.GetWorkArea();
1403             aClipRect.Top() = -aPosForWorkArea.Y();
1404             rView.SetWorkArea( aClipRect );
1405         }
1406         aPosForWorkArea.Y() += nSectionHeight;
1407     }
1408
1409
1410     for (aIter = m_aSections.begin(); aIter != aEnd; ++aIter)
1411     {
1412         OReportSection& rReportSection = (*aIter)->getReportSection();
1413         SdrHdl* pCurrentHdl = rReportSection.getSectionView().GetDragHdl();
1414         if ( pCurrentHdl )
1415         {
1416             if ( aRealMousePos.Y() > 0 )
1417                 aRealMousePos = _aPnt + pCurrentHdl->GetPos() - aHdlPos;
1418         }
1419         rReportSection.getSectionView().MovAction ( aRealMousePos );
1420         const long nSectionHeight = (*aIter)->PixelToLogic((*aIter)->GetOutputSizePixel()).Height();
1421         aRealMousePos.Y() -= nSectionHeight;
1422     }
1423 }
1424
1425 bool OViewsWindow::IsAction() const
1426 {
1427     bool bAction = false;
1428     TSectionsMap::const_iterator aIter = m_aSections.begin();
1429     TSectionsMap::const_iterator aEnd = m_aSections.end();
1430     for (; !bAction && aIter != aEnd; ++aIter)
1431         bAction = (*aIter)->getReportSection().getSectionView().IsAction();
1432     return bAction;
1433 }
1434
1435 bool OViewsWindow::IsDragObj() const
1436 {
1437     bool bAction = false;
1438     TSectionsMap::const_iterator aIter = m_aSections.begin();
1439     TSectionsMap::const_iterator aEnd = m_aSections.end();
1440     for (; !bAction && aIter != aEnd; ++aIter)
1441         bAction = (*aIter)->getReportSection().getSectionView().IsAction();
1442     return bAction;
1443 }
1444
1445 sal_uInt32 OViewsWindow::getMarkedObjectCount() const
1446 {
1447     sal_uInt32 nCount = 0;
1448     TSectionsMap::const_iterator aIter = m_aSections.begin();
1449     TSectionsMap::const_iterator aEnd = m_aSections.end();
1450     for (; aIter != aEnd; ++aIter)
1451         nCount += static_cast<sal_uInt32>((*aIter)->getReportSection().getSectionView().GetMarkedObjectCount());
1452     return nCount;
1453 }
1454
1455 void OViewsWindow::handleKey(const vcl::KeyCode& _rCode)
1456 {
1457     const sal_uInt16 nCode = _rCode.GetCode();
1458     if ( _rCode.IsMod1() )
1459     {
1460         // scroll page
1461         OScrollWindowHelper* pScrollWindow = getView()->getScrollWindow();
1462         ScrollBar& rScrollBar = ( nCode == KEY_LEFT || nCode == KEY_RIGHT ) ? pScrollWindow->GetHScroll() : pScrollWindow->GetVScroll();
1463         if ( rScrollBar.IsVisible() )
1464             rScrollBar.DoScrollAction(( nCode == KEY_RIGHT || nCode == KEY_UP ) ? SCROLL_LINEUP : SCROLL_LINEDOWN );
1465         return;
1466     }
1467     TSectionsMap::const_iterator aIter = m_aSections.begin();
1468     TSectionsMap::const_iterator aEnd = m_aSections.end();
1469     for (; aIter != aEnd; ++aIter)
1470     {
1471         OReportSection& rReportSection = (*aIter)->getReportSection();
1472         long nX = 0;
1473         long nY = 0;
1474
1475         if ( nCode == KEY_UP )
1476             nY = -1;
1477         else if ( nCode == KEY_DOWN )
1478             nY =  1;
1479         else if ( nCode == KEY_LEFT )
1480             nX = -1;
1481         else if ( nCode == KEY_RIGHT )
1482             nX =  1;
1483
1484         if ( rReportSection.getSectionView().AreObjectsMarked() )
1485         {
1486             if ( _rCode.IsMod2() )
1487             {
1488                 // move in 1 pixel distance
1489                 const Size aPixelSize = rReportSection.PixelToLogic( Size( 1, 1 ) );
1490                 nX *= aPixelSize.Width();
1491                 nY *= aPixelSize.Height();
1492             }
1493             else
1494             {
1495                 // move in 1 mm distance
1496                 nX *= DEFAUL_MOVE_SIZE;
1497                 nY *= DEFAUL_MOVE_SIZE;
1498             }
1499
1500             OSectionView& rView = rReportSection.getSectionView();
1501             const SdrHdlList& rHdlList = rView.GetHdlList();
1502             SdrHdl* pHdl = rHdlList.GetFocusHdl();
1503
1504             if ( pHdl == 0 )
1505             {
1506                 // no handle selected
1507                 if ( rView.IsMoveAllowed() )
1508                 {
1509                     // restrict movement to work area
1510                     Rectangle rWorkArea = rView.GetWorkArea();
1511                     rWorkArea.Right()++;
1512
1513                     if ( !rWorkArea.IsEmpty() )
1514                     {
1515                         if ( rWorkArea.Top() < 0 )
1516                             rWorkArea.Top() = 0;
1517                         Rectangle aMarkRect( rView.GetMarkedObjRect() );
1518                         aMarkRect.Move( nX, nY );
1519
1520                         if ( !rWorkArea.IsInside( aMarkRect ) )
1521                         {
1522                             if ( aMarkRect.Left() < rWorkArea.Left() )
1523                                 nX += rWorkArea.Left() - aMarkRect.Left();
1524
1525                             if ( aMarkRect.Right() > rWorkArea.Right() )
1526                                 nX -= aMarkRect.Right() - rWorkArea.Right();
1527
1528                             if ( aMarkRect.Top() < rWorkArea.Top() )
1529                                 nY += rWorkArea.Top() - aMarkRect.Top();
1530
1531                             if ( aMarkRect.Bottom() > rWorkArea.Bottom() )
1532                                 nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
1533                         }
1534                         bool bCheck = false;
1535                         const SdrMarkList& rMarkList = rView.GetMarkedObjectList();
1536                         for (size_t i = 0; !bCheck && i < rMarkList.GetMarkCount(); ++i )
1537                         {
1538                             SdrMark* pMark = rMarkList.GetMark(i);
1539                             bCheck = dynamic_cast<OUnoObject*>(pMark->GetMarkedSdrObj()) != NULL|| dynamic_cast<OOle2Obj*>(pMark->GetMarkedSdrObj());
1540                         }
1541
1542
1543                         if ( bCheck )
1544                         {
1545                             SdrObject* pOverlapped = isOver(aMarkRect,*rReportSection.getPage(),rView);
1546                             if ( pOverlapped )
1547                             {
1548                                 do
1549                                 {
1550                                     Rectangle aOver = pOverlapped->GetLastBoundRect();
1551                                     Point aPos;
1552                                     if ( nCode == KEY_UP )
1553                                     {
1554                                         aPos.X() = aMarkRect.Left();
1555                                         aPos.Y() = aOver.Top() - aMarkRect.getHeight();
1556                                         nY += (aPos.Y() - aMarkRect.Top());
1557                                     }
1558                                     else if ( nCode == KEY_DOWN )
1559                                     {
1560                                         aPos.X() = aMarkRect.Left();
1561                                         aPos.Y() = aOver.Bottom();
1562                                         nY += (aPos.Y() - aMarkRect.Top());
1563                                     }
1564                                     else if ( nCode == KEY_LEFT )
1565                                     {
1566                                         aPos.X() = aOver.Left() - aMarkRect.getWidth();
1567                                         aPos.Y() = aMarkRect.Top();
1568                                         nX += (aPos.X() - aMarkRect.Left());
1569                                     }
1570                                     else if ( nCode == KEY_RIGHT )
1571                                     {
1572                                         aPos.X() = aOver.Right();
1573                                         aPos.Y() = aMarkRect.Top();
1574                                         nX += (aPos.X() - aMarkRect.Left());
1575                                     }
1576
1577                                     aMarkRect.SetPos(aPos);
1578                                     if ( !rWorkArea.IsInside( aMarkRect ) )
1579                                     {
1580                                         break;
1581                                     }
1582                                     pOverlapped = isOver(aMarkRect,*rReportSection.getPage(),rView);
1583                                 }
1584                                 while(pOverlapped != NULL);
1585                                 if (pOverlapped != NULL)
1586                                     break;
1587                             }
1588                         }
1589                     }
1590
1591                     if ( nX != 0 || nY != 0 )
1592                     {
1593                         rView.MoveAllMarked( Size( nX, nY ) );
1594                         rView.MakeVisible( rView.GetAllMarkedRect(), rReportSection);
1595                     }
1596                 }
1597             }
1598             else
1599             {
1600                 // move the handle
1601                 if ( pHdl && ( nX || nY ) )
1602                 {
1603                     const Point aStartPoint( pHdl->GetPos() );
1604                     const Point aEndPoint( pHdl->GetPos() + Point( nX, nY ) );
1605                     const SdrDragStat& rDragStat = rView.GetDragStat();
1606
1607                     // start dragging
1608                     rView.BegDragObj( aStartPoint, 0, pHdl, 0 );
1609
1610                     if ( rView.IsDragObj() )
1611                     {
1612                         const bool bWasNoSnap = rDragStat.IsNoSnap();
1613                         const bool bWasSnapEnabled = rView.IsSnapEnabled();
1614
1615                         // switch snapping off
1616                         if ( !bWasNoSnap )
1617                             ((SdrDragStat&)rDragStat).SetNoSnap( true );
1618                         if ( bWasSnapEnabled )
1619                             rView.SetSnapEnabled( false );
1620
1621                         Rectangle aNewRect;
1622                         bool bCheck = false;
1623                         const SdrMarkList& rMarkList = rView.GetMarkedObjectList();
1624                         for (size_t i = 0; !bCheck && i < rMarkList.GetMarkCount(); ++i )
1625                         {
1626                             SdrMark* pMark = rMarkList.GetMark(i);
1627                             bCheck = dynamic_cast<OUnoObject*>(pMark->GetMarkedSdrObj()) != NULL || dynamic_cast<OOle2Obj*>(pMark->GetMarkedSdrObj()) != NULL;
1628                             if ( bCheck )
1629                                 aNewRect.Union(pMark->GetMarkedSdrObj()->GetLastBoundRect());
1630                         }
1631
1632                         switch(pHdl->GetKind())
1633                         {
1634                             case HDL_LEFT:
1635                             case HDL_UPLFT:
1636                             case HDL_LWLFT:
1637                             case HDL_UPPER:
1638                                 aNewRect.Left() += nX;
1639                                 aNewRect.Top()  += nY;
1640                                 break;
1641                             case HDL_UPRGT:
1642                             case HDL_RIGHT:
1643                             case HDL_LWRGT:
1644                             case HDL_LOWER:
1645                                 aNewRect.setWidth(aNewRect.getWidth() + nX);
1646                                 aNewRect.setHeight(aNewRect.getHeight() + nY);
1647                                 break;
1648                             default:
1649                                 break;
1650                         }
1651                         if ( !(bCheck && isOver(aNewRect,*rReportSection.getPage(),rView)) )
1652                             rView.MovAction(aEndPoint);
1653                         rView.EndDragObj();
1654
1655                         // restore snap
1656                         if ( !bWasNoSnap )
1657                             ((SdrDragStat&)rDragStat).SetNoSnap( bWasNoSnap );
1658                         if ( bWasSnapEnabled )
1659                             rView.SetSnapEnabled( bWasSnapEnabled );
1660                     }
1661
1662                     // make moved handle visible
1663                     const Rectangle aVisRect( aEndPoint - Point( DEFAUL_MOVE_SIZE, DEFAUL_MOVE_SIZE ), Size( 200, 200 ) );
1664                     rView.MakeVisible( aVisRect, rReportSection);
1665                 }
1666             }
1667             rView.AdjustMarkHdl();
1668         }
1669     }
1670 }
1671
1672 void OViewsWindow::stopScrollTimer()
1673 {
1674     ::std::for_each(m_aSections.begin(),m_aSections.end(),
1675         ::o3tl::compose1(::boost::mem_fn(&OReportSection::stopScrollTimer),TReportPairHelper()));
1676 }
1677
1678 void OViewsWindow::fillCollapsedSections(::std::vector<sal_uInt16>& _rCollapsedPositions) const
1679 {
1680     TSectionsMap::const_iterator aIter = m_aSections.begin();
1681     TSectionsMap::const_iterator aEnd = m_aSections.end();
1682     for (sal_uInt16 i = 0;aIter != aEnd ; ++aIter,++i)
1683     {
1684         if ( (*aIter)->getStartMarker().isCollapsed() )
1685             _rCollapsedPositions.push_back(i);
1686     }
1687 }
1688
1689 void OViewsWindow::collapseSections(const uno::Sequence< beans::PropertyValue>& _aCollpasedSections)
1690 {
1691     const beans::PropertyValue* pIter = _aCollpasedSections.getConstArray();
1692     const beans::PropertyValue* pEnd = pIter + _aCollpasedSections.getLength();
1693     for (; pIter != pEnd; ++pIter)
1694     {
1695         sal_uInt16 nPos = sal_uInt16(-1);
1696         if ( (pIter->Value >>= nPos) && nPos < m_aSections.size() )
1697         {
1698             m_aSections[nPos]->setCollapsed(true);
1699         }
1700     }
1701 }
1702
1703 void OViewsWindow::zoom(const Fraction& _aZoom)
1704 {
1705     const MapMode& aMapMode = GetMapMode();
1706
1707     Fraction aStartWidth(long(REPORT_STARTMARKER_WIDTH));
1708     if ( _aZoom < aMapMode.GetScaleX() )
1709         aStartWidth *= aMapMode.GetScaleX();
1710     else
1711         aStartWidth *= _aZoom;
1712
1713     setZoomFactor(_aZoom,*this);
1714
1715     TSectionsMap::iterator aIter = m_aSections.begin();
1716     TSectionsMap::iterator aEnd = m_aSections.end();
1717     for (;aIter != aEnd ; ++aIter)
1718     {
1719         (*aIter)->zoom(_aZoom);
1720     }
1721
1722     Resize();
1723
1724     Size aOut = GetOutputSizePixel();
1725     aOut.Width() = aStartWidth;
1726     aOut = PixelToLogic(aOut);
1727
1728     Rectangle aRect(PixelToLogic(Point(0,0)),aOut);
1729     static sal_Int32 nIn = INVALIDATE_NOCHILDREN;
1730     Invalidate(aRect,nIn);
1731 }
1732
1733 void OViewsWindow::scrollChildren(const Point& _aThumbPos)
1734 {
1735     const Point aPos(PixelToLogic(_aThumbPos));
1736     {
1737         MapMode aMapMode = GetMapMode();
1738         const Point aOld = aMapMode.GetOrigin();
1739         aMapMode.SetOrigin(m_pParent->GetMapMode().GetOrigin());
1740
1741         const Point aPosY(m_pParent->PixelToLogic(_aThumbPos,aMapMode));
1742
1743         aMapMode.SetOrigin( Point(aOld.X() , - aPosY.Y()));
1744         SetMapMode( aMapMode );
1745         Scroll(0, -( aOld.Y() + aPosY.Y()),SCROLL_CHILDREN);
1746     }
1747
1748     TSectionsMap::iterator aIter = m_aSections.begin();
1749     TSectionsMap::iterator aEnd = m_aSections.end();
1750     for (;aIter != aEnd ; ++aIter)
1751     {
1752         (*aIter)->scrollChildren(aPos.X());
1753     }
1754 }
1755
1756 void OViewsWindow::fillControlModelSelection(::std::vector< uno::Reference< uno::XInterface > >& _rSelection) const
1757 {
1758     TSectionsMap::const_iterator aIter = m_aSections.begin();
1759     TSectionsMap::const_iterator aEnd = m_aSections.end();
1760     for(;aIter != aEnd; ++aIter)
1761     {
1762         (*aIter)->getReportSection().fillControlModelSelection(_rSelection);
1763     }
1764 }
1765
1766 } // rptui
1767
1768
1769 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */