LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdedxv.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 108 1099 9.8 %
Date: 2014-11-03 Functions: 20 69 29.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <com/sun/star/i18n/WordType.hpp>
      21             : #include <svtools/accessibilityoptions.hxx>
      22             : #include <svx/svdedxv.hxx>
      23             : #include <svl/solar.hrc>
      24             : #include <svl/itemiter.hxx>
      25             : #include <vcl/msgbox.hxx>
      26             : #include <vcl/hatch.hxx>
      27             : #include <svl/whiter.hxx>
      28             : #include <svl/style.hxx>
      29             : #include <editeng/editstat.hxx>
      30             : #include <vcl/cursor.hxx>
      31             : #include <editeng/unotext.hxx>
      32             : #include <editeng/editdata.hxx>
      33             : #include <editeng/editeng.hxx>
      34             : #include <editeng/editobj.hxx>
      35             : #include <editeng/outlobj.hxx>
      36             : #include <editeng/scripttypeitem.hxx>
      37             : #include <svx/svdoutl.hxx>
      38             : #include <svx/sdtfchim.hxx>
      39             : #include <svx/svdotext.hxx>
      40             : #include <svx/svdundo.hxx>
      41             : #include "svx/svditer.hxx"
      42             : #include "svx/svdpagv.hxx"
      43             : #include "svx/svdpage.hxx"
      44             : #include "svx/svdetc.hxx"
      45             : #include "svx/svdotable.hxx"
      46             : #include <svx/selectioncontroller.hxx>
      47             : #ifdef DBG_UTIL
      48             : #include <svdibrow.hxx>
      49             : #endif
      50             : #include <svx/svddrgv.hxx>
      51             : #include "svx/svdstr.hrc"
      52             : #include "svdglob.hxx"
      53             : #include "svx/globl3d.hxx"
      54             : #include <editeng/outliner.hxx>
      55             : #include <editeng/adjustitem.hxx>
      56             : #include <svtools/colorcfg.hxx>
      57             : #include <vcl/svapp.hxx>
      58             : #include <svx/sdrpaintwindow.hxx>
      59             : #include <svx/sdrundomanager.hxx>
      60             : #include <sdr/overlay/overlaytools.hxx>
      61             : #include <svx/sdr/table/tablecontroller.hxx>
      62             : #include <drawinglayer/processor2d/processor2dtools.hxx>
      63             : #include <boost/scoped_ptr.hpp>
      64             : 
      65             : 
      66       15989 : void SdrObjEditView::ImpClearVars()
      67             : {
      68       15989 :     bQuickTextEditMode=true;
      69       15989 :     bMacroMode=true;
      70       15989 :     pTextEditOutliner=NULL;
      71       15989 :     pTextEditOutlinerView=NULL;
      72       15989 :     pTextEditPV=NULL;
      73       15989 :     pTextEditWin=NULL;
      74       15989 :     pTextEditCursorMerker=NULL;
      75       15989 :     pEditPara=NULL;
      76       15989 :     bTextEditNewObj=false;
      77       15989 :     bMacroDown=false;
      78       15989 :     pMacroObj=NULL;
      79       15989 :     pMacroPV=NULL;
      80       15989 :     pMacroWin=NULL;
      81       15989 :     nMacroTol=0;
      82       15989 :     bTextEditDontDelete=false;
      83       15989 :     bTextEditOnlyOneView=false;
      84       15989 : }
      85             : 
      86       15989 : SdrObjEditView::SdrObjEditView(SdrModel* pModel1, OutputDevice* pOut):
      87             :     SdrGlueEditView(pModel1,pOut),
      88       15989 :     mpOldTextEditUndoManager(0)
      89             : {
      90       15989 :     ImpClearVars();
      91       15989 : }
      92             : 
      93       31838 : SdrObjEditView::~SdrObjEditView()
      94             : {
      95       15919 :     pTextEditWin = NULL;            // so there's no ShowCursor in SdrEndTextEdit
      96       15919 :     if (IsTextEdit())
      97           0 :         SdrEndTextEdit();
      98       15919 :     delete pTextEditOutliner;
      99       15919 :     delete mpOldTextEditUndoManager;
     100       15919 : }
     101             : 
     102             : 
     103             : 
     104        3423 : bool SdrObjEditView::IsAction() const
     105             : {
     106        3423 :     return IsMacroObj() || SdrGlueEditView::IsAction();
     107             : }
     108             : 
     109           0 : void SdrObjEditView::MovAction(const Point& rPnt)
     110             : {
     111           0 :     if (IsMacroObj()) MovMacroObj(rPnt);
     112           0 :     SdrGlueEditView::MovAction(rPnt);
     113           0 : }
     114             : 
     115           0 : void SdrObjEditView::EndAction()
     116             : {
     117           0 :     if (IsMacroObj()) EndMacroObj();
     118           0 :     SdrGlueEditView::EndAction();
     119           0 : }
     120             : 
     121           0 : void SdrObjEditView::BckAction()
     122             : {
     123           0 :     BrkMacroObj();
     124           0 :     SdrGlueEditView::BckAction();
     125           0 : }
     126             : 
     127        8919 : void SdrObjEditView::BrkAction()
     128             : {
     129        8919 :     BrkMacroObj();
     130        8919 :     SdrGlueEditView::BrkAction();
     131        8919 : }
     132             : 
     133           0 : void SdrObjEditView::TakeActionRect(Rectangle& rRect) const
     134             : {
     135           0 :     if (IsMacroObj()) {
     136           0 :         rRect=pMacroObj->GetCurrentBoundRect();
     137             :     } else {
     138           0 :         SdrGlueEditView::TakeActionRect(rRect);
     139             :     }
     140           0 : }
     141             : 
     142      480398 : void SdrObjEditView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
     143             : {
     144      480398 :     SdrGlueEditView::Notify(rBC,rHint);
     145             :     // change of printer while editing
     146      480398 :     const SdrHint* pSdrHint = dynamic_cast<const SdrHint*>(&rHint);
     147      480398 :     if (pSdrHint!=NULL && pTextEditOutliner!=NULL) {
     148           0 :         SdrHintKind eKind=pSdrHint->GetKind();
     149           0 :         if (eKind==HINT_REFDEVICECHG) {
     150           0 :             pTextEditOutliner->SetRefDevice(pMod->GetRefDevice());
     151             :         }
     152           0 :         if (eKind==HINT_DEFAULTTABCHG) {
     153           0 :             pTextEditOutliner->SetDefTab(pMod->GetDefaultTabulator());
     154             :         }
     155             :         if (eKind==HINT_DEFFONTHGTCHG) {
     156             : 
     157             :         }
     158           0 :         if (eKind==HINT_MODELSAVED) {
     159           0 :             pTextEditOutliner->ClearModifyFlag();
     160             :         }
     161             :     }
     162      480398 : }
     163             : 
     164        8129 : void SdrObjEditView::ModelHasChanged()
     165             : {
     166        8129 :     SdrGlueEditView::ModelHasChanged();
     167        8129 :     if (mxTextEditObj.is() && !mxTextEditObj->IsInserted()) SdrEndTextEdit(); // object deleted
     168             :     // TextEditObj changed?
     169        8129 :     if (IsTextEdit()) {
     170           0 :         SdrTextObj* pTextObj=dynamic_cast<SdrTextObj*>( mxTextEditObj.get() );
     171           0 :         if (pTextObj!=NULL) {
     172           0 :             sal_uIntPtr nOutlViewAnz=pTextEditOutliner->GetViewCount();
     173           0 :             bool bAreaChg=false;
     174           0 :             bool bAnchorChg=false;
     175           0 :             bool bColorChg=false;
     176           0 :             bool bContourFrame=pTextObj->IsContourTextFrame();
     177           0 :             EVAnchorMode eNewAnchor(ANCHOR_VCENTER_HCENTER);
     178           0 :             Rectangle aOldArea(aMinTextEditArea);
     179           0 :             aOldArea.Union(aTextEditArea);
     180           0 :             Color aNewColor;
     181             :             { // check area
     182           0 :                 Size aPaperMin1;
     183           0 :                 Size aPaperMax1;
     184           0 :                 Rectangle aEditArea1;
     185           0 :                 Rectangle aMinArea1;
     186           0 :                 pTextObj->TakeTextEditArea(&aPaperMin1,&aPaperMax1,&aEditArea1,&aMinArea1);
     187             : 
     188           0 :                 Point aPvOfs(pTextObj->GetTextEditOffset());
     189             :                 // Hack for calc, transform position of edit object according
     190             :                 // to current zoom so as objects relative position to grid
     191             :                 // appears stable
     192           0 :                 aEditArea1 += pTextObj->GetGridOffset();
     193           0 :                 aMinArea1 += pTextObj->GetGridOffset();
     194           0 :                 aEditArea1.Move(aPvOfs.X(),aPvOfs.Y());
     195           0 :                 aMinArea1.Move(aPvOfs.X(),aPvOfs.Y());
     196           0 :                 Rectangle aNewArea(aMinArea1);
     197           0 :                 aNewArea.Union(aEditArea1);
     198             : 
     199           0 :                 if (aNewArea!=aOldArea || aEditArea1!=aTextEditArea || aMinArea1!=aMinTextEditArea ||
     200           0 :                     pTextEditOutliner->GetMinAutoPaperSize()!=aPaperMin1 || pTextEditOutliner->GetMaxAutoPaperSize()!=aPaperMax1) {
     201           0 :                     aTextEditArea=aEditArea1;
     202           0 :                     aMinTextEditArea=aMinArea1;
     203           0 :                     pTextEditOutliner->SetUpdateMode(false);
     204           0 :                     pTextEditOutliner->SetMinAutoPaperSize(aPaperMin1);
     205           0 :                     pTextEditOutliner->SetMaxAutoPaperSize(aPaperMax1);
     206           0 :                     pTextEditOutliner->SetPaperSize(Size(0,0)); // re-format Outliner
     207           0 :                     if (!bContourFrame) {
     208           0 :                         pTextEditOutliner->ClearPolygon();
     209           0 :                         sal_uIntPtr nStat=pTextEditOutliner->GetControlWord();
     210           0 :                         nStat|=EE_CNTRL_AUTOPAGESIZE;
     211           0 :                         pTextEditOutliner->SetControlWord(nStat);
     212             :                     } else {
     213           0 :                         sal_uIntPtr nStat=pTextEditOutliner->GetControlWord();
     214           0 :                         nStat&=~EE_CNTRL_AUTOPAGESIZE;
     215           0 :                         pTextEditOutliner->SetControlWord(nStat);
     216           0 :                         Rectangle aAnchorRect;
     217           0 :                         pTextObj->TakeTextAnchorRect(aAnchorRect);
     218           0 :                         pTextObj->ImpSetContourPolygon(*pTextEditOutliner,aAnchorRect, true);
     219             :                     }
     220           0 :                     for (sal_uIntPtr nOV=0; nOV<nOutlViewAnz; nOV++) {
     221           0 :                         OutlinerView* pOLV=pTextEditOutliner->GetView(nOV);
     222           0 :                         sal_uIntPtr nStat0=pOLV->GetControlWord();
     223           0 :                         sal_uIntPtr nStat=nStat0;
     224             :                         // AutoViewSize only if not ContourFrame.
     225           0 :                         if (!bContourFrame) nStat|=EV_CNTRL_AUTOSIZE;
     226           0 :                         else nStat&=~EV_CNTRL_AUTOSIZE;
     227           0 :                         if (nStat!=nStat0) pOLV->SetControlWord(nStat);
     228             :                     }
     229           0 :                     pTextEditOutliner->SetUpdateMode(true);
     230           0 :                     bAreaChg=true;
     231             :                 }
     232             :             }
     233           0 :             if (pTextEditOutlinerView!=NULL) { // check fill and anchor
     234           0 :                 EVAnchorMode eOldAnchor=pTextEditOutlinerView->GetAnchorMode();
     235           0 :                 eNewAnchor=(EVAnchorMode)pTextObj->GetOutlinerViewAnchorMode();
     236           0 :                 bAnchorChg=eOldAnchor!=eNewAnchor;
     237           0 :                 Color aOldColor(pTextEditOutlinerView->GetBackgroundColor());
     238           0 :                 aNewColor = GetTextEditBackgroundColor(*this);
     239           0 :                 bColorChg=aOldColor!=aNewColor;
     240             :             }
     241             :             // refresh always when it's a contour frame. That
     242             :             // refresh is necessary since it triggers the repaint
     243             :             // which makes the Handles visible. Changes at TakeTextRect()
     244             :             // seem to have resulted in a case where no refresh is executed.
     245             :             // Before that, a refresh must have been always executed
     246             :             // (else this error would have happened earlier), thus I
     247             :             // even think here a refresh should be done always.
     248             :             // Since follow-up problems cannot even be guessed I only
     249             :             // add this one more case to the if below.
     250             :             // BTW: It's VERY bad style that here, inside ModelHasChanged()
     251             :             // the outliner is again massively changed for the text object
     252             :             // in text edit mode. Normally, all necessary data should be
     253             :             // set at SdrBeginTextEdit(). Some changes and value assigns in
     254             :             // SdrBeginTextEdit() are completely useless since they are set here
     255             :             // again on ModelHasChanged().
     256           0 :             if (bContourFrame || bAreaChg || bAnchorChg || bColorChg)
     257             :             {
     258           0 :                 for (sal_uIntPtr nOV=0; nOV<nOutlViewAnz; nOV++)
     259             :                 {
     260           0 :                     OutlinerView* pOLV=pTextEditOutliner->GetView(nOV);
     261             :                     { // invalidate old OutlinerView area
     262           0 :                         vcl::Window* pWin=pOLV->GetWindow();
     263           0 :                         Rectangle aTmpRect(aOldArea);
     264           0 :                         sal_uInt16 nPixSiz=pOLV->GetInvalidateMore()+1;
     265           0 :                         Size aMore(pWin->PixelToLogic(Size(nPixSiz,nPixSiz)));
     266           0 :                         aTmpRect.Left()-=aMore.Width();
     267           0 :                         aTmpRect.Right()+=aMore.Width();
     268           0 :                         aTmpRect.Top()-=aMore.Height();
     269           0 :                         aTmpRect.Bottom()+=aMore.Height();
     270           0 :                         InvalidateOneWin(*pWin,aTmpRect);
     271             :                     }
     272           0 :                     if (bAnchorChg)
     273           0 :                         pOLV->SetAnchorMode(eNewAnchor);
     274           0 :                     if (bColorChg)
     275           0 :                         pOLV->SetBackgroundColor( aNewColor );
     276             : 
     277           0 :                     pOLV->SetOutputArea(aTextEditArea); // because otherwise, we're not re-anchoring correctly
     278           0 :                     ImpInvalidateOutlinerView(*pOLV);
     279             :                 }
     280           0 :                 pTextEditOutlinerView->ShowCursor();
     281             :             }
     282             :         }
     283           0 :         ImpMakeTextCursorAreaVisible();
     284             :     }
     285        8129 : }
     286             : 
     287             : 
     288             : // TextEdit
     289             : 
     290             : 
     291           0 : void SdrObjEditView::TextEditDrawing(SdrPaintWindow& rPaintWindow) const
     292             : {
     293             :     // draw old text edit stuff
     294           0 :     if(IsTextEdit())
     295             :     {
     296           0 :         const SdrOutliner* pActiveOutliner = GetTextEditOutliner();
     297             : 
     298           0 :         if(pActiveOutliner)
     299             :         {
     300           0 :             const sal_uInt32 nViewAnz(pActiveOutliner->GetViewCount());
     301             : 
     302           0 :             if(nViewAnz)
     303             :             {
     304           0 :                 const vcl::Region& rRedrawRegion = rPaintWindow.GetRedrawRegion();
     305           0 :                 const Rectangle aCheckRect(rRedrawRegion.GetBoundRect());
     306             : 
     307           0 :                 for(sal_uInt32 i(0); i < nViewAnz; i++)
     308             :                 {
     309           0 :                     OutlinerView* pOLV = pActiveOutliner->GetView(i);
     310             : 
     311           0 :                     if(pOLV->GetWindow() == &rPaintWindow.GetOutputDevice())
     312             :                     {
     313           0 :                         ImpPaintOutlinerView(*pOLV, aCheckRect, rPaintWindow.GetTargetOutputDevice());
     314           0 :                         return;
     315             :                     }
     316             :                 }
     317             :             }
     318             :         }
     319             :     }
     320             : }
     321             : 
     322           0 : void SdrObjEditView::ImpPaintOutlinerView(OutlinerView& rOutlView, const Rectangle& rRect, OutputDevice& rTargetDevice) const
     323             : {
     324           0 :     const SdrTextObj* pText = PTR_CAST(SdrTextObj,GetTextEditObject());
     325           0 :     bool bTextFrame(pText && pText->IsTextFrame());
     326           0 :     bool bFitToSize(0 != (pTextEditOutliner->GetControlWord() & EE_CNTRL_STRETCHING));
     327           0 :     bool bModifyMerk(pTextEditOutliner->IsModified()); // #43095#
     328           0 :     Rectangle aBlankRect(rOutlView.GetOutputArea());
     329           0 :     aBlankRect.Union(aMinTextEditArea);
     330           0 :     Rectangle aPixRect(rTargetDevice.LogicToPixel(aBlankRect));
     331           0 :     aBlankRect.Intersection(rRect);
     332           0 :     rOutlView.GetOutliner()->SetUpdateMode(true); // Bugfix #22596#
     333           0 :     rOutlView.Paint(aBlankRect, &rTargetDevice);
     334             : 
     335           0 :     if(!bModifyMerk)
     336             :     {
     337             :         // #43095#
     338           0 :         pTextEditOutliner->ClearModifyFlag();
     339             :     }
     340             : 
     341           0 :     if(bTextFrame && !bFitToSize)
     342             :     {
     343             :         // completely reworked to use primitives; this ensures same look and functionality
     344           0 :         const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
     345             :         boost::scoped_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor(drawinglayer::processor2d::createProcessor2DFromOutputDevice(
     346             :             rTargetDevice,
     347           0 :             aViewInformation2D));
     348             : 
     349           0 :         if(pProcessor)
     350             :         {
     351           0 :             const bool bMerk(rTargetDevice.IsMapModeEnabled());
     352           0 :             const basegfx::B2DRange aRange(aPixRect.Left(), aPixRect.Top(), aPixRect.Right(), aPixRect.Bottom());
     353           0 :             const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
     354           0 :             const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor());
     355           0 :             const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
     356           0 :             const sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
     357             :             const drawinglayer::primitive2d::Primitive2DReference xReference(
     358             :                 new drawinglayer::primitive2d::OverlayRectanglePrimitive(
     359             :                     aRange,
     360             :                     aHilightColor.getBColor(),
     361             :                     fTransparence,
     362           0 :                     std::max(6, nPixSiz - 2), // grow
     363             :                     0.0, // shrink
     364           0 :                     0.0));
     365           0 :             const drawinglayer::primitive2d::Primitive2DSequence aSequence(&xReference, 1);
     366             : 
     367           0 :             rTargetDevice.EnableMapMode(false);
     368           0 :             pProcessor->process(aSequence);
     369           0 :             rTargetDevice.EnableMapMode(bMerk);
     370           0 :         }
     371             :     }
     372             : 
     373           0 :     rOutlView.ShowCursor();
     374           0 : }
     375             : 
     376           0 : void SdrObjEditView::ImpInvalidateOutlinerView(OutlinerView& rOutlView) const
     377             : {
     378           0 :     vcl::Window* pWin = rOutlView.GetWindow();
     379             : 
     380           0 :     if(pWin)
     381             :     {
     382           0 :         const SdrTextObj* pText = PTR_CAST(SdrTextObj,GetTextEditObject());
     383           0 :         bool bTextFrame(pText && pText->IsTextFrame());
     384           0 :         bool bFitToSize(pText && pText->IsFitToSize());
     385             : 
     386           0 :         if(bTextFrame && !bFitToSize)
     387             :         {
     388           0 :             Rectangle aBlankRect(rOutlView.GetOutputArea());
     389           0 :             aBlankRect.Union(aMinTextEditArea);
     390           0 :             Rectangle aPixRect(pWin->LogicToPixel(aBlankRect));
     391           0 :             sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
     392             : 
     393           0 :             aPixRect.Left()--;
     394           0 :             aPixRect.Top()--;
     395           0 :             aPixRect.Right()++;
     396           0 :             aPixRect.Bottom()++;
     397             : 
     398             :             {
     399             :                 // limit xPixRect because of driver problems when pixel coordinates are too far out
     400           0 :                 Size aMaxXY(pWin->GetOutputSizePixel());
     401           0 :                 long a(2 * nPixSiz);
     402           0 :                 long nMaxX(aMaxXY.Width() + a);
     403           0 :                 long nMaxY(aMaxXY.Height() + a);
     404             : 
     405           0 :                 if (aPixRect.Left  ()<-a) aPixRect.Left()=-a;
     406           0 :                 if (aPixRect.Top   ()<-a) aPixRect.Top ()=-a;
     407           0 :                 if (aPixRect.Right ()>nMaxX) aPixRect.Right ()=nMaxX;
     408           0 :                 if (aPixRect.Bottom()>nMaxY) aPixRect.Bottom()=nMaxY;
     409             :             }
     410             : 
     411           0 :             Rectangle aOuterPix(aPixRect);
     412           0 :             aOuterPix.Left()-=nPixSiz;
     413           0 :             aOuterPix.Top()-=nPixSiz;
     414           0 :             aOuterPix.Right()+=nPixSiz;
     415           0 :             aOuterPix.Bottom()+=nPixSiz;
     416             : 
     417           0 :             bool bMerk(pWin->IsMapModeEnabled());
     418           0 :             pWin->EnableMapMode(false);
     419           0 :             pWin->Invalidate(aOuterPix);
     420           0 :             pWin->EnableMapMode(bMerk);
     421             :         }
     422             :     }
     423           0 : }
     424             : 
     425           0 : OutlinerView* SdrObjEditView::ImpMakeOutlinerView(vcl::Window* pWin, bool /*bNoPaint*/, OutlinerView* pGivenView) const
     426             : {
     427             :     // background
     428           0 :     Color aBackground(GetTextEditBackgroundColor(*this));
     429           0 :     SdrTextObj* pText = dynamic_cast< SdrTextObj * >( mxTextEditObj.get() );
     430           0 :     bool bTextFrame=pText!=NULL && pText->IsTextFrame();
     431           0 :     bool bContourFrame=pText!=NULL && pText->IsContourTextFrame();
     432             :     // create OutlinerView
     433           0 :     OutlinerView* pOutlView=pGivenView;
     434           0 :     pTextEditOutliner->SetUpdateMode(false);
     435           0 :     if (pOutlView==NULL) pOutlView = new OutlinerView(pTextEditOutliner,pWin);
     436           0 :     else pOutlView->SetWindow(pWin);
     437             :     // disallow scrolling
     438           0 :     sal_uIntPtr nStat=pOutlView->GetControlWord();
     439           0 :     nStat&=~EV_CNTRL_AUTOSCROLL;
     440             :     // AutoViewSize only if not ContourFrame.
     441           0 :     if (!bContourFrame) nStat|=EV_CNTRL_AUTOSIZE;
     442           0 :     if (bTextFrame) {
     443           0 :         sal_uInt16 nPixSiz=aHdl.GetHdlSize()*2+1;
     444           0 :         nStat|=EV_CNTRL_INVONEMORE;
     445           0 :         pOutlView->SetInvalidateMore(nPixSiz);
     446             :     }
     447           0 :     pOutlView->SetControlWord(nStat);
     448           0 :     pOutlView->SetBackgroundColor( aBackground );
     449           0 :     if (pText!=NULL)
     450             :     {
     451           0 :         pOutlView->SetAnchorMode((EVAnchorMode)(pText->GetOutlinerViewAnchorMode()));
     452           0 :         pTextEditOutliner->SetFixedCellHeight(static_cast<const SdrTextFixedCellHeightItem&>(pText->GetMergedItem(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue());
     453             :     }
     454             :     // do update before setting output area so that aTextEditArea can be recalculated
     455           0 :     pTextEditOutliner->SetUpdateMode(true);
     456           0 :     pOutlView->SetOutputArea(aTextEditArea);
     457           0 :     ImpInvalidateOutlinerView(*pOutlView);
     458           0 :     return pOutlView;
     459             : }
     460             : 
     461           0 : IMPL_LINK(SdrObjEditView,ImpOutlinerStatusEventHdl,EditStatus*,pEditStat)
     462             : {
     463           0 :     if(pTextEditOutliner )
     464             :     {
     465           0 :         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj * >( mxTextEditObj.get() );
     466           0 :         if( pTextObj )
     467             :         {
     468           0 :             pTextObj->onEditOutlinerStatusEvent( pEditStat );
     469             :         }
     470             :     }
     471           0 :     return 0;
     472             : }
     473             : 
     474           0 : IMPL_LINK(SdrObjEditView,ImpOutlinerCalcFieldValueHdl,EditFieldInfo*,pFI)
     475             : {
     476           0 :     bool bOk=false;
     477           0 :     OUString& rStr=pFI->GetRepresentation();
     478           0 :     rStr = "";
     479           0 :     SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() );
     480           0 :     if (pTextObj!=NULL) {
     481           0 :         Color* pTxtCol=NULL;
     482           0 :         Color* pFldCol=NULL;
     483           0 :         bOk=pTextObj->CalcFieldValue(pFI->GetField(),pFI->GetPara(),pFI->GetPos(),true,pTxtCol,pFldCol,rStr);
     484           0 :         if (bOk) {
     485           0 :             if (pTxtCol!=NULL) {
     486           0 :                 pFI->SetTxtColor(*pTxtCol);
     487           0 :                 delete pTxtCol;
     488             :             }
     489           0 :             if (pFldCol!=NULL) {
     490           0 :                 pFI->SetFldColor(*pFldCol);
     491           0 :                 delete pFldCol;
     492             :             } else {
     493           0 :                 pFI->SetFldColor(Color(COL_LIGHTGRAY)); // TODO: remove this later on (357)
     494             :             }
     495             :         }
     496             :     }
     497           0 :     Outliner& rDrawOutl=pMod->GetDrawOutliner(pTextObj);
     498           0 :     Link aDrawOutlLink=rDrawOutl.GetCalcFieldValueHdl();
     499           0 :     if (!bOk && aDrawOutlLink.IsSet()) {
     500           0 :         aDrawOutlLink.Call(pFI);
     501           0 :         bOk = !rStr.isEmpty();
     502             :     }
     503           0 :     if (!bOk && aOldCalcFieldValueLink.IsSet()) {
     504           0 :         return aOldCalcFieldValueLink.Call(pFI);
     505             :     }
     506           0 :     return 0;
     507             : }
     508             : 
     509           0 : IMPL_LINK(SdrObjEditView, EndTextEditHdl, SdrUndoManager*, /*pUndoManager*/)
     510             : {
     511           0 :     SdrEndTextEdit();
     512           0 :     return 0;
     513             : }
     514             : 
     515           0 : SdrUndoManager* SdrObjEditView::getSdrUndoManagerForEnhancedTextEdit() const
     516             : {
     517             :     // default returns registered UndoManager
     518           0 :     return GetModel() ? dynamic_cast< SdrUndoManager* >(GetModel()->GetSdrUndoManager()) : 0;
     519             : }
     520             : 
     521           0 : bool SdrObjEditView::SdrBeginTextEdit(
     522             :     SdrObject* pObj, SdrPageView* pPV, vcl::Window* pWin,
     523             :     bool bIsNewObj, SdrOutliner* pGivenOutliner,
     524             :     OutlinerView* pGivenOutlinerView,
     525             :     bool bDontDeleteOutliner, bool bOnlyOneView,
     526             :     bool bGrabFocus)
     527             : {
     528           0 :     SdrEndTextEdit();
     529             : 
     530           0 :     if( dynamic_cast< SdrTextObj* >( pObj ) == 0 )
     531           0 :         return false; // currently only possible with text objects
     532             : 
     533           0 :     if(bGrabFocus && pWin)
     534             :     {
     535             :         // attention, this call may cause an EndTextEdit() call to this view
     536           0 :         pWin->GrabFocus(); // to force the cursor into the edit view
     537             :     }
     538             : 
     539           0 :     bTextEditDontDelete=bDontDeleteOutliner && pGivenOutliner!=NULL;
     540           0 :     bTextEditOnlyOneView=bOnlyOneView;
     541           0 :     bTextEditNewObj=bIsNewObj;
     542           0 :     const sal_uInt32 nWinAnz(PaintWindowCount());
     543             :     sal_uInt32 i;
     544           0 :     bool bBrk(false);
     545             :     // break, when no object given
     546             : 
     547           0 :     if(!pObj)
     548             :     {
     549           0 :         bBrk = true;
     550             :     }
     551             : 
     552           0 :     if(!bBrk && !pWin)
     553             :     {
     554           0 :         for(i = 0L; i < nWinAnz && !pWin; i++)
     555             :         {
     556           0 :             SdrPaintWindow* pPaintWindow = GetPaintWindow(i);
     557             : 
     558           0 :             if(OUTDEV_WINDOW == pPaintWindow->GetOutputDevice().GetOutDevType())
     559             :             {
     560           0 :                 pWin = static_cast<vcl::Window*>(&pPaintWindow->GetOutputDevice());
     561             :             }
     562             :         }
     563             : 
     564             :         // break, when no window exists
     565           0 :         if(!pWin)
     566             :         {
     567           0 :             bBrk = true;
     568             :         }
     569             :     }
     570             : 
     571           0 :     if(!bBrk && !pPV)
     572             :     {
     573           0 :         pPV = GetSdrPageView();
     574             : 
     575             :         // break, when no PageView for the object exists
     576           0 :         if(!pPV)
     577             :         {
     578           0 :             bBrk = true;
     579             :         }
     580             :     }
     581             : 
     582           0 :     if(pObj && pPV)
     583             :     {
     584             :         // no TextEdit on objects in locked Layer
     585           0 :         if(pPV->GetLockedLayers().IsSet(pObj->GetLayer()))
     586             :         {
     587           0 :             bBrk = true;
     588             :         }
     589             :     }
     590             : 
     591           0 :     if(pTextEditOutliner)
     592             :     {
     593             :         OSL_FAIL("SdrObjEditView::SdrBeginTextEdit(): Old Outliner still exists.");
     594           0 :         delete pTextEditOutliner;
     595           0 :         pTextEditOutliner = 0L;
     596             :     }
     597             : 
     598           0 :     if(!bBrk)
     599             :     {
     600           0 :         pTextEditWin=pWin;
     601           0 :         pTextEditPV=pPV;
     602           0 :         mxTextEditObj.reset( pObj );
     603           0 :         pTextEditOutliner=pGivenOutliner;
     604           0 :         if (pTextEditOutliner==NULL)
     605           0 :             pTextEditOutliner = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, *mxTextEditObj->GetModel() );
     606             : 
     607             :         {
     608           0 :             SvtAccessibilityOptions aOptions;
     609           0 :             pTextEditOutliner->ForceAutoColor( aOptions.GetIsAutomaticFontColor() );
     610             :         }
     611             : 
     612           0 :         bool bEmpty = mxTextEditObj->GetOutlinerParaObject()==NULL;
     613             : 
     614           0 :         aOldCalcFieldValueLink=pTextEditOutliner->GetCalcFieldValueHdl();
     615             :         // FieldHdl has to be set by SdrBeginTextEdit, because this call an UpdateFields
     616           0 :         pTextEditOutliner->SetCalcFieldValueHdl(LINK(this,SdrObjEditView,ImpOutlinerCalcFieldValueHdl));
     617           0 :         pTextEditOutliner->SetBeginPasteOrDropHdl(LINK(this,SdrObjEditView,BeginPasteOrDropHdl));
     618           0 :         pTextEditOutliner->SetEndPasteOrDropHdl(LINK(this,SdrObjEditView, EndPasteOrDropHdl));
     619             : 
     620             :         // It is just necessary to make the visualized page known. Set it.
     621           0 :         pTextEditOutliner->setVisualizedPage(pPV->GetPage());
     622             : 
     623           0 :         pTextEditOutliner->SetTextObjNoInit( dynamic_cast< SdrTextObj* >( mxTextEditObj.get() ) );
     624             : 
     625           0 :         if(mxTextEditObj->BegTextEdit(*pTextEditOutliner))
     626             :         {
     627           0 :             SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() );
     628             :             DBG_ASSERT( pTextObj, "svx::SdrObjEditView::BegTextEdit(), no text object?" );
     629           0 :             if( !pTextObj )
     630           0 :                 return false;
     631             : 
     632             :             // switch off any running TextAnimations
     633           0 :             pTextObj->SetTextAnimationAllowed(false);
     634             : 
     635             :             // remember old cursor
     636           0 :             if (pTextEditOutliner->GetViewCount()!=0)
     637             :             {
     638           0 :                 OutlinerView* pTmpOLV=pTextEditOutliner->RemoveView(static_cast<size_t>(0));
     639           0 :                 if(pTmpOLV!=NULL && pTmpOLV!=pGivenOutlinerView)
     640           0 :                     delete pTmpOLV;
     641             :             }
     642             : 
     643             :             // Determine EditArea via TakeTextEditArea.
     644             :             // TODO: This could theoretically be left out, because TakeTextRect() calculates the aTextEditArea,
     645             :             // but aMinTextEditArea has to happen, too (therefore leaving this in right now)
     646           0 :             pTextObj->TakeTextEditArea(NULL,NULL,&aTextEditArea,&aMinTextEditArea);
     647             : 
     648           0 :             Rectangle aTextRect;
     649           0 :             Rectangle aAnchorRect;
     650             :             pTextObj->TakeTextRect(*pTextEditOutliner, aTextRect, true,
     651           0 :                 &aAnchorRect /* Give true here, not false */);
     652             : 
     653           0 :             if ( !pTextObj->IsContourTextFrame() )
     654             :             {
     655             :                 // FitToSize not together with ContourFrame, for now
     656           0 :                 if (pTextObj->IsFitToSize())
     657           0 :                     aTextRect = aAnchorRect;
     658             :             }
     659             : 
     660           0 :             aTextEditArea = aTextRect;
     661             : 
     662             :             // Hack for calc, transform position of edit object according
     663             :             // to current zoom so as objects relative position to grid
     664             :             // appears stable
     665             : 
     666           0 :             Point aPvOfs(pTextObj->GetTextEditOffset());
     667           0 :             aTextEditArea += pTextObj->GetGridOffset();
     668           0 :             aTextEditArea.Move(aPvOfs.X(),aPvOfs.Y());
     669           0 :             aMinTextEditArea += pTextObj->GetGridOffset();
     670           0 :             aMinTextEditArea.Move(aPvOfs.X(),aPvOfs.Y());
     671           0 :             pTextEditCursorMerker=pWin->GetCursor();
     672             : 
     673           0 :             aHdl.SetMoveOutside(true);
     674             : 
     675             :             // #i72757#
     676             :             // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary
     677             :             // to call AdjustMarkHdl() always.
     678           0 :             AdjustMarkHdl();
     679             : 
     680           0 :             pTextEditOutlinerView=ImpMakeOutlinerView(pWin,!bEmpty,pGivenOutlinerView);
     681             : 
     682             :             // check if this view is already inserted
     683           0 :             sal_uIntPtr i2,nCount = pTextEditOutliner->GetViewCount();
     684           0 :             for( i2 = 0; i2 < nCount; i2++ )
     685             :             {
     686           0 :                 if( pTextEditOutliner->GetView(i2) == pTextEditOutlinerView )
     687           0 :                     break;
     688             :             }
     689             : 
     690           0 :             if( i2 == nCount )
     691           0 :                 pTextEditOutliner->InsertView(pTextEditOutlinerView,0);
     692             : 
     693           0 :             aHdl.SetMoveOutside(false);
     694           0 :             aHdl.SetMoveOutside(true);
     695             : 
     696             :             // register all windows as OutlinerViews with the Outliner
     697           0 :             if(!bOnlyOneView)
     698             :             {
     699           0 :                 for(i = 0L; i < nWinAnz; i++)
     700             :                 {
     701           0 :                     SdrPaintWindow* pPaintWindow = GetPaintWindow(i);
     702           0 :                     OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
     703             : 
     704           0 :                     if(&rOutDev != pWin && OUTDEV_WINDOW == rOutDev.GetOutDevType())
     705             :                     {
     706           0 :                         OutlinerView* pOutlView = ImpMakeOutlinerView(static_cast<vcl::Window*>(&rOutDev), !bEmpty, 0L);
     707           0 :                         pTextEditOutliner->InsertView(pOutlView, (sal_uInt16)i);
     708             :                     }
     709             :                 }
     710             :             }
     711             : 
     712           0 :             pTextEditOutlinerView->ShowCursor();
     713           0 :             pTextEditOutliner->SetStatusEventHdl(LINK(this,SdrObjEditView,ImpOutlinerStatusEventHdl));
     714             : #ifdef DBG_UTIL
     715             :             if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
     716             : #endif
     717           0 :             pTextEditOutliner->ClearModifyFlag();
     718             : 
     719           0 :             if (pTextObj->IsFitToSize())
     720             :             {
     721           0 :                 pWin->Invalidate(aTextEditArea);
     722             :             }
     723             : 
     724           0 :             if( GetModel() )
     725             :             {
     726           0 :                 SdrHint aHint(*pTextObj);
     727           0 :                 aHint.SetKind(HINT_BEGEDIT);
     728           0 :                 GetModel()->Broadcast(aHint);
     729             :             }
     730             : 
     731           0 :             pTextEditOutliner->setVisualizedPage(0);
     732             : 
     733           0 :             if( mxSelectionController.is() )
     734           0 :                 mxSelectionController->onSelectionHasChanged();
     735             : 
     736           0 :             if(IsUndoEnabled() && GetModel() && !GetModel()->GetDisableTextEditUsesCommonUndoManager())
     737             :             {
     738           0 :                 SdrUndoManager* pSdrUndoManager = getSdrUndoManagerForEnhancedTextEdit();
     739             : 
     740           0 :                 if(pSdrUndoManager)
     741             :                 {
     742             :                     // we have an outliner, undo manager and it's an EditUndoManager, exchange
     743             :                     // the document undo manager and the default one from the outliner and tell
     744             :                     // it that text edit starts by setting a callback if it needs to end text edit mode.
     745           0 :                     if(mpOldTextEditUndoManager)
     746             :                     {
     747             :                         // should not happen, delete it since it was probably forgotten somewhere
     748             :                         OSL_ENSURE(false, "Deleting forgotten old TextEditUndoManager, should be checked (!)");
     749           0 :                         delete mpOldTextEditUndoManager;
     750           0 :                         mpOldTextEditUndoManager = 0;
     751             :                     }
     752             : 
     753           0 :                     mpOldTextEditUndoManager = pTextEditOutliner->SetUndoManager(pSdrUndoManager);
     754           0 :                     pSdrUndoManager->SetEndTextEditHdl(LINK(this, SdrObjEditView, EndTextEditHdl));
     755             :                 }
     756             :                 else
     757             :                 {
     758             :                     OSL_ENSURE(false, "The document undo manager is not derived from SdrUndoManager (!)");
     759             :                 }
     760             :             }
     761             : 
     762           0 :             return true; // ran fine, let TextEdit run now
     763             :         }
     764             :         else
     765             :         {
     766           0 :             pTextEditOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink);
     767           0 :             pTextEditOutliner->SetBeginPasteOrDropHdl(Link());
     768           0 :             pTextEditOutliner->SetEndPasteOrDropHdl(Link());
     769             :         }
     770             :     }
     771           0 :     if (pTextEditOutliner != NULL)
     772             :     {
     773           0 :         pTextEditOutliner->setVisualizedPage(0);
     774             :     }
     775             : 
     776             :     // something went wrong...
     777           0 :     if(!bDontDeleteOutliner)
     778             :     {
     779           0 :         if(pGivenOutliner!=NULL)
     780             :         {
     781           0 :             delete pGivenOutliner;
     782           0 :             pTextEditOutliner = NULL;
     783             :         }
     784           0 :         if(pGivenOutlinerView!=NULL)
     785             :         {
     786           0 :             delete pGivenOutlinerView;
     787           0 :             pGivenOutlinerView = NULL;
     788             :         }
     789             :     }
     790           0 :     if( pTextEditOutliner!=NULL )
     791             :     {
     792           0 :         delete pTextEditOutliner;
     793             :     }
     794             : 
     795           0 :     pTextEditOutliner=NULL;
     796           0 :     pTextEditOutlinerView=NULL;
     797           0 :     mxTextEditObj.reset(0);
     798           0 :     pTextEditPV=NULL;
     799           0 :     pTextEditWin=NULL;
     800           0 :     aHdl.SetMoveOutside(false);
     801             : 
     802           0 :     return false;
     803             : }
     804             : 
     805        2898 : SdrEndTextEditKind SdrObjEditView::SdrEndTextEdit(bool bDontDeleteReally)
     806             : {
     807        2898 :     SdrEndTextEditKind eRet=SDRENDTEXTEDIT_UNCHANGED;
     808        2898 :     SdrTextObj* pTEObj = dynamic_cast< SdrTextObj* >( mxTextEditObj.get() );
     809        2898 :     vcl::Window*       pTEWin         =pTextEditWin;
     810        2898 :     SdrOutliner*  pTEOutliner    =pTextEditOutliner;
     811        2898 :     OutlinerView* pTEOutlinerView=pTextEditOutlinerView;
     812        2898 :     vcl::Cursor*  pTECursorMerker=pTextEditCursorMerker;
     813        2898 :     SdrUndoManager* pUndoEditUndoManager = 0;
     814        2898 :     bool bNeedToUndoSavedRedoTextEdit(false);
     815             : 
     816        2898 :     if(IsUndoEnabled() && GetModel() && pTEObj && pTEOutliner && !GetModel()->GetDisableTextEditUsesCommonUndoManager())
     817             :     {
     818             :         // change back the UndoManager to the remembered original one
     819           0 :         ::svl::IUndoManager* pOriginal = pTEOutliner->SetUndoManager(mpOldTextEditUndoManager);
     820           0 :         mpOldTextEditUndoManager = 0;
     821             : 
     822           0 :         if(pOriginal)
     823             :         {
     824             :             // check if we got back our document undo manager
     825           0 :             SdrUndoManager* pSdrUndoManager = getSdrUndoManagerForEnhancedTextEdit();
     826             : 
     827           0 :             if(pSdrUndoManager && dynamic_cast< SdrUndoManager* >(pOriginal) == pSdrUndoManager)
     828             :             {
     829           0 :                 if(pSdrUndoManager->isEndTextEditTriggeredFromUndo())
     830             :                 {
     831             :                     // remember the UndoManager where missing Undos have to be triggered after end
     832             :                     // text edit. When the undo had triggered the end text edit, the original action
     833             :                     // which had to be undone originally is not yet undone.
     834           0 :                     pUndoEditUndoManager = pSdrUndoManager;
     835             : 
     836             :                     // We are ending text edit; if text edit was triggered from undo, execute all redos
     837             :                     // to create a complete text change undo action for the redo buffer. Also mark this
     838             :                     // state when at least one redo was executed; the created extra TextChange needs to
     839             :                     // be undone in addition to the first real undo outside the text edit changes
     840           0 :                     while(pSdrUndoManager->GetRedoActionCount())
     841             :                     {
     842           0 :                         bNeedToUndoSavedRedoTextEdit = true;
     843           0 :                         pSdrUndoManager->Redo();
     844             :                     }
     845             :                 }
     846             : 
     847             :                 // reset the callback link and let the undo manager cleanup all text edit
     848             :                 // undo actions to get the stack back to the form before the text edit
     849           0 :                 pSdrUndoManager->SetEndTextEditHdl(Link());
     850             :             }
     851             :             else
     852             :             {
     853             :                 OSL_ENSURE(false, "Got UndoManager back in SdrEndTextEdit which is NOT the expected document UndoManager (!)");
     854           0 :                 delete pOriginal;
     855             :             }
     856             :         }
     857             :     }
     858             : 
     859        2898 :     if( GetModel() && mxTextEditObj.is() )
     860             :     {
     861           0 :         SdrHint aHint(*mxTextEditObj.get());
     862           0 :         aHint.SetKind(HINT_ENDEDIT);
     863           0 :         GetModel()->Broadcast(aHint);
     864             :     }
     865             : 
     866        2898 :     mxTextEditObj.reset(0);
     867        2898 :     pTextEditPV=NULL;
     868        2898 :     pTextEditWin=NULL;
     869        2898 :     pTextEditOutliner=NULL;
     870        2898 :     pTextEditOutlinerView=NULL;
     871        2898 :     pTextEditCursorMerker=NULL;
     872        2898 :     aTextEditArea=Rectangle();
     873             : 
     874        2898 :     if (pTEOutliner!=NULL)
     875             :     {
     876           0 :         bool bModified=pTEOutliner->IsModified();
     877           0 :         if (pTEOutlinerView!=NULL)
     878             :         {
     879           0 :             pTEOutlinerView->HideCursor();
     880             :         }
     881           0 :         if (pTEObj!=NULL)
     882             :         {
     883           0 :             pTEOutliner->CompleteOnlineSpelling();
     884             : 
     885           0 :             SdrUndoObjSetText* pTxtUndo = 0;
     886             : 
     887           0 :             if( bModified )
     888             :             {
     889             :                 sal_Int32 nText;
     890           0 :                 for( nText = 0; nText < pTEObj->getTextCount(); ++nText )
     891           0 :                     if( pTEObj->getText( nText ) == pTEObj->getActiveText() )
     892           0 :                         break;
     893             : 
     894           0 :                 pTxtUndo = dynamic_cast< SdrUndoObjSetText* >( GetModel()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTEObj, nText ) );
     895             :             }
     896             :             DBG_ASSERT( !bModified || pTxtUndo, "svx::SdrObjEditView::EndTextEdit(), could not create undo action!" );
     897             :             // Set old CalcFieldValue-Handler again, this
     898             :             // has to happen before Obj::EndTextEdit(), as this does UpdateFields().
     899           0 :             pTEOutliner->SetCalcFieldValueHdl(aOldCalcFieldValueLink);
     900           0 :             pTEOutliner->SetBeginPasteOrDropHdl(Link());
     901           0 :             pTEOutliner->SetEndPasteOrDropHdl(Link());
     902             : 
     903           0 :             const bool bUndo = IsUndoEnabled();
     904           0 :             if( bUndo )
     905             :             {
     906           0 :                 OUString aObjName(pTEObj->TakeObjNameSingul());
     907           0 :                 BegUndo(ImpGetResStr(STR_UndoObjSetText),aObjName);
     908             :             }
     909             : 
     910           0 :             pTEObj->EndTextEdit(*pTEOutliner);
     911             : 
     912           0 :             if( (pTEObj->GetRotateAngle() != 0) || (pTEObj && pTEObj->ISA(SdrTextObj) && ((SdrTextObj*)pTEObj)->IsFontwork())  )
     913             :             {
     914           0 :                 pTEObj->ActionChanged();
     915             :             }
     916             : 
     917           0 :             if (pTxtUndo!=NULL)
     918             :             {
     919           0 :                 pTxtUndo->AfterSetText();
     920           0 :                 if (!pTxtUndo->IsDifferent())
     921             :                 {
     922           0 :                     delete pTxtUndo;
     923           0 :                     pTxtUndo=NULL;
     924             :                 }
     925             :             }
     926             :             // check deletion of entire TextObj
     927           0 :             SdrUndoAction* pDelUndo=NULL;
     928           0 :             bool bDelObj=false;
     929           0 :             SdrTextObj* pTextObj=PTR_CAST(SdrTextObj,pTEObj);
     930           0 :             if (pTextObj!=NULL && bTextEditNewObj)
     931             :             {
     932           0 :                 bDelObj=pTextObj->IsTextFrame() &&
     933           0 :                         !pTextObj->HasText() &&
     934           0 :                         !pTextObj->IsEmptyPresObj() &&
     935           0 :                         !pTextObj->HasFill() &&
     936           0 :                         !pTextObj->HasLine();
     937             : 
     938           0 :                 if(pTEObj->IsInserted() && bDelObj && pTextObj->GetObjInventor()==SdrInventor && !bDontDeleteReally)
     939             :                 {
     940           0 :                     SdrObjKind eIdent=(SdrObjKind)pTextObj->GetObjIdentifier();
     941           0 :                     if(eIdent==OBJ_TEXT || eIdent==OBJ_TEXTEXT)
     942             :                     {
     943           0 :                         pDelUndo= GetModel()->GetSdrUndoFactory().CreateUndoDeleteObject(*pTEObj);
     944             :                     }
     945             :                 }
     946             :             }
     947           0 :             if (pTxtUndo!=NULL)
     948             :             {
     949           0 :                 if( bUndo )
     950           0 :                     AddUndo(pTxtUndo);
     951           0 :                 eRet=SDRENDTEXTEDIT_CHANGED;
     952             :             }
     953           0 :             if (pDelUndo!=NULL)
     954             :             {
     955           0 :                 if( bUndo )
     956             :                 {
     957           0 :                     AddUndo(pDelUndo);
     958             :                 }
     959             :                 else
     960             :                 {
     961           0 :                     delete pDelUndo;
     962             :                 }
     963           0 :                 eRet=SDRENDTEXTEDIT_DELETED;
     964             :                 DBG_ASSERT(pTEObj->GetObjList()!=NULL,"SdrObjEditView::SdrEndTextEdit(): Fatal: Object edited doesn't have an ObjList!");
     965           0 :                 if (pTEObj->GetObjList()!=NULL)
     966             :                 {
     967           0 :                     pTEObj->GetObjList()->RemoveObject(pTEObj->GetOrdNum());
     968           0 :                     CheckMarked(); // remove selection immediately...
     969             :                 }
     970             :             }
     971           0 :             else if (bDelObj)
     972             :             { // for Writer: the app has to do the deletion itself.
     973           0 :                 eRet=SDRENDTEXTEDIT_SHOULDBEDELETED;
     974             :             }
     975             : 
     976           0 :             if( bUndo )
     977           0 :                 EndUndo(); // EndUndo after Remove, in case UndoStack is deleted immediately
     978             : 
     979             :             // Switch on any TextAnimation again after TextEdit
     980           0 :             if(pTEObj->ISA(SdrTextObj))
     981             :             {
     982           0 :                 ((SdrTextObj*)pTEObj)->SetTextAnimationAllowed(true);
     983             :             }
     984             : 
     985             :             // #i72757#
     986             :             // Since IsMarkHdlWhenTextEdit() is ignored, it is necessary
     987             :             // to call AdjustMarkHdl() always.
     988           0 :             AdjustMarkHdl();
     989             :         }
     990             :         // delete all OutlinerViews
     991           0 :         for (sal_uIntPtr i=pTEOutliner->GetViewCount(); i>0;)
     992             :         {
     993           0 :             i--;
     994           0 :             OutlinerView* pOLV=pTEOutliner->GetView(i);
     995           0 :             sal_uInt16 nMorePix=pOLV->GetInvalidateMore() + 10;
     996           0 :             vcl::Window* pWin=pOLV->GetWindow();
     997           0 :             Rectangle aRect(pOLV->GetOutputArea());
     998           0 :             pTEOutliner->RemoveView(i);
     999           0 :             if (!bTextEditDontDelete || i!=0)
    1000             :             {
    1001             :                 // may not own the zeroth one
    1002           0 :                 delete pOLV;
    1003             :             }
    1004           0 :             aRect.Union(aTextEditArea);
    1005           0 :             aRect.Union(aMinTextEditArea);
    1006           0 :             aRect=pWin->LogicToPixel(aRect);
    1007           0 :             aRect.Left()-=nMorePix;
    1008           0 :             aRect.Top()-=nMorePix;
    1009           0 :             aRect.Right()+=nMorePix;
    1010           0 :             aRect.Bottom()+=nMorePix;
    1011           0 :             aRect=pWin->PixelToLogic(aRect);
    1012           0 :             InvalidateOneWin(*pWin,aRect);
    1013           0 :             pWin->SetFillColor();
    1014           0 :             pWin->SetLineColor(COL_BLACK);
    1015           0 :             pWin->DrawPixel(aRect.TopLeft());
    1016           0 :             pWin->DrawPixel(aRect.TopRight());
    1017           0 :             pWin->DrawPixel(aRect.BottomLeft());
    1018           0 :             pWin->DrawPixel(aRect.BottomRight());
    1019             :         }
    1020             :         // and now the Outliner itself
    1021           0 :         if (!bTextEditDontDelete) delete pTEOutliner;
    1022           0 :         else pTEOutliner->Clear();
    1023           0 :         if (pTEWin!=NULL) {
    1024           0 :             pTEWin->SetCursor(pTECursorMerker);
    1025             :         }
    1026           0 :         aHdl.SetMoveOutside(false);
    1027           0 :         if (eRet!=SDRENDTEXTEDIT_UNCHANGED)
    1028             :         {
    1029           0 :             GetMarkedObjectListWriteAccess().SetNameDirty();
    1030             :         }
    1031             : #ifdef DBG_UTIL
    1032             :         if (pItemBrowser)
    1033             :         {
    1034             :             GetMarkedObjectListWriteAccess().SetNameDirty();
    1035             :             pItemBrowser->SetDirty();
    1036             :         }
    1037             : #endif
    1038             :     }
    1039             : 
    1040        2898 :     if( pTEObj &&
    1041           0 :         pTEObj->GetModel() &&
    1042        2898 :         !pTEObj->GetModel()->isLocked() &&
    1043           0 :         pTEObj->GetBroadcaster())
    1044             :     {
    1045           0 :         SdrHint aHint(HINT_ENDEDIT);
    1046           0 :         aHint.SetObject(pTEObj);
    1047           0 :         ((SfxBroadcaster*)pTEObj->GetBroadcaster())->Broadcast(aHint);
    1048             :     }
    1049             : 
    1050        2898 :     if(pUndoEditUndoManager)
    1051             :     {
    1052           0 :         if(bNeedToUndoSavedRedoTextEdit)
    1053             :         {
    1054             :             // undo the text edit action since it was created as part of an EndTextEdit
    1055             :             // callback from undo itself. This needs to be done after the call to
    1056             :             // FmFormView::SdrEndTextEdit since it gets created there
    1057           0 :             pUndoEditUndoManager->Undo();
    1058             :         }
    1059             : 
    1060             :         // trigger the Undo which was not executed, but lead to this
    1061             :         // end text edit
    1062           0 :         pUndoEditUndoManager->Undo();
    1063             :     }
    1064             : 
    1065        2898 :     return eRet;
    1066             : }
    1067             : 
    1068             : 
    1069             : // info about TextEdit. Default is false.
    1070       59217 : bool SdrObjEditView::IsTextEdit() const
    1071             : {
    1072       59217 :     return mxTextEditObj.is();
    1073             : }
    1074             : 
    1075             : // info about TextEditPageView. Default is 0L.
    1076           0 : SdrPageView* SdrObjEditView::GetTextEditPageView() const
    1077             : {
    1078           0 :     return pTextEditPV;
    1079             : }
    1080             : 
    1081             : 
    1082             : 
    1083           0 : OutlinerView* SdrObjEditView::ImpFindOutlinerView(vcl::Window* pWin) const
    1084             : {
    1085           0 :     if (pWin==NULL) return NULL;
    1086           0 :     if (pTextEditOutliner==NULL) return NULL;
    1087           0 :     OutlinerView* pNewView=NULL;
    1088           0 :     sal_uIntPtr nWinAnz=pTextEditOutliner->GetViewCount();
    1089           0 :     for (sal_uIntPtr i=0; i<nWinAnz && pNewView==NULL; i++) {
    1090           0 :         OutlinerView* pView=pTextEditOutliner->GetView(i);
    1091           0 :         if (pView->GetWindow()==pWin) pNewView=pView;
    1092             :     }
    1093           0 :     return pNewView;
    1094             : }
    1095             : 
    1096           0 : void SdrObjEditView::SetTextEditWin(vcl::Window* pWin)
    1097             : {
    1098           0 :     if(mxTextEditObj.is() && pWin!=NULL && pWin!=pTextEditWin)
    1099             :     {
    1100           0 :         OutlinerView* pNewView=ImpFindOutlinerView(pWin);
    1101           0 :         if (pNewView!=NULL && pNewView!=pTextEditOutlinerView)
    1102             :         {
    1103           0 :             if (pTextEditOutlinerView!=NULL)
    1104             :             {
    1105           0 :                 pTextEditOutlinerView->HideCursor();
    1106             :             }
    1107           0 :             pTextEditOutlinerView=pNewView;
    1108           0 :             pTextEditWin=pWin;
    1109           0 :             pWin->GrabFocus(); // Make the cursor blink here as well
    1110           0 :             pNewView->ShowCursor();
    1111           0 :             ImpMakeTextCursorAreaVisible();
    1112             :         }
    1113             :     }
    1114           0 : }
    1115             : 
    1116         550 : bool SdrObjEditView::IsTextEditHit(const Point& rHit, short nTol) const
    1117             : {
    1118         550 :     bool bOk=false;
    1119         550 :     if(mxTextEditObj.is())
    1120             :     {
    1121           0 :         nTol=ImpGetHitTolLogic(nTol,NULL);
    1122             :         // only a third of the tolerance here, so handles can be hit well
    1123           0 :         nTol=nTol/3;
    1124           0 :         nTol=0; // no hit tolerance here any more
    1125             : 
    1126           0 :         Rectangle aEditArea;
    1127           0 :         OutlinerView* pOLV=pTextEditOutliner->GetView(0);
    1128           0 :         if (pOLV!=NULL)
    1129             :         {
    1130           0 :             aEditArea.Union(pOLV->GetOutputArea());
    1131             :         }
    1132           0 :         aEditArea.Left()-=nTol;
    1133           0 :         aEditArea.Top()-=nTol;
    1134           0 :         aEditArea.Right()+=nTol;
    1135           0 :         aEditArea.Bottom()+=nTol;
    1136           0 :         bOk=aEditArea.IsInside(rHit);
    1137           0 :         if (bOk)
    1138             :         { // check if any characters were actually hit
    1139           0 :             Point aPnt(rHit); aPnt-=aEditArea.TopLeft();
    1140           0 :             long nHitTol = 2000;
    1141           0 :             OutputDevice* pRef = pTextEditOutliner->GetRefDevice();
    1142           0 :             if( pRef )
    1143           0 :                 nHitTol = OutputDevice::LogicToLogic( nHitTol, MAP_100TH_MM, pRef->GetMapMode().GetMapUnit() );
    1144             : 
    1145           0 :             bOk = pTextEditOutliner->IsTextPos( aPnt, (sal_uInt16)nHitTol );
    1146             :         }
    1147             :     }
    1148         550 :     return bOk;
    1149             : }
    1150             : 
    1151        5308 : bool SdrObjEditView::IsTextEditFrameHit(const Point& rHit) const
    1152             : {
    1153        5308 :     bool bOk=false;
    1154        5308 :     if(mxTextEditObj.is())
    1155             :     {
    1156           0 :         SdrTextObj* pText= dynamic_cast<SdrTextObj*>(mxTextEditObj.get());
    1157           0 :         OutlinerView* pOLV=pTextEditOutliner->GetView(0);
    1158           0 :         if( pOLV )
    1159             :         {
    1160           0 :             vcl::Window* pWin=pOLV->GetWindow();
    1161           0 :             if (pText!=NULL && pText->IsTextFrame() && pOLV!=NULL && pWin!=NULL) {
    1162           0 :                 sal_uInt16 nPixSiz=pOLV->GetInvalidateMore();
    1163           0 :                 Rectangle aEditArea(aMinTextEditArea);
    1164           0 :                 aEditArea.Union(pOLV->GetOutputArea());
    1165           0 :                 if (!aEditArea.IsInside(rHit)) {
    1166           0 :                     Size aSiz(pWin->PixelToLogic(Size(nPixSiz,nPixSiz)));
    1167           0 :                     aEditArea.Left()-=aSiz.Width();
    1168           0 :                     aEditArea.Top()-=aSiz.Height();
    1169           0 :                     aEditArea.Right()+=aSiz.Width();
    1170           0 :                     aEditArea.Bottom()+=aSiz.Height();
    1171           0 :                     bOk=aEditArea.IsInside(rHit);
    1172             :                 }
    1173             :             }
    1174             :         }
    1175             :     }
    1176        5308 :     return bOk;
    1177             : }
    1178             : 
    1179             : 
    1180             : 
    1181           0 : bool SdrObjEditView::KeyInput(const KeyEvent& rKEvt, vcl::Window* pWin)
    1182             : {
    1183           0 :     if(pTextEditOutlinerView)
    1184             :     {
    1185           0 :         if (pTextEditOutlinerView->PostKeyEvent(rKEvt, pWin))
    1186             :         {
    1187           0 :             if( pMod )
    1188             :             {
    1189           0 :                 if( pTextEditOutliner && pTextEditOutliner->IsModified() )
    1190           0 :                     pMod->SetChanged( true );
    1191             :             }
    1192             : 
    1193           0 :             if (pWin!=NULL && pWin!=pTextEditWin) SetTextEditWin(pWin);
    1194             : #ifdef DBG_UTIL
    1195             :             if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
    1196             : #endif
    1197           0 :             ImpMakeTextCursorAreaVisible();
    1198           0 :             return true;
    1199             :         }
    1200             :     }
    1201           0 :     return SdrGlueEditView::KeyInput(rKEvt,pWin);
    1202             : }
    1203             : 
    1204           0 : bool SdrObjEditView::MouseButtonDown(const MouseEvent& rMEvt, vcl::Window* pWin)
    1205             : {
    1206           0 :     if (pTextEditOutlinerView!=NULL) {
    1207           0 :         bool bPostIt=pTextEditOutliner->IsInSelectionMode();
    1208           0 :         if (!bPostIt) {
    1209           0 :             Point aPt(rMEvt.GetPosPixel());
    1210           0 :             if (pWin!=NULL) aPt=pWin->PixelToLogic(aPt);
    1211           0 :             else if (pTextEditWin!=NULL) aPt=pTextEditWin->PixelToLogic(aPt);
    1212           0 :             bPostIt=IsTextEditHit(aPt,nHitTolLog);
    1213             :         }
    1214           0 :         if (bPostIt) {
    1215           0 :             Point aPixPos(rMEvt.GetPosPixel());
    1216           0 :             if (pWin)
    1217             :             {
    1218           0 :                 Rectangle aR(pWin->LogicToPixel(pTextEditOutlinerView->GetOutputArea()));
    1219           0 :                 if (aPixPos.X()<aR.Left  ()) aPixPos.X()=aR.Left  ();
    1220           0 :                 if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right ();
    1221           0 :                 if (aPixPos.Y()<aR.Top   ()) aPixPos.Y()=aR.Top   ();
    1222           0 :                 if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom();
    1223             :             }
    1224           0 :             MouseEvent aMEvt(aPixPos,rMEvt.GetClicks(),rMEvt.GetMode(),
    1225           0 :                              rMEvt.GetButtons(),rMEvt.GetModifier());
    1226           0 :             if (pTextEditOutlinerView->MouseButtonDown(aMEvt)) {
    1227           0 :                 if (pWin!=NULL && pWin!=pTextEditWin) SetTextEditWin(pWin);
    1228             : #ifdef DBG_UTIL
    1229             :                 if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
    1230             : #endif
    1231           0 :                 ImpMakeTextCursorAreaVisible();
    1232           0 :                 return true;
    1233             :             }
    1234             :         }
    1235             :     }
    1236           0 :     return SdrGlueEditView::MouseButtonDown(rMEvt,pWin);
    1237             : }
    1238             : 
    1239           0 : bool SdrObjEditView::MouseButtonUp(const MouseEvent& rMEvt, vcl::Window* pWin)
    1240             : {
    1241           0 :     if (pTextEditOutlinerView!=NULL) {
    1242           0 :         bool bPostIt=pTextEditOutliner->IsInSelectionMode();
    1243           0 :         if (!bPostIt) {
    1244           0 :             Point aPt(rMEvt.GetPosPixel());
    1245           0 :             if (pWin!=NULL) aPt=pWin->PixelToLogic(aPt);
    1246           0 :             else if (pTextEditWin!=NULL) aPt=pTextEditWin->PixelToLogic(aPt);
    1247           0 :             bPostIt=IsTextEditHit(aPt,nHitTolLog);
    1248             :         }
    1249           0 :         if (bPostIt) {
    1250           0 :             Point aPixPos(rMEvt.GetPosPixel());
    1251           0 :             Rectangle aR(pWin->LogicToPixel(pTextEditOutlinerView->GetOutputArea()));
    1252           0 :             if (aPixPos.X()<aR.Left  ()) aPixPos.X()=aR.Left  ();
    1253           0 :             if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right ();
    1254           0 :             if (aPixPos.Y()<aR.Top   ()) aPixPos.Y()=aR.Top   ();
    1255           0 :             if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom();
    1256           0 :             MouseEvent aMEvt(aPixPos,rMEvt.GetClicks(),rMEvt.GetMode(),
    1257           0 :                              rMEvt.GetButtons(),rMEvt.GetModifier());
    1258           0 :             if (pTextEditOutlinerView->MouseButtonUp(aMEvt)) {
    1259             : #ifdef DBG_UTIL
    1260             :                 if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
    1261             : #endif
    1262           0 :                 ImpMakeTextCursorAreaVisible();
    1263           0 :                 return true;
    1264             :             }
    1265             :         }
    1266             :     }
    1267           0 :     return SdrGlueEditView::MouseButtonUp(rMEvt,pWin);
    1268             : }
    1269             : 
    1270           0 : bool SdrObjEditView::MouseMove(const MouseEvent& rMEvt, vcl::Window* pWin)
    1271             : {
    1272           0 :     if (pTextEditOutlinerView!=NULL) {
    1273           0 :         bool bSelMode=pTextEditOutliner->IsInSelectionMode();
    1274           0 :         bool bPostIt=bSelMode;
    1275           0 :         if (!bPostIt) {
    1276           0 :             Point aPt(rMEvt.GetPosPixel());
    1277           0 :             if (pWin)
    1278           0 :                 aPt=pWin->PixelToLogic(aPt);
    1279           0 :             else if (pTextEditWin)
    1280           0 :                 aPt=pTextEditWin->PixelToLogic(aPt);
    1281           0 :             bPostIt=IsTextEditHit(aPt,nHitTolLog);
    1282             :         }
    1283           0 :         if (bPostIt) {
    1284           0 :             Point aPixPos(rMEvt.GetPosPixel());
    1285           0 :             Rectangle aR(pTextEditOutlinerView->GetOutputArea());
    1286           0 :             if (pWin)
    1287           0 :                 aR = pWin->LogicToPixel(aR);
    1288           0 :             else if (pTextEditWin)
    1289           0 :                 aR = pTextEditWin->LogicToPixel(aR);
    1290           0 :             if (aPixPos.X()<aR.Left  ()) aPixPos.X()=aR.Left  ();
    1291           0 :             if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right ();
    1292           0 :             if (aPixPos.Y()<aR.Top   ()) aPixPos.Y()=aR.Top   ();
    1293           0 :             if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom();
    1294           0 :             MouseEvent aMEvt(aPixPos,rMEvt.GetClicks(),rMEvt.GetMode(),
    1295           0 :                              rMEvt.GetButtons(),rMEvt.GetModifier());
    1296           0 :             if (pTextEditOutlinerView->MouseMove(aMEvt) && bSelMode) {
    1297             : #ifdef DBG_UTIL
    1298             :                 if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
    1299             : #endif
    1300           0 :                 ImpMakeTextCursorAreaVisible();
    1301           0 :                 return true;
    1302             :             }
    1303             :         }
    1304             :     }
    1305           0 :     return SdrGlueEditView::MouseMove(rMEvt,pWin);
    1306             : }
    1307             : 
    1308           0 : bool SdrObjEditView::Command(const CommandEvent& rCEvt, vcl::Window* pWin)
    1309             : {
    1310             :     // as long as OutlinerView returns a sal_Bool, it only gets COMMAND_STARTDRAG
    1311           0 :     if (pTextEditOutlinerView!=NULL)
    1312             :     {
    1313           0 :         if (rCEvt.GetCommand()==COMMAND_STARTDRAG) {
    1314           0 :             bool bPostIt=pTextEditOutliner->IsInSelectionMode() || !rCEvt.IsMouseEvent();
    1315           0 :             if (!bPostIt && rCEvt.IsMouseEvent()) {
    1316           0 :                 Point aPt(rCEvt.GetMousePosPixel());
    1317           0 :                 if (pWin!=NULL) aPt=pWin->PixelToLogic(aPt);
    1318           0 :                 else if (pTextEditWin!=NULL) aPt=pTextEditWin->PixelToLogic(aPt);
    1319           0 :                 bPostIt=IsTextEditHit(aPt,nHitTolLog);
    1320             :             }
    1321           0 :             if (bPostIt) {
    1322           0 :                 Point aPixPos(rCEvt.GetMousePosPixel());
    1323           0 :                 if (rCEvt.IsMouseEvent()) {
    1324           0 :                     Rectangle aR(pWin->LogicToPixel(pTextEditOutlinerView->GetOutputArea()));
    1325           0 :                     if (aPixPos.X()<aR.Left  ()) aPixPos.X()=aR.Left  ();
    1326           0 :                     if (aPixPos.X()>aR.Right ()) aPixPos.X()=aR.Right ();
    1327           0 :                     if (aPixPos.Y()<aR.Top   ()) aPixPos.Y()=aR.Top   ();
    1328           0 :                     if (aPixPos.Y()>aR.Bottom()) aPixPos.Y()=aR.Bottom();
    1329             :                 }
    1330           0 :                 CommandEvent aCEvt(aPixPos,rCEvt.GetCommand(),rCEvt.IsMouseEvent());
    1331             :                 // Command is void at the OutlinerView, sadly
    1332           0 :                 pTextEditOutlinerView->Command(aCEvt);
    1333           0 :                 if (pWin!=NULL && pWin!=pTextEditWin) SetTextEditWin(pWin);
    1334             : #ifdef DBG_UTIL
    1335             :                 if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
    1336             : #endif
    1337           0 :                 ImpMakeTextCursorAreaVisible();
    1338           0 :                 return true;
    1339             :             }
    1340             :         }
    1341             :         else
    1342             :         {
    1343           0 :             pTextEditOutlinerView->Command(rCEvt);
    1344           0 :             return true;
    1345             :         }
    1346             :     }
    1347           0 :     return SdrGlueEditView::Command(rCEvt,pWin);
    1348             : }
    1349             : 
    1350             : 
    1351             : 
    1352           0 : bool SdrObjEditView::ImpIsTextEditAllSelected() const
    1353             : {
    1354           0 :     bool bRet=false;
    1355           0 :     if (pTextEditOutliner!=NULL && pTextEditOutlinerView!=NULL)
    1356             :     {
    1357           0 :         if(SdrTextObj::HasTextImpl( pTextEditOutliner ) )
    1358             :         {
    1359           0 :             const sal_Int32 nParaAnz=pTextEditOutliner->GetParagraphCount();
    1360           0 :             Paragraph* pLastPara=pTextEditOutliner->GetParagraph( nParaAnz > 1 ? nParaAnz - 1 : 0 );
    1361             : 
    1362           0 :             ESelection aESel(pTextEditOutlinerView->GetSelection());
    1363           0 :             if (aESel.nStartPara==0 && aESel.nStartPos==0 && aESel.nEndPara==(nParaAnz-1))
    1364             :             {
    1365           0 :                 if( pTextEditOutliner->GetText(pLastPara).getLength() == aESel.nEndPos )
    1366           0 :                     bRet = true;
    1367             :             }
    1368             :             // in case the selection was done backwards
    1369           0 :             if (!bRet && aESel.nEndPara==0 && aESel.nEndPos==0 && aESel.nStartPara==(nParaAnz-1))
    1370             :             {
    1371           0 :                 if(pTextEditOutliner->GetText(pLastPara).getLength() == aESel.nStartPos)
    1372           0 :                     bRet = true;
    1373             :             }
    1374             :         }
    1375             :         else
    1376             :         {
    1377           0 :             bRet=true;
    1378             :         }
    1379             :     }
    1380           0 :     return bRet;
    1381             : }
    1382             : 
    1383           0 : void SdrObjEditView::ImpMakeTextCursorAreaVisible()
    1384             : {
    1385           0 :     if (pTextEditOutlinerView!=NULL && pTextEditWin!=NULL) {
    1386           0 :         vcl::Cursor* pCsr=pTextEditWin->GetCursor();
    1387           0 :         if (pCsr!=NULL) {
    1388           0 :             Size aSiz(pCsr->GetSize());
    1389           0 :             if (aSiz.Width()!=0 && aSiz.Height()!=0) {
    1390           0 :                 MakeVisible(Rectangle(pCsr->GetPos(),aSiz),*pTextEditWin);
    1391             :             }
    1392             :         }
    1393             :     }
    1394           0 : }
    1395             : 
    1396           0 : sal_uInt16 SdrObjEditView::GetScriptType() const
    1397             : {
    1398           0 :     sal_uInt16 nScriptType = 0;
    1399             : 
    1400           0 :     if( IsTextEdit() )
    1401             :     {
    1402           0 :         if( mxTextEditObj->GetOutlinerParaObject() )
    1403           0 :             nScriptType = mxTextEditObj->GetOutlinerParaObject()->GetTextObject().GetScriptType();
    1404             : 
    1405           0 :         if( pTextEditOutlinerView )
    1406           0 :             nScriptType = pTextEditOutlinerView->GetSelectedScriptType();
    1407             :     }
    1408             :     else
    1409             :     {
    1410           0 :         const size_t nMarkCount( GetMarkedObjectCount() );
    1411             : 
    1412           0 :         for( size_t i = 0; i < nMarkCount; ++i )
    1413             :         {
    1414           0 :             OutlinerParaObject* pParaObj = GetMarkedObjectByIndex( i )->GetOutlinerParaObject();
    1415             : 
    1416           0 :             if( pParaObj )
    1417             :             {
    1418           0 :                 nScriptType |= pParaObj->GetTextObject().GetScriptType();
    1419             :             }
    1420             :         }
    1421             :     }
    1422             : 
    1423           0 :     if( nScriptType == 0 )
    1424           0 :         nScriptType = SCRIPTTYPE_LATIN;
    1425             : 
    1426           0 :     return nScriptType;
    1427             : }
    1428             : 
    1429         592 : bool SdrObjEditView::GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const
    1430             : {
    1431         592 :     if( mxSelectionController.is() )
    1432           0 :         if( mxSelectionController->GetAttributes( rTargetSet, bOnlyHardAttr ) )
    1433           0 :             return true;
    1434             : 
    1435         592 :     if(IsTextEdit())
    1436             :     {
    1437             :         DBG_ASSERT(pTextEditOutlinerView!=NULL,"SdrObjEditView::GetAttributes(): pTextEditOutlinerView=NULL");
    1438             :         DBG_ASSERT(pTextEditOutliner!=NULL,"SdrObjEditView::GetAttributes(): pTextEditOutliner=NULL");
    1439             : 
    1440             :         // take care of bOnlyHardAttr(!)
    1441           0 :         if(!bOnlyHardAttr && mxTextEditObj->GetStyleSheet())
    1442           0 :             rTargetSet.Put(mxTextEditObj->GetStyleSheet()->GetItemSet());
    1443             : 
    1444             :         // add object attributes
    1445           0 :         rTargetSet.Put( mxTextEditObj->GetMergedItemSet() );
    1446             : 
    1447           0 :         if( mxTextEditObj->GetOutlinerParaObject() )
    1448           0 :             rTargetSet.Put( SvxScriptTypeItem( mxTextEditObj->GetOutlinerParaObject()->GetTextObject().GetScriptType() ) );
    1449             : 
    1450           0 :         if(pTextEditOutlinerView)
    1451             :         {
    1452             :             // FALSE= regard InvalidItems as "holes," not as Default
    1453           0 :             rTargetSet.Put(pTextEditOutlinerView->GetAttribs(), false);
    1454           0 :             rTargetSet.Put( SvxScriptTypeItem( pTextEditOutlinerView->GetSelectedScriptType() ) );
    1455             :         }
    1456             : 
    1457           0 :         if(GetMarkedObjectCount()==1 && GetMarkedObjectByIndex(0)==mxTextEditObj.get())
    1458             :         {
    1459           0 :             MergeNotPersistAttrFromMarked(rTargetSet, bOnlyHardAttr);
    1460             :         }
    1461             : 
    1462           0 :         return true;
    1463             :     }
    1464             :     else
    1465             :     {
    1466         592 :         return SdrGlueEditView::GetAttributes(rTargetSet, bOnlyHardAttr);
    1467             :     }
    1468             : }
    1469             : 
    1470           0 : bool SdrObjEditView::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll)
    1471             : {
    1472           0 :     bool bRet=false;
    1473           0 :     bool bTextEdit=pTextEditOutlinerView!=NULL && mxTextEditObj.is();
    1474           0 :     bool bAllTextSelected=ImpIsTextEditAllSelected();
    1475           0 :     const SfxItemSet* pSet=&rSet;
    1476             : 
    1477           0 :     if (!bTextEdit)
    1478             :     {
    1479             :         // no TextEdit activw -> all Items to drawing object
    1480           0 :         if( mxSelectionController.is() )
    1481           0 :             bRet=mxSelectionController->SetAttributes(*pSet,bReplaceAll );
    1482             : 
    1483           0 :         if( !bRet )
    1484             :         {
    1485           0 :             bRet=SdrGlueEditView::SetAttributes(*pSet,bReplaceAll);
    1486             :         }
    1487             :     }
    1488             :     else
    1489             :     {
    1490             : #ifdef DBG_UTIL
    1491             :         {
    1492             :             bool bHasEEFeatureItems=false;
    1493             :             SfxItemIter aIter(rSet);
    1494             :             const SfxPoolItem* pItem=aIter.FirstItem();
    1495             :             while (!bHasEEFeatureItems && pItem!=NULL)
    1496             :             {
    1497             :                 if (!IsInvalidItem(pItem))
    1498             :                 {
    1499             :                     sal_uInt16 nW=pItem->Which();
    1500             :                     if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END)
    1501             :                         bHasEEFeatureItems=true;
    1502             :                 }
    1503             : 
    1504             :                 pItem=aIter.NextItem();
    1505             :             }
    1506             : 
    1507             :             if(bHasEEFeatureItems)
    1508             :             {
    1509             :                 OUString aMessage("SdrObjEditView::SetAttributes(): Setting EE_FEATURE items at the SdrView does not make sense! It only leads to overhead and unreadable documents.");
    1510             :                 InfoBox(NULL, aMessage).Execute();
    1511             :             }
    1512             :         }
    1513             : #endif
    1514             : 
    1515             :         bool bOnlyEEItems;
    1516           0 :         bool bNoEEItems=!SearchOutlinerItems(*pSet,bReplaceAll,&bOnlyEEItems);
    1517             :         // everything selected? -> attributes to the border, too
    1518             :         // if no EEItems, attributes to the border only
    1519           0 :         if (bAllTextSelected || bNoEEItems)
    1520             :         {
    1521           0 :             if( mxSelectionController.is() )
    1522           0 :                 bRet=mxSelectionController->SetAttributes(*pSet,bReplaceAll );
    1523             : 
    1524           0 :             if( !bRet )
    1525             :             {
    1526           0 :                 const bool bUndo = IsUndoEnabled();
    1527             : 
    1528           0 :                 if( bUndo )
    1529             :                 {
    1530           0 :                     OUString aStr;
    1531           0 :                     ImpTakeDescriptionStr(STR_EditSetAttributes,aStr);
    1532           0 :                     BegUndo(aStr);
    1533           0 :                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*mxTextEditObj.get()));
    1534             : 
    1535             :                     // #i43537#
    1536             :                     // If this is a text object also rescue the OutlinerParaObject since
    1537             :                     // applying attributes to the object may change text layout when
    1538             :                     // multiple portions exist with multiple formats. If a OutlinerParaObject
    1539             :                     // really exists and needs to be rescued is evaluated in the undo
    1540             :                     // implementation itself.
    1541           0 :                     bool bRescueText = dynamic_cast< SdrTextObj* >(mxTextEditObj.get());
    1542             : 
    1543           0 :                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*mxTextEditObj.get(),false,!bNoEEItems || bRescueText));
    1544           0 :                     EndUndo();
    1545             :                 }
    1546             : 
    1547           0 :                 mxTextEditObj->SetMergedItemSetAndBroadcast(*pSet, bReplaceAll);
    1548             : 
    1549           0 :                 FlushComeBackTimer(); // to set ModeHasChanged immediately
    1550           0 :                 bRet=true;
    1551           0 :             }
    1552             :         }
    1553           0 :         else if (!bOnlyEEItems)
    1554             :         {
    1555             :             // Otherwise split Set, if necessary.
    1556             :             // Now we build an ItemSet aSet that doesn't contain EE_Items from
    1557             :             // *pSet (otherwise it would be a copy).
    1558           0 :             sal_uInt16* pNewWhichTable=RemoveWhichRange(pSet->GetRanges(),EE_ITEMS_START,EE_ITEMS_END);
    1559           0 :             SfxItemSet aSet(pMod->GetItemPool(),pNewWhichTable);
    1560           0 :             delete[] pNewWhichTable;
    1561           0 :             SfxWhichIter aIter(aSet);
    1562           0 :             sal_uInt16 nWhich=aIter.FirstWhich();
    1563           0 :             while (nWhich!=0)
    1564             :             {
    1565             :                 const SfxPoolItem* pItem;
    1566           0 :                 SfxItemState eState=pSet->GetItemState(nWhich,false,&pItem);
    1567           0 :                 if (eState==SfxItemState::SET) aSet.Put(*pItem);
    1568           0 :                 nWhich=aIter.NextWhich();
    1569             :             }
    1570             : 
    1571             : 
    1572           0 :             if( mxSelectionController.is() )
    1573           0 :                 bRet=mxSelectionController->SetAttributes(aSet,bReplaceAll );
    1574             : 
    1575           0 :             if( !bRet )
    1576             :             {
    1577           0 :                 if( IsUndoEnabled() )
    1578             :                 {
    1579           0 :                     OUString aStr;
    1580           0 :                     ImpTakeDescriptionStr(STR_EditSetAttributes,aStr);
    1581           0 :                     BegUndo(aStr);
    1582           0 :                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*mxTextEditObj.get()));
    1583           0 :                     AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*mxTextEditObj.get(),false,false));
    1584           0 :                     EndUndo();
    1585             :                 }
    1586             : 
    1587           0 :                 mxTextEditObj->SetMergedItemSetAndBroadcast(aSet, bReplaceAll);
    1588             : 
    1589           0 :                 if (GetMarkedObjectCount()==1 && GetMarkedObjectByIndex(0)==mxTextEditObj.get())
    1590             :                 {
    1591           0 :                     SetNotPersistAttrToMarked(aSet,bReplaceAll);
    1592             :                 }
    1593             :             }
    1594           0 :             FlushComeBackTimer();
    1595           0 :             bRet=true;
    1596             :         }
    1597           0 :         if(!bNoEEItems)
    1598             :         {
    1599             :             // and now the attributes to the EditEngine
    1600           0 :             if (bReplaceAll) {
    1601           0 :                 pTextEditOutlinerView->RemoveAttribs( true );
    1602             :             }
    1603           0 :             pTextEditOutlinerView->SetAttribs(rSet);
    1604             : 
    1605             : #ifdef DBG_UTIL
    1606             :             if (pItemBrowser!=NULL)
    1607             :                 pItemBrowser->SetDirty();
    1608             : #endif
    1609             : 
    1610           0 :             ImpMakeTextCursorAreaVisible();
    1611             :         }
    1612           0 :         bRet=true;
    1613             :     }
    1614           0 :     return bRet;
    1615             : }
    1616             : 
    1617           0 : SfxStyleSheet* SdrObjEditView::GetStyleSheet() const
    1618             : {
    1619           0 :     SfxStyleSheet* pSheet = 0;
    1620             : 
    1621           0 :     if( mxSelectionController.is() )
    1622             :     {
    1623           0 :         if( mxSelectionController->GetStyleSheet( pSheet ) )
    1624           0 :             return pSheet;
    1625             :     }
    1626             : 
    1627           0 :     if ( pTextEditOutlinerView )
    1628             :     {
    1629           0 :         pSheet = pTextEditOutlinerView->GetStyleSheet();
    1630             :     }
    1631             :     else
    1632             :     {
    1633           0 :         pSheet = SdrGlueEditView::GetStyleSheet();
    1634             :     }
    1635           0 :     return pSheet;
    1636             : }
    1637             : 
    1638           0 : bool SdrObjEditView::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
    1639             : {
    1640           0 :     if( mxSelectionController.is() )
    1641             :     {
    1642           0 :         if( mxSelectionController->SetStyleSheet( pStyleSheet, bDontRemoveHardAttr ) )
    1643           0 :             return true;
    1644             :     }
    1645             : 
    1646             :     // if we are currently in edit mode we must also set the stylesheet
    1647             :     // on all paragraphs in the Outliner for the edit view
    1648           0 :     if( NULL != pTextEditOutlinerView )
    1649             :     {
    1650           0 :         Outliner* pOutliner = pTextEditOutlinerView->GetOutliner();
    1651             : 
    1652           0 :         const sal_Int32 nParaCount = pOutliner->GetParagraphCount();
    1653           0 :         for( sal_Int32 nPara = 0; nPara < nParaCount; nPara++ )
    1654             :         {
    1655           0 :             pOutliner->SetStyleSheet( nPara, pStyleSheet );
    1656             :         }
    1657             :     }
    1658             : 
    1659           0 :     return SdrGlueEditView::SetStyleSheet(pStyleSheet,bDontRemoveHardAttr);
    1660             : }
    1661             : 
    1662             : 
    1663             : 
    1664           6 : void SdrObjEditView::AddWindowToPaintView(OutputDevice* pNewWin)
    1665             : {
    1666           6 :     SdrGlueEditView::AddWindowToPaintView(pNewWin);
    1667             : 
    1668           6 :     if(mxTextEditObj.is() && !bTextEditOnlyOneView && pNewWin->GetOutDevType()==OUTDEV_WINDOW)
    1669             :     {
    1670           0 :         OutlinerView* pOutlView=ImpMakeOutlinerView(static_cast<vcl::Window*>(pNewWin),false,NULL);
    1671           0 :         pTextEditOutliner->InsertView(pOutlView);
    1672             :     }
    1673           6 : }
    1674             : 
    1675        1120 : void SdrObjEditView::DeleteWindowFromPaintView(OutputDevice* pOldWin)
    1676             : {
    1677        1120 :     SdrGlueEditView::DeleteWindowFromPaintView(pOldWin);
    1678             : 
    1679        1120 :     if(mxTextEditObj.is() && !bTextEditOnlyOneView && pOldWin->GetOutDevType()==OUTDEV_WINDOW)
    1680             :     {
    1681           0 :         for (sal_uIntPtr i=pTextEditOutliner->GetViewCount(); i>0;) {
    1682           0 :             i--;
    1683           0 :             OutlinerView* pOLV=pTextEditOutliner->GetView(i);
    1684           0 :             if (pOLV && pOLV->GetWindow()==static_cast<vcl::Window*>(pOldWin)) {
    1685           0 :                 delete pTextEditOutliner->RemoveView(i);
    1686             :             }
    1687             :         }
    1688             :     }
    1689        1120 : }
    1690             : 
    1691         550 : bool SdrObjEditView::IsTextEditInSelectionMode() const
    1692             : {
    1693         550 :     return pTextEditOutliner!=NULL && pTextEditOutliner->IsInSelectionMode();
    1694             : }
    1695             : 
    1696             : 
    1697             : // MacroMode
    1698             : 
    1699             : 
    1700           0 : bool SdrObjEditView::BegMacroObj(const Point& rPnt, short nTol, SdrObject* pObj, SdrPageView* pPV, vcl::Window* pWin)
    1701             : {
    1702           0 :     BrkMacroObj();
    1703           0 :     if (pObj!=NULL && pPV!=NULL && pWin!=NULL && pObj->HasMacro()) {
    1704           0 :         nTol=ImpGetHitTolLogic(nTol,NULL);
    1705           0 :         pMacroObj=pObj;
    1706           0 :         pMacroPV=pPV;
    1707           0 :         pMacroWin=pWin;
    1708           0 :         bMacroDown=false;
    1709           0 :         nMacroTol=sal_uInt16(nTol);
    1710           0 :         aMacroDownPos=rPnt;
    1711           0 :         MovMacroObj(rPnt);
    1712             :     }
    1713           0 :     return false;
    1714             : }
    1715             : 
    1716           0 : void SdrObjEditView::ImpMacroUp(const Point& rUpPos)
    1717             : {
    1718           0 :     if (pMacroObj!=NULL && bMacroDown)
    1719             :     {
    1720           0 :         SdrObjMacroHitRec aHitRec;
    1721           0 :         aHitRec.aPos=rUpPos;
    1722           0 :         aHitRec.aDownPos=aMacroDownPos;
    1723           0 :         aHitRec.nTol=nMacroTol;
    1724           0 :         aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers();
    1725           0 :         aHitRec.pPageView=pMacroPV;
    1726           0 :         aHitRec.pOut=pMacroWin;
    1727           0 :         pMacroObj->PaintMacro(*pMacroWin,Rectangle(),aHitRec);
    1728           0 :         bMacroDown=false;
    1729             :     }
    1730           0 : }
    1731             : 
    1732           0 : void SdrObjEditView::ImpMacroDown(const Point& rDownPos)
    1733             : {
    1734           0 :     if (pMacroObj!=NULL && !bMacroDown)
    1735             :     {
    1736           0 :         SdrObjMacroHitRec aHitRec;
    1737           0 :         aHitRec.aPos=rDownPos;
    1738           0 :         aHitRec.aDownPos=aMacroDownPos;
    1739           0 :         aHitRec.nTol=nMacroTol;
    1740           0 :         aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers();
    1741           0 :         aHitRec.pPageView=pMacroPV;
    1742           0 :         aHitRec.bDown=true;
    1743           0 :         aHitRec.pOut=pMacroWin;
    1744           0 :         pMacroObj->PaintMacro(*pMacroWin,Rectangle(),aHitRec);
    1745           0 :         bMacroDown=true;
    1746             :     }
    1747           0 : }
    1748             : 
    1749           0 : void SdrObjEditView::MovMacroObj(const Point& rPnt)
    1750             : {
    1751           0 :     if (pMacroObj!=NULL) {
    1752           0 :         SdrObjMacroHitRec aHitRec;
    1753           0 :         aHitRec.aPos=rPnt;
    1754           0 :         aHitRec.aDownPos=aMacroDownPos;
    1755           0 :         aHitRec.nTol=nMacroTol;
    1756           0 :         aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers();
    1757           0 :         aHitRec.pPageView=pMacroPV;
    1758           0 :         aHitRec.bDown=bMacroDown;
    1759           0 :         aHitRec.pOut=pMacroWin;
    1760           0 :         bool bDown=pMacroObj->IsMacroHit(aHitRec);
    1761           0 :         if (bDown) ImpMacroDown(rPnt);
    1762           0 :         else ImpMacroUp(rPnt);
    1763             :     }
    1764           0 : }
    1765             : 
    1766        8919 : void SdrObjEditView::BrkMacroObj()
    1767             : {
    1768        8919 :     if (pMacroObj!=NULL) {
    1769           0 :         ImpMacroUp(aMacroDownPos);
    1770           0 :         pMacroObj=NULL;
    1771           0 :         pMacroPV=NULL;
    1772           0 :         pMacroWin=NULL;
    1773             :     }
    1774        8919 : }
    1775             : 
    1776           0 : bool SdrObjEditView::EndMacroObj()
    1777             : {
    1778           0 :     if (pMacroObj!=NULL && bMacroDown) {
    1779           0 :         ImpMacroUp(aMacroDownPos);
    1780           0 :         SdrObjMacroHitRec aHitRec;
    1781           0 :         aHitRec.aPos=aMacroDownPos;
    1782           0 :         aHitRec.aDownPos=aMacroDownPos;
    1783           0 :         aHitRec.nTol=nMacroTol;
    1784           0 :         aHitRec.pVisiLayer=&pMacroPV->GetVisibleLayers();
    1785           0 :         aHitRec.pPageView=pMacroPV;
    1786           0 :         aHitRec.bDown=true;
    1787           0 :         aHitRec.pOut=pMacroWin;
    1788           0 :         bool bRet=pMacroObj->DoMacro(aHitRec);
    1789           0 :         pMacroObj=NULL;
    1790           0 :         pMacroPV=NULL;
    1791           0 :         pMacroWin=NULL;
    1792           0 :         return bRet;
    1793             :     } else {
    1794           0 :         BrkMacroObj();
    1795           0 :         return false;
    1796             :     }
    1797             : }
    1798             : 
    1799             : /** fills the given any with a XTextCursor for the current text selection.
    1800             :     Leaves the any untouched if there currently is no text selected */
    1801           0 : void SdrObjEditView::getTextSelection( ::com::sun::star::uno::Any& rSelection )
    1802             : {
    1803           0 :     if( IsTextEdit() )
    1804             :     {
    1805           0 :         OutlinerView* pOutlinerView = GetTextEditOutlinerView();
    1806           0 :         if( pOutlinerView && pOutlinerView->HasSelection() )
    1807             :         {
    1808           0 :             SdrObject* pObj = GetTextEditObject();
    1809             : 
    1810           0 :             if( pObj )
    1811             :             {
    1812           0 :                 ::com::sun::star::uno::Reference< ::com::sun::star::text::XText > xText( pObj->getUnoShape(), ::com::sun::star::uno::UNO_QUERY );
    1813           0 :                 if( xText.is() )
    1814             :                 {
    1815           0 :                     SvxUnoTextBase* pRange = SvxUnoTextBase::getImplementation( xText );
    1816           0 :                     if( pRange )
    1817             :                     {
    1818           0 :                         rSelection <<= pRange->createTextCursorBySelection( pOutlinerView->GetSelection() );
    1819             :                     }
    1820           0 :                 }
    1821             :             }
    1822             :         }
    1823             :     }
    1824           0 : }
    1825             : 
    1826             : /* check if we have a single selection and that single object likes
    1827             :     to handle the mouse and keyboard events itself
    1828             : 
    1829             :     TODO: the selection controller should be queried from the
    1830             :     object specific view contact. Currently this method only
    1831             :     works for tables.
    1832             : */
    1833        8078 : void SdrObjEditView::MarkListHasChanged()
    1834             : {
    1835        8078 :     SdrGlueEditView::MarkListHasChanged();
    1836             : 
    1837        8078 :     if( mxSelectionController.is() )
    1838             :     {
    1839           0 :         mxLastSelectionController = mxSelectionController;
    1840           0 :         mxSelectionController->onSelectionHasChanged();
    1841             :     }
    1842             : 
    1843        8078 :     mxSelectionController.clear();
    1844             : 
    1845        8078 :     const SdrMarkList& rMarkList=GetMarkedObjectList();
    1846        8078 :     if( rMarkList.GetMarkCount() == 1 )
    1847             :     {
    1848         700 :         const SdrObject* pObj= rMarkList.GetMark(0)->GetMarkedSdrObj();
    1849             :         // check for table
    1850         700 :         if( pObj && (pObj->GetObjInventor() == SdrInventor ) && (pObj->GetObjIdentifier() == OBJ_TABLE) )
    1851             :         {
    1852           0 :             mxSelectionController = sdr::table::CreateTableController( this, pObj, mxLastSelectionController );
    1853           0 :             if( mxSelectionController.is() )
    1854             :             {
    1855           0 :                 mxLastSelectionController.clear();
    1856           0 :                 mxSelectionController->onSelectionHasChanged();
    1857             :             }
    1858             :         }
    1859             :     }
    1860        8078 : }
    1861             : 
    1862           0 : IMPL_LINK( SdrObjEditView, EndPasteOrDropHdl, PasteOrDropInfos*, pInfos )
    1863             : {
    1864           0 :     OnEndPasteOrDrop( pInfos );
    1865           0 :     return 0;
    1866             : }
    1867             : 
    1868           0 : IMPL_LINK( SdrObjEditView, BeginPasteOrDropHdl, PasteOrDropInfos*, pInfos )
    1869             : {
    1870           0 :     OnBeginPasteOrDrop( pInfos );
    1871           0 :     return 0;
    1872             : }
    1873             : 
    1874           0 : void SdrObjEditView::OnBeginPasteOrDrop( PasteOrDropInfos* )
    1875             : {
    1876             :     // applications can derive from these virtual methods to do something before a drop or paste operation
    1877           0 : }
    1878             : 
    1879           0 : void SdrObjEditView::OnEndPasteOrDrop( PasteOrDropInfos* )
    1880             : {
    1881             :     // applications can derive from these virtual methods to do something before a drop or paste operation
    1882           0 : }
    1883             : 
    1884           0 : sal_uInt16 SdrObjEditView::GetSelectionLevel() const
    1885             : {
    1886           0 :     sal_uInt16 nLevel = 0xFFFF;
    1887           0 :     if( IsTextEdit() )
    1888             :     {
    1889             :         DBG_ASSERT(pTextEditOutlinerView!=NULL,"SdrObjEditView::GetAttributes(): pTextEditOutlinerView=NULL");
    1890             :         DBG_ASSERT(pTextEditOutliner!=NULL,"SdrObjEditView::GetAttributes(): pTextEditOutliner=NULL");
    1891           0 :         if( pTextEditOutlinerView )
    1892             :         {
    1893             :             //start and end position
    1894           0 :             ESelection aSelect = pTextEditOutlinerView->GetSelection();
    1895           0 :             sal_uInt16 nStartPara = ::std::min( aSelect.nStartPara, aSelect.nEndPara );
    1896           0 :             sal_uInt16 nEndPara = ::std::max( aSelect.nStartPara, aSelect.nEndPara );
    1897             :             //get level from each paragraph
    1898           0 :             nLevel = 0;
    1899           0 :             for( sal_uInt16 nPara = nStartPara; nPara <= nEndPara; nPara++ )
    1900             :             {
    1901           0 :                 sal_uInt16 nParaDepth = 1 << pTextEditOutliner->GetDepth( nPara );
    1902           0 :                 if( !(nLevel & nParaDepth) )
    1903           0 :                     nLevel += nParaDepth;
    1904             :             }
    1905             :             //reduce one level for Outliner Object
    1906             :             //if( nLevel > 0 && GetTextEditObject()->GetObjIdentifier() == OBJ_OUTLINETEXT )
    1907             :             //  nLevel = nLevel >> 1;
    1908             :             //no bullet paragraph selected
    1909           0 :             if( nLevel == 0)
    1910           0 :                 nLevel = 0xFFFF;
    1911             :         }
    1912             :     }
    1913           0 :     return nLevel;
    1914             : }
    1915             : 
    1916           2 : bool SdrObjEditView::SupportsFormatPaintbrush( sal_uInt32 nObjectInventor, sal_uInt16 nObjectIdentifier ) const
    1917             : {
    1918           2 :     if( nObjectInventor != SdrInventor && nObjectInventor != E3dInventor )
    1919           0 :         return false;
    1920           2 :     switch(nObjectIdentifier)
    1921             :     {
    1922             :         case OBJ_NONE:
    1923             :         case OBJ_GRUP:
    1924           0 :             return false;
    1925             :         case OBJ_LINE:
    1926             :         case OBJ_RECT:
    1927             :         case OBJ_CIRC:
    1928             :         case OBJ_SECT:
    1929             :         case OBJ_CARC:
    1930             :         case OBJ_CCUT:
    1931             :         case OBJ_POLY:
    1932             :         case OBJ_PLIN:
    1933             :         case OBJ_PATHLINE:
    1934             :         case OBJ_PATHFILL:
    1935             :         case OBJ_FREELINE:
    1936             :         case OBJ_FREEFILL:
    1937             :         case OBJ_SPLNLINE:
    1938             :         case OBJ_SPLNFILL:
    1939             :         case OBJ_TEXT:
    1940             :         case OBJ_TEXTEXT:
    1941             :         case OBJ_TITLETEXT:
    1942             :         case OBJ_OUTLINETEXT:
    1943             :         case OBJ_GRAF:
    1944             :         case OBJ_OLE2:
    1945             :         case OBJ_TABLE:
    1946           2 :             return true;
    1947             :         case OBJ_EDGE:
    1948             :         case OBJ_CAPTION:
    1949           0 :             return false;
    1950             :         case OBJ_PATHPOLY:
    1951             :         case OBJ_PATHPLIN:
    1952           0 :             return true;
    1953             :         case OBJ_PAGE:
    1954             :         case OBJ_MEASURE:
    1955             :         case OBJ_DUMMY:
    1956             :         case OBJ_FRAME:
    1957             :         case OBJ_UNO:
    1958           0 :             return false;
    1959             :         case OBJ_CUSTOMSHAPE:
    1960           0 :             return true;
    1961             :         default:
    1962           0 :             return false;
    1963             :     }
    1964             : }
    1965             : 
    1966           0 : static const sal_uInt16* GetFormatRangeImpl( bool bTextOnly )
    1967             : {
    1968             :     static const sal_uInt16 gRanges[] = {
    1969             :         SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST,
    1970             :         SDRATTR_GRAF_FIRST, SDRATTR_GRAF_LAST,
    1971             :         SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,
    1972             :         XATTR_LINE_FIRST, XATTR_LINE_LAST,
    1973             :         XATTR_FILL_FIRST, XATTRSET_FILL,
    1974             :         EE_PARA_START, EE_PARA_END,
    1975             :         EE_CHAR_START, EE_CHAR_END,
    1976             :         0,0
    1977             :     };
    1978           0 :     return &gRanges[ bTextOnly ? 10 : 0];
    1979             : }
    1980             : 
    1981           0 : bool SdrObjEditView::TakeFormatPaintBrush( boost::shared_ptr< SfxItemSet >& rFormatSet  )
    1982             : {
    1983           0 :     if( mxSelectionController.is() && mxSelectionController->TakeFormatPaintBrush(rFormatSet) )
    1984           0 :         return true;
    1985             : 
    1986           0 :     const SdrMarkList& rMarkList = GetMarkedObjectList();
    1987           0 :     if( rMarkList.GetMarkCount() > 0 )
    1988             :     {
    1989           0 :         OutlinerView* pOLV = GetTextEditOutlinerView();
    1990             : 
    1991           0 :         rFormatSet.reset( new SfxItemSet( GetModel()->GetItemPool(), GetFormatRangeImpl( pOLV != NULL ) ) );
    1992           0 :         if( pOLV )
    1993             :         {
    1994           0 :             rFormatSet->Put( pOLV->GetAttribs() );
    1995             :         }
    1996             :         else
    1997             :         {
    1998           0 :             const bool bOnlyHardAttr = false;
    1999           0 :             rFormatSet->Put( GetAttrFromMarked(bOnlyHardAttr) );
    2000             :         }
    2001           0 :         return true;
    2002             :     }
    2003             : 
    2004           0 :     return false;
    2005             : }
    2006             : 
    2007           0 : static SfxItemSet CreatePaintSet( const sal_uInt16 *pRanges, SfxItemPool& rPool, const SfxItemSet& rSourceSet, const SfxItemSet& rTargetSet, bool bNoCharacterFormats, bool bNoParagraphFormats )
    2008             : {
    2009           0 :     SfxItemSet aPaintSet( rPool, pRanges );
    2010             : 
    2011           0 :     while( *pRanges )
    2012             :     {
    2013           0 :         sal_uInt16 nWhich = *pRanges++;
    2014           0 :         const sal_uInt16 nLastWhich = *pRanges++;
    2015             : 
    2016           0 :         if( bNoCharacterFormats && (nWhich == EE_CHAR_START) )
    2017           0 :             continue;
    2018             : 
    2019           0 :         if( bNoParagraphFormats && (nWhich == EE_PARA_START ) )
    2020           0 :             continue;
    2021             : 
    2022           0 :         for( ; nWhich < nLastWhich; nWhich++ )
    2023             :         {
    2024           0 :             const SfxPoolItem* pSourceItem = rSourceSet.GetItem( nWhich );
    2025           0 :             const SfxPoolItem* pTargetItem = rTargetSet.GetItem( nWhich );
    2026             : 
    2027           0 :             if( (pSourceItem && !pTargetItem) || (pSourceItem && pTargetItem && !((*pSourceItem) == (*pTargetItem)) ) )
    2028             :             {
    2029           0 :                 aPaintSet.Put( *pSourceItem );
    2030             :             }
    2031             :         }
    2032             :     }
    2033           0 :     return aPaintSet;
    2034             : }
    2035             : 
    2036           0 : void SdrObjEditView::ApplyFormatPaintBrushToText( SfxItemSet& rFormatSet, SdrTextObj& rTextObj, SdrText* pText, bool bNoCharacterFormats, bool bNoParagraphFormats )
    2037             : {
    2038           0 :     OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : 0;
    2039           0 :     if(pParaObj)
    2040             :     {
    2041           0 :         SdrOutliner& rOutliner = rTextObj.ImpGetDrawOutliner();
    2042           0 :         rOutliner.SetText(*pParaObj);
    2043             : 
    2044           0 :         sal_Int32 nParaCount(rOutliner.GetParagraphCount());
    2045             : 
    2046           0 :         if(nParaCount)
    2047             :         {
    2048           0 :             for(sal_Int32 nPara = 0; nPara < nParaCount; nPara++)
    2049             :             {
    2050           0 :                 if( !bNoCharacterFormats )
    2051           0 :                     rOutliner.RemoveCharAttribs( nPara, /* remove all */0 );
    2052             : 
    2053           0 :                 SfxItemSet aSet(rOutliner.GetParaAttribs(nPara));
    2054           0 :                 aSet.Put(CreatePaintSet( GetFormatRangeImpl(true), *aSet.GetPool(), rFormatSet, aSet, bNoCharacterFormats, bNoParagraphFormats ) );
    2055           0 :                 rOutliner.SetParaAttribs(nPara, aSet);
    2056           0 :             }
    2057             : 
    2058           0 :             OutlinerParaObject* pTemp = rOutliner.CreateParaObject(0, nParaCount);
    2059           0 :             rOutliner.Clear();
    2060             : 
    2061           0 :             rTextObj.NbcSetOutlinerParaObjectForText(pTemp,pText);
    2062             :         }
    2063             :     }
    2064           0 : }
    2065             : 
    2066           0 : void SdrObjEditView::ApplyFormatPaintBrush( SfxItemSet& rFormatSet, bool bNoCharacterFormats, bool bNoParagraphFormats )
    2067             : {
    2068           0 :     if( !mxSelectionController.is() || !mxSelectionController->ApplyFormatPaintBrush( rFormatSet, bNoCharacterFormats, bNoParagraphFormats ) )
    2069             :     {
    2070           0 :         const SdrMarkList& rMarkList = GetMarkedObjectList();
    2071           0 :         SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
    2072           0 :         OutlinerView* pOLV = GetTextEditOutlinerView();
    2073             : 
    2074           0 :         const SfxItemSet& rShapeSet = pObj->GetMergedItemSet();
    2075             : 
    2076           0 :         if( !pOLV )
    2077             :         {
    2078             :             // if not in text edit mode (aka the user selected text or clicked on a word)
    2079             :             // apply formatting attributes to selected shape
    2080             :             // All formatting items (see ranges above) that are unequal in selected shape and
    2081             :             // the format paintbrush are hard set on the selected shape.
    2082             : 
    2083           0 :             const sal_uInt16* pRanges = rFormatSet.GetRanges();
    2084           0 :             bool bTextOnly = true;
    2085             : 
    2086           0 :             while( *pRanges )
    2087             :             {
    2088           0 :                 if( (*pRanges != EE_PARA_START) && (*pRanges != EE_CHAR_START) )
    2089             :                 {
    2090           0 :                     bTextOnly = false;
    2091           0 :                     break;
    2092             :                 }
    2093           0 :                 pRanges += 2;
    2094             :             }
    2095             : 
    2096           0 :             if( !bTextOnly )
    2097             :             {
    2098           0 :                 SfxItemSet aPaintSet( CreatePaintSet( GetFormatRangeImpl(false), *rShapeSet.GetPool(), rFormatSet, rShapeSet, bNoCharacterFormats, bNoParagraphFormats ) );
    2099           0 :                 const bool bReplaceAll = false;
    2100           0 :                 SetAttrToMarked(aPaintSet, bReplaceAll);
    2101             :             }
    2102             : 
    2103             :             // now apply character and paragraph formatting to text, if the shape has any
    2104           0 :             SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>(pObj);
    2105           0 :             if( pTextObj )
    2106             :             {
    2107           0 :                 sal_Int32 nText = pTextObj->getTextCount();
    2108             : 
    2109           0 :                 while( --nText >= 0 )
    2110             :                 {
    2111           0 :                     SdrText* pText = pTextObj->getText( nText );
    2112           0 :                     ApplyFormatPaintBrushToText( rFormatSet, *pTextObj, pText, bNoCharacterFormats, bNoParagraphFormats );
    2113             :                 }
    2114             :             }
    2115             :         }
    2116             :         else
    2117             :         {
    2118           0 :             ::Outliner* pOutliner = pOLV->GetOutliner();
    2119           0 :             if( pOutliner )
    2120             :             {
    2121           0 :                 const EditEngine& rEditEngine = pOutliner->GetEditEngine();
    2122             : 
    2123           0 :                 ESelection aSel( pOLV->GetSelection() );
    2124           0 :                 if( !aSel.HasRange() )
    2125           0 :                     pOLV->SetSelection( rEditEngine.GetWord( aSel, com::sun::star::i18n::WordType::DICTIONARY_WORD ) );
    2126             : 
    2127           0 :                 const bool bRemoveParaAttribs = !bNoParagraphFormats;
    2128           0 :                 pOLV->RemoveAttribsKeepLanguages( bRemoveParaAttribs );
    2129           0 :                 SfxItemSet aSet( pOLV->GetAttribs() );
    2130           0 :                 SfxItemSet aPaintSet( CreatePaintSet(GetFormatRangeImpl(true), *aSet.GetPool(), rFormatSet, aSet, bNoCharacterFormats, bNoParagraphFormats ) );
    2131           0 :                 pOLV->SetAttribs( aPaintSet );
    2132             :             }
    2133             :         }
    2134             :     }
    2135         651 : }
    2136             : 
    2137             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10