LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/func - futext.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 1 582 0.2 %
Date: 2012-12-27 Functions: 2 30 6.7 %
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 "futext.hxx"
      21             : #include <editeng/eeitem.hxx>
      22             : #include <editeng/editerr.hxx>
      23             : #include <svx/dlgutil.hxx>
      24             : #include <svx/svxerr.hxx>
      25             : #include <tools/urlobj.hxx>
      26             : #include <vcl/help.hxx>
      27             : #include <editeng/editstat.hxx>
      28             : #include <svl/aeitem.hxx>
      29             : #include <svl/intitem.hxx>
      30             : #include <svx/svdotext.hxx>
      31             : #include <svx/svdogrp.hxx>
      32             : #include <editeng/flditem.hxx>
      33             : #include <svl/style.hxx>
      34             : #include <svx/svdpagv.hxx>
      35             : #include <sfx2/viewfrm.hxx>
      36             : #include <sfx2/dispatch.hxx>
      37             : #include <sfx2/bindings.hxx>
      38             : #include <sfx2/request.hxx>
      39             : #include <editeng/editeng.hxx>
      40             : #include <svx/svdoutl.hxx>
      41             : #include <svx/svxids.hrc>
      42             : #include <sfx2/docfile.hxx>
      43             : #include <comphelper/processfactory.hxx>
      44             : #include <editeng/outlobj.hxx>
      45             : #include <svtools/langtab.hxx>
      46             : 
      47             : #include <editeng/frmdiritem.hxx>
      48             : 
      49             : #include <svx/svdetc.hxx>
      50             : #include <editeng/editview.hxx>
      51             : 
      52             : #include "sdresid.hxx"
      53             : #include "app.hrc"
      54             : #include "res_bmp.hrc"
      55             : #include "ViewShell.hxx"
      56             : #include "ViewShellBase.hxx"
      57             : #include "View.hxx"
      58             : #include "Outliner.hxx"
      59             : #include "Window.hxx"
      60             : #include "drawdoc.hxx"
      61             : #include "sdpage.hxx"
      62             : #include "sdmod.hxx"
      63             : #include "FrameView.hxx"
      64             : #include "ToolBarManager.hxx"
      65             : #include "DrawDocShell.hxx"
      66             : #include "glob.hrc"
      67             : #include "pres.hxx"
      68             : #include "optsitem.hxx"
      69             : 
      70             : using ::rtl::OUString;
      71             : using namespace ::com::sun::star;
      72             : using namespace ::com::sun::star::uno;
      73             : using namespace ::com::sun::star::lang;
      74             : using namespace ::com::sun::star::linguistic2;
      75             : 
      76             : namespace sd {
      77             : 
      78             : static sal_uInt16 SidArray[] = {
      79             :     SID_STYLE_FAMILY2,                //    5542
      80             :     SID_STYLE_FAMILY5,                //    5545
      81             :     SID_REDO,                         //    5700
      82             :     SID_UNDO,                         //    5701
      83             :     SID_CUT,                          //    5710
      84             :     SID_COPY,                         //    5711
      85             :     SID_ATTR_TABSTOP,                 //   10002
      86             :     SID_ATTR_CHAR_FONT,               //   10007
      87             :     SID_ATTR_CHAR_POSTURE,            //   10008
      88             :     SID_ATTR_CHAR_WEIGHT,             //   10009
      89             :     SID_ATTR_CHAR_UNDERLINE,          //   10014
      90             :     SID_ATTR_CHAR_FONTHEIGHT,         //   10015
      91             :     SID_ATTR_CHAR_COLOR,              //   10017
      92             :     SID_ATTR_PARA_ADJUST_LEFT,        //   10028
      93             :     SID_ATTR_PARA_ADJUST_RIGHT,       //   10029
      94             :     SID_ATTR_PARA_ADJUST_CENTER,      //   10030
      95             :     SID_ATTR_PARA_ADJUST_BLOCK,       //   10031
      96             :     SID_ATTR_PARA_LINESPACE_10,       //   10034
      97             :     SID_ATTR_PARA_LINESPACE_15,       //   10035
      98             :     SID_ATTR_PARA_LINESPACE_20,       //   10036
      99             :     SID_ATTR_PARA_LRSPACE,            //   10043
     100             :     SID_OUTLINE_UP,                   //   10150
     101             :     SID_OUTLINE_DOWN,                 //   10151
     102             :     SID_OUTLINE_LEFT,                 //   10152
     103             :     SID_OUTLINE_RIGHT,                //   10153
     104             :     SID_FORMTEXT_STYLE,               //   10257
     105             :     SID_SET_SUPER_SCRIPT,             //   10294
     106             :     SID_SET_SUB_SCRIPT,               //   10295
     107             :     SID_HYPERLINK_GETLINK,            //   10361
     108             :     SID_CHARMAP,                      //   10503
     109             :     SID_TEXTDIRECTION_LEFT_TO_RIGHT,  //   10907
     110             :     SID_TEXTDIRECTION_TOP_TO_BOTTOM,  //   10908
     111             :     SID_ATTR_PARA_LEFT_TO_RIGHT,      //   10950
     112             :     SID_ATTR_PARA_RIGHT_TO_LEFT,      //   10951
     113             :     FN_NUM_BULLET_ON,                 //   20138
     114             :     SID_PARASPACE_INCREASE,           //   27346
     115             :     SID_PARASPACE_DECREASE,           //   27347
     116             :                             0 };
     117             : 
     118           0 : TYPEINIT1( FuText, FuConstruct );
     119             : 
     120             : 
     121             : static sal_Bool bTestText = 0;
     122             : 
     123             : /*************************************************************************
     124             : |*
     125             : |* Basisklasse fuer Textfunktionen
     126             : |*
     127             : \************************************************************************/
     128             : 
     129           0 : FuText::FuText( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
     130             : : FuConstruct(pViewSh, pWin, pView, pDoc, rReq)
     131             : , bFirstObjCreated(sal_False)
     132             : , bJustEndedEdit(false)
     133           0 : , rRequest (rReq)
     134             : {
     135           0 : }
     136             : 
     137           0 : FunctionReference FuText::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
     138             : {
     139           0 :     FunctionReference xFunc( new FuText( pViewSh, pWin, pView, pDoc, rReq ) );
     140           0 :     return xFunc;
     141             : }
     142             : 
     143             : /*************************************************************************
     144             : |*
     145             : |* Destruktor
     146             : |*
     147             : \************************************************************************/
     148             : 
     149           0 : void FuText::disposing()
     150             : {
     151           0 :     if(mpView)
     152             :     {
     153           0 :         if(mpView->SdrEndTextEdit(sal_False) == SDRENDTEXTEDIT_DELETED)
     154           0 :             mxTextObj.reset( 0 );
     155             : 
     156             :         // die RequestHandler der benutzten Outliner zuruecksetzen auf den
     157             :         // Handler am Dokument
     158           0 :         ::Outliner* pOutliner = mpView->GetTextEditOutliner();
     159             : 
     160           0 :         if (pOutliner)
     161           0 :             pOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(mpDoc->GetStyleSheetPool()));
     162             :     }
     163           0 : }
     164             : 
     165             : /*************************************************************************
     166             : |*
     167             : |* Execute functionality of this class:
     168             : |*
     169             : |* #71422: Start the functionality of this class in this method
     170             : |* and not in the ctor.
     171             : |* If you construct an object of this class and you put the
     172             : |* address of this object to pFuActual you've got a problem,
     173             : |* because some methods inside DoExecute use the pFuActual-Pointer.
     174             : |* If the code inside DoExecute is executed inside the ctor,
     175             : |* the value of pFuActual is not right. And the value will not
     176             : |* be right until the ctor finished !!!
     177             : |*
     178             : \************************************************************************/
     179           0 : void FuText::DoExecute( SfxRequest& )
     180             : {
     181           0 :     mpViewShell->GetViewShellBase().GetToolBarManager()->SetToolBarShell(
     182             :         ToolBarManager::TBG_FUNCTION,
     183           0 :         RID_DRAW_TEXT_TOOLBOX);
     184             : 
     185           0 :     mpView->SetCurrentObj(OBJ_TEXT);
     186           0 :     mpView->SetEditMode(SDREDITMODE_EDIT);
     187             : 
     188           0 :     MouseEvent aMEvt(mpWindow->GetPointerPosPixel());
     189             : 
     190           0 :     if (nSlotId == SID_TEXTEDIT)
     191             :     {
     192             :         // Try to select an object
     193           0 :         SdrPageView* pPV = mpView->GetSdrPageView();
     194           0 :         SdrViewEvent aVEvt;
     195           0 :         mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     196           0 :         mpView->MarkObj(aVEvt.pRootObj, pPV);
     197             : 
     198           0 :         mxTextObj.reset( dynamic_cast< SdrTextObj* >( aVEvt.pObj ) );
     199             :     }
     200           0 :     else if (mpView->AreObjectsMarked())
     201             :     {
     202           0 :         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
     203             : 
     204           0 :         if (rMarkList.GetMarkCount() == 1)
     205             :         {
     206           0 :             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
     207           0 :             mxTextObj.reset( dynamic_cast< SdrTextObj* >( pObj ) );
     208             :         }
     209             :     }
     210             : 
     211             :     // check for table
     212           0 :     if (mpView->AreObjectsMarked())
     213             :     {
     214           0 :         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
     215             : 
     216           0 :         if (rMarkList.GetMarkCount() == 1)
     217             :         {
     218           0 :             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
     219           0 :             if( pObj && (pObj->GetObjInventor() == SdrInventor ) && (pObj->GetObjIdentifier() == OBJ_TABLE) )
     220             :             {
     221           0 :                 mpViewShell->GetViewShellBase().GetToolBarManager()->AddToolBarShell( ToolBarManager::TBG_FUNCTION, RID_DRAW_TABLE_TOOLBOX );
     222             :             }
     223             :         }
     224             :     }
     225             : 
     226           0 :     sal_Bool bQuickDrag = sal_True;
     227             : 
     228           0 :     const SfxItemSet* pArgs = rRequest.GetArgs();
     229             : 
     230           0 :     if (pArgs
     231             : 
     232             :         // test for type before using
     233             :         && SID_TEXTEDIT == nSlotId
     234           0 :         && SFX_ITEM_SET == pArgs->GetItemState(SID_TEXTEDIT)
     235             : 
     236           0 :         && (sal_uInt16)((SfxUInt16Item&)pArgs->Get(SID_TEXTEDIT)).GetValue() == 2)
     237             :     {
     238             :         // Selection by doubleclick -> don't allow QuickDrag
     239           0 :         bQuickDrag = sal_False;
     240             :     }
     241             : 
     242           0 :     SetInEditMode(aMEvt, bQuickDrag);
     243           0 : }
     244             : 
     245             : /*************************************************************************
     246             : |*
     247             : |* MouseButtonDown-event
     248             : |*
     249             : \************************************************************************/
     250             : 
     251           0 : sal_Bool FuText::MouseButtonDown(const MouseEvent& rMEvt)
     252             : {
     253           0 :     bMBDown = sal_True;
     254             : 
     255           0 :     sal_Bool bReturn = FuDraw::MouseButtonDown(rMEvt);
     256             : 
     257           0 :     mpView->SetMarkHdlWhenTextEdit(sal_True);
     258           0 :     SdrViewEvent aVEvt;
     259           0 :     SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     260             : 
     261           0 :     if (eHit == SDRHIT_TEXTEDIT)
     262             :     {
     263             :         // Text getroffen -> Event von SdrView auswerten lassen
     264           0 :         if (mpView->MouseButtonDown(rMEvt, mpWindow))
     265           0 :             return (sal_True);
     266             :     }
     267             : 
     268           0 :     if (rMEvt.GetClicks() == 1)
     269             :     {
     270           0 :         if (mpView->IsTextEdit() && eHit != SDRHIT_MARKEDOBJECT && eHit != SDRHIT_HANDLE)
     271             :         {
     272             :             // Texteingabe beenden
     273           0 :             if(mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED)
     274             :             {
     275             :                 // Bugfix von MBA: bei Doppelclick auf der Wiese im Modus Text wird
     276             :                 // beim zweiten Click eHit = SDRHIT_TEXTEDITOBJ erhalten, weil ja der
     277             :                 // zweite Click auf das im ersten Click angelegte TextObject geht.
     278             :                 // Dieses wird aber in SdrEndTextEdit entfernt, weil es leer ist. Es
     279             :                 // befindet sich aber noch in der Mark-Liste und der Aufruf MarkObj
     280             :                 // weiter unten greift dann auf das tote Object zu.
     281             :                 // Als einfacher Fix wird nach SdrEndTextEdit noch einmal eHit ermittelt,
     282             :                 // was dann SDRHIT_NONE liefert.
     283           0 :                 mxTextObj.reset( NULL );
     284           0 :                 eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     285             :             }
     286             : 
     287           0 :             mpView->SetCurrentObj(OBJ_TEXT);
     288           0 :             mpView->SetEditMode(SDREDITMODE_EDIT);
     289             :         }
     290             : 
     291           0 :         if (rMEvt.IsLeft() || rMEvt.IsRight())
     292             :         {
     293           0 :             mpWindow->CaptureMouse();
     294             :             SdrObject* pObj;
     295           0 :             SdrPageView* pPV = mpView->GetSdrPageView();
     296             : 
     297           0 :             if (eHit == SDRHIT_TEXTEDIT)
     298             :             {
     299           0 :                 SetInEditMode(rMEvt, sal_False);
     300             :             }
     301             :             else
     302             :             {
     303           0 :                 sal_Bool bMacro = sal_False;
     304             : 
     305           0 :                 if (bMacro && mpView->PickObj(aMDPos,mpView->getHitTolLog(),pObj,pPV,SDRSEARCH_PICKMACRO))
     306             :                 {
     307             :                     // Makro
     308           0 :                     sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
     309           0 :                     mpView->BegMacroObj(aMDPos,nHitLog,pObj,pPV,mpWindow);
     310             :                 }
     311             :                 else
     312             :                 {
     313           0 :                     if (eHit != SDRHIT_HANDLE)
     314             :                     {
     315             :                         // Selektion aufheben
     316           0 :                         if (!rMEvt.IsShift() && eHit == SDRHIT_TEXTEDITOBJ)
     317             :                         {
     318           0 :                             mpView->UnmarkAll();
     319           0 :                             mpView->SetDragMode(SDRDRAG_MOVE);
     320             :                         }
     321             :                     }
     322             : 
     323           0 :                     if ( aVEvt.eEvent == SDREVENT_EXECUTEURL                   ||
     324             :                          eHit == SDRHIT_HANDLE                                 ||
     325             :                          eHit == SDRHIT_MARKEDOBJECT                           ||
     326             :                          eHit == SDRHIT_TEXTEDITOBJ                            ||
     327             :                          ( eHit == SDRHIT_UNMARKEDOBJECT && bFirstObjCreated &&
     328           0 :                            !bPermanent ) )
     329             :                     {
     330             :                         /**********************************************************
     331             :                         * Handle, markiertes oder unmarkiertes Objekt getroffen
     332             :                         **********************************************************/
     333           0 :                         if (eHit == SDRHIT_TEXTEDITOBJ)
     334             :                         {
     335             :                             /******************************************************
     336             :                             * Text eines unmarkierten Objekts getroffen:
     337             :                             * Objekt wird selektiert und in EditMode versetzt
     338             :                             ******************************************************/
     339           0 :                             mpView->MarkObj(aVEvt.pRootObj, pPV);
     340             : 
     341           0 :                             if (aVEvt.pObj && aVEvt.pObj->ISA(SdrTextObj))
     342             :                             {
     343           0 :                                 mxTextObj.reset( static_cast<SdrTextObj*>(aVEvt.pObj) );
     344             :                             }
     345             : 
     346           0 :                             SetInEditMode(rMEvt, sal_True);
     347             :                         }
     348           0 :                         else if (aVEvt.eEvent == SDREVENT_EXECUTEURL && !rMEvt.IsMod2())
     349             :                         {
     350             :                             /******************************************************
     351             :                             * URL ausfuehren
     352             :                             ******************************************************/
     353           0 :                             mpWindow->ReleaseMouse();
     354           0 :                             SfxStringItem aStrItem(SID_FILE_NAME, aVEvt.pURLField->GetURL());
     355           0 :                             SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
     356           0 :                             SfxBoolItem aBrowseItem( SID_BROWSE, sal_True );
     357           0 :                             SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
     358           0 :                             mpWindow->ReleaseMouse();
     359             : 
     360           0 :                             if (rMEvt.IsMod1())
     361             :                             {
     362             :                                 // Im neuen Frame oeffnen
     363             :                                 pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
     364           0 :                                             &aStrItem, &aBrowseItem, &aReferer, 0L);
     365             :                             }
     366             :                             else
     367             :                             {
     368             :                                 // Im aktuellen Frame oeffnen
     369           0 :                                 SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
     370             :                                 pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
     371           0 :                                             &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
     372           0 :                             }
     373             :                         }
     374             :                         else
     375             :                         {
     376             :                             /******************************************************
     377             :                             * Objekt oder Handle draggen
     378             :                             ******************************************************/
     379             : 
     380             :                             // #i78748#
     381             :                             // do the EndTextEdit first, it will delete the handles and force a
     382             :                             // recreation. This will make aVEvt.pHdl to point to a deleted handle,
     383             :                             // thus it is necessary to reset it and to get it again.
     384             : 
     385             :                             // #i112855#
     386             :                             // cl: I'm not sure why we checked here also for mxTextObj->GetOutlinerParaObjet
     387             :                             // this caused SdrEndTextEdit() to be called also when not in text editing and
     388             :                             // this does not make sense and caused troubles. (see issue 112855)
     389             : 
     390           0 :                             if( mpView->IsTextEdit() )
     391             :                             {
     392           0 :                                 mpView->SdrEndTextEdit();
     393           0 :                                 bJustEndedEdit = true;
     394             : 
     395           0 :                                 if(aVEvt.pHdl)
     396             :                                 {
     397             :                                     // force new handle identification, the pointer will be dead here
     398             :                                     // since SdrEndTextEdit has resetted (deleted) the handles.
     399           0 :                                     aVEvt.pHdl = 0;
     400           0 :                                     mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     401             :                                 }
     402             :                             }
     403             : 
     404           0 :                             if (!aVEvt.pHdl)
     405             :                             {
     406           0 :                                 if( eHit == SDRHIT_UNMARKEDOBJECT )
     407             :                                 {
     408           0 :                                     if ( !rMEvt.IsShift() )
     409           0 :                                         mpView->UnmarkAll();
     410             : 
     411           0 :                                     mpView->MarkObj(aVEvt.pRootObj, pPV);
     412             :                                 }
     413             : 
     414             :                                 // Drag object
     415           0 :                                 bFirstMouseMove = sal_True;
     416           0 :                                 aDragTimer.Start();
     417             :                             }
     418             : 
     419             : 
     420           0 :                             if ( ! rMEvt.IsRight())
     421             :                             {
     422             :                                 // we need to pick again since SdrEndTextEdit can rebuild the handles list
     423           0 :                                 eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     424           0 :                                 if( (eHit == SDRHIT_HANDLE) || (eHit == SDRHIT_MARKEDOBJECT) )
     425             :                                 {
     426           0 :                                     sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     427           0 :                                     mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
     428             :                                 }
     429             :                             }
     430           0 :                             bReturn = true;
     431           0 :                         }
     432             :                     }
     433           0 :                     else if ( nSlotId != SID_TEXTEDIT &&
     434           0 :                               (bPermanent || !bFirstObjCreated) )
     435             :                     {
     436             :                         /**********************************************************
     437             :                         * Objekt erzeugen
     438             :                         **********************************************************/
     439           0 :                         mpView->SetCurrentObj(OBJ_TEXT);
     440           0 :                         mpView->SetEditMode(SDREDITMODE_CREATE);
     441           0 :                         sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     442           0 :                         mpView->BegCreateObj(aMDPos, (OutputDevice*) NULL, nDrgLog);
     443             :                     }
     444             :                     else
     445             :                     {
     446             :                         /**********************************************************
     447             :                         * Selektieren
     448             :                         **********************************************************/
     449           0 :                         if( !rMEvt.IsShift() )
     450           0 :                             mpView->UnmarkAll();
     451             : 
     452           0 :                         mpView->BegMarkObj( aMDPos );
     453             :                     }
     454             :                 }
     455             :             }
     456             :         }
     457             :     }
     458           0 :     else if ( rMEvt.GetClicks() == 2 && !mpView->IsTextEdit() )
     459             :     {
     460           0 :         MouseEvent aMEvt( mpWindow->GetPointerPosPixel() );
     461           0 :         SetInEditMode( aMEvt, sal_False );
     462             :     }
     463             : 
     464           0 :     if (!bIsInDragMode)
     465             :     {
     466           0 :         ForcePointer(&rMEvt);
     467           0 :         mpViewShell->GetViewFrame()->GetBindings().Invalidate(SidArray);
     468             :     }
     469             : 
     470           0 :     return (bReturn);
     471             : }
     472             : 
     473             : /*************************************************************************
     474             : |*
     475             : |* MouseMove-event
     476             : |*
     477             : \************************************************************************/
     478             : 
     479           0 : sal_Bool FuText::MouseMove(const MouseEvent& rMEvt)
     480             : {
     481           0 :     sal_Bool bReturn = FuDraw::MouseMove(rMEvt);
     482             : 
     483           0 :     if (aDragTimer.IsActive() )
     484             :     {
     485           0 :         if( bFirstMouseMove )
     486           0 :             bFirstMouseMove = sal_False;
     487             :         else
     488           0 :             aDragTimer.Stop();
     489             :     }
     490             : 
     491           0 :     if (!bReturn && mpView->IsAction() && !mpDocSh->IsReadOnly())
     492             :     {
     493           0 :         Point aPix(rMEvt.GetPosPixel());
     494           0 :         Point aPnt(mpWindow->PixelToLogic(aPix));
     495             : 
     496           0 :         ForceScroll(aPix);
     497           0 :         mpView->MovAction(aPnt);
     498             :     }
     499             : 
     500           0 :     ForcePointer(&rMEvt);
     501             : 
     502           0 :     return (bReturn);
     503             : }
     504             : 
     505             : /*************************************************************************
     506             : |*
     507             : |* MouseButtonUp-event
     508             : |*
     509             : \************************************************************************/
     510             : 
     511           0 : void FuText::ImpSetAttributesForNewTextObject(SdrTextObj* pTxtObj)
     512             : {
     513           0 :     if(mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS)
     514             :     {
     515           0 :         if( nSlotId == SID_ATTR_CHAR )
     516             :         {
     517             :             // Impress-Textobjekt wird erzeugt (faellt auf Zeilenhoehe zusammen)
     518             :             // Damit das Objekt beim anschliessenden Erzeugen gleich die richtige
     519             :             // Hoehe bekommt (sonst wird zuviel gepainted)
     520           0 :             SfxItemSet aSet(mpViewShell->GetPool());
     521           0 :             aSet.Put(SdrTextMinFrameHeightItem(0));
     522           0 :             aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
     523           0 :             aSet.Put(SdrTextAutoGrowHeightItem(sal_True));
     524           0 :             pTxtObj->SetMergedItemSet(aSet);
     525           0 :             pTxtObj->AdjustTextFrameWidthAndHeight();
     526           0 :             aSet.Put(SdrTextMaxFrameHeightItem(pTxtObj->GetLogicRect().GetSize().Height()));
     527           0 :             pTxtObj->SetMergedItemSet(aSet);
     528             :         }
     529           0 :         else if( nSlotId == SID_ATTR_CHAR_VERTICAL )
     530             :         {
     531           0 :             SfxItemSet aSet(mpViewShell->GetPool());
     532           0 :             aSet.Put(SdrTextMinFrameWidthItem(0));
     533           0 :             aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
     534           0 :             aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
     535             : 
     536             :             // Needs to be set since default is SDRTEXTHORZADJUST_BLOCK
     537           0 :             aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
     538           0 :             pTxtObj->SetMergedItemSet(aSet);
     539           0 :             pTxtObj->AdjustTextFrameWidthAndHeight();
     540           0 :             aSet.Put(SdrTextMaxFrameWidthItem(pTxtObj->GetLogicRect().GetSize().Width()));
     541           0 :             pTxtObj->SetMergedItemSet(aSet);
     542             :         }
     543             :     }
     544             :     else
     545             :     {
     546           0 :         if( nSlotId == SID_ATTR_CHAR_VERTICAL )
     547             :         {
     548             :             // draw text object, needs to be initialized when vertical text is used
     549           0 :             SfxItemSet aSet(mpViewShell->GetPool());
     550             : 
     551           0 :             aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
     552           0 :             aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
     553             : 
     554             :             // Set defaults for vertical klick-n'drag text object, pool defaults are:
     555             :             // SdrTextVertAdjustItem: SDRTEXTVERTADJUST_TOP
     556             :             // SdrTextHorzAdjustItem: SDRTEXTHORZADJUST_BLOCK
     557             :             // Analog to that:
     558           0 :             aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK));
     559           0 :             aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
     560             : 
     561           0 :             pTxtObj->SetMergedItemSet(aSet);
     562             :         }
     563             :     }
     564           0 : }
     565             : 
     566           0 : void FuText::ImpSetAttributesFitToSize(SdrTextObj* pTxtObj)
     567             : {
     568             :     // FitToSize (An Rahmen anpassen)
     569           0 :     SfxItemSet aSet(mpViewShell->GetPool(), SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH);
     570           0 :     SdrFitToSizeType eFTS = SDRTEXTFIT_PROPORTIONAL;
     571           0 :     aSet.Put(SdrTextFitToSizeTypeItem(eFTS));
     572           0 :     aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
     573           0 :     aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
     574           0 :     pTxtObj->SetMergedItemSet(aSet);
     575           0 :     pTxtObj->AdjustTextFrameWidthAndHeight();
     576           0 : }
     577             : 
     578           0 : void FuText::ImpSetAttributesFitToSizeVertical(SdrTextObj* pTxtObj)
     579             : {
     580           0 :     SfxItemSet aSet(mpViewShell->GetPool(),
     581           0 :         SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH);
     582           0 :     SdrFitToSizeType eFTS = SDRTEXTFIT_PROPORTIONAL;
     583           0 :     aSet.Put(SdrTextFitToSizeTypeItem(eFTS));
     584           0 :     aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
     585           0 :     aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
     586           0 :     pTxtObj->SetMergedItemSet(aSet);
     587           0 :     pTxtObj->AdjustTextFrameWidthAndHeight();
     588           0 : }
     589             : 
     590           0 : void FuText::ImpSetAttributesFitCommon(SdrTextObj* pTxtObj)
     591             : {
     592             :     // Normal Textobject
     593           0 :     if (mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS)
     594             :     {
     595           0 :         if( nSlotId == SID_ATTR_CHAR )
     596             :         {
     597             :             // Impress-Textobject (faellt auf Zeilenhoehe zusammen)
     598           0 :             SfxItemSet aSet(mpViewShell->GetPool());
     599           0 :             aSet.Put(SdrTextMinFrameHeightItem(0));
     600           0 :             aSet.Put(SdrTextMaxFrameHeightItem(0));
     601           0 :             aSet.Put(SdrTextAutoGrowHeightItem(sal_True));
     602           0 :             aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
     603           0 :             pTxtObj->SetMergedItemSet(aSet);
     604             :         }
     605           0 :         else if( nSlotId == SID_ATTR_CHAR_VERTICAL )
     606             :         {
     607           0 :             SfxItemSet aSet(mpViewShell->GetPool());
     608           0 :             aSet.Put(SdrTextMinFrameWidthItem(0));
     609           0 :             aSet.Put(SdrTextMaxFrameWidthItem(0));
     610           0 :             aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
     611           0 :             aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
     612           0 :             pTxtObj->SetMergedItemSet(aSet);
     613             :         }
     614             : 
     615           0 :         pTxtObj->AdjustTextFrameWidthAndHeight();
     616             :     }
     617           0 : }
     618             : 
     619           0 : sal_Bool FuText::MouseButtonUp(const MouseEvent& rMEvt)
     620             : {
     621           0 :     sal_Bool bReturn = sal_False;
     622             :     SdrObject* pObj;
     623             :     SdrPageView* pPV;
     624           0 :     if (aDragTimer.IsActive())
     625             :     {
     626           0 :         aDragTimer.Stop();
     627           0 :         bIsInDragMode = sal_False;
     628             :     }
     629             : 
     630           0 :     mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray );
     631             : 
     632           0 :     Point aPnt( mpWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
     633             : 
     634           0 :     if( (mpView && mpView->MouseButtonUp(rMEvt, mpWindow)) || rMEvt.GetClicks() == 2 )
     635           0 :         return (sal_True); // Event von der SdrView ausgewertet
     636             : 
     637           0 :     sal_Bool bEmptyTextObj = sal_False;
     638             : 
     639           0 :     if (mxTextObj.is())
     640             :     {
     641           0 :         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
     642             : 
     643           0 :         if (rMarkList.GetMarkCount() == 1
     644           0 :             && ( rMarkList.GetMark(0)->GetMarkedSdrObj() == mxTextObj.get()) )
     645             :         {
     646           0 :             if( mxTextObj.is() && !GetTextObj()->GetOutlinerParaObject() )
     647           0 :                 bEmptyTextObj = sal_True;
     648             :             else
     649           0 :                 bFirstObjCreated = sal_True;
     650             :         }
     651             :         else
     652             :         {
     653           0 :             mxTextObj.reset( 0 );
     654             :         }
     655             :     }
     656             : 
     657           0 :     if( mpView && mpView->IsDragObj())
     658             :     {
     659             :         /**********************************************************************
     660             :         * Objekt wurde verschoben
     661             :         **********************************************************************/
     662           0 :         FrameView* pFrameView = mpViewShell->GetFrameView();
     663           0 :         sal_Bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
     664             : 
     665           0 :         if (bDragWithCopy)
     666             :         {
     667           0 :             bDragWithCopy = !mpView->IsPresObjSelected(sal_False, sal_True);
     668             :         }
     669             : 
     670           0 :         mpView->SetDragWithCopy(bDragWithCopy);
     671           0 :         mpView->EndDragObj( mpView->IsDragWithCopy() );
     672           0 :         mpView->ForceMarkedToAnotherPage();
     673           0 :         mpView->SetCurrentObj(OBJ_TEXT);
     674             : 
     675           0 :         sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     676             : 
     677           0 :         if ( mpView->IsRotateAllowed() && mpViewShell->GetFrameView()->IsClickChangeRotation() && (rMEvt.GetClicks() != 2) && !bJustEndedEdit &&
     678           0 :             !rMEvt.IsShift() && !rMEvt.IsMod1() && !rMEvt.IsMod2() && !rMEvt.IsRight() &&
     679           0 :             Abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
     680           0 :             Abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
     681             :         {
     682             :             /*************************************************************
     683             :             * If a user wants to click on an object in front of a masked
     684             :             * one, he releases the mouse button immediately
     685             :             **************************************************************/
     686           0 :             if (mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER | SDRSEARCH_BEFOREMARK))
     687             :             {
     688           0 :                 mpView->UnmarkAllObj();
     689           0 :                 mpView->MarkObj(pObj,pPV,false,false);
     690           0 :                 return (bReturn);
     691             :             }
     692             :             // toggle to rotation mode
     693           0 :             mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_ROTATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
     694             :         }
     695             : 
     696           0 :         if( bJustEndedEdit )
     697           0 :             bJustEndedEdit = false;
     698             :     }
     699           0 :     else if( mpView && mpView->IsCreateObj() && rMEvt.IsLeft())
     700             :     {
     701             :         /**********************************************************************
     702             :         * Objekt wurde erzeugt
     703             :         **********************************************************************/
     704           0 :         mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetCreateObj() ) );
     705             : 
     706           0 :         if( mxTextObj.is() )
     707             :         {
     708             :             //AW outliner needs to be set to vertical when there is no
     709             :             // outliner object up to now; also it needs to be set back to not
     710             :             // vertical when there was a vertical one used last time.
     711           0 :             OutlinerParaObject* pOPO = GetTextObj()->GetOutlinerParaObject();
     712           0 :             SdrOutliner& rOutl = mxTextObj->GetModel()->GetDrawOutliner(GetTextObj());
     713           0 :             sal_Bool bVertical((pOPO && pOPO->IsVertical())
     714             :                 || nSlotId == SID_ATTR_CHAR_VERTICAL
     715           0 :                 || nSlotId == SID_TEXT_FITTOSIZE_VERTICAL);
     716           0 :             rOutl.SetVertical(bVertical);
     717             : 
     718             :             // Before ImpSetAttributesForNewTextObject the vertical writing mode
     719             :             // needs to be set at the object. This is done here at the OutlinerParaObject
     720             :             // directly to not mirror the layout text items involved. These items will be set
     721             :             // from ImpSetAttributesForNewTextObject and below.
     722           0 :             OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject();
     723             : 
     724           0 :             if(!pPara)
     725             :             {
     726           0 :                 GetTextObj()->ForceOutlinerParaObject();
     727           0 :                 pPara = GetTextObj()->GetOutlinerParaObject();
     728             :             }
     729             : 
     730           0 :             if(pPara && (bool)bVertical != pPara->IsVertical())
     731             :             {
     732             :                 // set ParaObject orientation accordingly
     733           0 :                 pPara->SetVertical(bVertical);
     734             :             }
     735             : 
     736           0 :             ImpSetAttributesForNewTextObject(GetTextObj());
     737             :         }
     738             : 
     739           0 :         if (!mpView->EndCreateObj(SDRCREATE_FORCEEND))
     740             :         {
     741             :             // Textobjekt konnte nicht erzeugt werden
     742           0 :             mxTextObj.reset(0);
     743             :         }
     744           0 :         else if (nSlotId == SID_TEXT_FITTOSIZE)
     745             :         {
     746           0 :             ImpSetAttributesFitToSize(GetTextObj());
     747             : 
     748           0 :             SetInEditMode(rMEvt, sal_False);
     749             :         }
     750           0 :         else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL )
     751             :         {
     752           0 :             ImpSetAttributesFitToSizeVertical(GetTextObj());
     753             : 
     754           0 :             SetInEditMode(rMEvt, sal_False);
     755             :         }
     756             :         else
     757             :         {
     758           0 :             ImpSetAttributesFitCommon(GetTextObj());
     759             : 
     760             :             // Damit die Handles und der graue Rahmen stimmen
     761           0 :             mpView->AdjustMarkHdl();
     762           0 :             mpView->PickHandle(aPnt);
     763           0 :             SetInEditMode(rMEvt, sal_False);
     764             :         }
     765             :     }
     766           0 :     else if ( mpView && mpView->IsAction())
     767             :     {
     768           0 :         mpView->EndAction();
     769             :     }
     770             : 
     771           0 :     ForcePointer(&rMEvt);
     772           0 :     mpWindow->ReleaseMouse();
     773           0 :     sal_uInt16 nDrgLog1 = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     774             : 
     775           0 :     if ( mpView && !mpView->AreObjectsMarked() &&
     776           0 :          Abs(aMDPos.X() - aPnt.X()) < nDrgLog1 &&
     777           0 :          Abs(aMDPos.Y() - aPnt.Y()) < nDrgLog1 &&
     778           0 :          !rMEvt.IsShift() && !rMEvt.IsMod2() )
     779             :     {
     780           0 :         SdrPageView* pPV2 = mpView->GetSdrPageView();
     781           0 :         SdrViewEvent aVEvt;
     782           0 :         mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
     783           0 :         mpView->MarkObj(aVEvt.pRootObj, pPV2);
     784             :     }
     785             : 
     786           0 :     if ( !mxTextObj.is() && mpView )
     787             :     {
     788           0 :         if ( ( (!bEmptyTextObj   &&  bPermanent) ||
     789           0 :              (!bFirstObjCreated && !bPermanent) ) &&
     790           0 :               !mpDocSh->IsReadOnly()               &&
     791             :               nSlotId != SID_TEXTEDIT )
     792             :         {
     793             :             /**********************************************************************
     794             :             * Mengentext (linksbuendiges AutoGrow)
     795             :             **********************************************************************/
     796           0 :             mpView->SetCurrentObj(OBJ_TEXT);
     797           0 :             mpView->SetEditMode(SDREDITMODE_CREATE);
     798           0 :             sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
     799           0 :             mpView->BegCreateObj(aMDPos, (OutputDevice*) NULL, nDrgLog);
     800             : 
     801           0 :             sal_Bool bSnapEnabled = mpView->IsSnapEnabled();
     802             : 
     803           0 :             if (bSnapEnabled)
     804           0 :                 mpView->SetSnapEnabled(sal_False);
     805             : 
     806           0 :             aPnt.X() += nDrgLog + nDrgLog;
     807           0 :             aPnt.Y() += nDrgLog + nDrgLog;
     808           0 :             mpView->MovAction(aPnt);
     809             : 
     810           0 :             mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetCreateObj() ) );
     811             : 
     812           0 :             if(mxTextObj.is())
     813             :             {
     814           0 :                 GetTextObj()->SetDisableAutoWidthOnDragging(sal_True);
     815             :             }
     816             : 
     817           0 :             if(!mpView->EndCreateObj(SDRCREATE_FORCEEND))
     818             :             {
     819           0 :                 mxTextObj.reset(0);
     820             :             }
     821             : 
     822           0 :             if(bSnapEnabled)
     823           0 :                 mpView->SetSnapEnabled(bSnapEnabled);
     824             : 
     825           0 :             if(mxTextObj.is())
     826             :             {
     827           0 :                 SfxItemSet aSet(mpViewShell->GetPool());
     828           0 :                 aSet.Put(SdrTextMinFrameHeightItem(0));
     829           0 :                 aSet.Put(SdrTextMinFrameWidthItem(0));
     830           0 :                 aSet.Put(SdrTextAutoGrowHeightItem(sal_True));
     831           0 :                 aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
     832             : 
     833           0 :                 if(nSlotId == SID_ATTR_CHAR_VERTICAL)
     834             :                 {
     835             :                     // Here, all items which need to be different from pool default need to be set
     836             :                     // again on the newly created text object.
     837             :                     // Since this is a simple klick text object, it is first created, then SetVertical()
     838             :                     // is used, then ImpSetAttributesForNewTextObject is called and then the object is
     839             :                     // deleted again since not the minimum drag distance was travelled. Then, a new
     840             :                     // klick text object is created and thus all that stuff needs to be set again here.
     841             :                     //
     842             :                     // Before using the new object the vertical writing mode
     843             :                     // needs to be set. This is done here at the OutlinerParaObject
     844             :                     // directly to not mirror the layout text items involved. These items will be set
     845             :                     // below.
     846           0 :                     OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject();
     847             : 
     848           0 :                     if(!pPara)
     849             :                     {
     850           0 :                         GetTextObj()->ForceOutlinerParaObject();
     851           0 :                         pPara = GetTextObj()->GetOutlinerParaObject();
     852             :                     }
     853             : 
     854           0 :                     if(pPara && sal_True != pPara->IsVertical())
     855             :                     {
     856             :                         // set ParaObject orientation accordingly
     857           0 :                         pPara->SetVertical(sal_True);
     858             :                     }
     859             : 
     860           0 :                     aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
     861             : 
     862             :                     // Analog to the else case below, for vertical simple click texts
     863             :                     // one of the defaulted setted items from ImpSetAttributesForNewTextObject
     864             :                     // needs to be adapted to non-block mode.
     865           0 :                     const SfxItemSet& rSet = mpView->GetDefaultAttr();
     866           0 :                     SvxFrameDirection eDirection = (SvxFrameDirection)((SvxFrameDirectionItem&)rSet.Get(EE_PARA_WRITINGDIR)).GetValue();
     867             : 
     868           0 :                     if(FRMDIR_HORI_RIGHT_TOP == eDirection || FRMDIR_VERT_TOP_RIGHT == eDirection)
     869             :                     {
     870           0 :                         aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM));
     871             :                     }
     872             :                     else
     873             :                     {
     874           0 :                         aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP));
     875             :                     }
     876             :                 }
     877             :                 else
     878             :                 {
     879             :                     // This is for Format/Page settings. Since this also leads
     880             :                     // to the object defaults to be changed, i think this code can be
     881             :                     // removed. CL. wanted to take a look before adding this.
     882             : 
     883             :                     // Look in the object defaults if left-to-right is wanted. If
     884             :                     // yes, set text anchoring to right to let the box grow to left.
     885           0 :                     const SfxItemSet& rSet = mpView->GetDefaultAttr();
     886           0 :                     SvxFrameDirection eDirection = (SvxFrameDirection)((SvxFrameDirectionItem&)rSet.Get(EE_PARA_WRITINGDIR)).GetValue();
     887             : 
     888           0 :                     if(FRMDIR_HORI_RIGHT_TOP == eDirection)
     889             :                     {
     890           0 :                         aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
     891             :                     }
     892             :                     else
     893             :                     {
     894           0 :                         aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT));
     895             :                     }
     896             :                 }
     897             : 
     898           0 :                 GetTextObj()->SetMergedItemSet(aSet);
     899           0 :                 GetTextObj()->SetDisableAutoWidthOnDragging(sal_True);
     900           0 :                 SetInEditMode(rMEvt, sal_False);
     901             :             }
     902             : 
     903           0 :             bFirstObjCreated = sal_True;
     904             :         }
     905             :         else
     906             :         {
     907             :             // In die Fkt. Selektion wechseln
     908           0 :             if (mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED)
     909             :             {
     910           0 :                 mxTextObj.reset(0);
     911             :             }
     912             : 
     913             :             mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_SELECT,
     914           0 :                                       SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
     915             :         }
     916             :     }
     917             : 
     918           0 :     bMBDown = sal_False;
     919           0 :     FuConstruct::MouseButtonUp(rMEvt);
     920           0 :     return (bReturn);
     921             : }
     922             : 
     923             : /*************************************************************************
     924             : |*
     925             : |* Tastaturereignisse bearbeiten
     926             : |*
     927             : |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
     928             : |* sal_False.
     929             : |*
     930             : \************************************************************************/
     931             : 
     932           0 : sal_Bool FuText::KeyInput(const KeyEvent& rKEvt)
     933             : {
     934           0 :     sal_Bool bReturn = sal_False;
     935           0 :     mpView->SetMarkHdlWhenTextEdit(sal_True);
     936             : 
     937           0 :     KeyCode nCode = rKEvt.GetKeyCode();
     938           0 :     sal_Bool bShift = nCode.IsShift();
     939             : 
     940           0 :     if(mxTextObj.is())
     941             :     {
     942             :         // maybe object is deleted, test if it's equal to the selected object
     943           0 :         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
     944           0 :         SdrObject* pSelectedObj = 0L;
     945             : 
     946           0 :         if(1 == rMarkList.GetMarkCount())
     947             :         {
     948           0 :             SdrMark* pMark = rMarkList.GetMark(0);
     949           0 :             pSelectedObj = pMark->GetMarkedSdrObj();
     950             :         }
     951             : 
     952           0 :         if(mxTextObj.get() != pSelectedObj)
     953             :         {
     954           0 :             mxTextObj.reset(0);
     955             :         }
     956             :     }
     957             : 
     958           0 :     if ( mxTextObj.is() && mxTextObj->GetObjInventor() == SdrInventor && mxTextObj->GetObjIdentifier() == OBJ_TITLETEXT && rKEvt.GetKeyCode().GetCode() == KEY_RETURN )
     959             :     {
     960             :         // Titeltext-Objekt: immer "weiche" Umbrueche
     961           0 :         bShift = sal_True;
     962             :     }
     963             : 
     964           0 :     sal_uInt16 nKey = nCode.GetCode();
     965           0 :     KeyCode aKeyCode (nKey, bShift, nCode.IsMod1(), nCode.IsMod2(), nCode.IsMod3() );
     966           0 :     KeyEvent aKEvt(rKEvt.GetCharCode(), aKeyCode);
     967             : 
     968           0 :     sal_Bool bOK = sal_True;
     969             : 
     970           0 :     if (mpDocSh->IsReadOnly())
     971             :     {
     972           0 :         bOK = !EditEngine::DoesKeyChangeText(aKEvt);
     973             :     }
     974           0 :     if( aKeyCode.GetCode() == KEY_PAGEUP || aKeyCode.GetCode() == KEY_PAGEDOWN )
     975             :     {
     976           0 :         bOK = sal_False;   // default handling in base class
     977             :     }
     978             : 
     979           0 :     if (bOK && mpView->KeyInput(aKEvt, mpWindow) )
     980             :     {
     981           0 :         bReturn = sal_True;
     982             : 
     983           0 :         mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray );
     984             : 
     985             :     }
     986           0 :     else if (aKeyCode == KEY_ESCAPE)
     987             :     {
     988           0 :         bReturn = cancel();
     989             :     }
     990             : 
     991           0 :     if( bPermanent )
     992             :     {
     993           0 :         mpView->SetCurrentObj(OBJ_TEXT);
     994           0 :         mpView->SetEditMode(SDREDITMODE_CREATE);
     995             :     }
     996             : 
     997           0 :     if (!bReturn)
     998             :     {
     999           0 :         bReturn = FuDraw::KeyInput(aKEvt);
    1000             :     }
    1001             : 
    1002           0 :     return (bReturn);
    1003             : }
    1004             : 
    1005             : 
    1006             : 
    1007             : /*************************************************************************
    1008             : |*
    1009             : |* Function aktivieren
    1010             : |*
    1011             : \************************************************************************/
    1012             : 
    1013           0 : void FuText::Activate()
    1014             : {
    1015           0 :     mpView->SetQuickTextEditMode(mpViewShell->GetFrameView()->IsQuickEdit());
    1016             : 
    1017             :     // #i89661# it's no longer necessary to make it so big here, it's fine tuned
    1018             :     // for text objects in SdrMarkView::CheckSingleSdrObjectHit
    1019           0 :     mpView->SetHitTolerancePixel( 2 * HITPIX );
    1020             : 
    1021           0 :     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
    1022             : 
    1023           0 :     if (pOLV)
    1024           0 :         pOLV->ShowCursor();
    1025             : 
    1026           0 :     FuConstruct::Activate();
    1027             : 
    1028           0 :     if( pOLV )
    1029           0 :         mpView->SetEditMode(SDREDITMODE_EDIT);
    1030           0 : }
    1031             : 
    1032             : 
    1033             : /*************************************************************************
    1034             : |*
    1035             : |* Function deaktivieren
    1036             : |*
    1037             : \************************************************************************/
    1038             : 
    1039           0 : void FuText::Deactivate()
    1040             : {
    1041           0 :     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
    1042             : 
    1043           0 :     if (pOLV)
    1044           0 :         pOLV->HideCursor();
    1045             : 
    1046           0 :     mpView->SetHitTolerancePixel( HITPIX );
    1047             : 
    1048           0 :     FuConstruct::Deactivate();
    1049           0 : }
    1050             : 
    1051             : 
    1052             : /*************************************************************************
    1053             : |*
    1054             : |* Objekt in Edit-Mode setzen
    1055             : |*
    1056             : \************************************************************************/
    1057             : 
    1058           0 : void FuText::SetInEditMode(const MouseEvent& rMEvt, sal_Bool bQuickDrag)
    1059             : {
    1060           0 :     SdrPageView* pPV = mpView->GetSdrPageView();
    1061           0 :     if( mxTextObj.is() && (mxTextObj->GetPage() == pPV->GetPage()) )
    1062             :     {
    1063           0 :         mpView->SetCurrentObj(OBJ_TEXT);
    1064             : 
    1065           0 :         if( bPermanent )
    1066           0 :             mpView->SetEditMode(SDREDITMODE_CREATE);
    1067             :         else
    1068           0 :             mpView->SetEditMode(SDREDITMODE_EDIT);
    1069             : 
    1070           0 :         sal_Bool bEmptyOutliner = sal_False;
    1071             : 
    1072           0 :         if (!GetTextObj()->GetOutlinerParaObject() && mpView->GetTextEditOutliner())
    1073             :         {
    1074           0 :             ::Outliner* pOutl = mpView->GetTextEditOutliner();
    1075           0 :             sal_uLong nParaAnz = pOutl->GetParagraphCount();
    1076           0 :             Paragraph* p1stPara = pOutl->GetParagraph( 0 );
    1077             : 
    1078           0 :             if (nParaAnz==1 && p1stPara)
    1079             :             {
    1080             :                 // Bei nur einem Pararaph
    1081           0 :                 if (pOutl->GetText(p1stPara).Len() == 0)
    1082             :                 {
    1083           0 :                     bEmptyOutliner = sal_True;
    1084             :                 }
    1085             :             }
    1086             :         }
    1087             : 
    1088           0 :         if (GetTextObj() != mpView->GetTextEditObject() || bEmptyOutliner)
    1089             :         {
    1090           0 :             sal_uInt32 nInv = mxTextObj->GetObjInventor();
    1091           0 :             sal_uInt16 nSdrObjKind = mxTextObj->GetObjIdentifier();
    1092             : 
    1093           0 :             if (nInv == SdrInventor && GetTextObj()->HasTextEdit() &&
    1094             :                 (nSdrObjKind == OBJ_TEXT ||
    1095             :                  nSdrObjKind == OBJ_TITLETEXT ||
    1096           0 :                  nSdrObjKind == OBJ_OUTLINETEXT || !mxTextObj->IsEmptyPresObj() ) )
    1097             :             {
    1098             :                 // Neuen Outliner machen (gehoert der SdrObjEditView)
    1099           0 :                 SdrOutliner* pOutl = SdrMakeOutliner( OUTLINERMODE_OUTLINEOBJECT, mpDoc );
    1100             : 
    1101           0 :                 if (bEmptyOutliner)
    1102           0 :                     mpView->SdrEndTextEdit(sal_True);
    1103             : 
    1104           0 :                 SdrTextObj* pTextObj = GetTextObj();
    1105           0 :                 if( pTextObj )
    1106             :                 {
    1107           0 :                     OutlinerParaObject* pOPO = pTextObj->GetOutlinerParaObject();
    1108           0 :                     if( ( pOPO && pOPO->IsVertical() ) || (nSlotId == SID_ATTR_CHAR_VERTICAL) || (nSlotId == SID_TEXT_FITTOSIZE_VERTICAL) )
    1109           0 :                         pOutl->SetVertical( sal_True );
    1110             : 
    1111           0 :                     if( pTextObj->getTextCount() > 1 )
    1112             :                     {
    1113           0 :                         Point aPix(rMEvt.GetPosPixel());
    1114           0 :                         Point aPnt(mpWindow->PixelToLogic(aPix));
    1115           0 :                         pTextObj->setActiveText( pTextObj->CheckTextHit(aPnt ) );
    1116             :                     }
    1117             : 
    1118           0 :                     if (mpView->SdrBeginTextEdit(pTextObj, pPV, mpWindow, sal_True, pOutl) && mxTextObj->GetObjInventor() == SdrInventor)
    1119             :                     {
    1120           0 :                         bFirstObjCreated = sal_True;
    1121           0 :                         DeleteDefaultText();
    1122             : 
    1123           0 :                         OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
    1124             : 
    1125           0 :                         nSdrObjKind = mxTextObj->GetObjIdentifier();
    1126             : 
    1127           0 :                         SdrViewEvent aVEvt;
    1128           0 :                         SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
    1129             : 
    1130           0 :                         if (eHit == SDRHIT_TEXTEDIT)
    1131             :                         {
    1132             :                             // Text getroffen
    1133           0 :                             if (nSdrObjKind == OBJ_TEXT ||
    1134             :                                 nSdrObjKind == OBJ_TITLETEXT ||
    1135             :                                 nSdrObjKind == OBJ_OUTLINETEXT ||
    1136             :                                 nSdrObjKind == OBJ_TABLE ||
    1137             :                                 nSlotId == SID_TEXTEDIT ||
    1138             :                                 !bQuickDrag)
    1139             :                             {
    1140           0 :                                 pOLV->MouseButtonDown(rMEvt);
    1141           0 :                                 pOLV->MouseMove(rMEvt);
    1142           0 :                                 pOLV->MouseButtonUp(rMEvt);
    1143             :                             }
    1144             : 
    1145           0 :                             if (mpViewShell->GetFrameView()->IsQuickEdit() && bQuickDrag && GetTextObj()->GetOutlinerParaObject())
    1146             :                             {
    1147           0 :                                 pOLV->MouseButtonDown(rMEvt);
    1148             :                             }
    1149             :                         }
    1150             :                         else
    1151             :                         {
    1152             :                             // Move cursor to end of text
    1153           0 :                             ESelection aNewSelection(EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND);
    1154           0 :                             pOLV->SetSelection(aNewSelection);
    1155           0 :                         }
    1156             :                     }
    1157             :                     else
    1158             :                     {
    1159           0 :                         mpView->RestoreDefaultText(dynamic_cast< SdrTextObj* >( mxTextObj.get() ));
    1160             :                     }
    1161             :                 }
    1162             :             }
    1163             :         }
    1164             :     }
    1165             :     else
    1166             :     {
    1167           0 :         mxTextObj.reset(0);
    1168             :     }
    1169           0 : }
    1170             : 
    1171             : /*************************************************************************
    1172             : |*
    1173             : |* Texteingabe wird gestartet, ggf. Default-Text loeschen
    1174             : |*
    1175             : \************************************************************************/
    1176             : 
    1177           0 : sal_Bool FuText::DeleteDefaultText()
    1178             : {
    1179           0 :     sal_Bool bDeleted = sal_False;
    1180             : 
    1181           0 :     if ( mxTextObj.is() && mxTextObj->IsEmptyPresObj() )
    1182             :     {
    1183           0 :         String aString;
    1184           0 :         SdPage* pPage = (SdPage*) mxTextObj->GetPage();
    1185             : 
    1186           0 :         if (pPage)
    1187             :         {
    1188           0 :             PresObjKind ePresObjKind = pPage->GetPresObjKind(mxTextObj.get());
    1189             : 
    1190           0 :             if ( (ePresObjKind == PRESOBJ_TITLE   ||
    1191             :                   ePresObjKind == PRESOBJ_OUTLINE ||
    1192             :                   ePresObjKind == PRESOBJ_NOTES   ||
    1193             :                   ePresObjKind == PRESOBJ_TEXT) &&
    1194           0 :                   !pPage->IsMasterPage() )
    1195             :             {
    1196           0 :                 ::Outliner* pOutliner = mpView->GetTextEditOutliner();
    1197           0 :                 SfxStyleSheet* pSheet = pOutliner->GetStyleSheet( 0 );
    1198           0 :                 sal_Bool bIsUndoEnabled = pOutliner->IsUndoEnabled();
    1199           0 :                 if( bIsUndoEnabled )
    1200           0 :                     pOutliner->EnableUndo(sal_False);
    1201             : 
    1202           0 :                 pOutliner->SetText( String(), pOutliner->GetParagraph( 0 ) );
    1203             : 
    1204           0 :                 if( bIsUndoEnabled )
    1205           0 :                     pOutliner->EnableUndo(sal_True);
    1206             : 
    1207           0 :                 if (pSheet &&
    1208             :                     (ePresObjKind == PRESOBJ_NOTES || ePresObjKind == PRESOBJ_TEXT))
    1209           0 :                     pOutliner->SetStyleSheet(0, pSheet);
    1210             : 
    1211           0 :                 mxTextObj->SetEmptyPresObj(sal_True);
    1212           0 :                 bDeleted = sal_True;
    1213             :             }
    1214           0 :         }
    1215             :     }
    1216             : 
    1217           0 :     return(bDeleted);
    1218             : }
    1219             : 
    1220             : /*************************************************************************
    1221             : |*
    1222             : |* Command-event
    1223             : |*
    1224             : \************************************************************************/
    1225             : 
    1226           0 : sal_Bool FuText::Command(const CommandEvent& rCEvt)
    1227             : {
    1228           0 :     return( FuPoor::Command(rCEvt) );
    1229             : }
    1230             : 
    1231             : /*************************************************************************
    1232             : |*
    1233             : |* Help-event
    1234             : |*
    1235             : \************************************************************************/
    1236             : 
    1237           0 : sal_Bool FuText::RequestHelp(const HelpEvent& rHEvt)
    1238             : {
    1239           0 :     sal_Bool bReturn = sal_False;
    1240             : 
    1241           0 :     OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
    1242             : 
    1243           0 :     if ((Help::IsBalloonHelpEnabled() || Help::IsQuickHelpEnabled()) &&
    1244           0 :         mxTextObj.is() && pOLV && pOLV->GetFieldUnderMousePointer())
    1245             :     {
    1246           0 :         String aHelpText;
    1247           0 :         const SvxFieldItem* pFieldItem = pOLV->GetFieldUnderMousePointer();
    1248           0 :         const SvxFieldData* pField = pFieldItem->GetField();
    1249             : 
    1250           0 :         if (pField && pField->ISA(SvxURLField))
    1251             :         {
    1252             :             /******************************************************************
    1253             :             * URL-Field
    1254             :             ******************************************************************/
    1255           0 :             aHelpText = INetURLObject::decode( ((const SvxURLField*)pField)->GetURL(), '%', INetURLObject::DECODE_WITH_CHARSET );
    1256             :         }
    1257           0 :         if (aHelpText.Len())
    1258             :         {
    1259           0 :             Rectangle aLogicPix = mpWindow->LogicToPixel(mxTextObj->GetLogicRect());
    1260           0 :             Rectangle aScreenRect(mpWindow->OutputToScreenPixel(aLogicPix.TopLeft()),
    1261           0 :                                   mpWindow->OutputToScreenPixel(aLogicPix.BottomRight()));
    1262             : 
    1263           0 :             if (Help::IsBalloonHelpEnabled())
    1264             :             {
    1265           0 :                 bReturn = Help::ShowBalloon( (Window*)mpWindow, rHEvt.GetMousePosPixel(), aScreenRect, aHelpText);
    1266             :             }
    1267           0 :             else if (Help::IsQuickHelpEnabled())
    1268             :             {
    1269           0 :                 bReturn = Help::ShowQuickHelp( (Window*)mpWindow, aScreenRect, aHelpText);
    1270             :             }
    1271           0 :         }
    1272             :     }
    1273             : 
    1274           0 :     if (!bReturn)
    1275             :     {
    1276           0 :         bReturn = FuConstruct::RequestHelp(rHEvt);
    1277             :     }
    1278             : 
    1279           0 :     return(bReturn);
    1280             : }
    1281             : 
    1282             : /*************************************************************************
    1283             : |*
    1284             : |* Request verarbeiten
    1285             : |*
    1286             : \************************************************************************/
    1287             : 
    1288           0 : void FuText::ReceiveRequest(SfxRequest& rReq)
    1289             : {
    1290           0 :     nSlotId = rReq.GetSlot();
    1291             : 
    1292             :     // Dann Basisklasse rufen (dort wird u.a. nSlotId NICHT gesetzt)
    1293           0 :     FuPoor::ReceiveRequest(rReq);
    1294             : 
    1295           0 :     if (nSlotId == SID_TEXTEDIT || mpViewShell->GetFrameView()->IsQuickEdit() || SID_ATTR_CHAR == nSlotId)
    1296             :     {
    1297           0 :         MouseEvent aMEvt(mpWindow->GetPointerPosPixel());
    1298             : 
    1299           0 :         mxTextObj.reset(0);
    1300             : 
    1301           0 :         if (nSlotId == SID_TEXTEDIT)
    1302             :         {
    1303             :             // Wird gerade editiert?
    1304           0 :             if(!bTestText)
    1305           0 :                 mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetTextEditObject() ) );
    1306             : 
    1307           0 :             if (!mxTextObj.is())
    1308             :             {
    1309             :                 // Try to select an object
    1310           0 :                 SdrPageView* pPV = mpView->GetSdrPageView();
    1311           0 :                 SdrViewEvent aVEvt;
    1312           0 :                 mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
    1313           0 :                 mpView->MarkObj(aVEvt.pRootObj, pPV);
    1314             : 
    1315           0 :                 if (aVEvt.pObj && aVEvt.pObj->ISA(SdrTextObj))
    1316             :                 {
    1317           0 :                     mxTextObj.reset( static_cast< SdrTextObj* >( aVEvt.pObj ) );
    1318           0 :                 }
    1319             :             }
    1320             :         }
    1321           0 :         else if (mpView->AreObjectsMarked())
    1322             :         {
    1323           0 :             const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
    1324             : 
    1325           0 :             if (rMarkList.GetMarkCount() == 1)
    1326             :             {
    1327           0 :                 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
    1328             : 
    1329           0 :                 if (pObj->ISA(SdrTextObj))
    1330             :                 {
    1331           0 :                     mxTextObj.reset( static_cast< SdrTextObj* >( pObj ) );
    1332             :                 }
    1333             :             }
    1334             :         }
    1335             : 
    1336           0 :         sal_Bool bQuickDrag = sal_True;
    1337             : 
    1338           0 :         const SfxItemSet* pArgs = rReq.GetArgs();
    1339             : 
    1340           0 :         if (pArgs
    1341             : 
    1342             :             // test for type before using
    1343             :             && SID_TEXTEDIT == nSlotId
    1344           0 :             && SFX_ITEM_SET == pArgs->GetItemState(SID_TEXTEDIT)
    1345             : 
    1346           0 :             && (sal_uInt16) ((SfxUInt16Item&) pArgs->Get(SID_TEXTEDIT)).GetValue() == 2)
    1347             :         {
    1348             :             // Anwahl per Doppelklick -> kein QuickDrag zulassen
    1349           0 :             bQuickDrag = sal_False;
    1350             :         }
    1351             : 
    1352           0 :         SetInEditMode(aMEvt, bQuickDrag);
    1353             :     }
    1354           0 : }
    1355             : 
    1356           0 : void FuText::DoubleClick(const MouseEvent& )
    1357             : {
    1358             :     // Nothing to do
    1359           0 : }
    1360             : 
    1361             : /** Removed the insertion of default text and putting a new text
    1362             :     object directly into edit mode.
    1363             : */
    1364           0 : SdrObject* FuText::CreateDefaultObject(const sal_uInt16 nID, const Rectangle& rRectangle)
    1365             : {
    1366             : 
    1367             :     SdrObject* pObj = SdrObjFactory::MakeNewObject(
    1368           0 :         mpView->GetCurrentObjInventor(), mpView->GetCurrentObjIdentifier(),
    1369           0 :         0L, mpDoc);
    1370             : 
    1371           0 :     if(pObj)
    1372             :     {
    1373           0 :         if(pObj->ISA(SdrTextObj))
    1374             :         {
    1375           0 :             SdrTextObj* pText = (SdrTextObj*)pObj;
    1376           0 :             pText->SetLogicRect(rRectangle);
    1377             : 
    1378           0 :             sal_Bool bVertical = (SID_ATTR_CHAR_VERTICAL == nID || SID_TEXT_FITTOSIZE_VERTICAL == nID);
    1379           0 :             pText->SetVerticalWriting(bVertical);
    1380             : 
    1381           0 :             ImpSetAttributesForNewTextObject(pText);
    1382             : 
    1383           0 :             if (nSlotId == SID_TEXT_FITTOSIZE)
    1384             :             {
    1385           0 :                 ImpSetAttributesFitToSize(pText);
    1386             :             }
    1387           0 :             else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL )
    1388             :             {
    1389           0 :                 ImpSetAttributesFitToSizeVertical(pText);
    1390             :             }
    1391             :             else
    1392             :             {
    1393           0 :                 ImpSetAttributesFitCommon(pText);
    1394             :             }
    1395             : 
    1396             :             // Put text object into edit mode.
    1397           0 :             SdrPageView* pPV = mpView->GetSdrPageView();
    1398           0 :             mpView->SdrBeginTextEdit(pText, pPV);
    1399             :         }
    1400             :         else
    1401             :         {
    1402             :             OSL_FAIL("Object is NO text object");
    1403             :         }
    1404             :     }
    1405             : 
    1406           0 :     return pObj;
    1407             : }
    1408             : 
    1409             : 
    1410             : 
    1411             : 
    1412             : /** is called when the currenct function should be aborted. <p>
    1413             :     This is used when a function gets a KEY_ESCAPE but can also
    1414             :     be called directly.
    1415             : 
    1416             :     @returns true if a active function was aborted
    1417             : */
    1418           0 : bool FuText::cancel()
    1419             : {
    1420           0 :     if ( mpView->IsTextEdit() )
    1421             :     {
    1422           0 :         if(mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED)
    1423           0 :             mxTextObj.reset(0);
    1424             : 
    1425           0 :         mpView->SetCurrentObj(OBJ_TEXT);
    1426           0 :         mpView->SetEditMode(SDREDITMODE_EDIT);
    1427           0 :         return true;
    1428             :     }
    1429             :     else
    1430             :     {
    1431           0 :         return false;
    1432             :     }
    1433             : }
    1434             : 
    1435           0 : void FuText::ChangeFontSize( bool bGrow, OutlinerView* pOLV, const FontList* pFontList, ::sd::View* pView )
    1436             : {
    1437           0 :     if( !pFontList || !pView )
    1438           0 :         return;
    1439             : 
    1440           0 :     if( pOLV )
    1441             :     {
    1442           0 :         pOLV->GetEditView().ChangeFontSize( bGrow, pFontList );
    1443             :     }
    1444             :     else
    1445             :     {
    1446             : 
    1447           0 :         const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
    1448           0 :         for( sal_uInt32 nMark = 0; nMark < rMarkList.GetMarkCount(); nMark++ )
    1449             :         {
    1450           0 :             SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( rMarkList.GetMark(nMark)->GetMarkedSdrObj() );
    1451           0 :             if( pTextObj )
    1452             :             {
    1453           0 :                 for( sal_Int32 nText = 0; nText < pTextObj->getTextCount(); nText++ )
    1454             :                 {
    1455           0 :                     pTextObj->setActiveText( nText );
    1456             : 
    1457             :                     // Put text object into edit mode.
    1458           0 :                     SdrPageView* pPV = pView->GetSdrPageView();
    1459           0 :                     pView->SdrBeginTextEdit(pTextObj, pPV);
    1460             : 
    1461           0 :                     pOLV = pView->GetTextEditOutlinerView();
    1462           0 :                     if( pOLV )
    1463             :                     {
    1464           0 :                         EditEngine* pEditEngine = pOLV->GetEditView().GetEditEngine();
    1465           0 :                         if( pEditEngine )
    1466             :                         {
    1467           0 :                             ESelection aSel;
    1468           0 :                             aSel.nEndPara = pEditEngine->GetParagraphCount()-1;
    1469           0 :                             aSel.nEndPos = pEditEngine->GetTextLen(aSel.nEndPara);
    1470           0 :                             pOLV->SetSelection(aSel);
    1471             :                         }
    1472             : 
    1473           0 :                         ChangeFontSize( bGrow, pOLV, pFontList, pView );
    1474             :                     }
    1475             : 
    1476           0 :                     pView->SdrEndTextEdit();
    1477             :                 }
    1478             : 
    1479           0 :                 SfxItemSet aShapeSet( pTextObj->GetMergedItemSet() );
    1480           0 :                 if( EditView::ChangeFontSize( bGrow, aShapeSet, pFontList ) )
    1481             :                 {
    1482           0 :                     pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT ) );
    1483           0 :                     pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CJK ) );
    1484           0 :                     pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CTL ) );
    1485           0 :                 }
    1486             :             }
    1487             :         }
    1488             :     }
    1489             : }
    1490             : 
    1491           9 : } // end of namespace sd
    1492             : 
    1493             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10