LCOV - code coverage report
Current view: top level - libreoffice/sw/source/ui/shells - basesh.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 19 1417 1.3 %
Date: 2012-12-27 Functions: 10 42 23.8 %
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             : 
      21             : #include <sot/factory.hxx>
      22             : #include <hintids.hxx>
      23             : #include <svl/urihelper.hxx>
      24             : #include <svl/languageoptions.hxx>
      25             : 
      26             : #include <svx/svxids.hrc>
      27             : #include <sfx2/linkmgr.hxx>
      28             : #include <svx/htmlmode.hxx>
      29             : #include <svx/imapdlg.hxx>
      30             : #include <sfx2/dispatch.hxx>
      31             : #include <sfx2/docfile.hxx>
      32             : #include <sfx2/viewfrm.hxx>
      33             : #include <sfx2/request.hxx>
      34             : #include <svl/whiter.hxx>
      35             : #include <svl/visitem.hxx>
      36             : #include <sfx2/objitem.hxx>
      37             : #include <svtools/filter.hxx>
      38             : #include <svx/gallery.hxx>
      39             : #include <editeng/langitem.hxx>
      40             : #include <svx/clipfmtitem.hxx>
      41             : #include <svx/contdlg.hxx>
      42             : #include <vcl/graph.hxx>
      43             : #include <svl/slstitm.hxx>
      44             : #include <vcl/msgbox.hxx>
      45             : #include <svl/ptitem.hxx>
      46             : #include <svl/itemiter.hxx>
      47             : #include <svl/stritem.hxx>
      48             : #include <editeng/colritem.hxx>
      49             : #include <editeng/shaditem.hxx>
      50             : #include <editeng/boxitem.hxx>
      51             : #include <svl/srchitem.hxx>
      52             : #include <editeng/ulspitem.hxx>
      53             : #include <editeng/lrspitem.hxx>
      54             : #include <editeng/brshitem.hxx>
      55             : #include <editeng/opaqitem.hxx>
      56             : #include <editeng/sizeitem.hxx>
      57             : #include <svx/flagsdef.hxx>
      58             : #include <editeng/scripttypeitem.hxx>
      59             : #include <sfx2/objface.hxx>
      60             : #include <fmturl.hxx>
      61             : #include <fmthdft.hxx>
      62             : #include <fmtclds.hxx>
      63             : #include <docsh.hxx>
      64             : #include <wrtsh.hxx>
      65             : #include <view.hxx>
      66             : #include <swmodule.hxx>
      67             : #include <swundo.hxx>
      68             : #include <fldbas.hxx>
      69             : #include <uitool.hxx>
      70             : #include <basesh.hxx>
      71             : #include <viewopt.hxx>
      72             : #include <fontcfg.hxx>
      73             : #include <docstat.hxx>
      74             : #include <usrfld.hxx>
      75             : #include <expfld.hxx>
      76             : #include <fldmgr.hxx>
      77             : #include <frmmgr.hxx>
      78             : #include <tablemgr.hxx>
      79             : #include <mdiexp.hxx>
      80             : #include <swdtflvr.hxx>
      81             : #include <pagedesc.hxx>
      82             : #include <convert.hxx>
      83             : #include <fmtcol.hxx>
      84             : #include <edtwin.hxx>
      85             : #include <tblafmt.hxx>
      86             : #include <caption.hxx>
      87             : #include <swwait.hxx>
      88             : #include <cmdid.h>
      89             : #include <globals.hrc>
      90             : #include <shells.hrc>
      91             : #include <statstr.hrc>
      92             : #include <globals.h>
      93             : #include <unotxdoc.hxx>
      94             : #include <crsskip.hxx>
      95             : #include <fmtinfmt.hxx>
      96             : #include <doc.hxx>
      97             : 
      98             : #include "swabstdlg.hxx"
      99             : #include "dialog.hrc"
     100             : #include "fldui.hrc"
     101             : #include "table.hrc"
     102             : #include <modcfg.hxx>
     103             : #include <instable.hxx>
     104             : #include <svx/fmshell.hxx> // for FN_XFORMS_DESIGN_MODE
     105             : #include <SwRewriter.hxx>
     106             : #include <comcore.hrc>
     107             : 
     108             : #include <unomid.h>
     109             : 
     110             : FlyMode SwBaseShell::eFrameMode = FLY_DRAG_END;
     111             : 
     112             : //Fuer die Erkennung der Id, die variable von Gallery mit SID_GALLERY_BG_BRUSH
     113             : //ankommt.
     114             : static sal_uInt8 nParagraphPos;
     115             : static sal_uInt8 nGraphicPos;
     116             : static sal_uInt8 nOlePos;
     117             : static sal_uInt8 nFramePos;
     118             : static sal_uInt8 nTablePos;
     119             : static sal_uInt8 nTableRowPos;
     120             : static sal_uInt8 nTableCellPos;
     121             : static sal_uInt8 nPagePos;
     122             : static sal_uInt8 nHeaderPos;
     123             : static sal_uInt8 nFooterPos;
     124             : 
     125             : #define SwBaseShell
     126             : #define Shadow
     127             : #include <sfx2/msg.hxx>
     128             : #include "swslots.hxx"
     129             : 
     130             : #define SWCONTOURDLG(rView) ( (SvxContourDlg*) ( rView.GetViewFrame()->GetChildWindow(  \
     131             :                           SvxContourDlgChildWindow::GetChildWindowId() )->  \
     132             :                           GetWindow() ) )
     133             : 
     134             : #define SWIMAPDLG(rView) ( (SvxIMapDlg*) ( rView.GetViewFrame()->GetChildWindow(        \
     135             :                         SvxIMapDlgChildWindow::GetChildWindowId() )->   \
     136             :                         GetWindow() ) )
     137             : 
     138             : 
     139             : using namespace ::com::sun::star;
     140             : using namespace ::com::sun::star::uno;
     141             : using namespace ::com::sun::star::frame;
     142             : using namespace ::com::sun::star::lang;
     143             : 
     144         150 : SFX_IMPL_INTERFACE(SwBaseShell, SfxShell, SW_RES(0))
     145             : {
     146          10 :     SFX_CHILDWINDOW_REGISTRATION(SvxIMapDlgChildWindow::GetChildWindowId());
     147          10 :     SFX_CHILDWINDOW_REGISTRATION(SvxContourDlgChildWindow::GetChildWindowId());
     148          10 : }
     149             : 
     150        6172 : TYPEINIT1(SwBaseShell,SfxShell)
     151             : 
     152             : /*--------------------------------------------------------------------
     153             :     Beschreibung:   statics
     154             :  --------------------------------------------------------------------*/
     155           0 : static void lcl_UpdateIMapDlg( SwWrtShell& rSh )
     156             : {
     157           0 :     Graphic aGrf( rSh.GetIMapGraphic() );
     158           0 :     GraphicType nGrfType = aGrf.GetType();
     159             :     void* pEditObj = GRAPHIC_NONE != nGrfType && GRAPHIC_DEFAULT != nGrfType
     160           0 :                         ? rSh.GetIMapInventor() : 0;
     161           0 :     TargetList* pList = new TargetList;
     162           0 :     rSh.GetView().GetViewFrame()->GetTopFrame().GetTargetList(*pList);
     163             : 
     164           0 :     SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
     165           0 :     rSh.GetFlyFrmAttr( aSet );
     166           0 :     const SwFmtURL &rURL = (SwFmtURL&)aSet.Get( RES_URL );
     167             :     SvxIMapDlgChildWindow::UpdateIMapDlg(
     168           0 :             aGrf, rURL.GetMap(), pList, pEditObj );
     169             : 
     170           0 :     for ( size_t i = 0, n = pList->size(); i < n; ++i )
     171           0 :         delete pList->at( i );
     172           0 :     delete pList;
     173           0 : }
     174             : 
     175           0 : static sal_Bool lcl_UpdateContourDlg( SwWrtShell &rSh, int nSel )
     176             : {
     177           0 :     Graphic aGraf( rSh.GetIMapGraphic() );
     178           0 :     GraphicType nGrfType = aGraf.GetType();
     179           0 :     sal_Bool bRet = GRAPHIC_NONE != nGrfType && GRAPHIC_DEFAULT != nGrfType;
     180           0 :     if( bRet )
     181             :     {
     182           0 :         String aGrfName;
     183           0 :         if ( nSel & nsSelectionType::SEL_GRF )
     184           0 :             rSh.GetGrfNms( &aGrfName, 0 );
     185             : 
     186           0 :         SvxContourDlg *pDlg = SWCONTOURDLG(rSh.GetView());
     187           0 :         pDlg->Update( aGraf, aGrfName.Len() > 0,
     188           0 :                   rSh.GetGraphicPolygon(), rSh.GetIMapInventor() );
     189             :     }
     190           0 :     return bRet;
     191             : }
     192             : 
     193             : /*--------------------------------------------------------------------
     194             :     Beschreibung:   loeschen
     195             :  --------------------------------------------------------------------*/
     196           0 : void SwBaseShell::ExecDelete(SfxRequest &rReq)
     197             : {
     198           0 :     SwWrtShell &rSh = GetShell();
     199           0 :     SwEditWin& rTmpEditWin = GetView().GetEditWin();
     200           0 :     switch(rReq.GetSlot())
     201             :     {
     202             :         case SID_DELETE:
     203           0 :             rSh.DelRight();
     204           0 :             break;
     205             : 
     206             :         case FN_BACKSPACE:
     207             : 
     208           0 :             if( rSh.IsNoNum() )
     209             :             {
     210           0 :                 rSh.SttCrsrMove();
     211           0 :                 sal_Bool bLeft = rSh.Left( CRSR_SKIP_CHARS, sal_True, 1, sal_False  );
     212           0 :                 if( bLeft )
     213             :                 {
     214           0 :                     rSh.DelLeft();
     215             :                 }
     216             :                 else
     217             :                     // JP 15.07.96: wenns nicht mehr nach vorne geht, die
     218             :                     //              Numerierung aufheben. Z.B. am Doc-/
     219             :                     //              Rahmen-/Tabellen-/Bereichs-Anfang
     220           0 :                     rSh.DelNumRules();
     221             : 
     222           0 :                 rSh.EndCrsrMove();
     223           0 :                 break;
     224             :             }
     225             : 
     226             :             // ansonsten DelLeft rufen
     227             :         case FN_SHIFT_BACKSPACE:
     228           0 :             rSh.DelLeft();
     229           0 :             break;
     230             :         default:
     231             :             OSL_FAIL("wrong Dispatcher");
     232           0 :             return;
     233             :     }
     234           0 :     rReq.Done();
     235             : 
     236             :     //#i42732# - notify the edit window that from now on we do not use the input language
     237           0 :     rTmpEditWin.SetUseInputLanguage( sal_False );
     238             : }
     239             : 
     240           0 : void SwBaseShell::ExecClpbrd(SfxRequest &rReq)
     241             : {
     242             :     //Achtung: Suizid gefaehrdet! Nach Paste, Paste special kann der die
     243             :     //Shell zerstoert sein.
     244             : 
     245             : 
     246           0 :     SwWrtShell &rSh = GetShell();
     247           0 :     sal_uInt16 nId = rReq.GetSlot();
     248           0 :     sal_Bool bIgnore = sal_False;
     249           0 :     switch( nId )
     250             :     {
     251             :         case SID_CUT:
     252             :         case SID_COPY:
     253           0 :             rView.GetEditWin().FlushInBuffer();
     254           0 :             if ( rSh.HasSelection() )
     255             :             {
     256           0 :                 SwTransferable* pTransfer = new SwTransferable( rSh );
     257           0 : /*??*/          uno::Reference< datatransfer::XTransferable > xRef( pTransfer );
     258             : 
     259           0 :                 if ( nId == SID_CUT && !rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT) )
     260           0 :                     pTransfer->Cut();
     261             :                 else
     262             :                 {
     263           0 :                     const sal_Bool bLockedView = rSh.IsViewLocked();
     264           0 :                     rSh.LockView( sal_True );    //lock visible section
     265           0 :                     pTransfer->Copy();
     266           0 :                     rSh.LockView( bLockedView );
     267             :                 }
     268           0 :                 break;
     269             :             }
     270           0 :             return;
     271             : 
     272             :         case SID_PASTE:
     273             :             {
     274             :                 TransferableDataHelper aDataHelper(
     275             :                         TransferableDataHelper::CreateFromSystemClipboard(
     276           0 :                                         &rSh.GetView().GetEditWin() ) );
     277             : 
     278           0 :                 if( aDataHelper.GetXTransferable().is() &&
     279           0 :                     SwTransferable::IsPaste( rSh, aDataHelper ))
     280             :                 {
     281             :                     // temp. Variablen, da die Shell nach dem Paste schon
     282             :                     // zerstoert sein kann
     283           0 :                     SwView* pView = &rView;
     284           0 :                     SwTransferable::Paste( rSh, aDataHelper );
     285           0 :                     if( rSh.IsFrmSelected() || rSh.IsObjSelected() )
     286           0 :                         rSh.EnterSelFrmMode();
     287           0 :                     pView->AttrChangedNotify( &rSh );
     288             :                 }
     289             :                 else
     290           0 :                     return;
     291             :             }
     292           0 :             break;
     293             : 
     294             :         case SID_CLIPBOARD_FORMAT_ITEMS:
     295             :             {
     296           0 :                 const SfxItemSet* pArgs = rReq.GetArgs();
     297             :                 const SfxPoolItem* pFmt;
     298           0 :                 if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( nId, sal_False, &pFmt ) )
     299             :                 {
     300             :                     TransferableDataHelper aDataHelper(
     301             :                         TransferableDataHelper::CreateFromSystemClipboard(
     302           0 :                                             &rSh.GetView().GetEditWin()) );
     303           0 :                     if( aDataHelper.GetXTransferable().is()
     304             :                         /*&& SwTransferable::IsPaste( rSh, aDataHelper )*/ )
     305             :                     {
     306             :                         // temp. Variablen, da die Shell nach dem Paste schon
     307             :                         // zerstoert sein kann
     308           0 :                         SwView* pView = &rView;
     309             : 
     310             :                         SwTransferable::PasteFormat( rSh, aDataHelper,
     311           0 :                                         ((SfxUInt32Item*)pFmt)->GetValue() );
     312             : 
     313             :                         //Done() has to be called before the shell has been removed
     314           0 :                         rReq.Done();
     315           0 :                         bIgnore = sal_True;
     316           0 :                         if( rSh.IsFrmSelected() || rSh.IsObjSelected())
     317           0 :                             rSh.EnterSelFrmMode();
     318           0 :                         pView->AttrChangedNotify( &rSh );
     319           0 :                     }
     320             :                 }
     321             :             }
     322           0 :             break;
     323             : 
     324             :         case SID_PASTE_UNFORMATTED:
     325             :             {
     326             :                 TransferableDataHelper aDataHelper(
     327             :                     TransferableDataHelper::CreateFromSystemClipboard(
     328           0 :                         &rSh.GetView().GetEditWin()) );
     329           0 :                 if( aDataHelper.GetXTransferable().is() &&
     330           0 :                     SwTransferable::IsPaste( rSh, aDataHelper ))
     331             :                 {
     332             :                     // temp. Variablen, da die Shell nach dem Paste schon
     333             :                     // zerstoert sein kann
     334           0 :                     SwView* pView = &rView;
     335           0 :                     rReq.Ignore();
     336           0 :                     bIgnore = sal_True;
     337           0 :                     int nRet = SwTransferable::PasteUnformatted( rSh, aDataHelper );
     338           0 :                     if(nRet)
     339             :                     {
     340           0 :                         SfxViewFrame* pViewFrame = pView->GetViewFrame();
     341             :                         uno::Reference< frame::XDispatchRecorder > xRecorder =
     342           0 :                             pViewFrame->GetBindings().GetRecorder();
     343           0 :                         if(xRecorder.is()) {
     344           0 :                             SfxRequest aReq( pViewFrame, SID_CLIPBOARD_FORMAT_ITEMS );
     345           0 :                             aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, SOT_FORMAT_STRING ) );
     346           0 :                             aReq.Done();
     347           0 :                         }
     348             :                     }
     349             : 
     350           0 :                     if (rSh.IsFrmSelected() || rSh.IsObjSelected())
     351           0 :                         rSh.EnterSelFrmMode();
     352           0 :                     pView->AttrChangedNotify( &rSh );
     353             :                 }
     354             :                 else
     355           0 :                     return;
     356             :             }
     357           0 :             break;
     358             : 
     359             :         case SID_PASTE_SPECIAL:
     360             :             {
     361             :                 TransferableDataHelper aDataHelper(
     362             :                         TransferableDataHelper::CreateFromSystemClipboard(
     363           0 :                                         &rSh.GetView().GetEditWin()) );
     364           0 :                 if( aDataHelper.GetXTransferable().is() &&
     365           0 :                     SwTransferable::IsPaste( rSh, aDataHelper ))
     366             :                 {
     367             :                     // temp. Variablen, da die Shell nach dem Paste schon
     368             :                     // zerstoert sein kann
     369           0 :                     SwView* pView = &rView;
     370           0 :                     sal_uLong nFormatId = 0;
     371           0 :                     rReq.Ignore();
     372           0 :                     bIgnore = sal_True;
     373           0 :                     int nRet = SwTransferable::PasteSpecial( rSh, aDataHelper, nFormatId );
     374           0 :                     if(nRet)
     375             :                     {
     376           0 :                         SfxViewFrame* pViewFrame = pView->GetViewFrame();
     377             :                         uno::Reference< frame::XDispatchRecorder > xRecorder =
     378           0 :                                 pViewFrame->GetBindings().GetRecorder();
     379           0 :                         if(xRecorder.is()) {
     380           0 :                             SfxRequest aReq( pViewFrame, SID_CLIPBOARD_FORMAT_ITEMS );
     381           0 :                             aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, nFormatId ) );
     382           0 :                             aReq.Done();
     383           0 :                         }
     384             :                     }
     385             : 
     386           0 :                     if (rSh.IsFrmSelected() || rSh.IsObjSelected())
     387           0 :                         rSh.EnterSelFrmMode();
     388           0 :                     pView->AttrChangedNotify( &rSh );
     389             :                 }
     390             :                 else
     391           0 :                     return;
     392             :             }
     393           0 :             break;
     394             :         default:
     395             :             OSL_FAIL("wrong Dispatcher");
     396           0 :             return;
     397             :     }
     398           0 :     if(!bIgnore)
     399           0 :         rReq.Done();
     400             : }
     401             : 
     402             : /*--------------------------------------------------------------------
     403             :     Beschreibung:   ClipBoard-Status
     404             :  --------------------------------------------------------------------*/
     405           0 : void SwBaseShell::StateClpbrd(SfxItemSet &rSet)
     406             : {
     407           0 :     SwWrtShell &rSh = GetShell();
     408           0 :     SfxWhichIter aIter(rSet);
     409             : 
     410           0 :     const sal_Bool bCopy = rSh.HasSelection();
     411             : 
     412           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
     413             : 
     414           0 :     while(nWhich)
     415             :     {
     416           0 :         switch(nWhich)
     417             :         {
     418             :         case SID_CUT:
     419           0 :             if( 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) )
     420             :             {
     421           0 :                 rSet.DisableItem( nWhich );
     422           0 :                 break;
     423             :             }
     424             :         case SID_COPY:
     425           0 :             if( !bCopy )
     426           0 :                 rSet.DisableItem( nWhich );
     427           0 :             break;
     428             : 
     429             :         case SID_PASTE:
     430           0 :             if( !GetView().IsPasteAllowed() )
     431           0 :                 rSet.DisableItem( SID_PASTE );
     432           0 :             break;
     433             : 
     434             :         case SID_PASTE_SPECIAL:
     435           0 :             if( !GetView().IsPasteSpecialAllowed() )
     436             :             {
     437           0 :                 rSet.DisableItem( SID_PASTE_SPECIAL );
     438           0 :                 rSet.DisableItem( SID_PASTE_UNFORMATTED );
     439             :             }
     440           0 :             break;
     441             : 
     442             :         case SID_CLIPBOARD_FORMAT_ITEMS:
     443             :             {
     444             :                 TransferableDataHelper aDataHelper(
     445             :                     TransferableDataHelper::CreateFromSystemClipboard(
     446           0 :                                             &rSh.GetView().GetEditWin()) );
     447             : 
     448           0 :                 SvxClipboardFmtItem aFmtItem( nWhich );
     449           0 :                 SwTransferable::FillClipFmtItem( rSh, aDataHelper, aFmtItem );
     450           0 :                 rSet.Put( aFmtItem );
     451             :             }
     452           0 :             break;
     453             :         }
     454           0 :         nWhich = aIter.NextWhich();
     455           0 :     }
     456           0 : }
     457             : 
     458             : /*--------------------------------------------------------------------
     459             :     Beschreibung:   Undo ausfuehren
     460             :  --------------------------------------------------------------------*/
     461           0 : void SwBaseShell::ExecUndo(SfxRequest &rReq)
     462             : {
     463           0 :     SwWrtShell &rSh = GetShell();
     464             : 
     465           0 :     sal_uInt16 nId = rReq.GetSlot(), nCnt = 1;
     466           0 :     const SfxItemSet* pArgs = rReq.GetArgs();
     467             :     const SfxPoolItem* pItem;
     468           0 :     if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( nId, sal_False, &pItem ))
     469           0 :         nCnt = ((SfxUInt16Item*)pItem)->GetValue();
     470             : 
     471             :     // #i106349#: save pointer: undo/redo may delete the shell, i.e., this!
     472           0 :     SfxViewFrame *const pViewFrame( GetView().GetViewFrame() );
     473             : 
     474           0 :     switch( nId )
     475             :     {
     476             :         case SID_UNDO:
     477           0 :             rSh.LockPaint();
     478           0 :             rSh.Do( SwWrtShell::UNDO, nCnt );
     479           0 :             rSh.UnlockPaint();
     480           0 :             break;
     481             : 
     482             :         case SID_REDO:
     483           0 :             rSh.LockPaint();
     484           0 :             rSh.Do( SwWrtShell::REDO, nCnt );
     485           0 :             rSh.UnlockPaint();
     486           0 :             break;
     487             : 
     488             :         case SID_REPEAT:
     489           0 :             rSh.Do( SwWrtShell::REPEAT );
     490           0 :             break;
     491             :         default:
     492             :             OSL_FAIL("wrong Dispatcher");
     493             :     }
     494             : 
     495           0 :     if (pViewFrame) { pViewFrame->GetBindings().InvalidateAll(sal_False); }
     496           0 : }
     497             : 
     498             : /*--------------------------------------------------------------------
     499             :     Beschreibung:   Zustand Undo
     500             :  --------------------------------------------------------------------*/
     501           0 : void SwBaseShell::StateUndo(SfxItemSet &rSet)
     502             : {
     503           0 :     SwWrtShell &rSh = GetShell();
     504           0 :     SfxWhichIter aIter(rSet);
     505           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
     506           0 :     while(nWhich)
     507             :     {
     508           0 :         switch(nWhich)
     509             :         {
     510             :             case SID_UNDO:
     511             :             {
     512           0 :                 if (rSh.GetLastUndoInfo(0, 0))
     513             :                 {
     514             :                     rSet.Put( SfxStringItem(nWhich,
     515           0 :                         rSh.GetDoString(SwWrtShell::UNDO)));
     516             :                 }
     517             :                 else
     518           0 :                     rSet.DisableItem(nWhich);
     519           0 :                 break;
     520             :             }
     521             :             case SID_REDO:
     522             :             {
     523           0 :                 if (rSh.GetFirstRedoInfo(0))
     524             :                 {
     525             :                     rSet.Put(SfxStringItem(nWhich,
     526           0 :                         rSh.GetDoString(SwWrtShell::REDO)));
     527             :                 }
     528             :                 else
     529           0 :                     rSet.DisableItem(nWhich);
     530           0 :                 break;
     531             :             }
     532             :             case SID_REPEAT:
     533             :             {   // Repeat nur moeglich wenn kein REDO moeglich - UI-Restriktion
     534           0 :                 if ((!rSh.GetFirstRedoInfo(0)) &&
     535           0 :                     !rSh.IsSelFrmMode() &&
     536           0 :                     (UNDO_EMPTY != rSh.GetRepeatInfo(0)))
     537             :                 {
     538           0 :                     rSet.Put(SfxStringItem(nWhich, rSh.GetRepeatString()));
     539             :                 }
     540             :                 else
     541           0 :                     rSet.DisableItem(nWhich);
     542           0 :                 break;
     543             :             }
     544             : 
     545             :             case SID_GETUNDOSTRINGS:
     546           0 :                 if (rSh.GetLastUndoInfo(0, 0))
     547             :                 {
     548           0 :                     SfxStringListItem aStrLst( nWhich );
     549           0 :                     rSh.GetDoStrings( SwWrtShell::UNDO, aStrLst );
     550           0 :                     rSet.Put( aStrLst );
     551             :                 }
     552             :                 else
     553           0 :                     rSet.DisableItem( nWhich );
     554           0 :                 break;
     555             : 
     556             :             case SID_GETREDOSTRINGS:
     557           0 :                 if (rSh.GetFirstRedoInfo(0))
     558             :                 {
     559           0 :                     SfxStringListItem aStrLst( nWhich );
     560           0 :                     rSh.GetDoStrings( SwWrtShell::REDO, aStrLst );
     561           0 :                     rSet.Put( aStrLst );
     562             :                 }
     563             :                 else
     564           0 :                     rSet.DisableItem( nWhich );
     565           0 :                 break;
     566             :         }
     567           0 :         nWhich = aIter.NextWhich();
     568           0 :     }
     569           0 : }
     570             : 
     571             : /*--------------------------------------------------------------------
     572             :     Beschreibung:   Slot-Id auswerten bzw. Dispatchen
     573             :  --------------------------------------------------------------------*/
     574           0 : void SwBaseShell::Execute(SfxRequest &rReq)
     575             : {
     576             :     const SfxPoolItem *pItem;
     577           0 :     SwWrtShell &rSh = GetShell();
     578           0 :     const SfxItemSet* pArgs = rReq.GetArgs();
     579           0 :     sal_Bool bMore = sal_False;
     580             : 
     581           0 :     sal_uInt16 nSlot = rReq.GetSlot();
     582           0 :     switch(nSlot)
     583             :     {
     584             :         case FN_REPAGINATE:
     585             :             {
     586           0 :                 Reference < XModel > xModel = GetView().GetDocShell()->GetModel();
     587           0 :                 Reference < XUnoTunnel > xDocTunnel ( xModel, UNO_QUERY );
     588           0 :                 SwXTextDocument *pDoc = reinterpret_cast < SwXTextDocument * > ( xDocTunnel->getSomething ( SwXTextDocument::getUnoTunnelId() ) );
     589           0 :                 pDoc->notifyRefreshListeners();
     590           0 :                 rSh.CalcLayout();
     591             :             }
     592           0 :             break;
     593             :         case FN_UPDATE_FIELDS:
     594             :             {
     595           0 :                 rSh.UpdateDocStat();
     596           0 :                 rSh.EndAllTblBoxEdit();
     597           0 :                 rSh.ViewShell::UpdateFlds(sal_True);
     598             : 
     599           0 :                 if( rSh.IsCrsrInTbl() )
     600             :                 {
     601           0 :                     if( !rSh.IsTblComplexForChart() )
     602           0 :                         SwTableFUNC( &rSh, sal_False).UpdateChart();
     603           0 :                     rSh.ClearTblBoxCntnt();
     604           0 :                     rSh.SaveTblBoxCntnt();
     605             :                 }
     606             :             }
     607           0 :             break;
     608             :         case FN_UPDATE_CHARTS:
     609             :             {
     610           0 :                 SwWait aWait( *rView.GetDocShell(), sal_True );
     611           0 :                 rSh.UpdateAllCharts();
     612             :             }
     613           0 :             break;
     614             : 
     615             :         case FN_UPDATE_ALL:
     616             :             {
     617           0 :                 SwView&  rTempView = GetView();
     618           0 :                 rSh.EnterStdMode();
     619           0 :                 if( !rSh.GetLinkManager().GetLinks().empty() )
     620             :                 {
     621           0 :                     rSh.StartAllAction();
     622           0 :                     rSh.GetLinkManager().UpdateAllLinks( false, true, true );
     623           0 :                     rSh.EndAllAction();
     624             :                 }
     625           0 :                 SfxDispatcher &rDis = *rTempView.GetViewFrame()->GetDispatcher();
     626           0 :                 rDis.Execute( FN_UPDATE_FIELDS );
     627           0 :                 rDis.Execute( FN_UPDATE_TOX );
     628           0 :                 rDis.Execute( FN_UPDATE_CHARTS );
     629           0 :                 rSh.CalcLayout();
     630             :             }
     631           0 :             break;
     632             : 
     633             :         case FN_UPDATE_INPUTFIELDS:
     634           0 :             rSh.UpdateInputFlds(NULL, sal_False);
     635           0 :             break;
     636             :         case FN_PREV_BOOKMARK:
     637           0 :             rReq.SetReturnValue(SfxBoolItem( nSlot, rSh.GoPrevBookmark()));
     638           0 :             break;
     639             :         case FN_NEXT_BOOKMARK:
     640           0 :             rReq.SetReturnValue(SfxBoolItem( nSlot, rSh.GoNextBookmark()));
     641           0 :             break;
     642             : 
     643             :         case FN_GOTO_NEXT_MARK:
     644             :         case FN_GOTO_PREV_MARK:
     645             :         {
     646           0 :             SwFldMgr aFldMgr;
     647           0 :             SwFieldType* pFldType = aFldMgr.GetFldType(RES_JUMPEDITFLD);
     648             : 
     649           0 :             if (pFldType)
     650             :             {
     651           0 :                 if (rSh.IsSelFrmMode())
     652             :                 {
     653           0 :                     rSh.UnSelectFrm();
     654           0 :                     rSh.LeaveSelFrmMode();
     655             :                 }
     656             : 
     657           0 :                 if (rSh.HasMark())
     658             :                 {
     659           0 :                     SwMvContext aMvContext(&rSh);
     660           0 :                     if (rSh.IsCrsrPtAtEnd())
     661           0 :                         rSh.SwapPam();
     662           0 :                     rSh.ClearMark();
     663           0 :                     rSh.EndSelect();
     664             :                 }
     665           0 :                 sal_Bool bRet = rSh.MoveFldType(pFldType, nSlot == FN_GOTO_NEXT_MARK);
     666           0 :                 SwField* pCurField = bRet ? rSh.GetCurFld() : 0;
     667           0 :                 if (pCurField)
     668           0 :                     rSh.ClickToField(*pCurField);
     669           0 :                 rReq.SetReturnValue(SfxBoolItem( nSlot, bRet));
     670           0 :             }
     671             :         }
     672           0 :         break;
     673             : 
     674             :         case FN_START_DOC_DIRECT:
     675             :         case FN_END_DOC_DIRECT:
     676             :         {
     677           0 :             if (rSh.IsSelFrmMode())
     678             :             {
     679           0 :                 rSh.UnSelectFrm();
     680           0 :                 rSh.LeaveSelFrmMode();
     681             :             }
     682           0 :             rSh.EnterStdMode();
     683             :             nSlot == FN_START_DOC_DIRECT ?
     684           0 :                 rSh.SttEndDoc(sal_True) :
     685           0 :                     rSh.SttEndDoc(sal_False);
     686             :         }
     687           0 :         break;
     688             :         case FN_GOTO_PREV_OBJ:
     689             :         case FN_GOTO_NEXT_OBJ:
     690             :         {
     691             :                 sal_Bool bSuccess = rSh.GotoObj(
     692           0 :                             nSlot == FN_GOTO_NEXT_OBJ ? sal_True : sal_False);
     693           0 :                 rReq.SetReturnValue(SfxBoolItem(nSlot, bSuccess));
     694           0 :                 if (bSuccess && !rSh.IsSelFrmMode())
     695             :                 {
     696           0 :                     rSh.HideCrsr();
     697           0 :                     rSh.EnterSelFrmMode();
     698           0 :                     GetView().AttrChangedNotify( &rSh );
     699             :                 }
     700             :         }
     701           0 :         break;
     702             :         case SID_GALLERY_FORMATS:
     703             :         {
     704           0 :             const int nSelType = rSh.GetSelectionType();
     705           0 :             if(SFX_ITEM_SET == pArgs->GetItemState( nSlot, sal_True, &pItem))
     706             :             {
     707           0 :                 GalleryExplorer* pGal = 0;
     708           0 :                 if ( (!rSh.IsSelFrmMode() || nSelType & nsSelectionType::SEL_GRF) &&
     709             :                     0!= (pGal = SVX_GALLERY())&&
     710           0 :                     0 != (SGA_FORMAT_GRAPHIC & ((SfxUInt32Item*)pItem)->GetValue()))
     711             :                 {
     712           0 :                     SwWait aWait( *rView.GetDocShell(), sal_True );
     713             : 
     714           0 :                     String aGrfName, aFltName;
     715           0 :                     const Graphic aGrf( pGal->GetGraphic() );
     716             : 
     717           0 :                     if( pGal->IsLinkage() )
     718             :                     {
     719             :                         // Verknuepft
     720           0 :                         aGrfName = pGal->GetURL().GetMainURL(INetURLObject::NO_DECODE);
     721           0 :                         aFltName = pGal->GetFilterName();
     722             :                     }
     723             : 
     724           0 :                     if ( nSelType & nsSelectionType::SEL_GRF )
     725           0 :                         rSh.ReRead( aGrfName, aFltName, &aGrf );
     726             :                     else
     727           0 :                         rSh.Insert( aGrfName, aFltName, aGrf );
     728             : 
     729           0 :                     GetView().GetEditWin().GrabFocus();
     730             :                 }
     731           0 :                 else if(!rSh.IsSelFrmMode() && SGA_FORMAT_SOUND & ((SfxUInt32Item*)pItem)->GetValue())
     732             :                 {
     733           0 :                     const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, pGal->GetURL().GetMainURL( INetURLObject::NO_DECODE ) );
     734           0 :                        GetView().GetViewFrame()->GetDispatcher()->Execute( SID_INSERT_AVMEDIA, SFX_CALLMODE_SYNCHRON, &aMediaURLItem, 0L );
     735             :                 }
     736             :             }
     737             :         }
     738           0 :         break;
     739             :         case FN_PAGE_STYLE_SET_COLS:
     740             :         {
     741           0 :             if (pArgs)
     742             :             {
     743             :                 // aktuellen PageDescriptor ermitteln und damit den Set fuellen
     744           0 :                 const sal_uInt16 nCurIdx = rSh.GetCurPageDesc();
     745           0 :                 SwPageDesc aPageDesc(rSh.GetPageDesc(nCurIdx));
     746             : 
     747           0 :                 SwFrmFmt &rFmt = aPageDesc.GetMaster();
     748             : 
     749           0 :                 SwFmtCol aFmtCol = rFmt.GetCol();
     750             : 
     751             :                 sal_uInt16 nCount;
     752           0 :                 if(SFX_ITEM_SET == pArgs->GetItemState(nSlot))
     753           0 :                     nCount = ((SfxUInt16Item &)pArgs->Get(nSlot)).GetValue();
     754             :                 else
     755           0 :                     nCount = ((SfxUInt16Item &)pArgs->Get(SID_ATTR_COLUMNS)).GetValue();
     756           0 :                 sal_uInt16 nGutterWidth = DEF_GUTTER_WIDTH;
     757             : 
     758           0 :                 aFmtCol.Init(nCount ? nCount : 1, nGutterWidth, USHRT_MAX);
     759           0 :                 aFmtCol.SetWishWidth(USHRT_MAX);
     760           0 :                 aFmtCol.SetGutterWidth(nGutterWidth, USHRT_MAX);
     761             : 
     762           0 :                 rFmt.SetFmtAttr(aFmtCol);
     763             : 
     764           0 :                 rSh.ChgPageDesc(nCurIdx, aPageDesc);
     765             :             }
     766             :             else
     767           0 :                 GetView().GetViewFrame()->GetDispatcher()->Execute(FN_FORMAT_PAGE_COLUMN_DLG, sal_False);
     768             :         }
     769           0 :         break;
     770             :         case FN_CONVERT_TABLE_TO_TEXT:
     771             :         case FN_CONVERT_TEXT_TO_TABLE:
     772             :         case FN_CONVERT_TEXT_TABLE:
     773             :         {
     774           0 :             sal_Unicode cDelim = 0;
     775           0 :             bool bToTable = false;
     776           0 :             if( nSlot == FN_CONVERT_TEXT_TO_TABLE ||
     777           0 :                 ( nSlot == FN_CONVERT_TEXT_TABLE && 0 == rSh.GetTableFmt() ))
     778           0 :                 bToTable = true;
     779           0 :             SwInsertTableOptions aInsTblOpts( tabopts::ALL_TBL_INS_ATTR, 1 );
     780           0 :             SwTableAutoFmt const* pTAFmt = 0;
     781           0 :             SwTableAutoFmtTbl* pAutoFmtTbl = 0;
     782           0 :             bool bDeleteFormat = true;
     783           0 :             if(pArgs && SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_1, sal_True, &pItem))
     784             :             {
     785           0 :                 aInsTblOpts.mnInsMode = 0;
     786             :                 //Delimiter
     787           0 :                 String sDelim = static_cast< const SfxStringItem* >(pItem)->GetValue();
     788           0 :                 if(sDelim.Len())
     789           0 :                     cDelim = sDelim.GetChar(0);
     790             :                 //AutoFormat
     791           0 :                 if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_2, sal_True, &pItem))
     792             :                 {
     793           0 :                     String sAutoFmt = static_cast< const SfxStringItem* >(pItem)->GetValue();
     794             : 
     795           0 :                     pAutoFmtTbl = new SwTableAutoFmtTbl;
     796           0 :                     pAutoFmtTbl->Load();
     797             : 
     798           0 :                     for( sal_uInt16 i = 0, nCount = pAutoFmtTbl->size(); i < nCount; i++ )
     799             :                     {
     800           0 :                         SwTableAutoFmt const*const pFmt = &(*pAutoFmtTbl)[ i ];
     801           0 :                         if( pFmt->GetName() == sAutoFmt )
     802             :                         {
     803           0 :                             pTAFmt = pFmt;
     804           0 :                             bDeleteFormat = false;
     805           0 :                             break;
     806             :                         }
     807           0 :                     }
     808             :                 }
     809             :                 //WithHeader
     810           0 :                 if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_3, sal_True, &pItem) &&
     811           0 :                             static_cast< const SfxBoolItem* >(pItem)->GetValue())
     812           0 :                     aInsTblOpts.mnInsMode |= tabopts::HEADLINE;
     813             :                 // RepeatHeaderLines
     814           0 :                 if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_4, sal_True, &pItem))
     815             :                    aInsTblOpts.mnRowsToRepeat =
     816           0 :                             (sal_uInt16)static_cast< const SfxInt16Item* >(pItem)->GetValue();
     817             :                 //WithBorder
     818           0 :                 if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_5, sal_True, &pItem) &&
     819           0 :                     static_cast< const SfxBoolItem* >(pItem)->GetValue())
     820           0 :                     aInsTblOpts.mnInsMode |= tabopts::DEFAULT_BORDER;
     821             :                 //DontSplitTable
     822           0 :                 if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_6, sal_True, &pItem) &&
     823           0 :                     !static_cast< const SfxBoolItem* >(pItem)->GetValue() )
     824           0 :                     aInsTblOpts.mnInsMode |= tabopts::SPLIT_LAYOUT;
     825             :             }
     826             :             else
     827             :             {
     828           0 :                 SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
     829             :                 OSL_ENSURE(pFact, "SwAbstractDialogFactory fail!");
     830             : 
     831           0 :                 AbstractSwConvertTableDlg* pDlg = pFact->CreateSwConvertTableDlg(GetView(), bToTable);
     832             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
     833           0 :                 if( RET_OK == pDlg->Execute() )
     834             :                 {
     835           0 :                     pDlg->GetValues( cDelim, aInsTblOpts, pTAFmt );
     836             : 
     837             :                 }
     838           0 :                 delete pDlg;
     839             :             }
     840             : 
     841           0 :             if( cDelim )
     842             :             {
     843             :                 //Shellwechsel!
     844           0 :                 SwView& rSaveView = rView;
     845           0 :                 sal_Bool bInserted = sal_False;
     846             :                 //recording:
     847             : 
     848           0 :                 SfxViewFrame* pViewFrame = GetView().GetViewFrame();
     849           0 :                 if( SfxRequest::HasMacroRecorder(pViewFrame) )
     850             :                 {
     851           0 :                     SfxRequest aReq( pViewFrame, nSlot);
     852           0 :                     aReq.AppendItem( SfxStringItem( FN_PARAM_1, rtl::OUString(cDelim) ));
     853           0 :                     if(bToTable)
     854             :                     {
     855           0 :                         if(pTAFmt)
     856           0 :                             aReq.AppendItem( SfxStringItem( FN_PARAM_2, pTAFmt->GetName()));
     857           0 :                         aReq.AppendItem( SfxBoolItem ( FN_PARAM_3, 0 != (aInsTblOpts.mnInsMode & tabopts::HEADLINE)));
     858           0 :                         aReq.AppendItem( SfxInt16Item( FN_PARAM_4, (short)aInsTblOpts.mnRowsToRepeat ));
     859           0 :                         aReq.AppendItem( SfxBoolItem ( FN_PARAM_5, 0 != (aInsTblOpts.mnInsMode & tabopts::DEFAULT_BORDER) ));
     860           0 :                         aReq.AppendItem( SfxBoolItem ( FN_PARAM_6, !(aInsTblOpts.mnInsMode & tabopts::SPLIT_LAYOUT)));
     861             :                     }
     862           0 :                     aReq.Done();
     863             :                 }
     864             : 
     865           0 :                 if( !bToTable )
     866           0 :                     rSh.TableToText( cDelim );
     867             :                 else
     868             :                 {
     869           0 :                     bInserted = rSh.TextToTable( aInsTblOpts, cDelim, text::HoriOrientation::FULL, pTAFmt );
     870             :                 }
     871           0 :                 rSh.EnterStdMode();
     872             : 
     873           0 :                 if( bInserted )
     874           0 :                     rSaveView.AutoCaption( TABLE_CAP );
     875             :             }
     876           0 :             if(bDeleteFormat)
     877           0 :                 delete pTAFmt;
     878           0 :             delete pAutoFmtTbl;
     879             :         }
     880           0 :         break;
     881             :         case SID_STYLE_WATERCAN:
     882             :         case SID_STYLE_UPDATE_BY_EXAMPLE:
     883             :         case SID_STYLE_NEW_BY_EXAMPLE:
     884             :         case SID_STYLE_APPLY:
     885             :         {
     886           0 :             ShellModes eMode = GetView().GetShellMode();
     887           0 :             if ( SHELL_MODE_DRAW != eMode &&
     888             :                  SHELL_MODE_DRAW_CTRL != eMode &&
     889             :                  SHELL_MODE_DRAW_FORM != eMode &&
     890             :                  SHELL_MODE_DRAWTEXT != eMode &&
     891             :                  SHELL_MODE_BEZIER != eMode )
     892             :             {
     893             :                 // oj #107754#
     894           0 :                 if ( SID_STYLE_WATERCAN == nSlot )
     895             :                 {
     896           0 :                     const sal_Bool bLockedView = rSh.IsViewLocked();
     897           0 :                     rSh.LockView( sal_True );    //lock visible section
     898             : 
     899           0 :                     GetView().GetDocShell()->ExecStyleSheet(rReq);
     900             : 
     901           0 :                     rSh.LockView( bLockedView );
     902             :                 }
     903             :                 else
     904             :                 // wird von der DocShell aufgezeichnet
     905           0 :                     GetView().GetDocShell()->ExecStyleSheet(rReq);
     906             :             }
     907             :         }
     908           0 :         break;
     909             :         case FN_ESCAPE:
     910           0 :             GetView().ExecuteSlot(rReq);
     911           0 :         break;
     912             :         case SID_IMAP:
     913             :         {
     914           0 :             sal_uInt16      nId = SvxIMapDlgChildWindow::GetChildWindowId();
     915             : 
     916           0 :             SfxViewFrame* pVFrame = GetView().GetViewFrame();
     917           0 :             pVFrame->ToggleChildWindow( nId );
     918           0 :             pVFrame->GetBindings().Invalidate( SID_IMAP );
     919             : 
     920           0 :             if ( pVFrame->HasChildWindow( nId ) && rSh.IsFrmSelected() )
     921           0 :                 lcl_UpdateIMapDlg( rSh );
     922             :         }
     923           0 :         break;
     924             :         case SID_IMAP_EXEC:
     925             :         {
     926           0 :             SvxIMapDlg* pDlg = SWIMAPDLG(GetView());
     927             : 
     928             :             // Kontrolle, ob Zuweisung ueberhaupt sinnvoll/erlaubt
     929           0 :             if ( rSh.IsFrmSelected() &&
     930           0 :                  pDlg->GetEditingObject() == rSh.GetIMapInventor() )
     931             :             {
     932           0 :                     SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
     933           0 :                     rSh.GetFlyFrmAttr( aSet );
     934           0 :                     SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) );
     935           0 :                     aURL.SetMap( &pDlg->GetImageMap() );
     936           0 :                     aSet.Put( aURL );
     937           0 :                     rSh.SetFlyFrmAttr( aSet );
     938             :             }
     939             :         }
     940           0 :         break;
     941             :         case SID_CONTOUR_DLG:
     942             :         {
     943           0 :             sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
     944             : 
     945           0 :             SfxViewFrame* pVFrame = GetView().GetViewFrame();
     946           0 :             pVFrame->ToggleChildWindow( nId );
     947           0 :             pVFrame->GetBindings().Invalidate( SID_CONTOUR_DLG );
     948             : 
     949           0 :             int nSel = rSh.GetSelectionType();
     950           0 :             if ( pVFrame->HasChildWindow( nId ) &&
     951             :                  (nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE)) )
     952             :             {
     953           0 :                 lcl_UpdateContourDlg( rSh, nSel );
     954             :             }
     955             :         }
     956           0 :         break;
     957             :         case SID_CONTOUR_EXEC:
     958             :         {
     959           0 :             SvxContourDlg *pDlg = SWCONTOURDLG(GetView());
     960             : 
     961             :             // Kontrolle, ob Zuweisung ueberhaupt sinnvoll/erlaubt
     962           0 :             int nSel = rSh.GetSelectionType();
     963           0 :             if ( nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE) )
     964             :             {
     965           0 :                 if ( pDlg->GetEditingObject() == rSh.GetIMapInventor() )
     966             :                 {
     967           0 :                     rSh.StartAction();
     968           0 :                     SfxItemSet aSet( rSh.GetAttrPool(), RES_SURROUND, RES_SURROUND);
     969           0 :                     rSh.GetFlyFrmAttr( aSet );
     970           0 :                     SwFmtSurround aSur( (SwFmtSurround&)aSet.Get( RES_SURROUND ) );
     971           0 :                     if ( !aSur.IsContour() )
     972             :                     {
     973           0 :                         aSur.SetContour( sal_True );
     974           0 :                         if ( aSur.GetSurround() == SURROUND_NONE )
     975           0 :                             aSur.SetSurround( SURROUND_PARALLEL );
     976           0 :                         aSet.Put( aSur );
     977           0 :                         rSh.SetFlyFrmAttr( aSet );
     978             :                     }
     979           0 :                     const PolyPolygon aPoly( pDlg->GetPolyPolygon() );
     980           0 :                     rSh.SetGraphicPolygon( &aPoly );
     981           0 :                     if ( pDlg->IsGraphicChanged() )
     982           0 :                         rSh.ReRead( aEmptyStr, aEmptyStr, &pDlg->GetGraphic());
     983           0 :                     rSh.EndAction();
     984             :                 }
     985             :             }
     986             :         }
     987           0 :         break;
     988             :         case FN_FRAME_TO_ANCHOR:
     989             :         {
     990           0 :             rSh.GotoFlyAnchor();
     991           0 :             rSh.EnterStdMode();
     992           0 :             rSh.CallChgLnk();
     993             :         }
     994           0 :         break;
     995             :         case FN_TOOL_ANCHOR:
     996           0 :             break;
     997             :         case FN_TOOL_ANCHOR_PAGE:
     998             :         case FN_TOOL_ANCHOR_PARAGRAPH:
     999             :         case FN_TOOL_ANCHOR_CHAR:
    1000             :         case FN_TOOL_ANCHOR_AT_CHAR:
    1001             :         case FN_TOOL_ANCHOR_FRAME:
    1002             :         {
    1003             :             RndStdIds eSet = nSlot == FN_TOOL_ANCHOR_PAGE
    1004             :                                 ? FLY_AT_PAGE
    1005             :                                 : nSlot == FN_TOOL_ANCHOR_PARAGRAPH
    1006             :                                     ? FLY_AT_PARA
    1007             :                                     : nSlot == FN_TOOL_ANCHOR_FRAME
    1008             :                                         ? FLY_AT_FLY
    1009             :                                         : nSlot == FN_TOOL_ANCHOR_CHAR
    1010             :                                             ? FLY_AS_CHAR
    1011           0 :                                             : FLY_AT_CHAR;
    1012           0 :             rSh.StartUndo();
    1013           0 :             if( rSh.IsObjSelected() )
    1014           0 :                 rSh.ChgAnchor( eSet );
    1015           0 :             else if( rSh.IsFrmSelected() )
    1016             :             {
    1017             :                 // Der Set beinhaltet auch VERT/HORI_ORIENT, da in FEShell::
    1018             :                 // SetFlyFrmAttr/SetFlyFrmAnchor ggf. als Folge des Umankerns
    1019             :                 // die Ausrichtungen veraendert werden sollen.
    1020           0 :                 SfxItemSet aSet( GetPool(), RES_VERT_ORIENT, RES_ANCHOR );
    1021           0 :                 SwFmtAnchor aAnc( eSet, rSh.GetPhyPageNum() );
    1022           0 :                 aSet.Put( aAnc );
    1023           0 :                 rSh.SetFlyFrmAttr(aSet);
    1024             :             }
    1025             : 
    1026             :             // if new anchor is 'as char' and it is a Math object and the usual
    1027             :             // pre-conditions are met then align the formula to the baseline of the text
    1028           0 :             const uno::Reference < embed::XEmbeddedObject > xObj( rSh.GetOleRef() );
    1029           0 :             const bool bDoMathBaselineAlignment = xObj.is() && SotExchange::IsMath( xObj->getClassID() )
    1030           0 :                     && FLY_AS_CHAR == eSet && rSh.GetDoc()->get( IDocumentSettingAccess::MATH_BASELINE_ALIGNMENT );
    1031           0 :             if (bDoMathBaselineAlignment)
    1032           0 :                 rSh.AlignFormulaToBaseline( xObj );
    1033             : 
    1034           0 :             sal_uInt16 nHtmlMode = ::GetHtmlMode(GetView().GetDocShell());
    1035           0 :             if( nHtmlMode )
    1036             :             {
    1037           0 :                 SfxItemSet aSet(GetPool(), RES_SURROUND, RES_HORI_ORIENT);
    1038           0 :                 rSh.GetFlyFrmAttr(aSet);
    1039             : 
    1040           0 :                 const SwFmtSurround& rSurround = (const SwFmtSurround&)aSet.Get(RES_SURROUND);
    1041           0 :                 const SwFmtVertOrient& rVert = (const SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT);
    1042           0 :                 const SwFmtHoriOrient& rHori = (const SwFmtHoriOrient&)aSet.Get(RES_HORI_ORIENT);
    1043           0 :                 sal_Int16 eVOrient = rVert.GetVertOrient();
    1044           0 :                 sal_Int16 eHOrient = rHori.GetHoriOrient();
    1045           0 :                 SwSurround eSurround = rSurround.GetSurround();
    1046             : 
    1047           0 :                 switch( eSet )
    1048             :                 {
    1049             :                 case FLY_AT_FLY:
    1050             :                 case FLY_AT_PAGE:
    1051             : 
    1052             :                     //Durchlauf, links oder von links, oben, von oben
    1053           0 :                     if(eSurround != SURROUND_THROUGHT)
    1054           0 :                         aSet.Put(SwFmtSurround(SURROUND_THROUGHT));
    1055             : 
    1056           0 :                     if( eVOrient != text::VertOrientation::TOP && eVOrient != text::VertOrientation::NONE)
    1057           0 :                         aSet.Put(SwFmtVertOrient(0, text::VertOrientation::TOP));
    1058             : 
    1059           0 :                     if(eHOrient != text::HoriOrientation::NONE || eHOrient != text::HoriOrientation::LEFT)
    1060           0 :                         aSet.Put(SwFmtHoriOrient(0, text::HoriOrientation::LEFT));
    1061           0 :                     break;
    1062             : 
    1063             :                 case FLY_AT_PARA:
    1064             :                     //links, von links, rechts, oben, kein Uml, li+re Umlauf,
    1065           0 :                     if(eSurround != SURROUND_LEFT || eSurround != SURROUND_RIGHT)
    1066           0 :                         aSet.Put(SwFmtSurround(SURROUND_LEFT));
    1067             : 
    1068           0 :                     if( eVOrient != text::VertOrientation::TOP)
    1069           0 :                         aSet.Put(SwFmtVertOrient(0, text::VertOrientation::TOP));
    1070             : 
    1071           0 :                     if(eHOrient != text::HoriOrientation::NONE || eHOrient != text::HoriOrientation::LEFT || eHOrient != text::HoriOrientation::RIGHT)
    1072           0 :                         aSet.Put(SwFmtHoriOrient(0, text::HoriOrientation::LEFT));
    1073           0 :                     break;
    1074             : 
    1075             :                 case FLY_AT_CHAR:
    1076             :                     //links, von links, rechts, oben,  Durchlauf
    1077           0 :                     if(eSurround != SURROUND_THROUGHT)
    1078           0 :                         aSet.Put(SwFmtSurround(SURROUND_THROUGHT));
    1079             : 
    1080           0 :                     if( eVOrient != text::VertOrientation::TOP)
    1081           0 :                         aSet.Put(SwFmtVertOrient(0, text::VertOrientation::TOP));
    1082             : 
    1083           0 :                     if(eHOrient != text::HoriOrientation::NONE || eHOrient != text::HoriOrientation::LEFT || eHOrient != text::HoriOrientation::RIGHT)
    1084           0 :                         aSet.Put(SwFmtHoriOrient(0, text::HoriOrientation::LEFT));
    1085           0 :                     break;
    1086             : 
    1087             :                 default:
    1088             :                     ;
    1089             :                 }
    1090             : 
    1091           0 :                 if( aSet.Count() )
    1092           0 :                     rSh.SetFlyFrmAttr( aSet );
    1093             :             }
    1094           0 :             rSh.EndUndo();
    1095             : 
    1096           0 :             GetView().GetViewFrame()->GetBindings().Invalidate( FN_TOOL_ANCHOR );
    1097             :         }
    1098           0 :         break;
    1099             : 
    1100             :         case FN_FRAME_NOWRAP:
    1101             :         case FN_FRAME_WRAP:
    1102             :         case FN_FRAME_WRAP_IDEAL:
    1103             :         case FN_FRAME_WRAPTHRU:
    1104             :         case FN_FRAME_WRAPTHRU_TRANSP:
    1105             :         case FN_FRAME_WRAP_CONTOUR:
    1106             :         case FN_WRAP_ANCHOR_ONLY:
    1107             :         case FN_FRAME_WRAP_LEFT:
    1108             :         case FN_FRAME_WRAP_RIGHT:
    1109           0 :             SetWrapMode( nSlot );
    1110           0 :             break;
    1111             : 
    1112             :         case FN_UPDATE_ALL_LINKS:
    1113             :             {
    1114           0 :                 if( !rSh.GetLinkManager().GetLinks().empty() )
    1115             :                 {
    1116           0 :                     rSh.EnterStdMode();
    1117           0 :                     rSh.StartAllAction();
    1118           0 :                     rSh.GetLinkManager().UpdateAllLinks( false, false, false );
    1119           0 :                     rSh.EndAllAction();
    1120             :                 }
    1121             :             }
    1122           0 :             break;
    1123             : 
    1124             :         case FN_XFORMS_DESIGN_MODE:
    1125           0 :             if( pArgs != NULL
    1126           0 :                 && pArgs->GetItemState( nSlot, sal_True, &pItem ) == SFX_ITEM_SET
    1127             :                 && pItem != NULL
    1128           0 :                 && pItem->ISA( SfxBoolItem ) )
    1129             :             {
    1130             :                 sal_Bool bDesignMode =
    1131           0 :                     static_cast<const SfxBoolItem*>( pItem )->GetValue();
    1132             : 
    1133             :                 // set form design mode
    1134             :                 OSL_ENSURE( GetView().GetFormShell() != NULL, "form shell?" );
    1135           0 :                 SfxRequest aReq( GetView().GetViewFrame(), SID_FM_DESIGN_MODE );
    1136           0 :                 aReq.AppendItem( SfxBoolItem( SID_FM_DESIGN_MODE, bDesignMode ) );
    1137           0 :                 GetView().GetFormShell()->Execute( aReq );
    1138           0 :                 aReq.Done();
    1139             : 
    1140             :                 // also set suitable view options
    1141           0 :                 SwViewOption aViewOption = *rSh.GetViewOptions();
    1142           0 :                 aViewOption.SetFormView( ! bDesignMode );
    1143           0 :                 rSh.ApplyViewOptions( aViewOption );
    1144             :             }
    1145           0 :             break;
    1146             : 
    1147             :         default:
    1148           0 :             bMore = sal_True;
    1149             :     }
    1150           0 :     if(bMore && pArgs)
    1151             :     {
    1152           0 :         pItem = 0;
    1153           0 :         pArgs->GetItemState(GetPool().GetWhich(nSlot), sal_False, &pItem);
    1154           0 :         if(pItem)
    1155           0 :         switch(nSlot)
    1156             :         {
    1157             :         case SID_ATTR_BRUSH:
    1158             :         case SID_ATTR_BORDER_SHADOW:
    1159             :         case RES_SHADOW:
    1160             :         {
    1161           0 :             rSh.StartAllAction();
    1162           0 :             SfxItemSet   aSet( rSh.GetAttrPool(),
    1163             :                                 RES_SHADOW, RES_SHADOW,
    1164           0 :                                 RES_BACKGROUND, RES_BACKGROUND, 0 );
    1165             : 
    1166           0 :             aSet.Put(*pItem);
    1167             :             // Tabellenzelle(n) selektiert?
    1168           0 :             if ( rSh.IsTableMode() )
    1169             :             {
    1170           0 :                 SwFrmFmt *pFmt = rSh.GetTableFmt();
    1171           0 :                 pFmt->SetFmtAttr( *pItem );
    1172             :             }
    1173           0 :             else if ( rSh.IsFrmSelected() )
    1174             :             {
    1175             :                 // Umrandungsattribute ueber Frame-Manager setzen
    1176           0 :                 SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
    1177           0 :                 aMgr.SetAttrSet( *pArgs );
    1178           0 :                 aMgr.UpdateFlyFrm();
    1179             :             }
    1180             :             else
    1181             :             {
    1182           0 :                 rSh.SetAttr( *pArgs );
    1183             :             }
    1184           0 :             rSh.EndAllAction();
    1185             :         }
    1186           0 :         break;
    1187             :         case FN_PAGE_STYLE_SET_LR_MARGIN:
    1188             :         case FN_PAGE_STYLE_SET_UL_MARGIN:
    1189             :         case FN_PAGE_STYLE_SET_NUMBER_FORMAT:
    1190             :         case FN_PAGE_STYLE_SET_PAPER_SIZE:
    1191             :         case FN_PAGE_STYLE_SET_PAPER_BIN:
    1192             :         {
    1193             :             OSL_FAIL("not implemented");
    1194             :         }
    1195           0 :         break;
    1196             : 
    1197             :         case SID_ATTR_BORDER_OUTER:
    1198             :         {
    1199             :             // Tabellenzelle(n) selektiert?
    1200           0 :             if ( rSh.IsTableMode() )
    1201             :             {
    1202             :                 // Umrandungattribute Get/SetTabBorders() setzen
    1203           0 :                 rSh.SetTabBorders(*pArgs);
    1204             :             }
    1205           0 :             else if ( rSh.IsFrmSelected() )
    1206             :             {
    1207             :                 // Umrandungsattribute ueber Frame-Manager setzen
    1208           0 :                 SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
    1209           0 :                 aMgr.SetAttrSet(*pArgs);
    1210           0 :                 aMgr.UpdateFlyFrm();
    1211             :             }
    1212             :             else
    1213             :             {
    1214             :                 // Umrandungsattribute ganz normal ueber Shell setzen
    1215           0 :                 rSh.SetAttr( *pItem );
    1216             :             }
    1217             :         }
    1218           0 :         break;
    1219             :         default:
    1220             :                 OSL_FAIL("wrong Dispatcher");
    1221             :         }
    1222             : 
    1223             :     }
    1224           0 : }
    1225             : 
    1226             : /* --------------------------------------------------
    1227             :  * Hier wird der State fuer SID_IMAP / SID_CONTOUR behandelt,
    1228             :  * wenn die Grafik ausgeswappt ist
    1229             :  * --------------------------------------------------*/
    1230           0 : IMPL_LINK_NOARG(SwBaseShell, GraphicArrivedHdl)
    1231             : {
    1232             :     sal_uInt16 nGrfType;
    1233           0 :     SwWrtShell &rSh = GetShell();
    1234           0 :     if( CNT_GRF == rSh.SwEditShell::GetCntType() &&
    1235           0 :         GRAPHIC_NONE != ( nGrfType = rSh.GetGraphicType() ) &&
    1236           0 :         !aGrfUpdateSlots.empty() )
    1237             :     {
    1238           0 :         sal_Bool bProtect = 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT);
    1239           0 :         SfxViewFrame* pVFrame = GetView().GetViewFrame();
    1240             :         sal_uInt16 nSlot;
    1241           0 :         std::set<sal_uInt16>::iterator it;
    1242           0 :         for( it = aGrfUpdateSlots.begin(); it != aGrfUpdateSlots.end(); ++it )
    1243             :         {
    1244           0 :             sal_Bool bSetState = sal_False;
    1245           0 :             sal_Bool bState = sal_False;
    1246           0 :             switch( nSlot = *it )
    1247             :             {
    1248             :             case SID_IMAP:
    1249             :             case SID_IMAP_EXEC:
    1250             :                 {
    1251           0 :                     sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
    1252           0 :                     SvxIMapDlg *pDlg = pVFrame->HasChildWindow( nId ) ?
    1253             :                         (SvxIMapDlg*) ( pVFrame->GetChildWindow( nId )
    1254           0 :                                             ->GetWindow()) : 0;
    1255             : 
    1256           0 :                     if( pDlg && ( SID_IMAP_EXEC == nSlot ||
    1257             :                                 ( SID_IMAP == nSlot && !bProtect)) &&
    1258           0 :                         pDlg->GetEditingObject() != rSh.GetIMapInventor())
    1259           0 :                             lcl_UpdateIMapDlg( rSh );
    1260             : 
    1261           0 :                     if( !bProtect && SID_IMAP == nSlot )
    1262           0 :                         bSetState = sal_True, bState = 0 != pDlg;
    1263             :                 }
    1264           0 :                 break;
    1265             : 
    1266             :             case SID_CONTOUR_DLG:
    1267           0 :                 if( !bProtect )
    1268             :                 {
    1269           0 :                     sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
    1270           0 :                     SvxIMapDlg *pDlg = pVFrame->HasChildWindow( nId ) ?
    1271             :                         (SvxIMapDlg*) ( pVFrame->GetChildWindow( nId )
    1272           0 :                                             ->GetWindow()) : 0;
    1273           0 :                     if( pDlg && pDlg->GetEditingObject() !=
    1274           0 :                                 rSh.GetIMapInventor() )
    1275           0 :                         lcl_UpdateContourDlg( rSh, nsSelectionType::SEL_GRF );
    1276             : 
    1277           0 :                     bSetState = sal_True;
    1278           0 :                     bState = 0 != pDlg;
    1279             :                 }
    1280           0 :                 break;
    1281             : 
    1282             :             case FN_FRAME_WRAP_CONTOUR:
    1283           0 :                 if( !bProtect )
    1284             :                 {
    1285           0 :                     SfxItemSet aSet(GetPool(), RES_SURROUND, RES_SURROUND);
    1286           0 :                     rSh.GetFlyFrmAttr(aSet);
    1287           0 :                     const SwFmtSurround& rWrap = (const SwFmtSurround&)aSet.Get(RES_SURROUND);
    1288           0 :                     bSetState = sal_True;
    1289           0 :                     bState = rWrap.IsContour();
    1290             :                 }
    1291           0 :                 break;
    1292             : 
    1293             :             case SID_GRFFILTER:
    1294             :             case SID_GRFFILTER_INVERT:
    1295             :             case SID_GRFFILTER_SMOOTH:
    1296             :             case SID_GRFFILTER_SHARPEN:
    1297             :             case SID_GRFFILTER_REMOVENOISE:
    1298             :             case SID_GRFFILTER_SOBEL:
    1299             :             case SID_GRFFILTER_MOSAIC:
    1300             :             case SID_GRFFILTER_EMBOSS:
    1301             :             case SID_GRFFILTER_POSTER:
    1302             :             case SID_GRFFILTER_POPART:
    1303             :             case SID_GRFFILTER_SEPIA:
    1304             :             case SID_GRFFILTER_SOLARIZE:
    1305           0 :                 bSetState = bState = GRAPHIC_BITMAP == nGrfType;
    1306           0 :                 break;
    1307             :             }
    1308             : 
    1309           0 :             if( bSetState )
    1310             :             {
    1311           0 :                 SfxBoolItem aBool( nSlot, bState );
    1312           0 :                 if( pGetStateSet )
    1313           0 :                     pGetStateSet->Put( aBool );
    1314             :                 else
    1315           0 :                     pVFrame->GetBindings().SetState( aBool );
    1316             :             }
    1317             :         }
    1318           0 :         aGrfUpdateSlots.clear();
    1319             :     }
    1320           0 :     return 0;
    1321             : }
    1322             : 
    1323           0 : void SwBaseShell::GetState( SfxItemSet &rSet )
    1324             : {
    1325           0 :     SwWrtShell &rSh = GetShell();
    1326           0 :     SfxViewFrame* pVFrame = GetView().GetViewFrame();
    1327           0 :     SfxWhichIter aIter( rSet );
    1328           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
    1329           0 :     pGetStateSet = &rSet;
    1330           0 :     while ( nWhich )
    1331             :     {
    1332           0 :         switch ( nWhich )
    1333             :         {
    1334             :             case SID_GALLERY_FORMATS:
    1335           0 :                 if ( rSh.IsObjSelected() ||
    1336           0 :                      (rSh.IsSelFrmMode() &&
    1337           0 :                       !(rSh.GetSelectionType() & nsSelectionType::SEL_GRF)) )
    1338           0 :                     rSet.DisableItem( nWhich );
    1339           0 :                 break;
    1340             :             case SID_GALLERY_ENABLE_ADDCOPY:
    1341             :                 // #108230# allow copy from gallery in Writer AND Writer/Web!
    1342           0 :                 rSet.Put( SfxBoolItem( SID_GALLERY_ENABLE_ADDCOPY, sal_True ) );
    1343           0 :                 break;
    1344             :             case FN_EDIT_REGION:
    1345           0 :                 if( !rSh.IsAnySectionInDoc() )
    1346           0 :                     rSet.DisableItem(nWhich);
    1347           0 :                 break;
    1348             : 
    1349             :             case FN_INSERT_REGION:
    1350           0 :                 if( rSh.IsSelFrmMode() ||
    1351           0 :                     !rSh.IsInsRegionAvailable() )
    1352           0 :                     rSet.DisableItem( nWhich );
    1353           0 :                 break;
    1354             :             case FN_CONVERT_TABLE_TO_TEXT:
    1355             :             {
    1356           0 :                 sal_uInt16 eFrmType = rSh.GetFrmType(0,sal_True);
    1357           0 :                 if( (eFrmType & FRMTYPE_FOOTNOTE) ||
    1358           0 :                     !rSh.GetTableFmt() )
    1359           0 :                     rSet.DisableItem( nWhich );
    1360             :             }
    1361           0 :             break;
    1362             :             case FN_CONVERT_TEXT_TO_TABLE:
    1363             :             {
    1364           0 :                 sal_uInt16 eFrmType = rSh.GetFrmType(0,sal_True);
    1365           0 :                 if( (eFrmType & FRMTYPE_FOOTNOTE) ||
    1366           0 :                     !rSh.IsTextToTableAvailable()  )
    1367           0 :                     rSet.DisableItem( nWhich );
    1368             :             }
    1369           0 :             break;
    1370             :             case FN_CONVERT_TEXT_TABLE:
    1371             :             {
    1372           0 :                 sal_uInt16 eFrmType = rSh.GetFrmType(0,sal_True);
    1373           0 :                 if( (eFrmType & FRMTYPE_FOOTNOTE) ||
    1374           0 :                     (!rSh.GetTableFmt() && !rSh.IsTextToTableAvailable() ) )
    1375           0 :                     rSet.DisableItem( nWhich );
    1376             :             }
    1377           0 :             break;
    1378             :             case RES_SHADOW:
    1379             :             {
    1380           0 :                 SfxItemSet   aSet( rSh.GetAttrPool(),
    1381           0 :                                     RES_SHADOW, RES_SHADOW );
    1382             : 
    1383             :                 // Tabellenzelle(n) selektiert?
    1384           0 :                 if ( rSh.IsTableMode() )
    1385             :                 {
    1386           0 :                     SwFrmFmt *pFmt = rSh.GetTableFmt();
    1387           0 :                     aSet.Put(pFmt->GetFmtAttr( nWhich, sal_True ));
    1388             :                 }
    1389           0 :                 else if( rSh.IsFrmSelected() )
    1390             :                 {
    1391           0 :                     SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
    1392           0 :                     aSet.Put( aMgr.GetAttrSet() );
    1393             :                 }
    1394             :                 else
    1395           0 :                     rSh.GetCurAttr( aSet );
    1396             : 
    1397           0 :                 const SvxShadowItem& rShItem = (const SvxShadowItem&)aSet.Get(nWhich);
    1398           0 :                 rSet.Put(rShItem);
    1399             :             }
    1400           0 :             break;
    1401             :             case SID_IMAP:
    1402             :             {
    1403             :                 // #i59688#
    1404             :                 // improve efficiency:
    1405             :                 // If selected object is protected, item has to disabled.
    1406           0 :                 const sal_Bool bProtect = 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT);
    1407           0 :                 if ( bProtect )
    1408             :                 {
    1409           0 :                     rSet.DisableItem( nWhich );
    1410             :                 }
    1411             :                 else
    1412             :                 {
    1413           0 :                     const sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
    1414           0 :                     const sal_Bool bHas = pVFrame->HasChildWindow( nId );
    1415           0 :                     const sal_Bool bFrmSel = rSh.IsFrmSelected();
    1416             :                     const sal_Bool bIsGraphicSelection =
    1417           0 :                                 rSh.GetSelectionType() == nsSelectionType::SEL_GRF;
    1418             : 
    1419             :                     // #i59688#
    1420             :                     // avoid unnecessary loading of selected graphic.
    1421             :                     // The graphic is only needed, if the dialog is open.
    1422             :                     //wenn die Grafik ausgeswappt ist, dann muss der
    1423             :                     //Status asynchron ermittelt werden
    1424             :                     //bis dahin wird der Slot disabled
    1425           0 :                     if ( bHas && bIsGraphicSelection && rSh.IsGrfSwapOut( sal_True ) )
    1426             :                     {
    1427           0 :                         if( AddGrfUpdateSlot( nWhich ))
    1428           0 :                             rSh.GetGraphic(sal_False);  // start the loading
    1429             :                     }
    1430             :                     else
    1431             :                     {
    1432           0 :                         if ( !bHas &&
    1433             :                              ( !bFrmSel ||
    1434             :                                ( bIsGraphicSelection &&
    1435           0 :                                  rSh.GetGraphicType() == GRAPHIC_NONE ) ) )
    1436             :                         {
    1437           0 :                             rSet.DisableItem( nWhich );
    1438             :                         }
    1439             :                         else
    1440             :                         {
    1441           0 :                             SfxBoolItem aBool(nWhich, bHas);
    1442           0 :                             if ( bHas && bFrmSel )
    1443           0 :                                 lcl_UpdateIMapDlg( rSh );
    1444           0 :                             rSet.Put(aBool);
    1445             :                         }
    1446             :                     }
    1447             :                 }
    1448             :             }
    1449           0 :             break;
    1450             :             case SID_IMAP_EXEC:
    1451             :             {
    1452           0 :                 sal_Bool bDisable = sal_False;
    1453           0 :                 if( !rSh.IsFrmSelected())
    1454           0 :                     bDisable = sal_True;
    1455           0 :                 sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
    1456           0 :                 if(!bDisable && pVFrame->HasChildWindow( nId ))
    1457             :                 {
    1458           0 :                     if(rSh.GetSelectionType() == nsSelectionType::SEL_GRF
    1459           0 :                                     && rSh.IsGrfSwapOut(sal_True))
    1460             :                     {
    1461           0 :                         if( AddGrfUpdateSlot( nWhich ))
    1462           0 :                             rSh.GetGraphic(sal_False);  // start the loading
    1463             :                     }
    1464             :                     else
    1465             :                     {
    1466           0 :                         SvxIMapDlg *pDlg = SWIMAPDLG(GetView());
    1467           0 :                         if( pDlg->GetEditingObject() != rSh.GetIMapInventor() )
    1468           0 :                             lcl_UpdateIMapDlg( rSh );
    1469             :                     }
    1470             :                 }
    1471           0 :                 rSet.Put(SfxBoolItem(nWhich, bDisable));
    1472             :             }
    1473           0 :             break;
    1474             :             case FN_BACKSPACE:
    1475             :             case SID_DELETE:
    1476           0 :                 if (rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0)
    1477           0 :                     rSet.DisableItem( nWhich );
    1478           0 :                 break;
    1479             :             case SID_CONTOUR_DLG:
    1480             :             {
    1481           0 :                 sal_Bool bParentCntProt = 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT );
    1482             : 
    1483           0 :                 if( bParentCntProt || 0 != (HTMLMODE_ON & ::GetHtmlMode(
    1484           0 :                                             GetView().GetDocShell() )) )
    1485           0 :                     rSet.DisableItem( nWhich );
    1486             :                 else
    1487             :                 {
    1488           0 :                     sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
    1489           0 :                     sal_Bool bHas = GetView().GetViewFrame()->HasChildWindow( nId );
    1490           0 :                     int nSel = rSh.GetSelectionType();
    1491           0 :                     sal_Bool bOk = 0 != (nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE));
    1492             : 
    1493           0 :                     sal_Bool bDisable = sal_False;
    1494           0 :                     if( !bHas && !bOk )
    1495           0 :                         bDisable = sal_True;
    1496             :                     // #i59688#
    1497             :                     // avoid unnecessary loading of selected graphic.
    1498             :                     // The graphic is only needed, if the dialog is open.
    1499             :                     // wenn die Grafik ausgeswappt ist, dann muss der Status
    1500             :                     // asynchron ermittelt werden bis dahin wird der Slot
    1501             :                     // disabled
    1502           0 :                     else if ( bHas && (nSel & nsSelectionType::SEL_GRF) &&
    1503           0 :                               rSh.IsGrfSwapOut(sal_True) )
    1504             :                     {
    1505           0 :                         if( AddGrfUpdateSlot( nWhich ))
    1506           0 :                             rSh.GetGraphic(sal_False);  // start the loading
    1507             :                         // #i75481#
    1508           0 :                         bDisable = sal_True;
    1509             :                     }
    1510           0 :                     else if( bHas && bOk )
    1511           0 :                         bDisable = !lcl_UpdateContourDlg( rSh, nSel );
    1512           0 :                     else if( bOk )
    1513             :                     {
    1514             :                         // #i75481#
    1515             :                         // apply fix #i59688# only for selected graphics
    1516           0 :                         if ( nSel & nsSelectionType::SEL_GRF )
    1517           0 :                             bDisable = GRAPHIC_NONE == rSh.GetGraphicType();
    1518             :                         else
    1519           0 :                             bDisable = GRAPHIC_NONE == rSh.GetIMapGraphic().GetType();
    1520             :                     }
    1521             : 
    1522           0 :                     if( bDisable )
    1523           0 :                         rSet.DisableItem( nWhich );
    1524             :                     else
    1525           0 :                         rSet.Put( SfxBoolItem(nWhich, bHas) );
    1526             :                 }
    1527             :             }
    1528           0 :             break;
    1529             :             case SID_CONTOUR_EXEC:
    1530             :             {
    1531           0 :                 sal_Bool bDisable = sal_False;
    1532           0 :                 int nSel = rSh.GetSelectionType();
    1533           0 :                 if( !(nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE)) )
    1534           0 :                     bDisable = sal_True;
    1535           0 :                 sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
    1536           0 :                 if( !bDisable && GetView().GetViewFrame()->HasChildWindow( nId ))
    1537             :                 {
    1538           0 :                     SvxContourDlg *pDlg = SWCONTOURDLG(GetView());
    1539           0 :                     if( pDlg->GetEditingObject() != rSh.GetIMapInventor() )
    1540           0 :                         bDisable = sal_True;
    1541             :                 }
    1542           0 :                 rSet.Put(SfxBoolItem(nWhich, bDisable));
    1543             :             }
    1544           0 :             break;
    1545             : 
    1546             :             case FN_TOOL_ANCHOR:
    1547             :             case FN_TOOL_ANCHOR_PAGE:
    1548             :             case FN_TOOL_ANCHOR_PARAGRAPH:
    1549             :             case FN_TOOL_ANCHOR_CHAR:
    1550             :             case FN_TOOL_ANCHOR_AT_CHAR:
    1551             :             case FN_TOOL_ANCHOR_FRAME:
    1552             :             {
    1553           0 :                 sal_Bool bObj = 0 != rSh.IsObjSelected();
    1554           0 :                 sal_Bool bParentCntProt = rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
    1555             : 
    1556           0 :                 if( !bParentCntProt && (bObj || rSh.IsFrmSelected()))
    1557             :                 {
    1558           0 :                     SfxItemSet aSet(GetPool(), RES_ANCHOR, RES_ANCHOR);
    1559           0 :                     if(bObj)
    1560           0 :                         rSh.GetObjAttr(aSet);
    1561             :                     else
    1562           0 :                         rSh.GetFlyFrmAttr(aSet);
    1563           0 :                     RndStdIds eSet = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetAnchorId();
    1564             :                     const sal_Bool bSet =
    1565             :                            ((nWhich == FN_TOOL_ANCHOR_PAGE) &&
    1566             :                             (eSet == FLY_AT_PAGE))
    1567             :                         || ((nWhich == FN_TOOL_ANCHOR_PARAGRAPH) &&
    1568             :                             (eSet == FLY_AT_PARA))
    1569             :                         || ((nWhich == FN_TOOL_ANCHOR_FRAME) &&
    1570             :                             (eSet == FLY_AT_FLY))
    1571             :                         || ((nWhich == FN_TOOL_ANCHOR_AT_CHAR) &&
    1572             :                             (eSet == FLY_AT_CHAR))
    1573             :                         || ((nWhich == FN_TOOL_ANCHOR_CHAR) &&
    1574           0 :                             (eSet == FLY_AS_CHAR));
    1575           0 :                     if(nWhich != FN_TOOL_ANCHOR)
    1576             :                     {
    1577           0 :                         if( nWhich == FN_TOOL_ANCHOR_FRAME && !rSh.IsFlyInFly() )
    1578           0 :                             rSet.DisableItem(nWhich);
    1579             :                         else
    1580           0 :                             rSet.Put(SfxBoolItem(nWhich, bSet));
    1581             :                     }
    1582             :                     else
    1583             :                     {
    1584           0 :                         sal_uInt16 nSlotId = 0;
    1585             : 
    1586           0 :                         switch (eSet)
    1587             :                         {
    1588             :                             case FLY_AT_PAGE:
    1589           0 :                                 nSlotId = FN_TOOL_ANCHOR_PAGE;
    1590           0 :                             break;
    1591             :                             case FLY_AT_PARA:
    1592           0 :                                 nSlotId = FN_TOOL_ANCHOR_PARAGRAPH;
    1593           0 :                             break;
    1594             :                             case FLY_AS_CHAR:
    1595           0 :                                 nSlotId = FN_TOOL_ANCHOR_CHAR;
    1596           0 :                             break;
    1597             :                             case FLY_AT_CHAR:
    1598           0 :                                 nSlotId = FN_TOOL_ANCHOR_AT_CHAR;
    1599           0 :                             break;
    1600             :                             case FLY_AT_FLY:
    1601           0 :                                 nSlotId = FN_TOOL_ANCHOR_FRAME;
    1602           0 :                             break;
    1603             :                             default:
    1604             :                                 ;
    1605             :                         }
    1606           0 :                         rSet.Put(SfxUInt16Item(nWhich, nSlotId));
    1607           0 :                     }
    1608             :                 }
    1609             :                 else
    1610           0 :                     rSet.DisableItem( nWhich );
    1611             :             }
    1612           0 :             break;
    1613             :             case FN_FRAME_NOWRAP:
    1614             :             case FN_FRAME_WRAP:
    1615             :             case FN_FRAME_WRAP_IDEAL:
    1616             :             case FN_FRAME_WRAPTHRU:
    1617             :             case FN_FRAME_WRAPTHRU_TRANSP:
    1618             :             case FN_FRAME_WRAP_CONTOUR:
    1619             :             case FN_WRAP_ANCHOR_ONLY:
    1620             :             case FN_FRAME_WRAP_LEFT:
    1621             :             case FN_FRAME_WRAP_RIGHT:
    1622             :             {
    1623           0 :                 sal_Bool bObj = 0 != rSh.IsObjSelected();
    1624           0 :                 sal_Bool bParentCntProt = rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
    1625             : 
    1626           0 :                 if( !bParentCntProt && (bObj || rSh.IsFrmSelected()))
    1627             :                 {
    1628           0 :                     SfxItemSet aSet(GetPool(), RES_OPAQUE, RES_ANCHOR);
    1629             :                     int nAnchorType;
    1630           0 :                     if(bObj)
    1631             :                     {
    1632           0 :                         rSh.GetObjAttr(aSet);
    1633           0 :                         nAnchorType = rSh.GetAnchorId();
    1634             :                     }
    1635             :                     else
    1636             :                     {
    1637           0 :                         rSh.GetFlyFrmAttr(aSet);
    1638           0 :                         nAnchorType = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetAnchorId();
    1639             :                     }
    1640           0 :                     const SwFmtSurround& rWrap = (const SwFmtSurround&)aSet.Get(RES_SURROUND);
    1641             : 
    1642           0 :                     const SvxOpaqueItem& rOpaque = (const SvxOpaqueItem&)aSet.Get(RES_OPAQUE);
    1643           0 :                     sal_Bool bOpaque = rOpaque.GetValue();
    1644           0 :                     SwSurround nSurround = rWrap.GetSurround();
    1645           0 :                     sal_Bool bSet = sal_False;
    1646             : 
    1647             :                     bool bDisable =
    1648           0 :                         (nAnchorType == - 1) || (nAnchorType == FLY_AS_CHAR);
    1649             :                     const bool bHtmlMode =
    1650           0 :                         0 != ::GetHtmlMode(GetView().GetDocShell());
    1651             : 
    1652           0 :                     switch( nWhich )
    1653             :                     {
    1654             :                         case FN_FRAME_NOWRAP:
    1655             :                             bDisable |=
    1656             :                                 (   (nAnchorType != FLY_AT_PARA)
    1657             :                                  && (nAnchorType != FLY_AT_CHAR)
    1658           0 :                                  && (nAnchorType != FLY_AT_PAGE));
    1659           0 :                             bSet = nSurround == SURROUND_NONE;
    1660           0 :                         break;
    1661             :                         case FN_FRAME_WRAP:
    1662           0 :                             bDisable |= bHtmlMode;
    1663           0 :                             bSet = nSurround == SURROUND_PARALLEL;
    1664           0 :                         break;
    1665             :                         case FN_FRAME_WRAP_IDEAL:
    1666           0 :                             bDisable |= bHtmlMode;
    1667           0 :                             bSet = nSurround == SURROUND_IDEAL;
    1668           0 :                         break;
    1669             :                         case FN_FRAME_WRAPTHRU:
    1670             :                             bDisable |= (bHtmlMode ||
    1671             :                                 (   (nAnchorType != FLY_AT_PARA)
    1672             :                                  && (nAnchorType != FLY_AT_CHAR)
    1673           0 :                                  && (nAnchorType != FLY_AT_PAGE)));
    1674           0 :                             if(bObj)
    1675           0 :                                 bSet = nSurround == SURROUND_THROUGHT && rSh.GetLayerId();
    1676             :                             else
    1677           0 :                                 bSet = nSurround == SURROUND_THROUGHT && bOpaque;
    1678           0 :                         break;
    1679             :                         case FN_FRAME_WRAPTHRU_TRANSP:
    1680           0 :                             bDisable |= bHtmlMode;
    1681           0 :                             if(bObj)
    1682           0 :                                 bSet = nSurround == SURROUND_THROUGHT && !rSh.GetLayerId();
    1683             :                             else
    1684           0 :                                 bSet = nSurround == SURROUND_THROUGHT && !bOpaque;
    1685           0 :                         break;
    1686             :                         case FN_FRAME_WRAP_CONTOUR:
    1687           0 :                             bDisable |= bHtmlMode;
    1688             :                             //no contour available whenn no wrap or wrap through is set
    1689           0 :                             bDisable |= (nSurround == SURROUND_NONE || nSurround == SURROUND_THROUGHT);
    1690           0 :                             bSet = rWrap.IsContour();
    1691           0 :                             if( !bDisable )
    1692             :                             {
    1693           0 :                                 int nSel = rSh.GetSelectionType();
    1694           0 :                                 if( (nSel & nsSelectionType::SEL_GRF) &&
    1695           0 :                                             rSh.IsGrfSwapOut(sal_True))
    1696             :                                 {
    1697           0 :                                     if( AddGrfUpdateSlot( nWhich ))
    1698           0 :                                         rSh.GetGraphic(sal_False);  // start the loading
    1699             :                                 }
    1700           0 :                                 else if( rSh.IsFrmSelected() )
    1701             :                                 {
    1702             :                                     // #i102253# applied patch from OD (see task)
    1703             :                                     bDisable =
    1704             :                                         nSel & nsSelectionType::SEL_FRM ||
    1705           0 :                                         GRAPHIC_NONE == rSh.GetIMapGraphic().GetType();
    1706             :                                 }
    1707             :                             }
    1708           0 :                             bSet = bDisable ? sal_False : rWrap.IsContour();
    1709             : 
    1710           0 :                         break;
    1711             :                         case FN_WRAP_ANCHOR_ONLY:
    1712             :                             bDisable |= (bHtmlMode ||
    1713           0 :                                 (nAnchorType != FLY_AT_PARA));
    1714           0 :                             bSet = rWrap.IsAnchorOnly();
    1715           0 :                         break;
    1716             :                         case FN_FRAME_WRAP_LEFT:
    1717           0 :                             bSet = nSurround == SURROUND_LEFT;
    1718           0 :                         break;
    1719             :                         case FN_FRAME_WRAP_RIGHT:
    1720           0 :                             bSet = nSurround == SURROUND_RIGHT;
    1721           0 :                         break;
    1722             :                     }
    1723             : 
    1724           0 :                     if(bDisable)
    1725           0 :                         rSet.DisableItem(nWhich);
    1726             :                     else
    1727           0 :                         rSet.Put(SfxBoolItem(nWhich, bSet));
    1728             :                 }
    1729             :                 else
    1730           0 :                     rSet.DisableItem(nWhich);
    1731             :             }
    1732           0 :             break;
    1733             :             case FN_UPDATE_CHARTS:
    1734           0 :                 if( !rSh.HasCharts() )
    1735           0 :                     rSet.DisableItem( nWhich );
    1736           0 :                 break;
    1737             :             case FN_UPDATE_ALL_LINKS:
    1738           0 :                 if ( rSh.GetLinkManager().GetLinks().empty() )
    1739           0 :                     rSet.DisableItem(nWhich);
    1740           0 :                 break;
    1741             :             case FN_XFORMS_DESIGN_MODE:
    1742             :                 // enable if in XForms document
    1743           0 :                 if( rSh.GetDoc()->isXForms() )
    1744             :                 {
    1745             :                     // determine current state from view options
    1746           0 :                     sal_Bool bValue = ! rSh.GetViewOptions()->IsFormView();
    1747           0 :                     rSet.Put( SfxBoolItem( nWhich, bValue ) );
    1748             :                 }
    1749             :                 else
    1750           0 :                     rSet.Put( SfxVisibilityItem( nWhich, sal_False ) );
    1751           0 :                 break;
    1752             :         }
    1753           0 :         nWhich = aIter.NextWhich();
    1754             :     }
    1755           0 :     pGetStateSet = 0;
    1756           0 : }
    1757             : 
    1758             : /*--------------------------------------------------------------------
    1759             :     Beschreibung:   Slots mit dieser Statusmethode disablen
    1760             :  --------------------------------------------------------------------*/
    1761           0 : void SwBaseShell::StateDisableItems( SfxItemSet &rSet )
    1762             : {
    1763           0 :     SfxWhichIter aIter(rSet);
    1764           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
    1765             : 
    1766           0 :     while (nWhich)
    1767             :     {
    1768           0 :         rSet.DisableItem( nWhich );
    1769           0 :         nWhich = aIter.NextWhich();
    1770           0 :     }
    1771           0 : }
    1772             : 
    1773             : /*--------------------------------------------------------------------
    1774             :     Beschreibung:   Slots mit dieser Statusmethode disablen
    1775             :  --------------------------------------------------------------------*/
    1776           0 : void SwBaseShell::StateStyle( SfxItemSet &rSet )
    1777             : {
    1778           0 :     sal_Bool bParentCntProt = GetShell().IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
    1779           0 :     ShellModes eMode = GetView().GetShellMode();
    1780             : 
    1781           0 :     if ( bParentCntProt ||
    1782             :          SHELL_MODE_DRAW == eMode ||
    1783             :          SHELL_MODE_DRAW_CTRL == eMode ||
    1784             :          SHELL_MODE_DRAW_FORM == eMode ||
    1785             :          SHELL_MODE_DRAWTEXT == eMode ||
    1786             :          SHELL_MODE_BEZIER == eMode )
    1787             :     {
    1788           0 :         SfxWhichIter aIter( rSet );
    1789           0 :         sal_uInt16 nWhich = aIter.FirstWhich();
    1790           0 :         while ( nWhich )
    1791             :         {
    1792           0 :             rSet.DisableItem( nWhich );
    1793           0 :             nWhich = aIter.NextWhich();
    1794           0 :         }
    1795             :     }
    1796             :     else
    1797           0 :         GetView().GetDocShell()->StateStyleSheet(rSet, &GetShell());
    1798           0 : }
    1799             : 
    1800           0 : void SwBaseShell::SetWrapMode( sal_uInt16 nSlot )
    1801             : {
    1802           0 :     SwWrtShell &rSh = GetShell();
    1803           0 :     sal_Bool bObj = 0 != rSh.IsObjSelected();
    1804           0 :     if( bObj || rSh.IsFrmSelected())
    1805             :     {
    1806           0 :         SfxItemSet aSet(GetPool(), RES_OPAQUE, RES_SURROUND);
    1807           0 :         if(bObj)
    1808           0 :             rSh.GetObjAttr(aSet);
    1809             :         else
    1810           0 :             rSh.GetFlyFrmAttr(aSet);
    1811           0 :         SwFmtSurround aWrap( (SwFmtSurround&)aSet.Get(RES_SURROUND) );
    1812           0 :         SwSurround nOldSurround(aWrap.GetSurround());
    1813           0 :         SwSurround nSurround = SURROUND_PARALLEL;
    1814             : 
    1815           0 :         switch (nSlot)
    1816             :         {
    1817             :             case FN_FRAME_NOWRAP:
    1818           0 :                 nSurround = SURROUND_NONE;
    1819           0 :                 if (aWrap.IsContour())
    1820           0 :                     aWrap.SetContour(sal_False);
    1821           0 :                 break;
    1822             :             case FN_FRAME_WRAP_IDEAL:
    1823           0 :                 nSurround = SURROUND_IDEAL;
    1824           0 :                 break;
    1825             :             case FN_WRAP_ANCHOR_ONLY:
    1826           0 :                 aWrap.SetAnchorOnly(!aWrap.IsAnchorOnly());
    1827             :                 //
    1828             :                 // keep previous wrapping
    1829             :                 //
    1830             :                 // switch to wrap SURROUND_PARALLEL, if previous wrap is SURROUND_NONE
    1831           0 :                 if ( nOldSurround != SURROUND_NONE )
    1832             :                 {
    1833           0 :                     nSurround = nOldSurround;
    1834             :                 }
    1835           0 :                 break;
    1836             :             case FN_FRAME_WRAP_CONTOUR:
    1837           0 :                 aWrap.SetContour(!aWrap.IsContour());
    1838           0 :                 if (nSurround == SURROUND_THROUGHT)
    1839           0 :                     nSurround = SURROUND_PARALLEL;
    1840           0 :                 break;
    1841             :             case FN_FRAME_WRAPTHRU_TRANSP:
    1842           0 :                 if (aWrap.IsContour())
    1843           0 :                     aWrap.SetContour(sal_False);
    1844             :                 // kein break!!!
    1845             :             case FN_FRAME_WRAPTHRU:
    1846           0 :                 nSurround = SURROUND_THROUGHT;
    1847           0 :                 break;
    1848             : 
    1849             :             case FN_FRAME_WRAP_LEFT:
    1850           0 :                 nSurround = SURROUND_LEFT;
    1851           0 :                 break;
    1852             : 
    1853             :             case FN_FRAME_WRAP_RIGHT:
    1854           0 :                 nSurround = SURROUND_RIGHT;
    1855           0 :                 break;
    1856             : 
    1857             :             default:
    1858           0 :                 break;
    1859             :         }
    1860           0 :         aWrap.SetSurround(nSurround);
    1861             : 
    1862           0 :         if (nSlot != FN_FRAME_WRAP_CONTOUR)
    1863             :         {
    1864             :             // Konturumfluss bei Draw-Objekten defaulten
    1865           0 :             if (bObj && nOldSurround != nSurround &&
    1866             :                 (nOldSurround == SURROUND_NONE || nOldSurround == SURROUND_THROUGHT))
    1867             :             {
    1868           0 :                 aWrap.SetContour(sal_True);
    1869             :             }
    1870             :         }
    1871             : 
    1872           0 :         aSet.Put( aWrap );
    1873           0 :         aSet.Put(SvxOpaqueItem(RES_OPAQUE, nSlot != FN_FRAME_WRAPTHRU_TRANSP));
    1874           0 :         if(bObj)
    1875             :         {
    1876           0 :             rSh.SetObjAttr(aSet);
    1877           0 :             if (nSlot != FN_FRAME_WRAPTHRU_TRANSP)
    1878           0 :                 rSh.SelectionToHeaven();
    1879             :             else
    1880           0 :                 rSh.SelectionToHell();
    1881             :         }
    1882             :         else
    1883           0 :             rSh.SetFlyFrmAttr(aSet);
    1884             :     }
    1885           0 : }
    1886             : 
    1887             : /*--------------------------------------------------------------------
    1888             :     Beschreibung:   Update der Statuszeile erzwingen
    1889             :  --------------------------------------------------------------------*/
    1890           0 : void SwBaseShell::SetFrmMode(FlyMode eMode, SwWrtShell *pSh )
    1891             : {
    1892           0 :     eFrameMode = eMode;
    1893           0 :     SfxBindings &rBnd = pSh->GetView().GetViewFrame()->GetBindings();
    1894             : 
    1895           0 :     if( eMode == FLY_DRAG ||
    1896           0 :         (pSh && (pSh->IsFrmSelected() || pSh->IsObjSelected())) )
    1897             :     {
    1898           0 :         const SfxPointItem aTmp1( SID_ATTR_POSITION, pSh->GetAnchorObjDiff());
    1899           0 :         const SvxSizeItem  aTmp2( SID_ATTR_SIZE,     pSh->GetObjSize());
    1900           0 :         rBnd.SetState( aTmp1 );
    1901           0 :         rBnd.SetState( aTmp2 );
    1902             :     }
    1903           0 :     else if( eMode == FLY_DRAG_END )
    1904             :     {
    1905             :         static sal_uInt16 aInval[] =
    1906             :         {
    1907             :             SID_ATTR_POSITION, SID_ATTR_SIZE, 0
    1908             :         };
    1909           0 :         rBnd.Invalidate(aInval);
    1910             :     }
    1911           0 : }
    1912             : 
    1913             : /*--------------------------------------------------------------------
    1914             :     Beschreibung:   Ctor
    1915             :  --------------------------------------------------------------------*/
    1916             : 
    1917         498 : SwBaseShell::SwBaseShell(SwView& rVw) :
    1918             :     SfxShell( &rVw ),
    1919             :     rView(rVw),
    1920         498 :     pGetStateSet(0)
    1921             : {
    1922         498 :     SwWrtShell& rWrtSh = rView.GetWrtShell();
    1923             : 
    1924         498 :     SetPool(&rWrtSh.GetAttrPool());
    1925         498 :     SetName(rtl::OUString("Base"));
    1926         498 :     rWrtSh.SetGrfArrivedLnk( LINK( this, SwBaseShell, GraphicArrivedHdl));
    1927         498 : }
    1928             : 
    1929         262 : SwBaseShell::~SwBaseShell()
    1930             : {
    1931         131 :     if( rView.GetCurShell() == this )
    1932           0 :         rView.ResetSubShell();
    1933             : 
    1934         131 :     Link aTmp( LINK( this, SwBaseShell, GraphicArrivedHdl));
    1935         131 :     if( aTmp == rView.GetWrtShell().GetGrfArrivedLnk() )
    1936          63 :         rView.GetWrtShell().SetGrfArrivedLnk( Link() );
    1937         131 : }
    1938             : 
    1939           0 : void SwBaseShell::ExecTxtCtrl( SfxRequest& rReq )
    1940             : {
    1941           0 :     const SfxItemSet *pArgs = rReq.GetArgs();
    1942             : 
    1943           0 :     if( pArgs)
    1944             :     {
    1945           0 :         SwWrtShell &rSh = GetShell();
    1946           0 :         SvxScriptSetItem* pSSetItem = 0;
    1947           0 :         sal_uInt16 nSlot = rReq.GetSlot();
    1948           0 :         SfxItemPool& rPool = rSh.GetAttrPool();
    1949           0 :         sal_uInt16 nWhich = rPool.GetWhich( nSlot );
    1950           0 :         sal_uInt16 nScripts = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
    1951           0 :         SfxItemSet aHeightSet( GetPool(),  RES_CHRATR_FONTSIZE, RES_CHRATR_FONTSIZE,
    1952             :                                             RES_CHRATR_CJK_FONTSIZE, RES_CHRATR_CJK_FONTSIZE,
    1953             :                                             RES_CHRATR_CTL_FONTSIZE, RES_CHRATR_CTL_FONTSIZE,
    1954           0 :                                         0L);
    1955             : 
    1956           0 :         switch( nSlot )
    1957             :         {
    1958             :             case SID_ATTR_CHAR_FONT:
    1959             :             {
    1960           0 :                 nScripts = rSh.GetScriptType();
    1961             :                 // #i42732# input language should be preferred over
    1962             :                 // current cursor position to detect script type
    1963           0 :                 if(!rSh.HasSelection())
    1964             :                 {
    1965           0 :                     LanguageType nInputLang = GetView().GetEditWin().GetInputLanguage();
    1966           0 :                     if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
    1967           0 :                         nScripts = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
    1968             :                 }
    1969             :             }
    1970             :             case SID_ATTR_CHAR_POSTURE:
    1971             :             case SID_ATTR_CHAR_WEIGHT:
    1972             :             {
    1973           0 :                 pSSetItem = new SvxScriptSetItem( nSlot, rPool );
    1974           0 :                 pSSetItem->PutItemForScriptType( nScripts, pArgs->Get( nWhich ));
    1975           0 :                 pArgs = &pSSetItem->GetItemSet();
    1976             :             }
    1977           0 :             break;
    1978             :             case SID_ATTR_CHAR_FONTHEIGHT:
    1979             :             {
    1980           0 :                 if(rSh.HasSelection())
    1981             :                 {
    1982           0 :                     pSSetItem = new SvxScriptSetItem( nSlot, rPool );
    1983           0 :                     pSSetItem->PutItemForScriptType( nScripts, pArgs->Get( nWhich ));
    1984           0 :                     pArgs = &pSSetItem->GetItemSet();
    1985             :                 }
    1986             :                 else
    1987             :                 {
    1988           0 :                     nScripts = rSh.GetScriptType();
    1989           0 :                     LanguageType nInputLang = GetView().GetEditWin().GetInputLanguage();
    1990           0 :                     if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
    1991           0 :                         nScripts = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
    1992           0 :                     sal_uInt32 nHeight = static_cast< const SvxFontHeightItem& >(pArgs->Get( nWhich )).GetHeight();
    1993           0 :                     SwStdFontConfig* pStdFont = SW_MOD()->GetStdFontConfig();
    1994             : 
    1995           0 :                     SfxItemSet aLangSet( GetPool(), RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE,
    1996             :                                                     RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_LANGUAGE,
    1997             :                                                     RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_LANGUAGE,
    1998           0 :                                                     0L);
    1999           0 :                     rSh.GetCurAttr( aLangSet );
    2000             : 
    2001             :                     sal_Int32 nWesternSize =
    2002             :                             pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_DEFAULT,
    2003           0 :                             static_cast<const SvxLanguageItem&>(aLangSet.Get( RES_CHRATR_LANGUAGE)).GetLanguage());
    2004             :                     sal_Int32 nCJKSize =
    2005             :                             pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_CJK,
    2006           0 :                             static_cast<const SvxLanguageItem&>(aLangSet.Get( RES_CHRATR_CJK_LANGUAGE)).GetLanguage());
    2007             :                     sal_Int32 nCTLSize =
    2008             :                             pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_CTL,
    2009           0 :                             static_cast<const SvxLanguageItem&>(aLangSet.Get( RES_CHRATR_CTL_LANGUAGE)).GetLanguage());
    2010             : 
    2011           0 :                     switch(nScripts)
    2012             :                     {
    2013             :                         case SCRIPTTYPE_LATIN:
    2014           0 :                             nCJKSize = nHeight * nCJKSize / nWesternSize;
    2015           0 :                             nCTLSize = nHeight * nCTLSize / nWesternSize;
    2016           0 :                             nWesternSize = (sal_Int32) nHeight;
    2017           0 :                         break;
    2018             :                         case SCRIPTTYPE_ASIAN:
    2019           0 :                             nCTLSize = nHeight* nCTLSize / nCJKSize;
    2020           0 :                             nWesternSize = nHeight * nWesternSize / nCJKSize;
    2021           0 :                             nCJKSize = (sal_Int32) nHeight;
    2022           0 :                         break;
    2023             :                         case SCRIPTTYPE_COMPLEX:
    2024           0 :                             nCJKSize = nHeight * nCJKSize / nCTLSize;
    2025           0 :                             nWesternSize = nHeight * nWesternSize / nCTLSize;
    2026           0 :                             nCTLSize = (sal_Int32) nHeight;
    2027           0 :                         break;
    2028             :                     }
    2029           0 :                     aHeightSet.Put( SvxFontHeightItem( (sal_uInt32)nWesternSize, 100, RES_CHRATR_FONTSIZE ));
    2030           0 :                     aHeightSet.Put( SvxFontHeightItem( (sal_uInt32)nCJKSize, 100, RES_CHRATR_CJK_FONTSIZE ));
    2031           0 :                     aHeightSet.Put( SvxFontHeightItem( (sal_uInt32)nCTLSize, 100, RES_CHRATR_CTL_FONTSIZE ));
    2032           0 :                     pArgs = &aHeightSet;
    2033             :                 }
    2034             :             }
    2035           0 :             break;
    2036             :         }
    2037             : 
    2038           0 :         if( pArgs )
    2039             :         {
    2040           0 :             bool bAuto = false;
    2041           0 :             if ( !isCHRATR(nWhich) ||
    2042           0 :                  ( rSh.HasSelection() && rSh.IsSelFullPara() ) )
    2043             :             {
    2044           0 :                 SwTxtFmtColl * pColl = rSh.GetCurTxtFmtColl();
    2045           0 :                 if ( pColl && pColl->IsAutoUpdateFmt() )
    2046             :                 {
    2047           0 :                     rSh.AutoUpdatePara( pColl, *pArgs );
    2048           0 :                     bAuto = true;
    2049             :                 }
    2050             :             }
    2051             : 
    2052           0 :             if (!bAuto)
    2053             :             {
    2054           0 :                 rSh.SetAttr( *pArgs );
    2055             :             }
    2056             :         }
    2057           0 :         delete pSSetItem;
    2058             :     }
    2059             :     else
    2060           0 :         GetView().GetViewFrame()->GetDispatcher()->Execute( SID_CHAR_DLG, sal_False);
    2061           0 :     rReq.Done();
    2062           0 : }
    2063             : 
    2064           0 : void SwBaseShell::GetTxtCtrlState( SfxItemSet& rSet )
    2065             : {
    2066           0 :     SwWrtShell &rSh = GetShell();
    2067           0 :     rSh.GetCurAttr( rSet );
    2068           0 : }
    2069             : 
    2070           0 : void SwBaseShell::GetTxtFontCtrlState( SfxItemSet& rSet )
    2071             : {
    2072           0 :     SwWrtShell &rSh = GetShell();
    2073           0 :     sal_Bool bFirst = sal_True;
    2074           0 :     SfxItemSet* pFntCoreSet = 0;
    2075           0 :     sal_uInt16 nScriptType = SCRIPTTYPE_LATIN;
    2076           0 :     SfxWhichIter aIter( rSet );
    2077           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
    2078           0 :     while( nWhich )
    2079             :     {
    2080           0 :         switch( nWhich )
    2081             :         {
    2082             :         case RES_CHRATR_FONT:
    2083             :         case RES_CHRATR_FONTSIZE:
    2084             :         case RES_CHRATR_WEIGHT:
    2085             :         case RES_CHRATR_POSTURE:
    2086             :             {
    2087           0 :                 if( !pFntCoreSet )
    2088             :                 {
    2089             :                     pFntCoreSet = new SfxItemSet( *rSet.GetPool(),
    2090           0 :                                     RES_CHRATR_BEGIN, RES_CHRATR_END-1 );
    2091           0 :                     rSh.GetCurAttr( *pFntCoreSet );
    2092           0 :                     nScriptType = rSh.GetScriptType();
    2093             :                     // #i42732# input language should be preferred over
    2094             :                     // current cursor position to detect script type
    2095           0 :                     SwEditWin& rEditWin = GetView().GetEditWin();
    2096           0 :                     if( rEditWin.IsUseInputLanguage() )
    2097             :                     {
    2098           0 :                         if(!rSh.HasSelection() && (
    2099             :                             nWhich == RES_CHRATR_FONT ||
    2100             :                             nWhich == RES_CHRATR_FONTSIZE ))
    2101             :                         {
    2102           0 :                             LanguageType nInputLang = rEditWin.GetInputLanguage();
    2103           0 :                             if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
    2104           0 :                                 nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
    2105             :                         }
    2106             :                     }
    2107             :                 }
    2108           0 :                 SfxItemPool& rPool = *rSet.GetPool();
    2109           0 :                 SvxScriptSetItem aSetItem( rPool.GetSlotId( nWhich ), rPool );
    2110           0 :                 aSetItem.GetItemSet().Put( *pFntCoreSet, sal_False );
    2111           0 :                 const SfxPoolItem* pI = aSetItem.GetItemOfScript( nScriptType );
    2112           0 :                 if( pI )
    2113           0 :                     rSet.Put( *pI, nWhich );
    2114             :                 else
    2115           0 :                     rSet.InvalidateItem( nWhich );
    2116             :                 //set input context of the SwEditWin according to the selected font and script type
    2117           0 :                 if(RES_CHRATR_FONT == nWhich)
    2118             :                 {
    2119           0 :                     Font aFont;
    2120           0 :                     if(pI && pI->ISA(SvxFontItem))
    2121             :                     {
    2122           0 :                         aFont.SetName( ((const SvxFontItem*)pI)->GetFamilyName());
    2123           0 :                         aFont.SetStyleName(((const SvxFontItem*)pI)->GetStyleName());
    2124           0 :                         aFont.SetFamily(((const SvxFontItem*)pI)->GetFamily());
    2125           0 :                         aFont.SetPitch(((const SvxFontItem*)pI)->GetPitch());
    2126           0 :                         aFont.SetCharSet(((const SvxFontItem*)pI)->GetCharSet());
    2127             :                     }
    2128             : 
    2129           0 :                     bool bVertical = rSh.IsInVerticalText();
    2130           0 :                     aFont.SetOrientation(bVertical ? 2700 : 0);
    2131           0 :                     aFont.SetVertical(bVertical ? sal_True : sal_False);
    2132           0 :                     GetView().GetEditWin().SetInputContext( InputContext( aFont, INPUTCONTEXT_TEXT |
    2133           0 :                                                         INPUTCONTEXT_EXTTEXTINPUT ) );
    2134           0 :                 }
    2135             :             }
    2136           0 :             break;
    2137             : 
    2138             :         default:
    2139           0 :             if( bFirst )
    2140             :             {
    2141           0 :                 rSh.GetCurAttr( rSet );
    2142           0 :                 bFirst = sal_False;
    2143             :             }
    2144             :         }
    2145           0 :         nWhich = aIter.NextWhich();
    2146             :     }
    2147           0 :     delete pFntCoreSet;
    2148           0 : }
    2149             : 
    2150           0 : void SwBaseShell::GetBckColState(SfxItemSet &rSet)
    2151             : {
    2152           0 :     SwWrtShell &rSh = GetShell();
    2153           0 :     SfxWhichIter aIter( rSet );
    2154           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
    2155           0 :     int nSelType = rSh.GetSelectionType();
    2156             : 
    2157           0 :     if( nSelType & nsSelectionType::SEL_OLE )
    2158             :     {
    2159           0 :         rSet.DisableItem( SID_BACKGROUND_COLOR );
    2160             :         return;
    2161             :     }
    2162             : 
    2163           0 :     if ( nSelType & nsSelectionType::SEL_FRM )
    2164             :     {
    2165           0 :         sal_Bool bParentCntProt = rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
    2166           0 :         if (bParentCntProt)
    2167             :         {
    2168           0 :             rSet.DisableItem( SID_BACKGROUND_COLOR );
    2169             :             return;
    2170             :         }
    2171             :     }
    2172             : 
    2173           0 :     SvxBrushItem aBrushItem( RES_BACKGROUND );
    2174             : 
    2175           0 :     if( nsSelectionType::SEL_TBL_CELLS & nSelType )
    2176           0 :         rSh.GetBoxBackground( aBrushItem );
    2177             :     else
    2178             :     {
    2179           0 :         SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
    2180           0 :         if( nSelType & nsSelectionType::SEL_GRF || nsSelectionType::SEL_FRM & nSelType )
    2181           0 :             rSh.GetFlyFrmAttr( aCoreSet );
    2182             :         else
    2183           0 :             rSh.GetCurAttr( aCoreSet );
    2184           0 :         aBrushItem = (const SvxBrushItem&)aCoreSet.Get(RES_BACKGROUND);
    2185             :     }
    2186             : 
    2187           0 :     while ( nWhich )
    2188             :     {
    2189           0 :         switch(nWhich)
    2190             :         {
    2191             :             case SID_BACKGROUND_COLOR  :
    2192             :             {
    2193           0 :                 SvxColorItem aColorItem(aBrushItem.GetColor(), SID_BACKGROUND_COLOR);
    2194           0 :                 rSet.Put( aColorItem, SID_BACKGROUND_COLOR );
    2195             :             }
    2196           0 :             break;
    2197             :             case SID_ATTR_BRUSH:
    2198             :             case RES_BACKGROUND:
    2199           0 :                 rSet.Put( aBrushItem, GetPool().GetWhich(nWhich) );
    2200           0 :             break;
    2201             :         }
    2202           0 :         nWhich = aIter.NextWhich();
    2203           0 :     }
    2204             : }
    2205             : 
    2206           0 : void SwBaseShell::ExecBckCol(SfxRequest& rReq)
    2207             : {
    2208           0 :     SwWrtShell &rSh = GetShell();
    2209           0 :     int nSelType = rSh.GetSelectionType();
    2210           0 :     if ( nSelType & nsSelectionType::SEL_OLE )
    2211             :     {
    2212             :         return;
    2213             :     }
    2214             : 
    2215           0 :     const SfxItemSet* pArgs = rReq.GetArgs();
    2216           0 :     sal_uInt16 nSlot = rReq.GetSlot();
    2217           0 :     if( !pArgs  && nSlot != SID_BACKGROUND_COLOR)
    2218             :         return ;
    2219             : 
    2220           0 :     SvxBrushItem aBrushItem( RES_BACKGROUND );
    2221             : 
    2222           0 :     if( nsSelectionType::SEL_TBL_CELLS & nSelType )
    2223             :     {
    2224           0 :         rSh.GetBoxBackground( aBrushItem );
    2225             :     }
    2226             :     else
    2227             :     {
    2228           0 :         SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
    2229           0 :         if( (nsSelectionType::SEL_FRM & nSelType) || (nsSelectionType::SEL_GRF & nSelType) )
    2230           0 :             rSh.GetFlyFrmAttr( aCoreSet );
    2231             :         else
    2232           0 :             rSh.GetCurAttr( aCoreSet );
    2233           0 :         aBrushItem = (const SvxBrushItem&)aCoreSet.Get(RES_BACKGROUND);
    2234             :     }
    2235             : 
    2236           0 :     switch (nSlot)
    2237             :     {
    2238             :         // RES_BACKGROUND (=SID_ATTR_BRUSH) muss ueber zwei IDs
    2239             :         // gesetzt werden:
    2240             :         case SID_BACKGROUND_COLOR:
    2241             :             {
    2242           0 :                 aBrushItem.SetGraphicPos(GPOS_NONE);
    2243             : 
    2244           0 :                 if(pArgs)
    2245             :                 {
    2246             :                     const SvxColorItem& rNewColorItem = (const SvxColorItem&)
    2247           0 :                                             pArgs->Get(SID_BACKGROUND_COLOR);
    2248           0 :                     const Color& rNewColor = rNewColorItem.GetValue();
    2249           0 :                     aBrushItem.SetColor( rNewColor );
    2250           0 :                     GetView().GetViewFrame()->GetBindings().SetState(rNewColorItem);
    2251             :                 }
    2252             :                 else
    2253             :                 {
    2254           0 :                     aBrushItem.SetColor( COL_TRANSPARENT );
    2255           0 :                     rReq.AppendItem( SvxColorItem( Color( COL_TRANSPARENT ), nSlot ) );
    2256             :                 }
    2257             :             }
    2258           0 :             break;
    2259             : 
    2260             :         case SID_ATTR_BRUSH:
    2261             :         case RES_BACKGROUND:
    2262             :         {
    2263             :             const SvxBrushItem& rNewBrushItem = (const SvxBrushItem&)
    2264           0 :                                     pArgs->Get( GetPool().GetWhich(nSlot) );
    2265           0 :             aBrushItem = rNewBrushItem;
    2266             :         }
    2267           0 :         break;
    2268             :         default:
    2269           0 :             rReq.Ignore();
    2270             :             OSL_FAIL("unknown message in ExecuteAttr!" );
    2271             :             return;
    2272             :     }
    2273             : 
    2274           0 :     if( nsSelectionType::SEL_TBL_CELLS & nSelType )
    2275             :     {
    2276           0 :         rSh.SetBoxBackground( aBrushItem );
    2277             :     }
    2278           0 :     else if( (nsSelectionType::SEL_FRM & nSelType) ||
    2279             :         (nsSelectionType::SEL_GRF & nSelType)  )
    2280             :     {
    2281           0 :         SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
    2282           0 :         aCoreSet.Put( aBrushItem );
    2283             :         // Vorlagen-AutoUpdate
    2284           0 :         SwFrmFmt* pFmt = rSh.GetCurFrmFmt();
    2285           0 :         if(pFmt && pFmt->IsAutoUpdateFmt())
    2286           0 :             rSh.AutoUpdateFrame( pFmt, aCoreSet);
    2287             :         else
    2288           0 :             rSh.SetFlyFrmAttr( aCoreSet );
    2289             :     }
    2290             :     else
    2291             :     {
    2292           0 :         SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
    2293           0 :         if( pColl && pColl->IsAutoUpdateFmt())
    2294             :         {
    2295           0 :             SfxItemSet aSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND );
    2296           0 :             aSet.Put(aBrushItem);
    2297           0 :             rSh.AutoUpdatePara( pColl, aSet);
    2298             :         }
    2299             :         else
    2300           0 :             rSh.SetAttr( aBrushItem );
    2301             :     }
    2302             : 
    2303           0 :     rReq.Done();
    2304             : }
    2305             : 
    2306           0 : void SwBaseShell::GetBorderState(SfxItemSet &rSet)
    2307             : {
    2308           0 :     SwWrtShell &rSh = GetShell();
    2309             :     // Tabellenzelle(n) selektiert?
    2310           0 :     sal_Bool bPrepare = sal_True;
    2311           0 :     sal_Bool bTableMode = rSh.IsTableMode();
    2312           0 :     if ( bTableMode )
    2313             :     {
    2314           0 :         SfxItemSet aCoreSet( GetPool(),
    2315             :                              RES_BOX, RES_BOX,
    2316           0 :                              SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
    2317           0 :         SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
    2318           0 :         aCoreSet.Put( aBoxInfo );
    2319           0 :         rSh.GetTabBorders( aCoreSet );
    2320           0 :         rSet.Put( aCoreSet );
    2321             :     }
    2322           0 :     else if ( rSh.IsFrmSelected() )
    2323             :     {
    2324           0 :         SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
    2325           0 :         rSet.Put( aMgr.GetAttrSet() );
    2326           0 :         bPrepare = sal_False;
    2327             :     }
    2328             :     else
    2329             :         // Umrandungsattribute ganz normal ueber Shell holen
    2330           0 :         rSh.GetCurAttr( rSet );
    2331           0 :     if ( bPrepare )
    2332           0 :         ::PrepareBoxInfo( rSet, rSh );
    2333             :     // switch the border toolbox controller mode
    2334           0 :     rSet.Put( SfxBoolItem( SID_BORDER_REDUCED_MODE, !bTableMode ));
    2335           0 : }
    2336             : 
    2337           0 : void SwBaseShell::ExecDlg(SfxRequest &rReq)
    2338             : {
    2339           0 :     SwWrtShell &rSh = GetShell();
    2340           0 :     Window *pMDI = &GetView().GetViewFrame()->GetWindow();
    2341             :     //Damit aus dem Basic keine Dialoge fuer Hintergrund-Views aufgerufen werden:
    2342           0 :     sal_Bool bBackground = (&GetView() != GetActiveView());
    2343           0 :     const SfxPoolItem* pItem = 0;
    2344           0 :     const SfxItemSet* pArgs = rReq.GetArgs();
    2345             : 
    2346           0 :     sal_uInt16 nSlot = rReq.GetSlot();
    2347           0 :     const SfxItemSet* pOutSet = 0;
    2348           0 :     bool bDone = false;
    2349           0 :     if(pArgs)
    2350           0 :         pArgs->GetItemState( GetPool().GetWhich(nSlot), sal_False, &pItem );
    2351             : 
    2352           0 :     switch ( nSlot )
    2353             :     {
    2354             :         case FN_FORMAT_TITLEPAGE_DLG:
    2355             :         {
    2356           0 :             SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
    2357           0 :             VclAbstractDialog* pDlg = pFact->CreateTitlePageDlg( pMDI );
    2358           0 :             pDlg->Execute();
    2359           0 :             delete pDlg;
    2360             :         }
    2361           0 :         break;
    2362             :         case FN_FORMAT_PAGE_COLUMN_DLG:
    2363             :         case FN_FORMAT_PAGE_DLG:
    2364             :         {
    2365           0 :             if( !bBackground )
    2366             :             {
    2367           0 :                 const sal_uInt16 nCurIdx = rSh.GetCurPageDesc();
    2368           0 :                 const SwPageDesc& rPageDesc = rSh.GetPageDesc( nCurIdx );
    2369             :                 //temp. View, weil die Shell nach dem Dialog nicht mehr gueltig sein muss
    2370             :                 //z.B. Kopfzeile ausschalten
    2371           0 :                 SwView& rTempView = GetView();
    2372           0 :                 sal_uInt16 nPageId = 0;
    2373           0 :                 if ( nSlot == FN_FORMAT_PAGE_COLUMN_DLG )
    2374           0 :                     nPageId = TP_COLUMN ;
    2375           0 :                 rTempView.GetDocShell()->FormatPage(rPageDesc.GetName(),
    2376           0 :                                     nPageId, &rSh );
    2377           0 :                 rTempView.InvalidateRulerPos();
    2378             :             }
    2379             :         }
    2380           0 :         break;
    2381             :         case FN_FORMAT_BORDER_DLG:
    2382             :         {
    2383           0 :             SfxItemSet   aSet( rSh.GetAttrPool(),
    2384             :                                RES_BOX              , RES_SHADOW,
    2385             :                                SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
    2386           0 :                                0 );
    2387           0 :             SfxAbstractDialog * pDlg = 0;
    2388             :             // Tabellenzelle(n) selektiert?
    2389           0 :             if ( rSh.IsTableMode() )
    2390             :             {
    2391             :                 // Umrandungattribute Get/SetTabBorders() setzen
    2392           0 :                 ::PrepareBoxInfo( aSet, rSh );
    2393           0 :                 rSh.GetTabBorders( aSet );
    2394           0 :                 SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
    2395             :                 OSL_ENSURE(pFact, "SwAbstractDialogFactory fail!");
    2396             : 
    2397           0 :                 pDlg = pFact->CreateSwBorderDlg( pMDI, aSet, SW_BORDER_MODE_TABLE, RC_DLG_SWBORDERDLG );
    2398             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2399           0 :                 if ( pDlg->Execute() == RET_OK )
    2400             :                 {
    2401           0 :                     rSh.SetTabBorders( *pDlg->GetOutputItemSet() );
    2402           0 :                     pOutSet = pDlg->GetOutputItemSet();
    2403             :                 }
    2404             :             }
    2405           0 :             else if ( rSh.IsFrmSelected() )
    2406             :             {
    2407             :                 // Umrandungsattribute ueber Frame-Manager setzen
    2408           0 :                 SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
    2409           0 :                 aSet.Put( aMgr.GetAttrSet() );
    2410             : 
    2411           0 :                 SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
    2412             :                 OSL_ENSURE(pFact, "SwAbstractDialogFactory fail!");
    2413             : 
    2414           0 :                 pDlg = pFact->CreateSwBorderDlg( pMDI, aSet, SW_BORDER_MODE_FRAME, RC_DLG_SWBORDERDLG );
    2415             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2416           0 :                 if ( pDlg->Execute() == RET_OK )
    2417             :                 {
    2418           0 :                     aMgr.SetAttrSet( *pDlg->GetOutputItemSet() );
    2419           0 :                     aMgr.UpdateFlyFrm();
    2420           0 :                     pOutSet = pDlg->GetOutputItemSet();
    2421           0 :                 }
    2422             :             }
    2423             :             else
    2424             :             {
    2425             :                 // Umrandungsattribute ganz normal ueber Shell setzen
    2426           0 :                 rSh.GetCurAttr( aSet );
    2427           0 :                 ::PrepareBoxInfo( aSet, rSh );
    2428             : 
    2429           0 :                 SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
    2430             :                 OSL_ENSURE(pFact, "SwAbstractDialogFactory fail!");
    2431             : 
    2432           0 :                 pDlg = pFact->CreateSwBorderDlg( pMDI, aSet, SW_BORDER_MODE_PARA, RC_DLG_SWBORDERDLG );
    2433             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2434           0 :                 if ( pDlg->Execute() == RET_OK )
    2435             :                 {
    2436           0 :                     rSh.SetAttr( *pDlg->GetOutputItemSet() );
    2437           0 :                     pOutSet = pDlg->GetOutputItemSet();
    2438             :                 }
    2439             :             }
    2440           0 :             if(pOutSet)
    2441             :             {
    2442           0 :                 rReq.Done(*pOutSet);
    2443           0 :                 bDone = true;
    2444             :             }
    2445           0 :             delete pDlg;
    2446             :         }
    2447           0 :         break;
    2448             :         case FN_FORMAT_BACKGROUND_DLG:
    2449             :         {
    2450           0 :             SfxItemSet aSet( rSh.GetAttrPool(),
    2451           0 :                              RES_BACKGROUND, RES_BACKGROUND );
    2452             : 
    2453           0 :             SfxAbstractDialog * pDlg = 0;
    2454           0 :             SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
    2455             :             OSL_ENSURE(pFact, "SwAbstractDialogFactory fail!");
    2456             : 
    2457             : 
    2458             :             // Tabellenzelle(n) selektiert?
    2459           0 :             if ( rSh.IsTableMode() )
    2460             :             {
    2461             :                 //Hintergrundattribute der Tabelle holen und in den Set packen
    2462           0 :                 SvxBrushItem aBrush(RES_BACKGROUND);
    2463           0 :                 rSh.GetBoxBackground( aBrush );
    2464             :                 pDlg = pFact->CreateSfxDialog( pMDI, aSet,
    2465           0 :                     rView.GetViewFrame()->GetFrame().GetFrameInterface(),
    2466           0 :                     RC_SWDLG_BACKGROUND );
    2467             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2468           0 :                 aSet.Put( aBrush );
    2469           0 :                 if ( pDlg->Execute() == RET_OK )
    2470             :                 {
    2471             : 
    2472             :                     rSh.SetBoxBackground( (SvxBrushItem&)
    2473           0 :                         pDlg->GetOutputItemSet()->Get( RES_BACKGROUND ));
    2474           0 :                     pOutSet = pDlg->GetOutputItemSet();
    2475           0 :                 }
    2476             :             }
    2477           0 :             else if ( rSh.IsFrmSelected() )
    2478             :             {
    2479             : 
    2480           0 :                 rSh.GetFlyFrmAttr( aSet );
    2481             : 
    2482             :                 pDlg = pFact->CreateSfxDialog( pMDI, aSet,
    2483           0 :                     rView.GetViewFrame()->GetFrame().GetFrameInterface(),
    2484           0 :                     RC_SWDLG_BACKGROUND );
    2485             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2486           0 :                 if ( pDlg->Execute() == RET_OK )
    2487             :                 {
    2488           0 :                     rSh.SetFlyFrmAttr((SfxItemSet &) *pDlg->GetOutputItemSet() );
    2489           0 :                     pOutSet = pDlg->GetOutputItemSet();
    2490             :                 }
    2491             :             }
    2492             :             else
    2493             :             {
    2494             :                 // Umrandungsattribute ganz normal ueber Shell setzen
    2495           0 :                 rSh.GetCurAttr( aSet );
    2496             : 
    2497             :                 pDlg = pFact->CreateSfxDialog( pMDI, aSet,
    2498           0 :                     rView.GetViewFrame()->GetFrame().GetFrameInterface(),
    2499           0 :                     RC_SWDLG_BACKGROUND );
    2500             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2501           0 :                 if ( pDlg->Execute() == RET_OK )
    2502             :                 {
    2503           0 :                     rSh.SetAttr( *pDlg->GetOutputItemSet() );
    2504           0 :                     pOutSet = pDlg->GetOutputItemSet();
    2505             :                 }
    2506             :             }
    2507           0 :             if(pOutSet)
    2508             :             {
    2509           0 :                 rReq.Done(*pOutSet);
    2510           0 :                 bDone = true;
    2511             :             }
    2512           0 :             delete pDlg;
    2513             : 
    2514             :         }
    2515           0 :         break;
    2516             :         default:OSL_FAIL("wrong Dispatcher (basesh.cxx)");
    2517             :     }
    2518           0 :     if(!bDone)
    2519           0 :         rReq.Done();
    2520           0 : }
    2521             : 
    2522           0 : SwWrtShell& SwBaseShell::GetShell()
    2523             : {
    2524           0 :     return rView.GetWrtShell();
    2525             : }
    2526             : 
    2527           0 : SwWrtShell* SwBaseShell::GetShellPtr()
    2528             : {
    2529           0 :     return rView.GetWrtShellPtr();
    2530             : }
    2531             : 
    2532           0 : void SwBaseShell::InsertTable( SfxRequest& _rRequest )
    2533             : {
    2534           0 :     const SfxItemSet* pArgs = _rRequest.GetArgs();
    2535           0 :     SwWrtShell& rSh = GetShell();
    2536             : 
    2537           0 :     if ( !( rSh.GetFrmType( 0, sal_True ) & FRMTYPE_FOOTNOTE ) )
    2538             :     {
    2539           0 :         SwView &rTempView = GetView(); // Da GetView() nach Shellwechsel nicht mehr geht
    2540           0 :         sal_Bool bHTMLMode = 0 != (::GetHtmlMode(rTempView.GetDocShell())&HTMLMODE_ON);
    2541           0 :         sal_Bool bCallEndUndo = sal_False;
    2542             : 
    2543           0 :         if( !pArgs && rSh.IsSelection() && !rSh.IsInClickToEdit() &&
    2544           0 :             !rSh.IsTableMode() )
    2545             :         {
    2546           0 :             const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
    2547           0 :             SwInsertTableOptions aInsTblOpts = pModOpt->GetInsTblFlags(bHTMLMode);
    2548             : 
    2549           0 :             rSh.StartUndo(UNDO_INSTABLE);
    2550           0 :             bCallEndUndo = sal_True;
    2551             : 
    2552           0 :             sal_Bool bInserted = rSh.TextToTable( aInsTblOpts, '\t', text::HoriOrientation::FULL );
    2553           0 :             rSh.EnterStdMode();
    2554           0 :             if (bInserted)
    2555           0 :                 rTempView.AutoCaption(TABLE_CAP);
    2556           0 :             _rRequest.Done();
    2557             :         }
    2558             :         else
    2559             :         {
    2560           0 :             sal_uInt16 nCols = 0;
    2561           0 :             sal_uInt16 nRows = 0;
    2562           0 :             SwInsertTableOptions aInsTblOpts( tabopts::ALL_TBL_INS_ATTR, 1 );
    2563           0 :             String aTableName, aAutoName;
    2564           0 :             SwTableAutoFmt* pTAFmt = 0;
    2565             : 
    2566           0 :             if( pArgs && pArgs->Count() >= 2 )
    2567             :             {
    2568           0 :                 SFX_REQUEST_ARG( _rRequest, pName, SfxStringItem, FN_INSERT_TABLE, sal_False );
    2569           0 :                 SFX_REQUEST_ARG( _rRequest, pCols, SfxUInt16Item, SID_ATTR_TABLE_COLUMN, sal_False );
    2570           0 :                 SFX_REQUEST_ARG( _rRequest, pRows, SfxUInt16Item, SID_ATTR_TABLE_ROW, sal_False );
    2571           0 :                 SFX_REQUEST_ARG( _rRequest, pFlags, SfxInt32Item, FN_PARAM_1, sal_False );
    2572           0 :                 SFX_REQUEST_ARG( _rRequest, pAuto, SfxStringItem, FN_PARAM_2, sal_False );
    2573             : 
    2574           0 :                 if ( pName )
    2575           0 :                     aTableName = pName->GetValue();
    2576           0 :                 if ( pCols )
    2577           0 :                     nCols = pCols->GetValue();
    2578           0 :                 if ( pRows )
    2579           0 :                     nRows = pRows->GetValue();
    2580           0 :                 if ( pAuto )
    2581             :                 {
    2582           0 :                     aAutoName = pAuto->GetValue();
    2583           0 :                     if ( aAutoName.Len() )
    2584             :                     {
    2585           0 :                         SwTableAutoFmtTbl aTableTbl;
    2586           0 :                         aTableTbl.Load();
    2587           0 :                         for ( sal_uInt16 n=0; n<aTableTbl.size(); n++ )
    2588             :                         {
    2589           0 :                             if ( aTableTbl[n].GetName() == aAutoName )
    2590             :                             {
    2591           0 :                                 pTAFmt = new SwTableAutoFmt( aTableTbl[n] );
    2592           0 :                                 break;
    2593             :                             }
    2594           0 :                         }
    2595             :                     }
    2596             :                 }
    2597             : 
    2598           0 :                 if ( pFlags )
    2599           0 :                     aInsTblOpts.mnInsMode = (sal_uInt16) pFlags->GetValue();
    2600             :                 else
    2601             :                 {
    2602           0 :                     const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
    2603           0 :                     aInsTblOpts = pModOpt->GetInsTblFlags(bHTMLMode);
    2604             :                 }
    2605             :             }
    2606             : 
    2607           0 :             if( !nCols || !nRows )
    2608             :             {
    2609           0 :                 SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
    2610             :                 OSL_ENSURE(pFact, "Dialogdiet fail!");
    2611           0 :                 AbstractInsTableDlg* pDlg = pFact->CreateInsTableDlg(rTempView);
    2612             :                 OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2613           0 :                 if( RET_OK == pDlg->Execute() )
    2614             :                 {
    2615           0 :                     pDlg->GetValues( aTableName, nRows, nCols, aInsTblOpts, aAutoName, pTAFmt );
    2616             :                 }
    2617             :                 else
    2618           0 :                     _rRequest.Ignore();
    2619           0 :                 delete pDlg;
    2620             :             }
    2621             : 
    2622           0 :             if( nCols && nRows )
    2623             :             {
    2624             :                 // record before shell change
    2625           0 :                 _rRequest.AppendItem( SfxStringItem( FN_INSERT_TABLE, aTableName ) );
    2626           0 :                 if ( aAutoName.Len() )
    2627           0 :                     _rRequest.AppendItem( SfxStringItem( FN_PARAM_2, aAutoName ) );
    2628           0 :                 _rRequest.AppendItem( SfxUInt16Item( SID_ATTR_TABLE_COLUMN, nCols ) );
    2629           0 :                 _rRequest.AppendItem( SfxUInt16Item( SID_ATTR_TABLE_ROW, nRows ) );
    2630           0 :                 _rRequest.AppendItem( SfxInt32Item( FN_PARAM_1, (sal_Int32) aInsTblOpts.mnInsMode ) );
    2631           0 :                 _rRequest.Done();
    2632             : 
    2633           0 :                 rSh.StartUndo(UNDO_INSTABLE);
    2634           0 :                 bCallEndUndo = sal_True;
    2635             : 
    2636           0 :                 rSh.StartAllAction();
    2637           0 :                 if( rSh.HasSelection() )
    2638           0 :                     rSh.DelRight();
    2639             : 
    2640           0 :                 rSh.InsertTable( aInsTblOpts, nRows, nCols, text::HoriOrientation::FULL, pTAFmt );
    2641           0 :                 rSh.MoveTable( fnTablePrev, fnTableStart );
    2642             : 
    2643           0 :                 if( aTableName.Len() && !rSh.GetTblStyle( aTableName ) )
    2644           0 :                     rSh.GetTableFmt()->SetName( aTableName );
    2645             : 
    2646           0 :                 rSh.EndAllAction();
    2647           0 :                 rTempView.AutoCaption(TABLE_CAP);
    2648             :             }
    2649           0 :             delete pTAFmt;
    2650             :         }
    2651             : 
    2652           0 :         if( bCallEndUndo )
    2653             :         {
    2654           0 :             SwRewriter aRewriter;
    2655             : 
    2656           0 :             if (rSh.GetTableFmt())
    2657             :             {
    2658           0 :                 aRewriter.AddRule(UndoArg1, SW_RESSTR(STR_START_QUOTE));
    2659           0 :                 aRewriter.AddRule(UndoArg2, rSh.GetTableFmt()->GetName());
    2660           0 :                 aRewriter.AddRule(UndoArg3, SW_RESSTR(STR_END_QUOTE));
    2661             : 
    2662             :             }
    2663           0 :             rSh.EndUndo(UNDO_INSTABLE, &aRewriter); // wegen moegl. Shellwechsel
    2664             :         }
    2665             :     }
    2666           0 : }
    2667             : 
    2668           0 : void SwBaseShell::GetGalleryState( SfxItemSet &rSet )
    2669             : {
    2670           0 :     SwWrtShell &rSh = GetShell();
    2671           0 :     SfxWhichIter aIter( rSet );
    2672           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
    2673           0 :     switch ( nWhich )
    2674             :     {
    2675             :         case SID_GALLERY_BG_BRUSH:
    2676             :         {
    2677           0 :             int nSel = rSh.GetSelectionType();
    2678           0 :             SfxStringListItem aLst( nWhich );
    2679           0 :             std::vector<String> &rLst = aLst.GetList();
    2680             :             nParagraphPos = nGraphicPos = nOlePos = nFramePos = nTablePos =
    2681             :             nTableRowPos  = nTableCellPos = nPagePos =
    2682           0 :             nHeaderPos    = nFooterPos = 0;
    2683           0 :             sal_uInt8 nPos = 1;
    2684           0 :             rLst.push_back( SW_RESSTR( STR_SWBG_PAGE ) );
    2685           0 :             nPagePos = nPos++;
    2686           0 :             sal_uInt16 nHtmlMode = ::GetHtmlMode(GetView().GetDocShell());
    2687           0 :             sal_Bool bHtmlMode = 0 != (nHtmlMode & HTMLMODE_ON);
    2688             : 
    2689           0 :             if ( (!bHtmlMode || (nHtmlMode & HTMLMODE_FULL_STYLES)) &&
    2690             :                  (nSel & nsSelectionType::SEL_TXT) )
    2691             :             {
    2692           0 :                 rLst.push_back( SW_RESSTR( STR_SWBG_PARAGRAPH ) );
    2693           0 :                 nParagraphPos = nPos++;
    2694             :             }
    2695           0 :             if ( (!bHtmlMode || (nHtmlMode & HTMLMODE_SOME_STYLES)) &&
    2696             :                     nSel & (nsSelectionType::SEL_TBL|nsSelectionType::SEL_TBL_CELLS) )
    2697             :             {
    2698           0 :                 rLst.push_back( SW_RESSTR( STR_SWBG_TABLE ) );
    2699           0 :                 nTablePos = nPos++;
    2700             : 
    2701           0 :                 if(!bHtmlMode)
    2702             :                 {
    2703           0 :                     rLst.push_back( SW_RESSTR( STR_SWBG_TABLE_ROW ) );
    2704           0 :                     nTableRowPos = nPos++;
    2705             :                 }
    2706             : 
    2707           0 :                 rLst.push_back( SW_RESSTR( STR_SWBG_TABLE_CELL) );
    2708           0 :                 nTableCellPos = nPos++;
    2709             :             }
    2710           0 :             if(!bHtmlMode)
    2711             :             {
    2712           0 :                 if ( nSel & nsSelectionType::SEL_FRM )
    2713             :                 {
    2714           0 :                     rLst.push_back( SW_RESSTR( STR_SWBG_FRAME ) );
    2715           0 :                     nFramePos = nPos++;
    2716             :                 }
    2717           0 :                 if ( nSel & nsSelectionType::SEL_GRF )
    2718             :                 {
    2719           0 :                     rLst.push_back( SW_RESSTR( STR_SWBG_GRAPHIC ) );
    2720           0 :                     nGraphicPos = nPos++;
    2721             :                 }
    2722           0 :                 if ( nSel & nsSelectionType::SEL_OLE )
    2723             :                 {
    2724           0 :                     rLst.push_back( SW_RESSTR( STR_SWBG_OLE ) );
    2725           0 :                     nOlePos = nPos++;
    2726             :                 }
    2727           0 :                 const sal_uInt16 nType = rSh.GetFrmType(0,sal_True);
    2728           0 :                 if ( nType & FRMTYPE_HEADER )
    2729             :                 {
    2730           0 :                     rLst.push_back( SW_RESSTR( STR_SWBG_HEADER ) );
    2731           0 :                     nHeaderPos = nPos++;
    2732             :                 }
    2733           0 :                 if ( nType & FRMTYPE_FOOTER )
    2734             :                 {
    2735           0 :                     rLst.push_back( SW_RESSTR( STR_SWBG_FOOTER ) );
    2736           0 :                     nFooterPos = nPos;
    2737             :                 }
    2738             :             }
    2739           0 :             if ( rLst.empty() )
    2740           0 :                 rSet.DisableItem( nWhich );
    2741             :             else
    2742           0 :                 rSet.Put( aLst );
    2743           0 :             break;
    2744             :         }
    2745           0 :     }
    2746           0 : }
    2747             : 
    2748           0 : void SwBaseShell::ExecuteGallery(SfxRequest &rReq)
    2749             : {
    2750           0 :     SwWrtShell &rSh = GetShell();
    2751           0 :     rSh.StartAction();
    2752           0 :     const SfxItemSet* pArgs = rReq.GetArgs();
    2753           0 :     sal_uInt16 nSlot = rReq.GetSlot();
    2754           0 :     switch(nSlot)
    2755             :     {
    2756             :         case SID_GALLERY_BG_BRUSH:
    2757             :         {
    2758           0 :             int nSel = rSh.GetSelectionType();
    2759           0 :             if ( nSel & nsSelectionType::SEL_DRW_TXT )
    2760             :                 break;
    2761             : 
    2762           0 :             sal_uInt8 nPos = (sal_uInt8)((SfxUInt16Item &)pArgs->Get(SID_GALLERY_BG_POS)).GetValue();
    2763           0 :             ++nPos;
    2764             : 
    2765           0 :             SvxBrushItem aBrush( (SvxBrushItem&)pArgs->Get(SID_GALLERY_BG_BRUSH));
    2766           0 :             aBrush.SetWhich( RES_BACKGROUND );
    2767           0 :             if ( nPos == nParagraphPos )
    2768           0 :                 rSh.SetAttr( aBrush );
    2769           0 :             else if ( nPos == nTablePos )
    2770           0 :                 rSh.SetTabBackground( aBrush );
    2771           0 :             else if ( nPos == nTableRowPos )
    2772           0 :                 rSh.SetRowBackground( aBrush );
    2773           0 :             else if ( nPos == nTableCellPos )
    2774           0 :                 rSh.SetBoxBackground( aBrush );
    2775           0 :             else if ( nPos == nFramePos || nPos == nGraphicPos || nPos == nOlePos )
    2776             :             {
    2777           0 :                 SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
    2778           0 :                 aCoreSet.Put( aBrush );
    2779           0 :                 rSh.SetFlyFrmAttr( aCoreSet );
    2780             :             }
    2781           0 :             else if ( nPos == nPagePos || nPos == nHeaderPos || nPos == nFooterPos )
    2782             :             {
    2783           0 :                 sal_uInt16 nDesc = rSh.GetCurPageDesc();
    2784           0 :                 SwPageDesc aDesc( rSh.GetPageDesc( nDesc ) );
    2785           0 :                 if ( nPos == nPagePos )
    2786           0 :                     aDesc.GetMaster().SetFmtAttr( aBrush );
    2787           0 :                 else if ( nPos == nHeaderPos )
    2788             :                 {
    2789           0 :                     SwFmtHeader aHead( aDesc.GetMaster().GetHeader() );
    2790           0 :                     aHead.GetHeaderFmt()->SetFmtAttr( aBrush );
    2791           0 :                     aDesc.GetMaster().SetFmtAttr( aHead );
    2792             :                 }
    2793           0 :                 else if ( nPos == nFooterPos )
    2794             :                 {
    2795           0 :                     SwFmtFooter aFoot( aDesc.GetMaster().GetFooter() );
    2796           0 :                     aFoot.GetFooterFmt()->SetFmtAttr( aBrush );
    2797           0 :                     aDesc.GetMaster().SetFmtAttr( aFoot );
    2798             :                 }
    2799           0 :                 rSh.ChgPageDesc( nDesc, aDesc );
    2800             :             }
    2801           0 :             break;
    2802             :         }
    2803             :     }
    2804           0 :     rSh.EndAction();
    2805           0 :     rReq.Done();
    2806           0 : }
    2807             : 
    2808           0 : void SwBaseShell::ExecField( SfxRequest& rReq )
    2809             : {
    2810           0 :     sal_uInt16 nSlot = rReq.GetSlot();
    2811           0 :     switch( nSlot )
    2812             :     {
    2813             :         case FN_CHANGE_DBFIELD:
    2814             :         {
    2815           0 :             SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
    2816             :             OSL_ENSURE(pFact, "SwAbstractDialogFactory fail!");
    2817             : 
    2818           0 :             VclAbstractDialog* pDlg = pFact->CreateSwChangeDBDlg(GetView(), DLG_CHANGE_DB );
    2819             :             OSL_ENSURE(pDlg, "Dialogdiet fail!");
    2820           0 :             pDlg->Execute();
    2821           0 :             delete pDlg;
    2822             :         }
    2823           0 :         break;
    2824             :         default:
    2825             :             OSL_FAIL("wrong dispatcher");
    2826             :     }
    2827          30 : }
    2828             : 
    2829             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10